--- /dev/null
+// Functions for Exception Support for -*- C++ -*-
+// Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000 Free Software Foundation
+
+// This file is part of GNU CC.
+
+// GNU CC is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// GNU CC is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with GNU CC; see the file COPYING. If not, write to
+// the Free Software Foundation, 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction. Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License. This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+#pragma implementation "exception"
+
+#include "typeinfo"
+#include "exception"
+#include <stddef.h>
+#include "gansidecl.h" /* Needed to support macros used in eh-common.h. */
+#include "eh-common.h"
+
+/* Define terminate, unexpected, set_terminate, set_unexpected as
+ well as the default terminate func and default unexpected func. */
+
+extern std::terminate_handler __terminate_func __attribute__((__noreturn__));
+using std::terminate;
+
+void
+std::terminate ()
+{
+ __terminate_func ();
+}
+
+void
+__default_unexpected ()
+{
+ terminate ();
+}
+
+static std::unexpected_handler __unexpected_func __attribute__((__noreturn__))
+ = __default_unexpected;
+
+std::terminate_handler
+std::set_terminate (std::terminate_handler func)
+{
+ std::terminate_handler old = __terminate_func;
+
+ __terminate_func = func;
+ return old;
+}
+
+std::unexpected_handler
+std::set_unexpected (std::unexpected_handler func)
+{
+ std::unexpected_handler old = __unexpected_func;
+
+ __unexpected_func = func;
+ return old;
+}
+
+void
+std::unexpected ()
+{
+ __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 **
+
+/* Exception allocate and free, defined in libgcc2. */
+extern "C" void *__eh_alloc(size_t);
+extern "C" void __eh_free(void *);
+
+/* Is P the type_info node for a pointer of some kind? */
+
+extern bool __is_pointer (void *);
+
+
+/* OLD Compiler hook to return a pointer to the info for the current exception.
+ Used by get_eh_info (). This fudges the actualy returned value to
+ point to the beginning of what USE to be the cp_eh_info structure.
+ THis is so that old code that dereferences this pointer will find
+ things where it expects it to be.*/
+extern "C" void *
+__cp_exception_info (void)
+{
+ return &((*__get_eh_info ())->value);
+}
+
+#define CP_EH_INFO ((cp_eh_info *) *__get_eh_info ())
+
+/* Old Compiler hook to return a pointer to the info for the current exception.
+ Used by get_eh_info (). */
+
+extern "C" cp_eh_info *
+__cp_eh_info (void)
+{
+ cp_eh_info *p = CP_EH_INFO;
+ return p;
+}
+
+/* Compiler hook to return a pointer to the info for the current exception,
+ Set the caught bit, and increment the number of handlers that are
+ looking at this exception. This makes handlers smaller. */
+
+extern "C" cp_eh_info *
+__start_cp_handler (void)
+{
+ cp_eh_info *p = CP_EH_INFO;
+ p->caught = 1;
+ p->handlers++;
+ return p;
+}
+
+extern "C" int __throw_type_match_rtti_2 (const void *, const void *,
+ void *, void **);
+
+extern "C" void *
+__cplus_type_matcher (__eh_info *info_, void *match_info,
+ exception_descriptor *exception_table)
+{
+ cp_eh_info *info = (cp_eh_info *)info_;
+
+ /* No exception table implies the old style mechanism, so don't check. */
+ if (exception_table != NULL
+ && exception_table->lang.language != EH_LANG_C_plus_plus)
+ return NULL;
+
+ if (match_info == CATCH_ALL_TYPE)
+ return (void *)1;
+
+ /* we don't worry about version info yet, there is only one version! */
+
+ void *match_type = match_info;
+
+#if !defined (__GXX_ABI_VERSION) || __GXX_ABI_VERSION < 100
+ match_type = ((void *(*)())match_type) ();
+#endif
+
+ if (__throw_type_match_rtti_2 (match_type, info->type,
+ info->original_value, &info->value))
+ // Arbitrary non-null pointer.
+ return (void *)1;
+ else
+ return NULL;
+}
+
+/* Compiler hook to push a new exception onto the stack.
+ Used by expand_throw(). */
+
+extern "C" void
+__cp_push_exception (void *value, void *type, cleanup_fn cleanup)
+{
+ cp_eh_info *p = (cp_eh_info *) __eh_alloc (sizeof (cp_eh_info));
+
+ p->value = value;
+ p->type = type;
+ p->cleanup = cleanup;
+ p->handlers = 0;
+ p->caught = false;
+ p->original_value = value;
+
+ p->eh_info.match_function = __cplus_type_matcher;
+ p->eh_info.language = EH_LANG_C_plus_plus;
+ p->eh_info.version = 1;
+
+ cp_eh_info **q = __get_eh_info ();
+
+ p->next = *q;
+ *q = p;
+}
+
+/* Compiler hook to pop an exception that has been finalized. Used by
+ push_eh_cleanup(). P is the info for the exception caught by the
+ current catch block. */
+
+extern "C" void
+__cp_pop_exception (cp_eh_info *p)
+{
+ cp_eh_info **stack = __get_eh_info ();
+ cp_eh_info **q = stack;
+
+ --p->handlers;
+
+ /* Do nothing if our exception is being rethrown (i.e. if the active
+ exception is our exception and it is uncaught). */
+ if (p == *q && !p->caught)
+ return;
+
+ /* Don't really pop if there are still active handlers for our exception;
+ rather, push it down past any uncaught exceptions. */
+ if (p->handlers != 0)
+ {
+ if (p == *q && p->next && !p->next->caught)
+ {
+ q = &(p->next);
+ while (1)
+ {
+ if (*q == 0 || (*q)->caught)
+ break;
+
+ q = &((*q)->next);
+ }
+ *stack = p->next;
+ p->next = *q;
+ *q = p;
+ }
+ return;
+ }
+
+ for (; *q; q = &((*q)->next))
+ if (*q == p)
+ break;
+
+ if (! *q)
+ terminate ();
+
+ *q = p->next;
+
+ if (p->cleanup)
+ // value may have been adjusted.
+ CALL_CLEANUP (p->cleanup, p->original_value);
+
+ if (! __is_pointer (p->type))
+ __eh_free (p->original_value); // value may have been adjusted.
+
+ __eh_free (p);
+}
+
+/* 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
+__uncatch_exception (void)
+{
+ cp_eh_info **stack = __get_eh_info ();
+ cp_eh_info **q = stack;
+ cp_eh_info *p;
+
+ while (1)
+ {
+ p = *q;
+
+ if (p == 0)
+ terminate ();
+ if (p->caught)
+ break;
+
+ q = &(p->next);
+ }
+
+ if (q != stack)
+ {
+ *q = p->next;
+ p->next = *stack;
+ *stack = p;
+ }
+
+ p->caught = false;
+}
+
+/* As per [except.unexpected]:
+ If an exception is thrown, we check it against the spec. If it doesn't
+ match, we call unexpected (). If unexpected () throws, we check that
+ exception against the spec. If it doesn't match, if the spec allows
+ bad_exception we throw that; otherwise we call terminate ().
+
+ The compiler treats an exception spec as a try block with a generic
+ handler that just calls this function with a list of the allowed
+ exception types, so we have an active exception that can be rethrown.
+
+ This function does not return. */
+
+extern "C" void
+__check_eh_spec (int n, const void **spec)
+{
+ cp_eh_info *p = CP_EH_INFO;
+ void *d;
+
+ for (int i = 0; i < n; ++i)
+ {
+ if (__throw_type_match_rtti_2 (spec[i], p->type, p->value, &d))
+ throw;
+ }
+
+ try
+ {
+ std::unexpected ();
+ }
+ catch (...)
+ {
+ // __exception_info is an artificial var pushed into each catch block.
+ if (p != __exception_info)
+ {
+ p = __exception_info;
+ for (int i = 0; i < n; ++i)
+ {
+ if (__throw_type_match_rtti_2 (spec[i], p->type, p->value, &d))
+ throw;
+ }
+ }
+
+ const std::type_info &bad_exc = typeid (std::bad_exception);
+ for (int i = 0; i < n; ++i)
+ {
+ if (__throw_type_match_rtti_2 (spec[i], &bad_exc, p->value, &d))
+ throw std::bad_exception ();
+ }
+
+ terminate ();
+ }
+}
+
+/* Special case of the above for throw() specs. */
+
+extern "C" void
+__check_null_eh_spec (void)
+{
+ __check_eh_spec (0, 0);
+}
+
+// Helpers for rtti. Although these don't return, we give them return types so
+// that the type system is not broken.
+
+extern "C" void *
+__throw_bad_cast ()
+{
+ throw std::bad_cast ();
+ return 0;
+}
+
+extern "C" std::type_info const &
+__throw_bad_typeid ()
+{
+ throw std::bad_typeid ();
+ return typeid (void);
+}
+
+/* Has the current exception been caught? */
+
+bool
+std::uncaught_exception ()
+{
+ cp_eh_info *p = CP_EH_INFO;
+ return p && ! p->caught;
+}
+
+const char * std::exception::
+what () const
+{
+ return typeid (*this).name ();
+}
OSDN Git Service
