|
111
|
1 /* Common unwinding code for ARM EABI and C6X.
|
|
131
|
2 Copyright (C) 2004-2018 Free Software Foundation, Inc.
|
|
111
|
3 Contributed by Paul Brook
|
|
|
4
|
|
|
5 This file is free software; you can redistribute it and/or modify it
|
|
|
6 under the terms of the GNU General Public License as published by the
|
|
|
7 Free Software Foundation; either version 3, or (at your option) any
|
|
|
8 later version.
|
|
|
9
|
|
|
10 This file is distributed in the hope that it will be useful, but
|
|
|
11 WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
13 General Public License for more details.
|
|
|
14
|
|
|
15 Under Section 7 of GPL version 3, you are granted additional
|
|
|
16 permissions described in the GCC Runtime Library Exception, version
|
|
|
17 3.1, as published by the Free Software Foundation.
|
|
|
18
|
|
|
19 You should have received a copy of the GNU General Public License and
|
|
|
20 a copy of the GCC Runtime Library Exception along with this program;
|
|
|
21 see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
|
|
|
22 <http://www.gnu.org/licenses/>. */
|
|
|
23
|
|
|
24 #include "tconfig.h"
|
|
|
25 #include "tsystem.h"
|
|
|
26 #include "unwind.h"
|
|
|
27
|
|
|
28 /* Used for SystemTap unwinder probe. */
|
|
|
29 #ifdef HAVE_SYS_SDT_H
|
|
|
30 #include <sys/sdt.h>
|
|
|
31 #endif
|
|
|
32
|
|
|
33 /* We add a prototype for abort here to avoid creating a dependency on
|
|
|
34 target headers. */
|
|
|
35 extern void abort (void);
|
|
|
36
|
|
|
37 /* Definitions for C++ runtime support routines. We make these weak
|
|
|
38 declarations to avoid pulling in libsupc++ unnecessarily. */
|
|
|
39 typedef unsigned char bool;
|
|
|
40
|
|
|
41 typedef struct _ZSt9type_info type_info; /* This names C++ type_info type */
|
|
|
42 enum __cxa_type_match_result
|
|
|
43 {
|
|
|
44 ctm_failed = 0,
|
|
|
45 ctm_succeeded = 1,
|
|
|
46 ctm_succeeded_with_ptr_to_base = 2
|
|
|
47 };
|
|
|
48
|
|
|
49 void __attribute__((weak)) __cxa_call_unexpected(_Unwind_Control_Block *ucbp);
|
|
|
50 bool __attribute__((weak)) __cxa_begin_cleanup(_Unwind_Control_Block *ucbp);
|
|
|
51 enum __cxa_type_match_result __attribute__((weak)) __cxa_type_match
|
|
|
52 (_Unwind_Control_Block *ucbp, const type_info *rttip,
|
|
|
53 bool is_reference, void **matched_object);
|
|
|
54
|
|
|
55 _Unwind_Ptr __attribute__((weak))
|
|
|
56 __gnu_Unwind_Find_exidx (_Unwind_Ptr, int *);
|
|
|
57
|
|
|
58 #define EXIDX_CANTUNWIND 1
|
|
|
59 #define uint32_highbit (((_uw) 1) << 31)
|
|
|
60
|
|
|
61 #define UCB_FORCED_STOP_FN(ucbp) ((ucbp)->unwinder_cache.reserved1)
|
|
|
62 #define UCB_PR_ADDR(ucbp) ((ucbp)->unwinder_cache.reserved2)
|
|
|
63 #define UCB_SAVED_CALLSITE_ADDR(ucbp) ((ucbp)->unwinder_cache.reserved3)
|
|
|
64 #define UCB_FORCED_STOP_ARG(ucbp) ((ucbp)->unwinder_cache.reserved4)
|
|
|
65
|
|
|
66 /* Unwind descriptors. */
|
|
|
67
|
|
|
68 typedef struct
|
|
|
69 {
|
|
|
70 _uw16 length;
|
|
|
71 _uw16 offset;
|
|
|
72 } EHT16;
|
|
|
73
|
|
|
74 typedef struct
|
|
|
75 {
|
|
|
76 _uw length;
|
|
|
77 _uw offset;
|
|
|
78 } EHT32;
|
|
|
79
|
|
|
80 /* An exception index table entry. */
|
|
|
81
|
|
|
82 typedef struct __EIT_entry
|
|
|
83 {
|
|
|
84 _uw fnoffset;
|
|
|
85 _uw content;
|
|
|
86 } __EIT_entry;
|
|
|
87
|
|
|
88 /* Assembly helper functions. */
|
|
|
89
|
|
|
90 /* Restore core register state. Never returns. */
|
|
|
91 void __attribute__((noreturn)) restore_core_regs (struct core_regs *);
|
|
|
92
|
|
|
93
|
|
|
94 /* Restore coprocessor state after phase1 unwinding. */
|
|
|
95 static void restore_non_core_regs (phase1_vrs * vrs);
|
|
|
96
|
|
|
97 /* A better way to do this would probably be to compare the absolute address
|
|
|
98 with a segment relative relocation of the same symbol. */
|
|
|
99
|
|
|
100 extern int __text_start;
|
|
|
101 extern int __data_start;
|
|
|
102
|
|
|
103 /* The exception index table location. */
|
|
|
104 extern __EIT_entry __exidx_start;
|
|
|
105 extern __EIT_entry __exidx_end;
|
|
|
106
|
|
|
107 /* Core unwinding functions. */
|
|
|
108
|
|
|
109 /* Calculate the address encoded by a 31-bit self-relative offset at address
|
|
|
110 P. */
|
|
|
111 static inline _uw selfrel_offset31 (const _uw *p);
|
|
|
112
|
|
|
113 static _uw __gnu_unwind_get_pr_addr (int idx);
|
|
|
114
|
|
|
115 static void _Unwind_DebugHook (void *, void *)
|
|
|
116 __attribute__ ((__noinline__, __used__, __noclone__));
|
|
|
117
|
|
|
118 /* This function is called during unwinding. It is intended as a hook
|
|
|
119 for a debugger to intercept exceptions. CFA is the CFA of the
|
|
|
120 target frame. HANDLER is the PC to which control will be
|
|
|
121 transferred. */
|
|
|
122
|
|
|
123 static void
|
|
|
124 _Unwind_DebugHook (void *cfa __attribute__ ((__unused__)),
|
|
|
125 void *handler __attribute__ ((__unused__)))
|
|
|
126 {
|
|
|
127 /* We only want to use stap probes starting with v3. Earlier
|
|
|
128 versions added too much startup cost. */
|
|
|
129 #if defined (HAVE_SYS_SDT_H) && defined (STAP_PROBE2) && _SDT_NOTE_TYPE >= 3
|
|
|
130 STAP_PROBE2 (libgcc, unwind, cfa, handler);
|
|
|
131 #else
|
|
|
132 asm ("");
|
|
|
133 #endif
|
|
|
134 }
|
|
|
135
|
|
|
136 /* This is a wrapper to be called when we need to restore core registers.
|
|
|
137 It will call `_Unwind_DebugHook' before restoring the registers, thus
|
|
|
138 making it possible to intercept and debug exceptions.
|
|
|
139
|
|
|
140 When calling `_Unwind_DebugHook', the first argument (the CFA) is zero
|
|
|
141 because we are not interested in it. However, it must be there (even
|
|
|
142 being zero) because GDB expects to find it when using the probe. */
|
|
|
143
|
|
|
144 #define uw_restore_core_regs(TARGET, CORE) \
|
|
|
145 do \
|
|
|
146 { \
|
|
|
147 void *handler = __builtin_frob_return_addr ((void *) VRS_PC (TARGET)); \
|
|
|
148 _Unwind_DebugHook (0, handler); \
|
|
|
149 restore_core_regs (CORE); \
|
|
|
150 } \
|
|
|
151 while (0)
|
|
|
152
|
|
|
153 /* Perform a binary search for RETURN_ADDRESS in TABLE. The table contains
|
|
|
154 NREC entries. */
|
|
|
155
|
|
|
156 static const __EIT_entry *
|
|
|
157 search_EIT_table (const __EIT_entry * table, int nrec, _uw return_address)
|
|
|
158 {
|
|
|
159 _uw next_fn;
|
|
|
160 _uw this_fn;
|
|
|
161 int n, left, right;
|
|
|
162
|
|
|
163 if (nrec == 0)
|
|
|
164 return (__EIT_entry *) 0;
|
|
|
165
|
|
|
166 left = 0;
|
|
|
167 right = nrec - 1;
|
|
|
168
|
|
|
169 while (1)
|
|
|
170 {
|
|
|
171 n = (left + right) / 2;
|
|
|
172 this_fn = selfrel_offset31 (&table[n].fnoffset);
|
|
|
173 if (n != nrec - 1)
|
|
|
174 next_fn = selfrel_offset31 (&table[n + 1].fnoffset) - 1;
|
|
|
175 else
|
|
|
176 next_fn = (_uw)0 - 1;
|
|
|
177
|
|
|
178 if (return_address < this_fn)
|
|
|
179 {
|
|
|
180 if (n == left)
|
|
|
181 return (__EIT_entry *) 0;
|
|
|
182 right = n - 1;
|
|
|
183 }
|
|
|
184 else if (return_address <= next_fn)
|
|
|
185 return &table[n];
|
|
|
186 else
|
|
|
187 left = n + 1;
|
|
|
188 }
|
|
|
189 }
|
|
|
190
|
|
|
191 /* Find the exception index table eintry for the given address.
|
|
|
192 Fill in the relevant fields of the UCB.
|
|
|
193 Returns _URC_FAILURE if an error occurred, _URC_OK on success. */
|
|
|
194
|
|
|
195 static _Unwind_Reason_Code
|
|
|
196 get_eit_entry (_Unwind_Control_Block *ucbp, _uw return_address)
|
|
|
197 {
|
|
|
198 const __EIT_entry * eitp;
|
|
|
199 int nrec;
|
|
|
200
|
|
|
201 /* The return address is the address of the instruction following the
|
|
|
202 call instruction (plus one in thumb mode). If this was the last
|
|
|
203 instruction in the function the address will lie in the following
|
|
|
204 function. Subtract 2 from the address so that it points within the call
|
|
|
205 instruction itself. */
|
|
|
206 return_address -= 2;
|
|
|
207
|
|
|
208 if (__gnu_Unwind_Find_exidx)
|
|
|
209 {
|
|
|
210 eitp = (const __EIT_entry *) __gnu_Unwind_Find_exidx (return_address,
|
|
|
211 &nrec);
|
|
|
212 if (!eitp)
|
|
|
213 {
|
|
|
214 UCB_PR_ADDR (ucbp) = 0;
|
|
|
215 return _URC_FAILURE;
|
|
|
216 }
|
|
|
217 }
|
|
|
218 else
|
|
|
219 {
|
|
|
220 eitp = &__exidx_start;
|
|
|
221 nrec = &__exidx_end - &__exidx_start;
|
|
|
222 }
|
|
|
223
|
|
|
224 eitp = search_EIT_table (eitp, nrec, return_address);
|
|
|
225
|
|
|
226 if (!eitp)
|
|
|
227 {
|
|
|
228 UCB_PR_ADDR (ucbp) = 0;
|
|
|
229 return _URC_FAILURE;
|
|
|
230 }
|
|
|
231 ucbp->pr_cache.fnstart = selfrel_offset31 (&eitp->fnoffset);
|
|
|
232
|
|
|
233 /* Can this frame be unwound at all? */
|
|
|
234 if (eitp->content == EXIDX_CANTUNWIND)
|
|
|
235 {
|
|
|
236 UCB_PR_ADDR (ucbp) = 0;
|
|
|
237 return _URC_END_OF_STACK;
|
|
|
238 }
|
|
|
239
|
|
|
240 /* Obtain the address of the "real" __EHT_Header word. */
|
|
|
241
|
|
|
242 if (eitp->content & uint32_highbit)
|
|
|
243 {
|
|
|
244 /* It is immediate data. */
|
|
|
245 ucbp->pr_cache.ehtp = (_Unwind_EHT_Header *)&eitp->content;
|
|
|
246 ucbp->pr_cache.additional = 1;
|
|
|
247 }
|
|
|
248 else
|
|
|
249 {
|
|
|
250 /* The low 31 bits of the content field are a self-relative
|
|
|
251 offset to an _Unwind_EHT_Entry structure. */
|
|
|
252 ucbp->pr_cache.ehtp =
|
|
|
253 (_Unwind_EHT_Header *) selfrel_offset31 (&eitp->content);
|
|
|
254 ucbp->pr_cache.additional = 0;
|
|
|
255 }
|
|
|
256
|
|
|
257 /* Discover the personality routine address. */
|
|
|
258 if (*ucbp->pr_cache.ehtp & (1u << 31))
|
|
|
259 {
|
|
|
260 /* One of the predefined standard routines. */
|
|
|
261 _uw idx = (*(_uw *) ucbp->pr_cache.ehtp >> 24) & 0xf;
|
|
|
262 UCB_PR_ADDR (ucbp) = __gnu_unwind_get_pr_addr (idx);
|
|
|
263 if (UCB_PR_ADDR (ucbp) == 0)
|
|
|
264 {
|
|
|
265 /* Failed */
|
|
|
266 return _URC_FAILURE;
|
|
|
267 }
|
|
|
268 }
|
|
|
269 else
|
|
|
270 {
|
|
|
271 /* Execute region offset to PR */
|
|
|
272 UCB_PR_ADDR (ucbp) = selfrel_offset31 (ucbp->pr_cache.ehtp);
|
|
|
273 }
|
|
|
274 return _URC_OK;
|
|
|
275 }
|
|
|
276
|
|
|
277
|
|
|
278 /* Perform phase2 unwinding. VRS is the initial virtual register state. */
|
|
|
279
|
|
|
280 static void __attribute__((noreturn))
|
|
|
281 unwind_phase2 (_Unwind_Control_Block * ucbp, phase2_vrs * vrs)
|
|
|
282 {
|
|
|
283 _Unwind_Reason_Code pr_result;
|
|
|
284
|
|
|
285 do
|
|
|
286 {
|
|
|
287 /* Find the entry for this routine. */
|
|
|
288 if (get_eit_entry (ucbp, VRS_PC(vrs)) != _URC_OK)
|
|
|
289 abort ();
|
|
|
290
|
|
|
291 UCB_SAVED_CALLSITE_ADDR (ucbp) = VRS_PC(vrs);
|
|
|
292
|
|
|
293 /* Call the pr to decide what to do. */
|
|
|
294 pr_result = ((personality_routine) UCB_PR_ADDR (ucbp))
|
|
|
295 (_US_UNWIND_FRAME_STARTING, ucbp, (_Unwind_Context *) vrs);
|
|
|
296 }
|
|
|
297 while (pr_result == _URC_CONTINUE_UNWIND);
|
|
|
298
|
|
|
299 if (pr_result != _URC_INSTALL_CONTEXT)
|
|
|
300 abort();
|
|
|
301
|
|
|
302 uw_restore_core_regs (vrs, &vrs->core);
|
|
|
303 }
|
|
|
304
|
|
|
305 /* Perform phase2 forced unwinding. */
|
|
|
306
|
|
|
307 static _Unwind_Reason_Code
|
|
|
308 unwind_phase2_forced (_Unwind_Control_Block *ucbp, phase2_vrs *entry_vrs,
|
|
|
309 int resuming)
|
|
|
310 {
|
|
|
311 _Unwind_Stop_Fn stop_fn = (_Unwind_Stop_Fn) UCB_FORCED_STOP_FN (ucbp);
|
|
|
312 void *stop_arg = (void *)UCB_FORCED_STOP_ARG (ucbp);
|
|
|
313 _Unwind_Reason_Code pr_result = 0;
|
|
|
314 /* We use phase1_vrs here even though we do not demand save, for the
|
|
|
315 prev_sp field. */
|
|
|
316 phase1_vrs saved_vrs, next_vrs;
|
|
|
317
|
|
|
318 /* Save the core registers. */
|
|
|
319 saved_vrs.core = entry_vrs->core;
|
|
|
320 /* We don't need to demand-save the non-core registers, because we
|
|
|
321 unwind in a single pass. */
|
|
|
322 saved_vrs.demand_save_flags = 0;
|
|
|
323
|
|
|
324 /* Unwind until we reach a propagation barrier. */
|
|
|
325 do
|
|
|
326 {
|
|
|
327 _Unwind_State action;
|
|
|
328 _Unwind_Reason_Code entry_code;
|
|
|
329 _Unwind_Reason_Code stop_code;
|
|
|
330
|
|
|
331 /* Find the entry for this routine. */
|
|
|
332 entry_code = get_eit_entry (ucbp, VRS_PC (&saved_vrs));
|
|
|
333
|
|
|
334 if (resuming)
|
|
|
335 {
|
|
|
336 action = _US_UNWIND_FRAME_RESUME | _US_FORCE_UNWIND;
|
|
|
337 resuming = 0;
|
|
|
338 }
|
|
|
339 else
|
|
|
340 action = _US_UNWIND_FRAME_STARTING | _US_FORCE_UNWIND;
|
|
|
341
|
|
|
342 if (entry_code == _URC_OK)
|
|
|
343 {
|
|
|
344 UCB_SAVED_CALLSITE_ADDR (ucbp) = VRS_PC (&saved_vrs);
|
|
|
345
|
|
|
346 next_vrs = saved_vrs;
|
|
|
347
|
|
|
348 /* Call the pr to decide what to do. */
|
|
|
349 pr_result = ((personality_routine) UCB_PR_ADDR (ucbp))
|
|
|
350 (action, ucbp, (void *) &next_vrs);
|
|
|
351
|
|
|
352 saved_vrs.prev_sp = VRS_SP (&next_vrs);
|
|
|
353 }
|
|
|
354 else
|
|
|
355 {
|
|
|
356 /* Treat any failure as the end of unwinding, to cope more
|
|
|
357 gracefully with missing EH information. Mixed EH and
|
|
|
358 non-EH within one object will usually result in failure,
|
|
|
359 because the .ARM.exidx tables do not indicate the end
|
|
|
360 of the code to which they apply; but mixed EH and non-EH
|
|
|
361 shared objects should return an unwind failure at the
|
|
|
362 entry of a non-EH shared object. */
|
|
|
363 action |= _US_END_OF_STACK;
|
|
|
364
|
|
|
365 saved_vrs.prev_sp = VRS_SP (&saved_vrs);
|
|
|
366 }
|
|
|
367
|
|
|
368 stop_code = stop_fn (1, action, ucbp->exception_class, ucbp,
|
|
|
369 (void *)&saved_vrs, stop_arg);
|
|
|
370 if (stop_code != _URC_NO_REASON)
|
|
|
371 return _URC_FAILURE;
|
|
|
372
|
|
|
373 if (entry_code != _URC_OK)
|
|
|
374 return entry_code;
|
|
|
375
|
|
|
376 saved_vrs = next_vrs;
|
|
|
377 }
|
|
|
378 while (pr_result == _URC_CONTINUE_UNWIND);
|
|
|
379
|
|
|
380 if (pr_result != _URC_INSTALL_CONTEXT)
|
|
|
381 {
|
|
|
382 /* Some sort of failure has occurred in the pr and probably the
|
|
|
383 pr returned _URC_FAILURE. */
|
|
|
384 return _URC_FAILURE;
|
|
|
385 }
|
|
|
386
|
|
|
387 uw_restore_core_regs (&saved_vrs, &saved_vrs.core);
|
|
|
388 }
|
|
|
389
|
|
|
390 /* This is a very limited implementation of _Unwind_GetCFA. It returns
|
|
|
391 the stack pointer as it is about to be unwound, and is only valid
|
|
|
392 while calling the stop function during forced unwinding. If the
|
|
|
393 current personality routine result is going to run a cleanup, this
|
|
|
394 will not be the CFA; but when the frame is really unwound, it will
|
|
|
395 be. */
|
|
|
396
|
|
|
397 _Unwind_Word
|
|
|
398 _Unwind_GetCFA (_Unwind_Context *context)
|
|
|
399 {
|
|
|
400 return ((phase1_vrs *) context)->prev_sp;
|
|
|
401 }
|
|
|
402
|
|
|
403 /* Perform phase1 unwinding. UCBP is the exception being thrown, and
|
|
|
404 entry_VRS is the register state on entry to _Unwind_RaiseException. */
|
|
|
405
|
|
|
406 _Unwind_Reason_Code
|
|
|
407 __gnu_Unwind_RaiseException (_Unwind_Control_Block *, phase2_vrs *);
|
|
|
408
|
|
|
409 _Unwind_Reason_Code
|
|
|
410 __gnu_Unwind_RaiseException (_Unwind_Control_Block * ucbp,
|
|
|
411 phase2_vrs * entry_vrs)
|
|
|
412 {
|
|
|
413 phase1_vrs saved_vrs;
|
|
|
414 _Unwind_Reason_Code pr_result;
|
|
|
415
|
|
|
416 /* Set the pc to the call site. */
|
|
|
417 VRS_PC (entry_vrs) = VRS_RETURN(entry_vrs);
|
|
|
418
|
|
|
419 /* Save the core registers. */
|
|
|
420 saved_vrs.core = entry_vrs->core;
|
|
|
421 /* Set demand-save flags. */
|
|
|
422 saved_vrs.demand_save_flags = ~(_uw) 0;
|
|
|
423
|
|
|
424 /* Unwind until we reach a propagation barrier. */
|
|
|
425 do
|
|
|
426 {
|
|
|
427 /* Find the entry for this routine. */
|
|
|
428 if (get_eit_entry (ucbp, VRS_PC (&saved_vrs)) != _URC_OK)
|
|
|
429 return _URC_FAILURE;
|
|
|
430
|
|
|
431 /* Call the pr to decide what to do. */
|
|
|
432 pr_result = ((personality_routine) UCB_PR_ADDR (ucbp))
|
|
|
433 (_US_VIRTUAL_UNWIND_FRAME, ucbp, (void *) &saved_vrs);
|
|
|
434 }
|
|
|
435 while (pr_result == _URC_CONTINUE_UNWIND);
|
|
|
436
|
|
|
437 /* We've unwound as far as we want to go, so restore the original
|
|
|
438 register state. */
|
|
|
439 restore_non_core_regs (&saved_vrs);
|
|
|
440 if (pr_result != _URC_HANDLER_FOUND)
|
|
|
441 {
|
|
|
442 /* Some sort of failure has occurred in the pr and probably the
|
|
|
443 pr returned _URC_FAILURE. */
|
|
|
444 return _URC_FAILURE;
|
|
|
445 }
|
|
|
446
|
|
|
447 unwind_phase2 (ucbp, entry_vrs);
|
|
|
448 }
|
|
|
449
|
|
|
450 /* Resume unwinding after a cleanup has been run. UCBP is the exception
|
|
|
451 being thrown and ENTRY_VRS is the register state on entry to
|
|
|
452 _Unwind_Resume. */
|
|
|
453 _Unwind_Reason_Code
|
|
|
454 __gnu_Unwind_ForcedUnwind (_Unwind_Control_Block *,
|
|
|
455 _Unwind_Stop_Fn, void *, phase2_vrs *);
|
|
|
456
|
|
|
457 _Unwind_Reason_Code
|
|
|
458 __gnu_Unwind_ForcedUnwind (_Unwind_Control_Block *ucbp,
|
|
|
459 _Unwind_Stop_Fn stop_fn, void *stop_arg,
|
|
|
460 phase2_vrs *entry_vrs)
|
|
|
461 {
|
|
|
462 UCB_FORCED_STOP_FN (ucbp) = (_uw) stop_fn;
|
|
|
463 UCB_FORCED_STOP_ARG (ucbp) = (_uw) stop_arg;
|
|
|
464
|
|
|
465 /* Set the pc to the call site. */
|
|
|
466 VRS_PC (entry_vrs) = VRS_RETURN(entry_vrs);
|
|
|
467
|
|
|
468 return unwind_phase2_forced (ucbp, entry_vrs, 0);
|
|
|
469 }
|
|
|
470
|
|
|
471 _Unwind_Reason_Code
|
|
|
472 __gnu_Unwind_Resume (_Unwind_Control_Block *, phase2_vrs *);
|
|
|
473
|
|
|
474 _Unwind_Reason_Code
|
|
|
475 __gnu_Unwind_Resume (_Unwind_Control_Block * ucbp, phase2_vrs * entry_vrs)
|
|
|
476 {
|
|
|
477 _Unwind_Reason_Code pr_result;
|
|
|
478
|
|
|
479 /* Recover the saved address. */
|
|
|
480 VRS_PC (entry_vrs) = UCB_SAVED_CALLSITE_ADDR (ucbp);
|
|
|
481
|
|
|
482 if (UCB_FORCED_STOP_FN (ucbp))
|
|
|
483 {
|
|
|
484 unwind_phase2_forced (ucbp, entry_vrs, 1);
|
|
|
485
|
|
|
486 /* We can't return failure at this point. */
|
|
|
487 abort ();
|
|
|
488 }
|
|
|
489
|
|
|
490 /* Call the cached PR. */
|
|
|
491 pr_result = ((personality_routine) UCB_PR_ADDR (ucbp))
|
|
|
492 (_US_UNWIND_FRAME_RESUME, ucbp, (_Unwind_Context *) entry_vrs);
|
|
|
493
|
|
|
494 switch (pr_result)
|
|
|
495 {
|
|
|
496 case _URC_INSTALL_CONTEXT:
|
|
|
497 /* Upload the registers to enter the landing pad. */
|
|
|
498 uw_restore_core_regs (entry_vrs, &entry_vrs->core);
|
|
|
499
|
|
|
500 case _URC_CONTINUE_UNWIND:
|
|
|
501 /* Continue unwinding the next frame. */
|
|
|
502 unwind_phase2 (ucbp, entry_vrs);
|
|
|
503
|
|
|
504 default:
|
|
|
505 abort ();
|
|
|
506 }
|
|
|
507 }
|
|
|
508
|
|
|
509 _Unwind_Reason_Code
|
|
|
510 __gnu_Unwind_Resume_or_Rethrow (_Unwind_Control_Block *, phase2_vrs *);
|
|
|
511
|
|
|
512 _Unwind_Reason_Code
|
|
|
513 __gnu_Unwind_Resume_or_Rethrow (_Unwind_Control_Block * ucbp,
|
|
|
514 phase2_vrs * entry_vrs)
|
|
|
515 {
|
|
|
516 if (!UCB_FORCED_STOP_FN (ucbp))
|
|
|
517 return __gnu_Unwind_RaiseException (ucbp, entry_vrs);
|
|
|
518
|
|
|
519 /* Set the pc to the call site. */
|
|
|
520 VRS_PC (entry_vrs) = VRS_RETURN (entry_vrs);
|
|
|
521 /* Continue unwinding the next frame. */
|
|
|
522 return unwind_phase2_forced (ucbp, entry_vrs, 0);
|
|
|
523 }
|
|
|
524
|
|
|
525 /* Clean up an exception object when unwinding is complete. */
|
|
|
526 void
|
|
|
527 _Unwind_Complete (_Unwind_Control_Block * ucbp __attribute__((unused)))
|
|
|
528 {
|
|
|
529 }
|
|
|
530
|
|
|
531
|
|
|
532 /* Free an exception. */
|
|
|
533
|
|
|
534 void
|
|
|
535 _Unwind_DeleteException (_Unwind_Exception * exc)
|
|
|
536 {
|
|
|
537 if (exc->exception_cleanup)
|
|
|
538 (*exc->exception_cleanup) (_URC_FOREIGN_EXCEPTION_CAUGHT, exc);
|
|
|
539 }
|
|
|
540
|
|
|
541
|
|
|
542 /* Perform stack backtrace through unwind data. */
|
|
|
543 _Unwind_Reason_Code
|
|
|
544 __gnu_Unwind_Backtrace(_Unwind_Trace_Fn trace, void * trace_argument,
|
|
|
545 phase2_vrs * entry_vrs);
|
|
|
546 _Unwind_Reason_Code
|
|
|
547 __gnu_Unwind_Backtrace(_Unwind_Trace_Fn trace, void * trace_argument,
|
|
|
548 phase2_vrs * entry_vrs)
|
|
|
549 {
|
|
|
550 phase1_vrs saved_vrs;
|
|
|
551 _Unwind_Reason_Code code;
|
|
|
552
|
|
|
553 _Unwind_Control_Block ucb;
|
|
|
554 _Unwind_Control_Block *ucbp = &ucb;
|
|
|
555
|
|
|
556 /* Set the pc to the call site. */
|
|
|
557 VRS_PC (entry_vrs) = VRS_RETURN (entry_vrs);
|
|
|
558
|
|
|
559 /* Save the core registers. */
|
|
|
560 saved_vrs.core = entry_vrs->core;
|
|
|
561 /* Set demand-save flags. */
|
|
|
562 saved_vrs.demand_save_flags = ~(_uw) 0;
|
|
|
563
|
|
|
564 do
|
|
|
565 {
|
|
|
566 /* Find the entry for this routine. */
|
|
|
567 if (get_eit_entry (ucbp, VRS_PC (&saved_vrs)) != _URC_OK)
|
|
|
568 {
|
|
|
569 code = _URC_FAILURE;
|
|
|
570 break;
|
|
|
571 }
|
|
|
572
|
|
|
573 /* The dwarf unwinder assumes the context structure holds things
|
|
|
574 like the function and LSDA pointers. The ARM implementation
|
|
|
575 caches these in the exception header (UCB). To avoid
|
|
|
576 rewriting everything we make the virtual IP register point at
|
|
|
577 the UCB. */
|
|
|
578 _Unwind_SetGR((_Unwind_Context *)&saved_vrs, UNWIND_POINTER_REG, (_Unwind_Ptr) ucbp);
|
|
|
579
|
|
|
580 /* Call trace function. */
|
|
|
581 if ((*trace) ((_Unwind_Context *) &saved_vrs, trace_argument)
|
|
|
582 != _URC_NO_REASON)
|
|
|
583 {
|
|
|
584 code = _URC_FAILURE;
|
|
|
585 break;
|
|
|
586 }
|
|
|
587
|
|
|
588 /* Call the pr to decide what to do. */
|
|
|
589 code = ((personality_routine) UCB_PR_ADDR (ucbp))
|
|
|
590 (_US_VIRTUAL_UNWIND_FRAME | _US_FORCE_UNWIND,
|
|
|
591 ucbp, (void *) &saved_vrs);
|
|
|
592 }
|
|
|
593 while (code != _URC_END_OF_STACK
|
|
|
594 && code != _URC_FAILURE);
|
|
|
595
|
|
|
596 restore_non_core_regs (&saved_vrs);
|
|
|
597 return code;
|
|
|
598 }
|
|
|
599
|
|
|
600
|
|
|
601 /* Common implementation for ARM ABI defined personality routines.
|
|
|
602 ID is the index of the personality routine, other arguments are as defined
|
|
|
603 by __aeabi_unwind_cpp_pr{0,1,2}. */
|
|
|
604
|
|
|
605 static _Unwind_Reason_Code
|
|
|
606 __gnu_unwind_pr_common (_Unwind_State state,
|
|
|
607 _Unwind_Control_Block *ucbp,
|
|
|
608 _Unwind_Context *context,
|
|
|
609 int id)
|
|
|
610 {
|
|
|
611 __gnu_unwind_state uws;
|
|
|
612 _uw *data;
|
|
|
613 _uw offset;
|
|
|
614 _uw len;
|
|
|
615 _uw rtti_count;
|
|
|
616 int phase2_call_unexpected_after_unwind = 0;
|
|
|
617 int in_range = 0;
|
|
|
618 int forced_unwind = state & _US_FORCE_UNWIND;
|
|
|
619
|
|
|
620 state &= _US_ACTION_MASK;
|
|
|
621
|
|
|
622 data = (_uw *) ucbp->pr_cache.ehtp;
|
|
|
623 uws.data = *(data++);
|
|
|
624 uws.next = data;
|
|
|
625 if (id == 0)
|
|
|
626 {
|
|
|
627 uws.data <<= 8;
|
|
|
628 uws.words_left = 0;
|
|
|
629 uws.bytes_left = 3;
|
|
|
630 }
|
|
|
631 else if (id < 3)
|
|
|
632 {
|
|
|
633 uws.words_left = (uws.data >> 16) & 0xff;
|
|
|
634 uws.data <<= 16;
|
|
|
635 uws.bytes_left = 2;
|
|
|
636 data += uws.words_left;
|
|
|
637 }
|
|
|
638
|
|
|
639 /* Restore the saved pointer. */
|
|
|
640 if (state == _US_UNWIND_FRAME_RESUME)
|
|
|
641 data = (_uw *) ucbp->cleanup_cache.bitpattern[0];
|
|
|
642
|
|
|
643 if ((ucbp->pr_cache.additional & 1) == 0)
|
|
|
644 {
|
|
|
645 /* Process descriptors. */
|
|
|
646 while (*data)
|
|
|
647 {
|
|
|
648 _uw addr;
|
|
|
649 _uw fnstart;
|
|
|
650
|
|
|
651 if (id == 2)
|
|
|
652 {
|
|
|
653 len = ((EHT32 *) data)->length;
|
|
|
654 offset = ((EHT32 *) data)->offset;
|
|
|
655 data += 2;
|
|
|
656 }
|
|
|
657 else
|
|
|
658 {
|
|
|
659 len = ((EHT16 *) data)->length;
|
|
|
660 offset = ((EHT16 *) data)->offset;
|
|
|
661 data++;
|
|
|
662 }
|
|
|
663
|
|
|
664 fnstart = ucbp->pr_cache.fnstart + (offset & ~1);
|
|
|
665 addr = _Unwind_GetGR (context, R_PC);
|
|
|
666 in_range = (fnstart <= addr && addr < fnstart + (len & ~1));
|
|
|
667
|
|
|
668 switch (((offset & 1) << 1) | (len & 1))
|
|
|
669 {
|
|
|
670 case 0:
|
|
|
671 /* Cleanup. */
|
|
|
672 if (state != _US_VIRTUAL_UNWIND_FRAME
|
|
|
673 && in_range)
|
|
|
674 {
|
|
|
675 /* Cleanup in range, and we are running cleanups. */
|
|
|
676 _uw lp;
|
|
|
677
|
|
|
678 /* Landing pad address is 31-bit pc-relative offset. */
|
|
|
679 lp = selfrel_offset31 (data);
|
|
|
680 data++;
|
|
|
681 /* Save the exception data pointer. */
|
|
|
682 ucbp->cleanup_cache.bitpattern[0] = (_uw) data;
|
|
|
683 if (!__cxa_begin_cleanup (ucbp))
|
|
|
684 return _URC_FAILURE;
|
|
|
685 /* Setup the VRS to enter the landing pad. */
|
|
|
686 _Unwind_SetGR (context, R_PC, lp);
|
|
|
687 return _URC_INSTALL_CONTEXT;
|
|
|
688 }
|
|
|
689 /* Cleanup not in range, or we are in stage 1. */
|
|
|
690 data++;
|
|
|
691 break;
|
|
|
692
|
|
|
693 case 1:
|
|
|
694 /* Catch handler. */
|
|
|
695 if (state == _US_VIRTUAL_UNWIND_FRAME)
|
|
|
696 {
|
|
|
697 if (in_range)
|
|
|
698 {
|
|
|
699 /* Check for a barrier. */
|
|
|
700 _uw rtti;
|
|
|
701 bool is_reference = (data[0] & uint32_highbit) != 0;
|
|
|
702 void *matched;
|
|
|
703 enum __cxa_type_match_result match_type;
|
|
|
704
|
|
|
705 /* Check for no-throw areas. */
|
|
|
706 if (data[1] == (_uw) -2)
|
|
|
707 return _URC_FAILURE;
|
|
|
708
|
|
|
709 /* The thrown object immediately follows the ECB. */
|
|
|
710 matched = (void *)(ucbp + 1);
|
|
|
711 if (data[1] != (_uw) -1)
|
|
|
712 {
|
|
|
713 /* Match a catch specification. */
|
|
|
714 rtti = _Unwind_decode_typeinfo_ptr (0,
|
|
|
715 (_uw) &data[1]);
|
|
|
716 match_type = __cxa_type_match (ucbp,
|
|
|
717 (type_info *) rtti,
|
|
|
718 is_reference,
|
|
|
719 &matched);
|
|
|
720 }
|
|
|
721 else
|
|
|
722 match_type = ctm_succeeded;
|
|
|
723
|
|
|
724 if (match_type)
|
|
|
725 {
|
|
|
726 ucbp->barrier_cache.sp =
|
|
|
727 _Unwind_GetGR (context, R_SP);
|
|
|
728 // ctm_succeeded_with_ptr_to_base really
|
|
|
729 // means _c_t_m indirected the pointer
|
|
|
730 // object. We have to reconstruct the
|
|
|
731 // additional pointer layer by using a temporary.
|
|
|
732 if (match_type == ctm_succeeded_with_ptr_to_base)
|
|
|
733 {
|
|
|
734 ucbp->barrier_cache.bitpattern[2]
|
|
|
735 = (_uw) matched;
|
|
|
736 ucbp->barrier_cache.bitpattern[0]
|
|
|
737 = (_uw) &ucbp->barrier_cache.bitpattern[2];
|
|
|
738 }
|
|
|
739 else
|
|
|
740 ucbp->barrier_cache.bitpattern[0] = (_uw) matched;
|
|
|
741 ucbp->barrier_cache.bitpattern[1] = (_uw) data;
|
|
|
742 return _URC_HANDLER_FOUND;
|
|
|
743 }
|
|
|
744 }
|
|
|
745 /* Handler out of range, or not matched. */
|
|
|
746 }
|
|
|
747 else if (ucbp->barrier_cache.sp == _Unwind_GetGR (context, R_SP)
|
|
|
748 && ucbp->barrier_cache.bitpattern[1] == (_uw) data)
|
|
|
749 {
|
|
|
750 /* Matched a previous propagation barrier. */
|
|
|
751 _uw lp;
|
|
|
752
|
|
|
753 /* Setup for entry to the handler. */
|
|
|
754 lp = selfrel_offset31 (data);
|
|
|
755 _Unwind_SetGR (context, R_PC, lp);
|
|
|
756 _Unwind_SetGR (context, 0, (_uw) ucbp);
|
|
|
757 return _URC_INSTALL_CONTEXT;
|
|
|
758 }
|
|
|
759 /* Catch handler not matched. Advance to the next descriptor. */
|
|
|
760 data += 2;
|
|
|
761 break;
|
|
|
762
|
|
|
763 case 2:
|
|
|
764 rtti_count = data[0] & 0x7fffffff;
|
|
|
765 /* Exception specification. */
|
|
|
766 if (state == _US_VIRTUAL_UNWIND_FRAME)
|
|
|
767 {
|
|
|
768 if (in_range && (!forced_unwind || !rtti_count))
|
|
|
769 {
|
|
|
770 /* Match against the exception specification. */
|
|
|
771 _uw i;
|
|
|
772 _uw rtti;
|
|
|
773 void *matched;
|
|
|
774
|
|
|
775 for (i = 0; i < rtti_count; i++)
|
|
|
776 {
|
|
|
777 matched = (void *)(ucbp + 1);
|
|
|
778 rtti = _Unwind_decode_typeinfo_ptr (0,
|
|
|
779 (_uw) &data[i + 1]);
|
|
|
780 if (__cxa_type_match (ucbp, (type_info *) rtti, 0,
|
|
|
781 &matched))
|
|
|
782 break;
|
|
|
783 }
|
|
|
784
|
|
|
785 if (i == rtti_count)
|
|
|
786 {
|
|
|
787 /* Exception does not match the spec. */
|
|
|
788 ucbp->barrier_cache.sp =
|
|
|
789 _Unwind_GetGR (context, R_SP);
|
|
|
790 ucbp->barrier_cache.bitpattern[0] = (_uw) matched;
|
|
|
791 ucbp->barrier_cache.bitpattern[1] = (_uw) data;
|
|
|
792 return _URC_HANDLER_FOUND;
|
|
|
793 }
|
|
|
794 }
|
|
|
795 /* Handler out of range, or exception is permitted. */
|
|
|
796 }
|
|
|
797 else if (ucbp->barrier_cache.sp == _Unwind_GetGR (context, R_SP)
|
|
|
798 && ucbp->barrier_cache.bitpattern[1] == (_uw) data)
|
|
|
799 {
|
|
|
800 /* Matched a previous propagation barrier. */
|
|
|
801 _uw lp;
|
|
|
802 /* Record the RTTI list for __cxa_call_unexpected. */
|
|
|
803 ucbp->barrier_cache.bitpattern[1] = rtti_count;
|
|
|
804 ucbp->barrier_cache.bitpattern[2] = 0;
|
|
|
805 ucbp->barrier_cache.bitpattern[3] = 4;
|
|
|
806 ucbp->barrier_cache.bitpattern[4] = (_uw) &data[1];
|
|
|
807
|
|
|
808 if (data[0] & uint32_highbit)
|
|
|
809 {
|
|
|
810 data += rtti_count + 1;
|
|
|
811 /* Setup for entry to the handler. */
|
|
|
812 lp = selfrel_offset31 (data);
|
|
|
813 data++;
|
|
|
814 _Unwind_SetGR (context, R_PC, lp);
|
|
|
815 _Unwind_SetGR (context, 0, (_uw) ucbp);
|
|
|
816 return _URC_INSTALL_CONTEXT;
|
|
|
817 }
|
|
|
818 else
|
|
|
819 phase2_call_unexpected_after_unwind = 1;
|
|
|
820 }
|
|
|
821 if (data[0] & uint32_highbit)
|
|
|
822 data++;
|
|
|
823 data += rtti_count + 1;
|
|
|
824 break;
|
|
|
825
|
|
|
826 default:
|
|
|
827 /* Should never happen. */
|
|
|
828 return _URC_FAILURE;
|
|
|
829 }
|
|
|
830 /* Finished processing this descriptor. */
|
|
|
831 }
|
|
|
832 }
|
|
|
833
|
|
|
834 if (id >= 3)
|
|
|
835 {
|
|
|
836 /* 24-bit ecoding */
|
|
|
837 if (__gnu_unwind_24bit (context, uws.data, id == 4) != _URC_OK)
|
|
|
838 return _URC_FAILURE;
|
|
|
839 }
|
|
|
840 else
|
|
|
841 {
|
|
|
842 if (__gnu_unwind_execute (context, &uws) != _URC_OK)
|
|
|
843 return _URC_FAILURE;
|
|
|
844 }
|
|
|
845
|
|
|
846 if (phase2_call_unexpected_after_unwind)
|
|
|
847 {
|
|
|
848 /* Enter __cxa_unexpected as if called from the call site. */
|
|
|
849 _Unwind_SetGR (context, R_LR, _Unwind_GetGR (context, R_PC));
|
|
|
850 _Unwind_SetGR (context, R_PC, (_uw) &__cxa_call_unexpected);
|
|
|
851 return _URC_INSTALL_CONTEXT;
|
|
|
852 }
|
|
|
853
|
|
|
854 return _URC_CONTINUE_UNWIND;
|
|
|
855 }
|
