1 //===------------------------ exception.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 #include <stdlib.h>
10 #include <stdio.h>
11 
12 #include "exception"
13 #include "new"
14 
15 #if defined(_LIBCPP_ABI_MICROSOFT)
16 #include <eh.h>
17 #include <corecrt_terminate.h>
18 #elif defined(__APPLE__) && !defined(LIBCXXRT) && \
19     !defined(_LIBCPP_BUILDING_HAS_NO_ABI_LIBRARY)
20   #include <cxxabi.h>
21 
22   using namespace __cxxabiv1;
23   #define HAVE_DEPENDENT_EH_ABI 1
24   #ifndef _LIBCPPABI_VERSION
25     using namespace __cxxabiapple;
26     // On Darwin, there are two STL shared libraries and a lower level ABI
27     // shared library.  The globals holding the current terminate handler and
28     // current unexpected handler are in the ABI library.
29     #define __terminate_handler  __cxxabiapple::__cxa_terminate_handler
30     #define __unexpected_handler __cxxabiapple::__cxa_unexpected_handler
31   #endif  // _LIBCPPABI_VERSION
32 #elif defined(LIBCXXRT) || defined(LIBCXX_BUILDING_LIBCXXABI)
33   #include <cxxabi.h>
34   using namespace __cxxabiv1;
35   #if defined(LIBCXXRT) || defined(_LIBCPPABI_VERSION)
36     #define HAVE_DEPENDENT_EH_ABI 1
37   #endif
38 #elif !defined(__GLIBCXX__) // defined(LIBCXX_BUILDING_LIBCXXABI)
39   _LIBCPP_SAFE_STATIC static std::terminate_handler  __terminate_handler;
40   _LIBCPP_SAFE_STATIC static std::unexpected_handler __unexpected_handler;
41 #endif // defined(LIBCXX_BUILDING_LIBCXXABI)
42 
43 namespace std
44 {
45 
46 #if !defined(LIBCXXRT) && !defined(_LIBCPPABI_VERSION) && !defined(__GLIBCXX__)
47 
48 // libcxxrt provides implementations of these functions itself.
49 unexpected_handler
50 set_unexpected(unexpected_handler func) _NOEXCEPT
51 {
52 #if defined(_LIBCPP_ABI_MICROSOFT)
53   return ::set_unexpected(func);
54 #else
55   return __sync_lock_test_and_set(&__unexpected_handler, func);
56 #endif
57 }
58 
59 unexpected_handler
60 get_unexpected() _NOEXCEPT
61 {
62 #if defined(_LIBCPP_ABI_MICROSOFT)
63   return ::_get_unexpected();
64 #else
65   return __sync_fetch_and_add(&__unexpected_handler, (unexpected_handler)0);
66 #endif
67 }
68 
69 _LIBCPP_NORETURN
70 void
71 unexpected()
72 {
73     (*get_unexpected())();
74     // unexpected handler should not return
75     terminate();
76 }
77 
78 terminate_handler
79 set_terminate(terminate_handler func) _NOEXCEPT
80 {
81 #if defined(_LIBCPP_ABI_MICROSOFT)
82   return ::set_terminate(func);
83 #else
84   return __sync_lock_test_and_set(&__terminate_handler, func);
85 #endif
86 }
87 
88 terminate_handler
89 get_terminate() _NOEXCEPT
90 {
91 #if defined(_LIBCPP_ABI_MICROSOFT)
92   return ::_get_terminate();
93 #else
94   return __sync_fetch_and_add(&__terminate_handler, (terminate_handler)0);
95 #endif
96 }
97 
98 #ifndef __EMSCRIPTEN__ // We provide this in JS
99 _LIBCPP_NORETURN
100 void
101 terminate() _NOEXCEPT
102 {
103 #ifndef _LIBCPP_NO_EXCEPTIONS
104     try
105     {
106 #endif  // _LIBCPP_NO_EXCEPTIONS
107         (*get_terminate())();
108         // handler should not return
109         fprintf(stderr, "terminate_handler unexpectedly returned\n");
110         ::abort();
111 #ifndef _LIBCPP_NO_EXCEPTIONS
112     }
113     catch (...)
114     {
115         // handler should not throw exception
116         fprintf(stderr, "terminate_handler unexpectedly threw an exception\n");
117         ::abort();
118     }
119 #endif  // _LIBCPP_NO_EXCEPTIONS
120 }
121 #endif // !__EMSCRIPTEN__
122 #endif // !defined(LIBCXXRT) && !defined(_LIBCPPABI_VERSION)
123 
124 #if !defined(LIBCXXRT) && !defined(__GLIBCXX__) && !defined(__EMSCRIPTEN__)
125 
126 bool uncaught_exception() _NOEXCEPT { return uncaught_exceptions() > 0; }
127 
128 int uncaught_exceptions() _NOEXCEPT
129 {
130 #if !defined(_LIBCPP_BUILDING_HAS_NO_ABI_LIBRARY) && \
131     (defined(__APPLE__) || defined(_LIBCPPABI_VERSION))
132    // on Darwin, there is a helper function so __cxa_get_globals is private
133 # if _LIBCPPABI_VERSION > 1101
134     return __cxa_uncaught_exceptions();
135 # else
136     return __cxa_uncaught_exception() ? 1 : 0;
137 # endif
138 #elif defined(_LIBCPP_ABI_MICROSOFT)
139     return __uncaught_exceptions();
140 #else
141 #   if defined(_MSC_VER) && ! defined(__clang__)
142         _LIBCPP_WARNING("uncaught_exceptions not yet implemented")
143 #   else
144 #       warning uncaught_exception not yet implemented
145 #   endif
146     fprintf(stderr, "uncaught_exceptions not yet implemented\n");
147     ::abort();
148 #endif  // __APPLE__
149 }
150 
151 
152 #ifndef _LIBCPPABI_VERSION
153 
154 exception::~exception() _NOEXCEPT
155 {
156 }
157 
158 const char* exception::what() const _NOEXCEPT
159 {
160   return "std::exception";
161 }
162 
163 #endif  // _LIBCPPABI_VERSION
164 #endif //LIBCXXRT
165 #if !defined(_LIBCPPABI_VERSION) && !defined(__GLIBCXX__)
166 
167 bad_exception::~bad_exception() _NOEXCEPT
168 {
169 }
170 
171 const char* bad_exception::what() const _NOEXCEPT
172 {
173   return "std::bad_exception";
174 }
175 
176 #endif
177 
178 #if defined(__GLIBCXX__)
179 
180 // libsupc++ does not implement the dependent EH ABI and the functionality
181 // it uses to implement std::exception_ptr (which it declares as an alias of
182 // std::__exception_ptr::exception_ptr) is not directly exported to clients. So
183 // we have little choice but to hijack std::__exception_ptr::exception_ptr's
184 // (which fortunately has the same layout as our std::exception_ptr) copy
185 // constructor, assignment operator and destructor (which are part of its
186 // stable ABI), and its rethrow_exception(std::__exception_ptr::exception_ptr)
187 // function.
188 
189 namespace __exception_ptr
190 {
191 
192 struct exception_ptr
193 {
194     void* __ptr_;
195 
196     exception_ptr(const exception_ptr&) _NOEXCEPT;
197     exception_ptr& operator=(const exception_ptr&) _NOEXCEPT;
198     ~exception_ptr() _NOEXCEPT;
199 };
200 
201 }
202 
203 _LIBCPP_NORETURN void rethrow_exception(__exception_ptr::exception_ptr);
204 
205 #endif
206 
207 exception_ptr::~exception_ptr() _NOEXCEPT
208 {
209 #if HAVE_DEPENDENT_EH_ABI
210     __cxa_decrement_exception_refcount(__ptr_);
211 #elif defined(__GLIBCXX__)
212     reinterpret_cast<__exception_ptr::exception_ptr*>(this)->~exception_ptr();
213 #else
214 #   if defined(_MSC_VER) && ! defined(__clang__)
215         _LIBCPP_WARNING("exception_ptr not yet implemented")
216 #   else
217 #       warning exception_ptr not yet implemented
218 #   endif
219     fprintf(stderr, "exception_ptr not yet implemented\n");
220     ::abort();
221 #endif
222 }
223 
224 exception_ptr::exception_ptr(const exception_ptr& other) _NOEXCEPT
225     : __ptr_(other.__ptr_)
226 {
227 #if HAVE_DEPENDENT_EH_ABI
228     __cxa_increment_exception_refcount(__ptr_);
229 #elif defined(__GLIBCXX__)
230     new (reinterpret_cast<void*>(this)) __exception_ptr::exception_ptr(
231         reinterpret_cast<const __exception_ptr::exception_ptr&>(other));
232 #else
233 #   if defined(_MSC_VER) && ! defined(__clang__)
234         _LIBCPP_WARNING("exception_ptr not yet implemented")
235 #   else
236 #       warning exception_ptr not yet implemented
237 #   endif
238     fprintf(stderr, "exception_ptr not yet implemented\n");
239     ::abort();
240 #endif
241 }
242 
243 exception_ptr& exception_ptr::operator=(const exception_ptr& other) _NOEXCEPT
244 {
245 #if HAVE_DEPENDENT_EH_ABI
246     if (__ptr_ != other.__ptr_)
247     {
248         __cxa_increment_exception_refcount(other.__ptr_);
249         __cxa_decrement_exception_refcount(__ptr_);
250         __ptr_ = other.__ptr_;
251     }
252     return *this;
253 #elif defined(__GLIBCXX__)
254     *reinterpret_cast<__exception_ptr::exception_ptr*>(this) =
255         reinterpret_cast<const __exception_ptr::exception_ptr&>(other);
256     return *this;
257 #else
258 #   if defined(_MSC_VER) && ! defined(__clang__)
259         _LIBCPP_WARNING("exception_ptr not yet implemented")
260 #   else
261 #       warning exception_ptr not yet implemented
262 #   endif
263     fprintf(stderr, "exception_ptr not yet implemented\n");
264     ::abort();
265 #endif
266 }
267 
268 nested_exception::nested_exception() _NOEXCEPT
269     : __ptr_(current_exception())
270 {
271 }
272 
273 #if !defined(__GLIBCXX__)
274 
275 nested_exception::~nested_exception() _NOEXCEPT
276 {
277 }
278 
279 #endif
280 
281 _LIBCPP_NORETURN
282 void
283 nested_exception::rethrow_nested() const
284 {
285     if (__ptr_ == nullptr)
286         terminate();
287     rethrow_exception(__ptr_);
288 }
289 
290 #if !defined(__GLIBCXX__)
291 
292 exception_ptr current_exception() _NOEXCEPT
293 {
294 #if HAVE_DEPENDENT_EH_ABI
295     // be nicer if there was a constructor that took a ptr, then
296     // this whole function would be just:
297     //    return exception_ptr(__cxa_current_primary_exception());
298     exception_ptr ptr;
299     ptr.__ptr_ = __cxa_current_primary_exception();
300     return ptr;
301 #else
302 #   if defined(_MSC_VER) && ! defined(__clang__)
303         _LIBCPP_WARNING( "exception_ptr not yet implemented" )
304 #   else
305 #       warning exception_ptr not yet implemented
306 #   endif
307     fprintf(stderr, "exception_ptr not yet implemented\n");
308     ::abort();
309 #endif
310 }
311 
312 #endif  // !__GLIBCXX__
313 
314 _LIBCPP_NORETURN
315 void rethrow_exception(exception_ptr p)
316 {
317 #if HAVE_DEPENDENT_EH_ABI
318     __cxa_rethrow_primary_exception(p.__ptr_);
319     // if p.__ptr_ is NULL, above returns so we terminate
320     terminate();
321 #elif defined(__GLIBCXX__)
322     rethrow_exception(reinterpret_cast<__exception_ptr::exception_ptr&>(p));
323 #else
324 #   if defined(_MSC_VER) && ! defined(__clang__)
325         _LIBCPP_WARNING("exception_ptr not yet implemented")
326 #   else
327 #       warning exception_ptr not yet implemented
328 #   endif
329     fprintf(stderr, "exception_ptr not yet implemented\n");
330     ::abort();
331 #endif
332 }
333 } // std
334