gcc/unwind-dw2.c

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