1/* DWARF2 exception handling and frame unwind runtime interface routines.
2   Copyright (C) 1997-2015 Free Software Foundation, Inc.
3
4   This file is part of GCC.
5
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 3, or (at your option)
9   any later version.
10
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.
15
16   Under Section 7 of GPL version 3, you are granted additional
17   permissions described in the GCC Runtime Library Exception, version
18   3.1, as published by the Free Software Foundation.
19
20   You should have received a copy of the GNU General Public License and
21   a copy of the GCC Runtime Library Exception along with this program;
22   see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23   <http://www.gnu.org/licenses/>.  */
24
25#include "tconfig.h"
26#include "tsystem.h"
27#include "coretypes.h"
28#include "tm.h"
29#include "libgcc_tm.h"
30#include "dwarf2.h"
31#include "unwind.h"
32#ifdef __USING_SJLJ_EXCEPTIONS__
33# define NO_SIZE_OF_ENCODED_VALUE
34#endif
35#include "unwind-pe.h"
36#include "unwind-dw2-fde.h"
37#include "gthr.h"
38#include "unwind-dw2.h"
39
40#ifdef HAVE_SYS_SDT_H
41#include <sys/sdt.h>
42#endif
43
44#ifndef __USING_SJLJ_EXCEPTIONS__
45
46#ifndef __LIBGCC_STACK_GROWS_DOWNWARD__
47#define __LIBGCC_STACK_GROWS_DOWNWARD__ 0
48#else
49#undef __LIBGCC_STACK_GROWS_DOWNWARD__
50#define __LIBGCC_STACK_GROWS_DOWNWARD__ 1
51#endif
52
53/* Dwarf frame registers used for pre gcc 3.0 compiled glibc.  */
54#ifndef PRE_GCC3_DWARF_FRAME_REGISTERS
55#define PRE_GCC3_DWARF_FRAME_REGISTERS __LIBGCC_DWARF_FRAME_REGISTERS__
56#endif
57
58/* ??? For the public function interfaces, we tend to gcc_assert that the
59   column numbers are in range.  For the dwarf2 unwind info this does happen,
60   although so far in a case that doesn't actually matter.
61
62   See PR49146, in which a call from x86_64 ms abi to x86_64 unix abi stores
63   the call-saved xmm registers and annotates them.  We havn't bothered
64   providing support for the xmm registers for the x86_64 port primarily
65   because the 64-bit windows targets don't use dwarf2 unwind, using sjlj or
66   SEH instead.  Adding the support for unix targets would generally be a
67   waste.  However, some runtime libraries supplied with ICC do contain such
68   an unorthodox transition, as well as the unwind info to match.  This loss
69   of register restoration doesn't matter in practice, because the exception
70   is caught in the native unix abi, where all of the xmm registers are
71   call clobbered.
72
73   Ideally, we'd record some bit to notice when we're failing to restore some
74   register recorded in the unwind info, but to do that we need annotation on
75   the unix->ms abi edge, so that we know when the register data may be
76   discarded.  And since this edge is also within the ICC library, we're
77   unlikely to be able to get the new annotation.
78
79   Barring a magic solution to restore the ms abi defined 128-bit xmm registers
80   (as distictly opposed to the full runtime width) without causing extra
81   overhead for normal unix abis, the best solution seems to be to simply
82   ignore unwind data for unknown columns.  */
83
84#define UNWIND_COLUMN_IN_RANGE(x) \
85    __builtin_expect((x) <= __LIBGCC_DWARF_FRAME_REGISTERS__, 1)
86
87#ifdef REG_VALUE_IN_UNWIND_CONTEXT
88typedef _Unwind_Word _Unwind_Context_Reg_Val;
89
90#ifndef ASSUME_EXTENDED_UNWIND_CONTEXT
91#define ASSUME_EXTENDED_UNWIND_CONTEXT 1
92#endif
93
94static inline _Unwind_Word
95_Unwind_Get_Unwind_Word (_Unwind_Context_Reg_Val val)
96{
97  return val;
98}
99
100static inline _Unwind_Context_Reg_Val
101_Unwind_Get_Unwind_Context_Reg_Val (_Unwind_Word val)
102{
103  return val;
104}
105#else
106typedef void *_Unwind_Context_Reg_Val;
107
108static inline _Unwind_Word
109_Unwind_Get_Unwind_Word (_Unwind_Context_Reg_Val val)
110{
111  return (_Unwind_Word) (_Unwind_Internal_Ptr) val;
112}
113
114static inline _Unwind_Context_Reg_Val
115_Unwind_Get_Unwind_Context_Reg_Val (_Unwind_Word val)
116{
117  return (_Unwind_Context_Reg_Val) (_Unwind_Internal_Ptr) val;
118}
119#endif
120
121#ifndef ASSUME_EXTENDED_UNWIND_CONTEXT
122#define ASSUME_EXTENDED_UNWIND_CONTEXT 0
123#endif
124
125/* This is the register and unwind state for a particular frame.  This
126   provides the information necessary to unwind up past a frame and return
127   to its caller.  */
128struct _Unwind_Context
129{
130  _Unwind_Context_Reg_Val reg[__LIBGCC_DWARF_FRAME_REGISTERS__+1];
131  void *cfa;
132  void *ra;
133  void *lsda;
134  struct dwarf_eh_bases bases;
135  /* Signal frame context.  */
136#define SIGNAL_FRAME_BIT ((~(_Unwind_Word) 0 >> 1) + 1)
137  /* Context which has version/args_size/by_value fields.  */
138#define EXTENDED_CONTEXT_BIT ((~(_Unwind_Word) 0 >> 2) + 1)
139  _Unwind_Word flags;
140  /* 0 for now, can be increased when further fields are added to
141     struct _Unwind_Context.  */
142  _Unwind_Word version;
143  _Unwind_Word args_size;
144  char by_value[__LIBGCC_DWARF_FRAME_REGISTERS__+1];
145};
146
147/* Byte size of every register managed by these routines.  */
148static unsigned char dwarf_reg_size_table[__LIBGCC_DWARF_FRAME_REGISTERS__+1];
149
150
151/* Read unaligned data from the instruction buffer.  */
152
153union unaligned
154{
155  void *p;
156  unsigned u2 __attribute__ ((mode (HI)));
157  unsigned u4 __attribute__ ((mode (SI)));
158  unsigned u8 __attribute__ ((mode (DI)));
159  signed s2 __attribute__ ((mode (HI)));
160  signed s4 __attribute__ ((mode (SI)));
161  signed s8 __attribute__ ((mode (DI)));
162} __attribute__ ((packed));
163
164static void uw_update_context (struct _Unwind_Context *, _Unwind_FrameState *);
165static _Unwind_Reason_Code uw_frame_state_for (struct _Unwind_Context *,
166					       _Unwind_FrameState *);
167
168static inline void *
169read_pointer (const void *p) { const union unaligned *up = p; return up->p; }
170
171static inline int
172read_1u (const void *p) { return *(const unsigned char *) p; }
173
174static inline int
175read_1s (const void *p) { return *(const signed char *) p; }
176
177static inline int
178read_2u (const void *p) { const union unaligned *up = p; return up->u2; }
179
180static inline int
181read_2s (const void *p) { const union unaligned *up = p; return up->s2; }
182
183static inline unsigned int
184read_4u (const void *p) { const union unaligned *up = p; return up->u4; }
185
186static inline int
187read_4s (const void *p) { const union unaligned *up = p; return up->s4; }
188
189static inline unsigned long
190read_8u (const void *p) { const union unaligned *up = p; return up->u8; }
191
192static inline unsigned long
193read_8s (const void *p) { const union unaligned *up = p; return up->s8; }
194
195static inline _Unwind_Word
196_Unwind_IsSignalFrame (struct _Unwind_Context *context)
197{
198  return (context->flags & SIGNAL_FRAME_BIT) ? 1 : 0;
199}
200
201static inline void
202_Unwind_SetSignalFrame (struct _Unwind_Context *context, int val)
203{
204  if (val)
205    context->flags |= SIGNAL_FRAME_BIT;
206  else
207    context->flags &= ~SIGNAL_FRAME_BIT;
208}
209
210static inline _Unwind_Word
211_Unwind_IsExtendedContext (struct _Unwind_Context *context)
212{
213  return (ASSUME_EXTENDED_UNWIND_CONTEXT
214	  || (context->flags & EXTENDED_CONTEXT_BIT));
215}
216
217/* Get the value of register INDEX as saved in CONTEXT.  */
218
219inline _Unwind_Word
220_Unwind_GetGR (struct _Unwind_Context *context, int index)
221{
222  int size;
223  _Unwind_Context_Reg_Val val;
224
225#ifdef DWARF_ZERO_REG
226  if (index == DWARF_ZERO_REG)
227    return 0;
228#endif
229
230  index = DWARF_REG_TO_UNWIND_COLUMN (index);
231  gcc_assert (index < (int) sizeof(dwarf_reg_size_table));
232  size = dwarf_reg_size_table[index];
233  val = context->reg[index];
234
235  if (_Unwind_IsExtendedContext (context) && context->by_value[index])
236    return _Unwind_Get_Unwind_Word (val);
237
238  /* This will segfault if the register hasn't been saved.  */
239  if (size == sizeof(_Unwind_Ptr))
240    return * (_Unwind_Ptr *) (_Unwind_Internal_Ptr) val;
241  else
242    {
243      gcc_assert (size == sizeof(_Unwind_Word));
244      return * (_Unwind_Word *) (_Unwind_Internal_Ptr) val;
245    }
246}
247
248static inline void *
249_Unwind_GetPtr (struct _Unwind_Context *context, int index)
250{
251  return (void *)(_Unwind_Ptr) _Unwind_GetGR (context, index);
252}
253
254/* Get the value of the CFA as saved in CONTEXT.  */
255
256_Unwind_Word
257_Unwind_GetCFA (struct _Unwind_Context *context)
258{
259  return (_Unwind_Ptr) context->cfa;
260}
261
262/* Overwrite the saved value for register INDEX in CONTEXT with VAL.  */
263
264inline void
265_Unwind_SetGR (struct _Unwind_Context *context, int index, _Unwind_Word val)
266{
267  int size;
268  void *ptr;
269
270  index = DWARF_REG_TO_UNWIND_COLUMN (index);
271  gcc_assert (index < (int) sizeof(dwarf_reg_size_table));
272  size = dwarf_reg_size_table[index];
273
274  if (_Unwind_IsExtendedContext (context) && context->by_value[index])
275    {
276      context->reg[index] = _Unwind_Get_Unwind_Context_Reg_Val (val);
277      return;
278    }
279
280  ptr = (void *) (_Unwind_Internal_Ptr) context->reg[index];
281
282  if (size == sizeof(_Unwind_Ptr))
283    * (_Unwind_Ptr *) ptr = val;
284  else
285    {
286      gcc_assert (size == sizeof(_Unwind_Word));
287      * (_Unwind_Word *) ptr = val;
288    }
289}
290
291/* Get the pointer to a register INDEX as saved in CONTEXT.  */
292
293static inline void *
294_Unwind_GetGRPtr (struct _Unwind_Context *context, int index)
295{
296  index = DWARF_REG_TO_UNWIND_COLUMN (index);
297  if (_Unwind_IsExtendedContext (context) && context->by_value[index])
298    return &context->reg[index];
299  return (void *) (_Unwind_Internal_Ptr) context->reg[index];
300}
301
302/* Set the pointer to a register INDEX as saved in CONTEXT.  */
303
304static inline void
305_Unwind_SetGRPtr (struct _Unwind_Context *context, int index, void *p)
306{
307  index = DWARF_REG_TO_UNWIND_COLUMN (index);
308  if (_Unwind_IsExtendedContext (context))
309    context->by_value[index] = 0;
310  context->reg[index] = (_Unwind_Context_Reg_Val) (_Unwind_Internal_Ptr) p;
311}
312
313/* Overwrite the saved value for register INDEX in CONTEXT with VAL.  */
314
315static inline void
316_Unwind_SetGRValue (struct _Unwind_Context *context, int index,
317		    _Unwind_Word val)
318{
319  index = DWARF_REG_TO_UNWIND_COLUMN (index);
320  gcc_assert (index < (int) sizeof(dwarf_reg_size_table));
321  /* Return column size may be smaller than _Unwind_Context_Reg_Val.  */
322  gcc_assert (dwarf_reg_size_table[index] <= sizeof (_Unwind_Context_Reg_Val));
323
324  context->by_value[index] = 1;
325  context->reg[index] = _Unwind_Get_Unwind_Context_Reg_Val (val);
326}
327
328/* Return nonzero if register INDEX is stored by value rather than
329   by reference.  */
330
331static inline int
332_Unwind_GRByValue (struct _Unwind_Context *context, int index)
333{
334  index = DWARF_REG_TO_UNWIND_COLUMN (index);
335  return context->by_value[index];
336}
337
338/* Retrieve the return address for CONTEXT.  */
339
340inline _Unwind_Ptr
341_Unwind_GetIP (struct _Unwind_Context *context)
342{
343  return (_Unwind_Ptr) context->ra;
344}
345
346/* Retrieve the return address and flag whether that IP is before
347   or after first not yet fully executed instruction.  */
348
349inline _Unwind_Ptr
350_Unwind_GetIPInfo (struct _Unwind_Context *context, int *ip_before_insn)
351{
352  *ip_before_insn = _Unwind_IsSignalFrame (context);
353  return (_Unwind_Ptr) context->ra;
354}
355
356/* Overwrite the return address for CONTEXT with VAL.  */
357
358inline void
359_Unwind_SetIP (struct _Unwind_Context *context, _Unwind_Ptr val)
360{
361  context->ra = (void *) val;
362}
363
364void *
365_Unwind_GetLanguageSpecificData (struct _Unwind_Context *context)
366{
367  return context->lsda;
368}
369
370_Unwind_Ptr
371_Unwind_GetRegionStart (struct _Unwind_Context *context)
372{
373  return (_Unwind_Ptr) context->bases.func;
374}
375
376void *
377_Unwind_FindEnclosingFunction (void *pc)
378{
379  struct dwarf_eh_bases bases;
380  const struct dwarf_fde *fde = _Unwind_Find_FDE (pc-1, &bases);
381  if (fde)
382    return bases.func;
383  else
384    return NULL;
385}
386
387#ifndef __ia64__
388_Unwind_Ptr
389_Unwind_GetDataRelBase (struct _Unwind_Context *context)
390{
391  return (_Unwind_Ptr) context->bases.dbase;
392}
393
394_Unwind_Ptr
395_Unwind_GetTextRelBase (struct _Unwind_Context *context)
396{
397  return (_Unwind_Ptr) context->bases.tbase;
398}
399#endif
400
401#include "md-unwind-support.h"
402
403/* Extract any interesting information from the CIE for the translation
404   unit F belongs to.  Return a pointer to the byte after the augmentation,
405   or NULL if we encountered an undecipherable augmentation.  */
406
407static const unsigned char *
408extract_cie_info (const struct dwarf_cie *cie, struct _Unwind_Context *context,
409		  _Unwind_FrameState *fs)
410{
411  const unsigned char *aug = cie->augmentation;
412  const unsigned char *p = aug + strlen ((const char *)aug) + 1;
413  const unsigned char *ret = NULL;
414  _uleb128_t utmp;
415  _sleb128_t stmp;
416
417  /* g++ v2 "eh" has pointer immediately following augmentation string,
418     so it must be handled first.  */
419  if (aug[0] == 'e' && aug[1] == 'h')
420    {
421      fs->eh_ptr = read_pointer (p);
422      p += sizeof (void *);
423      aug += 2;
424    }
425
426  /* After the augmentation resp. pointer for "eh" augmentation
427     follows for CIE version >= 4 address size byte and
428     segment size byte.  */
429  if (__builtin_expect (cie->version >= 4, 0))
430    {
431      if (p[0] != sizeof (void *) || p[1] != 0)
432	return NULL;
433      p += 2;
434    }
435  /* Immediately following this are the code and
436     data alignment and return address column.  */
437  p = read_uleb128 (p, &utmp);
438  fs->code_align = (_Unwind_Word)utmp;
439  p = read_sleb128 (p, &stmp);
440  fs->data_align = (_Unwind_Sword)stmp;
441  if (cie->version == 1)
442    fs->retaddr_column = *p++;
443  else
444    {
445      p = read_uleb128 (p, &utmp);
446      fs->retaddr_column = (_Unwind_Word)utmp;
447    }
448  fs->lsda_encoding = DW_EH_PE_omit;
449
450  /* If the augmentation starts with 'z', then a uleb128 immediately
451     follows containing the length of the augmentation field following
452     the size.  */
453  if (*aug == 'z')
454    {
455      p = read_uleb128 (p, &utmp);
456      ret = p + utmp;
457
458      fs->saw_z = 1;
459      ++aug;
460    }
461
462  /* Iterate over recognized augmentation subsequences.  */
463  while (*aug != '\0')
464    {
465      /* "L" indicates a byte showing how the LSDA pointer is encoded.  */
466      if (aug[0] == 'L')
467	{
468	  fs->lsda_encoding = *p++;
469	  aug += 1;
470	}
471
472      /* "R" indicates a byte indicating how FDE addresses are encoded.  */
473      else if (aug[0] == 'R')
474	{
475	  fs->fde_encoding = *p++;
476	  aug += 1;
477	}
478
479      /* "P" indicates a personality routine in the CIE augmentation.  */
480      else if (aug[0] == 'P')
481	{
482	  _Unwind_Ptr personality;
483
484	  p = read_encoded_value (context, *p, p + 1, &personality);
485	  fs->personality = (_Unwind_Personality_Fn) personality;
486	  aug += 1;
487	}
488
489      /* "S" indicates a signal frame.  */
490      else if (aug[0] == 'S')
491	{
492	  fs->signal_frame = 1;
493	  aug += 1;
494	}
495
496      /* Otherwise we have an unknown augmentation string.
497	 Bail unless we saw a 'z' prefix.  */
498      else
499	return ret;
500    }
501
502  return ret ? ret : p;
503}
504
505
506/* Decode a DW_OP stack program.  Return the top of stack.  Push INITIAL
507   onto the stack to start.  */
508
509static _Unwind_Word
510execute_stack_op (const unsigned char *op_ptr, const unsigned char *op_end,
511		  struct _Unwind_Context *context, _Unwind_Word initial)
512{
513  _Unwind_Word stack[64];	/* ??? Assume this is enough.  */
514  int stack_elt;
515
516  stack[0] = initial;
517  stack_elt = 1;
518
519  while (op_ptr < op_end)
520    {
521      enum dwarf_location_atom op = *op_ptr++;
522      _Unwind_Word result;
523      _uleb128_t reg, utmp;
524      _sleb128_t offset, stmp;
525
526      switch (op)
527	{
528	case DW_OP_lit0:
529	case DW_OP_lit1:
530	case DW_OP_lit2:
531	case DW_OP_lit3:
532	case DW_OP_lit4:
533	case DW_OP_lit5:
534	case DW_OP_lit6:
535	case DW_OP_lit7:
536	case DW_OP_lit8:
537	case DW_OP_lit9:
538	case DW_OP_lit10:
539	case DW_OP_lit11:
540	case DW_OP_lit12:
541	case DW_OP_lit13:
542	case DW_OP_lit14:
543	case DW_OP_lit15:
544	case DW_OP_lit16:
545	case DW_OP_lit17:
546	case DW_OP_lit18:
547	case DW_OP_lit19:
548	case DW_OP_lit20:
549	case DW_OP_lit21:
550	case DW_OP_lit22:
551	case DW_OP_lit23:
552	case DW_OP_lit24:
553	case DW_OP_lit25:
554	case DW_OP_lit26:
555	case DW_OP_lit27:
556	case DW_OP_lit28:
557	case DW_OP_lit29:
558	case DW_OP_lit30:
559	case DW_OP_lit31:
560	  result = op - DW_OP_lit0;
561	  break;
562
563	case DW_OP_addr:
564	  result = (_Unwind_Word) (_Unwind_Ptr) read_pointer (op_ptr);
565	  op_ptr += sizeof (void *);
566	  break;
567
568	case DW_OP_GNU_encoded_addr:
569	  {
570	    _Unwind_Ptr presult;
571	    op_ptr = read_encoded_value (context, *op_ptr, op_ptr+1, &presult);
572	    result = presult;
573	  }
574	  break;
575
576	case DW_OP_const1u:
577	  result = read_1u (op_ptr);
578	  op_ptr += 1;
579	  break;
580	case DW_OP_const1s:
581	  result = read_1s (op_ptr);
582	  op_ptr += 1;
583	  break;
584	case DW_OP_const2u:
585	  result = read_2u (op_ptr);
586	  op_ptr += 2;
587	  break;
588	case DW_OP_const2s:
589	  result = read_2s (op_ptr);
590	  op_ptr += 2;
591	  break;
592	case DW_OP_const4u:
593	  result = read_4u (op_ptr);
594	  op_ptr += 4;
595	  break;
596	case DW_OP_const4s:
597	  result = read_4s (op_ptr);
598	  op_ptr += 4;
599	  break;
600	case DW_OP_const8u:
601	  result = read_8u (op_ptr);
602	  op_ptr += 8;
603	  break;
604	case DW_OP_const8s:
605	  result = read_8s (op_ptr);
606	  op_ptr += 8;
607	  break;
608	case DW_OP_constu:
609	  op_ptr = read_uleb128 (op_ptr, &utmp);
610	  result = (_Unwind_Word)utmp;
611	  break;
612	case DW_OP_consts:
613	  op_ptr = read_sleb128 (op_ptr, &stmp);
614	  result = (_Unwind_Sword)stmp;
615	  break;
616
617	case DW_OP_reg0:
618	case DW_OP_reg1:
619	case DW_OP_reg2:
620	case DW_OP_reg3:
621	case DW_OP_reg4:
622	case DW_OP_reg5:
623	case DW_OP_reg6:
624	case DW_OP_reg7:
625	case DW_OP_reg8:
626	case DW_OP_reg9:
627	case DW_OP_reg10:
628	case DW_OP_reg11:
629	case DW_OP_reg12:
630	case DW_OP_reg13:
631	case DW_OP_reg14:
632	case DW_OP_reg15:
633	case DW_OP_reg16:
634	case DW_OP_reg17:
635	case DW_OP_reg18:
636	case DW_OP_reg19:
637	case DW_OP_reg20:
638	case DW_OP_reg21:
639	case DW_OP_reg22:
640	case DW_OP_reg23:
641	case DW_OP_reg24:
642	case DW_OP_reg25:
643	case DW_OP_reg26:
644	case DW_OP_reg27:
645	case DW_OP_reg28:
646	case DW_OP_reg29:
647	case DW_OP_reg30:
648	case DW_OP_reg31:
649	  result = _Unwind_GetGR (context, op - DW_OP_reg0);
650	  break;
651	case DW_OP_regx:
652	  op_ptr = read_uleb128 (op_ptr, &reg);
653	  result = _Unwind_GetGR (context, reg);
654	  break;
655
656	case DW_OP_breg0:
657	case DW_OP_breg1:
658	case DW_OP_breg2:
659	case DW_OP_breg3:
660	case DW_OP_breg4:
661	case DW_OP_breg5:
662	case DW_OP_breg6:
663	case DW_OP_breg7:
664	case DW_OP_breg8:
665	case DW_OP_breg9:
666	case DW_OP_breg10:
667	case DW_OP_breg11:
668	case DW_OP_breg12:
669	case DW_OP_breg13:
670	case DW_OP_breg14:
671	case DW_OP_breg15:
672	case DW_OP_breg16:
673	case DW_OP_breg17:
674	case DW_OP_breg18:
675	case DW_OP_breg19:
676	case DW_OP_breg20:
677	case DW_OP_breg21:
678	case DW_OP_breg22:
679	case DW_OP_breg23:
680	case DW_OP_breg24:
681	case DW_OP_breg25:
682	case DW_OP_breg26:
683	case DW_OP_breg27:
684	case DW_OP_breg28:
685	case DW_OP_breg29:
686	case DW_OP_breg30:
687	case DW_OP_breg31:
688	  op_ptr = read_sleb128 (op_ptr, &offset);
689	  result = _Unwind_GetGR (context, op - DW_OP_breg0) + offset;
690	  break;
691	case DW_OP_bregx:
692	  op_ptr = read_uleb128 (op_ptr, &reg);
693	  op_ptr = read_sleb128 (op_ptr, &offset);
694	  result = _Unwind_GetGR (context, reg) + (_Unwind_Word)offset;
695	  break;
696
697	case DW_OP_dup:
698	  gcc_assert (stack_elt);
699	  result = stack[stack_elt - 1];
700	  break;
701
702	case DW_OP_drop:
703	  gcc_assert (stack_elt);
704	  stack_elt -= 1;
705	  goto no_push;
706
707	case DW_OP_pick:
708	  offset = *op_ptr++;
709	  gcc_assert (offset < stack_elt - 1);
710	  result = stack[stack_elt - 1 - offset];
711	  break;
712
713	case DW_OP_over:
714	  gcc_assert (stack_elt >= 2);
715	  result = stack[stack_elt - 2];
716	  break;
717
718	case DW_OP_swap:
719	  {
720	    _Unwind_Word t;
721	    gcc_assert (stack_elt >= 2);
722	    t = stack[stack_elt - 1];
723	    stack[stack_elt - 1] = stack[stack_elt - 2];
724	    stack[stack_elt - 2] = t;
725	    goto no_push;
726	  }
727
728	case DW_OP_rot:
729	  {
730	    _Unwind_Word t1, t2, t3;
731
732	    gcc_assert (stack_elt >= 3);
733	    t1 = stack[stack_elt - 1];
734	    t2 = stack[stack_elt - 2];
735	    t3 = stack[stack_elt - 3];
736	    stack[stack_elt - 1] = t2;
737	    stack[stack_elt - 2] = t3;
738	    stack[stack_elt - 3] = t1;
739	    goto no_push;
740	  }
741
742	case DW_OP_deref:
743	case DW_OP_deref_size:
744	case DW_OP_abs:
745	case DW_OP_neg:
746	case DW_OP_not:
747	case DW_OP_plus_uconst:
748	  /* Unary operations.  */
749	  gcc_assert (stack_elt);
750	  stack_elt -= 1;
751
752	  result = stack[stack_elt];
753
754	  switch (op)
755	    {
756	    case DW_OP_deref:
757	      {
758		void *ptr = (void *) (_Unwind_Ptr) result;
759		result = (_Unwind_Ptr) read_pointer (ptr);
760	      }
761	      break;
762
763	    case DW_OP_deref_size:
764	      {
765		void *ptr = (void *) (_Unwind_Ptr) result;
766		switch (*op_ptr++)
767		  {
768		  case 1:
769		    result = read_1u (ptr);
770		    break;
771		  case 2:
772		    result = read_2u (ptr);
773		    break;
774		  case 4:
775		    result = read_4u (ptr);
776		    break;
777		  case 8:
778		    result = read_8u (ptr);
779		    break;
780		  default:
781		    gcc_unreachable ();
782		  }
783	      }
784	      break;
785
786	    case DW_OP_abs:
787	      if ((_Unwind_Sword) result < 0)
788		result = -result;
789	      break;
790	    case DW_OP_neg:
791	      result = -result;
792	      break;
793	    case DW_OP_not:
794	      result = ~result;
795	      break;
796	    case DW_OP_plus_uconst:
797	      op_ptr = read_uleb128 (op_ptr, &utmp);
798	      result += (_Unwind_Word)utmp;
799	      break;
800
801	    default:
802	      gcc_unreachable ();
803	    }
804	  break;
805
806	case DW_OP_and:
807	case DW_OP_div:
808	case DW_OP_minus:
809	case DW_OP_mod:
810	case DW_OP_mul:
811	case DW_OP_or:
812	case DW_OP_plus:
813	case DW_OP_shl:
814	case DW_OP_shr:
815	case DW_OP_shra:
816	case DW_OP_xor:
817	case DW_OP_le:
818	case DW_OP_ge:
819	case DW_OP_eq:
820	case DW_OP_lt:
821	case DW_OP_gt:
822	case DW_OP_ne:
823	  {
824	    /* Binary operations.  */
825	    _Unwind_Word first, second;
826	    gcc_assert (stack_elt >= 2);
827	    stack_elt -= 2;
828
829	    second = stack[stack_elt];
830	    first = stack[stack_elt + 1];
831
832	    switch (op)
833	      {
834	      case DW_OP_and:
835		result = second & first;
836		break;
837	      case DW_OP_div:
838		result = (_Unwind_Sword) second / (_Unwind_Sword) first;
839		break;
840	      case DW_OP_minus:
841		result = second - first;
842		break;
843	      case DW_OP_mod:
844		result = second % first;
845		break;
846	      case DW_OP_mul:
847		result = second * first;
848		break;
849	      case DW_OP_or:
850		result = second | first;
851		break;
852	      case DW_OP_plus:
853		result = second + first;
854		break;
855	      case DW_OP_shl:
856		result = second << first;
857		break;
858	      case DW_OP_shr:
859		result = second >> first;
860		break;
861	      case DW_OP_shra:
862		result = (_Unwind_Sword) second >> first;
863		break;
864	      case DW_OP_xor:
865		result = second ^ first;
866		break;
867	      case DW_OP_le:
868		result = (_Unwind_Sword) second <= (_Unwind_Sword) first;
869		break;
870	      case DW_OP_ge:
871		result = (_Unwind_Sword) second >= (_Unwind_Sword) first;
872		break;
873	      case DW_OP_eq:
874		result = (_Unwind_Sword) second == (_Unwind_Sword) first;
875		break;
876	      case DW_OP_lt:
877		result = (_Unwind_Sword) second < (_Unwind_Sword) first;
878		break;
879	      case DW_OP_gt:
880		result = (_Unwind_Sword) second > (_Unwind_Sword) first;
881		break;
882	      case DW_OP_ne:
883		result = (_Unwind_Sword) second != (_Unwind_Sword) first;
884		break;
885
886	      default:
887		gcc_unreachable ();
888	      }
889	  }
890	  break;
891
892	case DW_OP_skip:
893	  offset = read_2s (op_ptr);
894	  op_ptr += 2;
895	  op_ptr += offset;
896	  goto no_push;
897
898	case DW_OP_bra:
899	  gcc_assert (stack_elt);
900	  stack_elt -= 1;
901
902	  offset = read_2s (op_ptr);
903	  op_ptr += 2;
904	  if (stack[stack_elt] != 0)
905	    op_ptr += offset;
906	  goto no_push;
907
908	case DW_OP_nop:
909	  goto no_push;
910
911	default:
912	  gcc_unreachable ();
913	}
914
915      /* Most things push a result value.  */
916      gcc_assert ((size_t) stack_elt < sizeof(stack)/sizeof(*stack));
917      stack[stack_elt++] = result;
918    no_push:;
919    }
920
921  /* We were executing this program to get a value.  It should be
922     at top of stack.  */
923  gcc_assert (stack_elt);
924  stack_elt -= 1;
925  return stack[stack_elt];
926}
927
928
929/* Decode DWARF 2 call frame information. Takes pointers the
930   instruction sequence to decode, current register information and
931   CIE info, and the PC range to evaluate.  */
932
933static void
934execute_cfa_program (const unsigned char *insn_ptr,
935		     const unsigned char *insn_end,
936		     struct _Unwind_Context *context,
937		     _Unwind_FrameState *fs)
938{
939  struct frame_state_reg_info *unused_rs = NULL;
940
941  /* Don't allow remember/restore between CIE and FDE programs.  */
942  fs->regs.prev = NULL;
943
944  /* The comparison with the return address uses < rather than <= because
945     we are only interested in the effects of code before the call; for a
946     noreturn function, the return address may point to unrelated code with
947     a different stack configuration that we are not interested in.  We
948     assume that the call itself is unwind info-neutral; if not, or if
949     there are delay instructions that adjust the stack, these must be
950     reflected at the point immediately before the call insn.
951     In signal frames, return address is after last completed instruction,
952     so we add 1 to return address to make the comparison <=.  */
953  while (insn_ptr < insn_end
954	 && fs->pc < context->ra + _Unwind_IsSignalFrame (context))
955    {
956      unsigned char insn = *insn_ptr++;
957      _uleb128_t reg, utmp;
958      _sleb128_t offset, stmp;
959
960      if ((insn & 0xc0) == DW_CFA_advance_loc)
961	fs->pc += (insn & 0x3f) * fs->code_align;
962      else if ((insn & 0xc0) == DW_CFA_offset)
963	{
964	  reg = insn & 0x3f;
965	  insn_ptr = read_uleb128 (insn_ptr, &utmp);
966	  offset = (_Unwind_Sword) utmp * fs->data_align;
967	  reg = DWARF_REG_TO_UNWIND_COLUMN (reg);
968	  if (UNWIND_COLUMN_IN_RANGE (reg))
969	    {
970	      fs->regs.reg[reg].how = REG_SAVED_OFFSET;
971	      fs->regs.reg[reg].loc.offset = offset;
972	    }
973	}
974      else if ((insn & 0xc0) == DW_CFA_restore)
975	{
976	  reg = insn & 0x3f;
977	  reg = DWARF_REG_TO_UNWIND_COLUMN (reg);
978	  if (UNWIND_COLUMN_IN_RANGE (reg))
979	    fs->regs.reg[reg].how = REG_UNSAVED;
980	}
981      else switch (insn)
982	{
983	case DW_CFA_set_loc:
984	  {
985	    _Unwind_Ptr pc;
986
987	    insn_ptr = read_encoded_value (context, fs->fde_encoding,
988					   insn_ptr, &pc);
989	    fs->pc = (void *) pc;
990	  }
991	  break;
992
993	case DW_CFA_advance_loc1:
994	  fs->pc += read_1u (insn_ptr) * fs->code_align;
995	  insn_ptr += 1;
996	  break;
997	case DW_CFA_advance_loc2:
998	  fs->pc += read_2u (insn_ptr) * fs->code_align;
999	  insn_ptr += 2;
1000	  break;
1001	case DW_CFA_advance_loc4:
1002	  fs->pc += read_4u (insn_ptr) * fs->code_align;
1003	  insn_ptr += 4;
1004	  break;
1005
1006	case DW_CFA_offset_extended:
1007	  insn_ptr = read_uleb128 (insn_ptr, &reg);
1008	  insn_ptr = read_uleb128 (insn_ptr, &utmp);
1009	  offset = (_Unwind_Sword) utmp * fs->data_align;
1010	  reg = DWARF_REG_TO_UNWIND_COLUMN (reg);
1011	  if (UNWIND_COLUMN_IN_RANGE (reg))
1012	    {
1013	      fs->regs.reg[reg].how = REG_SAVED_OFFSET;
1014	      fs->regs.reg[reg].loc.offset = offset;
1015	    }
1016	  break;
1017
1018	case DW_CFA_restore_extended:
1019	  insn_ptr = read_uleb128 (insn_ptr, &reg);
1020	  /* FIXME, this is wrong; the CIE might have said that the
1021	     register was saved somewhere.  */
1022	  reg = DWARF_REG_TO_UNWIND_COLUMN (reg);
1023	  if (UNWIND_COLUMN_IN_RANGE (reg))
1024	    fs->regs.reg[reg].how = REG_UNSAVED;
1025	  break;
1026
1027	case DW_CFA_same_value:
1028	  insn_ptr = read_uleb128 (insn_ptr, &reg);
1029	  reg = DWARF_REG_TO_UNWIND_COLUMN (reg);
1030	  if (UNWIND_COLUMN_IN_RANGE (reg))
1031	    fs->regs.reg[reg].how = REG_UNSAVED;
1032	  break;
1033
1034	case DW_CFA_undefined:
1035	  insn_ptr = read_uleb128 (insn_ptr, &reg);
1036	  reg = DWARF_REG_TO_UNWIND_COLUMN (reg);
1037	  if (UNWIND_COLUMN_IN_RANGE (reg))
1038	    fs->regs.reg[reg].how = REG_UNDEFINED;
1039	  break;
1040
1041	case DW_CFA_nop:
1042	  break;
1043
1044	case DW_CFA_register:
1045	  {
1046	    _uleb128_t reg2;
1047	    insn_ptr = read_uleb128 (insn_ptr, &reg);
1048	    insn_ptr = read_uleb128 (insn_ptr, &reg2);
1049	    reg = DWARF_REG_TO_UNWIND_COLUMN (reg);
1050	    if (UNWIND_COLUMN_IN_RANGE (reg))
1051	      {
1052	        fs->regs.reg[reg].how = REG_SAVED_REG;
1053	        fs->regs.reg[reg].loc.reg = (_Unwind_Word)reg2;
1054	      }
1055	  }
1056	  break;
1057
1058	case DW_CFA_remember_state:
1059	  {
1060	    struct frame_state_reg_info *new_rs;
1061	    if (unused_rs)
1062	      {
1063		new_rs = unused_rs;
1064		unused_rs = unused_rs->prev;
1065	      }
1066	    else
1067	      new_rs = alloca (sizeof (struct frame_state_reg_info));
1068
1069	    *new_rs = fs->regs;
1070	    fs->regs.prev = new_rs;
1071	  }
1072	  break;
1073
1074	case DW_CFA_restore_state:
1075	  {
1076	    struct frame_state_reg_info *old_rs = fs->regs.prev;
1077	    fs->regs = *old_rs;
1078	    old_rs->prev = unused_rs;
1079	    unused_rs = old_rs;
1080	  }
1081	  break;
1082
1083	case DW_CFA_def_cfa:
1084	  insn_ptr = read_uleb128 (insn_ptr, &utmp);
1085	  fs->regs.cfa_reg = (_Unwind_Word)utmp;
1086	  insn_ptr = read_uleb128 (insn_ptr, &utmp);
1087	  fs->regs.cfa_offset = (_Unwind_Word)utmp;
1088	  fs->regs.cfa_how = CFA_REG_OFFSET;
1089	  break;
1090
1091	case DW_CFA_def_cfa_register:
1092	  insn_ptr = read_uleb128 (insn_ptr, &utmp);
1093	  fs->regs.cfa_reg = (_Unwind_Word)utmp;
1094	  fs->regs.cfa_how = CFA_REG_OFFSET;
1095	  break;
1096
1097	case DW_CFA_def_cfa_offset:
1098	  insn_ptr = read_uleb128 (insn_ptr, &utmp);
1099	  fs->regs.cfa_offset = utmp;
1100	  /* cfa_how deliberately not set.  */
1101	  break;
1102
1103	case DW_CFA_def_cfa_expression:
1104	  fs->regs.cfa_exp = insn_ptr;
1105	  fs->regs.cfa_how = CFA_EXP;
1106	  insn_ptr = read_uleb128 (insn_ptr, &utmp);
1107	  insn_ptr += utmp;
1108	  break;
1109
1110	case DW_CFA_expression:
1111	  insn_ptr = read_uleb128 (insn_ptr, &reg);
1112	  reg = DWARF_REG_TO_UNWIND_COLUMN (reg);
1113	  if (UNWIND_COLUMN_IN_RANGE (reg))
1114	    {
1115	      fs->regs.reg[reg].how = REG_SAVED_EXP;
1116	      fs->regs.reg[reg].loc.exp = insn_ptr;
1117	    }
1118	  insn_ptr = read_uleb128 (insn_ptr, &utmp);
1119	  insn_ptr += utmp;
1120	  break;
1121
1122	  /* Dwarf3.  */
1123	case DW_CFA_offset_extended_sf:
1124	  insn_ptr = read_uleb128 (insn_ptr, &reg);
1125	  insn_ptr = read_sleb128 (insn_ptr, &stmp);
1126	  offset = stmp * fs->data_align;
1127	  reg = DWARF_REG_TO_UNWIND_COLUMN (reg);
1128	  if (UNWIND_COLUMN_IN_RANGE (reg))
1129	    {
1130	      fs->regs.reg[reg].how = REG_SAVED_OFFSET;
1131	      fs->regs.reg[reg].loc.offset = offset;
1132	    }
1133	  break;
1134
1135	case DW_CFA_def_cfa_sf:
1136	  insn_ptr = read_uleb128 (insn_ptr, &utmp);
1137	  fs->regs.cfa_reg = (_Unwind_Word)utmp;
1138	  insn_ptr = read_sleb128 (insn_ptr, &stmp);
1139	  fs->regs.cfa_offset = (_Unwind_Sword)stmp;
1140	  fs->regs.cfa_how = CFA_REG_OFFSET;
1141	  fs->regs.cfa_offset *= fs->data_align;
1142	  break;
1143
1144	case DW_CFA_def_cfa_offset_sf:
1145	  insn_ptr = read_sleb128 (insn_ptr, &stmp);
1146	  fs->regs.cfa_offset = (_Unwind_Sword)stmp;
1147	  fs->regs.cfa_offset *= fs->data_align;
1148	  /* cfa_how deliberately not set.  */
1149	  break;
1150
1151	case DW_CFA_val_offset:
1152	  insn_ptr = read_uleb128 (insn_ptr, &reg);
1153	  insn_ptr = read_uleb128 (insn_ptr, &utmp);
1154	  offset = (_Unwind_Sword) utmp * fs->data_align;
1155	  reg = DWARF_REG_TO_UNWIND_COLUMN (reg);
1156	  if (UNWIND_COLUMN_IN_RANGE (reg))
1157	    {
1158	      fs->regs.reg[reg].how = REG_SAVED_VAL_OFFSET;
1159	      fs->regs.reg[reg].loc.offset = offset;
1160	    }
1161	  break;
1162
1163	case DW_CFA_val_offset_sf:
1164	  insn_ptr = read_uleb128 (insn_ptr, &reg);
1165	  insn_ptr = read_sleb128 (insn_ptr, &stmp);
1166	  offset = stmp * fs->data_align;
1167	  reg = DWARF_REG_TO_UNWIND_COLUMN (reg);
1168	  if (UNWIND_COLUMN_IN_RANGE (reg))
1169	    {
1170	      fs->regs.reg[reg].how = REG_SAVED_VAL_OFFSET;
1171	      fs->regs.reg[reg].loc.offset = offset;
1172	    }
1173	  break;
1174
1175	case DW_CFA_val_expression:
1176	  insn_ptr = read_uleb128 (insn_ptr, &reg);
1177	  reg = DWARF_REG_TO_UNWIND_COLUMN (reg);
1178	  if (UNWIND_COLUMN_IN_RANGE (reg))
1179	    {
1180	      fs->regs.reg[reg].how = REG_SAVED_VAL_EXP;
1181	      fs->regs.reg[reg].loc.exp = insn_ptr;
1182	    }
1183	  insn_ptr = read_uleb128 (insn_ptr, &utmp);
1184	  insn_ptr += utmp;
1185	  break;
1186
1187	case DW_CFA_GNU_window_save:
1188	  /* ??? Hardcoded for SPARC register window configuration.  */
1189	  if (__LIBGCC_DWARF_FRAME_REGISTERS__ >= 32)
1190	    for (reg = 16; reg < 32; ++reg)
1191	      {
1192		fs->regs.reg[reg].how = REG_SAVED_OFFSET;
1193		fs->regs.reg[reg].loc.offset = (reg - 16) * sizeof (void *);
1194	      }
1195	  break;
1196
1197	case DW_CFA_GNU_args_size:
1198	  insn_ptr = read_uleb128 (insn_ptr, &utmp);
1199	  context->args_size = (_Unwind_Word)utmp;
1200	  break;
1201
1202	case DW_CFA_GNU_negative_offset_extended:
1203	  /* Obsoleted by DW_CFA_offset_extended_sf, but used by
1204	     older PowerPC code.  */
1205	  insn_ptr = read_uleb128 (insn_ptr, &reg);
1206	  insn_ptr = read_uleb128 (insn_ptr, &utmp);
1207	  offset = (_Unwind_Word) utmp * fs->data_align;
1208	  reg = DWARF_REG_TO_UNWIND_COLUMN (reg);
1209	  if (UNWIND_COLUMN_IN_RANGE (reg))
1210	    {
1211	      fs->regs.reg[reg].how = REG_SAVED_OFFSET;
1212	      fs->regs.reg[reg].loc.offset = -offset;
1213	    }
1214	  break;
1215
1216	default:
1217	  gcc_unreachable ();
1218	}
1219    }
1220}
1221
1222/* Given the _Unwind_Context CONTEXT for a stack frame, look up the FDE for
1223   its caller and decode it into FS.  This function also sets the
1224   args_size and lsda members of CONTEXT, as they are really information
1225   about the caller's frame.  */
1226
1227static _Unwind_Reason_Code
1228uw_frame_state_for (struct _Unwind_Context *context, _Unwind_FrameState *fs)
1229{
1230  const struct dwarf_fde *fde;
1231  const struct dwarf_cie *cie;
1232  const unsigned char *aug, *insn, *end;
1233
1234  memset (fs, 0, sizeof (*fs));
1235  context->args_size = 0;
1236  context->lsda = 0;
1237
1238  if (context->ra == 0)
1239    return _URC_END_OF_STACK;
1240
1241  fde = _Unwind_Find_FDE (context->ra + _Unwind_IsSignalFrame (context) - 1,
1242			  &context->bases);
1243  if (fde == NULL)
1244    {
1245#ifdef MD_FALLBACK_FRAME_STATE_FOR
1246      /* Couldn't find frame unwind info for this function.  Try a
1247	 target-specific fallback mechanism.  This will necessarily
1248	 not provide a personality routine or LSDA.  */
1249      return MD_FALLBACK_FRAME_STATE_FOR (context, fs);
1250#else
1251      return _URC_END_OF_STACK;
1252#endif
1253    }
1254
1255  fs->pc = context->bases.func;
1256
1257  cie = get_cie (fde);
1258  insn = extract_cie_info (cie, context, fs);
1259  if (insn == NULL)
1260    /* CIE contained unknown augmentation.  */
1261    return _URC_FATAL_PHASE1_ERROR;
1262
1263  /* First decode all the insns in the CIE.  */
1264  end = (const unsigned char *) next_fde ((const struct dwarf_fde *) cie);
1265  execute_cfa_program (insn, end, context, fs);
1266
1267  /* Locate augmentation for the fde.  */
1268  aug = (const unsigned char *) fde + sizeof (*fde);
1269  aug += 2 * size_of_encoded_value (fs->fde_encoding);
1270  insn = NULL;
1271  if (fs->saw_z)
1272    {
1273      _uleb128_t i;
1274      aug = read_uleb128 (aug, &i);
1275      insn = aug + i;
1276    }
1277  if (fs->lsda_encoding != DW_EH_PE_omit)
1278    {
1279      _Unwind_Ptr lsda;
1280
1281      aug = read_encoded_value (context, fs->lsda_encoding, aug, &lsda);
1282      context->lsda = (void *) lsda;
1283    }
1284
1285  /* Then the insns in the FDE up to our target PC.  */
1286  if (insn == NULL)
1287    insn = aug;
1288  end = (const unsigned char *) next_fde (fde);
1289  execute_cfa_program (insn, end, context, fs);
1290
1291  return _URC_NO_REASON;
1292}
1293
1294typedef struct frame_state
1295{
1296  void *cfa;
1297  void *eh_ptr;
1298  long cfa_offset;
1299  long args_size;
1300  long reg_or_offset[PRE_GCC3_DWARF_FRAME_REGISTERS+1];
1301  unsigned short cfa_reg;
1302  unsigned short retaddr_column;
1303  char saved[PRE_GCC3_DWARF_FRAME_REGISTERS+1];
1304} frame_state;
1305
1306struct frame_state * __frame_state_for (void *, struct frame_state *);
1307
1308/* Called from pre-G++ 3.0 __throw to find the registers to restore for
1309   a given PC_TARGET.  The caller should allocate a local variable of
1310   `struct frame_state' and pass its address to STATE_IN.  */
1311
1312struct frame_state *
1313__frame_state_for (void *pc_target, struct frame_state *state_in)
1314{
1315  struct _Unwind_Context context;
1316  _Unwind_FrameState fs;
1317  int reg;
1318
1319  memset (&context, 0, sizeof (struct _Unwind_Context));
1320  if (!ASSUME_EXTENDED_UNWIND_CONTEXT)
1321    context.flags = EXTENDED_CONTEXT_BIT;
1322  context.ra = pc_target + 1;
1323
1324  if (uw_frame_state_for (&context, &fs) != _URC_NO_REASON)
1325    return 0;
1326
1327  /* We have no way to pass a location expression for the CFA to our
1328     caller.  It wouldn't understand it anyway.  */
1329  if (fs.regs.cfa_how == CFA_EXP)
1330    return 0;
1331
1332  for (reg = 0; reg < PRE_GCC3_DWARF_FRAME_REGISTERS + 1; reg++)
1333    {
1334      state_in->saved[reg] = fs.regs.reg[reg].how;
1335      switch (state_in->saved[reg])
1336	{
1337	case REG_SAVED_REG:
1338	  state_in->reg_or_offset[reg] = fs.regs.reg[reg].loc.reg;
1339	  break;
1340	case REG_SAVED_OFFSET:
1341	  state_in->reg_or_offset[reg] = fs.regs.reg[reg].loc.offset;
1342	  break;
1343	default:
1344	  state_in->reg_or_offset[reg] = 0;
1345	  break;
1346	}
1347    }
1348
1349  state_in->cfa_offset = fs.regs.cfa_offset;
1350  state_in->cfa_reg = fs.regs.cfa_reg;
1351  state_in->retaddr_column = fs.retaddr_column;
1352  state_in->args_size = context.args_size;
1353  state_in->eh_ptr = fs.eh_ptr;
1354
1355  return state_in;
1356}
1357
1358typedef union { _Unwind_Ptr ptr; _Unwind_Word word; } _Unwind_SpTmp;
1359
1360static inline void
1361_Unwind_SetSpColumn (struct _Unwind_Context *context, void *cfa,
1362		     _Unwind_SpTmp *tmp_sp)
1363{
1364  int size = dwarf_reg_size_table[__builtin_dwarf_sp_column ()];
1365
1366  if (size == sizeof(_Unwind_Ptr))
1367    tmp_sp->ptr = (_Unwind_Ptr) cfa;
1368  else
1369    {
1370      gcc_assert (size == sizeof(_Unwind_Word));
1371      tmp_sp->word = (_Unwind_Ptr) cfa;
1372    }
1373  _Unwind_SetGRPtr (context, __builtin_dwarf_sp_column (), tmp_sp);
1374}
1375
1376static void
1377uw_update_context_1 (struct _Unwind_Context *context, _Unwind_FrameState *fs)
1378{
1379  struct _Unwind_Context orig_context = *context;
1380  void *cfa;
1381  long i;
1382
1383#ifdef __LIBGCC_EH_RETURN_STACKADJ_RTX__
1384  /* Special handling here: Many machines do not use a frame pointer,
1385     and track the CFA only through offsets from the stack pointer from
1386     one frame to the next.  In this case, the stack pointer is never
1387     stored, so it has no saved address in the context.  What we do
1388     have is the CFA from the previous stack frame.
1389
1390     In very special situations (such as unwind info for signal return),
1391     there may be location expressions that use the stack pointer as well.
1392
1393     Do this conditionally for one frame.  This allows the unwind info
1394     for one frame to save a copy of the stack pointer from the previous
1395     frame, and be able to use much easier CFA mechanisms to do it.
1396     Always zap the saved stack pointer value for the next frame; carrying
1397     the value over from one frame to another doesn't make sense.  */
1398
1399  _Unwind_SpTmp tmp_sp;
1400
1401  if (!_Unwind_GetGRPtr (&orig_context, __builtin_dwarf_sp_column ()))
1402    _Unwind_SetSpColumn (&orig_context, context->cfa, &tmp_sp);
1403  _Unwind_SetGRPtr (context, __builtin_dwarf_sp_column (), NULL);
1404#endif
1405
1406  /* Compute this frame's CFA.  */
1407  switch (fs->regs.cfa_how)
1408    {
1409    case CFA_REG_OFFSET:
1410      cfa = _Unwind_GetPtr (&orig_context, fs->regs.cfa_reg);
1411      cfa += fs->regs.cfa_offset;
1412      break;
1413
1414    case CFA_EXP:
1415      {
1416	const unsigned char *exp = fs->regs.cfa_exp;
1417	_uleb128_t len;
1418
1419	exp = read_uleb128 (exp, &len);
1420	cfa = (void *) (_Unwind_Ptr)
1421	  execute_stack_op (exp, exp + len, &orig_context, 0);
1422	break;
1423      }
1424
1425    default:
1426      gcc_unreachable ();
1427    }
1428  context->cfa = cfa;
1429
1430  /* Compute the addresses of all registers saved in this frame.  */
1431  for (i = 0; i < __LIBGCC_DWARF_FRAME_REGISTERS__ + 1; ++i)
1432    switch (fs->regs.reg[i].how)
1433      {
1434      case REG_UNSAVED:
1435      case REG_UNDEFINED:
1436	break;
1437
1438      case REG_SAVED_OFFSET:
1439	_Unwind_SetGRPtr (context, i,
1440			  (void *) (cfa + fs->regs.reg[i].loc.offset));
1441	break;
1442
1443      case REG_SAVED_REG:
1444	if (_Unwind_GRByValue (&orig_context, fs->regs.reg[i].loc.reg))
1445	  _Unwind_SetGRValue (context, i,
1446			      _Unwind_GetGR (&orig_context,
1447					     fs->regs.reg[i].loc.reg));
1448	else
1449	  _Unwind_SetGRPtr (context, i,
1450			    _Unwind_GetGRPtr (&orig_context,
1451					      fs->regs.reg[i].loc.reg));
1452	break;
1453
1454      case REG_SAVED_EXP:
1455	{
1456	  const unsigned char *exp = fs->regs.reg[i].loc.exp;
1457	  _uleb128_t len;
1458	  _Unwind_Ptr val;
1459
1460	  exp = read_uleb128 (exp, &len);
1461	  val = execute_stack_op (exp, exp + len, &orig_context,
1462				  (_Unwind_Ptr) cfa);
1463	  _Unwind_SetGRPtr (context, i, (void *) val);
1464	}
1465	break;
1466
1467      case REG_SAVED_VAL_OFFSET:
1468	_Unwind_SetGRValue (context, i,
1469			    (_Unwind_Internal_Ptr)
1470			    (cfa + fs->regs.reg[i].loc.offset));
1471	break;
1472
1473      case REG_SAVED_VAL_EXP:
1474	{
1475	  const unsigned char *exp = fs->regs.reg[i].loc.exp;
1476	  _uleb128_t len;
1477	  _Unwind_Ptr val;
1478
1479	  exp = read_uleb128 (exp, &len);
1480	  val = execute_stack_op (exp, exp + len, &orig_context,
1481				  (_Unwind_Ptr) cfa);
1482	  _Unwind_SetGRValue (context, i, val);
1483	}
1484	break;
1485      }
1486
1487  _Unwind_SetSignalFrame (context, fs->signal_frame);
1488
1489#ifdef MD_FROB_UPDATE_CONTEXT
1490  MD_FROB_UPDATE_CONTEXT (context, fs);
1491#endif
1492}
1493
1494/* CONTEXT describes the unwind state for a frame, and FS describes the FDE
1495   of its caller.  Update CONTEXT to refer to the caller as well.  Note
1496   that the args_size and lsda members are not updated here, but later in
1497   uw_frame_state_for.  */
1498
1499static void
1500uw_update_context (struct _Unwind_Context *context, _Unwind_FrameState *fs)
1501{
1502  uw_update_context_1 (context, fs);
1503
1504  /* In general this unwinder doesn't make any distinction between
1505     undefined and same_value rule.  Call-saved registers are assumed
1506     to have same_value rule by default and explicit undefined
1507     rule is handled like same_value.  The only exception is
1508     DW_CFA_undefined on retaddr_column which is supposed to
1509     mark outermost frame in DWARF 3.  */
1510  if (fs->regs.reg[DWARF_REG_TO_UNWIND_COLUMN (fs->retaddr_column)].how
1511      == REG_UNDEFINED)
1512    /* uw_frame_state_for uses context->ra == 0 check to find outermost
1513       stack frame.  */
1514    context->ra = 0;
1515  else
1516    /* Compute the return address now, since the return address column
1517       can change from frame to frame.  */
1518    context->ra = __builtin_extract_return_addr
1519      (_Unwind_GetPtr (context, fs->retaddr_column));
1520}
1521
1522static void
1523uw_advance_context (struct _Unwind_Context *context, _Unwind_FrameState *fs)
1524{
1525  uw_update_context (context, fs);
1526}
1527
1528/* Fill in CONTEXT for top-of-stack.  The only valid registers at this
1529   level will be the return address and the CFA.  */
1530
1531#define uw_init_context(CONTEXT)					   \
1532  do									   \
1533    {									   \
1534      /* Do any necessary initialization to access arbitrary stack frames. \
1535	 On the SPARC, this means flushing the register windows.  */	   \
1536      __builtin_unwind_init ();						   \
1537      uw_init_context_1 (CONTEXT, __builtin_dwarf_cfa (),		   \
1538			 __builtin_return_address (0));			   \
1539    }									   \
1540  while (0)
1541
1542static inline void
1543init_dwarf_reg_size_table (void)
1544{
1545  __builtin_init_dwarf_reg_size_table (dwarf_reg_size_table);
1546}
1547
1548static void __attribute__((noinline))
1549uw_init_context_1 (struct _Unwind_Context *context,
1550		   void *outer_cfa, void *outer_ra)
1551{
1552  void *ra = __builtin_extract_return_addr (__builtin_return_address (0));
1553  _Unwind_FrameState fs;
1554  _Unwind_SpTmp sp_slot;
1555  _Unwind_Reason_Code code;
1556
1557  memset (context, 0, sizeof (struct _Unwind_Context));
1558  context->ra = ra;
1559  if (!ASSUME_EXTENDED_UNWIND_CONTEXT)
1560    context->flags = EXTENDED_CONTEXT_BIT;
1561
1562  code = uw_frame_state_for (context, &fs);
1563  gcc_assert (code == _URC_NO_REASON);
1564
1565#if __GTHREADS
1566  {
1567    static __gthread_once_t once_regsizes = __GTHREAD_ONCE_INIT;
1568    if (__gthread_once (&once_regsizes, init_dwarf_reg_size_table) != 0
1569	&& dwarf_reg_size_table[0] == 0)
1570      init_dwarf_reg_size_table ();
1571  }
1572#else
1573  if (dwarf_reg_size_table[0] == 0)
1574    init_dwarf_reg_size_table ();
1575#endif
1576
1577  /* Force the frame state to use the known cfa value.  */
1578  _Unwind_SetSpColumn (context, outer_cfa, &sp_slot);
1579  fs.regs.cfa_how = CFA_REG_OFFSET;
1580  fs.regs.cfa_reg = __builtin_dwarf_sp_column ();
1581  fs.regs.cfa_offset = 0;
1582
1583  uw_update_context_1 (context, &fs);
1584
1585  /* If the return address column was saved in a register in the
1586     initialization context, then we can't see it in the given
1587     call frame data.  So have the initialization context tell us.  */
1588  context->ra = __builtin_extract_return_addr (outer_ra);
1589}
1590
1591static void _Unwind_DebugHook (void *, void *)
1592  __attribute__ ((__noinline__, __used__, __noclone__));
1593
1594/* This function is called during unwinding.  It is intended as a hook
1595   for a debugger to intercept exceptions.  CFA is the CFA of the
1596   target frame.  HANDLER is the PC to which control will be
1597   transferred.  */
1598static void
1599_Unwind_DebugHook (void *cfa __attribute__ ((__unused__)),
1600		   void *handler __attribute__ ((__unused__)))
1601{
1602  /* We only want to use stap probes starting with v3.  Earlier
1603     versions added too much startup cost.  */
1604#if defined (HAVE_SYS_SDT_H) && defined (STAP_PROBE2) && _SDT_NOTE_TYPE >= 3
1605  STAP_PROBE2 (libgcc, unwind, cfa, handler);
1606#else
1607  asm ("");
1608#endif
1609}
1610
1611/* Install TARGET into CURRENT so that we can return to it.  This is a
1612   macro because __builtin_eh_return must be invoked in the context of
1613   our caller.  */
1614
1615#define uw_install_context(CURRENT, TARGET)				\
1616  do									\
1617    {									\
1618      long offset = uw_install_context_1 ((CURRENT), (TARGET));		\
1619      void *handler = __builtin_frob_return_addr ((TARGET)->ra);	\
1620      _Unwind_DebugHook ((TARGET)->cfa, handler);			\
1621      __builtin_eh_return (offset, handler);				\
1622    }									\
1623  while (0)
1624
1625static long
1626uw_install_context_1 (struct _Unwind_Context *current,
1627		      struct _Unwind_Context *target)
1628{
1629  long i;
1630  _Unwind_SpTmp sp_slot;
1631
1632  /* If the target frame does not have a saved stack pointer,
1633     then set up the target's CFA.  */
1634  if (!_Unwind_GetGRPtr (target, __builtin_dwarf_sp_column ()))
1635    _Unwind_SetSpColumn (target, target->cfa, &sp_slot);
1636
1637  for (i = 0; i < __LIBGCC_DWARF_FRAME_REGISTERS__; ++i)
1638    {
1639      void *c = (void *) (_Unwind_Internal_Ptr) current->reg[i];
1640      void *t = (void *) (_Unwind_Internal_Ptr)target->reg[i];
1641
1642      gcc_assert (current->by_value[i] == 0);
1643      if (target->by_value[i] && c)
1644	{
1645	  _Unwind_Word w;
1646	  _Unwind_Ptr p;
1647	  if (dwarf_reg_size_table[i] == sizeof (_Unwind_Word))
1648	    {
1649	      w = (_Unwind_Internal_Ptr) t;
1650	      memcpy (c, &w, sizeof (_Unwind_Word));
1651	    }
1652	  else
1653	    {
1654	      gcc_assert (dwarf_reg_size_table[i] == sizeof (_Unwind_Ptr));
1655	      p = (_Unwind_Internal_Ptr) t;
1656	      memcpy (c, &p, sizeof (_Unwind_Ptr));
1657	    }
1658	}
1659      else if (t && c && t != c)
1660	memcpy (c, t, dwarf_reg_size_table[i]);
1661    }
1662
1663  /* If the current frame doesn't have a saved stack pointer, then we
1664     need to rely on EH_RETURN_STACKADJ_RTX to get our target stack
1665     pointer value reloaded.  */
1666  if (!_Unwind_GetGRPtr (current, __builtin_dwarf_sp_column ()))
1667    {
1668      void *target_cfa;
1669
1670      target_cfa = _Unwind_GetPtr (target, __builtin_dwarf_sp_column ());
1671
1672      /* We adjust SP by the difference between CURRENT and TARGET's CFA.  */
1673      if (__LIBGCC_STACK_GROWS_DOWNWARD__)
1674	return target_cfa - current->cfa + target->args_size;
1675      else
1676	return current->cfa - target_cfa - target->args_size;
1677    }
1678  return 0;
1679}
1680
1681static inline _Unwind_Ptr
1682uw_identify_context (struct _Unwind_Context *context)
1683{
1684  /* The CFA is not sufficient to disambiguate the context of a function
1685     interrupted by a signal before establishing its frame and the context
1686     of the signal itself.  */
1687  if (__LIBGCC_STACK_GROWS_DOWNWARD__)
1688    return _Unwind_GetCFA (context) - _Unwind_IsSignalFrame (context);
1689  else
1690    return _Unwind_GetCFA (context) + _Unwind_IsSignalFrame (context);
1691}
1692
1693
1694#include "unwind.inc"
1695
1696#if defined (USE_GAS_SYMVER) && defined (SHARED) && defined (USE_LIBUNWIND_EXCEPTIONS)
1697alias (_Unwind_Backtrace);
1698alias (_Unwind_DeleteException);
1699alias (_Unwind_FindEnclosingFunction);
1700alias (_Unwind_ForcedUnwind);
1701alias (_Unwind_GetDataRelBase);
1702alias (_Unwind_GetTextRelBase);
1703alias (_Unwind_GetCFA);
1704alias (_Unwind_GetGR);
1705alias (_Unwind_GetIP);
1706alias (_Unwind_GetLanguageSpecificData);
1707alias (_Unwind_GetRegionStart);
1708alias (_Unwind_RaiseException);
1709alias (_Unwind_Resume);
1710alias (_Unwind_Resume_or_Rethrow);
1711alias (_Unwind_SetGR);
1712alias (_Unwind_SetIP);
1713#endif
1714
1715#endif /* !USING_SJLJ_EXCEPTIONS */
1716