1// -*- C++ -*- std::exception implementation.
2// Copyright (C) 1994-2017 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 <cxxabi.h>
28
29std::exception::~exception() _GLIBCXX_TXN_SAFE_DYN _GLIBCXX_USE_NOEXCEPT { }
30
31std::bad_exception::~bad_exception() _GLIBCXX_TXN_SAFE_DYN
32 _GLIBCXX_USE_NOEXCEPT
33{ }
34
35abi::__forced_unwind::~__forced_unwind() throw() { }
36
37abi::__foreign_exception::~__foreign_exception() throw() { }
38
39const char*
40std::exception::what() const _GLIBCXX_TXN_SAFE_DYN _GLIBCXX_USE_NOEXCEPT
41{
42 // NB: Another elegant option would be returning typeid(*this).name()
43 // and not overriding what() in bad_exception, bad_alloc, etc. In
44 // that case, however, mangled names would be returned, PR 14493.
45 return "std::exception";
46}
47
48const char*
49std::bad_exception::what() const _GLIBCXX_TXN_SAFE_DYN _GLIBCXX_USE_NOEXCEPT
50{
51 return "std::bad_exception";
52}
53
54// Transactional clones for the destructors and what().
55// what() is effectively transaction_pure, but we do not want to annotate it
56// as such; thus, we call exactly the respective nontransactional function.
57extern "C" {
58
59void
60_ZGTtNKSt9exceptionD1Ev(const std::exception*)
61{ }
62
63const char*
64_ZGTtNKSt9exception4whatEv(const std::exception* that)
65{
66 // We really want the non-virtual call here. We already executed the
67 // indirect call representing the virtual call, and the TM runtime or the
68 // compiler resolved it to this transactional clone. In the clone, we want
69 // to do the same as for the nontransactional original, so we just call it.
70 return that->std::exception::what();
71}
72
73void
74_ZGTtNKSt13bad_exceptionD1Ev(
75 const std::bad_exception*)
76{ }
77
78const char*
79_ZGTtNKSt13bad_exception4whatEv(
80 const std::bad_exception* that)
81{
82 // Also see _ZGTtNKSt9exception4whatEv.
83 return that->std::bad_exception::what();
84}
85
86}
87