[libc++abi] Add a silent terminate handler to libcxxabi.

[trybka]

Summary

The current std::terminate_handler pulls in some string code, some I/O
code, and more. Since it is automatically setup as the default, this means that
any trivial binary linking against libcxxabi will get this extra bloat.

On Android, debuggerd seems to actually handle unwinding and demangling, so
this code is unnecessary in certain cases. We would just like a way to turn it
off.

[danalbert]

debuggerd will give you a stack trace, but it won't give you the exception information.

My plan for making this a bit leaner was to make a non-demangling version (but one that still handled the exception stuff). iirc the demangler is by far the heaviest part of this, and that part people can definitely get by without.

[danalbert]

I talked this over with trybka on IM. There's precedent for a silent mode in libstdc++, and for his use case the debuggerd issues aren't actually a problem, so I think this is fine to go in. I'd also like a non-demangling version for the more generic Android case, but that doesn't need to be a part of this patch.

I'll defer to @EricWF to actually sign off, but this LGTM.

libcxxabi/trunk/CMakeLists.txt

if (MSVC)
   add_definitions(-D_CRT_SECURE_NO_WARNINGS)
 endif()
 
 # Define LIBCXXABI_USE_LLVM_UNWINDER for conditional compilation.
 if (LIBCXXABI_USE_LLVM_UNWINDER)
   add_definitions(-DLIBCXXABI_USE_LLVM_UNWINDER=1)
 endif()
 
+if (LIBCXXABI_SILENT_TERMINATE)
+  add_definitions(-DLIBCXXABI_SILENT_TERMINATE=1)
+endif()
+
 string(REPLACE ";" " " LIBCXXABI_CXX_FLAGS "${LIBCXXABI_CXX_FLAGS}")
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${LIBCXXABI_CXX_FLAGS}")
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${LIBCXXABI_C_FLAGS}")
 
 #===============================================================================
 # Setup Source Code
 #===============================================================================
 

libcxxabi/trunk/src/config.h

 
 // Set this in the CXXFLAGS when you need it, because otherwise we'd have to
 // #if !defined(__linux__) && !defined(__APPLE__) && ...
 // and so-on for *every* platform.
 #ifndef LIBCXXABI_BAREMETAL
 #  define LIBCXXABI_BAREMETAL 0
 #endif
 
+// The default terminate handler attempts to demangle uncaught exceptions, which
+// causes extra I/O and demangling code to be pulled in.
+// Set this to make the terminate handler default to a silent alternative.
+#ifndef LIBCXXABI_SILENT_TERMINATE
+#  define LIBCXXABI_SILENT_TERMINATE 0
+#endif
+
 #endif // LIBCXXABI_CONFIG_H

libcxxabi/trunk/src/cxa_default_handlers.cpp

 //===------------------------- cxa_default_handlers.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 default terminate_handler and unexpected_handler.
 //===----------------------------------------------------------------------===//
 
 #include <stdexcept>
 #include <new>
 #include <exception>
+#include <cstdlib>
 #include "abort_message.h"
 #include "config.h" // For __sync_swap
 #include "cxxabi.h"
 #include "cxa_handlers.hpp"
 #include "cxa_exception.hpp"
 #include "private_typeinfo.h"
 
 static const char* cause = "uncaught";
 
 __attribute__((noreturn))
-static void default_terminate_handler()
+static void demangling_terminate_handler()
 {
     // If there might be an uncaught exception
     using namespace __cxxabiv1;
     __cxa_eh_globals* globals = __cxa_get_globals_fast();
     if (globals)
     {
         __cxa_exception* exception_header = globals->caughtExceptions;
         // If there is an uncaught exception
if (globals)
                 abort_message("terminating with %s foreign exception", cause);
         }
     }
     // Else just note that we're terminating
     abort_message("terminating");
 }
 
 __attribute__((noreturn))
-static void default_unexpected_handler() 
+static void demangling_unexpected_handler()
 {
     cause = "unexpected";
     std::terminate();
 }
 
+#if !LIBCXXABI_SILENT_TERMINATE
+static std::terminate_handler default_terminate_handler = demangling_terminate_handler;
+static std::terminate_handler default_unexpected_handler = demangling_unexpected_handler;
+#else
+static std::terminate_handler default_terminate_handler = std::abort;
+static std::terminate_handler default_unexpected_handler = std::abort;
+#endif
 
 //
 // Global variables that hold the pointers to the current handler
 //
 _LIBCXXABI_DATA_VIS
 std::terminate_handler __cxa_terminate_handler = default_terminate_handler;
 
 _LIBCXXABI_DATA_VIS