1 // Functions for Exception Support for -*- C++ -*-
2 // Copyright (C) 1994, 1995, 1996, 1998 Free Software Foundation
4 // This file is part of GNU CC.
6 // GNU CC 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 2, or (at your option)
11 // GNU CC 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.
16 // You should have received a copy of the GNU General Public License
17 // along with GNU CC; see the file COPYING. If not, write to
18 // the Free Software Foundation, 59 Temple Place - Suite 330,
19 // Boston, MA 02111-1307, USA.
21 // As a special exception, if you link this library with other files,
22 // some of which are compiled with GCC, to produce an executable,
23 // this library does not by itself cause the resulting executable
24 // to be covered by the GNU General Public License.
25 // This exception does not however invalidate any other reasons why
26 // the executable file might be covered by the GNU General Public License.
28 #pragma implementation "exception"
33 #include "eh-common.h"
35 /* Define terminate, unexpected, set_terminate, set_unexpected as
36 well as the default terminate func and default unexpected func. */
38 extern std::terminate_handler __terminate_func
__attribute__((__noreturn__
));
48 __default_unexpected ()
53 static std::unexpected_handler __unexpected_func
__attribute__((__noreturn__
))
54 = __default_unexpected
;
56 std::terminate_handler
57 std::set_terminate (std::terminate_handler func
)
59 std::terminate_handler old
= __terminate_func
;
61 __terminate_func
= func
;
65 std::unexpected_handler
66 std::set_unexpected (std::unexpected_handler func
)
68 std::unexpected_handler old
= __unexpected_func
;
70 __unexpected_func
= func
;
80 /* C++-specific state about the current exception.
81 This must match init_exception_processing().
83 Note that handlers and caught are not redundant; when rethrown, an
84 exception can have multiple active handlers and still be considered
92 void (*cleanup
)(void *, int);
99 /* Language-specific EH info pointer, defined in libgcc2. */
101 extern "C" cp_eh_info
**__get_eh_info (); // actually void **
103 /* Is P the type_info node for a pointer of some kind? */
105 extern bool __is_pointer (void *);
108 /* OLD Compiler hook to return a pointer to the info for the current exception.
109 Used by get_eh_info (). This fudges the actualy returned value to
110 point to the beginning of what USE to be the cp_eh_info structure.
111 THis is so that old code that dereferences this pointer will find
112 things where it expects it to be.*/
114 __cp_exception_info (void)
116 return &((*__get_eh_info ())->value
);
119 /* Compiler hook to return a pointer to the info for the current exception.
120 Used by get_eh_info (). */
122 extern "C" cp_eh_info
*
125 return *__get_eh_info ();
128 /* Allocate a buffer for a cp_eh_info and an exception object of size SIZE,
129 and return a pointer to the beginning of the object's space. */
131 extern "C" void * malloc (size_t);
133 __eh_alloc (size_t size
)
135 void *p
= malloc (size
);
141 /* Free the memory for an cp_eh_info and associated exception, given
142 a pointer to the cp_eh_info. */
144 extern "C" void free (void *);
152 typedef void * (* rtimetype
) (void);
155 __cplus_type_matcher (cp_eh_info
*info
, rtimetype match_info
,
156 exception_descriptor
*exception_table
)
160 if (exception_table
->lang
.language
!= EH_LANG_C_plus_plus
)
163 if (match_info
== CATCH_ALL_TYPE
)
166 /* we don't worry about version info yet, there is only one version! */
168 void *match_type
= match_info ();
169 ret
= __throw_type_match_rtti (match_type
, info
->type
, info
->original_value
);
170 /* change value of exception */
177 /* Compiler hook to push a new exception onto the stack.
178 Used by expand_throw(). */
181 __cp_push_exception (void *value
, void *type
, void (*cleanup
)(void *, int))
183 cp_eh_info
*p
= (cp_eh_info
*) __eh_alloc (sizeof (cp_eh_info
));
187 p
->cleanup
= cleanup
;
190 p
->original_value
= value
;
192 p
->eh_info
.match_function
= __cplus_type_matcher
;
193 p
->eh_info
.language
= EH_LANG_C_plus_plus
;
194 p
->eh_info
.version
= 1;
196 cp_eh_info
**q
= __get_eh_info ();
202 /* Compiler hook to pop an exception that has been finalized. Used by
203 push_eh_cleanup(). P is the info for the exception caught by the
204 current catch block. */
207 __cp_pop_exception (cp_eh_info
*p
)
209 cp_eh_info
**q
= __get_eh_info ();
213 /* Don't really pop if there are still active handlers for our exception,
214 or if our exception is being rethrown (i.e. if the active exception is
215 our exception and it is uncaught). */
217 || (p
== *q
&& !p
->caught
))
220 for (; *q
; q
= &((*q
)->next
))
230 /* 2 is a magic value for destructors; see build_delete(). */
231 p
->cleanup (p
->value
, 2);
233 if (! __is_pointer (p
->type
))
234 __eh_free (p
->value
);
240 __uncatch_exception (void)
242 cp_eh_info
*p
= __cp_eh_info ();
248 /* As per [except.unexpected]:
249 If an exception is thrown, we check it against the spec. If it doesn't
250 match, we call unexpected (). If unexpected () throws, we check that
251 exception against the spec. If it doesn't match, if the spec allows
252 bad_exception we throw that; otherwise we call terminate ().
254 The compiler treats an exception spec as a try block with a generic
255 handler that just calls this function with a list of the allowed
256 exception types, so we have an active exception that can be rethrown.
258 This function does not return. */
261 __check_eh_spec (int n
, const void **spec
)
263 cp_eh_info
*p
= __cp_eh_info ();
265 for (int i
= 0; i
< n
; ++i
)
267 if (__throw_type_match_rtti (spec
[i
], p
->type
, p
->value
))
277 // __exception_info is an artificial var pushed into each catch block.
278 if (p
!= __exception_info
)
280 p
= __exception_info
;
281 for (int i
= 0; i
< n
; ++i
)
283 if (__throw_type_match_rtti (spec
[i
], p
->type
, p
->value
))
288 const std::type_info
&bad_exc
= typeid (std::bad_exception
);
289 for (int i
= 0; i
< n
; ++i
)
291 if (__throw_type_match_rtti (spec
[i
], &bad_exc
, p
->value
))
292 throw std::bad_exception ();
300 __throw_bad_cast (void)
302 throw std::bad_cast ();
306 __throw_bad_typeid (void)
308 throw std::bad_typeid ();
311 /* Has the current exception been caught? */
314 std::uncaught_exception ()
316 cp_eh_info
*p
= __cp_eh_info ();
317 return p
&& ! p
->caught
;
320 const char * std::exception::
323 return typeid (*this).name ();