0
|
1 /* DWARF2 exception handling and frame unwinding for Xtensa.
|
|
2 Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
|
|
3 2007, 2008, 2009
|
|
4 Free Software Foundation, Inc.
|
|
5
|
|
6 This file is part of GCC.
|
|
7
|
|
8 GCC is free software; you can redistribute it and/or modify it
|
|
9 under the terms of the GNU General Public License as published by
|
|
10 the Free Software Foundation; either version 3, or (at your option)
|
|
11 any later version.
|
|
12
|
|
13 GCC is distributed in the hope that it will be useful, but WITHOUT
|
|
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
|
15 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
|
|
16 License 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 "coretypes.h"
|
|
30 #include "tm.h"
|
|
31 #include "dwarf2.h"
|
|
32 #include "unwind.h"
|
|
33 #ifdef __USING_SJLJ_EXCEPTIONS__
|
|
34 # define NO_SIZE_OF_ENCODED_VALUE
|
|
35 #endif
|
|
36 #include "unwind-pe.h"
|
|
37 #include "unwind-dw2-fde.h"
|
|
38 #include "unwind-dw2-xtensa.h"
|
|
39
|
|
40 #ifndef __USING_SJLJ_EXCEPTIONS__
|
|
41
|
|
42 /* The standard CIE and FDE structures work fine for Xtensa but the
|
|
43 variable-size register window save areas are not a good fit for the rest
|
|
44 of the standard DWARF unwinding mechanism. Nor is that mechanism
|
|
45 necessary, since the register save areas are always in fixed locations
|
|
46 in each stack frame. This file is a stripped down and customized version
|
|
47 of the standard DWARF unwinding code. It needs to be customized to have
|
|
48 builtin logic for finding the save areas and also to track the stack
|
|
49 pointer value (besides the CFA) while unwinding since the primary save
|
|
50 area is located below the stack pointer. It is stripped down to reduce
|
|
51 code size and ease the maintenance burden of tracking changes in the
|
|
52 standard version of the code. */
|
|
53
|
|
54 #ifndef DWARF_REG_TO_UNWIND_COLUMN
|
|
55 #define DWARF_REG_TO_UNWIND_COLUMN(REGNO) (REGNO)
|
|
56 #endif
|
|
57
|
|
58 #define XTENSA_RA_FIELD_MASK 0x3FFFFFFF
|
|
59
|
|
60 /* This is the register and unwind state for a particular frame. This
|
|
61 provides the information necessary to unwind up past a frame and return
|
|
62 to its caller. */
|
|
63 struct _Unwind_Context
|
|
64 {
|
|
65 /* Track register window save areas of 4 registers each, instead of
|
|
66 keeping separate addresses for the individual registers. */
|
|
67 _Unwind_Word *reg[4];
|
|
68
|
|
69 void *cfa;
|
|
70 void *sp;
|
|
71 void *ra;
|
|
72
|
|
73 /* Cache the 2 high bits to replace the window size in return addresses. */
|
|
74 _Unwind_Word ra_high_bits;
|
|
75
|
|
76 void *lsda;
|
|
77 struct dwarf_eh_bases bases;
|
|
78 /* Signal frame context. */
|
|
79 #define SIGNAL_FRAME_BIT ((~(_Unwind_Word) 0 >> 1) + 1)
|
|
80 _Unwind_Word flags;
|
|
81 /* 0 for now, can be increased when further fields are added to
|
|
82 struct _Unwind_Context. */
|
|
83 _Unwind_Word version;
|
|
84 };
|
|
85
|
|
86
|
|
87 /* Read unaligned data from the instruction buffer. */
|
|
88
|
|
89 union unaligned
|
|
90 {
|
|
91 void *p;
|
|
92 } __attribute__ ((packed));
|
|
93
|
|
94 static void uw_update_context (struct _Unwind_Context *, _Unwind_FrameState *);
|
|
95 static _Unwind_Reason_Code uw_frame_state_for (struct _Unwind_Context *,
|
|
96 _Unwind_FrameState *);
|
|
97
|
|
98 static inline void *
|
|
99 read_pointer (const void *p) { const union unaligned *up = p; return up->p; }
|
|
100
|
|
101 static inline _Unwind_Word
|
|
102 _Unwind_IsSignalFrame (struct _Unwind_Context *context)
|
|
103 {
|
|
104 return (context->flags & SIGNAL_FRAME_BIT) ? 1 : 0;
|
|
105 }
|
|
106
|
|
107 static inline void
|
|
108 _Unwind_SetSignalFrame (struct _Unwind_Context *context, int val)
|
|
109 {
|
|
110 if (val)
|
|
111 context->flags |= SIGNAL_FRAME_BIT;
|
|
112 else
|
|
113 context->flags &= ~SIGNAL_FRAME_BIT;
|
|
114 }
|
|
115
|
|
116 /* Get the value of register INDEX as saved in CONTEXT. */
|
|
117
|
|
118 inline _Unwind_Word
|
|
119 _Unwind_GetGR (struct _Unwind_Context *context, int index)
|
|
120 {
|
|
121 _Unwind_Word *ptr;
|
|
122
|
|
123 index = DWARF_REG_TO_UNWIND_COLUMN (index);
|
|
124 ptr = context->reg[index >> 2] + (index & 3);
|
|
125
|
|
126 return *ptr;
|
|
127 }
|
|
128
|
|
129 /* Get the value of the CFA as saved in CONTEXT. */
|
|
130
|
|
131 _Unwind_Word
|
|
132 _Unwind_GetCFA (struct _Unwind_Context *context)
|
|
133 {
|
|
134 return (_Unwind_Ptr) context->cfa;
|
|
135 }
|
|
136
|
|
137 /* Overwrite the saved value for register INDEX in CONTEXT with VAL. */
|
|
138
|
|
139 inline void
|
|
140 _Unwind_SetGR (struct _Unwind_Context *context, int index, _Unwind_Word val)
|
|
141 {
|
|
142 _Unwind_Word *ptr;
|
|
143
|
|
144 index = DWARF_REG_TO_UNWIND_COLUMN (index);
|
|
145 ptr = context->reg[index >> 2] + (index & 3);
|
|
146
|
|
147 *ptr = val;
|
|
148 }
|
|
149
|
|
150 /* Retrieve the return address for CONTEXT. */
|
|
151
|
|
152 inline _Unwind_Ptr
|
|
153 _Unwind_GetIP (struct _Unwind_Context *context)
|
|
154 {
|
|
155 return (_Unwind_Ptr) context->ra;
|
|
156 }
|
|
157
|
|
158 /* Retrieve the return address and flag whether that IP is before
|
|
159 or after first not yet fully executed instruction. */
|
|
160
|
|
161 inline _Unwind_Ptr
|
|
162 _Unwind_GetIPInfo (struct _Unwind_Context *context, int *ip_before_insn)
|
|
163 {
|
|
164 *ip_before_insn = _Unwind_IsSignalFrame (context);
|
|
165 return (_Unwind_Ptr) context->ra;
|
|
166 }
|
|
167
|
|
168 /* Overwrite the return address for CONTEXT with VAL. */
|
|
169
|
|
170 inline void
|
|
171 _Unwind_SetIP (struct _Unwind_Context *context, _Unwind_Ptr val)
|
|
172 {
|
|
173 context->ra = (void *) val;
|
|
174 }
|
|
175
|
|
176 void *
|
|
177 _Unwind_GetLanguageSpecificData (struct _Unwind_Context *context)
|
|
178 {
|
|
179 return context->lsda;
|
|
180 }
|
|
181
|
|
182 _Unwind_Ptr
|
|
183 _Unwind_GetRegionStart (struct _Unwind_Context *context)
|
|
184 {
|
|
185 return (_Unwind_Ptr) context->bases.func;
|
|
186 }
|
|
187
|
|
188 void *
|
|
189 _Unwind_FindEnclosingFunction (void *pc)
|
|
190 {
|
|
191 struct dwarf_eh_bases bases;
|
|
192 const struct dwarf_fde *fde = _Unwind_Find_FDE (pc-1, &bases);
|
|
193 if (fde)
|
|
194 return bases.func;
|
|
195 else
|
|
196 return NULL;
|
|
197 }
|
|
198
|
|
199 _Unwind_Ptr
|
|
200 _Unwind_GetDataRelBase (struct _Unwind_Context *context)
|
|
201 {
|
|
202 return (_Unwind_Ptr) context->bases.dbase;
|
|
203 }
|
|
204
|
|
205 _Unwind_Ptr
|
|
206 _Unwind_GetTextRelBase (struct _Unwind_Context *context)
|
|
207 {
|
|
208 return (_Unwind_Ptr) context->bases.tbase;
|
|
209 }
|
|
210
|
|
211 #ifdef MD_UNWIND_SUPPORT
|
|
212 #include MD_UNWIND_SUPPORT
|
|
213 #endif
|
|
214
|
|
215 /* Extract any interesting information from the CIE for the translation
|
|
216 unit F belongs to. Return a pointer to the byte after the augmentation,
|
|
217 or NULL if we encountered an undecipherable augmentation. */
|
|
218
|
|
219 static const unsigned char *
|
|
220 extract_cie_info (const struct dwarf_cie *cie, struct _Unwind_Context *context,
|
|
221 _Unwind_FrameState *fs)
|
|
222 {
|
|
223 const unsigned char *aug = cie->augmentation;
|
|
224 const unsigned char *p = aug + strlen ((const char *)aug) + 1;
|
|
225 const unsigned char *ret = NULL;
|
|
226 _uleb128_t utmp;
|
|
227 _sleb128_t stmp;
|
|
228
|
|
229 /* g++ v2 "eh" has pointer immediately following augmentation string,
|
|
230 so it must be handled first. */
|
|
231 if (aug[0] == 'e' && aug[1] == 'h')
|
|
232 {
|
|
233 fs->eh_ptr = read_pointer (p);
|
|
234 p += sizeof (void *);
|
|
235 aug += 2;
|
|
236 }
|
|
237
|
|
238 /* Immediately following the augmentation are the code and
|
|
239 data alignment and return address column. */
|
|
240 p = read_uleb128 (p, &utmp);
|
|
241 p = read_sleb128 (p, &stmp);
|
|
242 if (cie->version == 1)
|
|
243 fs->retaddr_column = *p++;
|
|
244 else
|
|
245 {
|
|
246 p = read_uleb128 (p, &utmp);
|
|
247 fs->retaddr_column = (_Unwind_Word)utmp;
|
|
248 }
|
|
249 fs->lsda_encoding = DW_EH_PE_omit;
|
|
250
|
|
251 /* If the augmentation starts with 'z', then a uleb128 immediately
|
|
252 follows containing the length of the augmentation field following
|
|
253 the size. */
|
|
254 if (*aug == 'z')
|
|
255 {
|
|
256 p = read_uleb128 (p, &utmp);
|
|
257 ret = p + utmp;
|
|
258
|
|
259 fs->saw_z = 1;
|
|
260 ++aug;
|
|
261 }
|
|
262
|
|
263 /* Iterate over recognized augmentation subsequences. */
|
|
264 while (*aug != '\0')
|
|
265 {
|
|
266 /* "L" indicates a byte showing how the LSDA pointer is encoded. */
|
|
267 if (aug[0] == 'L')
|
|
268 {
|
|
269 fs->lsda_encoding = *p++;
|
|
270 aug += 1;
|
|
271 }
|
|
272
|
|
273 /* "R" indicates a byte indicating how FDE addresses are encoded. */
|
|
274 else if (aug[0] == 'R')
|
|
275 {
|
|
276 fs->fde_encoding = *p++;
|
|
277 aug += 1;
|
|
278 }
|
|
279
|
|
280 /* "P" indicates a personality routine in the CIE augmentation. */
|
|
281 else if (aug[0] == 'P')
|
|
282 {
|
|
283 _Unwind_Ptr personality;
|
|
284
|
|
285 p = read_encoded_value (context, *p, p + 1, &personality);
|
|
286 fs->personality = (_Unwind_Personality_Fn) personality;
|
|
287 aug += 1;
|
|
288 }
|
|
289
|
|
290 /* "S" indicates a signal frame. */
|
|
291 else if (aug[0] == 'S')
|
|
292 {
|
|
293 fs->signal_frame = 1;
|
|
294 aug += 1;
|
|
295 }
|
|
296
|
|
297 /* Otherwise we have an unknown augmentation string.
|
|
298 Bail unless we saw a 'z' prefix. */
|
|
299 else
|
|
300 return ret;
|
|
301 }
|
|
302
|
|
303 return ret ? ret : p;
|
|
304 }
|
|
305
|
|
306 /* Given the _Unwind_Context CONTEXT for a stack frame, look up the FDE for
|
|
307 its caller and decode it into FS. This function also sets the
|
|
308 lsda member of CONTEXT, as it is really information
|
|
309 about the caller's frame. */
|
|
310
|
|
311 static _Unwind_Reason_Code
|
|
312 uw_frame_state_for (struct _Unwind_Context *context, _Unwind_FrameState *fs)
|
|
313 {
|
|
314 const struct dwarf_fde *fde;
|
|
315 const struct dwarf_cie *cie;
|
|
316 const unsigned char *aug;
|
|
317 int window_size;
|
|
318 _Unwind_Word *ra_ptr;
|
|
319
|
|
320 memset (fs, 0, sizeof (*fs));
|
|
321 context->lsda = 0;
|
|
322
|
|
323 fde = _Unwind_Find_FDE (context->ra + _Unwind_IsSignalFrame (context) - 1,
|
|
324 &context->bases);
|
|
325 if (fde == NULL)
|
|
326 {
|
|
327 #ifdef MD_FALLBACK_FRAME_STATE_FOR
|
|
328 _Unwind_Reason_Code reason;
|
|
329 /* Couldn't find frame unwind info for this function. Try a
|
|
330 target-specific fallback mechanism. This will necessarily
|
|
331 not provide a personality routine or LSDA. */
|
|
332 reason = MD_FALLBACK_FRAME_STATE_FOR (context, fs);
|
|
333 if (reason != _URC_END_OF_STACK)
|
|
334 return reason;
|
|
335 #endif
|
|
336 /* The frame was not recognized and handled by the fallback function,
|
|
337 but it is not really the end of the stack. Fall through here and
|
|
338 unwind it anyway. */
|
|
339 }
|
|
340 else
|
|
341 {
|
|
342 cie = get_cie (fde);
|
|
343 if (extract_cie_info (cie, context, fs) == NULL)
|
|
344 /* CIE contained unknown augmentation. */
|
|
345 return _URC_FATAL_PHASE1_ERROR;
|
|
346
|
|
347 /* Locate augmentation for the fde. */
|
|
348 aug = (const unsigned char *) fde + sizeof (*fde);
|
|
349 aug += 2 * size_of_encoded_value (fs->fde_encoding);
|
|
350 if (fs->saw_z)
|
|
351 {
|
|
352 _uleb128_t i;
|
|
353 aug = read_uleb128 (aug, &i);
|
|
354 }
|
|
355 if (fs->lsda_encoding != DW_EH_PE_omit)
|
|
356 {
|
|
357 _Unwind_Ptr lsda;
|
|
358
|
|
359 aug = read_encoded_value (context, fs->lsda_encoding, aug, &lsda);
|
|
360 context->lsda = (void *) lsda;
|
|
361 }
|
|
362 }
|
|
363
|
|
364 /* Check for the end of the stack. This needs to be checked after
|
|
365 the MD_FALLBACK_FRAME_STATE_FOR check for signal frames because
|
|
366 the contents of context->reg[0] are undefined at a signal frame,
|
|
367 and register a0 may appear to be zero. (The return address in
|
|
368 context->ra comes from register a4 or a8). */
|
|
369 ra_ptr = context->reg[0];
|
|
370 if (ra_ptr && *ra_ptr == 0)
|
|
371 return _URC_END_OF_STACK;
|
|
372
|
|
373 /* Find the window size from the high bits of the return address. */
|
|
374 if (ra_ptr)
|
|
375 window_size = (*ra_ptr >> 30) * 4;
|
|
376 else
|
|
377 window_size = 8;
|
|
378
|
|
379 fs->retaddr_column = window_size;
|
|
380
|
|
381 return _URC_NO_REASON;
|
|
382 }
|
|
383
|
|
384 static void
|
|
385 uw_update_context_1 (struct _Unwind_Context *context, _Unwind_FrameState *fs)
|
|
386 {
|
|
387 struct _Unwind_Context orig_context = *context;
|
|
388 _Unwind_Word *sp, *cfa, *next_cfa;
|
|
389 int i;
|
|
390
|
|
391 if (fs->signal_regs)
|
|
392 {
|
|
393 cfa = (_Unwind_Word *) fs->signal_regs[1];
|
|
394 next_cfa = (_Unwind_Word *) cfa[-3];
|
|
395
|
|
396 for (i = 0; i < 4; i++)
|
|
397 context->reg[i] = fs->signal_regs + (i << 2);
|
|
398 }
|
|
399 else
|
|
400 {
|
|
401 int window_size = fs->retaddr_column >> 2;
|
|
402
|
|
403 sp = (_Unwind_Word *) orig_context.sp;
|
|
404 cfa = (_Unwind_Word *) orig_context.cfa;
|
|
405 next_cfa = (_Unwind_Word *) cfa[-3];
|
|
406
|
|
407 /* Registers a0-a3 are in the save area below sp. */
|
|
408 context->reg[0] = sp - 4;
|
|
409
|
|
410 /* Find the extra save area below next_cfa. */
|
|
411 for (i = 1; i < window_size; i++)
|
|
412 context->reg[i] = next_cfa - 4 * (1 + window_size - i);
|
|
413
|
|
414 /* Remaining registers rotate from previous save areas. */
|
|
415 for (i = window_size; i < 4; i++)
|
|
416 context->reg[i] = orig_context.reg[i - window_size];
|
|
417 }
|
|
418
|
|
419 context->sp = cfa;
|
|
420 context->cfa = next_cfa;
|
|
421
|
|
422 _Unwind_SetSignalFrame (context, fs->signal_frame);
|
|
423 }
|
|
424
|
|
425 /* CONTEXT describes the unwind state for a frame, and FS describes the FDE
|
|
426 of its caller. Update CONTEXT to refer to the caller as well. Note
|
|
427 that the lsda member is not updated here, but later in
|
|
428 uw_frame_state_for. */
|
|
429
|
|
430 static void
|
|
431 uw_update_context (struct _Unwind_Context *context, _Unwind_FrameState *fs)
|
|
432 {
|
|
433 uw_update_context_1 (context, fs);
|
|
434
|
|
435 /* Compute the return address now, since the return address column
|
|
436 can change from frame to frame. */
|
|
437 if (fs->signal_ra != 0)
|
|
438 context->ra = (void *) fs->signal_ra;
|
|
439 else
|
|
440 context->ra = (void *) ((_Unwind_GetGR (context, fs->retaddr_column)
|
|
441 & XTENSA_RA_FIELD_MASK) | context->ra_high_bits);
|
|
442 }
|
|
443
|
|
444 static void
|
|
445 uw_advance_context (struct _Unwind_Context *context, _Unwind_FrameState *fs)
|
|
446 {
|
|
447 uw_update_context (context, fs);
|
|
448 }
|
|
449
|
|
450 /* Fill in CONTEXT for top-of-stack. The only valid registers at this
|
|
451 level will be the return address and the CFA. */
|
|
452
|
|
453 #define uw_init_context(CONTEXT) \
|
|
454 do \
|
|
455 { \
|
|
456 __builtin_unwind_init (); \
|
|
457 uw_init_context_1 (CONTEXT, __builtin_dwarf_cfa (), \
|
|
458 __builtin_return_address (0)); \
|
|
459 } \
|
|
460 while (0)
|
|
461
|
|
462 static void
|
|
463 uw_init_context_1 (struct _Unwind_Context *context, void *outer_cfa,
|
|
464 void *outer_ra)
|
|
465 {
|
|
466 void *ra = __builtin_return_address (0);
|
|
467 void *cfa = __builtin_dwarf_cfa ();
|
|
468 _Unwind_FrameState fs;
|
|
469
|
|
470 memset (context, 0, sizeof (struct _Unwind_Context));
|
|
471 context->ra = ra;
|
|
472
|
|
473 memset (&fs, 0, sizeof (fs));
|
|
474 fs.retaddr_column = 8;
|
|
475 context->sp = cfa;
|
|
476 context->cfa = outer_cfa;
|
|
477 context->ra_high_bits =
|
|
478 ((_Unwind_Word) uw_init_context_1) & ~XTENSA_RA_FIELD_MASK;
|
|
479 uw_update_context_1 (context, &fs);
|
|
480
|
|
481 context->ra = outer_ra;
|
|
482 }
|
|
483
|
|
484
|
|
485 /* Install TARGET into CURRENT so that we can return to it. This is a
|
|
486 macro because __builtin_eh_return must be invoked in the context of
|
|
487 our caller. */
|
|
488
|
|
489 #define uw_install_context(CURRENT, TARGET) \
|
|
490 do \
|
|
491 { \
|
|
492 long offset = uw_install_context_1 ((CURRENT), (TARGET)); \
|
|
493 void *handler = __builtin_frob_return_addr ((TARGET)->ra); \
|
|
494 __builtin_eh_return (offset, handler); \
|
|
495 } \
|
|
496 while (0)
|
|
497
|
|
498 static long
|
|
499 uw_install_context_1 (struct _Unwind_Context *current,
|
|
500 struct _Unwind_Context *target)
|
|
501 {
|
|
502 long i;
|
|
503
|
|
504 /* The eh_return insn assumes a window size of 8, so don't bother copying
|
|
505 the save areas for registers a8-a15 since they won't be reloaded. */
|
|
506 for (i = 0; i < 2; ++i)
|
|
507 {
|
|
508 void *c = current->reg[i];
|
|
509 void *t = target->reg[i];
|
|
510
|
|
511 if (t && c && t != c)
|
|
512 memcpy (c, t, 4 * sizeof (_Unwind_Word));
|
|
513 }
|
|
514
|
|
515 return 0;
|
|
516 }
|
|
517
|
|
518 static inline _Unwind_Ptr
|
|
519 uw_identify_context (struct _Unwind_Context *context)
|
|
520 {
|
|
521 return _Unwind_GetCFA (context);
|
|
522 }
|
|
523
|
|
524
|
|
525 #include "unwind.inc"
|
|
526
|
|
527 #if defined (USE_GAS_SYMVER) && defined (SHARED) && defined (USE_LIBUNWIND_EXCEPTIONS)
|
|
528 alias (_Unwind_Backtrace);
|
|
529 alias (_Unwind_DeleteException);
|
|
530 alias (_Unwind_FindEnclosingFunction);
|
|
531 alias (_Unwind_ForcedUnwind);
|
|
532 alias (_Unwind_GetDataRelBase);
|
|
533 alias (_Unwind_GetTextRelBase);
|
|
534 alias (_Unwind_GetCFA);
|
|
535 alias (_Unwind_GetGR);
|
|
536 alias (_Unwind_GetIP);
|
|
537 alias (_Unwind_GetLanguageSpecificData);
|
|
538 alias (_Unwind_GetRegionStart);
|
|
539 alias (_Unwind_RaiseException);
|
|
540 alias (_Unwind_Resume);
|
|
541 alias (_Unwind_Resume_or_Rethrow);
|
|
542 alias (_Unwind_SetGR);
|
|
543 alias (_Unwind_SetIP);
|
|
544 #endif
|
|
545
|
|
546 #endif /* !USING_SJLJ_EXCEPTIONS */
|