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