1 //===------------------------- cxa_default_handlers.cpp -------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is dual licensed under the MIT and the University of Illinois Open 6 // Source Licenses. See LICENSE.TXT for details. 7 // 8 // 9 // This file implements the default terminate_handler and unexpected_handler. 10 //===----------------------------------------------------------------------===// 11 12 #include <stdexcept> 13 #include <new> 14 #include <exception> 15 #include <cstdlib> 16 #include "abort_message.h" 17 #include "cxxabi.h" 18 #include "cxa_handlers.hpp" 19 #include "cxa_exception.hpp" 20 #include "private_typeinfo.h" 21 22 static const char* cause = "uncaught"; 23 24 __attribute__((noreturn)) 25 static void demangling_terminate_handler() 26 { 27 // If there might be an uncaught exception 28 using namespace __cxxabiv1; 29 __cxa_eh_globals* globals = __cxa_get_globals_fast(); 30 if (globals) 31 { 32 __cxa_exception* exception_header = globals->caughtExceptions; 33 // If there is an uncaught exception 34 if (exception_header) 35 { 36 _Unwind_Exception* unwind_exception = 37 reinterpret_cast<_Unwind_Exception*>(exception_header + 1) - 1; 38 bool native_exception = 39 (unwind_exception->exception_class & get_vendor_and_language) == 40 (kOurExceptionClass & get_vendor_and_language); 41 if (native_exception) 42 { 43 void* thrown_object = 44 unwind_exception->exception_class == kOurDependentExceptionClass ? 45 ((__cxa_dependent_exception*)exception_header)->primaryException : 46 exception_header + 1; 47 const __shim_type_info* thrown_type = 48 static_cast<const __shim_type_info*>(exception_header->exceptionType); 49 // Try to get demangled name of thrown_type 50 int status; 51 char buf[1024]; 52 size_t len = sizeof(buf); 53 const char* name = __cxa_demangle(thrown_type->name(), buf, &len, &status); 54 if (status != 0) 55 name = thrown_type->name(); 56 // If the uncaught exception can be caught with std::exception& 57 const __shim_type_info* catch_type = 58 static_cast<const __shim_type_info*>(&typeid(std::exception)); 59 if (catch_type->can_catch(thrown_type, thrown_object)) 60 { 61 // Include the what() message from the exception 62 const std::exception* e = static_cast<const std::exception*>(thrown_object); 63 abort_message("terminating with %s exception of type %s: %s", 64 cause, name, e->what()); 65 } 66 else 67 // Else just note that we're terminating with an exception 68 abort_message("terminating with %s exception of type %s", 69 cause, name); 70 } 71 else 72 // Else we're terminating with a foreign exception 73 abort_message("terminating with %s foreign exception", cause); 74 } 75 } 76 // Else just note that we're terminating 77 abort_message("terminating"); 78 } 79 80 __attribute__((noreturn)) 81 static void demangling_unexpected_handler() 82 { 83 cause = "unexpected"; 84 std::terminate(); 85 } 86 87 #if !defined(LIBCXXABI_SILENT_TERMINATE) 88 static std::terminate_handler default_terminate_handler = demangling_terminate_handler; 89 static std::terminate_handler default_unexpected_handler = demangling_unexpected_handler; 90 #else 91 static std::terminate_handler default_terminate_handler = std::abort; 92 static std::terminate_handler default_unexpected_handler = std::terminate; 93 #endif 94 95 // 96 // Global variables that hold the pointers to the current handler 97 // 98 _LIBCXXABI_DATA_VIS 99 std::terminate_handler __cxa_terminate_handler = default_terminate_handler; 100 101 _LIBCXXABI_DATA_VIS 102 std::unexpected_handler __cxa_unexpected_handler = default_unexpected_handler; 103 104 // In the future these will become: 105 // std::atomic<std::terminate_handler> __cxa_terminate_handler(default_terminate_handler); 106 // std::atomic<std::unexpected_handler> __cxa_unexpected_handler(default_unexpected_handler); 107 108 namespace std 109 { 110 111 unexpected_handler 112 set_unexpected(unexpected_handler func) _NOEXCEPT 113 { 114 if (func == 0) 115 func = default_unexpected_handler; 116 return __atomic_exchange_n(&__cxa_unexpected_handler, func, 117 __ATOMIC_ACQ_REL); 118 // Using of C++11 atomics this should be rewritten 119 // return __cxa_unexpected_handler.exchange(func, memory_order_acq_rel); 120 } 121 122 terminate_handler 123 set_terminate(terminate_handler func) _NOEXCEPT 124 { 125 if (func == 0) 126 func = default_terminate_handler; 127 return __atomic_exchange_n(&__cxa_terminate_handler, func, 128 __ATOMIC_ACQ_REL); 129 // Using of C++11 atomics this should be rewritten 130 // return __cxa_terminate_handler.exchange(func, memory_order_acq_rel); 131 } 132 133 } 134
