1 /* DWARF2 exception handling and frame unwind runtime interface routines.
2 Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
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, 59 Temple Place - Suite 330, 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 _Unwind_Word args_size
;
76 /* Byte size of every register managed by these routines. */
77 static unsigned char dwarf_reg_size_table
[DWARF_FRAME_REGISTERS
+1];
80 /* Read unaligned data from the instruction buffer. */
85 unsigned u2
__attribute__ ((mode (HI
)));
86 unsigned u4
__attribute__ ((mode (SI
)));
87 unsigned u8
__attribute__ ((mode (DI
)));
88 signed s2
__attribute__ ((mode (HI
)));
89 signed s4
__attribute__ ((mode (SI
)));
90 signed s8
__attribute__ ((mode (DI
)));
91 } __attribute__ ((packed
));
94 read_pointer (const void *p
) { const union unaligned
*up
= p
; return up
->p
; }
97 read_1u (const void *p
) { return *(const unsigned char *) p
; }
100 read_1s (const void *p
) { return *(const signed char *) p
; }
103 read_2u (const void *p
) { const union unaligned
*up
= p
; return up
->u2
; }
106 read_2s (const void *p
) { const union unaligned
*up
= p
; return up
->s2
; }
108 static inline unsigned int
109 read_4u (const void *p
) { const union unaligned
*up
= p
; return up
->u4
; }
112 read_4s (const void *p
) { const union unaligned
*up
= p
; return up
->s4
; }
114 static inline unsigned long
115 read_8u (const void *p
) { const union unaligned
*up
= p
; return up
->u8
; }
117 static inline unsigned long
118 read_8s (const void *p
) { const union unaligned
*up
= p
; return up
->s8
; }
120 /* Get the value of register REG as saved in CONTEXT. */
123 _Unwind_GetGR (struct _Unwind_Context
*context
, int index
)
128 #ifdef DWARF_ZERO_REG
129 if (index
== DWARF_ZERO_REG
)
133 index
= DWARF_REG_TO_UNWIND_COLUMN (index
);
134 gcc_assert (index
< (int) sizeof(dwarf_reg_size_table
));
135 size
= dwarf_reg_size_table
[index
];
136 ptr
= context
->reg
[index
];
138 /* This will segfault if the register hasn't been saved. */
139 if (size
== sizeof(_Unwind_Ptr
))
140 return * (_Unwind_Ptr
*) ptr
;
143 gcc_assert (size
== sizeof(_Unwind_Word
));
144 return * (_Unwind_Word
*) ptr
;
149 _Unwind_GetPtr (struct _Unwind_Context
*context
, int index
)
151 return (void *)(_Unwind_Ptr
) _Unwind_GetGR (context
, index
);
154 /* Get the value of the CFA as saved in CONTEXT. */
157 _Unwind_GetCFA (struct _Unwind_Context
*context
)
159 return (_Unwind_Ptr
) context
->cfa
;
162 /* Overwrite the saved value for register REG in CONTEXT with VAL. */
165 _Unwind_SetGR (struct _Unwind_Context
*context
, int index
, _Unwind_Word val
)
170 index
= DWARF_REG_TO_UNWIND_COLUMN (index
);
171 gcc_assert (index
< (int) sizeof(dwarf_reg_size_table
));
172 size
= dwarf_reg_size_table
[index
];
173 ptr
= context
->reg
[index
];
175 if (size
== sizeof(_Unwind_Ptr
))
176 * (_Unwind_Ptr
*) ptr
= val
;
179 gcc_assert (size
== sizeof(_Unwind_Word
));
180 * (_Unwind_Word
*) ptr
= val
;
184 /* Get the pointer to a register INDEX as saved in CONTEXT. */
187 _Unwind_GetGRPtr (struct _Unwind_Context
*context
, int index
)
189 index
= DWARF_REG_TO_UNWIND_COLUMN (index
);
190 return context
->reg
[index
];
193 /* Set the pointer to a register INDEX as saved in CONTEXT. */
196 _Unwind_SetGRPtr (struct _Unwind_Context
*context
, int index
, void *p
)
198 index
= DWARF_REG_TO_UNWIND_COLUMN (index
);
199 context
->reg
[index
] = p
;
202 /* Retrieve the return address for CONTEXT. */
205 _Unwind_GetIP (struct _Unwind_Context
*context
)
207 return (_Unwind_Ptr
) context
->ra
;
210 /* Overwrite the return address for CONTEXT with VAL. */
213 _Unwind_SetIP (struct _Unwind_Context
*context
, _Unwind_Ptr val
)
215 context
->ra
= (void *) val
;
219 _Unwind_GetLanguageSpecificData (struct _Unwind_Context
*context
)
221 return context
->lsda
;
225 _Unwind_GetRegionStart (struct _Unwind_Context
*context
)
227 return (_Unwind_Ptr
) context
->bases
.func
;
231 _Unwind_FindEnclosingFunction (void *pc
)
233 struct dwarf_eh_bases bases
;
234 const struct dwarf_fde
*fde
= _Unwind_Find_FDE (pc
-1, &bases
);
243 _Unwind_GetDataRelBase (struct _Unwind_Context
*context
)
245 return (_Unwind_Ptr
) context
->bases
.dbase
;
249 _Unwind_GetTextRelBase (struct _Unwind_Context
*context
)
251 return (_Unwind_Ptr
) context
->bases
.tbase
;
255 #ifdef MD_UNWIND_SUPPORT
256 #include MD_UNWIND_SUPPORT
259 /* Extract any interesting information from the CIE for the translation
260 unit F belongs to. Return a pointer to the byte after the augmentation,
261 or NULL if we encountered an undecipherable augmentation. */
263 static const unsigned char *
264 extract_cie_info (const struct dwarf_cie
*cie
, struct _Unwind_Context
*context
,
265 _Unwind_FrameState
*fs
)
267 const unsigned char *aug
= cie
->augmentation
;
268 const unsigned char *p
= aug
+ strlen ((const char *)aug
) + 1;
269 const unsigned char *ret
= NULL
;
272 /* g++ v2 "eh" has pointer immediately following augmentation string,
273 so it must be handled first. */
274 if (aug
[0] == 'e' && aug
[1] == 'h')
276 fs
->eh_ptr
= read_pointer (p
);
277 p
+= sizeof (void *);
281 /* Immediately following the augmentation are the code and
282 data alignment and return address column. */
283 p
= read_uleb128 (p
, &fs
->code_align
);
284 p
= read_sleb128 (p
, &fs
->data_align
);
285 if (cie
->version
== 1)
286 fs
->retaddr_column
= *p
++;
288 p
= read_uleb128 (p
, &fs
->retaddr_column
);
289 fs
->lsda_encoding
= DW_EH_PE_omit
;
291 /* If the augmentation starts with 'z', then a uleb128 immediately
292 follows containing the length of the augmentation field following
296 p
= read_uleb128 (p
, &utmp
);
303 /* Iterate over recognized augmentation subsequences. */
306 /* "L" indicates a byte showing how the LSDA pointer is encoded. */
309 fs
->lsda_encoding
= *p
++;
313 /* "R" indicates a byte indicating how FDE addresses are encoded. */
314 else if (aug
[0] == 'R')
316 fs
->fde_encoding
= *p
++;
320 /* "P" indicates a personality routine in the CIE augmentation. */
321 else if (aug
[0] == 'P')
323 p
= read_encoded_value (context
, *p
, p
+ 1,
324 (_Unwind_Ptr
*) &fs
->personality
);
328 /* Otherwise we have an unknown augmentation string.
329 Bail unless we saw a 'z' prefix. */
334 return ret
? ret
: p
;
338 /* Decode a DW_OP stack program. Return the top of stack. Push INITIAL
339 onto the stack to start. */
342 execute_stack_op (const unsigned char *op_ptr
, const unsigned char *op_end
,
343 struct _Unwind_Context
*context
, _Unwind_Word initial
)
345 _Unwind_Word stack
[64]; /* ??? Assume this is enough. */
351 while (op_ptr
< op_end
)
353 enum dwarf_location_atom op
= *op_ptr
++;
354 _Unwind_Word result
, reg
, utmp
;
355 _Unwind_Sword offset
, stmp
;
391 result
= op
- DW_OP_lit0
;
395 result
= (_Unwind_Word
) (_Unwind_Ptr
) read_pointer (op_ptr
);
396 op_ptr
+= sizeof (void *);
400 result
= read_1u (op_ptr
);
404 result
= read_1s (op_ptr
);
408 result
= read_2u (op_ptr
);
412 result
= read_2s (op_ptr
);
416 result
= read_4u (op_ptr
);
420 result
= read_4s (op_ptr
);
424 result
= read_8u (op_ptr
);
428 result
= read_8s (op_ptr
);
432 op_ptr
= read_uleb128 (op_ptr
, &result
);
435 op_ptr
= read_sleb128 (op_ptr
, &stmp
);
471 result
= _Unwind_GetGR (context
, op
- DW_OP_reg0
);
474 op_ptr
= read_uleb128 (op_ptr
, ®
);
475 result
= _Unwind_GetGR (context
, reg
);
510 op_ptr
= read_sleb128 (op_ptr
, &offset
);
511 result
= _Unwind_GetGR (context
, op
- DW_OP_breg0
) + offset
;
514 op_ptr
= read_uleb128 (op_ptr
, ®
);
515 op_ptr
= read_sleb128 (op_ptr
, &offset
);
516 result
= _Unwind_GetGR (context
, reg
) + offset
;
520 gcc_assert (stack_elt
);
521 result
= stack
[stack_elt
- 1];
525 gcc_assert (stack_elt
);
531 gcc_assert (offset
< stack_elt
- 1);
532 result
= stack
[stack_elt
- 1 - offset
];
536 gcc_assert (stack_elt
>= 2);
537 result
= stack
[stack_elt
- 2];
542 _Unwind_Word t1
, t2
, t3
;
544 gcc_assert (stack_elt
>= 3);
545 t1
= stack
[stack_elt
- 1];
546 t2
= stack
[stack_elt
- 2];
547 t3
= stack
[stack_elt
- 3];
548 stack
[stack_elt
- 1] = t2
;
549 stack
[stack_elt
- 2] = t3
;
550 stack
[stack_elt
- 3] = t1
;
555 case DW_OP_deref_size
:
559 case DW_OP_plus_uconst
:
560 /* Unary operations. */
561 gcc_assert (stack_elt
);
564 result
= stack
[stack_elt
];
570 void *ptr
= (void *) (_Unwind_Ptr
) result
;
571 result
= (_Unwind_Ptr
) read_pointer (ptr
);
575 case DW_OP_deref_size
:
577 void *ptr
= (void *) (_Unwind_Ptr
) result
;
581 result
= read_1u (ptr
);
584 result
= read_2u (ptr
);
587 result
= read_4u (ptr
);
590 result
= read_8u (ptr
);
599 if ((_Unwind_Sword
) result
< 0)
608 case DW_OP_plus_uconst
:
609 op_ptr
= read_uleb128 (op_ptr
, &utmp
);
636 /* Binary operations. */
637 _Unwind_Word first
, second
;
638 gcc_assert (stack_elt
>= 2);
641 second
= stack
[stack_elt
];
642 first
= stack
[stack_elt
+ 1];
647 result
= second
& first
;
650 result
= (_Unwind_Sword
) second
/ (_Unwind_Sword
) first
;
653 result
= second
- first
;
656 result
= (_Unwind_Sword
) second
% (_Unwind_Sword
) first
;
659 result
= second
* first
;
662 result
= second
| first
;
665 result
= second
+ first
;
668 result
= second
<< first
;
671 result
= second
>> first
;
674 result
= (_Unwind_Sword
) second
>> first
;
677 result
= second
^ first
;
680 result
= (_Unwind_Sword
) first
<= (_Unwind_Sword
) second
;
683 result
= (_Unwind_Sword
) first
>= (_Unwind_Sword
) second
;
686 result
= (_Unwind_Sword
) first
== (_Unwind_Sword
) second
;
689 result
= (_Unwind_Sword
) first
< (_Unwind_Sword
) second
;
692 result
= (_Unwind_Sword
) first
> (_Unwind_Sword
) second
;
695 result
= (_Unwind_Sword
) first
!= (_Unwind_Sword
) second
;
705 offset
= read_2s (op_ptr
);
711 gcc_assert (stack_elt
);
714 offset
= read_2s (op_ptr
);
716 if (stack
[stack_elt
] != 0)
727 /* Most things push a result value. */
728 gcc_assert ((size_t) stack_elt
< sizeof(stack
)/sizeof(*stack
));
729 stack
[stack_elt
++] = result
;
733 /* We were executing this program to get a value. It should be
735 gcc_assert (stack_elt
);
737 return stack
[stack_elt
];
741 /* Decode DWARF 2 call frame information. Takes pointers the
742 instruction sequence to decode, current register information and
743 CIE info, and the PC range to evaluate. */
746 execute_cfa_program (const unsigned char *insn_ptr
,
747 const unsigned char *insn_end
,
748 struct _Unwind_Context
*context
,
749 _Unwind_FrameState
*fs
)
751 struct frame_state_reg_info
*unused_rs
= NULL
;
753 /* Don't allow remember/restore between CIE and FDE programs. */
754 fs
->regs
.prev
= NULL
;
756 /* The comparison with the return address uses < rather than <= because
757 we are only interested in the effects of code before the call; for a
758 noreturn function, the return address may point to unrelated code with
759 a different stack configuration that we are not interested in. We
760 assume that the call itself is unwind info-neutral; if not, or if
761 there are delay instructions that adjust the stack, these must be
762 reflected at the point immediately before the call insn. */
763 while (insn_ptr
< insn_end
&& fs
->pc
< context
->ra
)
765 unsigned char insn
= *insn_ptr
++;
766 _Unwind_Word reg
, utmp
;
767 _Unwind_Sword offset
, stmp
;
769 if ((insn
& 0xc0) == DW_CFA_advance_loc
)
770 fs
->pc
+= (insn
& 0x3f) * fs
->code_align
;
771 else if ((insn
& 0xc0) == DW_CFA_offset
)
774 insn_ptr
= read_uleb128 (insn_ptr
, &utmp
);
775 offset
= (_Unwind_Sword
) utmp
* fs
->data_align
;
776 fs
->regs
.reg
[DWARF_REG_TO_UNWIND_COLUMN (reg
)].how
778 fs
->regs
.reg
[DWARF_REG_TO_UNWIND_COLUMN (reg
)].loc
.offset
= offset
;
780 else if ((insn
& 0xc0) == DW_CFA_restore
)
783 fs
->regs
.reg
[DWARF_REG_TO_UNWIND_COLUMN (reg
)].how
= REG_UNSAVED
;
788 insn_ptr
= read_encoded_value (context
, fs
->fde_encoding
,
789 insn_ptr
, (_Unwind_Ptr
*) &fs
->pc
);
792 case DW_CFA_advance_loc1
:
793 fs
->pc
+= read_1u (insn_ptr
) * fs
->code_align
;
796 case DW_CFA_advance_loc2
:
797 fs
->pc
+= read_2u (insn_ptr
) * fs
->code_align
;
800 case DW_CFA_advance_loc4
:
801 fs
->pc
+= read_4u (insn_ptr
) * fs
->code_align
;
805 case DW_CFA_offset_extended
:
806 insn_ptr
= read_uleb128 (insn_ptr
, ®
);
807 insn_ptr
= read_uleb128 (insn_ptr
, &utmp
);
808 offset
= (_Unwind_Sword
) utmp
* fs
->data_align
;
809 fs
->regs
.reg
[DWARF_REG_TO_UNWIND_COLUMN (reg
)].how
811 fs
->regs
.reg
[DWARF_REG_TO_UNWIND_COLUMN (reg
)].loc
.offset
= offset
;
814 case DW_CFA_restore_extended
:
815 insn_ptr
= read_uleb128 (insn_ptr
, ®
);
816 /* FIXME, this is wrong; the CIE might have said that the
817 register was saved somewhere. */
818 fs
->regs
.reg
[DWARF_REG_TO_UNWIND_COLUMN(reg
)].how
= REG_UNSAVED
;
821 case DW_CFA_undefined
:
822 case DW_CFA_same_value
:
823 insn_ptr
= read_uleb128 (insn_ptr
, ®
);
824 fs
->regs
.reg
[DWARF_REG_TO_UNWIND_COLUMN(reg
)].how
= REG_UNSAVED
;
830 case DW_CFA_register
:
833 insn_ptr
= read_uleb128 (insn_ptr
, ®
);
834 insn_ptr
= read_uleb128 (insn_ptr
, ®2
);
835 fs
->regs
.reg
[DWARF_REG_TO_UNWIND_COLUMN (reg
)].how
= REG_SAVED_REG
;
836 fs
->regs
.reg
[DWARF_REG_TO_UNWIND_COLUMN (reg
)].loc
.reg
= reg2
;
840 case DW_CFA_remember_state
:
842 struct frame_state_reg_info
*new_rs
;
846 unused_rs
= unused_rs
->prev
;
849 new_rs
= alloca (sizeof (struct frame_state_reg_info
));
852 fs
->regs
.prev
= new_rs
;
856 case DW_CFA_restore_state
:
858 struct frame_state_reg_info
*old_rs
= fs
->regs
.prev
;
860 old_rs
->prev
= unused_rs
;
866 insn_ptr
= read_uleb128 (insn_ptr
, &fs
->cfa_reg
);
867 insn_ptr
= read_uleb128 (insn_ptr
, &utmp
);
868 fs
->cfa_offset
= utmp
;
869 fs
->cfa_how
= CFA_REG_OFFSET
;
872 case DW_CFA_def_cfa_register
:
873 insn_ptr
= read_uleb128 (insn_ptr
, &fs
->cfa_reg
);
874 fs
->cfa_how
= CFA_REG_OFFSET
;
877 case DW_CFA_def_cfa_offset
:
878 insn_ptr
= read_uleb128 (insn_ptr
, &utmp
);
879 fs
->cfa_offset
= utmp
;
880 /* cfa_how deliberately not set. */
883 case DW_CFA_def_cfa_expression
:
884 fs
->cfa_exp
= insn_ptr
;
885 fs
->cfa_how
= CFA_EXP
;
886 insn_ptr
= read_uleb128 (insn_ptr
, &utmp
);
890 case DW_CFA_expression
:
891 insn_ptr
= read_uleb128 (insn_ptr
, ®
);
892 fs
->regs
.reg
[DWARF_REG_TO_UNWIND_COLUMN (reg
)].how
= REG_SAVED_EXP
;
893 fs
->regs
.reg
[DWARF_REG_TO_UNWIND_COLUMN (reg
)].loc
.exp
= insn_ptr
;
894 insn_ptr
= read_uleb128 (insn_ptr
, &utmp
);
898 /* From the 2.1 draft. */
899 case DW_CFA_offset_extended_sf
:
900 insn_ptr
= read_uleb128 (insn_ptr
, ®
);
901 insn_ptr
= read_sleb128 (insn_ptr
, &stmp
);
902 offset
= stmp
* fs
->data_align
;
903 fs
->regs
.reg
[DWARF_REG_TO_UNWIND_COLUMN (reg
)].how
905 fs
->regs
.reg
[DWARF_REG_TO_UNWIND_COLUMN (reg
)].loc
.offset
= offset
;
908 case DW_CFA_def_cfa_sf
:
909 insn_ptr
= read_uleb128 (insn_ptr
, &fs
->cfa_reg
);
910 insn_ptr
= read_sleb128 (insn_ptr
, &fs
->cfa_offset
);
911 fs
->cfa_how
= CFA_REG_OFFSET
;
914 case DW_CFA_def_cfa_offset_sf
:
915 insn_ptr
= read_sleb128 (insn_ptr
, &fs
->cfa_offset
);
916 /* cfa_how deliberately not set. */
919 case DW_CFA_GNU_window_save
:
920 /* ??? Hardcoded for SPARC register window configuration. */
921 for (reg
= 16; reg
< 32; ++reg
)
923 fs
->regs
.reg
[reg
].how
= REG_SAVED_OFFSET
;
924 fs
->regs
.reg
[reg
].loc
.offset
= (reg
- 16) * sizeof (void *);
928 case DW_CFA_GNU_args_size
:
929 insn_ptr
= read_uleb128 (insn_ptr
, &context
->args_size
);
932 case DW_CFA_GNU_negative_offset_extended
:
933 /* Obsoleted by DW_CFA_offset_extended_sf, but used by
934 older PowerPC code. */
935 insn_ptr
= read_uleb128 (insn_ptr
, ®
);
936 insn_ptr
= read_uleb128 (insn_ptr
, &utmp
);
937 offset
= (_Unwind_Word
) utmp
* fs
->data_align
;
938 fs
->regs
.reg
[DWARF_REG_TO_UNWIND_COLUMN (reg
)].how
940 fs
->regs
.reg
[DWARF_REG_TO_UNWIND_COLUMN (reg
)].loc
.offset
= -offset
;
949 /* Given the _Unwind_Context CONTEXT for a stack frame, look up the FDE for
950 its caller and decode it into FS. This function also sets the
951 args_size and lsda members of CONTEXT, as they are really information
952 about the caller's frame. */
954 static _Unwind_Reason_Code
955 uw_frame_state_for (struct _Unwind_Context
*context
, _Unwind_FrameState
*fs
)
957 const struct dwarf_fde
*fde
;
958 const struct dwarf_cie
*cie
;
959 const unsigned char *aug
, *insn
, *end
;
961 memset (fs
, 0, sizeof (*fs
));
962 context
->args_size
= 0;
965 if (context
->ra
== 0)
966 return _URC_END_OF_STACK
;
968 fde
= _Unwind_Find_FDE (context
->ra
- 1, &context
->bases
);
971 #ifdef MD_FALLBACK_FRAME_STATE_FOR
972 /* Couldn't find frame unwind info for this function. Try a
973 target-specific fallback mechanism. This will necessarily
974 not provide a personality routine or LSDA. */
975 return MD_FALLBACK_FRAME_STATE_FOR (context
, fs
);
977 return _URC_END_OF_STACK
;
981 fs
->pc
= context
->bases
.func
;
984 insn
= extract_cie_info (cie
, context
, fs
);
986 /* CIE contained unknown augmentation. */
987 return _URC_FATAL_PHASE1_ERROR
;
989 /* First decode all the insns in the CIE. */
990 end
= (unsigned char *) next_fde ((struct dwarf_fde
*) cie
);
991 execute_cfa_program (insn
, end
, context
, fs
);
993 /* Locate augmentation for the fde. */
994 aug
= (unsigned char *) fde
+ sizeof (*fde
);
995 aug
+= 2 * size_of_encoded_value (fs
->fde_encoding
);
1000 aug
= read_uleb128 (aug
, &i
);
1003 if (fs
->lsda_encoding
!= DW_EH_PE_omit
)
1004 aug
= read_encoded_value (context
, fs
->lsda_encoding
, aug
,
1005 (_Unwind_Ptr
*) &context
->lsda
);
1007 /* Then the insns in the FDE up to our target PC. */
1010 end
= (unsigned char *) next_fde (fde
);
1011 execute_cfa_program (insn
, end
, context
, fs
);
1013 return _URC_NO_REASON
;
1016 typedef struct frame_state
1022 long reg_or_offset
[PRE_GCC3_DWARF_FRAME_REGISTERS
+1];
1023 unsigned short cfa_reg
;
1024 unsigned short retaddr_column
;
1025 char saved
[PRE_GCC3_DWARF_FRAME_REGISTERS
+1];
1028 struct frame_state
* __frame_state_for (void *, struct frame_state
*);
1030 /* Called from pre-G++ 3.0 __throw to find the registers to restore for
1031 a given PC_TARGET. The caller should allocate a local variable of
1032 `struct frame_state' and pass its address to STATE_IN. */
1034 struct frame_state
*
1035 __frame_state_for (void *pc_target
, struct frame_state
*state_in
)
1037 struct _Unwind_Context context
;
1038 _Unwind_FrameState fs
;
1041 memset (&context
, 0, sizeof (struct _Unwind_Context
));
1042 context
.ra
= pc_target
+ 1;
1044 if (uw_frame_state_for (&context
, &fs
) != _URC_NO_REASON
)
1047 /* We have no way to pass a location expression for the CFA to our
1048 caller. It wouldn't understand it anyway. */
1049 if (fs
.cfa_how
== CFA_EXP
)
1052 for (reg
= 0; reg
< PRE_GCC3_DWARF_FRAME_REGISTERS
+ 1; reg
++)
1054 state_in
->saved
[reg
] = fs
.regs
.reg
[reg
].how
;
1055 switch (state_in
->saved
[reg
])
1058 state_in
->reg_or_offset
[reg
] = fs
.regs
.reg
[reg
].loc
.reg
;
1060 case REG_SAVED_OFFSET
:
1061 state_in
->reg_or_offset
[reg
] = fs
.regs
.reg
[reg
].loc
.offset
;
1064 state_in
->reg_or_offset
[reg
] = 0;
1069 state_in
->cfa_offset
= fs
.cfa_offset
;
1070 state_in
->cfa_reg
= fs
.cfa_reg
;
1071 state_in
->retaddr_column
= fs
.retaddr_column
;
1072 state_in
->args_size
= context
.args_size
;
1073 state_in
->eh_ptr
= fs
.eh_ptr
;
1078 typedef union { _Unwind_Ptr ptr
; _Unwind_Word word
; } _Unwind_SpTmp
;
1081 _Unwind_SetSpColumn (struct _Unwind_Context
*context
, void *cfa
,
1082 _Unwind_SpTmp
*tmp_sp
)
1084 int size
= dwarf_reg_size_table
[__builtin_dwarf_sp_column ()];
1086 if (size
== sizeof(_Unwind_Ptr
))
1087 tmp_sp
->ptr
= (_Unwind_Ptr
) cfa
;
1090 gcc_assert (size
== sizeof(_Unwind_Word
));
1091 tmp_sp
->word
= (_Unwind_Ptr
) cfa
;
1093 _Unwind_SetGRPtr (context
, __builtin_dwarf_sp_column (), tmp_sp
);
1097 uw_update_context_1 (struct _Unwind_Context
*context
, _Unwind_FrameState
*fs
)
1099 struct _Unwind_Context orig_context
= *context
;
1103 #ifdef EH_RETURN_STACKADJ_RTX
1104 /* Special handling here: Many machines do not use a frame pointer,
1105 and track the CFA only through offsets from the stack pointer from
1106 one frame to the next. In this case, the stack pointer is never
1107 stored, so it has no saved address in the context. What we do
1108 have is the CFA from the previous stack frame.
1110 In very special situations (such as unwind info for signal return),
1111 there may be location expressions that use the stack pointer as well.
1113 Do this conditionally for one frame. This allows the unwind info
1114 for one frame to save a copy of the stack pointer from the previous
1115 frame, and be able to use much easier CFA mechanisms to do it.
1116 Always zap the saved stack pointer value for the next frame; carrying
1117 the value over from one frame to another doesn't make sense. */
1119 _Unwind_SpTmp tmp_sp
;
1121 if (!_Unwind_GetGRPtr (&orig_context
, __builtin_dwarf_sp_column ()))
1122 _Unwind_SetSpColumn (&orig_context
, context
->cfa
, &tmp_sp
);
1123 _Unwind_SetGRPtr (context
, __builtin_dwarf_sp_column (), NULL
);
1126 /* Compute this frame's CFA. */
1127 switch (fs
->cfa_how
)
1129 case CFA_REG_OFFSET
:
1130 cfa
= _Unwind_GetPtr (&orig_context
, fs
->cfa_reg
);
1131 cfa
+= fs
->cfa_offset
;
1136 const unsigned char *exp
= fs
->cfa_exp
;
1139 exp
= read_uleb128 (exp
, &len
);
1140 cfa
= (void *) (_Unwind_Ptr
)
1141 execute_stack_op (exp
, exp
+ len
, &orig_context
, 0);
1150 /* Compute the addresses of all registers saved in this frame. */
1151 for (i
= 0; i
< DWARF_FRAME_REGISTERS
+ 1; ++i
)
1152 switch (fs
->regs
.reg
[i
].how
)
1157 case REG_SAVED_OFFSET
:
1158 _Unwind_SetGRPtr (context
, i
,
1159 (void *) (cfa
+ fs
->regs
.reg
[i
].loc
.offset
));
1165 _Unwind_GetGRPtr (&orig_context
, fs
->regs
.reg
[i
].loc
.reg
));
1170 const unsigned char *exp
= fs
->regs
.reg
[i
].loc
.exp
;
1174 exp
= read_uleb128 (exp
, &len
);
1175 val
= execute_stack_op (exp
, exp
+ len
, &orig_context
,
1177 _Unwind_SetGRPtr (context
, i
, (void *) val
);
1182 #ifdef MD_FROB_UPDATE_CONTEXT
1183 MD_FROB_UPDATE_CONTEXT (context
, fs
);
1187 /* CONTEXT describes the unwind state for a frame, and FS describes the FDE
1188 of its caller. Update CONTEXT to refer to the caller as well. Note
1189 that the args_size and lsda members are not updated here, but later in
1190 uw_frame_state_for. */
1193 uw_update_context (struct _Unwind_Context
*context
, _Unwind_FrameState
*fs
)
1195 uw_update_context_1 (context
, fs
);
1197 /* Compute the return address now, since the return address column
1198 can change from frame to frame. */
1199 context
->ra
= __builtin_extract_return_addr
1200 (_Unwind_GetPtr (context
, fs
->retaddr_column
));
1203 /* Fill in CONTEXT for top-of-stack. The only valid registers at this
1204 level will be the return address and the CFA. */
1206 #define uw_init_context(CONTEXT) \
1209 /* Do any necessary initialization to access arbitrary stack frames. \
1210 On the SPARC, this means flushing the register windows. */ \
1211 __builtin_unwind_init (); \
1212 uw_init_context_1 (CONTEXT, __builtin_dwarf_cfa (), \
1213 __builtin_return_address (0)); \
1218 init_dwarf_reg_size_table (void)
1220 __builtin_init_dwarf_reg_size_table (dwarf_reg_size_table
);
1224 uw_init_context_1 (struct _Unwind_Context
*context
,
1225 void *outer_cfa
, void *outer_ra
)
1227 void *ra
= __builtin_extract_return_addr (__builtin_return_address (0));
1228 _Unwind_FrameState fs
;
1229 _Unwind_SpTmp sp_slot
;
1230 _Unwind_Reason_Code code
;
1232 memset (context
, 0, sizeof (struct _Unwind_Context
));
1235 code
= uw_frame_state_for (context
, &fs
);
1236 gcc_assert (code
== _URC_NO_REASON
);
1240 static __gthread_once_t once_regsizes
= __GTHREAD_ONCE_INIT
;
1241 if (__gthread_once (&once_regsizes
, init_dwarf_reg_size_table
) != 0
1242 || dwarf_reg_size_table
[0] == 0)
1243 init_dwarf_reg_size_table ();
1246 if (dwarf_reg_size_table
[0] == 0)
1247 init_dwarf_reg_size_table ();
1250 /* Force the frame state to use the known cfa value. */
1251 _Unwind_SetSpColumn (context
, outer_cfa
, &sp_slot
);
1252 fs
.cfa_how
= CFA_REG_OFFSET
;
1253 fs
.cfa_reg
= __builtin_dwarf_sp_column ();
1256 uw_update_context_1 (context
, &fs
);
1258 /* If the return address column was saved in a register in the
1259 initialization context, then we can't see it in the given
1260 call frame data. So have the initialization context tell us. */
1261 context
->ra
= __builtin_extract_return_addr (outer_ra
);
1265 /* Install TARGET into CURRENT so that we can return to it. This is a
1266 macro because __builtin_eh_return must be invoked in the context of
1269 #define uw_install_context(CURRENT, TARGET) \
1272 long offset = uw_install_context_1 ((CURRENT), (TARGET)); \
1273 void *handler = __builtin_frob_return_addr ((TARGET)->ra); \
1274 __builtin_eh_return (offset, handler); \
1279 uw_install_context_1 (struct _Unwind_Context
*current
,
1280 struct _Unwind_Context
*target
)
1283 _Unwind_SpTmp sp_slot
;
1285 /* If the target frame does not have a saved stack pointer,
1286 then set up the target's CFA. */
1287 if (!_Unwind_GetGRPtr (target
, __builtin_dwarf_sp_column ()))
1288 _Unwind_SetSpColumn (target
, target
->cfa
, &sp_slot
);
1290 for (i
= 0; i
< DWARF_FRAME_REGISTERS
; ++i
)
1292 void *c
= current
->reg
[i
];
1293 void *t
= target
->reg
[i
];
1295 if (t
&& c
&& t
!= c
)
1296 memcpy (c
, t
, dwarf_reg_size_table
[i
]);
1299 /* If the current frame doesn't have a saved stack pointer, then we
1300 need to rely on EH_RETURN_STACKADJ_RTX to get our target stack
1301 pointer value reloaded. */
1302 if (!_Unwind_GetGRPtr (current
, __builtin_dwarf_sp_column ()))
1306 target_cfa
= _Unwind_GetPtr (target
, __builtin_dwarf_sp_column ());
1308 /* We adjust SP by the difference between CURRENT and TARGET's CFA. */
1309 if (STACK_GROWS_DOWNWARD
)
1310 return target_cfa
- current
->cfa
+ target
->args_size
;
1312 return current
->cfa
- target_cfa
- target
->args_size
;
1317 static inline _Unwind_Ptr
1318 uw_identify_context (struct _Unwind_Context
*context
)
1320 return _Unwind_GetIP (context
);
1324 #include "unwind.inc"
1326 #if defined (USE_GAS_SYMVER) && defined (SHARED) && defined (USE_LIBUNWIND_EXCEPTIONS)
1327 alias (_Unwind_Backtrace
);
1328 alias (_Unwind_DeleteException
);
1329 alias (_Unwind_FindEnclosingFunction
);
1330 alias (_Unwind_ForcedUnwind
);
1331 alias (_Unwind_GetDataRelBase
);
1332 alias (_Unwind_GetTextRelBase
);
1333 alias (_Unwind_GetCFA
);
1334 alias (_Unwind_GetGR
);
1335 alias (_Unwind_GetIP
);
1336 alias (_Unwind_GetLanguageSpecificData
);
1337 alias (_Unwind_GetRegionStart
);
1338 alias (_Unwind_RaiseException
);
1339 alias (_Unwind_Resume
);
1340 alias (_Unwind_Resume_or_Rethrow
);
1341 alias (_Unwind_SetGR
);
1342 alias (_Unwind_SetIP
);
1345 #endif /* !USING_SJLJ_EXCEPTIONS */