Home | History | Annotate | Download | only in src 
      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 "abort_message.h"
     16 #include "config.h" // For __sync_swap
     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 default_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 default_unexpected_handler()
     82 {
     83     cause = "unexpected";
     84     std::terminate();
     85 }
     86 
     87 
     88 //
     89 // Global variables that hold the pointers to the current handler
     90 //
     91 std::terminate_handler  __cxa_terminate_handler = default_terminate_handler;
     92 std::unexpected_handler __cxa_unexpected_handler = default_unexpected_handler;
     93 
     94 // In the future these will become:
     95 // std::atomic<std::terminate_handler>  __cxa_terminate_handler(default_terminate_handler);
     96 // std::atomic<std::unexpected_handler> __cxa_unexpected_handler(default_unexpected_handler);
     97 
     98 namespace std
     99 {
    100 
    101 unexpected_handler
    102 set_unexpected(unexpected_handler func) _NOEXCEPT
    103 {
    104     if (func == 0)
    105         func = default_unexpected_handler;
    106     return __atomic_exchange_n(&__cxa_unexpected_handler, func,
    107                                __ATOMIC_ACQ_REL);
    108 //  Using of C++11 atomics this should be rewritten
    109 //  return __cxa_unexpected_handler.exchange(func, memory_order_acq_rel);
    110 }
    111 
    112 terminate_handler
    113 set_terminate(terminate_handler func) _NOEXCEPT
    114 {
    115     if (func == 0)
    116         func = default_terminate_handler;
    117     return __atomic_exchange_n(&__cxa_terminate_handler, func,
    118                                __ATOMIC_ACQ_REL);
    119 //  Using of C++11 atomics this should be rewritten
    120 //  return __cxa_terminate_handler.exchange(func, memory_order_acq_rel);
    121 }
    122 
    123 }
    124