1 /* DWARF2 exception handling and frame unwind runtime interface routines.
2 Copyright (C) 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it
7 under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GCC is distributed in the hope that it will be useful, but WITHOUT
12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
13 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
14 License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING. If not, write to the Free
18 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
25 #include "unwind-pe.h"
26 #include "unwind-dw2-fde.h"
30 #if !USING_SJLJ_EXCEPTIONS
32 #ifndef STACK_GROWS_DOWNWARD
33 #define STACK_GROWS_DOWNWARD 0
35 #undef STACK_GROWS_DOWNWARD
36 #define STACK_GROWS_DOWNWARD 1
39 /* A target can override (perhaps for backward compatibility) how
40 many dwarf2 columns are unwound. */
41 #ifndef DWARF_FRAME_REGISTERS
42 #define DWARF_FRAME_REGISTERS FIRST_PSEUDO_REGISTER
45 /* This is the register and unwind state for a particular frame. */
46 struct _Unwind_Context
48 void *reg[DWARF_FRAME_REGISTERS+1];
52 struct dwarf_eh_bases bases;
53 _Unwind_Word args_size;
56 /* Byte size of every register managed by these routines. */
57 static unsigned char dwarf_reg_size_table[DWARF_FRAME_REGISTERS];
60 /* The result of interpreting the frame unwind info for a frame.
61 This is all symbolic at this point, as none of the values can
62 be resolved until the target pc is located. */
65 /* Each register save state can be described in terms of a CFA slot,
66 another register, or a location expression. */
67 struct frame_state_reg_info
73 const unsigned char *exp;
81 } reg[DWARF_FRAME_REGISTERS+1];
83 /* Used to implement DW_CFA_remember_state. */
84 struct frame_state_reg_info *prev;
87 /* The CFA can be described in terms of a reg+offset or a
88 location expression. */
89 _Unwind_Sword cfa_offset;
91 const unsigned char *cfa_exp;
98 /* The PC described by the current frame state. */
101 /* The information we care about from the CIE/FDE. */
102 _Unwind_Personality_Fn personality;
103 _Unwind_Sword data_align;
104 _Unwind_Word code_align;
105 unsigned char retaddr_column;
106 unsigned char fde_encoding;
107 unsigned char lsda_encoding;
110 } _Unwind_FrameState;
112 /* Read unaligned data from the instruction buffer. */
117 unsigned u2 __attribute__ ((mode (HI)));
118 unsigned u4 __attribute__ ((mode (SI)));
119 unsigned u8 __attribute__ ((mode (DI)));
120 signed s2 __attribute__ ((mode (HI)));
121 signed s4 __attribute__ ((mode (SI)));
122 signed s8 __attribute__ ((mode (DI)));
123 } __attribute__ ((packed));
126 read_pointer (const void *p) { const union unaligned *up = p; return up->p; }
129 read_1u (const void *p) { return *(const unsigned char *)p; }
132 read_1s (const void *p) { return *(const signed char *)p; }
135 read_2u (const void *p) { const union unaligned *up = p; return up->u2; }
138 read_2s (const void *p) { const union unaligned *up = p; return up->s2; }
140 static inline unsigned int
141 read_4u (const void *p) { const union unaligned *up = p; return up->u4; }
144 read_4s (const void *p) { const union unaligned *up = p; return up->s4; }
146 static inline unsigned long
147 read_8u (const void *p) { const union unaligned *up = p; return up->u8; }
149 static inline unsigned long
150 read_8s (const void *p) { const union unaligned *up = p; return up->s8; }
152 /* Get the value of register REG as saved in CONTEXT. */
155 _Unwind_GetGR (struct _Unwind_Context *context, int index)
157 /* This will segfault if the register hasn't been saved. */
158 return * (_Unwind_Word *) context->reg[index];
161 /* Overwrite the saved value for register REG in CONTEXT with VAL. */
164 _Unwind_SetGR (struct _Unwind_Context *context, int index, _Unwind_Word val)
166 * (_Unwind_Word *) context->reg[index] = val;
169 /* Retrieve the return address for CONTEXT. */
172 _Unwind_GetIP (struct _Unwind_Context *context)
174 return (_Unwind_Ptr) context->ra;
177 /* Overwrite the return address for CONTEXT with VAL. */
180 _Unwind_SetIP (struct _Unwind_Context *context, _Unwind_Ptr val)
182 context->ra = (void *) val;
186 _Unwind_GetLanguageSpecificData (struct _Unwind_Context *context)
188 return context->lsda;
192 _Unwind_GetRegionStart (struct _Unwind_Context *context)
194 return (_Unwind_Ptr) context->bases.func;
199 _Unwind_GetDataRelBase (struct _Unwind_Context *context)
201 return (_Unwind_Ptr) context->bases.dbase;
205 _Unwind_GetTextRelBase (struct _Unwind_Context *context)
207 return (_Unwind_Ptr) context->bases.tbase;
211 /* Extract any interesting information from the CIE for the translation
212 unit F belongs to. Return a pointer to the byte after the augmentation,
213 or NULL if we encountered an undecipherable augmentation. */
215 static const unsigned char *
216 extract_cie_info (struct dwarf_cie *cie, struct _Unwind_Context *context,
217 _Unwind_FrameState *fs)
219 const unsigned char *aug = cie->augmentation;
220 const unsigned char *p = aug + strlen (aug) + 1;
221 const unsigned char *ret = NULL;
224 /* g++ v2 "eh" has pointer immediately following augmentation string,
225 so it must be handled first. */
226 if (aug[0] == 'e' && aug[1] == 'h')
228 fs->eh_ptr = read_pointer (p);
229 p += sizeof (void *);
233 /* Immediately following the augmentation are the code and
234 data alignment and return address column. */
235 p = read_uleb128 (p, &fs->code_align);
236 p = read_sleb128 (p, &fs->data_align);
237 fs->retaddr_column = *p++;
238 fs->lsda_encoding = DW_EH_PE_omit;
240 /* If the augmentation starts with 'z', then a uleb128 immediately
241 follows containing the length of the augmentation field following
245 p = read_uleb128 (p, &utmp);
252 /* Iterate over recognized augmentation subsequences. */
255 /* "L" indicates a byte showing how the LSDA pointer is encoded. */
258 fs->lsda_encoding = *p++;
262 /* "R" indicates a byte indicating how FDE addresses are encoded. */
263 else if (aug[0] == 'R')
265 fs->fde_encoding = *p++;
269 /* "P" indicates a personality routine in the CIE augmentation. */
270 else if (aug[0] == 'P')
272 p = read_encoded_value (context, *p, p + 1,
273 (_Unwind_Ptr *) &fs->personality);
277 /* Otherwise we have an unknown augmentation string.
278 Bail unless we saw a 'z' prefix. */
283 return ret ? ret : p;
287 /* Decode a DW_OP stack program. Return the top of stack. Push INITIAL
288 onto the stack to start. */
291 execute_stack_op (const unsigned char *op_ptr, const unsigned char *op_end,
292 struct _Unwind_Context *context, _Unwind_Word initial)
294 _Unwind_Word stack[64]; /* ??? Assume this is enough. */
300 while (op_ptr < op_end)
302 enum dwarf_location_atom op = *op_ptr++;
303 _Unwind_Word result, reg, utmp;
304 _Unwind_Sword offset, stmp;
340 result = op - DW_OP_lit0;
344 result = (_Unwind_Word) (_Unwind_Ptr) read_pointer (op_ptr);
345 op_ptr += sizeof (void *);
349 result = read_1u (op_ptr);
353 result = read_1s (op_ptr);
357 result = read_2u (op_ptr);
361 result = read_2s (op_ptr);
365 result = read_4u (op_ptr);
369 result = read_4s (op_ptr);
373 result = read_8u (op_ptr);
377 result = read_8s (op_ptr);
381 op_ptr = read_uleb128 (op_ptr, &result);
384 op_ptr = read_sleb128 (op_ptr, &stmp);
420 result = _Unwind_GetGR (context, op - DW_OP_reg0);
423 op_ptr = read_uleb128 (op_ptr, ®);
424 result = _Unwind_GetGR (context, reg);
459 op_ptr = read_sleb128 (op_ptr, &offset);
460 result = _Unwind_GetGR (context, op - DW_OP_breg0) + offset;
463 op_ptr = read_uleb128 (op_ptr, ®);
464 op_ptr = read_sleb128 (op_ptr, &offset);
465 result = _Unwind_GetGR (context, reg) + offset;
471 result = stack[stack_elt - 1];
481 if (offset >= stack_elt - 1)
483 result = stack[stack_elt - 1 - offset];
489 result = stack[stack_elt - 2];
494 _Unwind_Word t1, t2, t3;
498 t1 = stack[stack_elt - 1];
499 t2 = stack[stack_elt - 2];
500 t3 = stack[stack_elt - 3];
501 stack[stack_elt - 1] = t2;
502 stack[stack_elt - 2] = t3;
503 stack[stack_elt - 3] = t1;
508 case DW_OP_deref_size:
512 case DW_OP_plus_uconst:
513 /* Unary operations. */
516 result = stack[stack_elt];
522 void *ptr = (void *)(_Unwind_Ptr) result;
523 result = (_Unwind_Ptr) read_pointer (ptr);
527 case DW_OP_deref_size:
529 void *ptr = (void *)(_Unwind_Ptr) result;
533 result = read_1u (ptr);
536 result = read_2u (ptr);
539 result = read_4u (ptr);
542 result = read_8u (ptr);
551 if ((_Unwind_Sword) result < 0)
560 case DW_OP_plus_uconst:
561 op_ptr = read_uleb128 (op_ptr, &utmp);
584 /* Binary operations. */
585 _Unwind_Word first, second;
586 if ((stack_elt -= 2) < 0)
588 second = stack[stack_elt];
589 first = stack[stack_elt + 1];
594 result = second & first;
597 result = (_Unwind_Sword)second / (_Unwind_Sword)first;
600 result = second - first;
603 result = (_Unwind_Sword)second % (_Unwind_Sword)first;
606 result = second * first;
609 result = second | first;
612 result = second + first;
615 result = second << first;
618 result = second >> first;
621 result = (_Unwind_Sword)second >> first;
624 result = second ^ first;
627 result = (_Unwind_Sword)first <= (_Unwind_Sword)second;
630 result = (_Unwind_Sword)first >= (_Unwind_Sword)second;
633 result = (_Unwind_Sword)first == (_Unwind_Sword)second;
636 result = (_Unwind_Sword)first < (_Unwind_Sword)second;
639 result = (_Unwind_Sword)first > (_Unwind_Sword)second;
642 result = (_Unwind_Sword)first != (_Unwind_Sword)second;
652 offset = read_2s (op_ptr);
660 offset = read_2s (op_ptr);
662 if (stack[stack_elt] != 0)
673 /* Most things push a result value. */
674 if ((size_t) stack_elt >= sizeof(stack)/sizeof(*stack))
676 stack[++stack_elt] = result;
680 /* We were executing this program to get a value. It should be
684 return stack[stack_elt];
688 /* Decode DWARF 2 call frame information. Takes pointers the
689 instruction sequence to decode, current register information and
690 CIE info, and the PC range to evaluate. */
693 execute_cfa_program (const unsigned char *insn_ptr,
694 const unsigned char *insn_end,
695 struct _Unwind_Context *context,
696 _Unwind_FrameState *fs)
698 struct frame_state_reg_info *unused_rs = NULL;
700 /* Don't allow remember/restore between CIE and FDE programs. */
701 fs->regs.prev = NULL;
703 while (insn_ptr < insn_end && fs->pc <= context->ra)
705 unsigned char insn = *insn_ptr++;
706 _Unwind_Word reg, utmp;
707 _Unwind_Sword offset, stmp;
709 if (insn & DW_CFA_advance_loc)
710 fs->pc += (insn & 0x3f) * fs->code_align;
711 else if (insn & DW_CFA_offset)
714 insn_ptr = read_uleb128 (insn_ptr, &utmp);
715 offset = (_Unwind_Sword)utmp * fs->data_align;
716 fs->regs.reg[reg].how = REG_SAVED_OFFSET;
717 fs->regs.reg[reg].loc.offset = offset;
719 else if (insn & DW_CFA_restore)
722 fs->regs.reg[reg].how = REG_UNSAVED;
727 insn_ptr = read_encoded_value (context, fs->fde_encoding,
728 insn_ptr, (_Unwind_Ptr *) &fs->pc);
731 case DW_CFA_advance_loc1:
732 fs->pc += read_1u (insn_ptr) * fs->code_align;
735 case DW_CFA_advance_loc2:
736 fs->pc += read_2u (insn_ptr) * fs->code_align;
739 case DW_CFA_advance_loc4:
740 fs->pc += read_4u (insn_ptr) * fs->code_align;
744 case DW_CFA_offset_extended:
745 insn_ptr = read_uleb128 (insn_ptr, ®);
746 insn_ptr = read_uleb128 (insn_ptr, &utmp);
747 offset = (_Unwind_Sword)utmp * fs->data_align;
748 fs->regs.reg[reg].how = REG_SAVED_OFFSET;
749 fs->regs.reg[reg].loc.offset = offset;
752 case DW_CFA_restore_extended:
753 insn_ptr = read_uleb128 (insn_ptr, ®);
754 fs->regs.reg[reg].how = REG_UNSAVED;
757 case DW_CFA_undefined:
758 case DW_CFA_same_value:
762 case DW_CFA_register:
765 insn_ptr = read_uleb128 (insn_ptr, ®);
766 insn_ptr = read_uleb128 (insn_ptr, ®2);
767 fs->regs.reg[reg].how = REG_SAVED_REG;
768 fs->regs.reg[reg].loc.reg = reg2;
772 case DW_CFA_remember_state:
774 struct frame_state_reg_info *new_rs;
778 unused_rs = unused_rs->prev;
781 new_rs = __builtin_alloca (sizeof (struct frame_state_reg_info));
784 fs->regs.prev = new_rs;
788 case DW_CFA_restore_state:
790 struct frame_state_reg_info *old_rs = fs->regs.prev;
792 old_rs->prev = unused_rs;
798 insn_ptr = read_uleb128 (insn_ptr, &fs->cfa_reg);
799 insn_ptr = read_uleb128 (insn_ptr, &utmp);
800 fs->cfa_offset = utmp;
801 fs->cfa_how = CFA_REG_OFFSET;
804 case DW_CFA_def_cfa_register:
805 insn_ptr = read_uleb128 (insn_ptr, &fs->cfa_reg);
806 fs->cfa_how = CFA_REG_OFFSET;
809 case DW_CFA_def_cfa_offset:
810 insn_ptr = read_uleb128 (insn_ptr, &utmp);
811 fs->cfa_offset = utmp;
812 /* cfa_how deliberately not set. */
815 case DW_CFA_def_cfa_expression:
816 insn_ptr = read_uleb128 (insn_ptr, &utmp);
817 fs->cfa_exp = insn_ptr;
818 fs->cfa_how = CFA_EXP;
822 case DW_CFA_expression:
823 insn_ptr = read_uleb128 (insn_ptr, ®);
824 insn_ptr = read_uleb128 (insn_ptr, &utmp);
825 fs->regs.reg[reg].how = REG_SAVED_EXP;
826 fs->regs.reg[reg].loc.exp = insn_ptr;
830 /* From the 2.1 draft. */
831 case DW_CFA_offset_extended_sf:
832 insn_ptr = read_uleb128 (insn_ptr, ®);
833 insn_ptr = read_sleb128 (insn_ptr, &stmp);
834 offset = stmp * fs->data_align;
835 fs->regs.reg[reg].how = REG_SAVED_OFFSET;
836 fs->regs.reg[reg].loc.offset = offset;
839 case DW_CFA_def_cfa_sf:
840 insn_ptr = read_uleb128 (insn_ptr, &fs->cfa_reg);
841 insn_ptr = read_sleb128 (insn_ptr, &fs->cfa_offset);
842 fs->cfa_how = CFA_REG_OFFSET;
845 case DW_CFA_def_cfa_offset_sf:
846 insn_ptr = read_sleb128 (insn_ptr, &fs->cfa_offset);
847 /* cfa_how deliberately not set. */
850 case DW_CFA_GNU_window_save:
851 /* ??? Hardcoded for SPARC register window configuration. */
852 for (reg = 16; reg < 32; ++reg)
854 fs->regs.reg[reg].how = REG_SAVED_OFFSET;
855 fs->regs.reg[reg].loc.offset = (reg - 16) * sizeof (void *);
859 case DW_CFA_GNU_args_size:
860 insn_ptr = read_uleb128 (insn_ptr, &context->args_size);
863 case DW_CFA_GNU_negative_offset_extended:
864 /* Obsoleted by DW_CFA_offset_extended_sf, but used by
865 older PowerPC code. */
866 insn_ptr = read_uleb128 (insn_ptr, ®);
867 insn_ptr = read_uleb128 (insn_ptr, &utmp);
868 offset = (_Unwind_Word)utmp * fs->data_align;
869 fs->regs.reg[reg].how = REG_SAVED_OFFSET;
870 fs->regs.reg[reg].loc.offset = -offset;
879 static _Unwind_Reason_Code
880 uw_frame_state_for (struct _Unwind_Context *context, _Unwind_FrameState *fs)
882 struct dwarf_fde *fde;
883 struct dwarf_cie *cie;
884 const unsigned char *aug, *insn, *end;
886 memset (fs, 0, sizeof (*fs));
887 context->args_size = 0;
890 fde = _Unwind_Find_FDE (context->ra - 1, &context->bases);
893 /* Couldn't find frame unwind info for this function. Try a
894 target-specific fallback mechanism. This will necessarily
895 not provide a personality routine or LSDA. */
896 #ifdef MD_FALLBACK_FRAME_STATE_FOR
897 MD_FALLBACK_FRAME_STATE_FOR (context, fs, success);
898 return _URC_END_OF_STACK;
900 return _URC_NO_REASON;
902 return _URC_END_OF_STACK;
906 fs->pc = context->bases.func;
909 insn = extract_cie_info (cie, context, fs);
911 /* CIE contained unknown augmentation. */
912 return _URC_FATAL_PHASE1_ERROR;
914 /* First decode all the insns in the CIE. */
915 end = (unsigned char *) next_fde ((struct dwarf_fde *) cie);
916 execute_cfa_program (insn, end, context, fs);
918 /* Locate augmentation for the fde. */
919 aug = (unsigned char *)fde + sizeof (*fde);
920 aug += 2 * size_of_encoded_value (fs->fde_encoding);
925 aug = read_uleb128 (aug, &i);
928 if (fs->lsda_encoding != DW_EH_PE_omit)
929 aug = read_encoded_value (context, fs->lsda_encoding, aug,
930 (_Unwind_Ptr *) &context->lsda);
932 /* Then the insns in the FDE up to our target PC. */
935 end = (unsigned char *) next_fde (fde);
936 execute_cfa_program (insn, end, context, fs);
938 return _URC_NO_REASON;
941 typedef struct frame_state
947 long reg_or_offset[DWARF_FRAME_REGISTERS+1];
948 unsigned short cfa_reg;
949 unsigned short retaddr_column;
950 char saved[DWARF_FRAME_REGISTERS+1];
953 struct frame_state * __frame_state_for (void *, struct frame_state *);
955 /* Called from pre-G++ 3.0 __throw to find the registers to restore for
956 a given PC_TARGET. The caller should allocate a local variable of
957 `struct frame_state' and pass its address to STATE_IN. */
960 __frame_state_for (void *pc_target, struct frame_state *state_in)
962 struct _Unwind_Context context;
963 _Unwind_FrameState fs;
966 memset (&context, 0, sizeof (struct _Unwind_Context));
967 context.ra = pc_target + 1;
969 if (uw_frame_state_for (&context, &fs) != _URC_NO_REASON)
972 /* We have no way to pass a location expression for the CFA to our
973 caller. It wouldn't understand it anyway. */
974 if (fs.cfa_how == CFA_EXP)
977 for (reg = 0; reg < DWARF_FRAME_REGISTERS + 1; reg++)
979 state_in->saved[reg] = fs.regs.reg[reg].how;
980 switch (state_in->saved[reg])
983 state_in->reg_or_offset[reg] = fs.regs.reg[reg].loc.reg;
985 case REG_SAVED_OFFSET:
986 state_in->reg_or_offset[reg] = fs.regs.reg[reg].loc.offset;
989 state_in->reg_or_offset[reg] = 0;
994 state_in->cfa_offset = fs.cfa_offset;
995 state_in->cfa_reg = fs.cfa_reg;
996 state_in->retaddr_column = fs.retaddr_column;
997 state_in->args_size = context.args_size;
998 state_in->eh_ptr = fs.eh_ptr;
1004 uw_update_context_1 (struct _Unwind_Context *context, _Unwind_FrameState *fs)
1006 struct _Unwind_Context orig_context = *context;
1010 /* Compute this frame's CFA. */
1011 switch (fs->cfa_how)
1013 case CFA_REG_OFFSET:
1014 /* Special handling here: Many machines do not use a frame pointer,
1015 and track the CFA only through offsets from the stack pointer from
1016 one frame to the next. In this case, the stack pointer is never
1017 stored, so it has no saved address in the context. What we do
1018 have is the CFA from the previous stack frame. */
1019 if (context->reg[fs->cfa_reg] == NULL)
1022 cfa = (void *) (_Unwind_Ptr) _Unwind_GetGR (context, fs->cfa_reg);
1023 cfa += fs->cfa_offset;
1027 /* ??? No way of knowing what register number is the stack pointer
1028 to do the same sort of handling as above. Assume that if the
1029 CFA calculation is so complicated as to require a stack program
1030 that this will not be a problem. */
1032 const unsigned char *exp = fs->cfa_exp;
1035 exp = read_uleb128 (exp, &len);
1036 cfa = (void *) (_Unwind_Ptr)
1037 execute_stack_op (exp, exp + len, context, 0);
1046 /* Compute the addresses of all registers saved in this frame. */
1047 for (i = 0; i < DWARF_FRAME_REGISTERS + 1; ++i)
1048 switch (fs->regs.reg[i].how)
1052 case REG_SAVED_OFFSET:
1053 context->reg[i] = cfa + fs->regs.reg[i].loc.offset;
1056 context->reg[i] = orig_context.reg[fs->regs.reg[i].loc.reg];
1060 const unsigned char *exp = fs->regs.reg[i].loc.exp;
1064 exp = read_uleb128 (exp, &len);
1065 val = execute_stack_op (exp, exp + len, &orig_context,
1067 context->reg[i] = (void *) val;
1074 uw_update_context (struct _Unwind_Context *context, _Unwind_FrameState *fs)
1076 uw_update_context_1 (context, fs);
1078 /* Compute the return address now, since the return address column
1079 can change from frame to frame. */
1080 context->ra = __builtin_extract_return_addr
1081 ((void *) (_Unwind_Ptr) _Unwind_GetGR (context, fs->retaddr_column));
1084 /* Fill in CONTEXT for top-of-stack. The only valid registers at this
1085 level will be the return address and the CFA. */
1087 #define uw_init_context(CONTEXT) \
1089 /* Do any necessary initialization to access arbitrary stack frames. \
1090 On the SPARC, this means flushing the register windows. */ \
1091 __builtin_unwind_init (); \
1092 uw_init_context_1 (CONTEXT, __builtin_dwarf_cfa (), \
1093 __builtin_return_address (0)); \
1097 uw_init_context_1 (struct _Unwind_Context *context,
1098 void *outer_cfa, void *outer_ra)
1100 void *ra = __builtin_extract_return_addr (__builtin_return_address (0));
1101 _Unwind_FrameState fs;
1103 memset (context, 0, sizeof (struct _Unwind_Context));
1106 if (uw_frame_state_for (context, &fs) != _URC_NO_REASON)
1109 /* Force the frame state to use the known cfa value. */
1110 context->cfa = outer_cfa;
1111 fs.cfa_how = CFA_REG_OFFSET;
1115 uw_update_context_1 (context, &fs);
1117 /* If the return address column was saved in a register in the
1118 initialization context, then we can't see it in the given
1119 call frame data. So have the initialization context tell us. */
1120 context->ra = __builtin_extract_return_addr (outer_ra);
1124 /* Install TARGET into CURRENT so that we can return to it. This is a
1125 macro because __builtin_eh_return must be invoked in the context of
1128 #define uw_install_context(CURRENT, TARGET) \
1130 long offset = uw_install_context_1 ((CURRENT), (TARGET)); \
1131 void *handler = __builtin_frob_return_addr ((TARGET)->ra); \
1132 __builtin_eh_return (offset, handler); \
1136 init_dwarf_reg_size_table (void)
1138 __builtin_init_dwarf_reg_size_table (dwarf_reg_size_table);
1142 uw_install_context_1 (struct _Unwind_Context *current,
1143 struct _Unwind_Context *target)
1149 static __gthread_once_t once_regsizes = __GTHREAD_ONCE_INIT;
1150 if (__gthread_once (&once_regsizes, init_dwarf_reg_size_table) != 0
1151 || dwarf_reg_size_table[0] == 0)
1152 init_dwarf_reg_size_table ();
1155 if (dwarf_reg_size_table[0] == 0)
1156 init_dwarf_reg_size_table ();
1159 for (i = 0; i < DWARF_FRAME_REGISTERS; ++i)
1161 void *c = current->reg[i];
1162 void *t = target->reg[i];
1163 if (t && c && t != c)
1164 memcpy (c, t, dwarf_reg_size_table[i]);
1167 /* We adjust SP by the difference between CURRENT and TARGET's CFA. */
1168 if (STACK_GROWS_DOWNWARD)
1169 return target->cfa - current->cfa + target->args_size;
1171 return current->cfa - target->cfa - target->args_size;
1174 static inline _Unwind_Ptr
1175 uw_identify_context (struct _Unwind_Context *context)
1177 return _Unwind_GetIP (context);
1181 #include "unwind.inc"
1183 #endif /* !USING_SJLJ_EXCEPTIONS */