* libsupc++/vec.cc: Include it.
(__cxa_vec_new2): Recatch exceptions before rethrows.
(__cxa_vec_new3): Likewise.
(__cxa_vec_ctor): Likewise.
(__cxa_vec_cctor): Likewise.
(__cxa_vec_dtor): Likewise.
(__cxa_vec_delete2): Likewise.
(__cxa_vec_delete3): Likewise.
git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@37551
138bc75d-0d04-0410-961f-
82ee72b054a4
+2000-11-18 Mark Mitchell <mark@codesourcery.com>
+
+ * libsupc++/exception_support.h: New header file.
+ * libsupc++/vec.cc: Include it.
+ (__cxa_vec_new2): Recatch exceptions before rethrows.
+ (__cxa_vec_new3): Likewise.
+ (__cxa_vec_ctor): Likewise.
+ (__cxa_vec_cctor): Likewise.
+ (__cxa_vec_dtor): Likewise.
+ (__cxa_vec_delete2): Likewise.
+ (__cxa_vec_delete3): Likewise.
+
2000-11-17 Theodore Papadopoulo <Theodore.Papadopoulo@sophia.inria.fr>
* include/bits/stl_tree.h: Overload operators == and != to be able
#include "typeinfo"
#include "exception"
#include <cstddef>
-#include "gansidecl.h" /* Needed to support macros used in eh-common.h. */
-#include "eh-common.h"
+#include "exception_support.h"
/* Define terminate, unexpected, set_terminate, set_unexpected as
well as the default terminate func and default unexpected func. */
__unexpected_func ();
}
-/* The type of a function called to clean up an exception object.
- (These will be destructors.) Under the old ABI, these take a
- second argument (the `in-charge' argument), that indicates whether
- or not do delete the object, and whether or not to destroy virtual
- bases. Under the new ABI, there is no second argument. */
-#if !defined (__GXX_ABI_VERSION) || __GXX_ABI_VERSION < 100
-typedef void (*cleanup_fn)(void *, int);
-/* The `2' is the value for the in-charge parameter that indicates
- that virtual bases should be destroyed. */
-#define CALL_CLEANUP(FN, THIS) FN (THIS, 2)
-#else
-typedef void (*cleanup_fn)(void *);
-#define CALL_CLEANUP(FN, THIS) FN (THIS)
-#endif
-
-/* C++-specific state about the current exception.
- This must match init_exception_processing().
-
- Note that handlers and caught are not redundant; when rethrown, an
- exception can have multiple active handlers and still be considered
- uncaught. */
-
-struct cp_eh_info
-{
- __eh_info eh_info;
- void *value;
- void *type;
- cleanup_fn cleanup;
- bool caught;
- cp_eh_info *next;
- long handlers;
- void *original_value;
-};
-
/* Language-specific EH info pointer, defined in libgcc2. */
extern "C" cp_eh_info **__get_eh_info (); // actually void **
/* We're doing a rethrow. Find the currently handled exception, mark it
uncaught, and move it to the top of the EH stack. */
-extern "C" void
+extern "C" cp_eh_info *
__uncatch_exception (void)
{
cp_eh_info **stack = __get_eh_info ();
}
p->caught = false;
+
+ return p;
+}
+
+/* Mark P as caught after we previously marked it as uncaught. */
+
+extern "C" void
+__recatch_exception (cp_eh_info *p)
+{
+ p->caught = true;
}
/* As per [except.unexpected]:
#include <new>
#include <exception>
-// Exception handling hook, to mark current exception as not caught --
-// generally because we're about to rethrow it after some cleanup.
-extern "C" void __uncatch_exception (void);
+#include "exception_support.h"
namespace __cxxabiv1
{
+namespace
+{
+struct uncatch_exception {
+ uncatch_exception () { p = __uncatch_exception (); }
+ ~uncatch_exception () { __recatch_exception (p); }
+
+ cp_eh_info *p;
+};
+}
+
/* allocate and construct array */
extern "C" void *
__cxa_vec_new (std::size_t element_count,
}
catch (...)
{
- __uncatch_exception ();
- dealloc (base - padding_size);
+ {
+ uncatch_exception ue;
+ dealloc (base - padding_size);
+ }
throw;
}
return base;
}
catch (...)
{
- __uncatch_exception ();
- dealloc (base - padding_size, size);
+ {
+ uncatch_exception ue;
+ dealloc (base - padding_size, size);
+ }
throw;
}
return base;
}
catch (...)
{
- __uncatch_exception ();
- __cxa_vec_dtor (array_address, ix, element_size, destructor);
+ {
+ uncatch_exception ue;
+ __cxa_vec_dtor (array_address, ix, element_size, destructor);
+ }
throw;
}
}
}
catch (...)
{
- __uncatch_exception ();
- __cxa_vec_dtor (dest_array, ix, element_size, destructor);
+ {
+ uncatch_exception ue;
+ __cxa_vec_dtor (dest_array, ix, element_size, destructor);
+ }
throw;
}
}
// [except.ctor]/3 If a destructor called during stack unwinding
// exits with an exception, terminate is called.
std::terminate ();
- __uncatch_exception ();
- __cxa_vec_dtor (array_address, ix, element_size, destructor);
+ {
+ uncatch_exception ue;
+ __cxa_vec_dtor (array_address, ix, element_size,
+ destructor);
+ }
throw;
}
}
}
catch (...)
{
- __uncatch_exception ();
- dealloc (base);
+ {
+ uncatch_exception ue;
+ dealloc (base);
+ }
throw;
}
}
}
catch (...)
{
- __uncatch_exception ();
- dealloc (base, size);
+ {
+ uncatch_exception ue;
+ dealloc (base, size);
+ }
throw;
}
}
OSDN Git Service
