Make it possible to build a -fno-exceptions libc++abi variant.

[rmaprath]

Summary

Support for building a -fno-exceptions libc++ variant was reinstated recently. However, some of the standard library functions like std::terminate() are currently spread across lib++ and libc++abi, making the -fno-exceptions libc++ variant useless when those functions are used (as they pull in all the exceptions machinery that we are trying to get rid of in the final image).

This patch makes it possilbe to also build libc++abi with -fno-exceptions so that functions like std::terminate() can be used in a no-exceptions environment.

Most of the sources are already correctly setup to support a -fno-exceptions build, I just filled in the missing bits.

If there are no objections, I will get this committed over the weekend.

[bcraig]

CMakeLists.txt

359 ↗

(On Diff #58597)

There's one area / test that I would still like to see when exceptions are off. "magic" / thread safe static initialization has a test (test_guard.pass.cpp). I think it would be pretty easy to #if out the one sub-test that uses exceptions there.

There's also some demangling and backtracing tests, but I'm much less concerned with those. If you go through the trouble to get any tests working with exceptions turned off, you might as well get those too.

src/cxa_aux_runtime.cpp

19 ↗

(On Diff #58597)

So you're turning off exceptions, but leaving RTTI? You might want to keep some of the RTTI tests around too if that's the case.

src/cxa_new_delete.cpp

85 ↗

(On Diff #58597)

Question: Should "throwing" new call terminate on allocation failure, or is returning null from "throwing" new fine?

I'm leaning towards returning null, as I would rapidly grow tired of std::nothrow everywhere, but it does seem a bit dangerous.

[rmaprath]

src/cxa_aux_runtime.cpp

19–20 ↗

(On Diff #58620)

I'm not very familiar with how RTTI works, I was simply getting rid of the throw statements which get in the way of compiling with -fno-exceptions.

So, I presume these __cxa_bad_xxx calls are inserted by the compiler?

The tests dynamic_cast_xxx all seem to pass, which I found a bit weird because I would've expected some of those to fail because of the std::terminate(). Or are they not related to RTTI?

src/cxa_new_delete.cpp

85–86 ↗

(On Diff #58620)

I agree. I've update it to be inline with new.cpp from libcxx.

At least the users will have some method of recovery if we return null, calling std::terminate() would be a bit rude.

[bcraig]

src/cxa_aux_runtime.cpp

19–24 ↗

(On Diff #58597)

_cxa_bad_cast should be inserted by the compiler. It is called when a dynamic_cast to a reference type fails.
_cxa_bad_typeid should be inserted by the compiler. It is called when typeid is used on a null pointer.

_cxa_throw_bad_array_new_length should probably stay put. The most common reason for that to get hit is if sizeof(obj) * number_of_elts > SIZE_T_MAX.

[rmaprath]

src/cxa_aux_runtime.cpp

19–25 ↗

(On Diff #58620)

Thanks. I will try to get clang to generate these (btw, do you have a reference for those RTTI functions? I couldn't find much on the interwebs.

I suppose leaving these functions (which call std::terminate()) in the -fno-exceptions variant is not a problem?

[jroelofs]

This is the canonical reference for the Itanium ABI: https://mentorembedded.github.io/cxx-abi/abi.html

[rmaprath]

In D20677#441061, @jroelofs wrote:

This is the canonical reference for the Itanium ABI: https://mentorembedded.github.io/cxx-abi/abi.html

I was indeed looking at this, but couldn't find those exact function signatures (or something that looks like it). Perhaps it's covered there as a more general concept. I'll have a read.

Thanks!

/ Asiri

[bcraig]

LGTM. Probably want a "LGTM" from at least one other person though.

In D20677#441085, @rmaprath wrote:

In D20677#441061, @jroelofs wrote:

This is the canonical reference for the Itanium ABI: https://mentorembedded.github.io/cxx-abi/abi.html

I was indeed looking at this, but couldn't find those exact function signatures (or something that looks like it). Perhaps it's covered there as a more general concept. I'll have a read.

https://mentorembedded.github.io/cxx-abi/abi-eh.html mentions the functions, but it doesn't really say what they are for. The C++ standard mentions when an exception of std::bad_cast and std::bad_typeid are thrown. Put those two documents together, and you get my earlier statements. Granted, it's just a well informed guess, but a guess I'm pretty confident in.

Leaving those functions in should be harmless, other than the size of the dead code. There are also all the private type_info classes that are dead weight if RTTI is turned off.

While it may make sense to remove those functions, that's probably best left for a different code review.

[EricWF]

I want to take a look at this as well. I'll review it tomorrow.

[EricWF]

Adding @mclow.lists to this as well.

[rmaprath]

In D20677#441407, @bcraig wrote:

https://mentorembedded.github.io/cxx-abi/abi-eh.html mentions the functions, but it doesn't really say what they are for. The C++ standard mentions when an exception of std::bad_cast and std::bad_typeid are thrown. Put those two documents together, and you get my earlier statements. Granted, it's just a well informed guess, but a guess I'm pretty confident in.

Leaving those functions in should be harmless, other than the size of the dead code. There are also all the private type_info classes that are dead weight if RTTI is turned off.

While it may make sense to remove those functions, that's probably best left for a different code review.

Thanks, added that to my arsenal of references :)

[rmaprath]

In D20677#441598, @EricWF wrote:

I want to take a look at this as well. I'll review it tomorrow.

Thanks! will wait until we have ironed out all the details, no hurry.

/ Asiri

[mclow.lists]

If you're really going to do this, you should probably empty out most of the routines in src/cxa_exception.cpp as well.

[EricWF]

I have an issue with this change since it allows a libc++abi built without exceptions to be used in a program compiled with them. I assert that this should not be supported in any way.

My personal preference would be to remove as much of the exception API from the library when it's built without exceptions. This should cause link errors if a program contains any code that throws. If this is not done it creates bugs within code like __terminate as mentioned in an inline comment.

I would like to see another revision of this patch that removes as much of the exception API as possible. Looking at the symbols defined in cxxabi.h I would say ever symbol in sections 2.4 and 2.5 should not longer be defined in the library.

src/cxa_handlers.cpp

62 ↗

(On Diff #58620)

If any part of your executable was compiled with exceptions on, and it sets a terminate handler that throws an exception this does the wrong thing. I don't really like that although I admit that would certainly be an exceptional situation.

At minimum this requirement needs to be documented explicitly somewhere. Within the CMake option description seems fine for now.

src/cxa_personality.cpp

1204 ↗

(On Diff #58620)

This is yucky. We are in exception handling code and we are saying it has been built without exceptions. I understand this "gets libc++abi to compile" without exceptions but it doesn't really make sense.

[rmaprath]

In D20677#442559, @EricWF wrote:

I have an issue with this change since it allows a libc++abi built without exceptions to be used in a program compiled with them. I assert that this should not be supported in any way.

My personal preference would be to remove as much of the exception API from the library when it's built without exceptions. This should cause link errors if a program contains any code that throws. If this is not done it creates bugs within code like __terminate as mentioned in an inline comment.

I would like to see another revision of this patch that removes as much of the exception API as possible. Looking at the symbols defined in cxxabi.h I would say ever symbol in sections 2.4 and 2.5 should not longer be defined in the library.

That sounds generally OK to me. The toolchain I'm working on (ARM Compiler 6) has an elaborate mechanism (based on build attributes) to select the correct variant of libraries. In other words, if any of your objects are compiled with exceptions, you are guaranteed to no select any of the no-exceptions library variants. This avoids the problem you mentioned altogether.

But I can see that this can be a problem for any other toolchain that does not have such a functionality, and a link-time error would be more suitable.

I'll re-spin a patch soon.

Thanks.

/ Asiri

[EricWF]

In D20677#442687, @rmaprath wrote:

In D20677#442559, @EricWF wrote:

I have an issue with this change since it allows a libc++abi built without exceptions to be used in a program compiled with them. I assert that this should not be supported in any way.

My personal preference would be to remove as much of the exception API from the library when it's built without exceptions. This should cause link errors if a program contains any code that throws. If this is not done it creates bugs within code like __terminate as mentioned in an inline comment.

I would like to see another revision of this patch that removes as much of the exception API as possible. Looking at the symbols defined in cxxabi.h I would say ever symbol in sections 2.4 and 2.5 should not longer be defined in the library.

That sounds generally OK to me. The toolchain I'm working on (ARM Compiler 6) has an elaborate mechanism (based on build attributes) to select the correct variant of libraries. In other words, if any of your objects are compiled with exceptions, you are guaranteed to no select any of the no-exceptions library variants. This avoids the problem you mentioned altogether.

Note that that behavior will cause different issues in some cases. If you link an executable to two libraries, libfoo.so and libbar.so, where one was compiled with exceptions and the other without you'll get two copies of libc++abi in the program. Now you have two copies of the global terminate handler and two copies of __terminate for the linker to select from.
If it selects the nothrow __terminate and the terminate handler throws an exception your in trouble.

That's not a reason to hold up this patch, but it is a potential problem you should be aware of.

[rmaprath]

In D20677#442713, @EricWF wrote:

In D20677#442687, @rmaprath wrote:

In D20677#442559, @EricWF wrote:

I have an issue with this change since it allows a libc++abi built without exceptions to be used in a program compiled with them. I assert that this should not be supported in any way.

My personal preference would be to remove as much of the exception API from the library when it's built without exceptions. This should cause link errors if a program contains any code that throws. If this is not done it creates bugs within code like __terminate as mentioned in an inline comment.

I would like to see another revision of this patch that removes as much of the exception API as possible. Looking at the symbols defined in cxxabi.h I would say ever symbol in sections 2.4 and 2.5 should not longer be defined in the library.

That sounds generally OK to me. The toolchain I'm working on (ARM Compiler 6) has an elaborate mechanism (based on build attributes) to select the correct variant of libraries. In other words, if any of your objects are compiled with exceptions, you are guaranteed to no select any of the no-exceptions library variants. This avoids the problem you mentioned altogether.

Note that that behavior will cause different issues in some cases. If you link an executable to two libraries, libfoo.so and libbar.so, where one was compiled with exceptions and the other without you'll get two copies of libc++abi in the program. Now you have two copies of the global terminate handler and two copies of __terminate for the linker to select from.
If it selects the nothrow __terminate and the terminate handler throws an exception your in trouble.

In this case, I expect the linker to only select one variant of libc++abi (the one with exceptions). The idea behind build-attributes is to capture user intentions, if the user links his program with libbar.a and libfoo.a user libraries (with and without exceptions), the linker would assume that the user meant to use exceptions rather than not, and hence select the with-exceptions libc++abi variant. The theory behind build-attributes is bit more complicated that that though, I'm not the best person to go on about this.

In any case, I agree that getting the linker to produce an error (when linking with-exceptions objects with a no-exceptions libc++abi) is much more clearer.

I have a small concern about how difficult this would make things for us though - our toolchain setup uses -ffunction-sections and -fdata-sections along with linker's unused-section elimination to get rid of most of the stuff not necessary for the final image, but I can't remember if unused-section elimination happens before or after checking for missing symbols. If it is the latter, then we might be in trouble with this approach. I will have a look into this when I get back to work.

Cheers,

/ Asiri

[rmaprath]

I have a small concern about how difficult this would make things for us though - our toolchain setup uses -ffunction-sections and -fdata-sections along with linker's unused-section elimination to get rid of most of the stuff not necessary for the final image, but I can't remember if unused-section elimination happens before or after checking for missing symbols. If it is the latter, then we might be in trouble with this approach. I will have a look into this when I get back to work.

Come to think of it, I'm 90% sure it's the latter (I don't see how the former can work - the linker has to load all the objects while resolving all the dependencies, then only it can get rid of the stuff the final image doesn't really need). The linker will give up as soon as it hits a missing symbol referred from a section which is actually unused in the final image (but is within some object which contains sections that are actually needed for the image).

Of course I need to confirm that 10% when I get my hands on the linker, but I have a feeling this is going to be a blocker for us.

[rmaprath]

OK, managed to solve this problem by removing cxa_exception.cpp and cxa_personality.cpp from the no-exceptions libcxxabi build.

In order to do this, a small patch was needed for exception.cpp of libcxx: D20784

@EricWF, @mclow.lists: WDYT?

Thanks.

/ Asiri

[rmaprath]

CMakeLists.txt

111 ↗

(On Diff #58927)

My bad, this should be ON by default (leftover from testing).

[rmaprath]

Fixed a few typos.

[rmaprath]

Addressing review comments from @EricWF:

• Rather than explicitly decoupling the no-exceptions libc++ library from the __cxa_* routines (D20784), provide a placeholder implementation of those functions within the no-exceptions libc++abi library. We still have some symbols like __cxa_throw removed from the no-exceptions libc++abi library (those symbols are generated from the compiler, rather than found in the library), so the original requirement of not allowing linking with-exceptions code with no-exceptions libc++abi library is satisfied.

[EricWF]

Looking good. I would like to see some tests for the methods we have specificly defined to have behavior in -fno-exceptions mode.

src/cxa_noexception.cpp

27 ↗

(On Diff #59000)

I think either all of the functions in this file should have _LIBCXXABI_FUNC_VIS or none of them should. My preference is none since the declarations should have them.

29 ↗

(On Diff #59000)

nit: nullptr

45 ↗

(On Diff #59000)

I think we should terminate if void* is non-null.

test/backtrace_test.pass.cpp

19 ↗

(On Diff #59000)

Does this test have any value in -fno-exceptions mode?

test/libcxxabi/test/config.py

46 ↗

(On Diff #59000)

Nit: I would prefer LIBCXXABI_HAS_NO_EXCEPTIONS since the default should be on. The fact that a macro is missing shouldn't disable half the tests.

test/test_vector1.pass.cpp

8 ↗

(On Diff #59000)

Don't you want these tests to run? They aren't part of the exception API AFAIK.

test/uncaught_exceptions.pass.cpp

10 ↗

(On Diff #59000)

We provided a different implementation so we should test it, not disable the test.

[rmaprath]

Addressed review comments from @EricWF:

• Addressed the nits
• Disabled backtrace_test.pass.cpp for the moment, need to check if using _Unwind_backtrace with no unwinding tables (-fno-exceptions) makes sense
• Enabled a small part of test_vector1.pass.cpp, most of this test and other vector tests are to do with how exceptions are dealt with
• Added tests for the new functions introduced to cxa_noexceptions.cpp. These are mostly trivial.
• Added tests for the __cxa_bad_cast and __cxa_bad_typeid functions. Could not manage to invoke __cxa_throw_bad_array_new_length, which does not seem to work like documented in [1]. Need to take this offline.

[1] http://en.cppreference.com/w/cpp/memory/new/bad_array_new_length

[EricWF]

For some reason I'm having trouble applying your patch. Could you please upload it with more context? (ie git diff -U999 or similar)

[EricWF]

Nevermind. I figured out why it wasn't working. Phab didn't know the libc++ patch was in a different repo and so it wouldn't apply the patch.

[EricWF]

Just for reference here is a list of symbols which have been removed:

https://gist.github.com/EricWF/bf00dbc5fccc78b779f8d260727a0710

LGTM. Your free to submit it after addressing the inline comments.

test/cxa_bad_cast.pass.cpp

40 ↗

(On Diff #59009)

return 0;

45 ↗

(On Diff #59009)

return 1;

test/cxa_bad_typeid.pass.cpp

39 ↗

(On Diff #59009)

return 0 here instead. "assert(true)" is pretty much un-observable.

44 ↗

(On Diff #59009)

This should return non-zero.

test/noexception1.pass.cpp

26 ↗

(On Diff #59009)

Before setting the terminate handling call the function once with null to make sure it returns.

test/noexception2.pass.cpp

26 ↗

(On Diff #59009)

Before setting the terminate handling call the function once with null to make sure it returns.

test/noexception3.pass.cpp

27 ↗

(On Diff #59009)

Before setting the terminate handling call the function once with null to make sure it returns.

[rmaprath]

Thanks Eric.

I think I noted a few other assert(true) statements elsewhere (with similar application), will update those separately.

Btw, do you use some systematic way to detect ABI breakages? I've only bumped into http://lvc.github.io/abi-compliance-checker/ but didn't go as far as setting it up.

/ Asiri

[EricWF]

In D20677#443997, @rmaprath wrote:

Thanks Eric.

I think I noted a few other assert(true) statements elsewhere (with similar application), will update those separately.

Btw, do you use some systematic way to detect ABI breakages? I've only bumped into http://lvc.github.io/abi-compliance-checker/ but didn't go as far as setting it up.

Not really, the two primary ways I try to detect ABI breakage are using:

• the scripts under libcxx/utils/sym_check/. They provide a way to diff the symbols between two dylibs sym_diff.py old-lib.so new-lib.so.
• Compiling against an old library and swapping in a new library at runtime.

I also used libabigail for a while but it was a bit too noisy with false positives. It may be better now though.

/ Asiri

libcxxabi/trunk/CMakeLists.txt

else()
   set(LIBCXXABI_LIBDIR_SUFFIX ${LLVM_LIBDIR_SUFFIX})
 endif()
 
 #===============================================================================
 # Setup CMake Options
 #===============================================================================
 
 # Define options.
+option(LIBCXXABI_ENABLE_EXCEPTIONS "Use exceptions." ON)
 option(LIBCXXABI_ENABLE_ASSERTIONS "Enable assertions independent of build mode." ON)
 option(LIBCXXABI_ENABLE_PEDANTIC "Compile with pedantic enabled." ON)
 option(LIBCXXABI_ENABLE_WERROR "Fail and stop if a warning is triggered." OFF)
 option(LIBCXXABI_USE_LLVM_UNWINDER "Build and use the LLVM unwinder." OFF)
 option(LIBCXXABI_ENABLE_THREADS "Build with threads enabled" ON)
 option(LIBCXXABI_HAS_PTHREAD_API "Ignore auto-detection and force use of pthread API" OFF)
 set(LIBCXXABI_GCC_TOOLCHAIN "" CACHE STRING "GCC toolchain for cross compiling.")
 set(LIBCXXABI_SYSROOT "" CACHE STRING "Sysroot for cross compiling.")
else()
   append_if(LIBCXXABI_COMPILE_FLAGS LIBCXXABI_HAS_WNO_ERROR_FLAG -Wno-error)
   append_if(LIBCXXABI_COMPILE_FLAGS LIBCXXABI_HAS_NO_WX_FLAG -WX-)
 endif()
 if (LIBCXXABI_ENABLE_PEDANTIC)
   append_if(LIBCXXABI_COMPILE_FLAGS LIBCXXABI_HAS_PEDANTIC_FLAG -pedantic)
 endif()
 
 # Get feature flags.
+append_if(LIBCXXABI_CXX_FLAGS LIBCXXABI_HAS_FSTRICT_ALIASING_FLAG -fstrict-aliasing)
+
 # Exceptions
+if (LIBCXXABI_ENABLE_EXCEPTIONS)
   # Catches C++ exceptions only and tells the compiler to assume that extern C
   # functions never throw a C++ exception.
-append_if(LIBCXXABI_CXX_FLAGS LIBCXXABI_HAS_FSTRICT_ALIASING_FLAG -fstrict-aliasing)
   append_if(LIBCXXABI_CXX_FLAGS LIBCXXABI_HAS_EHSC_FLAG -EHsc)
-
   append_if(LIBCXXABI_C_FLAGS LIBCXXABI_HAS_FUNWIND_TABLES -funwind-tables)
+else()
+  add_definitions(-D_LIBCXXABI_NO_EXCEPTIONS)
+  append_if(LIBCXXABI_CXX_FLAGS LIBCXXABI_HAS_NO_EXCEPTIONS_FLAG -fno-exceptions)
+  append_if(LIBCXXABI_CXX_FLAGS LIBCXXABI_HAS_NO_EHS_FLAG -EHs-)
+  append_if(LIBCXXABI_CXX_FLAGS LIBCXXABI_HAS_NO_EHA_FLAG -EHa-)
+endif()
 
 append_if(LIBCXXABI_COMPILE_FLAGS LIBCXXABI_HAS_FVISIBILITY_HIDDEN_FLAG -fvisibility=hidden)
 
 # Assert
 string(TOUPPER "${CMAKE_BUILD_TYPE}" uppercase_CMAKE_BUILD_TYPE)
 if (LIBCXXABI_ENABLE_ASSERTIONS)
   # MSVC doesn't like _DEBUG on release builds. See PR 4379.
   if (NOT MSVC)

libcxxabi/trunk/src/CMakeLists.txt

 # Get sources
 set(LIBCXXABI_SOURCES
   abort_message.cpp
   cxa_aux_runtime.cpp
   cxa_default_handlers.cpp
   cxa_demangle.cpp
-  cxa_exception.cpp
   cxa_exception_storage.cpp
   cxa_guard.cpp
   cxa_handlers.cpp
   cxa_new_delete.cpp
-  cxa_personality.cpp
   cxa_unexpected.cpp
   cxa_vector.cpp
   cxa_virtual.cpp
   exception.cpp
   private_typeinfo.cpp
   stdexcept.cpp
   typeinfo.cpp
 )
 
+if (LIBCXXABI_ENABLE_EXCEPTIONS)
+  list(APPEND LIBCXXABI_SOURCES cxa_exception.cpp)
+  list(APPEND LIBCXXABI_SOURCES cxa_personality.cpp)
+else()
+  list(APPEND LIBCXXABI_SOURCES cxa_noexception.cpp)
+endif()
+
 if (UNIX AND NOT (APPLE OR CYGWIN))
   list(APPEND LIBCXXABI_SOURCES cxa_thread_atexit.cpp)
 endif()
 
 set(LIBCXXABI_HEADERS ../include/cxxabi.h)
 
 # Add all the headers to the project for IDEs.
 if (MSVC_IDE OR XCODE)

libcxxabi/trunk/src/cxa_aux_runtime.cpp

 
 #include "cxxabi.h"
 #include <new>
 #include <typeinfo>
 
 namespace __cxxabiv1 {
 extern "C" {
 _LIBCXXABI_FUNC_VIS LIBCXXABI_NORETURN void __cxa_bad_cast(void) {
+#ifndef _LIBCXXABI_NO_EXCEPTIONS
   throw std::bad_cast();
+#else
+  std::terminate();
+#endif
 }
 
 _LIBCXXABI_FUNC_VIS LIBCXXABI_NORETURN void __cxa_bad_typeid(void) {
+#ifndef _LIBCXXABI_NO_EXCEPTIONS
   throw std::bad_typeid();
+#else
+  std::terminate();
+#endif
 }
 
 _LIBCXXABI_FUNC_VIS LIBCXXABI_NORETURN void
 __cxa_throw_bad_array_new_length(void) {
+#ifndef _LIBCXXABI_NO_EXCEPTIONS
   throw std::bad_array_new_length();
+#else
+  std::terminate();
+#endif
 }
 } // extern "C"
 } // abi

libcxxabi/trunk/src/cxa_handlers.cpp

 //  Using of C++11 atomics this should be rewritten
 //  return __cxa_terminate_handler.load(memory_order_acq);
 }
 
 __attribute__((visibility("hidden"), noreturn))
 void
 __terminate(terminate_handler func) _NOEXCEPT
 {
-#if __has_feature(cxx_exceptions)
+#ifndef _LIBCXXABI_NO_EXCEPTIONS
     try
     {
-#endif  // __has_feature(cxx_exceptions)
+#endif  // _LIBCXXABI_NO_EXCEPTIONS
         func();
         // handler should not return
         abort_message("terminate_handler unexpectedly returned");
-#if __has_feature(cxx_exceptions)
+#ifndef _LIBCXXABI_NO_EXCEPTIONS
     }
     catch (...)
     {
         // handler should not throw exception
         abort_message("terminate_handler unexpectedly threw an exception");
     }
-#endif  // #if __has_feature(cxx_exceptions)
+#endif  // _LIBCXXABI_NO_EXCEPTIONS
 }
 
 __attribute__((noreturn))
 void
 terminate() _NOEXCEPT
 {
     // If there might be an uncaught exception
     using namespace __cxxabiv1;

libcxxabi/trunk/src/cxa_new_delete.cpp

if (size == 0)
         size = 1;
     void* p;
     while ((p = std::malloc(size)) == 0)
     {
         std::new_handler nh = std::get_new_handler();
         if (nh)
             nh();
         else
+#ifndef _LIBCXXABI_NO_EXCEPTIONS
             throw std::bad_alloc();
+#else
+            break;
+#endif
     }
     return p;
 }
 
 /*
 Note:  The relationships among these operators is both carefully considered
 and standard in C++11.  Please do not change them without fully understanding
 the consequences of doing so.  Reference:

 operator new(size_t size, const std::nothrow_t&)
 #if __has_feature(cxx_noexcept)
     noexcept
 #else
     throw()
 #endif
 {
     void* p = 0;
+#ifndef _LIBCXXABI_NO_EXCEPTIONS
     try
     {
+#endif
         p = ::operator new(size);
+#ifndef _LIBCXXABI_NO_EXCEPTIONS
     }
     catch (...)
     {
     }
+#endif
     return p;
 }
 
 /*
 [new.delete.array]
 
 Returns operator new(size).
 */

 operator new[](size_t size, const std::nothrow_t&)
 #if __has_feature(cxx_noexcept)
     noexcept
 #else
     throw()
 #endif
 {
     void* p = 0;
+#ifndef _LIBCXXABI_NO_EXCEPTIONS
     try
     {
+#endif
         p = ::operator new[](size);
+#ifndef _LIBCXXABI_NO_EXCEPTIONS
     }
     catch (...)
     {
     }
+#endif
     return p;
 }
 
 /*
 [new.delete.single]
 
 If ptr is null, does nothing. Otherwise, reclaims the storage allocated by the
 earlier call to operator new.

libcxxabi/trunk/src/cxa_noexception.cpp

+//===------------------------- cxa_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.
+//
+//  
+//  This file implements the "Exception Handling APIs"
+//  http://mentorembedded.github.io/cxx-abi/abi-eh.html
+//  
+//===----------------------------------------------------------------------===//
+
+// Support functions for the no-exceptions libc++ library
+
+#include "config.h"
+#include "cxxabi.h"
+
+#include <exception>        // for std::terminate
+#include "cxa_exception.hpp"
+#include "cxa_handlers.hpp"
+
+namespace __cxxabiv1 {
+
+#pragma GCC visibility push(default)
+
+extern "C" {
+
+void
+__cxa_increment_exception_refcount(void *thrown_object) throw() {
+    if (thrown_object != nullptr)
+        std::terminate();
+}
+
+void
+__cxa_decrement_exception_refcount(void *thrown_object) throw() {
+    if (thrown_object != nullptr)
+      std::terminate();
+}
+
+
+void *__cxa_current_primary_exception() throw() { return nullptr; }
+
+void
+__cxa_rethrow_primary_exception(void* thrown_object) {
+    if (thrown_object != nullptr)
+      std::terminate();
+}
+
+bool
+__cxa_uncaught_exception() throw() { return false; }
+
+unsigned int
+__cxa_uncaught_exceptions() throw() { return 0; }
+
+}  // extern "C"
+
+#pragma GCC visibility pop
+
+}  // abi

libcxxabi/trunk/test/CMakeLists.txt

 macro(pythonize_bool var)
   if (${var})
     set(${var} True)
   else()
     set(${var} False)
   endif()
 endmacro()
 
 if (NOT DEFINED LIBCXX_ENABLE_SHARED)
   set(LIBCXX_ENABLE_SHARED ON)
 endif()
 
 pythonize_bool(LLVM_BUILD_32_BITS)
 pythonize_bool(LIBCXX_ENABLE_SHARED)
 pythonize_bool(LIBCXXABI_ENABLE_SHARED)
 pythonize_bool(LIBCXXABI_ENABLE_THREADS)
+pythonize_bool(LIBCXXABI_ENABLE_EXCEPTIONS)
 pythonize_bool(LIBCXXABI_USE_LLVM_UNWINDER)
 pythonize_bool(LIBCXXABI_HAS_CXA_THREAD_ATEXIT_IMPL)
 set(LIBCXXABI_TARGET_INFO "libcxx.test.target_info.LocalTI" CACHE STRING
     "TargetInfo to use when setting up test environment.")
 set(LIBCXXABI_EXECUTOR "None" CACHE STRING
     "Executor to use when running tests.")
 
 set(AUTO_GEN_COMMENT "## Autogenerated by libcxxabi configuration.\n# Do not edit!")

libcxxabi/trunk/test/backtrace_test.pass.cpp

 //===---------------------- backtrace_test.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.
 //
 //===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: libcxxabi-no-exceptions
+
 #include <assert.h>
 #include <stddef.h>
 #include <unwind.h>
 
 extern "C" _Unwind_Reason_Code
 trace_function(struct _Unwind_Context* context, void* ntraced) {
   (*reinterpret_cast<size_t*>(ntraced))++;
   // We should never have a call stack this deep...

libcxxabi/trunk/test/catch_array_01.pass.cpp

 //===---------------------- catch_array_01.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.
 //
 //===----------------------------------------------------------------------===//
 
 // Can you have a catch clause of array type that catches anything?
 
-
 // GCC incorrectly allows array types to be caught by reference.
 // See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=69372
 // XFAIL: gcc
+// UNSUPPORTED: libcxxabi-no-exceptions
 
 #include <cassert>
 
 int main()
 {
     typedef char Array[4];
     Array a = {'H', 'i', '!', 0};
     try

libcxxabi/trunk/test/catch_array_02.pass.cpp

 //===---------------------- catch_array_02.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.
 //
 //===----------------------------------------------------------------------===//
 
 // Can you have a catch clause of array type that catches anything?
+// UNSUPPORTED: libcxxabi-no-exceptions
 
 #include <cassert>
 
 int main()
 {
     typedef char Array[4];
     Array a = {'H', 'i', '!', 0};
     try

libcxxabi/trunk/test/catch_class_01.pass.cpp

 //===---------------------- catch_class_01.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.
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcxxabi-no-exceptions
+
 #include <exception>
 #include <stdlib.h>
 #include <assert.h>
 
 struct A
 {
     static int count;
     int id_;

libcxxabi/trunk/test/catch_class_02.pass.cpp

 //===---------------------- catch_class_02.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.
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcxxabi-no-exceptions
+
 #include <exception>
 #include <stdlib.h>
 #include <assert.h>
 
 struct B
 {
     static int count;
     int id_;

libcxxabi/trunk/test/catch_class_03.pass.cpp

 //===---------------------- catch_class_03.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 checks that adjustedPtr is correct as there exist offsets in this
     object for the various subobjects, all of which have a unique id_ to
     check against.
 */
 
+// UNSUPPORTED: libcxxabi-no-exceptions
+
 #include <exception>
 #include <stdlib.h>
 #include <assert.h>
 
 struct B
 {
     static int count;
     int id_;

libcxxabi/trunk/test/catch_class_04.pass.cpp

 //===---------------------- catch_class_04.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 checks that adjustedPtr is correct as there exist offsets in this
     object for the various subobjects, all of which have a unique id_ to
     check against.  It also checks that virtual bases work properly
 */
 
+// UNSUPPORTED: libcxxabi-no-exceptions
+
 #include <exception>
 #include <stdlib.h>
 #include <assert.h>
 
 struct B
 {
     static int count;
     int id_;

libcxxabi/trunk/test/catch_const_pointer_nullptr.pass.cpp

 //===--------------------- catch_const_pointer_nullptr.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.
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcxxabi-no-exceptions
+
 #include <cassert>
 
 #if __has_feature(cxx_nullptr)
 
 struct A {};
 
 void test1()
 {

libcxxabi/trunk/test/catch_function_01.pass.cpp

 //===----------------------- catch_function_01.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.
 //
 //===----------------------------------------------------------------------===//
 
 // Can you have a catch clause of array type that catches anything?
 
 // GCC incorrectly allows function pointer to be caught by reference.
 // See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=69372
 // XFAIL: gcc
+// UNSUPPORTED: libcxxabi-no-exceptions
 
 #include <cassert>
 
 template <class Tp>
 bool can_convert(Tp) { return true; }
 
 template <class>
 bool can_convert(...) { return false; }

libcxxabi/trunk/test/catch_function_02.pass.cpp

 //===---------------------- catch_function_02.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.
 //
 //===----------------------------------------------------------------------===//
 
 // Can you have a catch clause of array type that catches anything?
+// UNSUPPORTED: libcxxabi-no-exceptions
 
 #include <cassert>
 
 void f() {}
 
 int main()
 {
     typedef void Function();

libcxxabi/trunk/test/catch_in_noexcept.pass.cpp

 //===---------------------- catch_in_noexcept.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.
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++98, c++03
+// UNSUPPORTED: c++98, c++03, libcxxabi-no-exceptions
 
 #include <exception>
 #include <stdlib.h>
 #include <assert.h>
 
 struct A {};
 
 // Despite being marked as noexcept, this function must have an EHT entry that

libcxxabi/trunk/test/catch_member_data_pointer_01.pass.cpp

 //===----------------- catch_member_data_pointer_01.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.
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcxxabi-no-exceptions
+
 #include <cassert>
 
 struct A
 {
     const int i;
     int j;
 };
 

libcxxabi/trunk/test/catch_member_function_pointer_01.pass.cpp

 //===--------------- catch_member_function_pointer_01.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.
 //
 //===----------------------------------------------------------------------===//
 
 // GCC incorrectly allows PMF type "void (T::*)()" to be caught as "void (T::*)() const"
 // See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=69375
 // XFAIL: gcc
+// UNSUPPORTED: libcxxabi-no-exceptions
 #include <cassert>
 
 struct A
 {
     void foo() {}
     void bar() const {}
 };
 

libcxxabi/trunk/test/catch_member_pointer_nullptr.pass.cpp

 //===----------------- catch_member_pointer_nullptr.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.
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcxxabi-no-exceptions
+
 #include <cassert>
 
 #if __has_feature(cxx_nullptr)
 
 struct A
 {
     const int i;
     int j;

libcxxabi/trunk/test/catch_multi_level_pointer.pass.cpp

 //===--------------------- catch_pointer_nullptr.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.
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcxxabi-no-exceptions
+
 #include <cassert>
 #include <cstdlib>
 #include <iostream>
 
 // Roll our own assertion macro to get better error messages out of the tests.
 // In particular on systems that don't use __PRETTY_FUNCTION__ in assertions.
 #define my_assert(pred, msg) do_assert(pred, msg, __LINE__, __PRETTY_FUNCTION__)
 

libcxxabi/trunk/test/catch_pointer_nullptr.pass.cpp

 //===--------------------- catch_pointer_nullptr.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.
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++98, c++03
+// UNSUPPORTED: c++98, c++03, libcxxabi-no-exceptions
 
 #include <cassert>
 #include <cstdlib>
 
 struct A {};
 
 void test1()
 {

libcxxabi/trunk/test/catch_pointer_reference.pass.cpp

 //  |       o  a standard pointer conversion (4.10 [conv.ptr]) not involving   |
 //  |          conversions to private or protected or ambiguous classes        |
 //  \       o  a qualification conversion                                      /
 //     *  the handler is a pointer or pointer to member type and E is
 //        std::nullptr_t
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcxxabi-no-exceptions
+
 #include <exception>
 #include <stdlib.h>
 #include <assert.h>
 #include <stdio.h>
 
 struct Base {};
 struct Derived  : Base {};
 struct Derived2 : Base {};

libcxxabi/trunk/test/catch_ptr.pass.cpp

 //===---------------------- catch_class_04.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 checks that adjustedPtr is correct as there exist offsets in this
     object for the various subobjects, all of which have a unique id_ to
     check against.  It also checks that virtual bases work properly
 */
 
+// UNSUPPORTED: libcxxabi-no-exceptions
+
 #include <exception>
 #include <stdlib.h>
 #include <assert.h>
 
 struct B
 {
     static int count;
     int id_;

libcxxabi/trunk/test/catch_ptr_02.pass.cpp

 //===------------------------- catch_ptr_02.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.
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcxxabi-no-exceptions
+
 #include <cassert>
 
 #if __cplusplus < 201103L
 #define DISABLE_NULLPTR_TESTS
 #endif
 
 struct  A {};
 A a;

libcxxabi/trunk/test/cxa_bad_cast.pass.cpp

+//===----------------------- cxa_bad_cast.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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+#include <cxxabi.h>
+#include <cassert>
+#include <stdlib.h>
+#include <exception>
+#include <typeinfo>
+
+class Base {
+  virtual void foo() {};
+};
+
+class Derived : public Base {};
+
+Derived &test_bad_cast(Base b) {
+  return dynamic_cast<Derived&>(b);
+}
+
+Base gB;
+
+void my_terminate() { exit(0); }
+
+int main ()
+{
+    // swap-out the terminate handler
+    void (*default_handler)() = std::get_terminate(); 
+    std::set_terminate(my_terminate);
+
+#ifndef LIBCXXABI_HAS_NO_EXCEPTIONS
+    try {
+#endif
+        Derived &d = test_bad_cast(gB);
+        assert(false);
+#ifndef LIBCXXABI_HAS_NO_EXCEPTIONS
+    } catch (std::bad_cast) {
+        // success
+        return 0;
+    } catch (...) {
+        assert(false);
+    }
+#endif
+
+    // failure, restore the default terminate handler and fire
+    std::set_terminate(default_handler);
+    std::terminate();
+}

libcxxabi/trunk/test/cxa_bad_typeid.pass.cpp

+//===----------------------- cxa_bad_typeid.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.
+//
+//===------------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+#include <cxxabi.h>
+#include <cassert>
+#include <stdlib.h>
+#include <exception>
+#include <typeinfo>
+#include <string>
+#include <iostream>
+
+class Base {
+  virtual void foo() {};
+};
+
+class Derived : public Base {};
+
+std::string test_bad_typeid(Derived *p) {
+    typeid(*p).name();
+}
+
+void my_terminate() { std::cout << "A" << std::endl; exit(0); }
+
+int main ()
+{
+    // swap-out the terminate handler
+    void (*default_handler)() = std::get_terminate(); 
+    std::set_terminate(my_terminate);
+
+#ifndef LIBCXXABI_HAS_NO_EXCEPTIONS
+    try {
+#endif
+        test_bad_typeid(nullptr);
+        assert(false);
+#ifndef LIBCXXABI_HAS_NO_EXCEPTIONS
+    } catch (std::bad_typeid) {
+        // success
+        return 0;
+    } catch (...) {
+        assert(false);
+    }
+#endif
+
+    // failure, restore the default terminate handler and fire
+    std::set_terminate(default_handler);
+    std::terminate();
+}

libcxxabi/trunk/test/incomplete_type.sh.cpp

 //===------------------------- incomplete_type.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.
 //
 //===----------------------------------------------------------------------===//
 // http://mentorembedded.github.io/cxx-abi/abi.html#rtti-layout
 
 // Two abi::__pbase_type_info objects can always be compared for equality
 // (i.e. of the types represented) or ordering by comparison of their name
 // NTBS addresses. In addition, unless either or both have either of the
 // incomplete flags set, equality can be tested by comparing the type_info
 // addresses.
 
+// UNSUPPORTED: libcxxabi-no-exceptions
+
 // RUN: %cxx %flags %compile_flags -c %s -o %t.one.o
 // RUN: %cxx %flags %compile_flags -c %s -o %t.two.o -DTU_ONE
 // RUN: %cxx %flags %t.one.o %t.two.o %link_flags -o %t.exe
 // RUN: %exec %t.exe
 
 #include <stdio.h>
 #include <cstring>
 #include <cassert>

libcxxabi/trunk/test/inherited_exception.pass.cpp

 //          o  a standard pointer conversion (4.10 [conv.ptr]) not involving
 //             conversions to private or protected or ambiguous classes
 //          o  a qualification conversion
 //     *  the handler is a pointer or pointer to member type and E is
 //        std::nullptr_t
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcxxabi-no-exceptions
+
 #include <assert.h>
 
 struct Base {
   int b1;
 };
 
 struct Base2 {
   int b2;

libcxxabi/trunk/test/libcxxabi/test/config.py

def configure_src_root(self):
             os.path.join(self.libcxxabi_src_root, '/../libcxx'))
 
     def configure_obj_root(self):
         self.libcxxabi_obj_root = self.get_lit_conf('libcxxabi_obj_root')
         super(Configuration, self).configure_obj_root()
 
     def configure_features(self):
         super(Configuration, self).configure_features()
+        if not self.get_lit_bool('enable_exceptions', True):
+            self.config.available_features.add('libcxxabi-no-exceptions')
         if self.get_lit_bool('thread_atexit', True):
             self.config.available_features.add('thread_atexit')
 
     def configure_compile_flags(self):
         self.cxx.compile_flags += ['-DLIBCXXABI_NO_TIMER']
+        if self.get_lit_bool('enable_exceptions', True):
             self.cxx.compile_flags += ['-funwind-tables']
+        else:
+            self.cxx.compile_flags += ['-fno-exceptions', '-DLIBCXXABI_HAS_NO_EXCEPTIONS']
         if not self.get_lit_bool('enable_threads', True):
             self.cxx.compile_flags += ['-DLIBCXXABI_HAS_NO_THREADS=1']
         super(Configuration, self).configure_compile_flags()    
     
     def configure_compile_flags_header_includes(self):
         self.configure_config_site_header()
         cxx_headers = self.get_lit_conf(
             'cxx_headers',

libcxxabi/trunk/test/lit.site.cfg.in

 config.enable_threads           = "@LIBCXXABI_ENABLE_THREADS@"
 config.use_sanitizer            = "@LLVM_USE_SANITIZER@"
 config.enable_32bit             = "@LLVM_BUILD_32_BITS@"
 config.target_info              = "@LIBCXXABI_TARGET_INFO@"
 config.executor                 = "@LIBCXXABI_EXECUTOR@"
 config.thread_atexit            = "@LIBCXXABI_HAS_CXA_THREAD_ATEXIT_IMPL@"
 config.libcxxabi_shared         = "@LIBCXXABI_ENABLE_SHARED@"
 config.enable_shared            = "@LIBCXX_ENABLE_SHARED@"
+config.enable_exceptions        = "@LIBCXXABI_ENABLE_EXCEPTIONS@"
 
 # Let the main config do the real work.
 lit_config.load_config(config, "@LIBCXXABI_SOURCE_DIR@/test/lit.cfg")

libcxxabi/trunk/test/noexception1.pass.cpp

+//===----------------------- noexception1.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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+// REQUIRES: libcxxabi-no-exceptions
+
+#include <cxxabi.h>
+#include <exception>
+#include <cassert>
+#include <stdlib.h>
+
+// namespace __cxxabiv1 {
+//      void __cxa_increment_exception_refcount(void *thrown_object) throw();
+// }
+
+unsigned gCounter = 0;
+
+void my_terminate() { exit(0); }
+
+int main ()
+{
+    // should not call std::terminate()
+    __cxxabiv1::__cxa_increment_exception_refcount(nullptr);
+
+    std::set_terminate(my_terminate);
+
+    // should call std::terminate()
+    __cxxabiv1::__cxa_increment_exception_refcount((void*) &gCounter);
+    assert(false);
+
+    return 0;
+}

libcxxabi/trunk/test/noexception2.pass.cpp

+//===----------------------- noexception2.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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+// REQUIRES: libcxxabi-no-exceptions
+
+#include <cxxabi.h>
+#include <exception>
+#include <cassert>
+#include <stdlib.h>
+
+// namespace __cxxabiv1 {
+//      void __cxa_decrement_exception_refcount(void *thrown_object) throw();
+// }
+
+unsigned gCounter = 0;
+
+void my_terminate() { exit(0); }
+
+int main ()
+{
+    // should not call std::terminate()
+    __cxxabiv1::__cxa_decrement_exception_refcount(nullptr);
+
+    std::set_terminate(my_terminate);
+
+    // should call std::terminate()
+    __cxxabiv1::__cxa_decrement_exception_refcount((void*) &gCounter);
+    assert(false);
+
+    return 0;
+}

libcxxabi/trunk/test/noexception3.pass.cpp

+//===----------------------- noexception3.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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+// REQUIRES: libcxxabi-no-exceptions
+
+#include <cxxabi.h>
+#include <exception>
+#include <cassert>
+#include <stdlib.h>
+
+// namespace __cxxabiv1 {
+//      void __cxa_rethrow_primary_exception(void* thrown_object);
+// }
+
+unsigned gCounter = 0;
+
+void my_terminate() { exit(0); }
+
+int main ()
+{
+    // should not call std::terminate()
+    __cxxabiv1::__cxa_rethrow_primary_exception(nullptr);
+
+    std::set_terminate(my_terminate);
+
+    // should call std::terminate()
+    __cxxabiv1::__cxa_rethrow_primary_exception((void*) &gCounter);
+    assert(false);
+
+    return 0;
+}

libcxxabi/trunk/test/noexception4.pass.cpp

+//===----------------------- noexception4.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.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: libcxxabi-no-exceptions
+
+#include <cxxabi.h>
+#include <exception>
+#include <cassert>
+
+// namespace __cxxabiv1 {
+//      void *__cxa_current_primary_exception() throw();
+//      extern bool          __cxa_uncaught_exception () throw();
+//      extern unsigned int  __cxa_uncaught_exceptions() throw();
+// }
+
+int main ()
+{
+    // Trivially
+    assert(nullptr == __cxxabiv1::__cxa_current_primary_exception());
+    assert(!__cxxabiv1::__cxa_uncaught_exception());
+    assert(0 == __cxxabiv1::__cxa_uncaught_exceptions());
+    return 0;
+}

libcxxabi/trunk/test/test_aux_runtime.pass.cpp

 //===-------------------------- test_aux_runtime.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.
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcxxabi-no-exceptions
+
 #include <typeinfo>
 #include <iostream>
 
 //  Test taken from 5.2.8.2
 //  When typeid is applied to a glvalue expression whose type is a polymorphic 
 //  class type, (10.3), the result refers to a std::type_info object 
 //  representing the type of the most derived object (1.8) (that is, the 
 //  dynamic type) to which the glvalue refers. If the glvalue expression is 

libcxxabi/trunk/test/test_aux_runtime_op_array_new.pass.cpp

 //===-------------------------- test_aux_runtime_op_array_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.
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcxxabi-no-exceptions
+
 #include <iostream>
 #include <cxxabi.h>
 
 //  If the expression passed to operator new[] would result in an overflow, the
 //  allocation function is not called, and a std::bad_array_new_length exception
 //  is thrown instead (5.3.4p7).
 bool bad_array_new_length_test() {
     try {

libcxxabi/trunk/test/test_guard.pass.cpp

void test() {
         helper();
         assert(run_count == 3);
     }
 }
 
 // When initialization fails, ensure that we try to initialize it again next
 // time.
 namespace test2 {
+#ifndef LIBCXXABI_HAS_NO_EXCEPTIONS
     static int run_count = 0;
     int increment() {
         ++run_count;
         throw 0;
     }
     void helper() {
         try {
             static int a = increment();
             assert(0);
         } catch (...) {}
     }
     void test() {
         helper();
         assert(run_count == 1);
         helper();
         assert(run_count == 2);
     }
+#else
+   void test() {}
+#endif
 }
 
 // Check that we can initialize a second value while initializing a first.
 namespace test3 {
     int zero() {
         return 0;
     }
 

libcxxabi/trunk/test/test_vector1.pass.cpp

 void count_construct ( void *p ) { ++gCounter; }
 void count_destruct  ( void *p ) { --gCounter; }
 
 
 int gConstructorCounter;
 int gConstructorThrowTarget;
 int gDestructorCounter;
 int gDestructorThrowTarget;
-void throw_construct ( void *p ) { if ( gConstructorCounter   == gConstructorThrowTarget ) throw 1; ++gConstructorCounter; }
-void throw_destruct  ( void *p ) { if ( ++gDestructorCounter  == gDestructorThrowTarget  ) throw 2; }
+void throw_construct ( void *p ) {
+#ifndef LIBCXXABI_HAS_NO_EXCEPTIONS
+    if ( gConstructorCounter   == gConstructorThrowTarget )
+        throw 1;
+    ++gConstructorCounter;
+#endif
+}
+void throw_destruct  ( void *p ) {
+#ifndef LIBCXXABI_HAS_NO_EXCEPTIONS
+    if ( ++gDestructorCounter  == gDestructorThrowTarget  )
+        throw 2;
+#endif
+}
 
 #if __cplusplus >= 201103L
 #   define CAN_THROW noexcept(false)
 #else
 #   define CAN_THROW
 #endif
 
 struct vec_on_stack {
if ( gCounter != 0 ) {
         std::cerr << "Mismatched Constructor/Destructor calls (2)" << std::endl;
         std::cerr << "  Expected 0, got " << gCounter << std::endl;
         retVal = 1;
         }
 
     return retVal;
     }
     
+#ifndef LIBCXXABI_HAS_NO_EXCEPTIONS
 //  Make sure the constructors and destructors are matched
 int test_exception_in_constructor ( ) {
     int retVal = 0;
     void *one, *two, *three;
 
 //  Try with no padding
     gConstructorCounter = gDestructorCounter = 0;
     gConstructorThrowTarget = 15;
if ( gConstructorCounter != gDestructorCounter ) {
         std::cerr << "Mismatched Constructor/Destructor calls (2C)" << std::endl;
         std::cerr << gConstructorCounter << " constructors, but " << 
                 gDestructorCounter << " destructors" << std::endl;
         retVal = 1;
         }
 
     return retVal;
     }
+#endif
 
+#ifndef LIBCXXABI_HAS_NO_EXCEPTIONS
 //  Make sure the constructors and destructors are matched
 int test_exception_in_destructor ( ) {
     int retVal = 0;
     void *one, *two, *three;
     one = two = three = NULL;
 
 //  Throw from within a destructor
     gConstructorCounter = gDestructorCounter = 0;
if ( gConstructorCounter != gDestructorCounter ) {
         std::cerr << "Mismatched Constructor/Destructor calls (2D)" << std::endl;
         std::cerr << gConstructorCounter << " constructors, but " << 
                 gDestructorCounter << " destructors" << std::endl;
         retVal = 1;
         }
 
     return retVal;
     }
+#endif
 
 int main ( int argc, char *argv [] ) {
     int retVal = 0;
     retVal += test_empty ();
     retVal += test_counted ();
+#ifndef LIBCXXABI_HAS_NO_EXCEPTIONS
     retVal += test_exception_in_constructor ();
     retVal += test_exception_in_destructor ();
+#endif
     return retVal;
     }

libcxxabi/trunk/test/test_vector2.pass.cpp

 //===--------------------------- test_vector2.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.
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcxxabi-no-exceptions
+
 #include "cxxabi.h"
 
 #include <iostream>
 #include <cstdlib>
 
 void my_terminate () { exit ( 0 ); }
 
 //  Wrapper routines

libcxxabi/trunk/test/test_vector3.pass.cpp

 //===------------------------- test_vector3.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.
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcxxabi-no-exceptions
+
 #include "cxxabi.h"
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <assert.h>
 #include <exception>
 
 #include <memory>

libcxxabi/trunk/test/uncaught_exceptions.pass.cpp

 //===------------------- uncaught_exceptions.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.
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcxxabi-no-exceptions
+
 #include <cxxabi.h>
 #include <exception>
 #include <cassert>
 
 // namespace __cxxabiv1 {
 //      extern bool          __cxa_uncaught_exception () throw();
 //      extern unsigned int  __cxa_uncaught_exceptions() throw();
 // }

libcxxabi/trunk/test/unwind_01.pass.cpp

 //===------------------------- unwind_01.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.
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcxxabi-no-exceptions
+
 #include <assert.h>
 
 struct A
 {
     static int count;
     int id_;
     A() : id_(++count) {}
     ~A() {assert(id_ == count--);}

libcxxabi/trunk/test/unwind_02.pass.cpp

 //===------------------------- unwind_02.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.
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcxxabi-no-exceptions
+
 #include <assert.h>
 
 struct A
 {
     static int count;
     int id_;
     A() : id_(++count) {}
     ~A() {assert(id_ == count--);}

libcxxabi/trunk/test/unwind_03.pass.cpp

 //===------------------------- unwind_03.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.
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcxxabi-no-exceptions
+
 #include <exception>
 #include <stdlib.h>
 #include <assert.h>
 
 struct A
 {
     static int count;
     int id_;

libcxxabi/trunk/test/unwind_04.pass.cpp

 //===------------------------- unwind_04.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.
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcxxabi-no-exceptions
+
 #include <exception>
 #include <stdlib.h>
 #include <assert.h>
 
 struct A
 {
     static int count;
     int id_;

libcxxabi/trunk/test/unwind_05.pass.cpp

 //===------------------------- unwind_05.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.
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcxxabi-no-exceptions
+
 #include <exception>
 #include <stdlib.h>
 #include <assert.h>
 
 struct A
 {
     static int count;
     int id_;

libcxxabi/trunk/test/unwind_06.pass.cpp

 //===------------------------- unwind_06.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.
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcxxabi-no-exceptions
+
 #include <exception>
 #include <stdlib.h>
 #include <assert.h>
 #include <stdio.h>
 
 // Compile with -Os to get compiler uses float registers to hold float variables
 
 double get_(int x) { return (double)x; }