gcc/cp/exception.cc

   1 // Functions for Exception Support for -*- C++ -*-
   2 // Copyright (C) 1994, 1995, 1996 Free Software Foundation
   3
   4 // This file is part of GNU CC.
   5
   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)
   9 // any later version.
  10
  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.
  15
  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.
  20
  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.
  27
  28 #pragma implementation "exception"
  29
  30 #include "typeinfo"
  31 #include "exception"
  32
  33 /* Define terminate, unexpected, set_terminate, set_unexpected as
  34    well as the default terminate func and default unexpected func.  */
  35
  36 extern terminate_handler __terminate_func __attribute__((__noreturn__));
  37
  38 void
  39 terminate ()
  40 {
  41   __terminate_func ();
  42 }
  43
  44 void
  45 __default_unexpected ()
  46 {
  47   terminate ();
  48 }
  49
  50 static unexpected_handler __unexpected_func = __default_unexpected;
  51
  52 terminate_handler
  53 set_terminate (terminate_handler func)
  54 {
  55   terminate_handler old = __terminate_func;
  56
  57   __terminate_func = func;
  58   return old;
  59 }
  60
  61 unexpected_handler
  62 set_unexpected (unexpected_handler func)
  63 {
  64   unexpected_handler old = __unexpected_func;
  65
  66   __unexpected_func = func;
  67   return old;
  68 }
  69
  70 void
  71 unexpected ()
  72 {
  73   __unexpected_func ();
  74 }
  75
  76 /* C++-specific state about the current exception.
  77    This must match init_exception_processing().
  78
  79    Note that handlers and caught are not redundant; when rethrown, an
  80    exception can have multiple active handlers and still be considered
  81    uncaught.  */
  82
  83 struct cp_eh_info
  84 {
  85   void *value;
  86   void *type;
  87   void (*cleanup)(void *, int);
  88   bool caught;
  89   cp_eh_info *next;
  90   long handlers;
  91 };
  92
  93 /* Language-specific EH info pointer, defined in libgcc2.  */
  94
  95 extern cp_eh_info *__eh_info;  // actually void*
  96
  97 /* Is P the type_info node for a pointer of some kind?  */
  98
  99 extern bool __is_pointer (void *);
 100
 101 /* Compiler hook to return a pointer to the info for the current exception.
 102    Used by get_eh_info ().  */
 103
 104 extern "C" cp_eh_info *
 105 __cp_exception_info (void)
 106 {
 107   return __eh_info;
 108 }
 109
 110 /* Compiler hook to push a new exception onto the stack.
 111    Used by expand_throw().  */
 112
 113 extern "C" void
 114 __cp_push_exception (void *value, void *type, void (*cleanup)(void *, int))
 115 {
 116   cp_eh_info *p = new cp_eh_info;
 117   p->value = value;
 118   p->type = type;
 119   p->cleanup = cleanup;
 120   p->handlers = 0;
 121   p->caught = false;
 122   p->next = __eh_info;
 123   __eh_info = p;
 124 }
 125
 126 /* Compiler hook to pop an exception that has been finalized.  Used by
 127    push_eh_cleanup().  P is the info for the exception caught by the
 128    current catch block, and HANDLER determines if we've been called from
 129    an exception handler; if so, we avoid destroying the object on rethrow.  */
 130
 131 extern "C" void
 132 __cp_pop_exception (cp_eh_info *p, bool handler)
 133 {
 134   cp_eh_info **q = &__eh_info;
 135
 136   --p->handlers;
 137
 138   if (p->handlers > 0 || (handler && p == *q))
 139     return;
 140
 141   for (; *q; q = &((*q)->next))
 142     if (*q == p)
 143       break;
 144
 145   if (! *q)
 146     terminate ();
 147
 148   *q = p->next;
 149
 150   if (p->cleanup)
 151     /* 3 is a magic value for destructors; see build_delete().  */
 152     p->cleanup (p->value, 3);
 153   else if (__is_pointer (p->type))
 154     /* do nothing; pointers are passed directly in p->value.  */;
 155   else
 156     delete p->value;
 157
 158   delete p;
 159 }
 160
 161 extern "C" void
 162 __uncatch_exception (void)
 163 {
 164   cp_eh_info *p = __cp_exception_info ();
 165   if (p)
 166     p->caught = false;
 167   /* otherwise __throw will call terminate(); don't crash here.  */
 168 }
 169
 170 extern "C" void
 171 __throw_bad_cast (void)
 172 {
 173   throw bad_cast ();
 174 }
 175
 176 extern "C" void
 177 __throw_bad_typeid (void)
 178 {
 179   throw bad_typeid ();
 180 }
 181
 182 /* Has the current exception been caught?  */
 183
 184 bool
 185 uncaught_exception ()
 186 {
 187   cp_eh_info *p = __cp_exception_info ();
 188   return p && ! p->caught;
 189 }
 190
 191 const char * exception::
 192 what () const
 193 {
 194   return typeid (*this).name ();
 195 }