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