gcc/cp/exception.cc

   1 // Functions for Exception Support for -*- C++ -*-
   2 // Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999 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 #include <stddef.h>
  33 #include "gansidecl.h" /* Needed to support macros used in eh-common.h. */
  34 #include "eh-common.h"
  35
  36 /* Define terminate, unexpected, set_terminate, set_unexpected as
  37    well as the default terminate func and default unexpected func.  */
  38
  39 extern std::terminate_handler __terminate_func __attribute__((__noreturn__));
  40 using std::terminate;
  41
  42 void
  43 std::terminate ()
  44 {
  45   __terminate_func ();
  46 }
  47
  48 void
  49 __default_unexpected ()
  50 {
  51   terminate ();
  52 }
  53
  54 static std::unexpected_handler __unexpected_func __attribute__((__noreturn__))
  55   = __default_unexpected;
  56
  57 std::terminate_handler
  58 std::set_terminate (std::terminate_handler func)
  59 {
  60   std::terminate_handler old = __terminate_func;
  61
  62   __terminate_func = func;
  63   return old;
  64 }
  65
  66 std::unexpected_handler
  67 std::set_unexpected (std::unexpected_handler func)
  68 {
  69   std::unexpected_handler old = __unexpected_func;
  70
  71   __unexpected_func = func;
  72   return old;
  73 }
  74
  75 void
  76 std::unexpected ()
  77 {
  78   __unexpected_func ();
  79 }
  80
  81 /* C++-specific state about the current exception.
  82    This must match init_exception_processing().
  83
  84    Note that handlers and caught are not redundant; when rethrown, an
  85    exception can have multiple active handlers and still be considered
  86    uncaught.  */
  87
  88 struct cp_eh_info
  89 {
  90   __eh_info eh_info;
  91   void *value;
  92   void *type;
  93   void (*cleanup)(void *, int);
  94   bool caught;
  95   cp_eh_info *next;
  96   long handlers;
  97   void *original_value;
  98 };
  99
 100 /* Language-specific EH info pointer, defined in libgcc2. */
 101
 102 extern "C" cp_eh_info **__get_eh_info ();       // actually void **
 103
 104 /* Is P the type_info node for a pointer of some kind?  */
 105
 106 extern bool __is_pointer (void *);
 107
 108
 109 /* OLD Compiler hook to return a pointer to the info for the current exception.
 110    Used by get_eh_info ().  This fudges the actualy returned value to
 111    point to the beginning of what USE to be the cp_eh_info structure.
 112    THis is so that old code that dereferences this pointer will find
 113    things where it expects it to be.*/
 114 extern "C" void *
 115 __cp_exception_info (void)
 116 {
 117   return &((*__get_eh_info ())->value);
 118 }
 119
 120 #define CP_EH_INFO ((cp_eh_info *) *__get_eh_info ())
 121
 122 /* Old Compiler hook to return a pointer to the info for the current exception.
 123    Used by get_eh_info ().  */
 124
 125 extern "C" cp_eh_info *
 126 __cp_eh_info (void)
 127 {
 128   cp_eh_info *p = CP_EH_INFO;
 129   return p;
 130 }
 131
 132 /* Compiler hook to return a pointer to the info for the current exception,
 133    Set the caught bit, and increment the number of handlers that are
 134    looking at this exception. This makes handlers smaller. */
 135
 136 extern "C" cp_eh_info *
 137 __start_cp_handler (void)
 138 {
 139   cp_eh_info *p = CP_EH_INFO;
 140   p->caught = 1;
 141   p->handlers++;
 142   return p;
 143 }
 144
 145 /* Allocate a buffer for a cp_eh_info and an exception object of size SIZE,
 146    and return a pointer to the beginning of the object's space.  */
 147
 148 extern "C" void * malloc (size_t);
 149 extern "C" void *
 150 __eh_alloc (size_t size)
 151 {
 152   void *p = malloc (size);
 153   if (p == 0)
 154     terminate ();
 155   return p;
 156 }
 157
 158 /* Free the memory for an cp_eh_info and associated exception, given
 159    a pointer to the cp_eh_info.  */
 160
 161 extern "C" void free (void *);
 162 extern "C" void
 163 __eh_free (void *p)
 164 {
 165   free (p);
 166 }
 167
 168 extern "C" int __throw_type_match_rtti_2 (const void *, const void *,
 169                                          void *, void **);
 170
 171 extern "C" void *
 172 __cplus_type_matcher (__eh_info *info_, void *match_info,
 173                       exception_descriptor *exception_table)
 174 {
 175   cp_eh_info *info = (cp_eh_info *)info_;
 176
 177   /* No exception table implies the old style mechanism, so don't check. */
 178   if (exception_table != NULL
 179       && exception_table->lang.language != EH_LANG_C_plus_plus)
 180     return NULL;
 181
 182   if (match_info == CATCH_ALL_TYPE)
 183     return (void *)1;
 184
 185   /* we don't worry about version info yet, there is only one version! */
 186
 187   void *match_type = match_info;
 188
 189 #if !defined (__GXX_ABI_VERSION) || __GXX_ABI_VERSION < 100
 190   match_type  = ((void *(*)())match_type) ();
 191 #endif
 192
 193   if (__throw_type_match_rtti_2 (match_type, info->type,
 194                                  info->original_value, &info->value))
 195     // Arbitrary non-null pointer.
 196     return (void *)1;
 197   else
 198     return NULL;
 199 }
 200
 201 /* Compiler hook to push a new exception onto the stack.
 202    Used by expand_throw().  */
 203
 204 extern "C" void
 205 __cp_push_exception (void *value, void *type, void (*cleanup)(void *, int))
 206 {
 207   cp_eh_info *p = (cp_eh_info *) __eh_alloc (sizeof (cp_eh_info));
 208
 209   p->value = value;
 210   p->type = type;
 211   p->cleanup = cleanup;
 212   p->handlers = 0;
 213   p->caught = false;
 214   p->original_value = value;
 215
 216   p->eh_info.match_function = __cplus_type_matcher;
 217   p->eh_info.language = EH_LANG_C_plus_plus;
 218   p->eh_info.version = 1;
 219
 220   cp_eh_info **q = __get_eh_info ();
 221
 222   p->next = *q;
 223   *q = p;
 224 }
 225
 226 /* Compiler hook to pop an exception that has been finalized.  Used by
 227    push_eh_cleanup().  P is the info for the exception caught by the
 228    current catch block.  */
 229
 230 extern "C" void
 231 __cp_pop_exception (cp_eh_info *p)
 232 {
 233   cp_eh_info **q = __get_eh_info ();
 234
 235   --p->handlers;
 236
 237   /* Don't really pop if there are still active handlers for our exception,
 238      or if our exception is being rethrown (i.e. if the active exception is
 239      our exception and it is uncaught).  */
 240   if (p->handlers != 0
 241       || (p == *q && !p->caught))
 242     return;
 243
 244   for (; *q; q = &((*q)->next))
 245     if (*q == p)
 246       break;
 247
 248   if (! *q)
 249     terminate ();
 250
 251   *q = p->next;
 252
 253   if (p->cleanup)
 254     /* 2 is a magic value for destructors; see build_delete().  */
 255     p->cleanup (p->value, 2);
 256
 257   if (! __is_pointer (p->type))
 258     __eh_free (p->original_value);  // value may have been co-erced.
 259
 260   __eh_free (p);
 261 }
 262
 263 extern "C" void
 264 __uncatch_exception (void)
 265 {
 266   cp_eh_info *p = CP_EH_INFO;
 267   if (p == 0)
 268     terminate ();
 269   p->caught = false;
 270 }
 271
 272 /* As per [except.unexpected]:
 273    If an exception is thrown, we check it against the spec.  If it doesn't
 274    match, we call unexpected ().  If unexpected () throws, we check that
 275    exception against the spec.  If it doesn't match, if the spec allows
 276    bad_exception we throw that; otherwise we call terminate ().
 277
 278    The compiler treats an exception spec as a try block with a generic
 279    handler that just calls this function with a list of the allowed
 280    exception types, so we have an active exception that can be rethrown.
 281
 282    This function does not return.  */
 283
 284 extern "C" void
 285 __check_eh_spec (int n, const void **spec)
 286 {
 287   cp_eh_info *p = CP_EH_INFO;
 288   void *d;
 289
 290   for (int i = 0; i < n; ++i)
 291     {
 292       if (__throw_type_match_rtti_2 (spec[i], p->type, p->value, &d))
 293         throw;
 294     }
 295
 296   try
 297     {
 298       std::unexpected ();
 299     }
 300   catch (...)
 301     {
 302       // __exception_info is an artificial var pushed into each catch block.
 303       if (p != __exception_info)
 304         {
 305           p = __exception_info;
 306           for (int i = 0; i < n; ++i)
 307             {
 308               if (__throw_type_match_rtti_2 (spec[i], p->type, p->value, &d))
 309                 throw;
 310             }
 311         }
 312
 313       const std::type_info &bad_exc = typeid (std::bad_exception);
 314       for (int i = 0; i < n; ++i)
 315         {
 316           if (__throw_type_match_rtti_2 (spec[i], &bad_exc, p->value, &d))
 317             throw std::bad_exception ();
 318         }
 319
 320       terminate ();
 321     }
 322 }
 323
 324 // Helpers for rtti. Although these don't return, we give them return types so
 325 // that the type system is not broken.
 326
 327 extern "C" void *
 328 __throw_bad_cast ()
 329 {
 330   throw std::bad_cast ();
 331   return 0;
 332 }
 333
 334 extern "C" std::type_info const &
 335 __throw_bad_typeid ()
 336 {
 337   throw std::bad_typeid ();
 338   return typeid (void);
 339 }
 340
 341 /* Has the current exception been caught?  */
 342
 343 bool
 344 std::uncaught_exception ()
 345 {
 346   cp_eh_info *p = CP_EH_INFO;
 347   return p && ! p->caught;
 348 }
 349
 350 const char * std::exception::
 351 what () const
 352 {
 353   return typeid (*this).name ();
 354 }