gcc/unwind-c.c

   1 /* Supporting functions for C exception handling.
   2    Copyright (C) 2002, 2003, 2009 Free Software Foundation, Inc.
   3    Contributed by Aldy Hernandez <aldy@quesejoda.com>.
   4    Shamelessly stolen from the Java front end.
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 3, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 Under Section 7 of GPL version 3, you are granted additional
  19 permissions described in the GCC Runtime Library Exception, version
  20 3.1, as published by the Free Software Foundation.
  21
  22 You should have received a copy of the GNU General Public License and
  23 a copy of the GCC Runtime Library Exception along with this program;
  24 see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  25 <http://www.gnu.org/licenses/>.  */
  26
  27 #include "tconfig.h"
  28 #include "tsystem.h"
  29 #include "unwind.h"
  30 #define NO_SIZE_OF_ENCODED_VALUE
  31 #include "unwind-pe.h"
  32
  33 typedef struct
  34 {
  35   _Unwind_Ptr Start;
  36   _Unwind_Ptr LPStart;
  37   _Unwind_Ptr ttype_base;
  38   const unsigned char *TType;
  39   const unsigned char *action_table;
  40   unsigned char ttype_encoding;
  41   unsigned char call_site_encoding;
  42 } lsda_header_info;
  43
  44 static const unsigned char *
  45 parse_lsda_header (struct _Unwind_Context *context, const unsigned char *p,
  46                    lsda_header_info *info)
  47 {
  48   _uleb128_t tmp;
  49   unsigned char lpstart_encoding;
  50
  51   info->Start = (context ? _Unwind_GetRegionStart (context) : 0);
  52
  53   /* Find @LPStart, the base to which landing pad offsets are relative.  */
  54   lpstart_encoding = *p++;
  55   if (lpstart_encoding != DW_EH_PE_omit)
  56     p = read_encoded_value (context, lpstart_encoding, p, &info->LPStart);
  57   else
  58     info->LPStart = info->Start;
  59
  60   /* Find @TType, the base of the handler and exception spec type data.  */
  61   info->ttype_encoding = *p++;
  62   if (info->ttype_encoding != DW_EH_PE_omit)
  63     {
  64       p = read_uleb128 (p, &tmp);
  65       info->TType = p + tmp;
  66     }
  67   else
  68     info->TType = 0;
  69
  70   /* The encoding and length of the call-site table; the action table
  71      immediately follows.  */
  72   info->call_site_encoding = *p++;
  73   p = read_uleb128 (p, &tmp);
  74   info->action_table = p + tmp;
  75
  76   return p;
  77 }
  78
  79 #ifdef __ARM_EABI_UNWINDER__
  80 /* ARM EABI personality routines must also unwind the stack.  */
  81 #define CONTINUE_UNWINDING \
  82   do                                                            \
  83     {                                                           \
  84       if (__gnu_unwind_frame (ue_header, context) != _URC_OK)   \
  85         return _URC_FAILURE;                                    \
  86       return _URC_CONTINUE_UNWIND;                              \
  87     }                                                           \
  88   while (0)
  89 #else
  90 #define CONTINUE_UNWINDING return _URC_CONTINUE_UNWIND
  91 #endif
  92
  93 #ifdef __USING_SJLJ_EXCEPTIONS__
  94 #define PERSONALITY_FUNCTION    __gcc_personality_sj0
  95 #define __builtin_eh_return_data_regno(x) x
  96 #else
  97 #define PERSONALITY_FUNCTION    __gcc_personality_v0
  98 #endif
  99
 100 #ifdef __ARM_EABI_UNWINDER__
 101 _Unwind_Reason_Code
 102 PERSONALITY_FUNCTION (_Unwind_State, struct _Unwind_Exception *,
 103                       struct _Unwind_Context *);
 104
 105 _Unwind_Reason_Code
 106 PERSONALITY_FUNCTION (_Unwind_State state,
 107                       struct _Unwind_Exception * ue_header,
 108                       struct _Unwind_Context * context)
 109 #else
 110 _Unwind_Reason_Code
 111 PERSONALITY_FUNCTION (int, _Unwind_Action, _Unwind_Exception_Class,
 112                       struct _Unwind_Exception *, struct _Unwind_Context *);
 113
 114 _Unwind_Reason_Code
 115 PERSONALITY_FUNCTION (int version,
 116                       _Unwind_Action actions,
 117                       _Unwind_Exception_Class exception_class ATTRIBUTE_UNUSED,
 118                       struct _Unwind_Exception *ue_header,
 119                       struct _Unwind_Context *context)
 120 #endif
 121 {
 122   lsda_header_info info;
 123   const unsigned char *language_specific_data, *p, *action_record;
 124   _Unwind_Ptr landing_pad, ip;
 125   int ip_before_insn = 0;
 126
 127 #ifdef __ARM_EABI_UNWINDER__
 128   if ((state & _US_ACTION_MASK) != _US_UNWIND_FRAME_STARTING)
 129     CONTINUE_UNWINDING;
 130
 131   /* The dwarf unwinder assumes the context structure holds things like the
 132      function and LSDA pointers.  The ARM implementation caches these in
 133      the exception header (UCB).  To avoid rewriting everything we make the
 134      virtual IP register point at the UCB.  */
 135   ip = (_Unwind_Ptr) ue_header;
 136   _Unwind_SetGR (context, 12, ip);
 137 #else
 138   if (version != 1)
 139     return _URC_FATAL_PHASE1_ERROR;
 140
 141   /* Currently we only support cleanups for C.  */
 142   if ((actions & _UA_CLEANUP_PHASE) == 0)
 143     CONTINUE_UNWINDING;
 144 #endif
 145
 146   language_specific_data = (const unsigned char *)
 147     _Unwind_GetLanguageSpecificData (context);
 148
 149   /* If no LSDA, then there are no handlers or cleanups.  */
 150   if (! language_specific_data)
 151     CONTINUE_UNWINDING;
 152
 153   /* Parse the LSDA header.  */
 154   p = parse_lsda_header (context, language_specific_data, &info);
 155 #ifdef HAVE_GETIPINFO
 156   ip = _Unwind_GetIPInfo (context, &ip_before_insn);
 157 #else
 158   ip = _Unwind_GetIP (context);
 159 #endif
 160   if (! ip_before_insn)
 161     --ip;
 162   landing_pad = 0;
 163
 164 #ifdef __USING_SJLJ_EXCEPTIONS__
 165   /* The given "IP" is an index into the call-site table, with two
 166      exceptions -- -1 means no-action, and 0 means terminate.  But
 167      since we're using uleb128 values, we've not got random access
 168      to the array.  */
 169   if ((int) ip <= 0)
 170     return _URC_CONTINUE_UNWIND;
 171   else
 172     {
 173       _uleb128_t cs_lp, cs_action;
 174       do
 175         {
 176           p = read_uleb128 (p, &cs_lp);
 177           p = read_uleb128 (p, &cs_action);
 178         }
 179       while (--ip);
 180
 181       /* Can never have null landing pad for sjlj -- that would have
 182          been indicated by a -1 call site index.  */
 183       landing_pad = (_Unwind_Ptr)cs_lp + 1;
 184       if (cs_action)
 185         action_record = info.action_table + cs_action - 1;
 186       goto found_something;
 187     }
 188 #else
 189   /* Search the call-site table for the action associated with this IP.  */
 190   while (p < info.action_table)
 191     {
 192       _Unwind_Ptr cs_start, cs_len, cs_lp;
 193       _uleb128_t cs_action;
 194
 195       /* Note that all call-site encodings are "absolute" displacements.  */
 196       p = read_encoded_value (0, info.call_site_encoding, p, &cs_start);
 197       p = read_encoded_value (0, info.call_site_encoding, p, &cs_len);
 198       p = read_encoded_value (0, info.call_site_encoding, p, &cs_lp);
 199       p = read_uleb128 (p, &cs_action);
 200
 201       /* The table is sorted, so if we've passed the ip, stop.  */
 202       if (ip < info.Start + cs_start)
 203         p = info.action_table;
 204       else if (ip < info.Start + cs_start + cs_len)
 205         {
 206           if (cs_lp)
 207             landing_pad = info.LPStart + cs_lp;
 208           if (cs_action)
 209             action_record = info.action_table + cs_action - 1;
 210           goto found_something;
 211         }
 212     }
 213 #endif
 214
 215   /* IP is not in table.  No associated cleanups.  */
 216   /* ??? This is where C++ calls std::terminate to catch throw
 217      from a destructor.  */
 218   CONTINUE_UNWINDING;
 219
 220  found_something:
 221   if (landing_pad == 0)
 222     {
 223       /* IP is present, but has a null landing pad.
 224          No handler to be run.  */
 225       CONTINUE_UNWINDING;
 226     }
 227
 228   _Unwind_SetGR (context, __builtin_eh_return_data_regno (0),
 229                  (_Unwind_Ptr) ue_header);
 230   _Unwind_SetGR (context, __builtin_eh_return_data_regno (1), 0);
 231   _Unwind_SetIP (context, landing_pad);
 232   return _URC_INSTALL_CONTEXT;
 233 }