]>
Commit | Line | Data |
---|---|---|
1 | /* DWARF2 exception handling and frame unwind runtime interface routines. | |
2 | Copyright (C) 1997-2018 Free Software Foundation, Inc. | |
3 | ||
4 | This file is part of GCC. | |
5 | ||
6 | GCC is free software; you can redistribute it and/or modify it | |
7 | under the terms of the GNU General Public License as published by | |
8 | the Free Software Foundation; either version 3, or (at your option) | |
9 | any later version. | |
10 | ||
11 | GCC is distributed in the hope that it will be useful, but WITHOUT | |
12 | ANY WARRANTY; without even the implied warranty of MERCHANTABILITY | |
13 | or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public | |
14 | License for more details. | |
15 | ||
16 | Under Section 7 of GPL version 3, you are granted additional | |
17 | permissions described in the GCC Runtime Library Exception, version | |
18 | 3.1, as published by the Free Software Foundation. | |
19 | ||
20 | You should have received a copy of the GNU General Public License and | |
21 | a copy of the GCC Runtime Library Exception along with this program; | |
22 | see the files COPYING3 and COPYING.RUNTIME respectively. If not, see | |
23 | <http://www.gnu.org/licenses/>. */ | |
24 | ||
25 | #include "tconfig.h" | |
26 | #include "tsystem.h" | |
27 | #include "coretypes.h" | |
28 | #include "tm.h" | |
29 | #include "libgcc_tm.h" | |
30 | #include "dwarf2.h" | |
31 | #include "unwind.h" | |
32 | #ifdef __USING_SJLJ_EXCEPTIONS__ | |
33 | # define NO_SIZE_OF_ENCODED_VALUE | |
34 | #endif | |
35 | #include "unwind-pe.h" | |
36 | #include "unwind-dw2-fde.h" | |
37 | #include "gthr.h" | |
38 | #include "unwind-dw2.h" | |
39 | ||
40 | #ifdef HAVE_SYS_SDT_H | |
41 | #include <sys/sdt.h> | |
42 | #endif | |
43 | ||
44 | #ifndef __USING_SJLJ_EXCEPTIONS__ | |
45 | ||
46 | #ifndef __LIBGCC_STACK_GROWS_DOWNWARD__ | |
47 | #define __LIBGCC_STACK_GROWS_DOWNWARD__ 0 | |
48 | #else | |
49 | #undef __LIBGCC_STACK_GROWS_DOWNWARD__ | |
50 | #define __LIBGCC_STACK_GROWS_DOWNWARD__ 1 | |
51 | #endif | |
52 | ||
53 | /* Dwarf frame registers used for pre gcc 3.0 compiled glibc. */ | |
54 | #ifndef PRE_GCC3_DWARF_FRAME_REGISTERS | |
55 | #define PRE_GCC3_DWARF_FRAME_REGISTERS __LIBGCC_DWARF_FRAME_REGISTERS__ | |
56 | #endif | |
57 | ||
58 | /* ??? For the public function interfaces, we tend to gcc_assert that the | |
59 | column numbers are in range. For the dwarf2 unwind info this does happen, | |
60 | although so far in a case that doesn't actually matter. | |
61 | ||
62 | See PR49146, in which a call from x86_64 ms abi to x86_64 unix abi stores | |
63 | the call-saved xmm registers and annotates them. We havn't bothered | |
64 | providing support for the xmm registers for the x86_64 port primarily | |
65 | because the 64-bit windows targets don't use dwarf2 unwind, using sjlj or | |
66 | SEH instead. Adding the support for unix targets would generally be a | |
67 | waste. However, some runtime libraries supplied with ICC do contain such | |
68 | an unorthodox transition, as well as the unwind info to match. This loss | |
69 | of register restoration doesn't matter in practice, because the exception | |
70 | is caught in the native unix abi, where all of the xmm registers are | |
71 | call clobbered. | |
72 | ||
73 | Ideally, we'd record some bit to notice when we're failing to restore some | |
74 | register recorded in the unwind info, but to do that we need annotation on | |
75 | the unix->ms abi edge, so that we know when the register data may be | |
76 | discarded. And since this edge is also within the ICC library, we're | |
77 | unlikely to be able to get the new annotation. | |
78 | ||
79 | Barring a magic solution to restore the ms abi defined 128-bit xmm registers | |
80 | (as distictly opposed to the full runtime width) without causing extra | |
81 | overhead for normal unix abis, the best solution seems to be to simply | |
82 | ignore unwind data for unknown columns. */ | |
83 | ||
84 | #define UNWIND_COLUMN_IN_RANGE(x) \ | |
85 | __builtin_expect((x) <= __LIBGCC_DWARF_FRAME_REGISTERS__, 1) | |
86 | ||
87 | #ifdef REG_VALUE_IN_UNWIND_CONTEXT | |
88 | typedef _Unwind_Word _Unwind_Context_Reg_Val; | |
89 | ||
90 | #ifndef ASSUME_EXTENDED_UNWIND_CONTEXT | |
91 | #define ASSUME_EXTENDED_UNWIND_CONTEXT 1 | |
92 | #endif | |
93 | ||
94 | static inline _Unwind_Word | |
95 | _Unwind_Get_Unwind_Word (_Unwind_Context_Reg_Val val) | |
96 | { | |
97 | return val; | |
98 | } | |
99 | ||
100 | static inline _Unwind_Context_Reg_Val | |
101 | _Unwind_Get_Unwind_Context_Reg_Val (_Unwind_Word val) | |
102 | { | |
103 | return val; | |
104 | } | |
105 | #else | |
106 | typedef void *_Unwind_Context_Reg_Val; | |
107 | ||
108 | static inline _Unwind_Word | |
109 | _Unwind_Get_Unwind_Word (_Unwind_Context_Reg_Val val) | |
110 | { | |
111 | return (_Unwind_Word) (_Unwind_Internal_Ptr) val; | |
112 | } | |
113 | ||
114 | static inline _Unwind_Context_Reg_Val | |
115 | _Unwind_Get_Unwind_Context_Reg_Val (_Unwind_Word val) | |
116 | { | |
117 | return (_Unwind_Context_Reg_Val) (_Unwind_Internal_Ptr) val; | |
118 | } | |
119 | #endif | |
120 | ||
121 | #ifndef ASSUME_EXTENDED_UNWIND_CONTEXT | |
122 | #define ASSUME_EXTENDED_UNWIND_CONTEXT 0 | |
123 | #endif | |
124 | ||
125 | /* This is the register and unwind state for a particular frame. This | |
126 | provides the information necessary to unwind up past a frame and return | |
127 | to its caller. */ | |
128 | struct _Unwind_Context | |
129 | { | |
130 | _Unwind_Context_Reg_Val reg[__LIBGCC_DWARF_FRAME_REGISTERS__+1]; | |
131 | void *cfa; | |
132 | void *ra; | |
133 | void *lsda; | |
134 | struct dwarf_eh_bases bases; | |
135 | /* Signal frame context. */ | |
136 | #define SIGNAL_FRAME_BIT ((~(_Unwind_Word) 0 >> 1) + 1) | |
137 | /* Context which has version/args_size/by_value fields. */ | |
138 | #define EXTENDED_CONTEXT_BIT ((~(_Unwind_Word) 0 >> 2) + 1) | |
139 | /* Bit reserved on AArch64, return address has been signed with A key. */ | |
140 | #define RA_A_SIGNED_BIT ((~(_Unwind_Word) 0 >> 3) + 1) | |
141 | _Unwind_Word flags; | |
142 | /* 0 for now, can be increased when further fields are added to | |
143 | struct _Unwind_Context. */ | |
144 | _Unwind_Word version; | |
145 | _Unwind_Word args_size; | |
146 | char by_value[__LIBGCC_DWARF_FRAME_REGISTERS__+1]; | |
147 | }; | |
148 | ||
149 | /* Byte size of every register managed by these routines. */ | |
150 | static unsigned char dwarf_reg_size_table[__LIBGCC_DWARF_FRAME_REGISTERS__+1]; | |
151 | ||
152 | \f | |
153 | /* Read unaligned data from the instruction buffer. */ | |
154 | ||
155 | union unaligned | |
156 | { | |
157 | void *p; | |
158 | unsigned u2 __attribute__ ((mode (HI))); | |
159 | unsigned u4 __attribute__ ((mode (SI))); | |
160 | unsigned u8 __attribute__ ((mode (DI))); | |
161 | signed s2 __attribute__ ((mode (HI))); | |
162 | signed s4 __attribute__ ((mode (SI))); | |
163 | signed s8 __attribute__ ((mode (DI))); | |
164 | } __attribute__ ((packed)); | |
165 | ||
166 | static void uw_update_context (struct _Unwind_Context *, _Unwind_FrameState *); | |
167 | static _Unwind_Reason_Code uw_frame_state_for (struct _Unwind_Context *, | |
168 | _Unwind_FrameState *); | |
169 | ||
170 | static inline void * | |
171 | read_pointer (const void *p) { const union unaligned *up = p; return up->p; } | |
172 | ||
173 | static inline int | |
174 | read_1u (const void *p) { return *(const unsigned char *) p; } | |
175 | ||
176 | static inline int | |
177 | read_1s (const void *p) { return *(const signed char *) p; } | |
178 | ||
179 | static inline int | |
180 | read_2u (const void *p) { const union unaligned *up = p; return up->u2; } | |
181 | ||
182 | static inline int | |
183 | read_2s (const void *p) { const union unaligned *up = p; return up->s2; } | |
184 | ||
185 | static inline unsigned int | |
186 | read_4u (const void *p) { const union unaligned *up = p; return up->u4; } | |
187 | ||
188 | static inline int | |
189 | read_4s (const void *p) { const union unaligned *up = p; return up->s4; } | |
190 | ||
191 | static inline unsigned long | |
192 | read_8u (const void *p) { const union unaligned *up = p; return up->u8; } | |
193 | ||
194 | static inline unsigned long | |
195 | read_8s (const void *p) { const union unaligned *up = p; return up->s8; } | |
196 | \f | |
197 | static inline _Unwind_Word | |
198 | _Unwind_IsSignalFrame (struct _Unwind_Context *context) | |
199 | { | |
200 | return (context->flags & SIGNAL_FRAME_BIT) ? 1 : 0; | |
201 | } | |
202 | ||
203 | static inline void | |
204 | _Unwind_SetSignalFrame (struct _Unwind_Context *context, int val) | |
205 | { | |
206 | if (val) | |
207 | context->flags |= SIGNAL_FRAME_BIT; | |
208 | else | |
209 | context->flags &= ~SIGNAL_FRAME_BIT; | |
210 | } | |
211 | ||
212 | static inline _Unwind_Word | |
213 | _Unwind_IsExtendedContext (struct _Unwind_Context *context) | |
214 | { | |
215 | return (ASSUME_EXTENDED_UNWIND_CONTEXT | |
216 | || (context->flags & EXTENDED_CONTEXT_BIT)); | |
217 | } | |
218 | \f | |
219 | /* Get the value of register REGNO as saved in CONTEXT. */ | |
220 | ||
221 | inline _Unwind_Word | |
222 | _Unwind_GetGR (struct _Unwind_Context *context, int regno) | |
223 | { | |
224 | int size, index; | |
225 | _Unwind_Context_Reg_Val val; | |
226 | ||
227 | #ifdef DWARF_ZERO_REG | |
228 | if (index == DWARF_ZERO_REG) | |
229 | return 0; | |
230 | #endif | |
231 | ||
232 | index = DWARF_REG_TO_UNWIND_COLUMN (regno); | |
233 | gcc_assert (index < (int) sizeof(dwarf_reg_size_table)); | |
234 | size = dwarf_reg_size_table[index]; | |
235 | val = context->reg[index]; | |
236 | ||
237 | if (_Unwind_IsExtendedContext (context) && context->by_value[index]) | |
238 | return _Unwind_Get_Unwind_Word (val); | |
239 | ||
240 | #ifdef DWARF_LAZY_REGISTER_VALUE | |
241 | { | |
242 | _Unwind_Word value; | |
243 | if (DWARF_LAZY_REGISTER_VALUE (regno, &value)) | |
244 | return value; | |
245 | } | |
246 | #endif | |
247 | ||
248 | /* This will segfault if the register hasn't been saved. */ | |
249 | if (size == sizeof(_Unwind_Ptr)) | |
250 | return * (_Unwind_Ptr *) (_Unwind_Internal_Ptr) val; | |
251 | else | |
252 | { | |
253 | gcc_assert (size == sizeof(_Unwind_Word)); | |
254 | return * (_Unwind_Word *) (_Unwind_Internal_Ptr) val; | |
255 | } | |
256 | } | |
257 | ||
258 | static inline void * | |
259 | _Unwind_GetPtr (struct _Unwind_Context *context, int index) | |
260 | { | |
261 | return (void *)(_Unwind_Ptr) _Unwind_GetGR (context, index); | |
262 | } | |
263 | ||
264 | /* Get the value of the CFA as saved in CONTEXT. */ | |
265 | ||
266 | _Unwind_Word | |
267 | _Unwind_GetCFA (struct _Unwind_Context *context) | |
268 | { | |
269 | return (_Unwind_Ptr) context->cfa; | |
270 | } | |
271 | ||
272 | /* Overwrite the saved value for register INDEX in CONTEXT with VAL. */ | |
273 | ||
274 | inline void | |
275 | _Unwind_SetGR (struct _Unwind_Context *context, int index, _Unwind_Word val) | |
276 | { | |
277 | int size; | |
278 | void *ptr; | |
279 | ||
280 | index = DWARF_REG_TO_UNWIND_COLUMN (index); | |
281 | gcc_assert (index < (int) sizeof(dwarf_reg_size_table)); | |
282 | size = dwarf_reg_size_table[index]; | |
283 | ||
284 | if (_Unwind_IsExtendedContext (context) && context->by_value[index]) | |
285 | { | |
286 | context->reg[index] = _Unwind_Get_Unwind_Context_Reg_Val (val); | |
287 | return; | |
288 | } | |
289 | ||
290 | ptr = (void *) (_Unwind_Internal_Ptr) context->reg[index]; | |
291 | ||
292 | if (size == sizeof(_Unwind_Ptr)) | |
293 | * (_Unwind_Ptr *) ptr = val; | |
294 | else | |
295 | { | |
296 | gcc_assert (size == sizeof(_Unwind_Word)); | |
297 | * (_Unwind_Word *) ptr = val; | |
298 | } | |
299 | } | |
300 | ||
301 | /* Get the pointer to a register INDEX as saved in CONTEXT. */ | |
302 | ||
303 | static inline void * | |
304 | _Unwind_GetGRPtr (struct _Unwind_Context *context, int index) | |
305 | { | |
306 | index = DWARF_REG_TO_UNWIND_COLUMN (index); | |
307 | if (_Unwind_IsExtendedContext (context) && context->by_value[index]) | |
308 | return &context->reg[index]; | |
309 | return (void *) (_Unwind_Internal_Ptr) context->reg[index]; | |
310 | } | |
311 | ||
312 | /* Set the pointer to a register INDEX as saved in CONTEXT. */ | |
313 | ||
314 | static inline void | |
315 | _Unwind_SetGRPtr (struct _Unwind_Context *context, int index, void *p) | |
316 | { | |
317 | index = DWARF_REG_TO_UNWIND_COLUMN (index); | |
318 | if (_Unwind_IsExtendedContext (context)) | |
319 | context->by_value[index] = 0; | |
320 | context->reg[index] = (_Unwind_Context_Reg_Val) (_Unwind_Internal_Ptr) p; | |
321 | } | |
322 | ||
323 | /* Overwrite the saved value for register INDEX in CONTEXT with VAL. */ | |
324 | ||
325 | static inline void | |
326 | _Unwind_SetGRValue (struct _Unwind_Context *context, int index, | |
327 | _Unwind_Word val) | |
328 | { | |
329 | index = DWARF_REG_TO_UNWIND_COLUMN (index); | |
330 | gcc_assert (index < (int) sizeof(dwarf_reg_size_table)); | |
331 | /* Return column size may be smaller than _Unwind_Context_Reg_Val. */ | |
332 | gcc_assert (dwarf_reg_size_table[index] <= sizeof (_Unwind_Context_Reg_Val)); | |
333 | ||
334 | context->by_value[index] = 1; | |
335 | context->reg[index] = _Unwind_Get_Unwind_Context_Reg_Val (val); | |
336 | } | |
337 | ||
338 | /* Return nonzero if register INDEX is stored by value rather than | |
339 | by reference. */ | |
340 | ||
341 | static inline int | |
342 | _Unwind_GRByValue (struct _Unwind_Context *context, int index) | |
343 | { | |
344 | index = DWARF_REG_TO_UNWIND_COLUMN (index); | |
345 | return context->by_value[index]; | |
346 | } | |
347 | ||
348 | /* Retrieve the return address for CONTEXT. */ | |
349 | ||
350 | inline _Unwind_Ptr | |
351 | _Unwind_GetIP (struct _Unwind_Context *context) | |
352 | { | |
353 | return (_Unwind_Ptr) context->ra; | |
354 | } | |
355 | ||
356 | /* Retrieve the return address and flag whether that IP is before | |
357 | or after first not yet fully executed instruction. */ | |
358 | ||
359 | inline _Unwind_Ptr | |
360 | _Unwind_GetIPInfo (struct _Unwind_Context *context, int *ip_before_insn) | |
361 | { | |
362 | *ip_before_insn = _Unwind_IsSignalFrame (context); | |
363 | return (_Unwind_Ptr) context->ra; | |
364 | } | |
365 | ||
366 | /* Overwrite the return address for CONTEXT with VAL. */ | |
367 | ||
368 | inline void | |
369 | _Unwind_SetIP (struct _Unwind_Context *context, _Unwind_Ptr val) | |
370 | { | |
371 | context->ra = (void *) val; | |
372 | } | |
373 | ||
374 | void * | |
375 | _Unwind_GetLanguageSpecificData (struct _Unwind_Context *context) | |
376 | { | |
377 | return context->lsda; | |
378 | } | |
379 | ||
380 | _Unwind_Ptr | |
381 | _Unwind_GetRegionStart (struct _Unwind_Context *context) | |
382 | { | |
383 | return (_Unwind_Ptr) context->bases.func; | |
384 | } | |
385 | ||
386 | void * | |
387 | _Unwind_FindEnclosingFunction (void *pc) | |
388 | { | |
389 | struct dwarf_eh_bases bases; | |
390 | const struct dwarf_fde *fde = _Unwind_Find_FDE (pc-1, &bases); | |
391 | if (fde) | |
392 | return bases.func; | |
393 | else | |
394 | return NULL; | |
395 | } | |
396 | ||
397 | #ifndef __ia64__ | |
398 | _Unwind_Ptr | |
399 | _Unwind_GetDataRelBase (struct _Unwind_Context *context) | |
400 | { | |
401 | return (_Unwind_Ptr) context->bases.dbase; | |
402 | } | |
403 | ||
404 | _Unwind_Ptr | |
405 | _Unwind_GetTextRelBase (struct _Unwind_Context *context) | |
406 | { | |
407 | return (_Unwind_Ptr) context->bases.tbase; | |
408 | } | |
409 | #endif | |
410 | ||
411 | #include "md-unwind-support.h" | |
412 | \f | |
413 | /* Extract any interesting information from the CIE for the translation | |
414 | unit F belongs to. Return a pointer to the byte after the augmentation, | |
415 | or NULL if we encountered an undecipherable augmentation. */ | |
416 | ||
417 | static const unsigned char * | |
418 | extract_cie_info (const struct dwarf_cie *cie, struct _Unwind_Context *context, | |
419 | _Unwind_FrameState *fs) | |
420 | { | |
421 | const unsigned char *aug = cie->augmentation; | |
422 | const unsigned char *p = aug + strlen ((const char *)aug) + 1; | |
423 | const unsigned char *ret = NULL; | |
424 | _uleb128_t utmp; | |
425 | _sleb128_t stmp; | |
426 | ||
427 | /* g++ v2 "eh" has pointer immediately following augmentation string, | |
428 | so it must be handled first. */ | |
429 | if (aug[0] == 'e' && aug[1] == 'h') | |
430 | { | |
431 | fs->eh_ptr = read_pointer (p); | |
432 | p += sizeof (void *); | |
433 | aug += 2; | |
434 | } | |
435 | ||
436 | /* After the augmentation resp. pointer for "eh" augmentation | |
437 | follows for CIE version >= 4 address size byte and | |
438 | segment size byte. */ | |
439 | if (__builtin_expect (cie->version >= 4, 0)) | |
440 | { | |
441 | if (p[0] != sizeof (void *) || p[1] != 0) | |
442 | return NULL; | |
443 | p += 2; | |
444 | } | |
445 | /* Immediately following this are the code and | |
446 | data alignment and return address column. */ | |
447 | p = read_uleb128 (p, &utmp); | |
448 | fs->code_align = (_Unwind_Word)utmp; | |
449 | p = read_sleb128 (p, &stmp); | |
450 | fs->data_align = (_Unwind_Sword)stmp; | |
451 | if (cie->version == 1) | |
452 | fs->retaddr_column = *p++; | |
453 | else | |
454 | { | |
455 | p = read_uleb128 (p, &utmp); | |
456 | fs->retaddr_column = (_Unwind_Word)utmp; | |
457 | } | |
458 | fs->lsda_encoding = DW_EH_PE_omit; | |
459 | ||
460 | /* If the augmentation starts with 'z', then a uleb128 immediately | |
461 | follows containing the length of the augmentation field following | |
462 | the size. */ | |
463 | if (*aug == 'z') | |
464 | { | |
465 | p = read_uleb128 (p, &utmp); | |
466 | ret = p + utmp; | |
467 | ||
468 | fs->saw_z = 1; | |
469 | ++aug; | |
470 | } | |
471 | ||
472 | /* Iterate over recognized augmentation subsequences. */ | |
473 | while (*aug != '\0') | |
474 | { | |
475 | /* "L" indicates a byte showing how the LSDA pointer is encoded. */ | |
476 | if (aug[0] == 'L') | |
477 | { | |
478 | fs->lsda_encoding = *p++; | |
479 | aug += 1; | |
480 | } | |
481 | ||
482 | /* "R" indicates a byte indicating how FDE addresses are encoded. */ | |
483 | else if (aug[0] == 'R') | |
484 | { | |
485 | fs->fde_encoding = *p++; | |
486 | aug += 1; | |
487 | } | |
488 | ||
489 | /* "P" indicates a personality routine in the CIE augmentation. */ | |
490 | else if (aug[0] == 'P') | |
491 | { | |
492 | _Unwind_Ptr personality; | |
493 | ||
494 | p = read_encoded_value (context, *p, p + 1, &personality); | |
495 | fs->personality = (_Unwind_Personality_Fn) personality; | |
496 | aug += 1; | |
497 | } | |
498 | ||
499 | /* "S" indicates a signal frame. */ | |
500 | else if (aug[0] == 'S') | |
501 | { | |
502 | fs->signal_frame = 1; | |
503 | aug += 1; | |
504 | } | |
505 | ||
506 | /* Otherwise we have an unknown augmentation string. | |
507 | Bail unless we saw a 'z' prefix. */ | |
508 | else | |
509 | return ret; | |
510 | } | |
511 | ||
512 | return ret ? ret : p; | |
513 | } | |
514 | ||
515 | ||
516 | /* Decode a DW_OP stack program. Return the top of stack. Push INITIAL | |
517 | onto the stack to start. */ | |
518 | ||
519 | static _Unwind_Word | |
520 | execute_stack_op (const unsigned char *op_ptr, const unsigned char *op_end, | |
521 | struct _Unwind_Context *context, _Unwind_Word initial) | |
522 | { | |
523 | _Unwind_Word stack[64]; /* ??? Assume this is enough. */ | |
524 | int stack_elt; | |
525 | ||
526 | stack[0] = initial; | |
527 | stack_elt = 1; | |
528 | ||
529 | while (op_ptr < op_end) | |
530 | { | |
531 | enum dwarf_location_atom op = *op_ptr++; | |
532 | _Unwind_Word result; | |
533 | _uleb128_t reg, utmp; | |
534 | _sleb128_t offset, stmp; | |
535 | ||
536 | switch (op) | |
537 | { | |
538 | case DW_OP_lit0: | |
539 | case DW_OP_lit1: | |
540 | case DW_OP_lit2: | |
541 | case DW_OP_lit3: | |
542 | case DW_OP_lit4: | |
543 | case DW_OP_lit5: | |
544 | case DW_OP_lit6: | |
545 | case DW_OP_lit7: | |
546 | case DW_OP_lit8: | |
547 | case DW_OP_lit9: | |
548 | case DW_OP_lit10: | |
549 | case DW_OP_lit11: | |
550 | case DW_OP_lit12: | |
551 | case DW_OP_lit13: | |
552 | case DW_OP_lit14: | |
553 | case DW_OP_lit15: | |
554 | case DW_OP_lit16: | |
555 | case DW_OP_lit17: | |
556 | case DW_OP_lit18: | |
557 | case DW_OP_lit19: | |
558 | case DW_OP_lit20: | |
559 | case DW_OP_lit21: | |
560 | case DW_OP_lit22: | |
561 | case DW_OP_lit23: | |
562 | case DW_OP_lit24: | |
563 | case DW_OP_lit25: | |
564 | case DW_OP_lit26: | |
565 | case DW_OP_lit27: | |
566 | case DW_OP_lit28: | |
567 | case DW_OP_lit29: | |
568 | case DW_OP_lit30: | |
569 | case DW_OP_lit31: | |
570 | result = op - DW_OP_lit0; | |
571 | break; | |
572 | ||
573 | case DW_OP_addr: | |
574 | result = (_Unwind_Word) (_Unwind_Ptr) read_pointer (op_ptr); | |
575 | op_ptr += sizeof (void *); | |
576 | break; | |
577 | ||
578 | case DW_OP_GNU_encoded_addr: | |
579 | { | |
580 | _Unwind_Ptr presult; | |
581 | op_ptr = read_encoded_value (context, *op_ptr, op_ptr+1, &presult); | |
582 | result = presult; | |
583 | } | |
584 | break; | |
585 | ||
586 | case DW_OP_const1u: | |
587 | result = read_1u (op_ptr); | |
588 | op_ptr += 1; | |
589 | break; | |
590 | case DW_OP_const1s: | |
591 | result = read_1s (op_ptr); | |
592 | op_ptr += 1; | |
593 | break; | |
594 | case DW_OP_const2u: | |
595 | result = read_2u (op_ptr); | |
596 | op_ptr += 2; | |
597 | break; | |
598 | case DW_OP_const2s: | |
599 | result = read_2s (op_ptr); | |
600 | op_ptr += 2; | |
601 | break; | |
602 | case DW_OP_const4u: | |
603 | result = read_4u (op_ptr); | |
604 | op_ptr += 4; | |
605 | break; | |
606 | case DW_OP_const4s: | |
607 | result = read_4s (op_ptr); | |
608 | op_ptr += 4; | |
609 | break; | |
610 | case DW_OP_const8u: | |
611 | result = read_8u (op_ptr); | |
612 | op_ptr += 8; | |
613 | break; | |
614 | case DW_OP_const8s: | |
615 | result = read_8s (op_ptr); | |
616 | op_ptr += 8; | |
617 | break; | |
618 | case DW_OP_constu: | |
619 | op_ptr = read_uleb128 (op_ptr, &utmp); | |
620 | result = (_Unwind_Word)utmp; | |
621 | break; | |
622 | case DW_OP_consts: | |
623 | op_ptr = read_sleb128 (op_ptr, &stmp); | |
624 | result = (_Unwind_Sword)stmp; | |
625 | break; | |
626 | ||
627 | case DW_OP_reg0: | |
628 | case DW_OP_reg1: | |
629 | case DW_OP_reg2: | |
630 | case DW_OP_reg3: | |
631 | case DW_OP_reg4: | |
632 | case DW_OP_reg5: | |
633 | case DW_OP_reg6: | |
634 | case DW_OP_reg7: | |
635 | case DW_OP_reg8: | |
636 | case DW_OP_reg9: | |
637 | case DW_OP_reg10: | |
638 | case DW_OP_reg11: | |
639 | case DW_OP_reg12: | |
640 | case DW_OP_reg13: | |
641 | case DW_OP_reg14: | |
642 | case DW_OP_reg15: | |
643 | case DW_OP_reg16: | |
644 | case DW_OP_reg17: | |
645 | case DW_OP_reg18: | |
646 | case DW_OP_reg19: | |
647 | case DW_OP_reg20: | |
648 | case DW_OP_reg21: | |
649 | case DW_OP_reg22: | |
650 | case DW_OP_reg23: | |
651 | case DW_OP_reg24: | |
652 | case DW_OP_reg25: | |
653 | case DW_OP_reg26: | |
654 | case DW_OP_reg27: | |
655 | case DW_OP_reg28: | |
656 | case DW_OP_reg29: | |
657 | case DW_OP_reg30: | |
658 | case DW_OP_reg31: | |
659 | result = _Unwind_GetGR (context, op - DW_OP_reg0); | |
660 | break; | |
661 | case DW_OP_regx: | |
662 | op_ptr = read_uleb128 (op_ptr, ®); | |
663 | result = _Unwind_GetGR (context, reg); | |
664 | break; | |
665 | ||
666 | case DW_OP_breg0: | |
667 | case DW_OP_breg1: | |
668 | case DW_OP_breg2: | |
669 | case DW_OP_breg3: | |
670 | case DW_OP_breg4: | |
671 | case DW_OP_breg5: | |
672 | case DW_OP_breg6: | |
673 | case DW_OP_breg7: | |
674 | case DW_OP_breg8: | |
675 | case DW_OP_breg9: | |
676 | case DW_OP_breg10: | |
677 | case DW_OP_breg11: | |
678 | case DW_OP_breg12: | |
679 | case DW_OP_breg13: | |
680 | case DW_OP_breg14: | |
681 | case DW_OP_breg15: | |
682 | case DW_OP_breg16: | |
683 | case DW_OP_breg17: | |
684 | case DW_OP_breg18: | |
685 | case DW_OP_breg19: | |
686 | case DW_OP_breg20: | |
687 | case DW_OP_breg21: | |
688 | case DW_OP_breg22: | |
689 | case DW_OP_breg23: | |
690 | case DW_OP_breg24: | |
691 | case DW_OP_breg25: | |
692 | case DW_OP_breg26: | |
693 | case DW_OP_breg27: | |
694 | case DW_OP_breg28: | |
695 | case DW_OP_breg29: | |
696 | case DW_OP_breg30: | |
697 | case DW_OP_breg31: | |
698 | op_ptr = read_sleb128 (op_ptr, &offset); | |
699 | result = _Unwind_GetGR (context, op - DW_OP_breg0) + offset; | |
700 | break; | |
701 | case DW_OP_bregx: | |
702 | op_ptr = read_uleb128 (op_ptr, ®); | |
703 | op_ptr = read_sleb128 (op_ptr, &offset); | |
704 | result = _Unwind_GetGR (context, reg) + (_Unwind_Word)offset; | |
705 | break; | |
706 | ||
707 | case DW_OP_dup: | |
708 | gcc_assert (stack_elt); | |
709 | result = stack[stack_elt - 1]; | |
710 | break; | |
711 | ||
712 | case DW_OP_drop: | |
713 | gcc_assert (stack_elt); | |
714 | stack_elt -= 1; | |
715 | goto no_push; | |
716 | ||
717 | case DW_OP_pick: | |
718 | offset = *op_ptr++; | |
719 | gcc_assert (offset < stack_elt - 1); | |
720 | result = stack[stack_elt - 1 - offset]; | |
721 | break; | |
722 | ||
723 | case DW_OP_over: | |
724 | gcc_assert (stack_elt >= 2); | |
725 | result = stack[stack_elt - 2]; | |
726 | break; | |
727 | ||
728 | case DW_OP_swap: | |
729 | { | |
730 | _Unwind_Word t; | |
731 | gcc_assert (stack_elt >= 2); | |
732 | t = stack[stack_elt - 1]; | |
733 | stack[stack_elt - 1] = stack[stack_elt - 2]; | |
734 | stack[stack_elt - 2] = t; | |
735 | goto no_push; | |
736 | } | |
737 | ||
738 | case DW_OP_rot: | |
739 | { | |
740 | _Unwind_Word t1, t2, t3; | |
741 | ||
742 | gcc_assert (stack_elt >= 3); | |
743 | t1 = stack[stack_elt - 1]; | |
744 | t2 = stack[stack_elt - 2]; | |
745 | t3 = stack[stack_elt - 3]; | |
746 | stack[stack_elt - 1] = t2; | |
747 | stack[stack_elt - 2] = t3; | |
748 | stack[stack_elt - 3] = t1; | |
749 | goto no_push; | |
750 | } | |
751 | ||
752 | case DW_OP_deref: | |
753 | case DW_OP_deref_size: | |
754 | case DW_OP_abs: | |
755 | case DW_OP_neg: | |
756 | case DW_OP_not: | |
757 | case DW_OP_plus_uconst: | |
758 | /* Unary operations. */ | |
759 | gcc_assert (stack_elt); | |
760 | stack_elt -= 1; | |
761 | ||
762 | result = stack[stack_elt]; | |
763 | ||
764 | switch (op) | |
765 | { | |
766 | case DW_OP_deref: | |
767 | { | |
768 | void *ptr = (void *) (_Unwind_Ptr) result; | |
769 | result = (_Unwind_Ptr) read_pointer (ptr); | |
770 | } | |
771 | break; | |
772 | ||
773 | case DW_OP_deref_size: | |
774 | { | |
775 | void *ptr = (void *) (_Unwind_Ptr) result; | |
776 | switch (*op_ptr++) | |
777 | { | |
778 | case 1: | |
779 | result = read_1u (ptr); | |
780 | break; | |
781 | case 2: | |
782 | result = read_2u (ptr); | |
783 | break; | |
784 | case 4: | |
785 | result = read_4u (ptr); | |
786 | break; | |
787 | case 8: | |
788 | result = read_8u (ptr); | |
789 | break; | |
790 | default: | |
791 | gcc_unreachable (); | |
792 | } | |
793 | } | |
794 | break; | |
795 | ||
796 | case DW_OP_abs: | |
797 | if ((_Unwind_Sword) result < 0) | |
798 | result = -result; | |
799 | break; | |
800 | case DW_OP_neg: | |
801 | result = -result; | |
802 | break; | |
803 | case DW_OP_not: | |
804 | result = ~result; | |
805 | break; | |
806 | case DW_OP_plus_uconst: | |
807 | op_ptr = read_uleb128 (op_ptr, &utmp); | |
808 | result += (_Unwind_Word)utmp; | |
809 | break; | |
810 | ||
811 | default: | |
812 | gcc_unreachable (); | |
813 | } | |
814 | break; | |
815 | ||
816 | case DW_OP_and: | |
817 | case DW_OP_div: | |
818 | case DW_OP_minus: | |
819 | case DW_OP_mod: | |
820 | case DW_OP_mul: | |
821 | case DW_OP_or: | |
822 | case DW_OP_plus: | |
823 | case DW_OP_shl: | |
824 | case DW_OP_shr: | |
825 | case DW_OP_shra: | |
826 | case DW_OP_xor: | |
827 | case DW_OP_le: | |
828 | case DW_OP_ge: | |
829 | case DW_OP_eq: | |
830 | case DW_OP_lt: | |
831 | case DW_OP_gt: | |
832 | case DW_OP_ne: | |
833 | { | |
834 | /* Binary operations. */ | |
835 | _Unwind_Word first, second; | |
836 | gcc_assert (stack_elt >= 2); | |
837 | stack_elt -= 2; | |
838 | ||
839 | second = stack[stack_elt]; | |
840 | first = stack[stack_elt + 1]; | |
841 | ||
842 | switch (op) | |
843 | { | |
844 | case DW_OP_and: | |
845 | result = second & first; | |
846 | break; | |
847 | case DW_OP_div: | |
848 | result = (_Unwind_Sword) second / (_Unwind_Sword) first; | |
849 | break; | |
850 | case DW_OP_minus: | |
851 | result = second - first; | |
852 | break; | |
853 | case DW_OP_mod: | |
854 | result = second % first; | |
855 | break; | |
856 | case DW_OP_mul: | |
857 | result = second * first; | |
858 | break; | |
859 | case DW_OP_or: | |
860 | result = second | first; | |
861 | break; | |
862 | case DW_OP_plus: | |
863 | result = second + first; | |
864 | break; | |
865 | case DW_OP_shl: | |
866 | result = second << first; | |
867 | break; | |
868 | case DW_OP_shr: | |
869 | result = second >> first; | |
870 | break; | |
871 | case DW_OP_shra: | |
872 | result = (_Unwind_Sword) second >> first; | |
873 | break; | |
874 | case DW_OP_xor: | |
875 | result = second ^ first; | |
876 | break; | |
877 | case DW_OP_le: | |
878 | result = (_Unwind_Sword) second <= (_Unwind_Sword) first; | |
879 | break; | |
880 | case DW_OP_ge: | |
881 | result = (_Unwind_Sword) second >= (_Unwind_Sword) first; | |
882 | break; | |
883 | case DW_OP_eq: | |
884 | result = (_Unwind_Sword) second == (_Unwind_Sword) first; | |
885 | break; | |
886 | case DW_OP_lt: | |
887 | result = (_Unwind_Sword) second < (_Unwind_Sword) first; | |
888 | break; | |
889 | case DW_OP_gt: | |
890 | result = (_Unwind_Sword) second > (_Unwind_Sword) first; | |
891 | break; | |
892 | case DW_OP_ne: | |
893 | result = (_Unwind_Sword) second != (_Unwind_Sword) first; | |
894 | break; | |
895 | ||
896 | default: | |
897 | gcc_unreachable (); | |
898 | } | |
899 | } | |
900 | break; | |
901 | ||
902 | case DW_OP_skip: | |
903 | offset = read_2s (op_ptr); | |
904 | op_ptr += 2; | |
905 | op_ptr += offset; | |
906 | goto no_push; | |
907 | ||
908 | case DW_OP_bra: | |
909 | gcc_assert (stack_elt); | |
910 | stack_elt -= 1; | |
911 | ||
912 | offset = read_2s (op_ptr); | |
913 | op_ptr += 2; | |
914 | if (stack[stack_elt] != 0) | |
915 | op_ptr += offset; | |
916 | goto no_push; | |
917 | ||
918 | case DW_OP_nop: | |
919 | goto no_push; | |
920 | ||
921 | default: | |
922 | gcc_unreachable (); | |
923 | } | |
924 | ||
925 | /* Most things push a result value. */ | |
926 | gcc_assert ((size_t) stack_elt < sizeof(stack)/sizeof(*stack)); | |
927 | stack[stack_elt++] = result; | |
928 | no_push:; | |
929 | } | |
930 | ||
931 | /* We were executing this program to get a value. It should be | |
932 | at top of stack. */ | |
933 | gcc_assert (stack_elt); | |
934 | stack_elt -= 1; | |
935 | return stack[stack_elt]; | |
936 | } | |
937 | ||
938 | ||
939 | /* Decode DWARF 2 call frame information. Takes pointers the | |
940 | instruction sequence to decode, current register information and | |
941 | CIE info, and the PC range to evaluate. */ | |
942 | ||
943 | static void | |
944 | execute_cfa_program (const unsigned char *insn_ptr, | |
945 | const unsigned char *insn_end, | |
946 | struct _Unwind_Context *context, | |
947 | _Unwind_FrameState *fs) | |
948 | { | |
949 | struct frame_state_reg_info *unused_rs = NULL; | |
950 | ||
951 | /* Don't allow remember/restore between CIE and FDE programs. */ | |
952 | fs->regs.prev = NULL; | |
953 | ||
954 | /* The comparison with the return address uses < rather than <= because | |
955 | we are only interested in the effects of code before the call; for a | |
956 | noreturn function, the return address may point to unrelated code with | |
957 | a different stack configuration that we are not interested in. We | |
958 | assume that the call itself is unwind info-neutral; if not, or if | |
959 | there are delay instructions that adjust the stack, these must be | |
960 | reflected at the point immediately before the call insn. | |
961 | In signal frames, return address is after last completed instruction, | |
962 | so we add 1 to return address to make the comparison <=. */ | |
963 | while (insn_ptr < insn_end | |
964 | && fs->pc < context->ra + _Unwind_IsSignalFrame (context)) | |
965 | { | |
966 | unsigned char insn = *insn_ptr++; | |
967 | _uleb128_t reg, utmp; | |
968 | _sleb128_t offset, stmp; | |
969 | ||
970 | if ((insn & 0xc0) == DW_CFA_advance_loc) | |
971 | fs->pc += (insn & 0x3f) * fs->code_align; | |
972 | else if ((insn & 0xc0) == DW_CFA_offset) | |
973 | { | |
974 | reg = insn & 0x3f; | |
975 | insn_ptr = read_uleb128 (insn_ptr, &utmp); | |
976 | offset = (_Unwind_Sword) utmp * fs->data_align; | |
977 | reg = DWARF_REG_TO_UNWIND_COLUMN (reg); | |
978 | if (UNWIND_COLUMN_IN_RANGE (reg)) | |
979 | { | |
980 | fs->regs.reg[reg].how = REG_SAVED_OFFSET; | |
981 | fs->regs.reg[reg].loc.offset = offset; | |
982 | } | |
983 | } | |
984 | else if ((insn & 0xc0) == DW_CFA_restore) | |
985 | { | |
986 | reg = insn & 0x3f; | |
987 | reg = DWARF_REG_TO_UNWIND_COLUMN (reg); | |
988 | if (UNWIND_COLUMN_IN_RANGE (reg)) | |
989 | fs->regs.reg[reg].how = REG_UNSAVED; | |
990 | } | |
991 | else switch (insn) | |
992 | { | |
993 | case DW_CFA_set_loc: | |
994 | { | |
995 | _Unwind_Ptr pc; | |
996 | ||
997 | insn_ptr = read_encoded_value (context, fs->fde_encoding, | |
998 | insn_ptr, &pc); | |
999 | fs->pc = (void *) pc; | |
1000 | } | |
1001 | break; | |
1002 | ||
1003 | case DW_CFA_advance_loc1: | |
1004 | fs->pc += read_1u (insn_ptr) * fs->code_align; | |
1005 | insn_ptr += 1; | |
1006 | break; | |
1007 | case DW_CFA_advance_loc2: | |
1008 | fs->pc += read_2u (insn_ptr) * fs->code_align; | |
1009 | insn_ptr += 2; | |
1010 | break; | |
1011 | case DW_CFA_advance_loc4: | |
1012 | fs->pc += read_4u (insn_ptr) * fs->code_align; | |
1013 | insn_ptr += 4; | |
1014 | break; | |
1015 | ||
1016 | case DW_CFA_offset_extended: | |
1017 | insn_ptr = read_uleb128 (insn_ptr, ®); | |
1018 | insn_ptr = read_uleb128 (insn_ptr, &utmp); | |
1019 | offset = (_Unwind_Sword) utmp * fs->data_align; | |
1020 | reg = DWARF_REG_TO_UNWIND_COLUMN (reg); | |
1021 | if (UNWIND_COLUMN_IN_RANGE (reg)) | |
1022 | { | |
1023 | fs->regs.reg[reg].how = REG_SAVED_OFFSET; | |
1024 | fs->regs.reg[reg].loc.offset = offset; | |
1025 | } | |
1026 | break; | |
1027 | ||
1028 | case DW_CFA_restore_extended: | |
1029 | insn_ptr = read_uleb128 (insn_ptr, ®); | |
1030 | /* FIXME, this is wrong; the CIE might have said that the | |
1031 | register was saved somewhere. */ | |
1032 | reg = DWARF_REG_TO_UNWIND_COLUMN (reg); | |
1033 | if (UNWIND_COLUMN_IN_RANGE (reg)) | |
1034 | fs->regs.reg[reg].how = REG_UNSAVED; | |
1035 | break; | |
1036 | ||
1037 | case DW_CFA_same_value: | |
1038 | insn_ptr = read_uleb128 (insn_ptr, ®); | |
1039 | reg = DWARF_REG_TO_UNWIND_COLUMN (reg); | |
1040 | if (UNWIND_COLUMN_IN_RANGE (reg)) | |
1041 | fs->regs.reg[reg].how = REG_UNSAVED; | |
1042 | break; | |
1043 | ||
1044 | case DW_CFA_undefined: | |
1045 | insn_ptr = read_uleb128 (insn_ptr, ®); | |
1046 | reg = DWARF_REG_TO_UNWIND_COLUMN (reg); | |
1047 | if (UNWIND_COLUMN_IN_RANGE (reg)) | |
1048 | fs->regs.reg[reg].how = REG_UNDEFINED; | |
1049 | break; | |
1050 | ||
1051 | case DW_CFA_nop: | |
1052 | break; | |
1053 | ||
1054 | case DW_CFA_register: | |
1055 | { | |
1056 | _uleb128_t reg2; | |
1057 | insn_ptr = read_uleb128 (insn_ptr, ®); | |
1058 | insn_ptr = read_uleb128 (insn_ptr, ®2); | |
1059 | reg = DWARF_REG_TO_UNWIND_COLUMN (reg); | |
1060 | if (UNWIND_COLUMN_IN_RANGE (reg)) | |
1061 | { | |
1062 | fs->regs.reg[reg].how = REG_SAVED_REG; | |
1063 | fs->regs.reg[reg].loc.reg = (_Unwind_Word)reg2; | |
1064 | } | |
1065 | } | |
1066 | break; | |
1067 | ||
1068 | case DW_CFA_remember_state: | |
1069 | { | |
1070 | struct frame_state_reg_info *new_rs; | |
1071 | if (unused_rs) | |
1072 | { | |
1073 | new_rs = unused_rs; | |
1074 | unused_rs = unused_rs->prev; | |
1075 | } | |
1076 | else | |
1077 | new_rs = alloca (sizeof (struct frame_state_reg_info)); | |
1078 | ||
1079 | *new_rs = fs->regs; | |
1080 | fs->regs.prev = new_rs; | |
1081 | } | |
1082 | break; | |
1083 | ||
1084 | case DW_CFA_restore_state: | |
1085 | { | |
1086 | struct frame_state_reg_info *old_rs = fs->regs.prev; | |
1087 | fs->regs = *old_rs; | |
1088 | old_rs->prev = unused_rs; | |
1089 | unused_rs = old_rs; | |
1090 | } | |
1091 | break; | |
1092 | ||
1093 | case DW_CFA_def_cfa: | |
1094 | insn_ptr = read_uleb128 (insn_ptr, &utmp); | |
1095 | fs->regs.cfa_reg = (_Unwind_Word)utmp; | |
1096 | insn_ptr = read_uleb128 (insn_ptr, &utmp); | |
1097 | fs->regs.cfa_offset = (_Unwind_Word)utmp; | |
1098 | fs->regs.cfa_how = CFA_REG_OFFSET; | |
1099 | break; | |
1100 | ||
1101 | case DW_CFA_def_cfa_register: | |
1102 | insn_ptr = read_uleb128 (insn_ptr, &utmp); | |
1103 | fs->regs.cfa_reg = (_Unwind_Word)utmp; | |
1104 | fs->regs.cfa_how = CFA_REG_OFFSET; | |
1105 | break; | |
1106 | ||
1107 | case DW_CFA_def_cfa_offset: | |
1108 | insn_ptr = read_uleb128 (insn_ptr, &utmp); | |
1109 | fs->regs.cfa_offset = utmp; | |
1110 | /* cfa_how deliberately not set. */ | |
1111 | break; | |
1112 | ||
1113 | case DW_CFA_def_cfa_expression: | |
1114 | fs->regs.cfa_exp = insn_ptr; | |
1115 | fs->regs.cfa_how = CFA_EXP; | |
1116 | insn_ptr = read_uleb128 (insn_ptr, &utmp); | |
1117 | insn_ptr += utmp; | |
1118 | break; | |
1119 | ||
1120 | case DW_CFA_expression: | |
1121 | insn_ptr = read_uleb128 (insn_ptr, ®); | |
1122 | reg = DWARF_REG_TO_UNWIND_COLUMN (reg); | |
1123 | if (UNWIND_COLUMN_IN_RANGE (reg)) | |
1124 | { | |
1125 | fs->regs.reg[reg].how = REG_SAVED_EXP; | |
1126 | fs->regs.reg[reg].loc.exp = insn_ptr; | |
1127 | } | |
1128 | insn_ptr = read_uleb128 (insn_ptr, &utmp); | |
1129 | insn_ptr += utmp; | |
1130 | break; | |
1131 | ||
1132 | /* Dwarf3. */ | |
1133 | case DW_CFA_offset_extended_sf: | |
1134 | insn_ptr = read_uleb128 (insn_ptr, ®); | |
1135 | insn_ptr = read_sleb128 (insn_ptr, &stmp); | |
1136 | offset = stmp * fs->data_align; | |
1137 | reg = DWARF_REG_TO_UNWIND_COLUMN (reg); | |
1138 | if (UNWIND_COLUMN_IN_RANGE (reg)) | |
1139 | { | |
1140 | fs->regs.reg[reg].how = REG_SAVED_OFFSET; | |
1141 | fs->regs.reg[reg].loc.offset = offset; | |
1142 | } | |
1143 | break; | |
1144 | ||
1145 | case DW_CFA_def_cfa_sf: | |
1146 | insn_ptr = read_uleb128 (insn_ptr, &utmp); | |
1147 | fs->regs.cfa_reg = (_Unwind_Word)utmp; | |
1148 | insn_ptr = read_sleb128 (insn_ptr, &stmp); | |
1149 | fs->regs.cfa_offset = (_Unwind_Sword)stmp; | |
1150 | fs->regs.cfa_how = CFA_REG_OFFSET; | |
1151 | fs->regs.cfa_offset *= fs->data_align; | |
1152 | break; | |
1153 | ||
1154 | case DW_CFA_def_cfa_offset_sf: | |
1155 | insn_ptr = read_sleb128 (insn_ptr, &stmp); | |
1156 | fs->regs.cfa_offset = (_Unwind_Sword)stmp; | |
1157 | fs->regs.cfa_offset *= fs->data_align; | |
1158 | /* cfa_how deliberately not set. */ | |
1159 | break; | |
1160 | ||
1161 | case DW_CFA_val_offset: | |
1162 | insn_ptr = read_uleb128 (insn_ptr, ®); | |
1163 | insn_ptr = read_uleb128 (insn_ptr, &utmp); | |
1164 | offset = (_Unwind_Sword) utmp * fs->data_align; | |
1165 | reg = DWARF_REG_TO_UNWIND_COLUMN (reg); | |
1166 | if (UNWIND_COLUMN_IN_RANGE (reg)) | |
1167 | { | |
1168 | fs->regs.reg[reg].how = REG_SAVED_VAL_OFFSET; | |
1169 | fs->regs.reg[reg].loc.offset = offset; | |
1170 | } | |
1171 | break; | |
1172 | ||
1173 | case DW_CFA_val_offset_sf: | |
1174 | insn_ptr = read_uleb128 (insn_ptr, ®); | |
1175 | insn_ptr = read_sleb128 (insn_ptr, &stmp); | |
1176 | offset = stmp * fs->data_align; | |
1177 | reg = DWARF_REG_TO_UNWIND_COLUMN (reg); | |
1178 | if (UNWIND_COLUMN_IN_RANGE (reg)) | |
1179 | { | |
1180 | fs->regs.reg[reg].how = REG_SAVED_VAL_OFFSET; | |
1181 | fs->regs.reg[reg].loc.offset = offset; | |
1182 | } | |
1183 | break; | |
1184 | ||
1185 | case DW_CFA_val_expression: | |
1186 | insn_ptr = read_uleb128 (insn_ptr, ®); | |
1187 | reg = DWARF_REG_TO_UNWIND_COLUMN (reg); | |
1188 | if (UNWIND_COLUMN_IN_RANGE (reg)) | |
1189 | { | |
1190 | fs->regs.reg[reg].how = REG_SAVED_VAL_EXP; | |
1191 | fs->regs.reg[reg].loc.exp = insn_ptr; | |
1192 | } | |
1193 | insn_ptr = read_uleb128 (insn_ptr, &utmp); | |
1194 | insn_ptr += utmp; | |
1195 | break; | |
1196 | ||
1197 | case DW_CFA_GNU_window_save: | |
1198 | #if defined (__aarch64__) && !defined (__ILP32__) | |
1199 | /* This CFA is multiplexed with Sparc. On AArch64 it's used to toggle | |
1200 | return address signing status. */ | |
1201 | fs->regs.reg[DWARF_REGNUM_AARCH64_RA_STATE].loc.offset ^= 1; | |
1202 | #else | |
1203 | /* ??? Hardcoded for SPARC register window configuration. */ | |
1204 | if (__LIBGCC_DWARF_FRAME_REGISTERS__ >= 32) | |
1205 | for (reg = 16; reg < 32; ++reg) | |
1206 | { | |
1207 | fs->regs.reg[reg].how = REG_SAVED_OFFSET; | |
1208 | fs->regs.reg[reg].loc.offset = (reg - 16) * sizeof (void *); | |
1209 | } | |
1210 | #endif | |
1211 | break; | |
1212 | ||
1213 | case DW_CFA_GNU_args_size: | |
1214 | insn_ptr = read_uleb128 (insn_ptr, &utmp); | |
1215 | context->args_size = (_Unwind_Word)utmp; | |
1216 | break; | |
1217 | ||
1218 | case DW_CFA_GNU_negative_offset_extended: | |
1219 | /* Obsoleted by DW_CFA_offset_extended_sf, but used by | |
1220 | older PowerPC code. */ | |
1221 | insn_ptr = read_uleb128 (insn_ptr, ®); | |
1222 | insn_ptr = read_uleb128 (insn_ptr, &utmp); | |
1223 | offset = (_Unwind_Word) utmp * fs->data_align; | |
1224 | reg = DWARF_REG_TO_UNWIND_COLUMN (reg); | |
1225 | if (UNWIND_COLUMN_IN_RANGE (reg)) | |
1226 | { | |
1227 | fs->regs.reg[reg].how = REG_SAVED_OFFSET; | |
1228 | fs->regs.reg[reg].loc.offset = -offset; | |
1229 | } | |
1230 | break; | |
1231 | ||
1232 | default: | |
1233 | gcc_unreachable (); | |
1234 | } | |
1235 | } | |
1236 | } | |
1237 | \f | |
1238 | /* Given the _Unwind_Context CONTEXT for a stack frame, look up the FDE for | |
1239 | its caller and decode it into FS. This function also sets the | |
1240 | args_size and lsda members of CONTEXT, as they are really information | |
1241 | about the caller's frame. */ | |
1242 | ||
1243 | static _Unwind_Reason_Code | |
1244 | uw_frame_state_for (struct _Unwind_Context *context, _Unwind_FrameState *fs) | |
1245 | { | |
1246 | const struct dwarf_fde *fde; | |
1247 | const struct dwarf_cie *cie; | |
1248 | const unsigned char *aug, *insn, *end; | |
1249 | ||
1250 | memset (fs, 0, sizeof (*fs)); | |
1251 | context->args_size = 0; | |
1252 | context->lsda = 0; | |
1253 | ||
1254 | if (context->ra == 0) | |
1255 | return _URC_END_OF_STACK; | |
1256 | ||
1257 | fde = _Unwind_Find_FDE (context->ra + _Unwind_IsSignalFrame (context) - 1, | |
1258 | &context->bases); | |
1259 | if (fde == NULL) | |
1260 | { | |
1261 | #ifdef MD_FALLBACK_FRAME_STATE_FOR | |
1262 | /* Couldn't find frame unwind info for this function. Try a | |
1263 | target-specific fallback mechanism. This will necessarily | |
1264 | not provide a personality routine or LSDA. */ | |
1265 | return MD_FALLBACK_FRAME_STATE_FOR (context, fs); | |
1266 | #else | |
1267 | return _URC_END_OF_STACK; | |
1268 | #endif | |
1269 | } | |
1270 | ||
1271 | fs->pc = context->bases.func; | |
1272 | ||
1273 | cie = get_cie (fde); | |
1274 | insn = extract_cie_info (cie, context, fs); | |
1275 | if (insn == NULL) | |
1276 | /* CIE contained unknown augmentation. */ | |
1277 | return _URC_FATAL_PHASE1_ERROR; | |
1278 | ||
1279 | /* First decode all the insns in the CIE. */ | |
1280 | end = (const unsigned char *) next_fde ((const struct dwarf_fde *) cie); | |
1281 | execute_cfa_program (insn, end, context, fs); | |
1282 | ||
1283 | /* Locate augmentation for the fde. */ | |
1284 | aug = (const unsigned char *) fde + sizeof (*fde); | |
1285 | aug += 2 * size_of_encoded_value (fs->fde_encoding); | |
1286 | insn = NULL; | |
1287 | if (fs->saw_z) | |
1288 | { | |
1289 | _uleb128_t i; | |
1290 | aug = read_uleb128 (aug, &i); | |
1291 | insn = aug + i; | |
1292 | } | |
1293 | if (fs->lsda_encoding != DW_EH_PE_omit) | |
1294 | { | |
1295 | _Unwind_Ptr lsda; | |
1296 | ||
1297 | aug = read_encoded_value (context, fs->lsda_encoding, aug, &lsda); | |
1298 | context->lsda = (void *) lsda; | |
1299 | } | |
1300 | ||
1301 | /* Then the insns in the FDE up to our target PC. */ | |
1302 | if (insn == NULL) | |
1303 | insn = aug; | |
1304 | end = (const unsigned char *) next_fde (fde); | |
1305 | execute_cfa_program (insn, end, context, fs); | |
1306 | ||
1307 | return _URC_NO_REASON; | |
1308 | } | |
1309 | \f | |
1310 | typedef struct frame_state | |
1311 | { | |
1312 | void *cfa; | |
1313 | void *eh_ptr; | |
1314 | long cfa_offset; | |
1315 | long args_size; | |
1316 | long reg_or_offset[PRE_GCC3_DWARF_FRAME_REGISTERS+1]; | |
1317 | unsigned short cfa_reg; | |
1318 | unsigned short retaddr_column; | |
1319 | char saved[PRE_GCC3_DWARF_FRAME_REGISTERS+1]; | |
1320 | } frame_state; | |
1321 | ||
1322 | struct frame_state * __frame_state_for (void *, struct frame_state *); | |
1323 | ||
1324 | /* Called from pre-G++ 3.0 __throw to find the registers to restore for | |
1325 | a given PC_TARGET. The caller should allocate a local variable of | |
1326 | `struct frame_state' and pass its address to STATE_IN. */ | |
1327 | ||
1328 | struct frame_state * | |
1329 | __frame_state_for (void *pc_target, struct frame_state *state_in) | |
1330 | { | |
1331 | struct _Unwind_Context context; | |
1332 | _Unwind_FrameState fs; | |
1333 | int reg; | |
1334 | ||
1335 | memset (&context, 0, sizeof (struct _Unwind_Context)); | |
1336 | if (!ASSUME_EXTENDED_UNWIND_CONTEXT) | |
1337 | context.flags = EXTENDED_CONTEXT_BIT; | |
1338 | context.ra = pc_target + 1; | |
1339 | ||
1340 | if (uw_frame_state_for (&context, &fs) != _URC_NO_REASON) | |
1341 | return 0; | |
1342 | ||
1343 | /* We have no way to pass a location expression for the CFA to our | |
1344 | caller. It wouldn't understand it anyway. */ | |
1345 | if (fs.regs.cfa_how == CFA_EXP) | |
1346 | return 0; | |
1347 | ||
1348 | for (reg = 0; reg < PRE_GCC3_DWARF_FRAME_REGISTERS + 1; reg++) | |
1349 | { | |
1350 | state_in->saved[reg] = fs.regs.reg[reg].how; | |
1351 | switch (state_in->saved[reg]) | |
1352 | { | |
1353 | case REG_SAVED_REG: | |
1354 | state_in->reg_or_offset[reg] = fs.regs.reg[reg].loc.reg; | |
1355 | break; | |
1356 | case REG_SAVED_OFFSET: | |
1357 | state_in->reg_or_offset[reg] = fs.regs.reg[reg].loc.offset; | |
1358 | break; | |
1359 | default: | |
1360 | state_in->reg_or_offset[reg] = 0; | |
1361 | break; | |
1362 | } | |
1363 | } | |
1364 | ||
1365 | state_in->cfa_offset = fs.regs.cfa_offset; | |
1366 | state_in->cfa_reg = fs.regs.cfa_reg; | |
1367 | state_in->retaddr_column = fs.retaddr_column; | |
1368 | state_in->args_size = context.args_size; | |
1369 | state_in->eh_ptr = fs.eh_ptr; | |
1370 | ||
1371 | return state_in; | |
1372 | } | |
1373 | \f | |
1374 | typedef union { _Unwind_Ptr ptr; _Unwind_Word word; } _Unwind_SpTmp; | |
1375 | ||
1376 | static inline void | |
1377 | _Unwind_SetSpColumn (struct _Unwind_Context *context, void *cfa, | |
1378 | _Unwind_SpTmp *tmp_sp) | |
1379 | { | |
1380 | int size = dwarf_reg_size_table[__builtin_dwarf_sp_column ()]; | |
1381 | ||
1382 | if (size == sizeof(_Unwind_Ptr)) | |
1383 | tmp_sp->ptr = (_Unwind_Ptr) cfa; | |
1384 | else | |
1385 | { | |
1386 | gcc_assert (size == sizeof(_Unwind_Word)); | |
1387 | tmp_sp->word = (_Unwind_Ptr) cfa; | |
1388 | } | |
1389 | _Unwind_SetGRPtr (context, __builtin_dwarf_sp_column (), tmp_sp); | |
1390 | } | |
1391 | ||
1392 | static void | |
1393 | uw_update_context_1 (struct _Unwind_Context *context, _Unwind_FrameState *fs) | |
1394 | { | |
1395 | struct _Unwind_Context orig_context = *context; | |
1396 | void *cfa; | |
1397 | long i; | |
1398 | ||
1399 | #ifdef __LIBGCC_EH_RETURN_STACKADJ_RTX__ | |
1400 | /* Special handling here: Many machines do not use a frame pointer, | |
1401 | and track the CFA only through offsets from the stack pointer from | |
1402 | one frame to the next. In this case, the stack pointer is never | |
1403 | stored, so it has no saved address in the context. What we do | |
1404 | have is the CFA from the previous stack frame. | |
1405 | ||
1406 | In very special situations (such as unwind info for signal return), | |
1407 | there may be location expressions that use the stack pointer as well. | |
1408 | ||
1409 | Do this conditionally for one frame. This allows the unwind info | |
1410 | for one frame to save a copy of the stack pointer from the previous | |
1411 | frame, and be able to use much easier CFA mechanisms to do it. | |
1412 | Always zap the saved stack pointer value for the next frame; carrying | |
1413 | the value over from one frame to another doesn't make sense. */ | |
1414 | ||
1415 | _Unwind_SpTmp tmp_sp; | |
1416 | ||
1417 | if (!_Unwind_GetGRPtr (&orig_context, __builtin_dwarf_sp_column ())) | |
1418 | _Unwind_SetSpColumn (&orig_context, context->cfa, &tmp_sp); | |
1419 | _Unwind_SetGRPtr (context, __builtin_dwarf_sp_column (), NULL); | |
1420 | #endif | |
1421 | ||
1422 | /* Compute this frame's CFA. */ | |
1423 | switch (fs->regs.cfa_how) | |
1424 | { | |
1425 | case CFA_REG_OFFSET: | |
1426 | cfa = _Unwind_GetPtr (&orig_context, fs->regs.cfa_reg); | |
1427 | cfa += fs->regs.cfa_offset; | |
1428 | break; | |
1429 | ||
1430 | case CFA_EXP: | |
1431 | { | |
1432 | const unsigned char *exp = fs->regs.cfa_exp; | |
1433 | _uleb128_t len; | |
1434 | ||
1435 | exp = read_uleb128 (exp, &len); | |
1436 | cfa = (void *) (_Unwind_Ptr) | |
1437 | execute_stack_op (exp, exp + len, &orig_context, 0); | |
1438 | break; | |
1439 | } | |
1440 | ||
1441 | default: | |
1442 | gcc_unreachable (); | |
1443 | } | |
1444 | context->cfa = cfa; | |
1445 | ||
1446 | /* Compute the addresses of all registers saved in this frame. */ | |
1447 | for (i = 0; i < __LIBGCC_DWARF_FRAME_REGISTERS__ + 1; ++i) | |
1448 | switch (fs->regs.reg[i].how) | |
1449 | { | |
1450 | case REG_UNSAVED: | |
1451 | case REG_UNDEFINED: | |
1452 | break; | |
1453 | ||
1454 | case REG_SAVED_OFFSET: | |
1455 | _Unwind_SetGRPtr (context, i, | |
1456 | (void *) (cfa + fs->regs.reg[i].loc.offset)); | |
1457 | break; | |
1458 | ||
1459 | case REG_SAVED_REG: | |
1460 | if (_Unwind_GRByValue (&orig_context, fs->regs.reg[i].loc.reg)) | |
1461 | _Unwind_SetGRValue (context, i, | |
1462 | _Unwind_GetGR (&orig_context, | |
1463 | fs->regs.reg[i].loc.reg)); | |
1464 | else | |
1465 | _Unwind_SetGRPtr (context, i, | |
1466 | _Unwind_GetGRPtr (&orig_context, | |
1467 | fs->regs.reg[i].loc.reg)); | |
1468 | break; | |
1469 | ||
1470 | case REG_SAVED_EXP: | |
1471 | { | |
1472 | const unsigned char *exp = fs->regs.reg[i].loc.exp; | |
1473 | _uleb128_t len; | |
1474 | _Unwind_Ptr val; | |
1475 | ||
1476 | exp = read_uleb128 (exp, &len); | |
1477 | val = execute_stack_op (exp, exp + len, &orig_context, | |
1478 | (_Unwind_Ptr) cfa); | |
1479 | _Unwind_SetGRPtr (context, i, (void *) val); | |
1480 | } | |
1481 | break; | |
1482 | ||
1483 | case REG_SAVED_VAL_OFFSET: | |
1484 | _Unwind_SetGRValue (context, i, | |
1485 | (_Unwind_Internal_Ptr) | |
1486 | (cfa + fs->regs.reg[i].loc.offset)); | |
1487 | break; | |
1488 | ||
1489 | case REG_SAVED_VAL_EXP: | |
1490 | { | |
1491 | const unsigned char *exp = fs->regs.reg[i].loc.exp; | |
1492 | _uleb128_t len; | |
1493 | _Unwind_Ptr val; | |
1494 | ||
1495 | exp = read_uleb128 (exp, &len); | |
1496 | val = execute_stack_op (exp, exp + len, &orig_context, | |
1497 | (_Unwind_Ptr) cfa); | |
1498 | _Unwind_SetGRValue (context, i, val); | |
1499 | } | |
1500 | break; | |
1501 | } | |
1502 | ||
1503 | _Unwind_SetSignalFrame (context, fs->signal_frame); | |
1504 | ||
1505 | #ifdef MD_FROB_UPDATE_CONTEXT | |
1506 | MD_FROB_UPDATE_CONTEXT (context, fs); | |
1507 | #endif | |
1508 | } | |
1509 | ||
1510 | /* CONTEXT describes the unwind state for a frame, and FS describes the FDE | |
1511 | of its caller. Update CONTEXT to refer to the caller as well. Note | |
1512 | that the args_size and lsda members are not updated here, but later in | |
1513 | uw_frame_state_for. */ | |
1514 | ||
1515 | static void | |
1516 | uw_update_context (struct _Unwind_Context *context, _Unwind_FrameState *fs) | |
1517 | { | |
1518 | uw_update_context_1 (context, fs); | |
1519 | ||
1520 | /* In general this unwinder doesn't make any distinction between | |
1521 | undefined and same_value rule. Call-saved registers are assumed | |
1522 | to have same_value rule by default and explicit undefined | |
1523 | rule is handled like same_value. The only exception is | |
1524 | DW_CFA_undefined on retaddr_column which is supposed to | |
1525 | mark outermost frame in DWARF 3. */ | |
1526 | if (fs->regs.reg[DWARF_REG_TO_UNWIND_COLUMN (fs->retaddr_column)].how | |
1527 | == REG_UNDEFINED) | |
1528 | /* uw_frame_state_for uses context->ra == 0 check to find outermost | |
1529 | stack frame. */ | |
1530 | context->ra = 0; | |
1531 | else | |
1532 | { | |
1533 | /* Compute the return address now, since the return address column | |
1534 | can change from frame to frame. */ | |
1535 | context->ra = __builtin_extract_return_addr | |
1536 | (_Unwind_GetPtr (context, fs->retaddr_column)); | |
1537 | #ifdef MD_POST_EXTRACT_FRAME_ADDR | |
1538 | context->ra = MD_POST_EXTRACT_FRAME_ADDR (context, fs, context->ra); | |
1539 | #endif | |
1540 | } | |
1541 | } | |
1542 | ||
1543 | static void | |
1544 | uw_advance_context (struct _Unwind_Context *context, _Unwind_FrameState *fs) | |
1545 | { | |
1546 | uw_update_context (context, fs); | |
1547 | } | |
1548 | \f | |
1549 | /* Fill in CONTEXT for top-of-stack. The only valid registers at this | |
1550 | level will be the return address and the CFA. */ | |
1551 | ||
1552 | #define uw_init_context(CONTEXT) \ | |
1553 | do \ | |
1554 | { \ | |
1555 | /* Do any necessary initialization to access arbitrary stack frames. \ | |
1556 | On the SPARC, this means flushing the register windows. */ \ | |
1557 | __builtin_unwind_init (); \ | |
1558 | uw_init_context_1 (CONTEXT, __builtin_dwarf_cfa (), \ | |
1559 | __builtin_return_address (0)); \ | |
1560 | } \ | |
1561 | while (0) | |
1562 | ||
1563 | static inline void | |
1564 | init_dwarf_reg_size_table (void) | |
1565 | { | |
1566 | __builtin_init_dwarf_reg_size_table (dwarf_reg_size_table); | |
1567 | } | |
1568 | ||
1569 | static void __attribute__((noinline)) | |
1570 | uw_init_context_1 (struct _Unwind_Context *context, | |
1571 | void *outer_cfa, void *outer_ra) | |
1572 | { | |
1573 | void *ra = __builtin_extract_return_addr (__builtin_return_address (0)); | |
1574 | #ifdef MD_POST_EXTRACT_ROOT_ADDR | |
1575 | ra = MD_POST_EXTRACT_ROOT_ADDR (ra); | |
1576 | #endif | |
1577 | _Unwind_FrameState fs; | |
1578 | _Unwind_SpTmp sp_slot; | |
1579 | _Unwind_Reason_Code code; | |
1580 | ||
1581 | memset (context, 0, sizeof (struct _Unwind_Context)); | |
1582 | context->ra = ra; | |
1583 | if (!ASSUME_EXTENDED_UNWIND_CONTEXT) | |
1584 | context->flags = EXTENDED_CONTEXT_BIT; | |
1585 | ||
1586 | code = uw_frame_state_for (context, &fs); | |
1587 | gcc_assert (code == _URC_NO_REASON); | |
1588 | ||
1589 | #if __GTHREADS | |
1590 | { | |
1591 | static __gthread_once_t once_regsizes = __GTHREAD_ONCE_INIT; | |
1592 | if (__gthread_once (&once_regsizes, init_dwarf_reg_size_table) != 0 | |
1593 | && dwarf_reg_size_table[0] == 0) | |
1594 | init_dwarf_reg_size_table (); | |
1595 | } | |
1596 | #else | |
1597 | if (dwarf_reg_size_table[0] == 0) | |
1598 | init_dwarf_reg_size_table (); | |
1599 | #endif | |
1600 | ||
1601 | /* Force the frame state to use the known cfa value. */ | |
1602 | _Unwind_SetSpColumn (context, outer_cfa, &sp_slot); | |
1603 | fs.regs.cfa_how = CFA_REG_OFFSET; | |
1604 | fs.regs.cfa_reg = __builtin_dwarf_sp_column (); | |
1605 | fs.regs.cfa_offset = 0; | |
1606 | ||
1607 | uw_update_context_1 (context, &fs); | |
1608 | ||
1609 | /* If the return address column was saved in a register in the | |
1610 | initialization context, then we can't see it in the given | |
1611 | call frame data. So have the initialization context tell us. */ | |
1612 | context->ra = __builtin_extract_return_addr (outer_ra); | |
1613 | #ifdef MD_POST_EXTRACT_ROOT_ADDR | |
1614 | context->ra = MD_POST_EXTRACT_ROOT_ADDR (context->ra); | |
1615 | #endif | |
1616 | } | |
1617 | ||
1618 | static void _Unwind_DebugHook (void *, void *) | |
1619 | __attribute__ ((__noinline__, __used__, __noclone__)); | |
1620 | ||
1621 | /* This function is called during unwinding. It is intended as a hook | |
1622 | for a debugger to intercept exceptions. CFA is the CFA of the | |
1623 | target frame. HANDLER is the PC to which control will be | |
1624 | transferred. */ | |
1625 | static void | |
1626 | _Unwind_DebugHook (void *cfa __attribute__ ((__unused__)), | |
1627 | void *handler __attribute__ ((__unused__))) | |
1628 | { | |
1629 | /* We only want to use stap probes starting with v3. Earlier | |
1630 | versions added too much startup cost. */ | |
1631 | #if defined (HAVE_SYS_SDT_H) && defined (STAP_PROBE2) && _SDT_NOTE_TYPE >= 3 | |
1632 | STAP_PROBE2 (libgcc, unwind, cfa, handler); | |
1633 | #else | |
1634 | asm (""); | |
1635 | #endif | |
1636 | } | |
1637 | ||
1638 | /* Frob exception handler's address kept in TARGET before installing into | |
1639 | CURRENT context. */ | |
1640 | ||
1641 | static inline void * | |
1642 | uw_frob_return_addr (struct _Unwind_Context *current | |
1643 | __attribute__ ((__unused__)), | |
1644 | struct _Unwind_Context *target) | |
1645 | { | |
1646 | void *ret_addr = __builtin_frob_return_addr (target->ra); | |
1647 | #ifdef MD_POST_FROB_EH_HANDLER_ADDR | |
1648 | ret_addr = MD_POST_FROB_EH_HANDLER_ADDR (current, target, ret_addr); | |
1649 | #endif | |
1650 | return ret_addr; | |
1651 | } | |
1652 | ||
1653 | /* Install TARGET into CURRENT so that we can return to it. This is a | |
1654 | macro because __builtin_eh_return must be invoked in the context of | |
1655 | our caller. FRAMES is a number of frames to be unwind. | |
1656 | _Unwind_Frames_Extra is a macro to do additional work during unwinding | |
1657 | if needed, for example shadow stack pointer adjustment for Intel CET | |
1658 | technology. */ | |
1659 | ||
1660 | #define uw_install_context(CURRENT, TARGET, FRAMES) \ | |
1661 | do \ | |
1662 | { \ | |
1663 | long offset = uw_install_context_1 ((CURRENT), (TARGET)); \ | |
1664 | void *handler = uw_frob_return_addr ((CURRENT), (TARGET)); \ | |
1665 | _Unwind_DebugHook ((TARGET)->cfa, handler); \ | |
1666 | _Unwind_Frames_Extra (FRAMES); \ | |
1667 | __builtin_eh_return (offset, handler); \ | |
1668 | } \ | |
1669 | while (0) | |
1670 | ||
1671 | static long | |
1672 | uw_install_context_1 (struct _Unwind_Context *current, | |
1673 | struct _Unwind_Context *target) | |
1674 | { | |
1675 | long i; | |
1676 | _Unwind_SpTmp sp_slot; | |
1677 | ||
1678 | /* If the target frame does not have a saved stack pointer, | |
1679 | then set up the target's CFA. */ | |
1680 | if (!_Unwind_GetGRPtr (target, __builtin_dwarf_sp_column ())) | |
1681 | _Unwind_SetSpColumn (target, target->cfa, &sp_slot); | |
1682 | ||
1683 | for (i = 0; i < __LIBGCC_DWARF_FRAME_REGISTERS__; ++i) | |
1684 | { | |
1685 | void *c = (void *) (_Unwind_Internal_Ptr) current->reg[i]; | |
1686 | void *t = (void *) (_Unwind_Internal_Ptr)target->reg[i]; | |
1687 | ||
1688 | gcc_assert (current->by_value[i] == 0); | |
1689 | if (target->by_value[i] && c) | |
1690 | { | |
1691 | _Unwind_Word w; | |
1692 | _Unwind_Ptr p; | |
1693 | if (dwarf_reg_size_table[i] == sizeof (_Unwind_Word)) | |
1694 | { | |
1695 | w = (_Unwind_Internal_Ptr) t; | |
1696 | memcpy (c, &w, sizeof (_Unwind_Word)); | |
1697 | } | |
1698 | else | |
1699 | { | |
1700 | gcc_assert (dwarf_reg_size_table[i] == sizeof (_Unwind_Ptr)); | |
1701 | p = (_Unwind_Internal_Ptr) t; | |
1702 | memcpy (c, &p, sizeof (_Unwind_Ptr)); | |
1703 | } | |
1704 | } | |
1705 | else if (t && c && t != c) | |
1706 | memcpy (c, t, dwarf_reg_size_table[i]); | |
1707 | } | |
1708 | ||
1709 | /* If the current frame doesn't have a saved stack pointer, then we | |
1710 | need to rely on EH_RETURN_STACKADJ_RTX to get our target stack | |
1711 | pointer value reloaded. */ | |
1712 | if (!_Unwind_GetGRPtr (current, __builtin_dwarf_sp_column ())) | |
1713 | { | |
1714 | void *target_cfa; | |
1715 | ||
1716 | target_cfa = _Unwind_GetPtr (target, __builtin_dwarf_sp_column ()); | |
1717 | ||
1718 | /* We adjust SP by the difference between CURRENT and TARGET's CFA. */ | |
1719 | if (__LIBGCC_STACK_GROWS_DOWNWARD__) | |
1720 | return target_cfa - current->cfa + target->args_size; | |
1721 | else | |
1722 | return current->cfa - target_cfa - target->args_size; | |
1723 | } | |
1724 | return 0; | |
1725 | } | |
1726 | ||
1727 | static inline _Unwind_Ptr | |
1728 | uw_identify_context (struct _Unwind_Context *context) | |
1729 | { | |
1730 | /* The CFA is not sufficient to disambiguate the context of a function | |
1731 | interrupted by a signal before establishing its frame and the context | |
1732 | of the signal itself. */ | |
1733 | if (__LIBGCC_STACK_GROWS_DOWNWARD__) | |
1734 | return _Unwind_GetCFA (context) - _Unwind_IsSignalFrame (context); | |
1735 | else | |
1736 | return _Unwind_GetCFA (context) + _Unwind_IsSignalFrame (context); | |
1737 | } | |
1738 | ||
1739 | ||
1740 | #include "unwind.inc" | |
1741 | ||
1742 | #if defined (USE_GAS_SYMVER) && defined (SHARED) && defined (USE_LIBUNWIND_EXCEPTIONS) | |
1743 | alias (_Unwind_Backtrace); | |
1744 | alias (_Unwind_DeleteException); | |
1745 | alias (_Unwind_FindEnclosingFunction); | |
1746 | alias (_Unwind_ForcedUnwind); | |
1747 | alias (_Unwind_GetDataRelBase); | |
1748 | alias (_Unwind_GetTextRelBase); | |
1749 | alias (_Unwind_GetCFA); | |
1750 | alias (_Unwind_GetGR); | |
1751 | alias (_Unwind_GetIP); | |
1752 | alias (_Unwind_GetLanguageSpecificData); | |
1753 | alias (_Unwind_GetRegionStart); | |
1754 | alias (_Unwind_RaiseException); | |
1755 | alias (_Unwind_Resume); | |
1756 | alias (_Unwind_Resume_or_Rethrow); | |
1757 | alias (_Unwind_SetGR); | |
1758 | alias (_Unwind_SetIP); | |
1759 | #endif | |
1760 | ||
1761 | #endif /* !USING_SJLJ_EXCEPTIONS */ |