3fc0d931e9e4857f0c0a5786105e830ca2c2cd62
[kopensolaris-gnu/glibc.git] / sysdeps / generic / unwind-dw2.c
1 /* DWARF2 exception handling and frame unwind runtime interface routines.
2    Copyright (C) 1997,1998,1999,2000,2001,2002,2003,2005,2006
3         Free Software Foundation, Inc.
4
5    This file is part of the GNU C Library.
6
7    The GNU C Library is free software; you can redistribute it and/or
8    modify it under the terms of the GNU Lesser General Public
9    License as published by the Free Software Foundation; either
10    version 2.1 of the License, or (at your option) any later version.
11
12    The GNU C Library is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15    Lesser General Public License for more details.
16
17    You should have received a copy of the GNU Lesser General Public
18    License along with the GNU C Library; if not, write to the Free
19    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
20    02111-1307 USA.  */
21
22 #ifdef _LIBC
23 #include <stdlib.h>
24 #include <string.h>
25 #include <error.h>
26 #include <libintl.h>
27 #include <dwarf2.h>
28 #include <unwind.h>
29 #include <unwind-pe.h>
30 #include <unwind-dw2-fde.h>
31 #else
32 #include "tconfig.h"
33 #include "tsystem.h"
34 #include "dwarf2.h"
35 #include "unwind.h"
36 #include "unwind-pe.h"
37 #include "unwind-dw2-fde.h"
38 #include "gthr.h"
39 #endif
40
41
42
43 #ifndef STACK_GROWS_DOWNWARD
44 #define STACK_GROWS_DOWNWARD 0
45 #else
46 #undef STACK_GROWS_DOWNWARD
47 #define STACK_GROWS_DOWNWARD 1
48 #endif
49
50 /* A target can override (perhaps for backward compatibility) how
51    many dwarf2 columns are unwound.  */
52 #ifndef DWARF_FRAME_REGISTERS
53 #define DWARF_FRAME_REGISTERS FIRST_PSEUDO_REGISTER
54 #endif
55
56 /* Dwarf frame registers used for pre gcc 3.0 compiled glibc.  */
57 #ifndef PRE_GCC3_DWARF_FRAME_REGISTERS
58 #define PRE_GCC3_DWARF_FRAME_REGISTERS DWARF_FRAME_REGISTERS
59 #endif
60
61 /* This is the register and unwind state for a particular frame.  This
62    provides the information necessary to unwind up past a frame and return
63    to its caller.  */
64 struct _Unwind_Context
65 {
66   void *reg[DWARF_FRAME_REGISTERS+1];
67   void *cfa;
68   void *ra;
69   void *lsda;
70   struct dwarf_eh_bases bases;
71   _Unwind_Word args_size;
72 };
73
74 #ifndef _LIBC
75 /* Byte size of every register managed by these routines.  */
76 static unsigned char dwarf_reg_size_table[DWARF_FRAME_REGISTERS];
77 #endif
78
79 \f
80 /* The result of interpreting the frame unwind info for a frame.
81    This is all symbolic at this point, as none of the values can
82    be resolved until the target pc is located.  */
83 typedef struct
84 {
85   /* Each register save state can be described in terms of a CFA slot,
86      another register, or a location expression.  */
87   struct frame_state_reg_info
88   {
89     struct {
90       union {
91         _Unwind_Word reg;
92         _Unwind_Sword offset;
93         const unsigned char *exp;
94       } loc;
95       enum {
96         REG_UNSAVED,
97         REG_SAVED_OFFSET,
98         REG_SAVED_REG,
99         REG_SAVED_EXP,
100       } how;
101     } reg[DWARF_FRAME_REGISTERS+1];
102
103     /* Used to implement DW_CFA_remember_state.  */
104     struct frame_state_reg_info *prev;
105   } regs;
106
107   /* The CFA can be described in terms of a reg+offset or a
108      location expression.  */
109   _Unwind_Sword cfa_offset;
110   _Unwind_Word cfa_reg;
111   const unsigned char *cfa_exp;
112   enum {
113     CFA_UNSET,
114     CFA_REG_OFFSET,
115     CFA_EXP,
116   } cfa_how;
117
118   /* The PC described by the current frame state.  */
119   void *pc;
120
121   /* The information we care about from the CIE/FDE.  */
122   _Unwind_Personality_Fn personality;
123   _Unwind_Sword data_align;
124   _Unwind_Word code_align;
125   unsigned char retaddr_column;
126   unsigned char fde_encoding;
127   unsigned char lsda_encoding;
128   unsigned char saw_z;
129   void *eh_ptr;
130 } _Unwind_FrameState;
131 \f
132 /* Read unaligned data from the instruction buffer.  */
133
134 union unaligned
135 {
136   void *p;
137   unsigned u2 __attribute__ ((mode (HI)));
138   unsigned u4 __attribute__ ((mode (SI)));
139   unsigned u8 __attribute__ ((mode (DI)));
140   signed s2 __attribute__ ((mode (HI)));
141   signed s4 __attribute__ ((mode (SI)));
142   signed s8 __attribute__ ((mode (DI)));
143 } __attribute__ ((packed));
144
145 static inline void *
146 read_pointer (const void *p) { const union unaligned *up = p; return up->p; }
147
148 static inline int
149 read_1u (const void *p) { return *(const unsigned char *) p; }
150
151 static inline int
152 read_1s (const void *p) { return *(const signed char *) p; }
153
154 static inline int
155 read_2u (const void *p) { const union unaligned *up = p; return up->u2; }
156
157 static inline int
158 read_2s (const void *p) { const union unaligned *up = p; return up->s2; }
159
160 static inline unsigned int
161 read_4u (const void *p) { const union unaligned *up = p; return up->u4; }
162
163 static inline int
164 read_4s (const void *p) { const union unaligned *up = p; return up->s4; }
165
166 static inline unsigned long
167 read_8u (const void *p) { const union unaligned *up = p; return up->u8; }
168
169 static inline unsigned long
170 read_8s (const void *p) { const union unaligned *up = p; return up->s8; }
171 \f
172 /* Get the value of register REG as saved in CONTEXT.  */
173
174 inline _Unwind_Word
175 _Unwind_GetGR (struct _Unwind_Context *context, int index)
176 {
177   /* This will segfault if the register hasn't been saved.  */
178   return * (_Unwind_Word *) context->reg[index];
179 }
180
181 /* Get the value of the CFA as saved in CONTEXT.  */
182
183 _Unwind_Word
184 _Unwind_GetCFA (struct _Unwind_Context *context)
185 {
186   return (_Unwind_Ptr) context->cfa;
187 }
188
189 /* Overwrite the saved value for register REG in CONTEXT with VAL.  */
190
191 inline void
192 _Unwind_SetGR (struct _Unwind_Context *context, int index, _Unwind_Word val)
193 {
194   * (_Unwind_Word *) context->reg[index] = val;
195 }
196
197 /* Retrieve the return address for CONTEXT.  */
198
199 inline _Unwind_Ptr
200 _Unwind_GetIP (struct _Unwind_Context *context)
201 {
202   return (_Unwind_Ptr) context->ra;
203 }
204
205 /* Overwrite the return address for CONTEXT with VAL.  */
206
207 inline void
208 _Unwind_SetIP (struct _Unwind_Context *context, _Unwind_Ptr val)
209 {
210   context->ra = (void *) val;
211 }
212
213 void *
214 _Unwind_GetLanguageSpecificData (struct _Unwind_Context *context)
215 {
216   return context->lsda;
217 }
218
219 _Unwind_Ptr
220 _Unwind_GetRegionStart (struct _Unwind_Context *context)
221 {
222   return (_Unwind_Ptr) context->bases.func;
223 }
224
225 void *
226 _Unwind_FindEnclosingFunction (void *pc)
227 {
228   struct dwarf_eh_bases bases;
229   struct dwarf_fde *fde = _Unwind_Find_FDE (pc-1, &bases);
230   if (fde)
231     return bases.func;
232   else
233     return NULL;
234 }
235
236 #ifndef __ia64__
237 _Unwind_Ptr
238 _Unwind_GetDataRelBase (struct _Unwind_Context *context)
239 {
240   return (_Unwind_Ptr) context->bases.dbase;
241 }
242
243 _Unwind_Ptr
244 _Unwind_GetTextRelBase (struct _Unwind_Context *context)
245 {
246   return (_Unwind_Ptr) context->bases.tbase;
247 }
248 #endif
249 \f
250 /* Extract any interesting information from the CIE for the translation
251    unit F belongs to.  Return a pointer to the byte after the augmentation,
252    or NULL if we encountered an undecipherable augmentation.  */
253
254 static const unsigned char *
255 extract_cie_info (struct dwarf_cie *cie, struct _Unwind_Context *context,
256                   _Unwind_FrameState *fs)
257 {
258   const unsigned char *aug = cie->augmentation;
259   const unsigned char *p = aug + strlen ((const char *) aug) + 1;
260   const unsigned char *ret = NULL;
261   _Unwind_Word utmp;
262
263   /* g++ v2 "eh" has pointer immediately following augmentation string,
264      so it must be handled first.  */
265   if (aug[0] == 'e' && aug[1] == 'h')
266     {
267       fs->eh_ptr = read_pointer (p);
268       p += sizeof (void *);
269       aug += 2;
270     }
271
272   /* Immediately following the augmentation are the code and
273      data alignment and return address column.  */
274   p = read_uleb128 (p, &fs->code_align);
275   p = read_sleb128 (p, &fs->data_align);
276   fs->retaddr_column = *p++;
277   fs->lsda_encoding = DW_EH_PE_omit;
278
279   /* If the augmentation starts with 'z', then a uleb128 immediately
280      follows containing the length of the augmentation field following
281      the size.  */
282   if (*aug == 'z')
283     {
284       p = read_uleb128 (p, &utmp);
285       ret = p + utmp;
286
287       fs->saw_z = 1;
288       ++aug;
289     }
290
291   /* Iterate over recognized augmentation subsequences.  */
292   while (*aug != '\0')
293     {
294       /* "L" indicates a byte showing how the LSDA pointer is encoded.  */
295       if (aug[0] == 'L')
296         {
297           fs->lsda_encoding = *p++;
298           aug += 1;
299         }
300
301       /* "R" indicates a byte indicating how FDE addresses are encoded.  */
302       else if (aug[0] == 'R')
303         {
304           fs->fde_encoding = *p++;
305           aug += 1;
306         }
307
308       /* "P" indicates a personality routine in the CIE augmentation.  */
309       else if (aug[0] == 'P')
310         {
311           p = read_encoded_value (context, *p, p + 1,
312                                   (_Unwind_Ptr *) &fs->personality);
313           aug += 1;
314         }
315
316       /* Otherwise we have an unknown augmentation string.
317          Bail unless we saw a 'z' prefix.  */
318       else
319         return ret;
320     }
321
322   return ret ? ret : p;
323 }
324
325 #ifndef _LIBC
326 /* Decode a DW_OP stack program.  Return the top of stack.  Push INITIAL
327    onto the stack to start.  */
328
329 static _Unwind_Word
330 execute_stack_op (const unsigned char *op_ptr, const unsigned char *op_end,
331                   struct _Unwind_Context *context, _Unwind_Word initial)
332 {
333   _Unwind_Word stack[64];       /* ??? Assume this is enough.  */
334   int stack_elt;
335
336   stack[0] = initial;
337   stack_elt = 1;
338
339   while (op_ptr < op_end)
340     {
341       enum dwarf_location_atom op = *op_ptr++;
342       _Unwind_Word result, reg, utmp;
343       _Unwind_Sword offset, stmp;
344
345       switch (op)
346         {
347         case DW_OP_lit0:
348         case DW_OP_lit1:
349         case DW_OP_lit2:
350         case DW_OP_lit3:
351         case DW_OP_lit4:
352         case DW_OP_lit5:
353         case DW_OP_lit6:
354         case DW_OP_lit7:
355         case DW_OP_lit8:
356         case DW_OP_lit9:
357         case DW_OP_lit10:
358         case DW_OP_lit11:
359         case DW_OP_lit12:
360         case DW_OP_lit13:
361         case DW_OP_lit14:
362         case DW_OP_lit15:
363         case DW_OP_lit16:
364         case DW_OP_lit17:
365         case DW_OP_lit18:
366         case DW_OP_lit19:
367         case DW_OP_lit20:
368         case DW_OP_lit21:
369         case DW_OP_lit22:
370         case DW_OP_lit23:
371         case DW_OP_lit24:
372         case DW_OP_lit25:
373         case DW_OP_lit26:
374         case DW_OP_lit27:
375         case DW_OP_lit28:
376         case DW_OP_lit29:
377         case DW_OP_lit30:
378         case DW_OP_lit31:
379           result = op - DW_OP_lit0;
380           break;
381
382         case DW_OP_addr:
383           result = (_Unwind_Word) (_Unwind_Ptr) read_pointer (op_ptr);
384           op_ptr += sizeof (void *);
385           break;
386
387         case DW_OP_const1u:
388           result = read_1u (op_ptr);
389           op_ptr += 1;
390           break;
391         case DW_OP_const1s:
392           result = read_1s (op_ptr);
393           op_ptr += 1;
394           break;
395         case DW_OP_const2u:
396           result = read_2u (op_ptr);
397           op_ptr += 2;
398           break;
399         case DW_OP_const2s:
400           result = read_2s (op_ptr);
401           op_ptr += 2;
402           break;
403         case DW_OP_const4u:
404           result = read_4u (op_ptr);
405           op_ptr += 4;
406           break;
407         case DW_OP_const4s:
408           result = read_4s (op_ptr);
409           op_ptr += 4;
410           break;
411         case DW_OP_const8u:
412           result = read_8u (op_ptr);
413           op_ptr += 8;
414           break;
415         case DW_OP_const8s:
416           result = read_8s (op_ptr);
417           op_ptr += 8;
418           break;
419         case DW_OP_constu:
420           op_ptr = read_uleb128 (op_ptr, &result);
421           break;
422         case DW_OP_consts:
423           op_ptr = read_sleb128 (op_ptr, &stmp);
424           result = stmp;
425           break;
426
427         case DW_OP_reg0:
428         case DW_OP_reg1:
429         case DW_OP_reg2:
430         case DW_OP_reg3:
431         case DW_OP_reg4:
432         case DW_OP_reg5:
433         case DW_OP_reg6:
434         case DW_OP_reg7:
435         case DW_OP_reg8:
436         case DW_OP_reg9:
437         case DW_OP_reg10:
438         case DW_OP_reg11:
439         case DW_OP_reg12:
440         case DW_OP_reg13:
441         case DW_OP_reg14:
442         case DW_OP_reg15:
443         case DW_OP_reg16:
444         case DW_OP_reg17:
445         case DW_OP_reg18:
446         case DW_OP_reg19:
447         case DW_OP_reg20:
448         case DW_OP_reg21:
449         case DW_OP_reg22:
450         case DW_OP_reg23:
451         case DW_OP_reg24:
452         case DW_OP_reg25:
453         case DW_OP_reg26:
454         case DW_OP_reg27:
455         case DW_OP_reg28:
456         case DW_OP_reg29:
457         case DW_OP_reg30:
458         case DW_OP_reg31:
459           result = _Unwind_GetGR (context, op - DW_OP_reg0);
460           break;
461         case DW_OP_regx:
462           op_ptr = read_uleb128 (op_ptr, &reg);
463           result = _Unwind_GetGR (context, reg);
464           break;
465
466         case DW_OP_breg0:
467         case DW_OP_breg1:
468         case DW_OP_breg2:
469         case DW_OP_breg3:
470         case DW_OP_breg4:
471         case DW_OP_breg5:
472         case DW_OP_breg6:
473         case DW_OP_breg7:
474         case DW_OP_breg8:
475         case DW_OP_breg9:
476         case DW_OP_breg10:
477         case DW_OP_breg11:
478         case DW_OP_breg12:
479         case DW_OP_breg13:
480         case DW_OP_breg14:
481         case DW_OP_breg15:
482         case DW_OP_breg16:
483         case DW_OP_breg17:
484         case DW_OP_breg18:
485         case DW_OP_breg19:
486         case DW_OP_breg20:
487         case DW_OP_breg21:
488         case DW_OP_breg22:
489         case DW_OP_breg23:
490         case DW_OP_breg24:
491         case DW_OP_breg25:
492         case DW_OP_breg26:
493         case DW_OP_breg27:
494         case DW_OP_breg28:
495         case DW_OP_breg29:
496         case DW_OP_breg30:
497         case DW_OP_breg31:
498           op_ptr = read_sleb128 (op_ptr, &offset);
499           result = _Unwind_GetGR (context, op - DW_OP_breg0) + offset;
500           break;
501         case DW_OP_bregx:
502           op_ptr = read_uleb128 (op_ptr, &reg);
503           op_ptr = read_sleb128 (op_ptr, &offset);
504           result = _Unwind_GetGR (context, reg) + offset;
505           break;
506
507         case DW_OP_dup:
508           if (stack_elt < 1)
509             abort ();
510           result = stack[stack_elt - 1];
511           break;
512
513         case DW_OP_drop:
514           if (--stack_elt < 0)
515             abort ();
516           goto no_push;
517
518         case DW_OP_pick:
519           offset = *op_ptr++;
520           if (offset >= stack_elt - 1)
521             abort ();
522           result = stack[stack_elt - 1 - offset];
523           break;
524
525         case DW_OP_over:
526           if (stack_elt < 2)
527             abort ();
528           result = stack[stack_elt - 2];
529           break;
530
531         case DW_OP_rot:
532           {
533             _Unwind_Word t1, t2, t3;
534
535             if (stack_elt < 3)
536               abort ();
537             t1 = stack[stack_elt - 1];
538             t2 = stack[stack_elt - 2];
539             t3 = stack[stack_elt - 3];
540             stack[stack_elt - 1] = t2;
541             stack[stack_elt - 2] = t3;
542             stack[stack_elt - 3] = t1;
543             goto no_push;
544           }
545
546         case DW_OP_deref:
547         case DW_OP_deref_size:
548         case DW_OP_abs:
549         case DW_OP_neg:
550         case DW_OP_not:
551         case DW_OP_plus_uconst:
552           /* Unary operations.  */
553           if (--stack_elt < 0)
554             abort ();
555           result = stack[stack_elt];
556
557           switch (op)
558             {
559             case DW_OP_deref:
560               {
561                 void *ptr = (void *) (_Unwind_Ptr) result;
562                 result = (_Unwind_Ptr) read_pointer (ptr);
563               }
564               break;
565
566             case DW_OP_deref_size:
567               {
568                 void *ptr = (void *) (_Unwind_Ptr) result;
569                 switch (*op_ptr++)
570                   {
571                   case 1:
572                     result = read_1u (ptr);
573                     break;
574                   case 2:
575                     result = read_2u (ptr);
576                     break;
577                   case 4:
578                     result = read_4u (ptr);
579                     break;
580                   case 8:
581                     result = read_8u (ptr);
582                     break;
583                   default:
584                     abort ();
585                   }
586               }
587               break;
588
589             case DW_OP_abs:
590               if ((_Unwind_Sword) result < 0)
591                 result = -result;
592               break;
593             case DW_OP_neg:
594               result = -result;
595               break;
596             case DW_OP_not:
597               result = ~result;
598               break;
599             case DW_OP_plus_uconst:
600               op_ptr = read_uleb128 (op_ptr, &utmp);
601               result += utmp;
602               break;
603
604             default:
605               abort ();
606             }
607           break;
608
609         case DW_OP_and:
610         case DW_OP_div:
611         case DW_OP_minus:
612         case DW_OP_mod:
613         case DW_OP_mul:
614         case DW_OP_or:
615         case DW_OP_plus:
616         case DW_OP_le:
617         case DW_OP_ge:
618         case DW_OP_eq:
619         case DW_OP_lt:
620         case DW_OP_gt:
621         case DW_OP_ne:
622           {
623             /* Binary operations.  */
624             _Unwind_Word first, second;
625             if ((stack_elt -= 2) < 0)
626               abort ();
627             second = stack[stack_elt];
628             first = stack[stack_elt + 1];
629
630             switch (op)
631               {
632               case DW_OP_and:
633                 result = second & first;
634                 break;
635               case DW_OP_div:
636                 result = (_Unwind_Sword) second / (_Unwind_Sword) first;
637                 break;
638               case DW_OP_minus:
639                 result = second - first;
640                 break;
641               case DW_OP_mod:
642                 result = (_Unwind_Sword) second % (_Unwind_Sword) first;
643                 break;
644               case DW_OP_mul:
645                 result = second * first;
646                 break;
647               case DW_OP_or:
648                 result = second | first;
649                 break;
650               case DW_OP_plus:
651                 result = second + first;
652                 break;
653               case DW_OP_shl:
654                 result = second << first;
655                 break;
656               case DW_OP_shr:
657                 result = second >> first;
658                 break;
659               case DW_OP_shra:
660                 result = (_Unwind_Sword) second >> first;
661                 break;
662               case DW_OP_xor:
663                 result = second ^ first;
664                 break;
665               case DW_OP_le:
666                 result = (_Unwind_Sword) first <= (_Unwind_Sword) second;
667                 break;
668               case DW_OP_ge:
669                 result = (_Unwind_Sword) first >= (_Unwind_Sword) second;
670                 break;
671               case DW_OP_eq:
672                 result = (_Unwind_Sword) first == (_Unwind_Sword) second;
673                 break;
674               case DW_OP_lt:
675                 result = (_Unwind_Sword) first < (_Unwind_Sword) second;
676                 break;
677               case DW_OP_gt:
678                 result = (_Unwind_Sword) first > (_Unwind_Sword) second;
679                 break;
680               case DW_OP_ne:
681                 result = (_Unwind_Sword) first != (_Unwind_Sword) second;
682                 break;
683
684               default:
685                 abort ();
686               }
687           }
688           break;
689
690         case DW_OP_skip:
691           offset = read_2s (op_ptr);
692           op_ptr += 2;
693           op_ptr += offset;
694           goto no_push;
695
696         case DW_OP_bra:
697           if (--stack_elt < 0)
698             abort ();
699           offset = read_2s (op_ptr);
700           op_ptr += 2;
701           if (stack[stack_elt] != 0)
702             op_ptr += offset;
703           goto no_push;
704
705         case DW_OP_nop:
706           goto no_push;
707
708         default:
709           abort ();
710         }
711
712       /* Most things push a result value.  */
713       if ((size_t) stack_elt >= sizeof(stack)/sizeof(*stack))
714         abort ();
715       stack[stack_elt++] = result;
716     no_push:;
717     }
718
719   /* We were executing this program to get a value.  It should be
720      at top of stack.  */
721   if (--stack_elt < 0)
722     abort ();
723   return stack[stack_elt];
724 }
725 #endif
726
727 /* Decode DWARF 2 call frame information. Takes pointers the
728    instruction sequence to decode, current register information and
729    CIE info, and the PC range to evaluate.  */
730
731 static void
732 execute_cfa_program (const unsigned char *insn_ptr,
733                      const unsigned char *insn_end,
734                      struct _Unwind_Context *context,
735                      _Unwind_FrameState *fs)
736 {
737   struct frame_state_reg_info *unused_rs = NULL;
738
739   /* Don't allow remember/restore between CIE and FDE programs.  */
740   fs->regs.prev = NULL;
741
742   /* The comparison with the return address uses < rather than <= because
743      we are only interested in the effects of code before the call; for a
744      noreturn function, the return address may point to unrelated code with
745      a different stack configuration that we are not interested in.  We
746      assume that the call itself is unwind info-neutral; if not, or if
747      there are delay instructions that adjust the stack, these must be
748      reflected at the point immediately before the call insn.  */
749   while (insn_ptr < insn_end && fs->pc < context->ra)
750     {
751       unsigned char insn = *insn_ptr++;
752       _Unwind_Word reg, utmp;
753       _Unwind_Sword offset, stmp;
754
755       if ((insn & 0xc0) == DW_CFA_advance_loc)
756         fs->pc += (insn & 0x3f) * fs->code_align;
757       else if ((insn & 0xc0) == DW_CFA_offset)
758         {
759           reg = insn & 0x3f;
760           insn_ptr = read_uleb128 (insn_ptr, &utmp);
761           offset = (_Unwind_Sword) utmp * fs->data_align;
762           fs->regs.reg[reg].how = REG_SAVED_OFFSET;
763           fs->regs.reg[reg].loc.offset = offset;
764         }
765       else if ((insn & 0xc0) == DW_CFA_restore)
766         {
767           reg = insn & 0x3f;
768           fs->regs.reg[reg].how = REG_UNSAVED;
769         }
770       else switch (insn)
771         {
772         case DW_CFA_set_loc:
773           insn_ptr = read_encoded_value (context, fs->fde_encoding,
774                                          insn_ptr, (_Unwind_Ptr *) &fs->pc);
775           break;
776
777         case DW_CFA_advance_loc1:
778           fs->pc += read_1u (insn_ptr) * fs->code_align;
779           insn_ptr += 1;
780           break;
781         case DW_CFA_advance_loc2:
782           fs->pc += read_2u (insn_ptr) * fs->code_align;
783           insn_ptr += 2;
784           break;
785         case DW_CFA_advance_loc4:
786           fs->pc += read_4u (insn_ptr) * fs->code_align;
787           insn_ptr += 4;
788           break;
789
790         case DW_CFA_offset_extended:
791           insn_ptr = read_uleb128 (insn_ptr, &reg);
792           insn_ptr = read_uleb128 (insn_ptr, &utmp);
793           offset = (_Unwind_Sword) utmp * fs->data_align;
794           fs->regs.reg[reg].how = REG_SAVED_OFFSET;
795           fs->regs.reg[reg].loc.offset = offset;
796           break;
797
798         case DW_CFA_restore_extended:
799           insn_ptr = read_uleb128 (insn_ptr, &reg);
800           fs->regs.reg[reg].how = REG_UNSAVED;
801           break;
802
803         case DW_CFA_undefined:
804         case DW_CFA_same_value:
805           insn_ptr = read_uleb128 (insn_ptr, &reg);
806           break;
807
808         case DW_CFA_nop:
809           break;
810
811         case DW_CFA_register:
812           {
813             _Unwind_Word reg2;
814             insn_ptr = read_uleb128 (insn_ptr, &reg);
815             insn_ptr = read_uleb128 (insn_ptr, &reg2);
816             fs->regs.reg[reg].how = REG_SAVED_REG;
817             fs->regs.reg[reg].loc.reg = reg2;
818           }
819           break;
820
821         case DW_CFA_remember_state:
822           {
823             struct frame_state_reg_info *new_rs;
824             if (unused_rs)
825               {
826                 new_rs = unused_rs;
827                 unused_rs = unused_rs->prev;
828               }
829             else
830               new_rs = __builtin_alloca (sizeof (struct frame_state_reg_info));
831
832             *new_rs = fs->regs;
833             fs->regs.prev = new_rs;
834           }
835           break;
836
837         case DW_CFA_restore_state:
838           {
839             struct frame_state_reg_info *old_rs = fs->regs.prev;
840             fs->regs = *old_rs;
841             old_rs->prev = unused_rs;
842             unused_rs = old_rs;
843           }
844           break;
845
846         case DW_CFA_def_cfa:
847           insn_ptr = read_uleb128 (insn_ptr, &fs->cfa_reg);
848           insn_ptr = read_uleb128 (insn_ptr, &utmp);
849           fs->cfa_offset = utmp;
850           fs->cfa_how = CFA_REG_OFFSET;
851           break;
852
853         case DW_CFA_def_cfa_register:
854           insn_ptr = read_uleb128 (insn_ptr, &fs->cfa_reg);
855           fs->cfa_how = CFA_REG_OFFSET;
856           break;
857
858         case DW_CFA_def_cfa_offset:
859           insn_ptr = read_uleb128 (insn_ptr, &utmp);
860           fs->cfa_offset = utmp;
861           /* cfa_how deliberately not set.  */
862           break;
863
864         case DW_CFA_def_cfa_expression:
865           fs->cfa_exp = insn_ptr;
866           fs->cfa_how = CFA_EXP;
867           insn_ptr = read_uleb128 (insn_ptr, &utmp);
868           insn_ptr += utmp;
869           break;
870
871         case DW_CFA_expression:
872           insn_ptr = read_uleb128 (insn_ptr, &reg);
873           fs->regs.reg[reg].how = REG_SAVED_EXP;
874           fs->regs.reg[reg].loc.exp = insn_ptr;
875           insn_ptr = read_uleb128 (insn_ptr, &utmp);
876           insn_ptr += utmp;
877           break;
878
879           /* From the 2.1 draft.  */
880         case DW_CFA_offset_extended_sf:
881           insn_ptr = read_uleb128 (insn_ptr, &reg);
882           insn_ptr = read_sleb128 (insn_ptr, &stmp);
883           offset = stmp * fs->data_align;
884           fs->regs.reg[reg].how = REG_SAVED_OFFSET;
885           fs->regs.reg[reg].loc.offset = offset;
886           break;
887
888         case DW_CFA_def_cfa_sf:
889           insn_ptr = read_uleb128 (insn_ptr, &fs->cfa_reg);
890           insn_ptr = read_sleb128 (insn_ptr, &fs->cfa_offset);
891           fs->cfa_how = CFA_REG_OFFSET;
892           break;
893
894         case DW_CFA_def_cfa_offset_sf:
895           insn_ptr = read_sleb128 (insn_ptr, &fs->cfa_offset);
896           /* cfa_how deliberately not set.  */
897           break;
898
899         case DW_CFA_GNU_window_save:
900           /* ??? Hardcoded for SPARC register window configuration.
901              At least do not do anything for archs which explicitly
902              define a lower register number.  */
903 #if DWARF_FRAME_REGISTERS < 32
904           for (reg = 16; reg < 32; ++reg)
905             {
906               fs->regs.reg[reg].how = REG_SAVED_OFFSET;
907               fs->regs.reg[reg].loc.offset = (reg - 16) * sizeof (void *);
908             }
909 #endif
910           break;
911
912         case DW_CFA_GNU_args_size:
913           insn_ptr = read_uleb128 (insn_ptr, &context->args_size);
914           break;
915
916         case DW_CFA_GNU_negative_offset_extended:
917           /* Obsoleted by DW_CFA_offset_extended_sf, but used by
918              older PowerPC code.  */
919           insn_ptr = read_uleb128 (insn_ptr, &reg);
920           insn_ptr = read_uleb128 (insn_ptr, &utmp);
921           offset = (_Unwind_Word) utmp * fs->data_align;
922           fs->regs.reg[reg].how = REG_SAVED_OFFSET;
923           fs->regs.reg[reg].loc.offset = -offset;
924           break;
925
926         default:
927           abort ();
928         }
929     }
930 }
931 \f
932 /* Given the _Unwind_Context CONTEXT for a stack frame, look up the FDE for
933    its caller and decode it into FS.  This function also sets the
934    args_size and lsda members of CONTEXT, as they are really information
935    about the caller's frame.  */
936
937 static _Unwind_Reason_Code
938 uw_frame_state_for (struct _Unwind_Context *context, _Unwind_FrameState *fs)
939 {
940   struct dwarf_fde *fde;
941   struct dwarf_cie *cie;
942   const unsigned char *aug, *insn, *end;
943
944   memset (fs, 0, sizeof (*fs));
945   context->args_size = 0;
946   context->lsda = 0;
947
948   fde = _Unwind_Find_FDE (context->ra - 1, &context->bases);
949   if (fde == NULL)
950     {
951       /* Couldn't find frame unwind info for this function.  Try a
952          target-specific fallback mechanism.  This will necessarily
953          not provide a personality routine or LSDA.  */
954 #ifdef MD_FALLBACK_FRAME_STATE_FOR
955       MD_FALLBACK_FRAME_STATE_FOR (context, fs, success);
956       return _URC_END_OF_STACK;
957     success:
958       return _URC_NO_REASON;
959 #else
960       return _URC_END_OF_STACK;
961 #endif
962     }
963
964   fs->pc = context->bases.func;
965
966   cie = get_cie (fde);
967   insn = extract_cie_info (cie, context, fs);
968   if (insn == NULL)
969     /* CIE contained unknown augmentation.  */
970     return _URC_FATAL_PHASE1_ERROR;
971
972   /* First decode all the insns in the CIE.  */
973   end = (unsigned char *) next_fde ((struct dwarf_fde *) cie);
974   execute_cfa_program (insn, end, context, fs);
975
976   /* Locate augmentation for the fde.  */
977   aug = (unsigned char *) fde + sizeof (*fde);
978   aug += 2 * size_of_encoded_value (fs->fde_encoding);
979   insn = NULL;
980   if (fs->saw_z)
981     {
982       _Unwind_Word i;
983       aug = read_uleb128 (aug, &i);
984       insn = aug + i;
985     }
986   if (fs->lsda_encoding != DW_EH_PE_omit)
987     aug = read_encoded_value (context, fs->lsda_encoding, aug,
988                               (_Unwind_Ptr *) &context->lsda);
989
990   /* Then the insns in the FDE up to our target PC.  */
991   if (insn == NULL)
992     insn = aug;
993   end = (unsigned char *) next_fde (fde);
994   execute_cfa_program (insn, end, context, fs);
995
996   return _URC_NO_REASON;
997 }
998 \f
999 typedef struct frame_state
1000 {
1001   void *cfa;
1002   void *eh_ptr;
1003   long cfa_offset;
1004   long args_size;
1005   long reg_or_offset[PRE_GCC3_DWARF_FRAME_REGISTERS+1];
1006   unsigned short cfa_reg;
1007   unsigned short retaddr_column;
1008   char saved[PRE_GCC3_DWARF_FRAME_REGISTERS+1];
1009 } frame_state;
1010
1011 #ifndef STATIC
1012 # define STATIC
1013 #endif
1014
1015 STATIC
1016 struct frame_state * __frame_state_for (void *, struct frame_state *);
1017
1018 /* Called from pre-G++ 3.0 __throw to find the registers to restore for
1019    a given PC_TARGET.  The caller should allocate a local variable of
1020    `struct frame_state' and pass its address to STATE_IN.  */
1021
1022 STATIC
1023 struct frame_state *
1024 __frame_state_for (void *pc_target, struct frame_state *state_in)
1025 {
1026   struct _Unwind_Context context;
1027   _Unwind_FrameState fs;
1028   int reg;
1029
1030   memset (&context, 0, sizeof (struct _Unwind_Context));
1031   context.ra = pc_target + 1;
1032
1033   if (uw_frame_state_for (&context, &fs) != _URC_NO_REASON)
1034     return 0;
1035
1036   /* We have no way to pass a location expression for the CFA to our
1037      caller.  It wouldn't understand it anyway.  */
1038   if (fs.cfa_how == CFA_EXP)
1039     return 0;
1040
1041   for (reg = 0; reg < PRE_GCC3_DWARF_FRAME_REGISTERS + 1; reg++)
1042     {
1043       state_in->saved[reg] = fs.regs.reg[reg].how;
1044       switch (state_in->saved[reg])
1045         {
1046         case REG_SAVED_REG:
1047           state_in->reg_or_offset[reg] = fs.regs.reg[reg].loc.reg;
1048           break;
1049         case REG_SAVED_OFFSET:
1050           state_in->reg_or_offset[reg] = fs.regs.reg[reg].loc.offset;
1051           break;
1052         default:
1053           state_in->reg_or_offset[reg] = 0;
1054           break;
1055         }
1056     }
1057
1058   state_in->cfa_offset = fs.cfa_offset;
1059   state_in->cfa_reg = fs.cfa_reg;
1060   state_in->retaddr_column = fs.retaddr_column;
1061   state_in->args_size = context.args_size;
1062   state_in->eh_ptr = fs.eh_ptr;
1063
1064   return state_in;
1065 }
1066 \f
1067 #ifndef _LIBC
1068
1069 static void
1070 uw_update_context_1 (struct _Unwind_Context *context, _Unwind_FrameState *fs)
1071 {
1072   struct _Unwind_Context orig_context = *context;
1073   void *cfa;
1074   long i;
1075
1076 #ifdef EH_RETURN_STACKADJ_RTX
1077   /* Special handling here: Many machines do not use a frame pointer,
1078      and track the CFA only through offsets from the stack pointer from
1079      one frame to the next.  In this case, the stack pointer is never
1080      stored, so it has no saved address in the context.  What we do
1081      have is the CFA from the previous stack frame.
1082
1083      In very special situations (such as unwind info for signal return),
1084      there may be location expressions that use the stack pointer as well.
1085
1086      Do this conditionally for one frame.  This allows the unwind info
1087      for one frame to save a copy of the stack pointer from the previous
1088      frame, and be able to use much easier CFA mechanisms to do it.
1089      Always zap the saved stack pointer value for the next frame; carrying
1090      the value over from one frame to another doesn't make sense.  */
1091
1092   _Unwind_Word tmp_sp;
1093
1094   if (!orig_context.reg[__builtin_dwarf_sp_column ()])
1095     {
1096       tmp_sp = (_Unwind_Ptr) context->cfa;
1097       orig_context.reg[__builtin_dwarf_sp_column ()] = &tmp_sp;
1098     }
1099   context->reg[__builtin_dwarf_sp_column ()] = NULL;
1100 #endif
1101
1102   /* Compute this frame's CFA.  */
1103   switch (fs->cfa_how)
1104     {
1105     case CFA_REG_OFFSET:
1106       cfa = (void *) (_Unwind_Ptr) _Unwind_GetGR (&orig_context, fs->cfa_reg);
1107       cfa += fs->cfa_offset;
1108       break;
1109
1110     case CFA_EXP:
1111       {
1112         const unsigned char *exp = fs->cfa_exp;
1113         _Unwind_Word len;
1114
1115         exp = read_uleb128 (exp, &len);
1116         cfa = (void *) (_Unwind_Ptr)
1117           execute_stack_op (exp, exp + len, &orig_context, 0);
1118         break;
1119       }
1120
1121     default:
1122       abort ();
1123     }
1124   context->cfa = cfa;
1125
1126   /* Compute the addresses of all registers saved in this frame.  */
1127   for (i = 0; i < DWARF_FRAME_REGISTERS + 1; ++i)
1128     switch (fs->regs.reg[i].how)
1129       {
1130       case REG_UNSAVED:
1131         break;
1132
1133       case REG_SAVED_OFFSET:
1134         context->reg[i] = cfa + fs->regs.reg[i].loc.offset;
1135         break;
1136
1137       case REG_SAVED_REG:
1138         context->reg[i] = orig_context.reg[fs->regs.reg[i].loc.reg];
1139         break;
1140
1141       case REG_SAVED_EXP:
1142         {
1143           const unsigned char *exp = fs->regs.reg[i].loc.exp;
1144           _Unwind_Word len;
1145           _Unwind_Ptr val;
1146
1147           exp = read_uleb128 (exp, &len);
1148           val = execute_stack_op (exp, exp + len, &orig_context,
1149                                   (_Unwind_Ptr) cfa);
1150           context->reg[i] = (void *) val;
1151         }
1152         break;
1153       }
1154 }
1155
1156 /* CONTEXT describes the unwind state for a frame, and FS describes the FDE
1157    of its caller.  Update CONTEXT to refer to the caller as well.  Note
1158    that the args_size and lsda members are not updated here, but later in
1159    uw_frame_state_for.  */
1160
1161 static void
1162 uw_update_context (struct _Unwind_Context *context, _Unwind_FrameState *fs)
1163 {
1164   uw_update_context_1 (context, fs);
1165
1166   /* Compute the return address now, since the return address column
1167      can change from frame to frame.  */
1168   context->ra = __builtin_extract_return_addr
1169     ((void *) (_Unwind_Ptr) _Unwind_GetGR (context, fs->retaddr_column));
1170 }
1171 \f
1172 /* Fill in CONTEXT for top-of-stack.  The only valid registers at this
1173    level will be the return address and the CFA.  */
1174
1175 #define uw_init_context(CONTEXT)                                           \
1176   do                                                                       \
1177     {                                                                      \
1178       /* Do any necessary initialization to access arbitrary stack frames. \
1179          On the SPARC, this means flushing the register windows.  */       \
1180       __builtin_unwind_init ();                                            \
1181       uw_init_context_1 (CONTEXT, __builtin_dwarf_cfa (),                  \
1182                          __builtin_return_address (0));                    \
1183     }                                                                      \
1184   while (0)
1185
1186 static void
1187 uw_init_context_1 (struct _Unwind_Context *context,
1188                    void *outer_cfa, void *outer_ra)
1189 {
1190   void *ra = __builtin_extract_return_addr (__builtin_return_address (0));
1191   _Unwind_FrameState fs;
1192   _Unwind_Word sp_slot;
1193
1194   memset (context, 0, sizeof (struct _Unwind_Context));
1195   context->ra = ra;
1196
1197   if (uw_frame_state_for (context, &fs) != _URC_NO_REASON)
1198     abort ();
1199
1200   /* Force the frame state to use the known cfa value.  */
1201   sp_slot = (_Unwind_Ptr) outer_cfa;
1202   context->reg[__builtin_dwarf_sp_column ()] = &sp_slot;
1203   fs.cfa_how = CFA_REG_OFFSET;
1204   fs.cfa_reg = __builtin_dwarf_sp_column ();
1205   fs.cfa_offset = 0;
1206
1207   uw_update_context_1 (context, &fs);
1208
1209   /* If the return address column was saved in a register in the
1210      initialization context, then we can't see it in the given
1211      call frame data.  So have the initialization context tell us.  */
1212   context->ra = __builtin_extract_return_addr (outer_ra);
1213 }
1214
1215
1216 /* Install TARGET into CURRENT so that we can return to it.  This is a
1217    macro because __builtin_eh_return must be invoked in the context of
1218    our caller.  */
1219
1220 #define uw_install_context(CURRENT, TARGET)                              \
1221   do                                                                     \
1222     {                                                                    \
1223       long offset = uw_install_context_1 ((CURRENT), (TARGET));          \
1224       void *handler = __builtin_frob_return_addr ((TARGET)->ra);         \
1225       __builtin_eh_return (offset, handler);                             \
1226     }                                                                    \
1227   while (0)
1228
1229 static inline void
1230 init_dwarf_reg_size_table (void)
1231 {
1232   __builtin_init_dwarf_reg_size_table (dwarf_reg_size_table);
1233 }
1234
1235 static long
1236 uw_install_context_1 (struct _Unwind_Context *current,
1237                       struct _Unwind_Context *target)
1238 {
1239   long i;
1240
1241 #if __GTHREADS
1242   {
1243     static __gthread_once_t once_regsizes = __GTHREAD_ONCE_INIT;
1244     if (__gthread_once (&once_regsizes, init_dwarf_reg_size_table) != 0
1245         || dwarf_reg_size_table[0] == 0)
1246       init_dwarf_reg_size_table ();
1247   }
1248 #else
1249   if (dwarf_reg_size_table[0] == 0)
1250     init_dwarf_reg_size_table ();
1251 #endif
1252
1253   for (i = 0; i < DWARF_FRAME_REGISTERS; ++i)
1254     {
1255       void *c = current->reg[i];
1256       void *t = target->reg[i];
1257       if (t && c && t != c)
1258         memcpy (c, t, dwarf_reg_size_table[i]);
1259     }
1260
1261 #ifdef EH_RETURN_STACKADJ_RTX
1262   {
1263     void *target_cfa;
1264
1265     /* If the last frame records a saved stack pointer, use it.  */
1266     if (target->reg[__builtin_dwarf_sp_column ()])
1267       target_cfa = (void *)(_Unwind_Ptr)
1268         _Unwind_GetGR (target, __builtin_dwarf_sp_column ());
1269     else
1270       target_cfa = target->cfa;
1271
1272     /* We adjust SP by the difference between CURRENT and TARGET's CFA.  */
1273     if (STACK_GROWS_DOWNWARD)
1274       return target_cfa - current->cfa + target->args_size;
1275     else
1276       return current->cfa - target_cfa - target->args_size;
1277   }
1278 #else
1279   return 0;
1280 #endif
1281 }
1282
1283 static inline _Unwind_Ptr
1284 uw_identify_context (struct _Unwind_Context *context)
1285 {
1286   return _Unwind_GetIP (context);
1287 }
1288
1289
1290 #include "unwind.inc"
1291
1292 #endif /* _LIBC */