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 */ 246