libgcc/unwind-c.c

   1 /* Supporting functions for C exception handling.
   2    Copyright (C) 2002-2018 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 "auto-target.h"
  30 #include "unwind.h"
  31 #define NO_SIZE_OF_ENCODED_VALUE
  32 #include "unwind-pe.h"
  33
  34 typedef struct
  35 {
  36   _Unwind_Ptr Start;
  37   _Unwind_Ptr LPStart;
  38   _Unwind_Ptr ttype_base;
  39   const unsigned char *TType;
  40   const unsigned char *action_table;
  41   unsigned char ttype_encoding;
  42   unsigned char call_site_encoding;
  43 } lsda_header_info;
  44
  45 static const unsigned char *
  46 parse_lsda_header (struct _Unwind_Context *context, const unsigned char *p,
  47                    lsda_header_info *info)
  48 {
  49   _uleb128_t tmp;
  50   unsigned char lpstart_encoding;
  51
  52   info->Start = (context ? _Unwind_GetRegionStart (context) : 0);
  53
  54   /* Find @LPStart, the base to which landing pad offsets are relative.  */
  55   lpstart_encoding = *p++;
  56   if (lpstart_encoding != DW_EH_PE_omit)
  57     p = read_encoded_value (context, lpstart_encoding, p, &info->LPStart);
  58   else
  59     info->LPStart = info->Start;
  60
  61   /* Find @TType, the base of the handler and exception spec type data.  */
  62   info->ttype_encoding = *p++;
  63   if (info->ttype_encoding != DW_EH_PE_omit)
  64     {
  65       p = read_uleb128 (p, &tmp);
  66       info->TType = p + tmp;
  67     }
  68   else
  69     info->TType = 0;
  70
  71   /* The encoding and length of the call-site table; the action table
  72      immediately follows.  */
  73   info->call_site_encoding = *p++;
  74   p = read_uleb128 (p, &tmp);
  75   info->action_table = p + tmp;
  76
  77   return p;
  78 }
  79
  80 #ifdef __ARM_EABI_UNWINDER__
  81 /* ARM EABI personality routines must also unwind the stack.  */
  82 #define CONTINUE_UNWINDING \
  83   do                                                            \
  84     {                                                           \
  85       if (__gnu_unwind_frame (ue_header, context) != _URC_OK)   \
  86         return _URC_FAILURE;                                    \
  87       return _URC_CONTINUE_UNWIND;                              \
  88     }                                                           \
  89   while (0)
  90 #else
  91 #define CONTINUE_UNWINDING return _URC_CONTINUE_UNWIND
  92 #endif
  93
  94 #ifdef __USING_SJLJ_EXCEPTIONS__
  95 #define PERSONALITY_FUNCTION    __gcc_personality_sj0
  96 #define __builtin_eh_return_data_regno(x) x
  97 #elif defined(__SEH__)
  98 #define PERSONALITY_FUNCTION    __gcc_personality_imp
  99 #else
 100 #define PERSONALITY_FUNCTION    __gcc_personality_v0
 101 #endif
 102
 103 #ifdef __ARM_EABI_UNWINDER__
 104 _Unwind_Reason_Code
 105 PERSONALITY_FUNCTION (_Unwind_State, struct _Unwind_Exception *,
 106                       struct _Unwind_Context *);
 107
 108 _Unwind_Reason_Code
 109 PERSONALITY_FUNCTION (_Unwind_State state,
 110                       struct _Unwind_Exception * ue_header,
 111                       struct _Unwind_Context * context)
 112 #else
 113 #if defined (__SEH__) && !defined (__USING_SJLJ_EXCEPTIONS__)
 114 static
 115 #endif
 116 _Unwind_Reason_Code
 117 PERSONALITY_FUNCTION (int, _Unwind_Action, _Unwind_Exception_Class,
 118                       struct _Unwind_Exception *, struct _Unwind_Context *);
 119
 120 _Unwind_Reason_Code
 121 PERSONALITY_FUNCTION (int version,
 122                       _Unwind_Action actions,
 123                       _Unwind_Exception_Class exception_class ATTRIBUTE_UNUSED,
 124                       struct _Unwind_Exception *ue_header,
 125                       struct _Unwind_Context *context)
 126 #endif
 127 {
 128   lsda_header_info info;
 129   const unsigned char *language_specific_data, *p;
 130   _Unwind_Ptr landing_pad, ip;
 131   int ip_before_insn = 0;
 132
 133 #ifdef __ARM_EABI_UNWINDER__
 134   if ((state & _US_ACTION_MASK) != _US_UNWIND_FRAME_STARTING)
 135     CONTINUE_UNWINDING;
 136
 137   /* The dwarf unwinder assumes the context structure holds things like the
 138      function and LSDA pointers.  The ARM implementation caches these in
 139      the exception header (UCB).  To avoid rewriting everything we make a
 140      virtual scratch register point at the UCB.  */
 141   ip = (_Unwind_Ptr) ue_header;
 142   _Unwind_SetGR (context, UNWIND_POINTER_REG, ip);
 143 #else
 144   if (version != 1)
 145     return _URC_FATAL_PHASE1_ERROR;
 146
 147   /* Currently we only support cleanups for C.  */
 148   if ((actions & _UA_CLEANUP_PHASE) == 0)
 149     CONTINUE_UNWINDING;
 150 #endif
 151
 152   language_specific_data = (const unsigned char *)
 153     _Unwind_GetLanguageSpecificData (context);
 154
 155   /* If no LSDA, then there are no handlers or cleanups.  */
 156   if (! language_specific_data)
 157     CONTINUE_UNWINDING;
 158
 159   /* Parse the LSDA header.  */
 160   p = parse_lsda_header (context, language_specific_data, &info);
 161 #ifdef HAVE_GETIPINFO
 162   ip = _Unwind_GetIPInfo (context, &ip_before_insn);
 163 #else
 164   ip = _Unwind_GetIP (context);
 165 #endif
 166   if (! ip_before_insn)
 167     --ip;
 168   landing_pad = 0;
 169
 170 #ifdef __USING_SJLJ_EXCEPTIONS__
 171   /* The given "IP" is an index into the call-site table, with two
 172      exceptions -- -1 means no-action, and 0 means terminate.  But
 173      since we're using uleb128 values, we've not got random access
 174      to the array.  */
 175   if ((int) ip <= 0)
 176     return _URC_CONTINUE_UNWIND;
 177   else
 178     {
 179       _uleb128_t cs_lp, cs_action;
 180       do
 181         {
 182           p = read_uleb128 (p, &cs_lp);
 183           p = read_uleb128 (p, &cs_action);
 184         }
 185       while (--ip);
 186
 187       /* Can never have null landing pad for sjlj -- that would have
 188          been indicated by a -1 call site index.  */
 189       landing_pad = (_Unwind_Ptr)cs_lp + 1;
 190       goto found_something;
 191     }
 192 #else
 193   /* Search the call-site table for the action associated with this IP.  */
 194   while (p < info.action_table)
 195     {
 196       _Unwind_Ptr cs_start, cs_len, cs_lp;
 197       _uleb128_t cs_action;
 198
 199       /* Note that all call-site encodings are "absolute" displacements.  */
 200       p = read_encoded_value (0, info.call_site_encoding, p, &cs_start);
 201       p = read_encoded_value (0, info.call_site_encoding, p, &cs_len);
 202       p = read_encoded_value (0, info.call_site_encoding, p, &cs_lp);
 203       p = read_uleb128 (p, &cs_action);
 204
 205       /* The table is sorted, so if we've passed the ip, stop.  */
 206       if (ip < info.Start + cs_start)
 207         p = info.action_table;
 208       else if (ip < info.Start + cs_start + cs_len)
 209         {
 210           if (cs_lp)
 211             landing_pad = info.LPStart + cs_lp;
 212           goto found_something;
 213         }
 214     }
 215 #endif
 216
 217   /* IP is not in table.  No associated cleanups.  */
 218   /* ??? This is where C++ calls std::terminate to catch throw
 219      from a destructor.  */
 220   CONTINUE_UNWINDING;
 221
 222  found_something:
 223   if (landing_pad == 0)
 224     {
 225       /* IP is present, but has a null landing pad.
 226          No handler to be run.  */
 227       CONTINUE_UNWINDING;
 228     }
 229
 230   _Unwind_SetGR (context, __builtin_eh_return_data_regno (0),
 231                  (_Unwind_Ptr) ue_header);
 232   _Unwind_SetGR (context, __builtin_eh_return_data_regno (1), 0);
 233   _Unwind_SetIP (context, landing_pad);
 234   return _URC_INSTALL_CONTEXT;
 235 }
 236
 237 #if defined (__SEH__) && !defined (__USING_SJLJ_EXCEPTIONS__)
 238 EXCEPTION_DISPOSITION
 239 __gcc_personality_seh0 (PEXCEPTION_RECORD ms_exc, void *this_frame,
 240                         PCONTEXT ms_orig_context, PDISPATCHER_CONTEXT ms_disp)
 241 {
 242   return _GCC_specific_handler (ms_exc, this_frame, ms_orig_context,
 243                                 ms_disp, __gcc_personality_imp);
 244 }
 245 #endif /* SEH */