1 /* DWARF2 exception handling and frame unwind runtime interface routines.
2 Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
3 2008, 2009 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
;
355 /* g++ v2 "eh" has pointer immediately following augmentation string,
356 so it must be handled first. */
357 if (aug
[0] == 'e' && aug
[1] == 'h')
359 fs
->eh_ptr
= read_pointer (p
);
360 p
+= sizeof (void *);
364 /* Immediately following the augmentation are the code and
365 data alignment and return address column. */
366 p
= read_uleb128 (p
, &utmp
);
367 fs
->code_align
= (_Unwind_Word
)utmp
;
368 p
= read_sleb128 (p
, &stmp
);
369 fs
->data_align
= (_Unwind_Sword
)stmp
;
370 if (cie
->version
== 1)
371 fs
->retaddr_column
= *p
++;
374 p
= read_uleb128 (p
, &utmp
);
375 fs
->retaddr_column
= (_Unwind_Word
)utmp
;
377 fs
->lsda_encoding
= DW_EH_PE_omit
;
379 /* If the augmentation starts with 'z', then a uleb128 immediately
380 follows containing the length of the augmentation field following
384 p
= read_uleb128 (p
, &utmp
);
391 /* Iterate over recognized augmentation subsequences. */
394 /* "L" indicates a byte showing how the LSDA pointer is encoded. */
397 fs
->lsda_encoding
= *p
++;
401 /* "R" indicates a byte indicating how FDE addresses are encoded. */
402 else if (aug
[0] == 'R')
404 fs
->fde_encoding
= *p
++;
408 /* "P" indicates a personality routine in the CIE augmentation. */
409 else if (aug
[0] == 'P')
411 _Unwind_Ptr personality
;
413 p
= read_encoded_value (context
, *p
, p
+ 1, &personality
);
414 fs
->personality
= (_Unwind_Personality_Fn
) personality
;
418 /* "S" indicates a signal frame. */
419 else if (aug
[0] == 'S')
421 fs
->signal_frame
= 1;
425 /* Otherwise we have an unknown augmentation string.
426 Bail unless we saw a 'z' prefix. */
431 return ret
? ret
: p
;
435 /* Decode a DW_OP stack program. Return the top of stack. Push INITIAL
436 onto the stack to start. */
439 execute_stack_op (const unsigned char *op_ptr
, const unsigned char *op_end
,
440 struct _Unwind_Context
*context
, _Unwind_Word initial
)
442 _Unwind_Word stack
[64]; /* ??? Assume this is enough. */
448 while (op_ptr
< op_end
)
450 enum dwarf_location_atom op
= *op_ptr
++;
452 _uleb128_t reg
, utmp
;
453 _sleb128_t offset
, stmp
;
489 result
= op
- DW_OP_lit0
;
493 result
= (_Unwind_Word
) (_Unwind_Ptr
) read_pointer (op_ptr
);
494 op_ptr
+= sizeof (void *);
497 case DW_OP_GNU_encoded_addr
:
500 op_ptr
= read_encoded_value (context
, *op_ptr
, op_ptr
+1, &presult
);
506 result
= read_1u (op_ptr
);
510 result
= read_1s (op_ptr
);
514 result
= read_2u (op_ptr
);
518 result
= read_2s (op_ptr
);
522 result
= read_4u (op_ptr
);
526 result
= read_4s (op_ptr
);
530 result
= read_8u (op_ptr
);
534 result
= read_8s (op_ptr
);
538 op_ptr
= read_uleb128 (op_ptr
, &utmp
);
539 result
= (_Unwind_Word
)utmp
;
542 op_ptr
= read_sleb128 (op_ptr
, &stmp
);
543 result
= (_Unwind_Sword
)stmp
;
578 result
= _Unwind_GetGR (context
, op
- DW_OP_reg0
);
581 op_ptr
= read_uleb128 (op_ptr
, ®
);
582 result
= _Unwind_GetGR (context
, reg
);
617 op_ptr
= read_sleb128 (op_ptr
, &offset
);
618 result
= _Unwind_GetGR (context
, op
- DW_OP_breg0
) + offset
;
621 op_ptr
= read_uleb128 (op_ptr
, ®
);
622 op_ptr
= read_sleb128 (op_ptr
, &offset
);
623 result
= _Unwind_GetGR (context
, reg
) + (_Unwind_Word
)offset
;
627 gcc_assert (stack_elt
);
628 result
= stack
[stack_elt
- 1];
632 gcc_assert (stack_elt
);
638 gcc_assert (offset
< stack_elt
- 1);
639 result
= stack
[stack_elt
- 1 - offset
];
643 gcc_assert (stack_elt
>= 2);
644 result
= stack
[stack_elt
- 2];
650 gcc_assert (stack_elt
>= 2);
651 t
= stack
[stack_elt
- 1];
652 stack
[stack_elt
- 1] = stack
[stack_elt
- 2];
653 stack
[stack_elt
- 2] = t
;
659 _Unwind_Word t1
, t2
, t3
;
661 gcc_assert (stack_elt
>= 3);
662 t1
= stack
[stack_elt
- 1];
663 t2
= stack
[stack_elt
- 2];
664 t3
= stack
[stack_elt
- 3];
665 stack
[stack_elt
- 1] = t2
;
666 stack
[stack_elt
- 2] = t3
;
667 stack
[stack_elt
- 3] = t1
;
672 case DW_OP_deref_size
:
676 case DW_OP_plus_uconst
:
677 /* Unary operations. */
678 gcc_assert (stack_elt
);
681 result
= stack
[stack_elt
];
687 void *ptr
= (void *) (_Unwind_Ptr
) result
;
688 result
= (_Unwind_Ptr
) read_pointer (ptr
);
692 case DW_OP_deref_size
:
694 void *ptr
= (void *) (_Unwind_Ptr
) result
;
698 result
= read_1u (ptr
);
701 result
= read_2u (ptr
);
704 result
= read_4u (ptr
);
707 result
= read_8u (ptr
);
716 if ((_Unwind_Sword
) result
< 0)
725 case DW_OP_plus_uconst
:
726 op_ptr
= read_uleb128 (op_ptr
, &utmp
);
727 result
+= (_Unwind_Word
)utmp
;
753 /* Binary operations. */
754 _Unwind_Word first
, second
;
755 gcc_assert (stack_elt
>= 2);
758 second
= stack
[stack_elt
];
759 first
= stack
[stack_elt
+ 1];
764 result
= second
& first
;
767 result
= (_Unwind_Sword
) second
/ (_Unwind_Sword
) first
;
770 result
= second
- first
;
773 result
= (_Unwind_Sword
) second
% (_Unwind_Sword
) first
;
776 result
= second
* first
;
779 result
= second
| first
;
782 result
= second
+ first
;
785 result
= second
<< first
;
788 result
= second
>> first
;
791 result
= (_Unwind_Sword
) second
>> first
;
794 result
= second
^ first
;
797 result
= (_Unwind_Sword
) first
<= (_Unwind_Sword
) second
;
800 result
= (_Unwind_Sword
) first
>= (_Unwind_Sword
) second
;
803 result
= (_Unwind_Sword
) first
== (_Unwind_Sword
) second
;
806 result
= (_Unwind_Sword
) first
< (_Unwind_Sword
) second
;
809 result
= (_Unwind_Sword
) first
> (_Unwind_Sword
) second
;
812 result
= (_Unwind_Sword
) first
!= (_Unwind_Sword
) second
;
822 offset
= read_2s (op_ptr
);
828 gcc_assert (stack_elt
);
831 offset
= read_2s (op_ptr
);
833 if (stack
[stack_elt
] != 0)
844 /* Most things push a result value. */
845 gcc_assert ((size_t) stack_elt
< sizeof(stack
)/sizeof(*stack
));
846 stack
[stack_elt
++] = result
;
850 /* We were executing this program to get a value. It should be
852 gcc_assert (stack_elt
);
854 return stack
[stack_elt
];
858 /* Decode DWARF 2 call frame information. Takes pointers the
859 instruction sequence to decode, current register information and
860 CIE info, and the PC range to evaluate. */
863 execute_cfa_program (const unsigned char *insn_ptr
,
864 const unsigned char *insn_end
,
865 struct _Unwind_Context
*context
,
866 _Unwind_FrameState
*fs
)
868 struct frame_state_reg_info
*unused_rs
= NULL
;
870 /* Don't allow remember/restore between CIE and FDE programs. */
871 fs
->regs
.prev
= NULL
;
873 /* The comparison with the return address uses < rather than <= because
874 we are only interested in the effects of code before the call; for a
875 noreturn function, the return address may point to unrelated code with
876 a different stack configuration that we are not interested in. We
877 assume that the call itself is unwind info-neutral; if not, or if
878 there are delay instructions that adjust the stack, these must be
879 reflected at the point immediately before the call insn.
880 In signal frames, return address is after last completed instruction,
881 so we add 1 to return address to make the comparison <=. */
882 while (insn_ptr
< insn_end
883 && fs
->pc
< context
->ra
+ _Unwind_IsSignalFrame (context
))
885 unsigned char insn
= *insn_ptr
++;
886 _uleb128_t reg
, utmp
;
887 _sleb128_t offset
, stmp
;
889 if ((insn
& 0xc0) == DW_CFA_advance_loc
)
890 fs
->pc
+= (insn
& 0x3f) * fs
->code_align
;
891 else if ((insn
& 0xc0) == DW_CFA_offset
)
894 insn_ptr
= read_uleb128 (insn_ptr
, &utmp
);
895 offset
= (_Unwind_Sword
) utmp
* fs
->data_align
;
896 fs
->regs
.reg
[DWARF_REG_TO_UNWIND_COLUMN (reg
)].how
898 fs
->regs
.reg
[DWARF_REG_TO_UNWIND_COLUMN (reg
)].loc
.offset
= offset
;
900 else if ((insn
& 0xc0) == DW_CFA_restore
)
903 fs
->regs
.reg
[DWARF_REG_TO_UNWIND_COLUMN (reg
)].how
= REG_UNSAVED
;
911 insn_ptr
= read_encoded_value (context
, fs
->fde_encoding
,
913 fs
->pc
= (void *) pc
;
917 case DW_CFA_advance_loc1
:
918 fs
->pc
+= read_1u (insn_ptr
) * fs
->code_align
;
921 case DW_CFA_advance_loc2
:
922 fs
->pc
+= read_2u (insn_ptr
) * fs
->code_align
;
925 case DW_CFA_advance_loc4
:
926 fs
->pc
+= read_4u (insn_ptr
) * fs
->code_align
;
930 case DW_CFA_offset_extended
:
931 insn_ptr
= read_uleb128 (insn_ptr
, ®
);
932 insn_ptr
= read_uleb128 (insn_ptr
, &utmp
);
933 offset
= (_Unwind_Sword
) utmp
* fs
->data_align
;
934 fs
->regs
.reg
[DWARF_REG_TO_UNWIND_COLUMN (reg
)].how
936 fs
->regs
.reg
[DWARF_REG_TO_UNWIND_COLUMN (reg
)].loc
.offset
= offset
;
939 case DW_CFA_restore_extended
:
940 insn_ptr
= read_uleb128 (insn_ptr
, ®
);
941 /* FIXME, this is wrong; the CIE might have said that the
942 register was saved somewhere. */
943 fs
->regs
.reg
[DWARF_REG_TO_UNWIND_COLUMN(reg
)].how
= REG_UNSAVED
;
946 case DW_CFA_same_value
:
947 insn_ptr
= read_uleb128 (insn_ptr
, ®
);
948 fs
->regs
.reg
[DWARF_REG_TO_UNWIND_COLUMN(reg
)].how
= REG_UNSAVED
;
951 case DW_CFA_undefined
:
952 insn_ptr
= read_uleb128 (insn_ptr
, ®
);
953 fs
->regs
.reg
[DWARF_REG_TO_UNWIND_COLUMN(reg
)].how
= REG_UNDEFINED
;
959 case DW_CFA_register
:
962 insn_ptr
= read_uleb128 (insn_ptr
, ®
);
963 insn_ptr
= read_uleb128 (insn_ptr
, ®2
);
964 fs
->regs
.reg
[DWARF_REG_TO_UNWIND_COLUMN (reg
)].how
= REG_SAVED_REG
;
965 fs
->regs
.reg
[DWARF_REG_TO_UNWIND_COLUMN (reg
)].loc
.reg
=
970 case DW_CFA_remember_state
:
972 struct frame_state_reg_info
*new_rs
;
976 unused_rs
= unused_rs
->prev
;
979 new_rs
= alloca (sizeof (struct frame_state_reg_info
));
982 fs
->regs
.prev
= new_rs
;
986 case DW_CFA_restore_state
:
988 struct frame_state_reg_info
*old_rs
= fs
->regs
.prev
;
990 old_rs
->prev
= unused_rs
;
996 insn_ptr
= read_uleb128 (insn_ptr
, &utmp
);
997 fs
->regs
.cfa_reg
= (_Unwind_Word
)utmp
;
998 insn_ptr
= read_uleb128 (insn_ptr
, &utmp
);
999 fs
->regs
.cfa_offset
= (_Unwind_Word
)utmp
;
1000 fs
->regs
.cfa_how
= CFA_REG_OFFSET
;
1003 case DW_CFA_def_cfa_register
:
1004 insn_ptr
= read_uleb128 (insn_ptr
, &utmp
);
1005 fs
->regs
.cfa_reg
= (_Unwind_Word
)utmp
;
1006 fs
->regs
.cfa_how
= CFA_REG_OFFSET
;
1009 case DW_CFA_def_cfa_offset
:
1010 insn_ptr
= read_uleb128 (insn_ptr
, &utmp
);
1011 fs
->regs
.cfa_offset
= utmp
;
1012 /* cfa_how deliberately not set. */
1015 case DW_CFA_def_cfa_expression
:
1016 fs
->regs
.cfa_exp
= insn_ptr
;
1017 fs
->regs
.cfa_how
= CFA_EXP
;
1018 insn_ptr
= read_uleb128 (insn_ptr
, &utmp
);
1022 case DW_CFA_expression
:
1023 insn_ptr
= read_uleb128 (insn_ptr
, ®
);
1024 fs
->regs
.reg
[DWARF_REG_TO_UNWIND_COLUMN (reg
)].how
= REG_SAVED_EXP
;
1025 fs
->regs
.reg
[DWARF_REG_TO_UNWIND_COLUMN (reg
)].loc
.exp
= insn_ptr
;
1026 insn_ptr
= read_uleb128 (insn_ptr
, &utmp
);
1031 case DW_CFA_offset_extended_sf
:
1032 insn_ptr
= read_uleb128 (insn_ptr
, ®
);
1033 insn_ptr
= read_sleb128 (insn_ptr
, &stmp
);
1034 offset
= stmp
* fs
->data_align
;
1035 fs
->regs
.reg
[DWARF_REG_TO_UNWIND_COLUMN (reg
)].how
1037 fs
->regs
.reg
[DWARF_REG_TO_UNWIND_COLUMN (reg
)].loc
.offset
= offset
;
1040 case DW_CFA_def_cfa_sf
:
1041 insn_ptr
= read_uleb128 (insn_ptr
, &utmp
);
1042 fs
->regs
.cfa_reg
= (_Unwind_Word
)utmp
;
1043 insn_ptr
= read_sleb128 (insn_ptr
, &stmp
);
1044 fs
->regs
.cfa_offset
= (_Unwind_Sword
)stmp
;
1045 fs
->regs
.cfa_how
= CFA_REG_OFFSET
;
1046 fs
->regs
.cfa_offset
*= fs
->data_align
;
1049 case DW_CFA_def_cfa_offset_sf
:
1050 insn_ptr
= read_sleb128 (insn_ptr
, &stmp
);
1051 fs
->regs
.cfa_offset
= (_Unwind_Sword
)stmp
;
1052 fs
->regs
.cfa_offset
*= fs
->data_align
;
1053 /* cfa_how deliberately not set. */
1056 case DW_CFA_val_offset
:
1057 insn_ptr
= read_uleb128 (insn_ptr
, ®
);
1058 insn_ptr
= read_uleb128 (insn_ptr
, &utmp
);
1059 offset
= (_Unwind_Sword
) utmp
* fs
->data_align
;
1060 fs
->regs
.reg
[DWARF_REG_TO_UNWIND_COLUMN (reg
)].how
1061 = REG_SAVED_VAL_OFFSET
;
1062 fs
->regs
.reg
[DWARF_REG_TO_UNWIND_COLUMN (reg
)].loc
.offset
= offset
;
1065 case DW_CFA_val_offset_sf
:
1066 insn_ptr
= read_uleb128 (insn_ptr
, ®
);
1067 insn_ptr
= read_sleb128 (insn_ptr
, &stmp
);
1068 offset
= stmp
* fs
->data_align
;
1069 fs
->regs
.reg
[DWARF_REG_TO_UNWIND_COLUMN (reg
)].how
1070 = REG_SAVED_VAL_OFFSET
;
1071 fs
->regs
.reg
[DWARF_REG_TO_UNWIND_COLUMN (reg
)].loc
.offset
= offset
;
1074 case DW_CFA_val_expression
:
1075 insn_ptr
= read_uleb128 (insn_ptr
, ®
);
1076 fs
->regs
.reg
[DWARF_REG_TO_UNWIND_COLUMN (reg
)].how
1077 = REG_SAVED_VAL_EXP
;
1078 fs
->regs
.reg
[DWARF_REG_TO_UNWIND_COLUMN (reg
)].loc
.exp
= insn_ptr
;
1079 insn_ptr
= read_uleb128 (insn_ptr
, &utmp
);
1083 case DW_CFA_GNU_window_save
:
1084 /* ??? Hardcoded for SPARC register window configuration. */
1085 for (reg
= 16; reg
< 32; ++reg
)
1087 fs
->regs
.reg
[reg
].how
= REG_SAVED_OFFSET
;
1088 fs
->regs
.reg
[reg
].loc
.offset
= (reg
- 16) * sizeof (void *);
1092 case DW_CFA_GNU_args_size
:
1093 insn_ptr
= read_uleb128 (insn_ptr
, &utmp
);
1094 context
->args_size
= (_Unwind_Word
)utmp
;
1097 case DW_CFA_GNU_negative_offset_extended
:
1098 /* Obsoleted by DW_CFA_offset_extended_sf, but used by
1099 older PowerPC code. */
1100 insn_ptr
= read_uleb128 (insn_ptr
, ®
);
1101 insn_ptr
= read_uleb128 (insn_ptr
, &utmp
);
1102 offset
= (_Unwind_Word
) utmp
* fs
->data_align
;
1103 fs
->regs
.reg
[DWARF_REG_TO_UNWIND_COLUMN (reg
)].how
1105 fs
->regs
.reg
[DWARF_REG_TO_UNWIND_COLUMN (reg
)].loc
.offset
= -offset
;
1114 /* Given the _Unwind_Context CONTEXT for a stack frame, look up the FDE for
1115 its caller and decode it into FS. This function also sets the
1116 args_size and lsda members of CONTEXT, as they are really information
1117 about the caller's frame. */
1119 static _Unwind_Reason_Code
1120 uw_frame_state_for (struct _Unwind_Context
*context
, _Unwind_FrameState
*fs
)
1122 const struct dwarf_fde
*fde
;
1123 const struct dwarf_cie
*cie
;
1124 const unsigned char *aug
, *insn
, *end
;
1126 memset (fs
, 0, sizeof (*fs
));
1127 context
->args_size
= 0;
1130 if (context
->ra
== 0)
1131 return _URC_END_OF_STACK
;
1133 fde
= _Unwind_Find_FDE (context
->ra
+ _Unwind_IsSignalFrame (context
) - 1,
1137 #ifdef MD_FALLBACK_FRAME_STATE_FOR
1138 /* Couldn't find frame unwind info for this function. Try a
1139 target-specific fallback mechanism. This will necessarily
1140 not provide a personality routine or LSDA. */
1141 return MD_FALLBACK_FRAME_STATE_FOR (context
, fs
);
1143 return _URC_END_OF_STACK
;
1147 fs
->pc
= context
->bases
.func
;
1149 cie
= get_cie (fde
);
1150 insn
= extract_cie_info (cie
, context
, fs
);
1152 /* CIE contained unknown augmentation. */
1153 return _URC_FATAL_PHASE1_ERROR
;
1155 /* First decode all the insns in the CIE. */
1156 end
= (const unsigned char *) next_fde ((const struct dwarf_fde
*) cie
);
1157 execute_cfa_program (insn
, end
, context
, fs
);
1159 /* Locate augmentation for the fde. */
1160 aug
= (const unsigned char *) fde
+ sizeof (*fde
);
1161 aug
+= 2 * size_of_encoded_value (fs
->fde_encoding
);
1166 aug
= read_uleb128 (aug
, &i
);
1169 if (fs
->lsda_encoding
!= DW_EH_PE_omit
)
1173 aug
= read_encoded_value (context
, fs
->lsda_encoding
, aug
, &lsda
);
1174 context
->lsda
= (void *) lsda
;
1177 /* Then the insns in the FDE up to our target PC. */
1180 end
= (const unsigned char *) next_fde (fde
);
1181 execute_cfa_program (insn
, end
, context
, fs
);
1183 return _URC_NO_REASON
;
1186 typedef struct frame_state
1192 long reg_or_offset
[PRE_GCC3_DWARF_FRAME_REGISTERS
+1];
1193 unsigned short cfa_reg
;
1194 unsigned short retaddr_column
;
1195 char saved
[PRE_GCC3_DWARF_FRAME_REGISTERS
+1];
1198 struct frame_state
* __frame_state_for (void *, struct frame_state
*);
1200 /* Called from pre-G++ 3.0 __throw to find the registers to restore for
1201 a given PC_TARGET. The caller should allocate a local variable of
1202 `struct frame_state' and pass its address to STATE_IN. */
1204 struct frame_state
*
1205 __frame_state_for (void *pc_target
, struct frame_state
*state_in
)
1207 struct _Unwind_Context context
;
1208 _Unwind_FrameState fs
;
1211 memset (&context
, 0, sizeof (struct _Unwind_Context
));
1212 context
.flags
= EXTENDED_CONTEXT_BIT
;
1213 context
.ra
= pc_target
+ 1;
1215 if (uw_frame_state_for (&context
, &fs
) != _URC_NO_REASON
)
1218 /* We have no way to pass a location expression for the CFA to our
1219 caller. It wouldn't understand it anyway. */
1220 if (fs
.regs
.cfa_how
== CFA_EXP
)
1223 for (reg
= 0; reg
< PRE_GCC3_DWARF_FRAME_REGISTERS
+ 1; reg
++)
1225 state_in
->saved
[reg
] = fs
.regs
.reg
[reg
].how
;
1226 switch (state_in
->saved
[reg
])
1229 state_in
->reg_or_offset
[reg
] = fs
.regs
.reg
[reg
].loc
.reg
;
1231 case REG_SAVED_OFFSET
:
1232 state_in
->reg_or_offset
[reg
] = fs
.regs
.reg
[reg
].loc
.offset
;
1235 state_in
->reg_or_offset
[reg
] = 0;
1240 state_in
->cfa_offset
= fs
.regs
.cfa_offset
;
1241 state_in
->cfa_reg
= fs
.regs
.cfa_reg
;
1242 state_in
->retaddr_column
= fs
.retaddr_column
;
1243 state_in
->args_size
= context
.args_size
;
1244 state_in
->eh_ptr
= fs
.eh_ptr
;
1249 typedef union { _Unwind_Ptr ptr
; _Unwind_Word word
; } _Unwind_SpTmp
;
1252 _Unwind_SetSpColumn (struct _Unwind_Context
*context
, void *cfa
,
1253 _Unwind_SpTmp
*tmp_sp
)
1255 int size
= dwarf_reg_size_table
[__builtin_dwarf_sp_column ()];
1257 if (size
== sizeof(_Unwind_Ptr
))
1258 tmp_sp
->ptr
= (_Unwind_Ptr
) cfa
;
1261 gcc_assert (size
== sizeof(_Unwind_Word
));
1262 tmp_sp
->word
= (_Unwind_Ptr
) cfa
;
1264 _Unwind_SetGRPtr (context
, __builtin_dwarf_sp_column (), tmp_sp
);
1268 uw_update_context_1 (struct _Unwind_Context
*context
, _Unwind_FrameState
*fs
)
1270 struct _Unwind_Context orig_context
= *context
;
1274 #ifdef EH_RETURN_STACKADJ_RTX
1275 /* Special handling here: Many machines do not use a frame pointer,
1276 and track the CFA only through offsets from the stack pointer from
1277 one frame to the next. In this case, the stack pointer is never
1278 stored, so it has no saved address in the context. What we do
1279 have is the CFA from the previous stack frame.
1281 In very special situations (such as unwind info for signal return),
1282 there may be location expressions that use the stack pointer as well.
1284 Do this conditionally for one frame. This allows the unwind info
1285 for one frame to save a copy of the stack pointer from the previous
1286 frame, and be able to use much easier CFA mechanisms to do it.
1287 Always zap the saved stack pointer value for the next frame; carrying
1288 the value over from one frame to another doesn't make sense. */
1290 _Unwind_SpTmp tmp_sp
;
1292 if (!_Unwind_GetGRPtr (&orig_context
, __builtin_dwarf_sp_column ()))
1293 _Unwind_SetSpColumn (&orig_context
, context
->cfa
, &tmp_sp
);
1294 _Unwind_SetGRPtr (context
, __builtin_dwarf_sp_column (), NULL
);
1297 /* Compute this frame's CFA. */
1298 switch (fs
->regs
.cfa_how
)
1300 case CFA_REG_OFFSET
:
1301 cfa
= _Unwind_GetPtr (&orig_context
, fs
->regs
.cfa_reg
);
1302 cfa
+= fs
->regs
.cfa_offset
;
1307 const unsigned char *exp
= fs
->regs
.cfa_exp
;
1310 exp
= read_uleb128 (exp
, &len
);
1311 cfa
= (void *) (_Unwind_Ptr
)
1312 execute_stack_op (exp
, exp
+ len
, &orig_context
, 0);
1321 /* Compute the addresses of all registers saved in this frame. */
1322 for (i
= 0; i
< DWARF_FRAME_REGISTERS
+ 1; ++i
)
1323 switch (fs
->regs
.reg
[i
].how
)
1329 case REG_SAVED_OFFSET
:
1330 _Unwind_SetGRPtr (context
, i
,
1331 (void *) (cfa
+ fs
->regs
.reg
[i
].loc
.offset
));
1335 if (_Unwind_GRByValue (&orig_context
, fs
->regs
.reg
[i
].loc
.reg
))
1336 _Unwind_SetGRValue (context
, i
,
1337 _Unwind_GetGR (&orig_context
,
1338 fs
->regs
.reg
[i
].loc
.reg
));
1340 _Unwind_SetGRPtr (context
, i
,
1341 _Unwind_GetGRPtr (&orig_context
,
1342 fs
->regs
.reg
[i
].loc
.reg
));
1347 const unsigned char *exp
= fs
->regs
.reg
[i
].loc
.exp
;
1351 exp
= read_uleb128 (exp
, &len
);
1352 val
= execute_stack_op (exp
, exp
+ len
, &orig_context
,
1354 _Unwind_SetGRPtr (context
, i
, (void *) val
);
1358 case REG_SAVED_VAL_OFFSET
:
1359 _Unwind_SetGRValue (context
, i
,
1360 (_Unwind_Internal_Ptr
)
1361 (cfa
+ fs
->regs
.reg
[i
].loc
.offset
));
1364 case REG_SAVED_VAL_EXP
:
1366 const unsigned char *exp
= fs
->regs
.reg
[i
].loc
.exp
;
1370 exp
= read_uleb128 (exp
, &len
);
1371 val
= execute_stack_op (exp
, exp
+ len
, &orig_context
,
1373 _Unwind_SetGRValue (context
, i
, val
);
1378 _Unwind_SetSignalFrame (context
, fs
->signal_frame
);
1380 #ifdef MD_FROB_UPDATE_CONTEXT
1381 MD_FROB_UPDATE_CONTEXT (context
, fs
);
1385 /* CONTEXT describes the unwind state for a frame, and FS describes the FDE
1386 of its caller. Update CONTEXT to refer to the caller as well. Note
1387 that the args_size and lsda members are not updated here, but later in
1388 uw_frame_state_for. */
1391 uw_update_context (struct _Unwind_Context
*context
, _Unwind_FrameState
*fs
)
1393 uw_update_context_1 (context
, fs
);
1395 /* In general this unwinder doesn't make any distinction between
1396 undefined and same_value rule. Call-saved registers are assumed
1397 to have same_value rule by default and explicit undefined
1398 rule is handled like same_value. The only exception is
1399 DW_CFA_undefined on retaddr_column which is supposed to
1400 mark outermost frame in DWARF 3. */
1401 if (fs
->regs
.reg
[DWARF_REG_TO_UNWIND_COLUMN (fs
->retaddr_column
)].how
1403 /* uw_frame_state_for uses context->ra == 0 check to find outermost
1407 /* Compute the return address now, since the return address column
1408 can change from frame to frame. */
1409 context
->ra
= __builtin_extract_return_addr
1410 (_Unwind_GetPtr (context
, fs
->retaddr_column
));
1414 uw_advance_context (struct _Unwind_Context
*context
, _Unwind_FrameState
*fs
)
1416 uw_update_context (context
, fs
);
1419 /* Fill in CONTEXT for top-of-stack. The only valid registers at this
1420 level will be the return address and the CFA. */
1422 #define uw_init_context(CONTEXT) \
1425 /* Do any necessary initialization to access arbitrary stack frames. \
1426 On the SPARC, this means flushing the register windows. */ \
1427 __builtin_unwind_init (); \
1428 uw_init_context_1 (CONTEXT, __builtin_dwarf_cfa (), \
1429 __builtin_return_address (0)); \
1434 init_dwarf_reg_size_table (void)
1436 __builtin_init_dwarf_reg_size_table (dwarf_reg_size_table
);
1440 uw_init_context_1 (struct _Unwind_Context
*context
,
1441 void *outer_cfa
, void *outer_ra
)
1443 void *ra
= __builtin_extract_return_addr (__builtin_return_address (0));
1444 _Unwind_FrameState fs
;
1445 _Unwind_SpTmp sp_slot
;
1446 _Unwind_Reason_Code code
;
1448 memset (context
, 0, sizeof (struct _Unwind_Context
));
1450 context
->flags
= EXTENDED_CONTEXT_BIT
;
1452 code
= uw_frame_state_for (context
, &fs
);
1453 gcc_assert (code
== _URC_NO_REASON
);
1457 static __gthread_once_t once_regsizes
= __GTHREAD_ONCE_INIT
;
1458 if (__gthread_once (&once_regsizes
, init_dwarf_reg_size_table
) != 0
1459 && dwarf_reg_size_table
[0] == 0)
1460 init_dwarf_reg_size_table ();
1463 if (dwarf_reg_size_table
[0] == 0)
1464 init_dwarf_reg_size_table ();
1467 /* Force the frame state to use the known cfa value. */
1468 _Unwind_SetSpColumn (context
, outer_cfa
, &sp_slot
);
1469 fs
.regs
.cfa_how
= CFA_REG_OFFSET
;
1470 fs
.regs
.cfa_reg
= __builtin_dwarf_sp_column ();
1471 fs
.regs
.cfa_offset
= 0;
1473 uw_update_context_1 (context
, &fs
);
1475 /* If the return address column was saved in a register in the
1476 initialization context, then we can't see it in the given
1477 call frame data. So have the initialization context tell us. */
1478 context
->ra
= __builtin_extract_return_addr (outer_ra
);
1482 /* Install TARGET into CURRENT so that we can return to it. This is a
1483 macro because __builtin_eh_return must be invoked in the context of
1486 #define uw_install_context(CURRENT, TARGET) \
1489 long offset = uw_install_context_1 ((CURRENT), (TARGET)); \
1490 void *handler = __builtin_frob_return_addr ((TARGET)->ra); \
1491 __builtin_eh_return (offset, handler); \
1496 uw_install_context_1 (struct _Unwind_Context
*current
,
1497 struct _Unwind_Context
*target
)
1500 _Unwind_SpTmp sp_slot
;
1502 /* If the target frame does not have a saved stack pointer,
1503 then set up the target's CFA. */
1504 if (!_Unwind_GetGRPtr (target
, __builtin_dwarf_sp_column ()))
1505 _Unwind_SetSpColumn (target
, target
->cfa
, &sp_slot
);
1507 for (i
= 0; i
< DWARF_FRAME_REGISTERS
; ++i
)
1509 void *c
= current
->reg
[i
];
1510 void *t
= target
->reg
[i
];
1512 gcc_assert (current
->by_value
[i
] == 0);
1513 if (target
->by_value
[i
] && c
)
1517 if (dwarf_reg_size_table
[i
] == sizeof (_Unwind_Word
))
1519 w
= (_Unwind_Internal_Ptr
) t
;
1520 memcpy (c
, &w
, sizeof (_Unwind_Word
));
1524 gcc_assert (dwarf_reg_size_table
[i
] == sizeof (_Unwind_Ptr
));
1525 p
= (_Unwind_Internal_Ptr
) t
;
1526 memcpy (c
, &p
, sizeof (_Unwind_Ptr
));
1529 else if (t
&& c
&& t
!= c
)
1530 memcpy (c
, t
, dwarf_reg_size_table
[i
]);
1533 /* If the current frame doesn't have a saved stack pointer, then we
1534 need to rely on EH_RETURN_STACKADJ_RTX to get our target stack
1535 pointer value reloaded. */
1536 if (!_Unwind_GetGRPtr (current
, __builtin_dwarf_sp_column ()))
1540 target_cfa
= _Unwind_GetPtr (target
, __builtin_dwarf_sp_column ());
1542 /* We adjust SP by the difference between CURRENT and TARGET's CFA. */
1543 if (STACK_GROWS_DOWNWARD
)
1544 return target_cfa
- current
->cfa
+ target
->args_size
;
1546 return current
->cfa
- target_cfa
- target
->args_size
;
1551 static inline _Unwind_Ptr
1552 uw_identify_context (struct _Unwind_Context
*context
)
1554 return _Unwind_GetCFA (context
);
1558 #include "unwind.inc"
1560 #if defined (USE_GAS_SYMVER) && defined (SHARED) && defined (USE_LIBUNWIND_EXCEPTIONS)
1561 alias (_Unwind_Backtrace
);
1562 alias (_Unwind_DeleteException
);
1563 alias (_Unwind_FindEnclosingFunction
);
1564 alias (_Unwind_ForcedUnwind
);
1565 alias (_Unwind_GetDataRelBase
);
1566 alias (_Unwind_GetTextRelBase
);
1567 alias (_Unwind_GetCFA
);
1568 alias (_Unwind_GetGR
);
1569 alias (_Unwind_GetIP
);
1570 alias (_Unwind_GetLanguageSpecificData
);
1571 alias (_Unwind_GetRegionStart
);
1572 alias (_Unwind_RaiseException
);
1573 alias (_Unwind_Resume
);
1574 alias (_Unwind_Resume_or_Rethrow
);
1575 alias (_Unwind_SetGR
);
1576 alias (_Unwind_SetIP
);
1579 #endif /* !USING_SJLJ_EXCEPTIONS */