Split exception.cpp and new.cpp implementation into different files for different runtimes

[EricWF]

Summary

exception.cpp is a bloody mess. It's full of confusing #ifdef branches for each different ABI library we support, and it's getting unmaintainable.

This patch breaks down exception.cpp into multiple different header files, roughly one per implementation. Additionally it moves the definitions of exceptions in new.cpp into the correct implementation header..

[EricWF]

• Cleanup new.cpp as well.

• Implement typeinfo on MSVC.

[smeenai]

I really like the cleanup, but I'm not the biggest fan of taking more Microsoft dependencies than necessary. I don't see any way around operator new/operator delete (since replacement in COFF can only work with a static library with one function per object file, the way msvcrt.lib does it, and it doesn't seem to be worth the trouble to provide our own corresponding static library), but I think the rest are avoidable (though it's entirely possible I'm missing something, of course).

include/exception

85

What's the rationale for relying on Microsoft's exception implementation rather than libc++'s?

include/new

96

new.h will pull in new unless you define certain macros. Is that desirable?

139

Again, why defer these to Microsoft's STL? In particular, set_new_handler and get_new_handler seem to be part of msvcprt, which means we would take a runtime dependency on Microsoft's C++ library, which doesn't seem great.

These functions should map pretty well to _query_new_handler and _set_new_handler (apart from the different function pointer signature, which can be thunked around), right?

178

Might be helpful to have a comment explaining why we wanna defer these to msvcrt on Windows?

Also, VS 2015 doesn't seem to have the sized and aligned allocation and deallocation functions. I haven't checked 2017.

[EricWF]

include/exception

85

vcruntime_new.h brings in vcruntime_exception.h which defines all of the exception symbols as inline. We have no choice but to cede to them.

include/new

96

That's not how I read the new.h header. In MSVC 2015 new.h pulls in vcruntime_new.h but it also declares std::new_handler and std::set_new_handler. <new> actually avoid declaring certain things if new.h has already been included.

std::get_new_handler is the only function declared in <new> that is not declared in <new.h>, however using this function also requires linking to the MSVC C++ STL which we can't do. It's not a great situation to be in, but I don't see how to avoid it.

139

We have to assume these declarations/definitions have already been included via a user including new.h, so we can't redefine them. std::set_new_handler seem to actually be a part of the CRT startup files, so we can't avoid using it (AFAIK).

These functions should map pretty well to _query_new_handler and _set_new_handler

Those functions take/return entirely different function types. So IDK how to turn the function pointer returned from _query_new_handler into an entirely different function type and return it from get_new_handler, at least not in a meaningful way.

178

You're right that VS 2015 doesn't have aligned new/delete. However until we can correctly implement get_new_handler we won't be able to correctly implement the additional aligned new/delete overloads.

[EricWF]

include/new

178

I failed to mention that I do plan to re-enable the aligned allocation overloads in the future; But before I do that I need a definition of std::get_new_handler which IDK how to provide yet. I've emailed the MSVC team asking for advice about implementing this.

[EricWF]

• Allow standalone libc++ build on OS X to default to using libc++abi.

[smeenai]

include/exception

85

Hmm, perhaps we're looking at different versions of the vcruntime headers? My _VC_CRT_BUILD_VERSION is 24210 (in crtversion.h).

vcruntime_new.h doesn't pull in vcruntime_exception.h for me:

% type headers.cpp
#include <vcruntime_new.h>

% cl /nologo /c /showIncludes headers.cpp
headers.cpp
Note: including file: C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\INCLUDE\vcruntime_new.h
Note: including file:  C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\INCLUDE\vcruntime.h
Note: including file:   C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\INCLUDE\sal.h
Note: including file:    C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\INCLUDE\ConcurrencySal.h
Note: including file:   C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\INCLUDE\vadefs.h

Additionally, I'm not sure what we need vcruntime_new.h for. As far as I can see, it just provides the operator new/delete overload prototypes, which we can provide ourselves.

include/new

96

My new.h header (from the 10.0.14393.0 SDK, though 10.0.10586.0 has the same line) contains:

#if !defined _MSC_EXTENSIONS && !defined _CRTBLD && !defined _CORECRT_BUILD
    #include <new>
#endif

_MSC_EXTENSIONS should be getting defined by default, which is why we're saved from that include, but I'd be explicit about avoiding that include.

I think it would be ideal to define _CORECRT_BUILD so that we avoid any extraneous definitions from new.h and just get _query_new_handler and _set_new_handler (which we can then use to implement std::get_new_handler and std::set_new_handler). Alternatively, we could just forward declare those two functions ourselves, since I think that's all we care about from that header.

139

Hmm, it seems annoying to have to be resilient to users including <new.h>. I guess it's technically part of the UCRT and not the MSVCPRT, but considering it can pull in <new> or define some standard C++ functions, it doesn't seem unreasonable to ask users to not mix and match <new.h> with libc++ headers.

I can think of a bunch of fun non-portable ways to do it, but the only portable way that comes to mind is stowing away the parameter to std::set_new_handler and then returning that in std::get_new_handler. That's what Microsoft's STL appears to be doing as well.

[smeenai]

@EricWF and I discussed this on IRC a bunch yesterday.

We were inadvertently statically linking the Microsoft C++ libraries into tests, which is why std::set_new_handler was working with this patch. With that incorrect link removed, we get an undefined reference to std::set_new_handler, as expected. libc++ will have to implement std::get_new_handler and std:set_new_handler itself.

vcruntime_new.h is a gigantic pain, since it defines the operator new/delete overloads itself and is just generally annoying. We can avoid pulling it in ourselves, but user code might pull it in, and we probably want to be resilient to that? (I don't know how common the usage of that header is and if it's worth trying to be interoperable or just failing miserably in its presence.)

[compnerd]

While I love this direction (the original version really was an unintelligible pile of code), I really think that this change may be taking on too much. Why not split it up first and do nothing else. We could do the MS ABI implementation in a subsequent change. This would improve the code and would not be gated on the MS ABI changes.

[EricWF]

In D28785#650101, @compnerd wrote:

While I love this direction (the original version really was an unintelligible pile of code), I really think that this change may be taking on too much. Why not split it up first and do nothing else. We could do the MS ABI implementation in a subsequent change. This would improve the code and would not be gated on the MS ABI changes.

I agree this review is taking on too much, it started out much smaller and I tried to avoid expanding it, but in the end I had three options:

A) Regress and remove all support for MSVC, this would break the windows build. (at least in exception.cpp and new.cpp).
B) Implement incorrect versions of support/runtime/<header>_msvc.ipp based on w/e we currently have, just to keep Windows building.
C) Implement correct versions of support/runtime/<header>_msvc.ipp.

I choose (C) since I didn't want to regress Windows, or spend time implementing incorrect <header>_msvc.ipp versions.
However I'm willing to try and shrink this down if you think that would be better.

[EricWF]

In D28785#651156, @EricWF wrote:

In D28785#650101, @compnerd wrote:

While I love this direction (the original version really was an unintelligible pile of code), I really think that this change may be taking on too much. Why not split it up first and do nothing else. We could do the MS ABI implementation in a subsequent change. This would improve the code and would not be gated on the MS ABI changes.

I agree this review is taking on too much, it started out much smaller and I tried to avoid expanding it, but in the end I had three options:

A) Regress and remove all support for MSVC, this would break the windows build. (at least in exception.cpp and new.cpp).
B) Implement incorrect versions of support/runtime/<header>_msvc.ipp based on w/e we currently have, just to keep Windows building.
C) Implement correct versions of support/runtime/<header>_msvc.ipp.

I choose (C) since I didn't want to regress Windows, or spend time implementing incorrect <header>_msvc.ipp versions.
However I'm willing to try and shrink this down if you think that would be better.

That's dumb, and I'm dumb. I should be perfectly capable of breaking this down into smaller pieces

[EricWF]

Merge with upstream.

[EricWF]

Accepting before committing.

I wasn't able to split out the MSVC only changes in a fruitful way, so I'm going to commit this patch as-is.

[EricWF]

Committed in r294707.

[smeenai]

Still not a fan of the amount of vcruntime dependencies this is taking on, but I guess that can be followed up on.

Was the get_new_handler/set_new_handler issue resolved? (The issue being that those functions are in msvcprt, which our tests were silently linking against statically).

[EricWF]

In D28785#673227, @smeenai wrote:

Still not a fan of the amount of vcruntime dependencies this is taking on, but I guess that can be followed up on.

Neither am I. However this gets the debug build working, and fixes RTTI, which in turn gets a ton of tests passing.
Now we have regression tests for when we start removing vcruntime dependencies.

Was the get_new_handler/set_new_handler issue resolved? (The issue being that those functions are in msvcprt, which our tests were silently linking against statically).

Not yet. I'll address that in another patch, and then also enable the aligned new/delete overloads.

CMakeLists.txt

 if (LIBCXX_CXX_ABI STREQUAL "default")
   find_path(
     LIBCXX_LIBCXXABI_INCLUDES_INTERNAL
     cxxabi.h
     PATHS ${LLVM_MAIN_SRC_DIR}/projects/libcxxabi/include
           ${LLVM_MAIN_SRC_DIR}/runtimes/libcxxabi/include
     NO_DEFAULT_PATH
   )
+  find_path(
+    LIBCXX_LIBCXXABI_INCLUDES_EXTERNAL
+    cxxabi.h
+    PATHS /usr/include
+  )
   if ((NOT LIBCXX_STANDALONE_BUILD OR HAVE_LIBCXXABI) AND
       IS_DIRECTORY "${LIBCXX_LIBCXXABI_INCLUDES_INTERNAL}")
     set(LIBCXX_CXX_ABI_LIBNAME "libcxxabi")
     set(LIBCXX_CXX_ABI_INCLUDE_PATHS "${LIBCXX_LIBCXXABI_INCLUDES_INTERNAL}")
     set(LIBCXX_CXX_ABI_INTREE 1)
+  elseif(APPLE AND IS_DIRECTORY "${LIBCXX_LIBCXXABI_INCLUDES_INTERNAL}")
+    set(LIBCXX_CXX_ABI_LIBNAME "libcxxabi")
+    set(LIBCXX_CXX_ABI_INCLUDE_PATHS "${LIBCXX_LIBCXXABI_INCLUDES_INTERNAL}")
   else()
     if (LIBCXX_TARGETING_MSVC)
       # FIXME: Figure out how to configure the ABI library on Windows.
       set(LIBCXX_CXX_ABI_LIBNAME "vcruntime")
     else()
       set(LIBCXX_CXX_ABI_LIBNAME "default")
     endif()
   endif()

include/exception

 
 */
 
 #include <__config>
 #include <cstddef>
 #include <cstdlib>
 #include <type_traits>
 
+#if defined(_LIBCPP_ABI_MICROSOFT)
+#include <vcruntime_exception.h>
+#endif
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 namespace std  // purposefully not using versioning namespace
 {
 
+#if !defined(_LIBCPP_ABI_MICROSOFT)
 class _LIBCPP_EXCEPTION_ABI exception
 {
 public:
     _LIBCPP_INLINE_VISIBILITY exception() _NOEXCEPT {}
     virtual ~exception() _NOEXCEPT;
     virtual const char* what() const _NOEXCEPT;
 };
 
 class _LIBCPP_EXCEPTION_ABI bad_exception
     : public exception
 {
 public:
     _LIBCPP_INLINE_VISIBILITY bad_exception() _NOEXCEPT {}
     virtual ~bad_exception() _NOEXCEPT;
     virtual const char* what() const _NOEXCEPT;
 };
+#endif // !_LIBCPP_ABI_MICROSOFT
 
 typedef void (*unexpected_handler)();
 _LIBCPP_FUNC_VIS unexpected_handler set_unexpected(unexpected_handler) _NOEXCEPT;
 _LIBCPP_FUNC_VIS unexpected_handler get_unexpected() _NOEXCEPT;
 _LIBCPP_NORETURN _LIBCPP_FUNC_VIS void unexpected();
 
 typedef void (*terminate_handler)();
 _LIBCPP_FUNC_VIS terminate_handler set_terminate(terminate_handler) _NOEXCEPT;

include/new

 
 #include <__config>
 #include <exception>
 #include <cstddef>
 #ifdef _LIBCPP_NO_EXCEPTIONS
 #include <cstdlib>
 #endif
 
+#if defined(_LIBCPP_ABI_MICROSOFT)
+#include <new.h>
+#endif
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 #if !(defined(_LIBCPP_BUILDING_NEW) || _LIBCPP_STD_VER >= 14 || \
     (defined(__cpp_sized_deallocation) && __cpp_sized_deallocation >= 201309))
 # define _LIBCPP_HAS_NO_SIZED_DEALLOCATION
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_ALIGNED_ALLOCATION) && \
     (!(defined(_LIBCPP_BUILDING_NEW) || _LIBCPP_STD_VER > 14 || \
     (defined(__cpp_aligned_new) && __cpp_aligned_new >= 201606)))
 # define _LIBCPP_HAS_NO_ALIGNED_ALLOCATION
 #endif
 
 namespace std  // purposefully not using versioning namespace
 {
 
+#if !defined(_LIBCPP_ABI_MICROSOFT)
+struct _LIBCPP_TYPE_VIS nothrow_t {};
+extern _LIBCPP_FUNC_VIS const nothrow_t nothrow;
+
 class _LIBCPP_EXCEPTION_ABI bad_alloc
     : public exception
 {
 public:
     bad_alloc() _NOEXCEPT;
     virtual ~bad_alloc() _NOEXCEPT;
     virtual const char* what() const _NOEXCEPT;
 };
 
 class _LIBCPP_EXCEPTION_ABI bad_array_new_length
     : public bad_alloc
 {
 public:
     bad_array_new_length() _NOEXCEPT;
     virtual ~bad_array_new_length() _NOEXCEPT;
     virtual const char* what() const _NOEXCEPT;
 };
 
+typedef void (*new_handler)();
+_LIBCPP_FUNC_VIS new_handler set_new_handler(new_handler) _NOEXCEPT;
+_LIBCPP_FUNC_VIS new_handler get_new_handler() _NOEXCEPT;
+
+#endif // !_LIBCPP_ABI_MICROSOFT
+
 _LIBCPP_NORETURN _LIBCPP_FUNC_VIS void __throw_bad_alloc();  // not in C++ spec
 
 #if defined(_LIBCPP_BUILDING_NEW) || (_LIBCPP_STD_VER > 11)
 
 class _LIBCPP_EXCEPTION_ABI bad_array_length
     : public bad_alloc
 {
 public:

 #if !defined(_LIBCPP_HAS_NO_ALIGNED_ALLOCATION) || _LIBCPP_STD_VER > 14
 #ifndef _LIBCPP_CXX03_LANG
 enum class _LIBCPP_ENUM_VIS align_val_t : size_t { };
 #else
 enum align_val_t { __zero = 0, __max = (size_t)-1 };
 #endif
 #endif
 
-struct _LIBCPP_TYPE_VIS nothrow_t {};
-extern _LIBCPP_FUNC_VIS const nothrow_t nothrow;
-typedef void (*new_handler)();
-_LIBCPP_FUNC_VIS new_handler set_new_handler(new_handler) _NOEXCEPT;
-_LIBCPP_FUNC_VIS new_handler get_new_handler() _NOEXCEPT;
-
 }  // std
 
 #if defined(_LIBCPP_CXX03_LANG)
 #define _THROW_BAD_ALLOC throw(std::bad_alloc)
 #else
 #define _THROW_BAD_ALLOC
 #endif
 
+#if !defined(_LIBCPP_ABI_MICROSOFT)
+
 _LIBCPP_OVERRIDABLE_FUNC_VIS void* operator new(std::size_t __sz) _THROW_BAD_ALLOC;
 _LIBCPP_OVERRIDABLE_FUNC_VIS void* operator new(std::size_t __sz, const std::nothrow_t&) _NOEXCEPT _NOALIAS;
 _LIBCPP_OVERRIDABLE_FUNC_VIS void  operator delete(void* __p) _NOEXCEPT;
 _LIBCPP_OVERRIDABLE_FUNC_VIS void  operator delete(void* __p, const std::nothrow_t&) _NOEXCEPT;
 #ifndef _LIBCPP_HAS_NO_SIZED_DEALLOCATION
 _LIBCPP_OVERRIDABLE_FUNC_VIS void  operator delete(void* __p, std::size_t __sz) _NOEXCEPT;
 #endif
 

 #endif
 #endif
 
 inline _LIBCPP_INLINE_VISIBILITY void* operator new  (std::size_t, void* __p) _NOEXCEPT {return __p;}
 inline _LIBCPP_INLINE_VISIBILITY void* operator new[](std::size_t, void* __p) _NOEXCEPT {return __p;}
 inline _LIBCPP_INLINE_VISIBILITY void  operator delete  (void*, void*) _NOEXCEPT {}
 inline _LIBCPP_INLINE_VISIBILITY void  operator delete[](void*, void*) _NOEXCEPT {}
 
+#endif // !_LIBCPP_ABI_MICROSOFT
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 inline _LIBCPP_INLINE_VISIBILITY void *__allocate(size_t __size) {
 #ifdef _LIBCPP_HAS_NO_BUILTIN_OPERATOR_NEW_DELETE
   return ::operator new(__size);
 #else
   return __builtin_operator_new(__size);
 #endif

include/typeinfo

 #ifdef _LIBCPP_NO_EXCEPTIONS
 #include <cstdlib>
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
-#if defined(_LIBCPP_NONUNIQUE_RTTI_BIT)
+#if defined(_LIBCPP_ABI_MICROSOFT)
+#include <vcruntime_typeinfo.h>
+#elif defined(_LIBCPP_NONUNIQUE_RTTI_BIT)
 #define _LIBCPP_HAS_NONUNIQUE_TYPEINFO
 #else
 #define _LIBCPP_HAS_UNIQUE_TYPEINFO
 #endif
 
 namespace std  // purposefully not using versioning namespace
 {
 
+#if !defined(_LIBCPP_ABI_MICROSOFT)
 class _LIBCPP_EXCEPTION_ABI type_info
 {
     type_info& operator=(const type_info&);
     type_info(const type_info&);
 
 #if defined(_LIBCPP_HAS_NONUNIQUE_TYPEINFO)
     _LIBCPP_INLINE_VISIBILITY
     int __compare_nonunique_names(const type_info &__arg) const _NOEXCEPT
class _LIBCPP_EXCEPTION_ABI bad_typeid
     : public exception
 {
 public:
     bad_typeid() _NOEXCEPT;
     virtual ~bad_typeid() _NOEXCEPT;
     virtual const char* what() const _NOEXCEPT;
 };
 
+#endif // !_LIBCPP_ABI_MICROSOFT
+
 }  // std
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 _LIBCPP_NORETURN inline _LIBCPP_ALWAYS_INLINE
 void __throw_bad_cast()
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     throw bad_cast();
 #else
   _VSTD::abort();
 #endif
 }
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // __LIBCPP_TYPEINFO

src/exception.cpp

 //===------------------------ exception.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.
 //
 //===----------------------------------------------------------------------===//
-#include <stdlib.h>
-#include <stdio.h>
 
 #include "exception"
 #include "new"
 
-#if defined(_LIBCPP_ABI_MICROSOFT)
-#include <eh.h>
-#include <corecrt_terminate.h>
-#elif defined(__APPLE__) && !defined(LIBCXXRT) && \
-    !defined(_LIBCPP_BUILDING_HAS_NO_ABI_LIBRARY)
-  #include <cxxabi.h>
-
-  using namespace __cxxabiv1;
-  #define HAVE_DEPENDENT_EH_ABI 1
-  #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(LIBCXXRT) || defined(LIBCXX_BUILDING_LIBCXXABI)
+#if defined(LIBCXXRT) || defined(LIBCXX_BUILDING_LIBCXXABI) || \
+  (defined(__APPLE__) && !defined(_LIBCPP_BUILDING_HAS_NO_ABI_LIBRARY))
   #include <cxxabi.h>
   using namespace __cxxabiv1;
-  #if defined(LIBCXXRT) || defined(_LIBCPPABI_VERSION)
-    #define HAVE_DEPENDENT_EH_ABI 1
-  #endif
-#elif !defined(__GLIBCXX__) // defined(LIBCXX_BUILDING_LIBCXXABI)
-  _LIBCPP_SAFE_STATIC static std::terminate_handler  __terminate_handler;
-  _LIBCPP_SAFE_STATIC static std::unexpected_handler __unexpected_handler;
-#endif // defined(LIBCXX_BUILDING_LIBCXXABI)
-
-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
-{
-#if defined(_LIBCPP_ABI_MICROSOFT)
-  return ::set_unexpected(func);
-#else
-  return __sync_lock_test_and_set(&__unexpected_handler, func);
-#endif
-}
 
-unexpected_handler
-get_unexpected() _NOEXCEPT
-{
 #if defined(_LIBCPP_ABI_MICROSOFT)
-  return ::_get_unexpected();
-#else
-  return __sync_fetch_and_add(&__unexpected_handler, (unexpected_handler)0);
-#endif
-}
-
-_LIBCPP_NORETURN
-void
-unexpected()
-{
-    (*get_unexpected())();
-    // unexpected handler should not return
-    terminate();
-}
-
-terminate_handler
-set_terminate(terminate_handler func) _NOEXCEPT
-{
-#if defined(_LIBCPP_ABI_MICROSOFT)
-  return ::set_terminate(func);
-#else
-  return __sync_lock_test_and_set(&__terminate_handler, func);
-#endif
-}
-
-terminate_handler
-get_terminate() _NOEXCEPT
-{
-#if defined(_LIBCPP_ABI_MICROSOFT)
-  return ::_get_terminate();
-#else
-  return __sync_fetch_and_add(&__terminate_handler, (terminate_handler)0);
-#endif
-}
-
-#ifndef __EMSCRIPTEN__ // We provide this in JS
-_LIBCPP_NORETURN
-void
-terminate() _NOEXCEPT
-{
-#ifndef _LIBCPP_NO_EXCEPTIONS
-    try
-    {
-#endif  // _LIBCPP_NO_EXCEPTIONS
-        (*get_terminate())();
-        // handler should not return
-        fprintf(stderr, "terminate_handler unexpectedly returned\n");
-        ::abort();
-#ifndef _LIBCPP_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-        // handler should not throw exception
-        fprintf(stderr, "terminate_handler unexpectedly threw an exception\n");
-        ::abort();
-    }
-#endif  // _LIBCPP_NO_EXCEPTIONS
-}
-#endif // !__EMSCRIPTEN__
-#endif // !defined(LIBCXXRT) && !defined(_LIBCPPABI_VERSION)
-
-#if !defined(LIBCXXRT) && !defined(__GLIBCXX__) && !defined(__EMSCRIPTEN__)
-
-bool uncaught_exception() _NOEXCEPT { return uncaught_exceptions() > 0; }
-
-int uncaught_exceptions() _NOEXCEPT
-{
-#if !defined(_LIBCPP_BUILDING_HAS_NO_ABI_LIBRARY) && \
-    (defined(__APPLE__) || defined(_LIBCPPABI_VERSION))
-   // on Darwin, there is a helper function so __cxa_get_globals is private
-# if _LIBCPPABI_VERSION > 1101
-    return __cxa_uncaught_exceptions();
-# else
-    return __cxa_uncaught_exception() ? 1 : 0;
-# endif
-#elif defined(_LIBCPP_ABI_MICROSOFT)
-    return __uncaught_exceptions();
-#else
-#   if defined(_LIBCPP_MSVC)
-        _LIBCPP_WARNING("uncaught_exceptions not yet implemented")
-#   else
-#       warning uncaught_exception not yet implemented
-#   endif
-    fprintf(stderr, "uncaught_exceptions 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
-#if !defined(_LIBCPPABI_VERSION) && !defined(__GLIBCXX__)
-
-bad_exception::~bad_exception() _NOEXCEPT
-{
-}
-
-const char* bad_exception::what() const _NOEXCEPT
-{
-  return "std::bad_exception";
-}
-
-#endif
-
-#if defined(__GLIBCXX__)
-
-// libsupc++ does not implement the dependent EH ABI and the functionality
-// it uses to implement std::exception_ptr (which it declares as an alias of
-// std::__exception_ptr::exception_ptr) is not directly exported to clients. So
-// we have little choice but to hijack std::__exception_ptr::exception_ptr's
-// (which fortunately has the same layout as our std::exception_ptr) copy
-// constructor, assignment operator and destructor (which are part of its
-// stable ABI), and its rethrow_exception(std::__exception_ptr::exception_ptr)
-// function.
-
-namespace __exception_ptr
-{
-
-struct exception_ptr
-{
-    void* __ptr_;
-
-    exception_ptr(const exception_ptr&) _NOEXCEPT;
-    exception_ptr& operator=(const exception_ptr&) _NOEXCEPT;
-    ~exception_ptr() _NOEXCEPT;
-};
-
-}
-
-_LIBCPP_NORETURN void rethrow_exception(__exception_ptr::exception_ptr);
-
-#endif
-
-exception_ptr::~exception_ptr() _NOEXCEPT
-{
-#if HAVE_DEPENDENT_EH_ABI
-    __cxa_decrement_exception_refcount(__ptr_);
+#include "support/runtime/exception_msvc.ipp"
+#include "support/runtime/exception_pointer_unimplemented.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__)
-    reinterpret_cast<__exception_ptr::exception_ptr*>(this)->~exception_ptr();
-#else
-#   if defined(_LIBCPP_MSVC)
-        _LIBCPP_WARNING("exception_ptr not yet implemented")
-#   else
-#       warning exception_ptr not yet implemented
-#   endif
-    fprintf(stderr, "exception_ptr not yet implemented\n");
-    ::abort();
-#endif
-}
-
-exception_ptr::exception_ptr(const exception_ptr& other) _NOEXCEPT
-    : __ptr_(other.__ptr_)
-{
-#if HAVE_DEPENDENT_EH_ABI
-    __cxa_increment_exception_refcount(__ptr_);
-#elif defined(__GLIBCXX__)
-    new (reinterpret_cast<void*>(this)) __exception_ptr::exception_ptr(
-        reinterpret_cast<const __exception_ptr::exception_ptr&>(other));
-#else
-#   if defined(_LIBCPP_MSVC)
-        _LIBCPP_WARNING("exception_ptr not yet implemented")
-#   else
-#       warning exception_ptr not yet implemented
-#   endif
-    fprintf(stderr, "exception_ptr not yet implemented\n");
-    ::abort();
-#endif
-}
-
-exception_ptr& exception_ptr::operator=(const exception_ptr& other) _NOEXCEPT
-{
-#if HAVE_DEPENDENT_EH_ABI
-    if (__ptr_ != other.__ptr_)
-    {
-        __cxa_increment_exception_refcount(other.__ptr_);
-        __cxa_decrement_exception_refcount(__ptr_);
-        __ptr_ = other.__ptr_;
-    }
-    return *this;
-#elif defined(__GLIBCXX__)
-    *reinterpret_cast<__exception_ptr::exception_ptr*>(this) =
-        reinterpret_cast<const __exception_ptr::exception_ptr&>(other);
-    return *this;
-#else
-#   if defined(_LIBCPP_MSVC)
-        _LIBCPP_WARNING("exception_ptr not yet implemented")
-#   else
-#       warning exception_ptr not yet implemented
-#   endif
-    fprintf(stderr, "exception_ptr not yet implemented\n");
-    ::abort();
-#endif
-}
-
-nested_exception::nested_exception() _NOEXCEPT
-    : __ptr_(current_exception())
-{
-}
-
-#if !defined(__GLIBCXX__)
-
-nested_exception::~nested_exception() _NOEXCEPT
-{
-}
-
-#endif
-
-_LIBCPP_NORETURN
-void
-nested_exception::rethrow_nested() const
-{
-    if (__ptr_ == nullptr)
-        terminate();
-    rethrow_exception(__ptr_);
-}
-
-#if !defined(__GLIBCXX__)
-
-exception_ptr current_exception() _NOEXCEPT
-{
-#if HAVE_DEPENDENT_EH_ABI
-    // be nicer if there was a constructor that took a ptr, then
-    // this whole function would be just:
-    //    return exception_ptr(__cxa_current_primary_exception());
-    exception_ptr ptr;
-    ptr.__ptr_ = __cxa_current_primary_exception();
-    return ptr;
-#else
-#   if defined(_LIBCPP_MSVC)
-        _LIBCPP_WARNING( "exception_ptr not yet implemented" )
-#   else
-#       warning exception_ptr not yet implemented
-#   endif
-    fprintf(stderr, "exception_ptr not yet implemented\n");
-    ::abort();
-#endif
-}
-
-#endif  // !__GLIBCXX__
-
-_LIBCPP_NORETURN
-void rethrow_exception(exception_ptr p)
-{
-#if HAVE_DEPENDENT_EH_ABI
-    __cxa_rethrow_primary_exception(p.__ptr_);
-    // if p.__ptr_ is NULL, above returns so we terminate
-    terminate();
-#elif defined(__GLIBCXX__)
-    rethrow_exception(reinterpret_cast<__exception_ptr::exception_ptr&>(p));
-#else
-#   if defined(_LIBCPP_MSVC)
-        _LIBCPP_WARNING("exception_ptr not yet implemented")
-#   else
-#       warning exception_ptr not yet implemented
-#   endif
-    fprintf(stderr, "exception_ptr not yet implemented\n");
-    ::abort();
+#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
-}
-} // std

src/new.cpp

 //===--------------------------- new.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.
 //
 //===----------------------------------------------------------------------===//
 
 #define _LIBCPP_BUILDING_NEW
 
 #include <stdlib.h>
 
 #include "new"
 
-#if defined(__APPLE__) && !defined(LIBCXXRT) && \
-    !defined(_LIBCPP_BUILDING_HAS_NO_ABI_LIBRARY)
-    #include <cxxabi.h>
-
-    #ifndef _LIBCPPABI_VERSION
-        // On Darwin, there are two STL shared libraries and a lower level ABI
-        // shared library.  The global holding the current new handler is
-        // in the ABI library and named __cxa_new_handler.
-        #define __new_handler __cxxabiapple::__cxa_new_handler
-    #endif
-#else  // __APPLE__
-    #if defined(LIBCXXRT) || defined(LIBCXX_BUILDING_LIBCXXABI)
-        #include <cxxabi.h>
-    #endif  // defined(LIBCXX_BUILDING_LIBCXXABI)
-    #if defined(_LIBCPP_BUILDING_HAS_NO_ABI_LIBRARY) || \
-        (!defined(_LIBCPPABI_VERSION) && !defined(__GLIBCXX__))
-        static std::new_handler __new_handler;
-    #endif  // _LIBCPPABI_VERSION
+#if defined(_LIBCPP_ABI_MICROSOFT)
+// nothing todo
+#elif defined(LIBCXX_BUILDING_LIBCXXABI)
+#elif defined(LIBCXXRT)
+#include "new_handler_fallback.ipp"
+#elif defined(__GLIBCXX__)
+// nothing todo
+#elif defined(_LIBCPP_BUILDING_NO_ABI_LIBRARY)
+// nothing todo
+#else
+#error UNSUPPORTED configuration
 #endif
 
+namespace std
+{
+
 #ifndef __GLIBCXX__
+const nothrow_t nothrow = {};
+#endif
+
+#ifndef LIBSTDCXX
+
+void
+__throw_bad_alloc()
+{
+#ifndef _LIBCPP_NO_EXCEPTIONS
+    throw bad_alloc();
+#else
+    _VSTD::abort();
+#endif
+}
+
+#endif // !LIBSTDCXX
+
+}  // std
+
+#if !defined(__GLIBCXX__) && !defined(_LIBCPP_ABI_MICROSOFT)
 
 // Implement all new and delete operators as weak definitions
 // in this shared library, so that they can be overridden by programs
 // that define non-weak copies of the functions.
 
 _LIBCPP_WEAK
 void *
 operator new(std::size_t size) _THROW_BAD_ALLOC

 
 _LIBCPP_WEAK
 void
 operator delete[] (void* ptr, size_t, std::align_val_t alignment) _NOEXCEPT
 {
     ::operator delete[](ptr, alignment);
 }
 
-#endif // !defined(_LIBCPP_HAS_NO_ALIGNED_ALLOCATION)
-
-#endif // !__GLIBCXX__
-
-namespace std
-{
-
-#ifndef __GLIBCXX__
-const nothrow_t nothrow = {};
-#endif
-
-#ifndef _LIBCPPABI_VERSION
-
-#ifndef __GLIBCXX__
-
-new_handler
-set_new_handler(new_handler handler) _NOEXCEPT
-{
-    return __sync_lock_test_and_set(&__new_handler, handler);
-}
-
-new_handler
-get_new_handler() _NOEXCEPT
-{
-    return __sync_fetch_and_add(&__new_handler, nullptr);
-}
-
-#endif // !__GLIBCXX__
-
-#ifndef LIBCXXRT
-
-bad_alloc::bad_alloc() _NOEXCEPT
-{
-}
-
-#ifndef __GLIBCXX__
-
-bad_alloc::~bad_alloc() _NOEXCEPT
-{
-}
-
-const char*
-bad_alloc::what() const _NOEXCEPT
-{
-    return "std::bad_alloc";
-}
-
-#endif // !__GLIBCXX__
-
-bad_array_new_length::bad_array_new_length() _NOEXCEPT
-{
-}
-
-#ifndef __GLIBCXX__
-
-bad_array_new_length::~bad_array_new_length() _NOEXCEPT
-{
-}
-
-const char*
-bad_array_new_length::what() const _NOEXCEPT
-{
-    return "bad_array_new_length";
-}
-
-#endif // !__GLIBCXX__
-
-#endif //LIBCXXRT
-
-bad_array_length::bad_array_length() _NOEXCEPT
-{
-}
-
-#ifndef __GLIBCXX__
-
-bad_array_length::~bad_array_length() _NOEXCEPT
-{
-}
-
-const char*
-bad_array_length::what() const _NOEXCEPT
-{
-    return "bad_array_length";
-}
-
-#endif // !__GLIBCXX__
-
-#endif // _LIBCPPABI_VERSION
-
-#ifndef LIBSTDCXX
-
-void
-__throw_bad_alloc()
-{
-#ifndef _LIBCPP_NO_EXCEPTIONS
-    throw bad_alloc();
-#else
-    _VSTD::abort();
-#endif
-}
-
-#endif // !LIBSTDCXX
-
-}  // std
+#endif // !_LIBCPP_HAS_NO_ALIGNED_ALLOCATION
+#endif // !__GLIBCXX__ && !_LIBCPP_ABI_MICROSOFT

src/support/runtime/exception_fallback.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.
+//
+//===----------------------------------------------------------------------===//
+
+namespace std {
+
+_LIBCPP_SAFE_STATIC static std::terminate_handler  __terminate_handler;
+_LIBCPP_SAFE_STATIC static std::unexpected_handler __unexpected_handler;
+
+
+// libcxxrt provides implementations of these functions itself.
+unexpected_handler
+set_unexpected(unexpected_handler func) _NOEXCEPT
+{
+  return __sync_lock_test_and_set(&__unexpected_handler, func);
+}
+
+unexpected_handler
+get_unexpected() _NOEXCEPT
+{
+  return __sync_fetch_and_add(&__unexpected_handler, (unexpected_handler)0);
+
+}
+
+_LIBCPP_NORETURN
+void unexpected()
+{
+    (*get_unexpected())();
+    // unexpected handler should not return
+    terminate();
+}
+
+terminate_handler
+set_terminate(terminate_handler func) _NOEXCEPT
+{
+  return __sync_lock_test_and_set(&__terminate_handler, func);
+}
+
+terminate_handler
+get_terminate() _NOEXCEPT
+{
+  return __sync_fetch_and_add(&__terminate_handler, (terminate_handler)0);
+
+}
+
+#ifndef __EMSCRIPTEN__ // We provide this in JS
+_LIBCPP_NORETURN
+void
+terminate() _NOEXCEPT
+{
+#ifndef _LIBCPP_NO_EXCEPTIONS
+    try
+    {
+#endif  // _LIBCPP_NO_EXCEPTIONS
+        (*get_terminate())();
+        // handler should not return
+        fprintf(stderr, "terminate_handler unexpectedly returned\n");
+        ::abort();
+#ifndef _LIBCPP_NO_EXCEPTIONS
+    }
+    catch (...)
+    {
+        // handler should not throw exception
+        fprintf(stderr, "terminate_handler unexpectedly threw an exception\n");
+        ::abort();
+    }
+#endif  // _LIBCPP_NO_EXCEPTIONS
+}
+#endif // !__EMSCRIPTEN__
+
+#if !defined(__EMSCRIPTEN__)
+bool uncaught_exception() _NOEXCEPT { return uncaught_exceptions() > 0; }
+
+int uncaught_exceptions() _NOEXCEPT
+{
+#warning uncaught_exception not yet implemented
+  fprintf(stderr, "uncaught_exceptions not yet implemented\n");
+  ::abort();
+}
+#endif // !__EMSCRIPTEN__
+
+
+exception::~exception() _NOEXCEPT
+{
+}
+
+const char* exception::what() const _NOEXCEPT
+{
+  return "std::exception";
+}
+
+bad_exception::~bad_exception() _NOEXCEPT
+{
+}
+
+const char* bad_exception::what() const _NOEXCEPT
+{
+  return "std::bad_exception";
+}
+
+
+bad_alloc::bad_alloc() _NOEXCEPT
+{
+}
+
+bad_alloc::~bad_alloc() _NOEXCEPT
+{
+}
+
+const char*
+bad_alloc::what() const _NOEXCEPT
+{
+    return "std::bad_alloc";
+}
+
+bad_array_new_length::bad_array_new_length() _NOEXCEPT
+{
+}
+
+bad_array_new_length::~bad_array_new_length() _NOEXCEPT
+{
+}
+
+const char*
+bad_array_new_length::what() const _NOEXCEPT
+{
+    return "bad_array_new_length";
+}
+
+
+bad_array_length::bad_array_length() _NOEXCEPT
+{
+}
+
+bad_array_length::~bad_array_length() _NOEXCEPT
+{
+}
+
+const char*
+bad_array_length::what() const _NOEXCEPT
+{
+    return "bad_array_length";
+}
+
+
+bad_cast::bad_cast() _NOEXCEPT
+{
+}
+
+bad_typeid::bad_typeid() _NOEXCEPT
+{
+}
+
+#ifndef __GLIBCXX__
+
+bad_cast::~bad_cast() _NOEXCEPT
+{
+}
+
+const char*
+bad_cast::what() const _NOEXCEPT
+{
+  return "std::bad_cast";
+}
+
+bad_typeid::~bad_typeid() _NOEXCEPT
+{
+}
+
+const char*
+bad_typeid::what() const _NOEXCEPT
+{
+  return "std::bad_typeid";
+}
+
+} // namespace std

src/support/runtime/exception_glibcxx.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.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef __GLIBCXX__
+#error header can only be used when targeting libstdc++ or libsupc++
+#endif
+
+namespace std {
+
+bad_alloc::bad_alloc() _NOEXCEPT
+{
+}
+
+bad_array_new_length::bad_array_new_length() _NOEXCEPT
+{
+}
+
+bad_array_length::bad_array_length() _NOEXCEPT
+{
+}
+
+
+bad_cast::bad_cast() _NOEXCEPT
+{
+}
+
+bad_typeid::bad_typeid() _NOEXCEPT
+{
+}
+
+} // namespace

src/support/runtime/exception_libcxxabi.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.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPPABI_VERSION
+#error this header can only be used with libc++abi
+#endif
+
+namespace std {
+
+bool uncaught_exception() _NOEXCEPT { return uncaught_exceptions() > 0; }
+
+int uncaught_exceptions() _NOEXCEPT
+{
+# if _LIBCPPABI_VERSION > 1101
+    return __cxa_uncaught_exceptions();
+# else
+    return __cxa_uncaught_exception() ? 1 : 0;
+# endif
+}
+
+} // namespace std

src/support/runtime/exception_libcxxrt.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.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LIBCXXRT
+#error this header may only be used when targeting libcxxrt
+#endif
+
+namespace std {
+
+bad_exception::~bad_exception() _NOEXCEPT
+{
+}
+
+const char* bad_exception::what() const _NOEXCEPT
+{
+  return "std::bad_exception";
+}
+
+
+bad_array_length::bad_array_length() _NOEXCEPT
+{
+}
+
+bad_array_length::~bad_array_length() _NOEXCEPT
+{
+}
+
+const char*
+bad_array_length::what() const _NOEXCEPT
+{
+    return "bad_array_length";
+}
+
+} // namespace std

src/support/runtime/exception_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.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_ABI_MICROSOFT
+#error this header can only be used when targeting the MSVC ABI
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <eh.h>
+#include <corecrt_terminate.h>
+
+namespace std {
+
+// libcxxrt provides implementations of these functions itself.
+unexpected_handler
+set_unexpected(unexpected_handler func) _NOEXCEPT {
+  return ::set_unexpected(func);
+}
+
+unexpected_handler get_unexpected() _NOEXCEPT {
+  return ::_get_unexpected();
+}
+
+_LIBCPP_NORETURN
+void unexpected() {
+    (*get_unexpected())();
+    // unexpected handler should not return
+    terminate();
+}
+
+terminate_handler set_terminate(terminate_handler func) _NOEXCEPT {
+  return ::set_terminate(func);
+}
+
+terminate_handler get_terminate() _NOEXCEPT {
+  return ::_get_terminate();
+}
+
+_LIBCPP_NORETURN
+void terminate() _NOEXCEPT
+{
+#ifndef _LIBCPP_NO_EXCEPTIONS
+    try
+    {
+#endif  // _LIBCPP_NO_EXCEPTIONS
+        (*get_terminate())();
+        // handler should not return
+        fprintf(stderr, "terminate_handler unexpectedly returned\n");
+        ::abort();
+#ifndef _LIBCPP_NO_EXCEPTIONS
+    }
+    catch (...)
+    {
+        // handler should not throw exception
+        fprintf(stderr, "terminate_handler unexpectedly threw an exception\n");
+        ::abort();
+    }
+#endif  // _LIBCPP_NO_EXCEPTIONS
+}
+
+bool uncaught_exception() _NOEXCEPT { return uncaught_exceptions() > 0; }
+
+int uncaught_exceptions() _NOEXCEPT {
+    return __uncaught_exceptions();
+}
+
+bad_array_length::bad_array_length() _NOEXCEPT
+{
+}
+
+bad_array_length::~bad_array_length() _NOEXCEPT
+{
+}
+
+const char*
+bad_array_length::what() const _NOEXCEPT
+{
+    return "bad_array_length";
+}
+
+} // namespace std

src/support/runtime/exception_pointer_cxxabi.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.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef HAVE_DEPENDENT_EH_ABI
+#error this header may only be used with libc++abi or libcxxrt
+#endif
+
+namespace std {
+
+exception_ptr::~exception_ptr() _NOEXCEPT {
+  __cxa_decrement_exception_refcount(__ptr_);
+}
+
+exception_ptr::exception_ptr(const exception_ptr& other) _NOEXCEPT
+    : __ptr_(other.__ptr_)
+{
+    __cxa_increment_exception_refcount(__ptr_);
+}
+
+exception_ptr& exception_ptr::operator=(const exception_ptr& other) _NOEXCEPT
+{
+    if (__ptr_ != other.__ptr_)
+    {
+        __cxa_increment_exception_refcount(other.__ptr_);
+        __cxa_decrement_exception_refcount(__ptr_);
+        __ptr_ = other.__ptr_;
+    }
+    return *this;
+}
+
+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_);
+}
+
+exception_ptr current_exception() _NOEXCEPT
+{
+    // be nicer if there was a constructor that took a ptr, then
+    // this whole function would be just:
+    //    return exception_ptr(__cxa_current_primary_exception());
+    exception_ptr ptr;
+    ptr.__ptr_ = __cxa_current_primary_exception();
+    return ptr;
+}
+
+_LIBCPP_NORETURN
+void rethrow_exception(exception_ptr p)
+{
+    __cxa_rethrow_primary_exception(p.__ptr_);
+    // if p.__ptr_ is NULL, above returns so we terminate
+    terminate();
+}
+
+} // namespace std

src/support/runtime/exception_pointer_glibcxx.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.
+//
+//===----------------------------------------------------------------------===//
+
+// libsupc++ does not implement the dependent EH ABI and the functionality
+// it uses to implement std::exception_ptr (which it declares as an alias of
+// std::__exception_ptr::exception_ptr) is not directly exported to clients. So
+// we have little choice but to hijack std::__exception_ptr::exception_ptr's
+// (which fortunately has the same layout as our std::exception_ptr) copy
+// constructor, assignment operator and destructor (which are part of its
+// stable ABI), and its rethrow_exception(std::__exception_ptr::exception_ptr)
+// function.
+
+namespace __exception_ptr
+{
+
+struct exception_ptr
+{
+    void* __ptr_;
+
+    exception_ptr(const exception_ptr&) _NOEXCEPT;
+    exception_ptr& operator=(const exception_ptr&) _NOEXCEPT;
+    ~exception_ptr() _NOEXCEPT;
+};
+
+}
+
+_LIBCPP_NORETURN void rethrow_exception(__exception_ptr::exception_ptr);
+
+exception_ptr::~exception_ptr() _NOEXCEPT
+{
+    reinterpret_cast<__exception_ptr::exception_ptr*>(this)->~exception_ptr();
+}
+
+exception_ptr::exception_ptr(const exception_ptr& other) _NOEXCEPT
+    : __ptr_(other.__ptr_)
+{
+    new (reinterpret_cast<void*>(this)) __exception_ptr::exception_ptr(
+        reinterpret_cast<const __exception_ptr::exception_ptr&>(other));
+}
+
+exception_ptr& exception_ptr::operator=(const exception_ptr& other) _NOEXCEPT
+{
+    *reinterpret_cast<__exception_ptr::exception_ptr*>(this) =
+        reinterpret_cast<const __exception_ptr::exception_ptr&>(other);
+    return *this;
+}
+
+nested_exception::nested_exception() _NOEXCEPT
+    : __ptr_(current_exception())
+{
+}
+
+
+_LIBCPP_NORETURN
+void
+nested_exception::rethrow_nested() const
+{
+    if (__ptr_ == nullptr)
+        terminate();
+    rethrow_exception(__ptr_);
+}
+
+_LIBCPP_NORETURN
+void rethrow_exception(exception_ptr p)
+{
+    rethrow_exception(reinterpret_cast<__exception_ptr::exception_ptr&>(p));
+}

src/support/runtime/exception_pointer_unimplemented.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>
+
+namespace std {
+
+exception_ptr::~exception_ptr() _NOEXCEPT
+{
+#  warning exception_ptr not yet implemented
+  fprintf(stderr, "exception_ptr not yet implemented\n");
+  ::abort();
+}
+
+exception_ptr::exception_ptr(const exception_ptr& other) _NOEXCEPT
+    : __ptr_(other.__ptr_)
+{
+#  warning exception_ptr not yet implemented
+  fprintf(stderr, "exception_ptr not yet implemented\n");
+  ::abort();
+}
+
+exception_ptr& exception_ptr::operator=(const exception_ptr& other) _NOEXCEPT
+{
+#  warning exception_ptr not yet implemented
+  fprintf(stderr, "exception_ptr not yet implemented\n");
+  ::abort();
+}
+
+nested_exception::nested_exception() _NOEXCEPT
+    : __ptr_(current_exception())
+{
+}
+
+#if !defined(__GLIBCXX__)
+
+nested_exception::~nested_exception() _NOEXCEPT
+{
+}
+
+#endif
+
+_LIBCPP_NORETURN
+void
+nested_exception::rethrow_nested() const
+{
+#  warning exception_ptr not yet implemented
+  fprintf(stderr, "exception_ptr not yet implemented\n");
+  ::abort();
+#if 0
+  if (__ptr_ == nullptr)
+      terminate();
+  rethrow_exception(__ptr_);
+#endif // FIXME
+}
+
+exception_ptr current_exception() _NOEXCEPT
+{
+#  warning exception_ptr not yet implemented
+  fprintf(stderr, "exception_ptr not yet implemented\n");
+  ::abort();
+}
+
+_LIBCPP_NORETURN
+void rethrow_exception(exception_ptr p)
+{
+#  warning exception_ptr not yet implemented
+  fprintf(stderr, "exception_ptr not yet implemented\n");
+  ::abort();
+}
+
+} // namespace std

src/support/runtime/new_handler_fallback.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.
+//
+//===----------------------------------------------------------------------===//
+
+namespace std {
+
+_LIBCPP_SAFE_STATIC static std::new_handler __new_handler;
+
+new_handler
+set_new_handler(new_handler handler) _NOEXCEPT
+{
+    return __sync_lock_test_and_set(&__new_handler, handler);
+}
+
+new_handler
+get_new_handler() _NOEXCEPT
+{
+    return __sync_fetch_and_add(&__new_handler, nullptr);
+}
+
+} // namespace std

src/typeinfo.cpp

 //===------------------------- typeinfo.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.
 //
 //===----------------------------------------------------------------------===//
-#include <stdlib.h>
-
-#if !defined(_LIBCPP_BUILDING_HAS_NO_ABI_LIBRARY) && \
-    (defined(__APPLE__) || defined(LIBCXXRT) || defined(LIBCXX_BUILDING_LIBCXXABI))
-#include <cxxabi.h>
-#endif
 
 #include "typeinfo"
 
-#if defined(_LIBCPP_BUILDING_HAS_NO_ABI_LIBRARY) || \
-    defined(_LIBCPP_ABI_MICROSOFT) // FIXME: This is a temporary workaround
+#if defined(_LIBCPP_BUILDING_HAS_NO_ABI_LIBRARY)
 std::type_info::~type_info()
 {
 }
 #endif
-
-#if !defined(LIBCXXRT) && !defined(_LIBCPPABI_VERSION)
-
-std::bad_cast::bad_cast() _NOEXCEPT
-{
-}
-
-std::bad_typeid::bad_typeid() _NOEXCEPT
-{
-}
-
-#ifndef __GLIBCXX__
-
-std::bad_cast::~bad_cast() _NOEXCEPT
-{
-}
-
-const char*
-std::bad_cast::what() const _NOEXCEPT
-{
-  return "std::bad_cast";
-}
-
-std::bad_typeid::~bad_typeid() _NOEXCEPT
-{
-}
-
-const char*
-std::bad_typeid::what() const _NOEXCEPT
-{
-  return "std::bad_typeid";
-}
-
-#if defined(__APPLE__) && !defined(_LIBCPP_BUILDING_HAS_NO_ABI_LIBRARY)
-  // On Darwin, the cxa_bad_* functions cannot be in the lower level library
-  // because bad_cast and bad_typeid are defined in his higher level library
-  void __cxxabiv1::__cxa_bad_typeid()
-  {
-#ifndef _LIBCPP_NO_EXCEPTIONS
-     throw std::bad_typeid();
-#else
-     _VSTD::abort();
-#endif
-  }
-  void __cxxabiv1::__cxa_bad_cast()
-  {
-#ifndef _LIBCPP_NO_EXCEPTIONS
-      throw std::bad_cast();
-#else
-      _VSTD::abort();
-#endif
-  }
-#endif
-
-#endif  // !__GLIBCXX__
-#endif  // !LIBCXXRT && !_LIBCPPABI_VERSION