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