libobjc/exception.c

   1 /* The implementation of exception handling primitives for Objective-C.
   2    Copyright (C) 2004, 2005, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC is free software; you can redistribute it and/or modify it
   7 under the terms of the GNU General Public License as published by the
   8 Free Software Foundation; either version 3, or (at your option) any
   9 later version.
  10
  11 GCC is distributed in the hope that it will be useful, but WITHOUT
  12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  14 License for more details.
  15
  16 Under Section 7 of GPL version 3, you are granted additional
  17 permissions described in the GCC Runtime Library Exception, version
  18 3.1, as published by the Free Software Foundation.
  19
  20 You should have received a copy of the GNU General Public License and
  21 a copy of the GCC Runtime Library Exception along with this program;
  22 see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  23 <http://www.gnu.org/licenses/>.  */
  24
  25 #include "objc-private/common.h"
  26 #include <stdlib.h>
  27 #include "config.h"
  28 #include "objc/runtime.h"
  29 #include "objc/objc-exception.h"
  30 #include "unwind.h"
  31 #include "unwind-pe.h"
  32 #include <string.h> /* For memcpy */
  33
  34 /* 'is_kind_of_exception_matcher' is our default exception matcher -
  35    it determines if the object 'exception' is of class 'catch_class',
  36    or of a subclass.  */
  37 static int
  38 is_kind_of_exception_matcher (Class catch_class, id exception)
  39 {
  40   /* NULL catch_class is catch-all (eg, @catch (id object)).  */
  41   if (catch_class == Nil)
  42     return 1;
  43
  44   /* If exception is nil (eg, @throw nil;), then it can only be
  45      catched by a catch-all (eg, @catch (id object)).  */
  46   if (exception != nil)
  47     {
  48       Class c;
  49
  50       for (c = exception->class_pointer; c != Nil;
  51            c = class_getSuperclass (c))
  52         if (c == catch_class)
  53           return 1;
  54     }
  55   return 0;
  56 }
  57
  58 /* The exception matcher currently in use.  */
  59 static objc_exception_matcher
  60 __objc_exception_matcher = is_kind_of_exception_matcher;
  61
  62 objc_exception_matcher
  63 objc_setExceptionMatcher (objc_exception_matcher new_matcher)
  64 {
  65   objc_exception_matcher old_matcher = __objc_exception_matcher;
  66   __objc_exception_matcher = new_matcher;
  67   return old_matcher;
  68 }
  69
  70 /* The uncaught exception handler currently in use.  */
  71 static objc_uncaught_exception_handler
  72 __objc_uncaught_exception_handler = NULL;
  73
  74 objc_uncaught_exception_handler
  75 objc_setUncaughtExceptionHandler (objc_uncaught_exception_handler
  76                                   new_handler)
  77 {
  78   objc_uncaught_exception_handler old_handler
  79     = __objc_uncaught_exception_handler;
  80   __objc_uncaught_exception_handler = new_handler;
  81   return old_handler;
  82 }
  83
  84
  85 \f
  86 #ifdef __ARM_EABI_UNWINDER__
  87
  88 const _Unwind_Exception_Class __objc_exception_class
  89   = {'G', 'N', 'U', 'C', 'O', 'B', 'J', 'C'};
  90
  91 #else
  92
  93 /* This is the exception class we report -- "GNUCOBJC".  */
  94 static const _Unwind_Exception_Class __objc_exception_class
  95   = ((((((((_Unwind_Exception_Class) 'G'
  96             << 8 | (_Unwind_Exception_Class) 'N')
  97            << 8 | (_Unwind_Exception_Class) 'U')
  98           << 8 | (_Unwind_Exception_Class) 'C')
  99          << 8 | (_Unwind_Exception_Class) 'O')
 100         << 8 | (_Unwind_Exception_Class) 'B')
 101        << 8 | (_Unwind_Exception_Class) 'J')
 102       << 8 | (_Unwind_Exception_Class) 'C');
 103
 104 #endif
 105
 106 /* This is the object that is passed around by the Objective C runtime
 107    to represent the exception in flight.  */
 108 struct ObjcException
 109 {
 110   /* This bit is needed in order to interact with the unwind runtime.  */
 111   struct _Unwind_Exception base;
 112
 113   /* The actual object we want to throw. Note: must come immediately
 114      after unwind header.  */
 115   id value;
 116
 117 #ifdef __ARM_EABI_UNWINDER__
 118   /* Note: we use the barrier cache defined in the unwind control
 119      block for ARM EABI.  */
 120 #else
 121   /* Cache some internal unwind data between phase 1 and phase 2.  */
 122   _Unwind_Ptr landingPad;
 123   int handlerSwitchValue;
 124 #endif
 125 };
 126
 127 \f
 128
 129 struct lsda_header_info
 130 {
 131   _Unwind_Ptr Start;
 132   _Unwind_Ptr LPStart;
 133   _Unwind_Ptr ttype_base;
 134   const unsigned char *TType;
 135   const unsigned char *action_table;
 136   unsigned char ttype_encoding;
 137   unsigned char call_site_encoding;
 138 };
 139
 140 static const unsigned char *
 141 parse_lsda_header (struct _Unwind_Context *context, const unsigned char *p,
 142                    struct lsda_header_info *info)
 143 {
 144   _uleb128_t tmp;
 145   unsigned char lpstart_encoding;
 146
 147   info->Start = (context ? _Unwind_GetRegionStart (context) : 0);
 148
 149   /* Find @LPStart, the base to which landing pad offsets are
 150      relative.  */
 151   lpstart_encoding = *p++;
 152   if (lpstart_encoding != DW_EH_PE_omit)
 153     p = read_encoded_value (context, lpstart_encoding, p, &info->LPStart);
 154   else
 155     info->LPStart = info->Start;
 156
 157   /* Find @TType, the base of the handler and exception spec type
 158      data.  */
 159   info->ttype_encoding = *p++;
 160   if (info->ttype_encoding != DW_EH_PE_omit)
 161     {
 162 #if _GLIBCXX_OVERRIDE_TTYPE_ENCODING
 163       /* Older ARM EABI toolchains set this value incorrectly, so use a
 164          hardcoded OS-specific format.  */
 165       info->ttype_encoding = _GLIBCXX_OVERRIDE_TTYPE_ENCODING;
 166 #endif
 167       p = read_uleb128 (p, &tmp);
 168       info->TType = p + tmp;
 169     }
 170   else
 171     info->TType = 0;
 172
 173   /* The encoding and length of the call-site table; the action table
 174      immediately follows.  */
 175   info->call_site_encoding = *p++;
 176   p = read_uleb128 (p, &tmp);
 177   info->action_table = p + tmp;
 178
 179   return p;
 180 }
 181
 182 static Class
 183 get_ttype_entry (struct lsda_header_info *info, _Unwind_Word i)
 184 {
 185   _Unwind_Ptr ptr;
 186
 187   i *= size_of_encoded_value (info->ttype_encoding);
 188   read_encoded_value_with_base (info->ttype_encoding, info->ttype_base,
 189                                 info->TType - i, &ptr);
 190
 191   /* NULL ptr means catch-all.  Note that if the class is not found,
 192      this will abort the program.  */
 193   if (ptr)
 194     return objc_getRequiredClass ((const char *) ptr);
 195   else
 196     return 0;
 197 }
 198
 199 /* Using a different personality function name causes link failures
 200    when trying to mix code using different exception handling
 201    models.  */
 202 #ifdef SJLJ_EXCEPTIONS
 203 #define PERSONALITY_FUNCTION    __gnu_objc_personality_sj0
 204 #define __builtin_eh_return_data_regno(x) x
 205 #else
 206 #define PERSONALITY_FUNCTION    __gnu_objc_personality_v0
 207 #endif
 208
 209 #ifdef __ARM_EABI_UNWINDER__
 210
 211 #define CONTINUE_UNWINDING \
 212   do                                                            \
 213     {                                                           \
 214       if (__gnu_unwind_frame(ue_header, context) != _URC_OK)    \
 215         return _URC_FAILURE;                                    \
 216       return _URC_CONTINUE_UNWIND;                              \
 217     }                                                           \
 218   while (0)
 219
 220 _Unwind_Reason_Code
 221 PERSONALITY_FUNCTION (_Unwind_State state,
 222                       struct _Unwind_Exception *ue_header,
 223                       struct _Unwind_Context *context)
 224 #else
 225
 226 #define CONTINUE_UNWINDING return _URC_CONTINUE_UNWIND
 227
 228 _Unwind_Reason_Code
 229 PERSONALITY_FUNCTION (int version,
 230                       _Unwind_Action actions,
 231                       _Unwind_Exception_Class exception_class,
 232                       struct _Unwind_Exception *ue_header,
 233                       struct _Unwind_Context *context)
 234 #endif
 235 {
 236   struct ObjcException *xh = (struct ObjcException *) ue_header;
 237
 238   struct lsda_header_info info;
 239   const unsigned char *language_specific_data;
 240   const unsigned char *action_record;
 241   const unsigned char *p;
 242   _Unwind_Ptr landing_pad, ip;
 243   int handler_switch_value;
 244   int saw_cleanup = 0, saw_handler, foreign_exception;
 245   void *return_object;
 246   int ip_before_insn = 0;
 247
 248 #ifdef __ARM_EABI_UNWINDER__
 249   _Unwind_Action actions;
 250
 251   switch (state & _US_ACTION_MASK)
 252     {
 253     case _US_VIRTUAL_UNWIND_FRAME:
 254       actions = _UA_SEARCH_PHASE;
 255       break;
 256
 257     case _US_UNWIND_FRAME_STARTING:
 258       actions = _UA_CLEANUP_PHASE;
 259       if (!(state & _US_FORCE_UNWIND)
 260           && ue_header->barrier_cache.sp == _Unwind_GetGR (context, 13))
 261         actions |= _UA_HANDLER_FRAME;
 262       break;
 263
 264     case _US_UNWIND_FRAME_RESUME:
 265       CONTINUE_UNWINDING;
 266       break;
 267
 268     default:
 269       abort();
 270     }
 271   actions |= state & _US_FORCE_UNWIND;
 272
 273   /* TODO: Foreign exceptions need some attention (e.g. rethrowing
 274      doesn't work).  */
 275   foreign_exception = 0;
 276
 277   /* The dwarf unwinder assumes the context structure holds things
 278      like the function and LSDA pointers.  The ARM implementation
 279      caches these in the exception header (UCB).  To avoid rewriting
 280      everything we make the virtual IP register point at the UCB.  */
 281   ip = (_Unwind_Ptr) ue_header;
 282   _Unwind_SetGR (context, 12, ip);
 283
 284 #else  /* !__ARM_EABI_UNWINDER.  */
 285   /* Interface version check.  */
 286   if (version != 1)
 287     return _URC_FATAL_PHASE1_ERROR;
 288
 289   foreign_exception = (exception_class != __objc_exception_class);
 290 #endif
 291
 292   /* Shortcut for phase 2 found handler for domestic exception.  */
 293   if (actions == (_UA_CLEANUP_PHASE | _UA_HANDLER_FRAME)
 294       && !foreign_exception)
 295     {
 296 #ifdef __ARM_EABI_UNWINDER__
 297       handler_switch_value = (int) ue_header->barrier_cache.bitpattern[1];
 298       landing_pad = (_Unwind_Ptr) ue_header->barrier_cache.bitpattern[3];
 299 #else
 300       handler_switch_value = xh->handlerSwitchValue;
 301       landing_pad = xh->landingPad;
 302 #endif
 303       goto install_context;
 304     }
 305
 306   language_specific_data = (const unsigned char *)
 307     _Unwind_GetLanguageSpecificData (context);
 308
 309   /* If no LSDA, then there are no handlers or cleanups.  */
 310   if (! language_specific_data)
 311     CONTINUE_UNWINDING;
 312
 313   /* Parse the LSDA header.  */
 314   p = parse_lsda_header (context, language_specific_data, &info);
 315   info.ttype_base = base_of_encoded_value (info.ttype_encoding, context);
 316 #ifdef HAVE_GETIPINFO
 317   ip = _Unwind_GetIPInfo (context, &ip_before_insn);
 318 #else
 319   ip = _Unwind_GetIP (context);
 320 #endif
 321   if (!ip_before_insn)
 322     --ip;
 323   landing_pad = 0;
 324   action_record = 0;
 325   handler_switch_value = 0;
 326
 327 #ifdef SJLJ_EXCEPTIONS
 328   /* The given "IP" is an index into the call-site table, with two
 329      exceptions -- -1 means no-action, and 0 means terminate.  But
 330      since we're using uleb128 values, we've not got random access to
 331      the array.  */
 332   if ((int) ip < 0)
 333     return _URC_CONTINUE_UNWIND;
 334   else
 335     {
 336       _uleb128_t cs_lp, cs_action;
 337       do
 338         {
 339           p = read_uleb128 (p, &cs_lp);
 340           p = read_uleb128 (p, &cs_action);
 341         }
 342       while (--ip);
 343
 344       /* Can never have null landing pad for sjlj -- that would have
 345          been indicated by a -1 call site index.  */
 346       landing_pad = cs_lp + 1;
 347       if (cs_action)
 348         action_record = info.action_table + cs_action - 1;
 349       goto found_something;
 350     }
 351 #else
 352   /* Search the call-site table for the action associated with this
 353      IP.  */
 354   while (p < info.action_table)
 355     {
 356       _Unwind_Ptr cs_start, cs_len, cs_lp;
 357       _uleb128_t cs_action;
 358
 359       /* Note that all call-site encodings are "absolute"
 360          displacements.  */
 361       p = read_encoded_value (0, info.call_site_encoding, p, &cs_start);
 362       p = read_encoded_value (0, info.call_site_encoding, p, &cs_len);
 363       p = read_encoded_value (0, info.call_site_encoding, p, &cs_lp);
 364       p = read_uleb128 (p, &cs_action);
 365
 366       /* The table is sorted, so if we've passed the ip, stop.  */
 367       if (ip < info.Start + cs_start)
 368         p = info.action_table;
 369       else if (ip < info.Start + cs_start + cs_len)
 370         {
 371           if (cs_lp)
 372             landing_pad = info.LPStart + cs_lp;
 373           if (cs_action)
 374             action_record = info.action_table + cs_action - 1;
 375           goto found_something;
 376         }
 377     }
 378 #endif /* SJLJ_EXCEPTIONS  */
 379
 380   /* If ip is not present in the table, C++ would call terminate.  */
 381   /* ??? As with Java, it's perhaps better to tweek the LSDA to that
 382      no-action is mapped to no-entry.  */
 383   CONTINUE_UNWINDING;
 384
 385  found_something:
 386   saw_cleanup = 0;
 387   saw_handler = 0;
 388
 389   if (landing_pad == 0)
 390     {
 391       /* If ip is present, and has a null landing pad, there are no
 392          cleanups or handlers to be run.  */
 393     }
 394   else if (action_record == 0)
 395     {
 396       /* If ip is present, has a non-null landing pad, and a null
 397          action table offset, then there are only cleanups present.
 398          Cleanups use a zero switch value, as set above.  */
 399       saw_cleanup = 1;
 400     }
 401   else
 402     {
 403       /* Otherwise we have a catch handler.  */
 404       _sleb128_t ar_filter, ar_disp;
 405
 406       while (1)
 407         {
 408           p = action_record;
 409           p = read_sleb128 (p, &ar_filter);
 410           read_sleb128 (p, &ar_disp);
 411
 412           if (ar_filter == 0)
 413             {
 414               /* Zero filter values are cleanups.  */
 415               saw_cleanup = 1;
 416             }
 417
 418           /* During forced unwinding, we only run cleanups.  With a
 419              foreign exception class, we have no class info to
 420              match.  */
 421           else if ((actions & _UA_FORCE_UNWIND) || foreign_exception)
 422             ;
 423
 424           else if (ar_filter > 0)
 425             {
 426               /* Positive filter values are handlers.  */
 427               Class catch_type = get_ttype_entry (&info, ar_filter);
 428
 429               if ((*__objc_exception_matcher) (catch_type, xh->value))
 430                 {
 431                   handler_switch_value = ar_filter;
 432                   saw_handler = 1;
 433                   break;
 434                 }
 435             }
 436           else
 437             {
 438               /* Negative filter values are exception specifications,
 439                  which Objective-C does not use.  */
 440               abort ();
 441             }
 442
 443           if (ar_disp == 0)
 444             break;
 445           action_record = p + ar_disp;
 446         }
 447     }
 448
 449   if (! saw_handler && ! saw_cleanup)
 450     CONTINUE_UNWINDING;
 451
 452   if (actions & _UA_SEARCH_PHASE)
 453     {
 454       if (!saw_handler)
 455         CONTINUE_UNWINDING;
 456
 457       /* For domestic exceptions, we cache data from phase 1 for phase
 458          2.  */
 459       if (!foreign_exception)
 460         {
 461 #ifdef __ARM_EABI_UNWINDER__
 462           ue_header->barrier_cache.sp = _Unwind_GetGR (context, 13);
 463           ue_header->barrier_cache.bitpattern[1] = (_uw) handler_switch_value;
 464           ue_header->barrier_cache.bitpattern[3] = (_uw) landing_pad;
 465 #else
 466           xh->handlerSwitchValue = handler_switch_value;
 467           xh->landingPad = landing_pad;
 468 #endif
 469         }
 470       return _URC_HANDLER_FOUND;
 471     }
 472
 473  install_context:
 474   if (saw_cleanup == 0)
 475     {
 476       return_object = xh->value;
 477       if (!(actions & _UA_SEARCH_PHASE))
 478         _Unwind_DeleteException(&xh->base);
 479     }
 480
 481   _Unwind_SetGR (context, __builtin_eh_return_data_regno (0),
 482                  __builtin_extend_pointer (saw_cleanup ? xh : return_object));
 483   _Unwind_SetGR (context, __builtin_eh_return_data_regno (1),
 484                  handler_switch_value);
 485   _Unwind_SetIP (context, landing_pad);
 486   return _URC_INSTALL_CONTEXT;
 487 }
 488
 489 static void
 490 __objc_exception_cleanup (_Unwind_Reason_Code code __attribute__((unused)),
 491                           struct _Unwind_Exception *exc)
 492 {
 493   free (exc);
 494 }
 495
 496 void
 497 objc_exception_throw (id exception)
 498 {
 499   struct ObjcException *header = calloc (1, sizeof (*header));
 500
 501   memcpy (&header->base.exception_class, &__objc_exception_class,
 502           sizeof (__objc_exception_class));
 503   header->base.exception_cleanup = __objc_exception_cleanup;
 504   header->value = exception;
 505
 506 #ifdef SJLJ_EXCEPTIONS
 507   _Unwind_SjLj_RaiseException (&header->base);
 508 #else
 509   _Unwind_RaiseException (&header->base);
 510 #endif
 511
 512   /* No exception handler was installed.  Call the uncaught exception
 513      handler if any is defined.  */
 514   if (__objc_uncaught_exception_handler != 0)
 515     {
 516       (*__objc_uncaught_exception_handler) (exception);
 517     }
 518
 519   abort ();
 520 }
 521