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
_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 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
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 *
read_pointer(const void * p)171 read_pointer (const void *p) { const union unaligned *up = p; return up->p; }
172
173 static inline int
read_1u(const void * p)174 read_1u (const void *p) { return *(const unsigned char *) p; }
175
176 static inline int
read_1s(const void * p)177 read_1s (const void *p) { return *(const signed char *) p; }
178
179 static inline int
read_2u(const void * p)180 read_2u (const void *p) { const union unaligned *up = p; return up->u2; }
181
182 static inline int
read_2s(const void * p)183 read_2s (const void *p) { const union unaligned *up = p; return up->s2; }
184
185 static inline unsigned int
read_4u(const void * p)186 read_4u (const void *p) { const union unaligned *up = p; return up->u4; }
187
188 static inline int
read_4s(const void * p)189 read_4s (const void *p) { const union unaligned *up = p; return up->s4; }
190
191 static inline unsigned long
read_8u(const void * p)192 read_8u (const void *p) { const union unaligned *up = p; return up->u8; }
193
194 static inline unsigned long
read_8s(const void * p)195 read_8s (const void *p) { const union unaligned *up = p; return up->s8; }
196
197 static inline _Unwind_Word
_Unwind_IsSignalFrame(struct _Unwind_Context * context)198 _Unwind_IsSignalFrame (struct _Unwind_Context *context)
199 {
200 return (context->flags & SIGNAL_FRAME_BIT) ? 1 : 0;
201 }
202
203 static inline void
_Unwind_SetSignalFrame(struct _Unwind_Context * context,int val)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
_Unwind_IsExtendedContext(struct _Unwind_Context * context)213 _Unwind_IsExtendedContext (struct _Unwind_Context *context)
214 {
215 return (ASSUME_EXTENDED_UNWIND_CONTEXT
216 || (context->flags & EXTENDED_CONTEXT_BIT));
217 }
218
219 /* Get the value of register REGNO as saved in CONTEXT. */
220
221 inline _Unwind_Word
_Unwind_GetGR(struct _Unwind_Context * context,int regno)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 (regno == 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 *
_Unwind_GetPtr(struct _Unwind_Context * context,int index)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
_Unwind_GetCFA(struct _Unwind_Context * context)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
_Unwind_SetGR(struct _Unwind_Context * context,int index,_Unwind_Word val)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 *
_Unwind_GetGRPtr(struct _Unwind_Context * context,int index)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
_Unwind_SetGRPtr(struct _Unwind_Context * context,int index,void * p)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
_Unwind_SetGRValue(struct _Unwind_Context * context,int index,_Unwind_Word val)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
_Unwind_GRByValue(struct _Unwind_Context * context,int index)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
_Unwind_GetIP(struct _Unwind_Context * context)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
_Unwind_GetIPInfo(struct _Unwind_Context * context,int * ip_before_insn)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
_Unwind_SetIP(struct _Unwind_Context * context,_Unwind_Ptr val)369 _Unwind_SetIP (struct _Unwind_Context *context, _Unwind_Ptr val)
370 {
371 context->ra = (void *) val;
372 }
373
374 void *
_Unwind_GetLanguageSpecificData(struct _Unwind_Context * context)375 _Unwind_GetLanguageSpecificData (struct _Unwind_Context *context)
376 {
377 return context->lsda;
378 }
379
380 _Unwind_Ptr
_Unwind_GetRegionStart(struct _Unwind_Context * context)381 _Unwind_GetRegionStart (struct _Unwind_Context *context)
382 {
383 return (_Unwind_Ptr) context->bases.func;
384 }
385
386 void *
_Unwind_FindEnclosingFunction(void * pc)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
_Unwind_GetDataRelBase(struct _Unwind_Context * context)399 _Unwind_GetDataRelBase (struct _Unwind_Context *context)
400 {
401 return (_Unwind_Ptr) context->bases.dbase;
402 }
403
404 _Unwind_Ptr
_Unwind_GetTextRelBase(struct _Unwind_Context * context)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
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 *
extract_cie_info(const struct dwarf_cie * cie,struct _Unwind_Context * context,_Unwind_FrameState * fs)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
execute_stack_op(const unsigned char * op_ptr,const unsigned char * op_end,struct _Unwind_Context * context,_Unwind_Word initial)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
execute_cfa_program(const unsigned char * insn_ptr,const unsigned char * insn_end,struct _Unwind_Context * context,_Unwind_FrameState * fs)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
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
uw_frame_state_for(struct _Unwind_Context * context,_Unwind_FrameState * fs)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
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 *
__frame_state_for(void * pc_target,struct frame_state * state_in)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
1374 typedef union { _Unwind_Ptr ptr; _Unwind_Word word; } _Unwind_SpTmp;
1375
1376 static inline void
_Unwind_SetSpColumn(struct _Unwind_Context * context,void * cfa,_Unwind_SpTmp * tmp_sp)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
uw_update_context_1(struct _Unwind_Context * context,_Unwind_FrameState * fs)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
uw_update_context(struct _Unwind_Context * context,_Unwind_FrameState * fs)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
uw_advance_context(struct _Unwind_Context * context,_Unwind_FrameState * fs)1544 uw_advance_context (struct _Unwind_Context *context, _Unwind_FrameState *fs)
1545 {
1546 uw_update_context (context, fs);
1547 }
1548
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
init_dwarf_reg_size_table(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))
uw_init_context_1(struct _Unwind_Context * context,void * outer_cfa,void * outer_ra)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
_Unwind_DebugHook(void * cfa,void * handler)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 *
uw_frob_return_addr(struct _Unwind_Context * current,struct _Unwind_Context * target)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
uw_install_context_1(struct _Unwind_Context * current,struct _Unwind_Context * target)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
uw_identify_context(struct _Unwind_Context * context)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 */
1762