gcc/unwind-dw2.c

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