1 /* DWARF2 exception handling and frame unwind runtime interface routines.
2 Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
3 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 In addition to the permissions in the GNU General Public License, the
13 Free Software Foundation gives you unlimited permission to link the
14 compiled version of this file into combinations with other programs,
15 and to distribute those combinations without any restriction coming
16 from the use of this file. (The General Public License restrictions
17 do apply in other respects; for example, they cover modification of
18 the file, and distribution when not linked into a combined
21 GCC is distributed in the hope that it will be useful, but WITHOUT
22 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
23 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
24 License for more details.
26 You should have received a copy of the GNU General Public License
27 along with GCC; see the file COPYING. If not, write to the Free
28 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
33 #include "coretypes.h"
37 #ifdef __USING_SJLJ_EXCEPTIONS__
38 # define NO_SIZE_OF_ENCODED_VALUE
40 #include "unwind-pe.h"
41 #include "unwind-dw2-fde.h"
43 #include "unwind-dw2.h"
45 #ifndef __USING_SJLJ_EXCEPTIONS__
47 #ifndef STACK_GROWS_DOWNWARD
48 #define STACK_GROWS_DOWNWARD 0
50 #undef STACK_GROWS_DOWNWARD
51 #define STACK_GROWS_DOWNWARD 1
54 /* Dwarf frame registers used for pre gcc 3.0 compiled glibc. */
55 #ifndef PRE_GCC3_DWARF_FRAME_REGISTERS
56 #define PRE_GCC3_DWARF_FRAME_REGISTERS DWARF_FRAME_REGISTERS
59 #ifndef DWARF_REG_TO_UNWIND_COLUMN
60 #define DWARF_REG_TO_UNWIND_COLUMN(REGNO) (REGNO)
63 /* This is the register and unwind state for a particular frame. This
64 provides the information necessary to unwind up past a frame and return
66 struct _Unwind_Context
68 void *reg[DWARF_FRAME_REGISTERS+1];
72 struct dwarf_eh_bases bases;
73 /* Signal frame context. */
74 #define SIGNAL_FRAME_BIT ((~(_Unwind_Word) 0 >> 1) + 1)
75 /* Context which has version/args_size/by_value fields. */
76 #define EXTENDED_CONTEXT_BIT ((~(_Unwind_Word) 0 >> 2) + 1)
78 /* 0 for now, can be increased when further fields are added to
79 struct _Unwind_Context. */
81 _Unwind_Word args_size;
82 char by_value[DWARF_FRAME_REGISTERS+1];
85 /* Byte size of every register managed by these routines. */
86 static unsigned char dwarf_reg_size_table[DWARF_FRAME_REGISTERS+1];
89 /* Read unaligned data from the instruction buffer. */
94 unsigned u2 __attribute__ ((mode (HI)));
95 unsigned u4 __attribute__ ((mode (SI)));
96 unsigned u8 __attribute__ ((mode (DI)));
97 signed s2 __attribute__ ((mode (HI)));
98 signed s4 __attribute__ ((mode (SI)));
99 signed s8 __attribute__ ((mode (DI)));
100 } __attribute__ ((packed));
102 static void uw_update_context (struct _Unwind_Context *, _Unwind_FrameState *);
103 static _Unwind_Reason_Code uw_frame_state_for (struct _Unwind_Context *,
104 _Unwind_FrameState *);
107 read_pointer (const void *p) { const union unaligned *up = p; return up->p; }
110 read_1u (const void *p) { return *(const unsigned char *) p; }
113 read_1s (const void *p) { return *(const signed char *) p; }
116 read_2u (const void *p) { const union unaligned *up = p; return up->u2; }
119 read_2s (const void *p) { const union unaligned *up = p; return up->s2; }
121 static inline unsigned int
122 read_4u (const void *p) { const union unaligned *up = p; return up->u4; }
125 read_4s (const void *p) { const union unaligned *up = p; return up->s4; }
127 static inline unsigned long
128 read_8u (const void *p) { const union unaligned *up = p; return up->u8; }
130 static inline unsigned long
131 read_8s (const void *p) { const union unaligned *up = p; return up->s8; }
133 static inline _Unwind_Word
134 _Unwind_IsSignalFrame (struct _Unwind_Context *context)
136 return (context->flags & SIGNAL_FRAME_BIT) ? 1 : 0;
140 _Unwind_SetSignalFrame (struct _Unwind_Context *context, int val)
143 context->flags |= SIGNAL_FRAME_BIT;
145 context->flags &= ~SIGNAL_FRAME_BIT;
148 static inline _Unwind_Word
149 _Unwind_IsExtendedContext (struct _Unwind_Context *context)
151 return context->flags & EXTENDED_CONTEXT_BIT;
154 /* Get the value of register INDEX as saved in CONTEXT. */
157 _Unwind_GetGR (struct _Unwind_Context *context, int index)
162 #ifdef DWARF_ZERO_REG
163 if (index == DWARF_ZERO_REG)
167 index = DWARF_REG_TO_UNWIND_COLUMN (index);
168 gcc_assert (index < (int) sizeof(dwarf_reg_size_table));
169 size = dwarf_reg_size_table[index];
170 ptr = context->reg[index];
172 if (_Unwind_IsExtendedContext (context) && context->by_value[index])
173 return (_Unwind_Word) (_Unwind_Internal_Ptr) ptr;
175 /* This will segfault if the register hasn't been saved. */
176 if (size == sizeof(_Unwind_Ptr))
177 return * (_Unwind_Ptr *) ptr;
180 gcc_assert (size == sizeof(_Unwind_Word));
181 return * (_Unwind_Word *) ptr;
186 _Unwind_GetPtr (struct _Unwind_Context *context, int index)
188 return (void *)(_Unwind_Ptr) _Unwind_GetGR (context, index);
191 /* Get the value of the CFA as saved in CONTEXT. */
194 _Unwind_GetCFA (struct _Unwind_Context *context)
196 return (_Unwind_Ptr) context->cfa;
199 /* Overwrite the saved value for register INDEX in CONTEXT with VAL. */
202 _Unwind_SetGR (struct _Unwind_Context *context, int index, _Unwind_Word val)
207 index = DWARF_REG_TO_UNWIND_COLUMN (index);
208 gcc_assert (index < (int) sizeof(dwarf_reg_size_table));
209 size = dwarf_reg_size_table[index];
211 if (_Unwind_IsExtendedContext (context) && context->by_value[index])
213 context->reg[index] = (void *) (_Unwind_Internal_Ptr) val;
217 ptr = context->reg[index];
219 if (size == sizeof(_Unwind_Ptr))
220 * (_Unwind_Ptr *) ptr = val;
223 gcc_assert (size == sizeof(_Unwind_Word));
224 * (_Unwind_Word *) ptr = val;
228 /* Get the pointer to a register INDEX as saved in CONTEXT. */
231 _Unwind_GetGRPtr (struct _Unwind_Context *context, int index)
233 index = DWARF_REG_TO_UNWIND_COLUMN (index);
234 if (_Unwind_IsExtendedContext (context) && context->by_value[index])
235 return &context->reg[index];
236 return context->reg[index];
239 /* Set the pointer to a register INDEX as saved in CONTEXT. */
242 _Unwind_SetGRPtr (struct _Unwind_Context *context, int index, void *p)
244 index = DWARF_REG_TO_UNWIND_COLUMN (index);
245 if (_Unwind_IsExtendedContext (context))
246 context->by_value[index] = 0;
247 context->reg[index] = p;
250 /* Overwrite the saved value for register INDEX in CONTEXT with VAL. */
253 _Unwind_SetGRValue (struct _Unwind_Context *context, int index,
256 index = DWARF_REG_TO_UNWIND_COLUMN (index);
257 gcc_assert (index < (int) sizeof(dwarf_reg_size_table));
258 gcc_assert (dwarf_reg_size_table[index] == sizeof (_Unwind_Ptr));
260 context->by_value[index] = 1;
261 context->reg[index] = (void *) (_Unwind_Internal_Ptr) val;
264 /* Return nonzero if register INDEX is stored by value rather than
268 _Unwind_GRByValue (struct _Unwind_Context *context, int index)
270 index = DWARF_REG_TO_UNWIND_COLUMN (index);
271 return context->by_value[index];
274 /* Retrieve the return address for CONTEXT. */
277 _Unwind_GetIP (struct _Unwind_Context *context)
279 return (_Unwind_Ptr) context->ra;
282 /* Retrieve the return address and flag whether that IP is before
283 or after first not yet fully executed instruction. */
286 _Unwind_GetIPInfo (struct _Unwind_Context *context, int *ip_before_insn)
288 *ip_before_insn = _Unwind_IsSignalFrame (context);
289 return (_Unwind_Ptr) context->ra;
292 /* Overwrite the return address for CONTEXT with VAL. */
295 _Unwind_SetIP (struct _Unwind_Context *context, _Unwind_Ptr val)
297 context->ra = (void *) val;
301 _Unwind_GetLanguageSpecificData (struct _Unwind_Context *context)
303 return context->lsda;
307 _Unwind_GetRegionStart (struct _Unwind_Context *context)
309 return (_Unwind_Ptr) context->bases.func;
313 _Unwind_FindEnclosingFunction (void *pc)
315 struct dwarf_eh_bases bases;
316 const struct dwarf_fde *fde = _Unwind_Find_FDE (pc-1, &bases);
325 _Unwind_GetDataRelBase (struct _Unwind_Context *context)
327 return (_Unwind_Ptr) context->bases.dbase;
331 _Unwind_GetTextRelBase (struct _Unwind_Context *context)
333 return (_Unwind_Ptr) context->bases.tbase;
337 #ifdef MD_UNWIND_SUPPORT
338 #include MD_UNWIND_SUPPORT
341 /* Extract any interesting information from the CIE for the translation
342 unit F belongs to. Return a pointer to the byte after the augmentation,
343 or NULL if we encountered an undecipherable augmentation. */
345 static const unsigned char *
346 extract_cie_info (const struct dwarf_cie *cie, struct _Unwind_Context *context,
347 _Unwind_FrameState *fs)
349 const unsigned char *aug = cie->augmentation;
350 const unsigned char *p = aug + strlen ((const char *)aug) + 1;
351 const unsigned char *ret = NULL;
354 /* g++ v2 "eh" has pointer immediately following augmentation string,
355 so it must be handled first. */
356 if (aug[0] == 'e' && aug[1] == 'h')
358 fs->eh_ptr = read_pointer (p);
359 p += sizeof (void *);
363 /* Immediately following the augmentation are the code and
364 data alignment and return address column. */
365 p = read_uleb128 (p, &fs->code_align);
366 p = read_sleb128 (p, &fs->data_align);
367 if (cie->version == 1)
368 fs->retaddr_column = *p++;
370 p = read_uleb128 (p, &fs->retaddr_column);
371 fs->lsda_encoding = DW_EH_PE_omit;
373 /* If the augmentation starts with 'z', then a uleb128 immediately
374 follows containing the length of the augmentation field following
378 p = read_uleb128 (p, &utmp);
385 /* Iterate over recognized augmentation subsequences. */
388 /* "L" indicates a byte showing how the LSDA pointer is encoded. */
391 fs->lsda_encoding = *p++;
395 /* "R" indicates a byte indicating how FDE addresses are encoded. */
396 else if (aug[0] == 'R')
398 fs->fde_encoding = *p++;
402 /* "P" indicates a personality routine in the CIE augmentation. */
403 else if (aug[0] == 'P')
405 _Unwind_Ptr personality;
407 p = read_encoded_value (context, *p, p + 1, &personality);
408 fs->personality = (_Unwind_Personality_Fn) personality;
412 /* "S" indicates a signal frame. */
413 else if (aug[0] == 'S')
415 fs->signal_frame = 1;
419 /* Otherwise we have an unknown augmentation string.
420 Bail unless we saw a 'z' prefix. */
425 return ret ? ret : p;
429 /* Decode a DW_OP stack program. Return the top of stack. Push INITIAL
430 onto the stack to start. */
433 execute_stack_op (const unsigned char *op_ptr, const unsigned char *op_end,
434 struct _Unwind_Context *context, _Unwind_Word initial)
436 _Unwind_Word stack[64]; /* ??? Assume this is enough. */
442 while (op_ptr < op_end)
444 enum dwarf_location_atom op = *op_ptr++;
445 _Unwind_Word result, reg, utmp;
446 _Unwind_Sword offset, stmp;
482 result = op - DW_OP_lit0;
486 result = (_Unwind_Word) (_Unwind_Ptr) read_pointer (op_ptr);
487 op_ptr += sizeof (void *);
491 result = read_1u (op_ptr);
495 result = read_1s (op_ptr);
499 result = read_2u (op_ptr);
503 result = read_2s (op_ptr);
507 result = read_4u (op_ptr);
511 result = read_4s (op_ptr);
515 result = read_8u (op_ptr);
519 result = read_8s (op_ptr);
523 op_ptr = read_uleb128 (op_ptr, &result);
526 op_ptr = read_sleb128 (op_ptr, &stmp);
562 result = _Unwind_GetGR (context, op - DW_OP_reg0);
565 op_ptr = read_uleb128 (op_ptr, ®);
566 result = _Unwind_GetGR (context, reg);
601 op_ptr = read_sleb128 (op_ptr, &offset);
602 result = _Unwind_GetGR (context, op - DW_OP_breg0) + offset;
605 op_ptr = read_uleb128 (op_ptr, ®);
606 op_ptr = read_sleb128 (op_ptr, &offset);
607 result = _Unwind_GetGR (context, reg) + offset;
611 gcc_assert (stack_elt);
612 result = stack[stack_elt - 1];
616 gcc_assert (stack_elt);
622 gcc_assert (offset < stack_elt - 1);
623 result = stack[stack_elt - 1 - offset];
627 gcc_assert (stack_elt >= 2);
628 result = stack[stack_elt - 2];
634 gcc_assert (stack_elt >= 2);
635 t = stack[stack_elt - 1];
636 stack[stack_elt - 1] = stack[stack_elt - 2];
637 stack[stack_elt - 2] = t;
643 _Unwind_Word t1, t2, t3;
645 gcc_assert (stack_elt >= 3);
646 t1 = stack[stack_elt - 1];
647 t2 = stack[stack_elt - 2];
648 t3 = stack[stack_elt - 3];
649 stack[stack_elt - 1] = t2;
650 stack[stack_elt - 2] = t3;
651 stack[stack_elt - 3] = t1;
656 case DW_OP_deref_size:
660 case DW_OP_plus_uconst:
661 /* Unary operations. */
662 gcc_assert (stack_elt);
665 result = stack[stack_elt];
671 void *ptr = (void *) (_Unwind_Ptr) result;
672 result = (_Unwind_Ptr) read_pointer (ptr);
676 case DW_OP_deref_size:
678 void *ptr = (void *) (_Unwind_Ptr) result;
682 result = read_1u (ptr);
685 result = read_2u (ptr);
688 result = read_4u (ptr);
691 result = read_8u (ptr);
700 if ((_Unwind_Sword) result < 0)
709 case DW_OP_plus_uconst:
710 op_ptr = read_uleb128 (op_ptr, &utmp);
737 /* Binary operations. */
738 _Unwind_Word first, second;
739 gcc_assert (stack_elt >= 2);
742 second = stack[stack_elt];
743 first = stack[stack_elt + 1];
748 result = second & first;
751 result = (_Unwind_Sword) second / (_Unwind_Sword) first;
754 result = second - first;
757 result = (_Unwind_Sword) second % (_Unwind_Sword) first;
760 result = second * first;
763 result = second | first;
766 result = second + first;
769 result = second << first;
772 result = second >> first;
775 result = (_Unwind_Sword) second >> first;
778 result = second ^ first;
781 result = (_Unwind_Sword) first <= (_Unwind_Sword) second;
784 result = (_Unwind_Sword) first >= (_Unwind_Sword) second;
787 result = (_Unwind_Sword) first == (_Unwind_Sword) second;
790 result = (_Unwind_Sword) first < (_Unwind_Sword) second;
793 result = (_Unwind_Sword) first > (_Unwind_Sword) second;
796 result = (_Unwind_Sword) first != (_Unwind_Sword) second;
806 offset = read_2s (op_ptr);
812 gcc_assert (stack_elt);
815 offset = read_2s (op_ptr);
817 if (stack[stack_elt] != 0)
828 /* Most things push a result value. */
829 gcc_assert ((size_t) stack_elt < sizeof(stack)/sizeof(*stack));
830 stack[stack_elt++] = result;
834 /* We were executing this program to get a value. It should be
836 gcc_assert (stack_elt);
838 return stack[stack_elt];
842 /* Decode DWARF 2 call frame information. Takes pointers the
843 instruction sequence to decode, current register information and
844 CIE info, and the PC range to evaluate. */
847 execute_cfa_program (const unsigned char *insn_ptr,
848 const unsigned char *insn_end,
849 struct _Unwind_Context *context,
850 _Unwind_FrameState *fs)
852 struct frame_state_reg_info *unused_rs = NULL;
854 /* Don't allow remember/restore between CIE and FDE programs. */
855 fs->regs.prev = NULL;
857 /* The comparison with the return address uses < rather than <= because
858 we are only interested in the effects of code before the call; for a
859 noreturn function, the return address may point to unrelated code with
860 a different stack configuration that we are not interested in. We
861 assume that the call itself is unwind info-neutral; if not, or if
862 there are delay instructions that adjust the stack, these must be
863 reflected at the point immediately before the call insn.
864 In signal frames, return address is after last completed instruction,
865 so we add 1 to return address to make the comparison <=. */
866 while (insn_ptr < insn_end
867 && fs->pc < context->ra + _Unwind_IsSignalFrame (context))
869 unsigned char insn = *insn_ptr++;
870 _Unwind_Word reg, utmp;
871 _Unwind_Sword offset, stmp;
873 if ((insn & 0xc0) == DW_CFA_advance_loc)
874 fs->pc += (insn & 0x3f) * fs->code_align;
875 else if ((insn & 0xc0) == DW_CFA_offset)
878 insn_ptr = read_uleb128 (insn_ptr, &utmp);
879 offset = (_Unwind_Sword) utmp * fs->data_align;
880 fs->regs.reg[DWARF_REG_TO_UNWIND_COLUMN (reg)].how
882 fs->regs.reg[DWARF_REG_TO_UNWIND_COLUMN (reg)].loc.offset = offset;
884 else if ((insn & 0xc0) == DW_CFA_restore)
887 fs->regs.reg[DWARF_REG_TO_UNWIND_COLUMN (reg)].how = REG_UNSAVED;
895 insn_ptr = read_encoded_value (context, fs->fde_encoding,
897 fs->pc = (void *) pc;
901 case DW_CFA_advance_loc1:
902 fs->pc += read_1u (insn_ptr) * fs->code_align;
905 case DW_CFA_advance_loc2:
906 fs->pc += read_2u (insn_ptr) * fs->code_align;
909 case DW_CFA_advance_loc4:
910 fs->pc += read_4u (insn_ptr) * fs->code_align;
914 case DW_CFA_offset_extended:
915 insn_ptr = read_uleb128 (insn_ptr, ®);
916 insn_ptr = read_uleb128 (insn_ptr, &utmp);
917 offset = (_Unwind_Sword) utmp * fs->data_align;
918 fs->regs.reg[DWARF_REG_TO_UNWIND_COLUMN (reg)].how
920 fs->regs.reg[DWARF_REG_TO_UNWIND_COLUMN (reg)].loc.offset = offset;
923 case DW_CFA_restore_extended:
924 insn_ptr = read_uleb128 (insn_ptr, ®);
925 /* FIXME, this is wrong; the CIE might have said that the
926 register was saved somewhere. */
927 fs->regs.reg[DWARF_REG_TO_UNWIND_COLUMN(reg)].how = REG_UNSAVED;
930 case DW_CFA_undefined:
931 case DW_CFA_same_value:
932 insn_ptr = read_uleb128 (insn_ptr, ®);
933 fs->regs.reg[DWARF_REG_TO_UNWIND_COLUMN(reg)].how = REG_UNSAVED;
939 case DW_CFA_register:
942 insn_ptr = read_uleb128 (insn_ptr, ®);
943 insn_ptr = read_uleb128 (insn_ptr, ®2);
944 fs->regs.reg[DWARF_REG_TO_UNWIND_COLUMN (reg)].how = REG_SAVED_REG;
945 fs->regs.reg[DWARF_REG_TO_UNWIND_COLUMN (reg)].loc.reg = reg2;
949 case DW_CFA_remember_state:
951 struct frame_state_reg_info *new_rs;
955 unused_rs = unused_rs->prev;
958 new_rs = alloca (sizeof (struct frame_state_reg_info));
961 fs->regs.prev = new_rs;
965 case DW_CFA_restore_state:
967 struct frame_state_reg_info *old_rs = fs->regs.prev;
969 old_rs->prev = unused_rs;
975 insn_ptr = read_uleb128 (insn_ptr, &fs->cfa_reg);
976 insn_ptr = read_uleb128 (insn_ptr, &utmp);
977 fs->cfa_offset = utmp;
978 fs->cfa_how = CFA_REG_OFFSET;
981 case DW_CFA_def_cfa_register:
982 insn_ptr = read_uleb128 (insn_ptr, &fs->cfa_reg);
983 fs->cfa_how = CFA_REG_OFFSET;
986 case DW_CFA_def_cfa_offset:
987 insn_ptr = read_uleb128 (insn_ptr, &utmp);
988 fs->cfa_offset = utmp;
989 /* cfa_how deliberately not set. */
992 case DW_CFA_def_cfa_expression:
993 fs->cfa_exp = insn_ptr;
994 fs->cfa_how = CFA_EXP;
995 insn_ptr = read_uleb128 (insn_ptr, &utmp);
999 case DW_CFA_expression:
1000 insn_ptr = read_uleb128 (insn_ptr, ®);
1001 fs->regs.reg[DWARF_REG_TO_UNWIND_COLUMN (reg)].how = REG_SAVED_EXP;
1002 fs->regs.reg[DWARF_REG_TO_UNWIND_COLUMN (reg)].loc.exp = insn_ptr;
1003 insn_ptr = read_uleb128 (insn_ptr, &utmp);
1008 case DW_CFA_offset_extended_sf:
1009 insn_ptr = read_uleb128 (insn_ptr, ®);
1010 insn_ptr = read_sleb128 (insn_ptr, &stmp);
1011 offset = stmp * fs->data_align;
1012 fs->regs.reg[DWARF_REG_TO_UNWIND_COLUMN (reg)].how
1014 fs->regs.reg[DWARF_REG_TO_UNWIND_COLUMN (reg)].loc.offset = offset;
1017 case DW_CFA_def_cfa_sf:
1018 insn_ptr = read_uleb128 (insn_ptr, &fs->cfa_reg);
1019 insn_ptr = read_sleb128 (insn_ptr, &fs->cfa_offset);
1020 fs->cfa_how = CFA_REG_OFFSET;
1021 fs->cfa_offset *= fs->data_align;
1024 case DW_CFA_def_cfa_offset_sf:
1025 insn_ptr = read_sleb128 (insn_ptr, &fs->cfa_offset);
1026 fs->cfa_offset *= fs->data_align;
1027 /* cfa_how deliberately not set. */
1030 case DW_CFA_val_offset:
1031 insn_ptr = read_uleb128 (insn_ptr, ®);
1032 insn_ptr = read_uleb128 (insn_ptr, &utmp);
1033 offset = (_Unwind_Sword) utmp * fs->data_align;
1034 fs->regs.reg[DWARF_REG_TO_UNWIND_COLUMN (reg)].how
1035 = REG_SAVED_VAL_OFFSET;
1036 fs->regs.reg[DWARF_REG_TO_UNWIND_COLUMN (reg)].loc.offset = offset;
1039 case DW_CFA_val_offset_sf:
1040 insn_ptr = read_uleb128 (insn_ptr, ®);
1041 insn_ptr = read_sleb128 (insn_ptr, &stmp);
1042 offset = stmp * fs->data_align;
1043 fs->regs.reg[DWARF_REG_TO_UNWIND_COLUMN (reg)].how
1044 = REG_SAVED_VAL_OFFSET;
1045 fs->regs.reg[DWARF_REG_TO_UNWIND_COLUMN (reg)].loc.offset = offset;
1048 case DW_CFA_val_expression:
1049 insn_ptr = read_uleb128 (insn_ptr, ®);
1050 fs->regs.reg[DWARF_REG_TO_UNWIND_COLUMN (reg)].how
1051 = REG_SAVED_VAL_EXP;
1052 fs->regs.reg[DWARF_REG_TO_UNWIND_COLUMN (reg)].loc.exp = insn_ptr;
1053 insn_ptr = read_uleb128 (insn_ptr, &utmp);
1057 case DW_CFA_GNU_window_save:
1058 /* ??? Hardcoded for SPARC register window configuration. */
1059 for (reg = 16; reg < 32; ++reg)
1061 fs->regs.reg[reg].how = REG_SAVED_OFFSET;
1062 fs->regs.reg[reg].loc.offset = (reg - 16) * sizeof (void *);
1066 case DW_CFA_GNU_args_size:
1067 insn_ptr = read_uleb128 (insn_ptr, &context->args_size);
1070 case DW_CFA_GNU_negative_offset_extended:
1071 /* Obsoleted by DW_CFA_offset_extended_sf, but used by
1072 older PowerPC code. */
1073 insn_ptr = read_uleb128 (insn_ptr, ®);
1074 insn_ptr = read_uleb128 (insn_ptr, &utmp);
1075 offset = (_Unwind_Word) utmp * fs->data_align;
1076 fs->regs.reg[DWARF_REG_TO_UNWIND_COLUMN (reg)].how
1078 fs->regs.reg[DWARF_REG_TO_UNWIND_COLUMN (reg)].loc.offset = -offset;
1087 /* Given the _Unwind_Context CONTEXT for a stack frame, look up the FDE for
1088 its caller and decode it into FS. This function also sets the
1089 args_size and lsda members of CONTEXT, as they are really information
1090 about the caller's frame. */
1092 static _Unwind_Reason_Code
1093 uw_frame_state_for (struct _Unwind_Context *context, _Unwind_FrameState *fs)
1095 const struct dwarf_fde *fde;
1096 const struct dwarf_cie *cie;
1097 const unsigned char *aug, *insn, *end;
1099 memset (fs, 0, sizeof (*fs));
1100 context->args_size = 0;
1103 if (context->ra == 0)
1104 return _URC_END_OF_STACK;
1106 fde = _Unwind_Find_FDE (context->ra + _Unwind_IsSignalFrame (context) - 1,
1110 #ifdef MD_FALLBACK_FRAME_STATE_FOR
1111 /* Couldn't find frame unwind info for this function. Try a
1112 target-specific fallback mechanism. This will necessarily
1113 not provide a personality routine or LSDA. */
1114 return MD_FALLBACK_FRAME_STATE_FOR (context, fs);
1116 return _URC_END_OF_STACK;
1120 fs->pc = context->bases.func;
1122 cie = get_cie (fde);
1123 insn = extract_cie_info (cie, context, fs);
1125 /* CIE contained unknown augmentation. */
1126 return _URC_FATAL_PHASE1_ERROR;
1128 /* First decode all the insns in the CIE. */
1129 end = (unsigned char *) next_fde ((struct dwarf_fde *) cie);
1130 execute_cfa_program (insn, end, context, fs);
1132 /* Locate augmentation for the fde. */
1133 aug = (unsigned char *) fde + sizeof (*fde);
1134 aug += 2 * size_of_encoded_value (fs->fde_encoding);
1139 aug = read_uleb128 (aug, &i);
1142 if (fs->lsda_encoding != DW_EH_PE_omit)
1146 aug = read_encoded_value (context, fs->lsda_encoding, aug, &lsda);
1147 context->lsda = (void *) lsda;
1150 /* Then the insns in the FDE up to our target PC. */
1153 end = (unsigned char *) next_fde (fde);
1154 execute_cfa_program (insn, end, context, fs);
1156 return _URC_NO_REASON;
1159 typedef struct frame_state
1165 long reg_or_offset[PRE_GCC3_DWARF_FRAME_REGISTERS+1];
1166 unsigned short cfa_reg;
1167 unsigned short retaddr_column;
1168 char saved[PRE_GCC3_DWARF_FRAME_REGISTERS+1];
1171 struct frame_state * __frame_state_for (void *, struct frame_state *);
1173 /* Called from pre-G++ 3.0 __throw to find the registers to restore for
1174 a given PC_TARGET. The caller should allocate a local variable of
1175 `struct frame_state' and pass its address to STATE_IN. */
1177 struct frame_state *
1178 __frame_state_for (void *pc_target, struct frame_state *state_in)
1180 struct _Unwind_Context context;
1181 _Unwind_FrameState fs;
1184 memset (&context, 0, sizeof (struct _Unwind_Context));
1185 context.flags = EXTENDED_CONTEXT_BIT;
1186 context.ra = pc_target + 1;
1188 if (uw_frame_state_for (&context, &fs) != _URC_NO_REASON)
1191 /* We have no way to pass a location expression for the CFA to our
1192 caller. It wouldn't understand it anyway. */
1193 if (fs.cfa_how == CFA_EXP)
1196 for (reg = 0; reg < PRE_GCC3_DWARF_FRAME_REGISTERS + 1; reg++)
1198 state_in->saved[reg] = fs.regs.reg[reg].how;
1199 switch (state_in->saved[reg])
1202 state_in->reg_or_offset[reg] = fs.regs.reg[reg].loc.reg;
1204 case REG_SAVED_OFFSET:
1205 state_in->reg_or_offset[reg] = fs.regs.reg[reg].loc.offset;
1208 state_in->reg_or_offset[reg] = 0;
1213 state_in->cfa_offset = fs.cfa_offset;
1214 state_in->cfa_reg = fs.cfa_reg;
1215 state_in->retaddr_column = fs.retaddr_column;
1216 state_in->args_size = context.args_size;
1217 state_in->eh_ptr = fs.eh_ptr;
1222 typedef union { _Unwind_Ptr ptr; _Unwind_Word word; } _Unwind_SpTmp;
1225 _Unwind_SetSpColumn (struct _Unwind_Context *context, void *cfa,
1226 _Unwind_SpTmp *tmp_sp)
1228 int size = dwarf_reg_size_table[__builtin_dwarf_sp_column ()];
1230 if (size == sizeof(_Unwind_Ptr))
1231 tmp_sp->ptr = (_Unwind_Ptr) cfa;
1234 gcc_assert (size == sizeof(_Unwind_Word));
1235 tmp_sp->word = (_Unwind_Ptr) cfa;
1237 _Unwind_SetGRPtr (context, __builtin_dwarf_sp_column (), tmp_sp);
1241 uw_update_context_1 (struct _Unwind_Context *context, _Unwind_FrameState *fs)
1243 struct _Unwind_Context orig_context = *context;
1247 #ifdef EH_RETURN_STACKADJ_RTX
1248 /* Special handling here: Many machines do not use a frame pointer,
1249 and track the CFA only through offsets from the stack pointer from
1250 one frame to the next. In this case, the stack pointer is never
1251 stored, so it has no saved address in the context. What we do
1252 have is the CFA from the previous stack frame.
1254 In very special situations (such as unwind info for signal return),
1255 there may be location expressions that use the stack pointer as well.
1257 Do this conditionally for one frame. This allows the unwind info
1258 for one frame to save a copy of the stack pointer from the previous
1259 frame, and be able to use much easier CFA mechanisms to do it.
1260 Always zap the saved stack pointer value for the next frame; carrying
1261 the value over from one frame to another doesn't make sense. */
1263 _Unwind_SpTmp tmp_sp;
1265 if (!_Unwind_GetGRPtr (&orig_context, __builtin_dwarf_sp_column ()))
1266 _Unwind_SetSpColumn (&orig_context, context->cfa, &tmp_sp);
1267 _Unwind_SetGRPtr (context, __builtin_dwarf_sp_column (), NULL);
1270 /* Compute this frame's CFA. */
1271 switch (fs->cfa_how)
1273 case CFA_REG_OFFSET:
1274 cfa = _Unwind_GetPtr (&orig_context, fs->cfa_reg);
1275 cfa += fs->cfa_offset;
1280 const unsigned char *exp = fs->cfa_exp;
1283 exp = read_uleb128 (exp, &len);
1284 cfa = (void *) (_Unwind_Ptr)
1285 execute_stack_op (exp, exp + len, &orig_context, 0);
1294 /* Compute the addresses of all registers saved in this frame. */
1295 for (i = 0; i < DWARF_FRAME_REGISTERS + 1; ++i)
1296 switch (fs->regs.reg[i].how)
1301 case REG_SAVED_OFFSET:
1302 _Unwind_SetGRPtr (context, i,
1303 (void *) (cfa + fs->regs.reg[i].loc.offset));
1307 if (_Unwind_GRByValue (&orig_context, fs->regs.reg[i].loc.reg))
1308 _Unwind_SetGRValue (context, i,
1309 _Unwind_GetGR (&orig_context,
1310 fs->regs.reg[i].loc.reg));
1312 _Unwind_SetGRPtr (context, i,
1313 _Unwind_GetGRPtr (&orig_context,
1314 fs->regs.reg[i].loc.reg));
1319 const unsigned char *exp = fs->regs.reg[i].loc.exp;
1323 exp = read_uleb128 (exp, &len);
1324 val = execute_stack_op (exp, exp + len, &orig_context,
1326 _Unwind_SetGRPtr (context, i, (void *) val);
1330 case REG_SAVED_VAL_OFFSET:
1331 _Unwind_SetGRValue (context, i,
1332 (_Unwind_Internal_Ptr)
1333 (cfa + fs->regs.reg[i].loc.offset));
1336 case REG_SAVED_VAL_EXP:
1338 const unsigned char *exp = fs->regs.reg[i].loc.exp;
1342 exp = read_uleb128 (exp, &len);
1343 val = execute_stack_op (exp, exp + len, &orig_context,
1345 _Unwind_SetGRValue (context, i, val);
1350 _Unwind_SetSignalFrame (context, fs->signal_frame);
1352 #ifdef MD_FROB_UPDATE_CONTEXT
1353 MD_FROB_UPDATE_CONTEXT (context, fs);
1357 /* CONTEXT describes the unwind state for a frame, and FS describes the FDE
1358 of its caller. Update CONTEXT to refer to the caller as well. Note
1359 that the args_size and lsda members are not updated here, but later in
1360 uw_frame_state_for. */
1363 uw_update_context (struct _Unwind_Context *context, _Unwind_FrameState *fs)
1365 uw_update_context_1 (context, fs);
1367 /* Compute the return address now, since the return address column
1368 can change from frame to frame. */
1369 context->ra = __builtin_extract_return_addr
1370 (_Unwind_GetPtr (context, fs->retaddr_column));
1374 uw_advance_context (struct _Unwind_Context *context, _Unwind_FrameState *fs)
1376 uw_update_context (context, fs);
1379 /* Fill in CONTEXT for top-of-stack. The only valid registers at this
1380 level will be the return address and the CFA. */
1382 #define uw_init_context(CONTEXT) \
1385 /* Do any necessary initialization to access arbitrary stack frames. \
1386 On the SPARC, this means flushing the register windows. */ \
1387 __builtin_unwind_init (); \
1388 uw_init_context_1 (CONTEXT, __builtin_dwarf_cfa (), \
1389 __builtin_return_address (0)); \
1394 init_dwarf_reg_size_table (void)
1396 __builtin_init_dwarf_reg_size_table (dwarf_reg_size_table);
1400 uw_init_context_1 (struct _Unwind_Context *context,
1401 void *outer_cfa, void *outer_ra)
1403 void *ra = __builtin_extract_return_addr (__builtin_return_address (0));
1404 _Unwind_FrameState fs;
1405 _Unwind_SpTmp sp_slot;
1406 _Unwind_Reason_Code code;
1408 memset (context, 0, sizeof (struct _Unwind_Context));
1410 context->flags = EXTENDED_CONTEXT_BIT;
1412 code = uw_frame_state_for (context, &fs);
1413 gcc_assert (code == _URC_NO_REASON);
1417 static __gthread_once_t once_regsizes = __GTHREAD_ONCE_INIT;
1418 if (__gthread_once (&once_regsizes, init_dwarf_reg_size_table) != 0
1419 || dwarf_reg_size_table[0] == 0)
1420 init_dwarf_reg_size_table ();
1423 if (dwarf_reg_size_table[0] == 0)
1424 init_dwarf_reg_size_table ();
1427 /* Force the frame state to use the known cfa value. */
1428 _Unwind_SetSpColumn (context, outer_cfa, &sp_slot);
1429 fs.cfa_how = CFA_REG_OFFSET;
1430 fs.cfa_reg = __builtin_dwarf_sp_column ();
1433 uw_update_context_1 (context, &fs);
1435 /* If the return address column was saved in a register in the
1436 initialization context, then we can't see it in the given
1437 call frame data. So have the initialization context tell us. */
1438 context->ra = __builtin_extract_return_addr (outer_ra);
1442 /* Install TARGET into CURRENT so that we can return to it. This is a
1443 macro because __builtin_eh_return must be invoked in the context of
1446 #define uw_install_context(CURRENT, TARGET) \
1449 long offset = uw_install_context_1 ((CURRENT), (TARGET)); \
1450 void *handler = __builtin_frob_return_addr ((TARGET)->ra); \
1451 __builtin_eh_return (offset, handler); \
1456 uw_install_context_1 (struct _Unwind_Context *current,
1457 struct _Unwind_Context *target)
1460 _Unwind_SpTmp sp_slot;
1462 /* If the target frame does not have a saved stack pointer,
1463 then set up the target's CFA. */
1464 if (!_Unwind_GetGRPtr (target, __builtin_dwarf_sp_column ()))
1465 _Unwind_SetSpColumn (target, target->cfa, &sp_slot);
1467 for (i = 0; i < DWARF_FRAME_REGISTERS; ++i)
1469 void *c = current->reg[i];
1470 void *t = target->reg[i];
1472 gcc_assert (current->by_value[i] == 0);
1473 if (target->by_value[i] && c)
1477 if (dwarf_reg_size_table[i] == sizeof (_Unwind_Word))
1479 w = (_Unwind_Internal_Ptr) t;
1480 memcpy (c, &w, sizeof (_Unwind_Word));
1484 gcc_assert (dwarf_reg_size_table[i] == sizeof (_Unwind_Ptr));
1485 p = (_Unwind_Internal_Ptr) t;
1486 memcpy (c, &p, sizeof (_Unwind_Ptr));
1489 else if (t && c && t != c)
1490 memcpy (c, t, dwarf_reg_size_table[i]);
1493 /* If the current frame doesn't have a saved stack pointer, then we
1494 need to rely on EH_RETURN_STACKADJ_RTX to get our target stack
1495 pointer value reloaded. */
1496 if (!_Unwind_GetGRPtr (current, __builtin_dwarf_sp_column ()))
1500 target_cfa = _Unwind_GetPtr (target, __builtin_dwarf_sp_column ());
1502 /* We adjust SP by the difference between CURRENT and TARGET's CFA. */
1503 if (STACK_GROWS_DOWNWARD)
1504 return target_cfa - current->cfa + target->args_size;
1506 return current->cfa - target_cfa - target->args_size;
1511 static inline _Unwind_Ptr
1512 uw_identify_context (struct _Unwind_Context *context)
1514 return _Unwind_GetIP (context);
1518 #include "unwind.inc"
1520 #if defined (USE_GAS_SYMVER) && defined (SHARED) && defined (USE_LIBUNWIND_EXCEPTIONS)
1521 alias (_Unwind_Backtrace);
1522 alias (_Unwind_DeleteException);
1523 alias (_Unwind_FindEnclosingFunction);
1524 alias (_Unwind_ForcedUnwind);
1525 alias (_Unwind_GetDataRelBase);
1526 alias (_Unwind_GetTextRelBase);
1527 alias (_Unwind_GetCFA);
1528 alias (_Unwind_GetGR);
1529 alias (_Unwind_GetIP);
1530 alias (_Unwind_GetLanguageSpecificData);
1531 alias (_Unwind_GetRegionStart);
1532 alias (_Unwind_RaiseException);
1533 alias (_Unwind_Resume);
1534 alias (_Unwind_Resume_or_Rethrow);
1535 alias (_Unwind_SetGR);
1536 alias (_Unwind_SetIP);
1539 #endif /* !USING_SJLJ_EXCEPTIONS */