libstdc++-v3/libsupc++/eh_terminate.cc

   1 // -*- C++ -*- std::terminate, std::unexpected and friends.
   2 // Copyright (C) 1994-2018 Free Software Foundation, Inc.
   3 //
   4 // This file is part of GCC.
   5 //
   6 // GCC is free software; you can redistribute it and/or modify
   7 // it under the terms of the GNU General Public License as published by
   8 // the Free Software Foundation; either version 3, or (at your option)
   9 // any later version.
  10 //
  11 // GCC is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15 //
  16 // Under Section 7 of GPL version 3, you are granted additional
  17 // permissions described in the GCC Runtime Library Exception, version
  18 // 3.1, as published by the Free Software Foundation.
  19
  20 // You should have received a copy of the GNU General Public License and
  21 // a copy of the GCC Runtime Library Exception along with this program;
  22 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  23 // <http://www.gnu.org/licenses/>.
  24
  25 #include "typeinfo"
  26 #include "exception"
  27 #include <cstdlib>
  28 #include "unwind-cxx.h"
  29 #include <bits/exception_defines.h>
  30 #include <bits/atomic_lockfree_defines.h>
  31
  32 #if ATOMIC_POINTER_LOCK_FREE < 2
  33 #include <ext/concurrence.h>
  34 namespace
  35 {
  36   __gnu_cxx::__mutex mx;
  37 }
  38 #endif
  39
  40 using namespace __cxxabiv1;
  41
  42 void
  43 __cxxabiv1::__terminate (std::terminate_handler handler) throw ()
  44 {
  45   __try
  46     {
  47       handler ();
  48       std::abort ();
  49     }
  50   __catch(...)
  51     { std::abort (); }
  52 }
  53
  54 void
  55 std::terminate () throw()
  56 {
  57   __terminate (get_terminate ());
  58 }
  59
  60 void
  61 __cxxabiv1::__unexpected (std::unexpected_handler handler)
  62 {
  63   handler();
  64   std::terminate ();
  65 }
  66
  67 void
  68 std::unexpected ()
  69 {
  70   __unexpected (get_unexpected ());
  71 }
  72
  73 std::terminate_handler
  74 std::set_terminate (std::terminate_handler func) throw()
  75 {
  76   std::terminate_handler old;
  77 #if ATOMIC_POINTER_LOCK_FREE > 1
  78   __atomic_exchange (&__terminate_handler, &func, &old, __ATOMIC_ACQ_REL);
  79 #else
  80   __gnu_cxx::__scoped_lock l(mx);
  81   old = __terminate_handler;
  82   __terminate_handler = func;
  83 #endif
  84   return old;
  85 }
  86
  87 std::terminate_handler
  88 std::get_terminate () noexcept
  89 {
  90   std::terminate_handler func;
  91 #if ATOMIC_POINTER_LOCK_FREE > 1
  92   __atomic_load (&__terminate_handler, &func, __ATOMIC_ACQUIRE);
  93 #else
  94   __gnu_cxx::__scoped_lock l(mx);
  95   func = __terminate_handler;
  96 #endif
  97   return func;
  98 }
  99
 100 std::unexpected_handler
 101 std::set_unexpected (std::unexpected_handler func) throw()
 102 {
 103   std::unexpected_handler old;
 104 #if ATOMIC_POINTER_LOCK_FREE > 1
 105   __atomic_exchange (&__unexpected_handler, &func, &old, __ATOMIC_ACQ_REL);
 106 #else
 107   __gnu_cxx::__scoped_lock l(mx);
 108   old = __unexpected_handler;
 109   __unexpected_handler = func;
 110 #endif
 111   return old;
 112 }
 113
 114 std::unexpected_handler
 115 std::get_unexpected () noexcept
 116 {
 117   std::unexpected_handler func;
 118 #if ATOMIC_POINTER_LOCK_FREE > 1
 119   __atomic_load (&__unexpected_handler, &func, __ATOMIC_ACQUIRE);
 120 #else
 121   __gnu_cxx::__scoped_lock l(mx);
 122   func = __unexpected_handler;
 123 #endif
 124   return func;
 125 }