gcc/config/ia64/unwind-ia64.c

   1 /* Subroutines needed for unwinding IA-64 standard format stack frame
   2    info for exception handling.
   3    Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2004, 2005, 2006,
   4    2009  Free Software Foundation, Inc.
   5    Contributed by Andrew MacLeod  <amacleod@cygnus.com>
   6                   Andrew Haley  <aph@cygnus.com>
   7                   David Mosberger-Tang <davidm@hpl.hp.com>
   8
   9    This file is part of GCC.
  10
  11    GCC is free software; you can redistribute it and/or modify
  12    it under the terms of the GNU General Public License as published by
  13    the Free Software Foundation; either version 3, or (at your option)
  14    any later version.
  15
  16    GCC is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19    GNU General Public License for more details.
  20
  21    Under Section 7 of GPL version 3, you are granted additional
  22    permissions described in the GCC Runtime Library Exception, version
  23    3.1, as published by the Free Software Foundation.
  24
  25    You should have received a copy of the GNU General Public License and
  26    a copy of the GCC Runtime Library Exception along with this program;
  27    see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  28    <http://www.gnu.org/licenses/>.  */
  29
  30 #include "tconfig.h"
  31 #include "tsystem.h"
  32 #include "coretypes.h"
  33 #include "tm.h"
  34 #include "unwind.h"
  35 #include "unwind-ia64.h"
  36 #include "unwind-compat.h"
  37 #include "ia64intrin.h"
  38
  39 /* This isn't thread safe, but nice for occasional tests.  */
  40 #undef ENABLE_MALLOC_CHECKING
  41
  42 #ifndef __USING_SJLJ_EXCEPTIONS__
  43
  44 #define UNW_VER(x)              ((x) >> 48)
  45 #define UNW_FLAG_MASK           0x0000ffff00000000
  46 #define UNW_FLAG_OSMASK         0x0000f00000000000
  47 #define UNW_FLAG_EHANDLER(x)    ((x) & 0x0000000100000000L)
  48 #define UNW_FLAG_UHANDLER(x)    ((x) & 0x0000000200000000L)
  49 #define UNW_LENGTH(x)           ((x) & 0x00000000ffffffffL)
  50
  51 enum unw_application_register
  52 {
  53   UNW_AR_BSP,
  54   UNW_AR_BSPSTORE,
  55   UNW_AR_PFS,
  56   UNW_AR_RNAT,
  57   UNW_AR_UNAT,
  58   UNW_AR_LC,
  59   UNW_AR_EC,
  60   UNW_AR_FPSR,
  61   UNW_AR_RSC,
  62   UNW_AR_CCV
  63 };
  64
  65 enum unw_register_index
  66 {
  67   /* Primary UNAT.  */
  68   UNW_REG_PRI_UNAT_GR,
  69   UNW_REG_PRI_UNAT_MEM,
  70
  71   /* Memory Stack.  */
  72   UNW_REG_PSP,                  /* previous memory stack pointer */
  73
  74   /* Register Stack.  */
  75   UNW_REG_BSP,                  /* register stack pointer */
  76   UNW_REG_BSPSTORE,
  77   UNW_REG_PFS,                  /* previous function state */
  78   UNW_REG_RNAT,
  79   /* Return Pointer.  */
  80   UNW_REG_RP,
  81
  82   /* Special preserved registers.  */
  83   UNW_REG_UNAT, UNW_REG_PR, UNW_REG_LC, UNW_REG_FPSR,
  84
  85   /* Non-stacked general registers.  */
  86   UNW_REG_R2,
  87   UNW_REG_R4 = UNW_REG_R2 + 2,
  88   UNW_REG_R7 = UNW_REG_R2 + 5,
  89   UNW_REG_R31 = UNW_REG_R2 + 29,
  90
  91   /* Non-stacked floating point registers.  */
  92   UNW_REG_F2,
  93   UNW_REG_F5 = UNW_REG_F2 + 3,
  94   UNW_REG_F16 = UNW_REG_F2 + 14,
  95   UNW_REG_F31 = UNW_REG_F2 + 29,
  96
  97   /* Branch registers.  */
  98   UNW_REG_B0, UNW_REG_B1,
  99   UNW_REG_B5 = UNW_REG_B1 + 4,
 100
 101   UNW_NUM_REGS
 102 };
 103
 104 enum unw_where
 105 {
 106   UNW_WHERE_NONE,       /* register isn't saved at all */
 107   UNW_WHERE_GR,         /* register is saved in a general register */
 108   UNW_WHERE_FR,         /* register is saved in a floating-point register */
 109   UNW_WHERE_BR,         /* register is saved in a branch register */
 110   UNW_WHERE_SPREL,      /* register is saved on memstack (sp-relative) */
 111   UNW_WHERE_PSPREL,     /* register is saved on memstack (psp-relative) */
 112
 113  /* At the end of each prologue these locations get resolved to
 114      UNW_WHERE_PSPREL and UNW_WHERE_GR, respectively.  */
 115   UNW_WHERE_SPILL_HOME, /* register is saved in its spill home */
 116   UNW_WHERE_GR_SAVE     /* register is saved in next general register */
 117 };
 118
 119 #define UNW_WHEN_NEVER  0x7fffffff
 120
 121 struct unw_reg_info
 122 {
 123   unsigned long val;            /* save location: register number or offset */
 124   enum unw_where where;         /* where the register gets saved */
 125   int when;                     /* when the register gets saved */
 126 };
 127
 128 struct unw_reg_state {
 129         struct unw_reg_state *next;     /* next (outer) element on state stack */
 130         struct unw_reg_info reg[UNW_NUM_REGS];  /* register save locations */
 131 };
 132
 133 struct unw_labeled_state {
 134         struct unw_labeled_state *next;         /* next labeled state (or NULL) */
 135         unsigned long label;                    /* label for this state */
 136         struct unw_reg_state saved_state;
 137 };
 138
 139 typedef struct unw_state_record
 140 {
 141   unsigned int first_region : 1;        /* is this the first region? */
 142   unsigned int done : 1;                /* are we done scanning descriptors? */
 143   unsigned int any_spills : 1;          /* got any register spills? */
 144   unsigned int in_body : 1;     /* are we inside a body? */
 145   unsigned int no_reg_stack_frame : 1;  /* Don't adjust bsp for i&l regs */
 146   unsigned char *imask;         /* imask of spill_mask record or NULL */
 147   unsigned long pr_val;         /* predicate values */
 148   unsigned long pr_mask;        /* predicate mask */
 149   long spill_offset;            /* psp-relative offset for spill base */
 150   int region_start;
 151   int region_len;
 152   int epilogue_start;
 153   int epilogue_count;
 154   int when_target;
 155
 156   unsigned char gr_save_loc;    /* next general register to use for saving */
 157   unsigned char return_link_reg; /* branch register for return link */
 158   unsigned short unwabi;
 159
 160   struct unw_labeled_state *labeled_states;     /* list of all labeled states */
 161   struct unw_reg_state curr;    /* current state */
 162
 163   _Unwind_Personality_Fn personality;
 164
 165 } _Unwind_FrameState;
 166
 167 enum unw_nat_type
 168 {
 169   UNW_NAT_NONE,                 /* NaT not represented */
 170   UNW_NAT_VAL,                  /* NaT represented by NaT value (fp reg) */
 171   UNW_NAT_MEMSTK,               /* NaT value is in unat word at offset OFF  */
 172   UNW_NAT_REGSTK                /* NaT is in rnat */
 173 };
 174
 175 struct unw_stack
 176 {
 177   unsigned long limit;
 178   unsigned long top;
 179 };
 180
 181 struct _Unwind_Context
 182 {
 183   /* Initial frame info.  */
 184   unsigned long rnat;           /* rse nat collection */
 185   unsigned long regstk_top;     /* lowest address of rbs stored register
 186                                    which uses context->rnat collection */
 187
 188   /* Current frame info.  */
 189   unsigned long bsp;            /* backing store pointer value
 190                                    corresponding to psp.  */
 191   unsigned long sp;             /* stack pointer value */
 192   unsigned long psp;            /* previous sp value */
 193   unsigned long rp;             /* return pointer */
 194   unsigned long pr;             /* predicate collection */
 195
 196   unsigned long region_start;   /* start of unwind region */
 197   unsigned long gp;             /* global pointer value */
 198   void *lsda;                   /* language specific data area */
 199
 200   /* Preserved state.  */
 201   unsigned long *bsp_loc;       /* previous bsp save location
 202                                    Appears to be write-only?    */
 203   unsigned long *bspstore_loc;
 204   unsigned long *pfs_loc;       /* Save location for pfs in current
 205                                    (corr. to sp) frame.  Target
 206                                    contains cfm for caller.     */
 207   unsigned long *signal_pfs_loc;/* Save location for pfs in current
 208                                    signal frame.  Target contains
 209                                    pfs for caller.  */
 210   unsigned long *pri_unat_loc;
 211   unsigned long *unat_loc;
 212   unsigned long *lc_loc;
 213   unsigned long *fpsr_loc;
 214
 215   unsigned long eh_data[4];
 216
 217   struct unw_ireg
 218   {
 219     unsigned long *loc;
 220     struct unw_ireg_nat
 221     {
 222       enum unw_nat_type type : 3;
 223       signed long off : 61;             /* NaT word is at loc+nat.off */
 224     } nat;
 225   } ireg[32 - 2];       /* Indexed by <register number> - 2 */
 226
 227   unsigned long *br_loc[8];
 228   void *fr_loc[32 - 2];
 229
 230   /* ??? We initially point pri_unat_loc here.  The entire NAT bit
 231      logic needs work.  */
 232   unsigned long initial_unat;
 233 };
 234
 235 typedef unsigned long unw_word;
 236
 237 /* Implicit register save order.  See section 11.4.2.3 Rules for Using
 238    Unwind Descriptors, rule 3.  */
 239
 240 static unsigned char const save_order[] =
 241 {
 242   UNW_REG_RP, UNW_REG_PFS, UNW_REG_PSP, UNW_REG_PR,
 243   UNW_REG_UNAT, UNW_REG_LC, UNW_REG_FPSR, UNW_REG_PRI_UNAT_GR
 244 };
 245
 246 \f
 247 #define MIN(X, Y) ((X) < (Y) ? (X) : (Y))
 248
 249 /* MASK is a bitmap describing the allocation state of emergency buffers,
 250    with bit set indicating free. Return >= 0 if allocation is successful;
 251    < 0 if failure.  */
 252
 253 static inline int
 254 atomic_alloc (unsigned int *mask)
 255 {
 256   unsigned int old = *mask, ret, new;
 257
 258   while (1)
 259     {
 260       if (old == 0)
 261         return -1;
 262       ret = old & -old;
 263       new = old & ~ret;
 264       new = __sync_val_compare_and_swap (mask, old, new);
 265       if (old == new)
 266         break;
 267       old = new;
 268     }
 269
 270   return __builtin_ffs (ret) - 1;
 271 }
 272
 273 /* Similarly, free an emergency buffer.  */
 274
 275 static inline void
 276 atomic_free (unsigned int *mask, int bit)
 277 {
 278   __sync_xor_and_fetch (mask, 1 << bit);
 279 }
 280
 281
 282 #define SIZE(X)         (sizeof(X) / sizeof(*(X)))
 283 #define MASK_FOR(X)     ((2U << (SIZE (X) - 1)) - 1)
 284 #define PTR_IN(X, P)    ((P) >= (X) && (P) < (X) + SIZE (X))
 285
 286 static struct unw_reg_state emergency_reg_state[32];
 287 static unsigned int emergency_reg_state_free = MASK_FOR (emergency_reg_state);
 288
 289 static struct unw_labeled_state emergency_labeled_state[8];
 290 static unsigned int emergency_labeled_state_free = MASK_FOR (emergency_labeled_state);
 291
 292 #ifdef ENABLE_MALLOC_CHECKING
 293 static int reg_state_alloced;
 294 static int labeled_state_alloced;
 295 #endif
 296
 297 /* Allocation and deallocation of structures.  */
 298
 299 static struct unw_reg_state *
 300 alloc_reg_state (void)
 301 {
 302   struct unw_reg_state *rs;
 303
 304 #ifdef ENABLE_MALLOC_CHECKING
 305   reg_state_alloced++;
 306 #endif
 307
 308   rs = malloc (sizeof (struct unw_reg_state));
 309   if (!rs)
 310     {
 311       int n = atomic_alloc (&emergency_reg_state_free);
 312       if (n >= 0)
 313         rs = &emergency_reg_state[n];
 314     }
 315
 316   return rs;
 317 }
 318
 319 static void
 320 free_reg_state (struct unw_reg_state *rs)
 321 {
 322 #ifdef ENABLE_MALLOC_CHECKING
 323   reg_state_alloced--;
 324 #endif
 325
 326   if (PTR_IN (emergency_reg_state, rs))
 327     atomic_free (&emergency_reg_state_free, rs - emergency_reg_state);
 328   else
 329     free (rs);
 330 }
 331
 332 static struct unw_labeled_state *
 333 alloc_label_state (void)
 334 {
 335   struct unw_labeled_state *ls;
 336
 337 #ifdef ENABLE_MALLOC_CHECKING
 338   labeled_state_alloced++;
 339 #endif
 340
 341   ls = malloc(sizeof(struct unw_labeled_state));
 342   if (!ls)
 343     {
 344       int n = atomic_alloc (&emergency_labeled_state_free);
 345       if (n >= 0)
 346         ls = &emergency_labeled_state[n];
 347     }
 348
 349   return ls;
 350 }
 351
 352 static void
 353 free_label_state (struct unw_labeled_state *ls)
 354 {
 355 #ifdef ENABLE_MALLOC_CHECKING
 356   labeled_state_alloced--;
 357 #endif
 358
 359   if (PTR_IN (emergency_labeled_state, ls))
 360     atomic_free (&emergency_labeled_state_free, emergency_labeled_state - ls);
 361   else
 362     free (ls);
 363 }
 364
 365 /* Routines to manipulate the state stack.  */
 366
 367 static void
 368 push (struct unw_state_record *sr)
 369 {
 370   struct unw_reg_state *rs = alloc_reg_state ();
 371   memcpy (rs, &sr->curr, sizeof (*rs));
 372   sr->curr.next = rs;
 373 }
 374
 375 static void
 376 pop (struct unw_state_record *sr)
 377 {
 378   struct unw_reg_state *rs = sr->curr.next;
 379
 380   if (!rs)
 381     abort ();
 382   memcpy (&sr->curr, rs, sizeof(*rs));
 383   free_reg_state (rs);
 384 }
 385
 386 /* Make a copy of the state stack.  Non-recursive to avoid stack overflows.  */
 387
 388 static struct unw_reg_state *
 389 dup_state_stack (struct unw_reg_state *rs)
 390 {
 391   struct unw_reg_state *copy, *prev = NULL, *first = NULL;
 392
 393   while (rs)
 394     {
 395       copy = alloc_reg_state ();
 396       memcpy (copy, rs, sizeof(*copy));
 397       if (first)
 398         prev->next = copy;
 399       else
 400         first = copy;
 401       rs = rs->next;
 402       prev = copy;
 403     }
 404
 405   return first;
 406 }
 407
 408 /* Free all stacked register states (but not RS itself).  */
 409 static void
 410 free_state_stack (struct unw_reg_state *rs)
 411 {
 412   struct unw_reg_state *p, *next;
 413
 414   for (p = rs->next; p != NULL; p = next)
 415     {
 416       next = p->next;
 417       free_reg_state (p);
 418     }
 419   rs->next = NULL;
 420 }
 421
 422 /* Free all labeled states.  */
 423
 424 static void
 425 free_label_states (struct unw_labeled_state *ls)
 426 {
 427   struct unw_labeled_state *next;
 428
 429   for (; ls ; ls = next)
 430     {
 431       next = ls->next;
 432
 433       free_state_stack (&ls->saved_state);
 434       free_label_state (ls);
 435     }
 436 }
 437 \f
 438 /* Unwind decoder routines */
 439
 440 static enum unw_register_index __attribute__((const))
 441 decode_abreg (unsigned char abreg, int memory)
 442 {
 443   switch (abreg)
 444     {
 445     case 0x04 ... 0x07: return UNW_REG_R4 + (abreg - 0x04);
 446     case 0x22 ... 0x25: return UNW_REG_F2 + (abreg - 0x22);
 447     case 0x30 ... 0x3f: return UNW_REG_F16 + (abreg - 0x30);
 448     case 0x41 ... 0x45: return UNW_REG_B1 + (abreg - 0x41);
 449     case 0x60: return UNW_REG_PR;
 450     case 0x61: return UNW_REG_PSP;
 451     case 0x62: return memory ? UNW_REG_PRI_UNAT_MEM : UNW_REG_PRI_UNAT_GR;
 452     case 0x63: return UNW_REG_RP;
 453     case 0x64: return UNW_REG_BSP;
 454     case 0x65: return UNW_REG_BSPSTORE;
 455     case 0x66: return UNW_REG_RNAT;
 456     case 0x67: return UNW_REG_UNAT;
 457     case 0x68: return UNW_REG_FPSR;
 458     case 0x69: return UNW_REG_PFS;
 459     case 0x6a: return UNW_REG_LC;
 460     default:
 461       abort ();
 462   }
 463 }
 464
 465 static void
 466 set_reg (struct unw_reg_info *reg, enum unw_where where,
 467          int when, unsigned long val)
 468 {
 469   reg->val = val;
 470   reg->where = where;
 471   if (reg->when == UNW_WHEN_NEVER)
 472     reg->when = when;
 473 }
 474
 475 static void
 476 alloc_spill_area (unsigned long *offp, unsigned long regsize,
 477                   struct unw_reg_info *lo, struct unw_reg_info *hi)
 478 {
 479   struct unw_reg_info *reg;
 480
 481   for (reg = hi; reg >= lo; --reg)
 482     {
 483       if (reg->where == UNW_WHERE_SPILL_HOME)
 484         {
 485           reg->where = UNW_WHERE_PSPREL;
 486           *offp -= regsize;
 487           reg->val = *offp;
 488         }
 489     }
 490 }
 491
 492 static inline void
 493 spill_next_when (struct unw_reg_info **regp, struct unw_reg_info *lim,
 494                  unw_word t)
 495 {
 496   struct unw_reg_info *reg;
 497
 498   for (reg = *regp; reg <= lim; ++reg)
 499     {
 500       if (reg->where == UNW_WHERE_SPILL_HOME)
 501         {
 502           reg->when = t;
 503           *regp = reg + 1;
 504           return;
 505         }
 506     }
 507   /* Excess spill.  */
 508   abort ();
 509 }
 510
 511 static void
 512 finish_prologue (struct unw_state_record *sr)
 513 {
 514   struct unw_reg_info *reg;
 515   unsigned long off;
 516   int i;
 517
 518   /* First, resolve implicit register save locations
 519      (see Section "11.4.2.3 Rules for Using Unwind Descriptors", rule 3).  */
 520
 521   for (i = 0; i < (int) sizeof (save_order); ++i)
 522     {
 523       reg = sr->curr.reg + save_order[i];
 524       if (reg->where == UNW_WHERE_GR_SAVE)
 525         {
 526           reg->where = UNW_WHERE_GR;
 527           reg->val = sr->gr_save_loc++;
 528         }
 529     }
 530
 531   /* Next, compute when the fp, general, and branch registers get saved.
 532      This must come before alloc_spill_area() because we need to know
 533      which registers are spilled to their home locations.  */
 534   if (sr->imask)
 535     {
 536       static unsigned char const limit[3] = {
 537         UNW_REG_F31, UNW_REG_R7, UNW_REG_B5
 538       };
 539
 540       unsigned char kind, mask = 0, *cp = sr->imask;
 541       int t;
 542       struct unw_reg_info *(regs[3]);
 543
 544       regs[0] = sr->curr.reg + UNW_REG_F2;
 545       regs[1] = sr->curr.reg + UNW_REG_R4;
 546       regs[2] = sr->curr.reg + UNW_REG_B1;
 547
 548       for (t = 0; t < sr->region_len; ++t)
 549         {
 550           if ((t & 3) == 0)
 551             mask = *cp++;
 552           kind = (mask >> 2*(3-(t & 3))) & 3;
 553           if (kind > 0)
 554             spill_next_when (&regs[kind - 1], sr->curr.reg + limit[kind - 1],
 555                              sr->region_start + t);
 556         }
 557     }
 558
 559   /* Next, lay out the memory stack spill area.  */
 560   if (sr->any_spills)
 561     {
 562       off = sr->spill_offset;
 563       alloc_spill_area (&off, 16, sr->curr.reg + UNW_REG_F2,
 564                         sr->curr.reg + UNW_REG_F31);
 565       alloc_spill_area (&off,  8, sr->curr.reg + UNW_REG_B1,
 566                         sr->curr.reg + UNW_REG_B5);
 567       alloc_spill_area (&off,  8, sr->curr.reg + UNW_REG_R4,
 568                         sr->curr.reg + UNW_REG_R7);
 569     }
 570 }
 571
 572 /*
 573  * Region header descriptors.
 574  */
 575
 576 static void
 577 desc_prologue (int body, unw_word rlen, unsigned char mask,
 578                unsigned char grsave, struct unw_state_record *sr)
 579 {
 580   int i;
 581
 582   if (!(sr->in_body || sr->first_region))
 583     finish_prologue (sr);
 584   sr->first_region = 0;
 585
 586   /* Check if we're done.  */
 587   if (sr->when_target < sr->region_start + sr->region_len)
 588     {
 589       sr->done = 1;
 590       return;
 591     }
 592
 593   for (i = 0; i < sr->epilogue_count; ++i)
 594     pop (sr);
 595
 596   sr->epilogue_count = 0;
 597   sr->epilogue_start = UNW_WHEN_NEVER;
 598
 599   if (!body)
 600     push (sr);
 601
 602   sr->region_start += sr->region_len;
 603   sr->region_len = rlen;
 604   sr->in_body = body;
 605
 606   if (!body)
 607     {
 608       for (i = 0; i < 4; ++i)
 609         {
 610           if (mask & 0x8)
 611             set_reg (sr->curr.reg + save_order[i], UNW_WHERE_GR,
 612                      sr->region_start + sr->region_len - 1, grsave++);
 613           mask <<= 1;
 614         }
 615       sr->gr_save_loc = grsave;
 616       sr->any_spills = 0;
 617       sr->imask = 0;
 618       sr->spill_offset = 0x10;  /* default to psp+16 */
 619     }
 620 }
 621
 622 /*
 623  * Prologue descriptors.
 624  */
 625
 626 static inline void
 627 desc_abi (unsigned char abi,
 628           unsigned char context,
 629           struct unw_state_record *sr)
 630 {
 631   sr->unwabi = (abi << 8) | context;
 632 }
 633
 634 static inline void
 635 desc_br_gr (unsigned char brmask, unsigned char gr,
 636             struct unw_state_record *sr)
 637 {
 638   int i;
 639
 640   for (i = 0; i < 5; ++i)
 641     {
 642       if (brmask & 1)
 643         set_reg (sr->curr.reg + UNW_REG_B1 + i, UNW_WHERE_GR,
 644                  sr->region_start + sr->region_len - 1, gr++);
 645       brmask >>= 1;
 646     }
 647 }
 648
 649 static inline void
 650 desc_br_mem (unsigned char brmask, struct unw_state_record *sr)
 651 {
 652   int i;
 653
 654   for (i = 0; i < 5; ++i)
 655     {
 656       if (brmask & 1)
 657         {
 658           set_reg (sr->curr.reg + UNW_REG_B1 + i, UNW_WHERE_SPILL_HOME,
 659                    sr->region_start + sr->region_len - 1, 0);
 660           sr->any_spills = 1;
 661         }
 662       brmask >>= 1;
 663     }
 664 }
 665
 666 static inline void
 667 desc_frgr_mem (unsigned char grmask, unw_word frmask,
 668                struct unw_state_record *sr)
 669 {
 670   int i;
 671
 672   for (i = 0; i < 4; ++i)
 673     {
 674       if ((grmask & 1) != 0)
 675         {
 676           set_reg (sr->curr.reg + UNW_REG_R4 + i, UNW_WHERE_SPILL_HOME,
 677                    sr->region_start + sr->region_len - 1, 0);
 678           sr->any_spills = 1;
 679         }
 680       grmask >>= 1;
 681     }
 682   for (i = 0; i < 20; ++i)
 683     {
 684       if ((frmask & 1) != 0)
 685         {
 686           enum unw_register_index base = i < 4 ? UNW_REG_F2 : UNW_REG_F16 - 4;
 687           set_reg (sr->curr.reg + base + i, UNW_WHERE_SPILL_HOME,
 688                    sr->region_start + sr->region_len - 1, 0);
 689           sr->any_spills = 1;
 690         }
 691       frmask >>= 1;
 692     }
 693 }
 694
 695 static inline void
 696 desc_fr_mem (unsigned char frmask, struct unw_state_record *sr)
 697 {
 698   int i;
 699
 700   for (i = 0; i < 4; ++i)
 701     {
 702       if ((frmask & 1) != 0)
 703         {
 704           set_reg (sr->curr.reg + UNW_REG_F2 + i, UNW_WHERE_SPILL_HOME,
 705                    sr->region_start + sr->region_len - 1, 0);
 706           sr->any_spills = 1;
 707         }
 708       frmask >>= 1;
 709     }
 710 }
 711
 712 static inline void
 713 desc_gr_gr (unsigned char grmask, unsigned char gr,
 714             struct unw_state_record *sr)
 715 {
 716   int i;
 717
 718   for (i = 0; i < 4; ++i)
 719     {
 720       if ((grmask & 1) != 0)
 721         set_reg (sr->curr.reg + UNW_REG_R4 + i, UNW_WHERE_GR,
 722                  sr->region_start + sr->region_len - 1, gr++);
 723       grmask >>= 1;
 724     }
 725 }
 726
 727 static inline void
 728 desc_gr_mem (unsigned char grmask, struct unw_state_record *sr)
 729 {
 730   int i;
 731
 732   for (i = 0; i < 4; ++i)
 733     {
 734       if ((grmask & 1) != 0)
 735         {
 736           set_reg (sr->curr.reg + UNW_REG_R4 + i, UNW_WHERE_SPILL_HOME,
 737                    sr->region_start + sr->region_len - 1, 0);
 738           sr->any_spills = 1;
 739         }
 740       grmask >>= 1;
 741     }
 742 }
 743
 744 static inline void
 745 desc_mem_stack_f (unw_word t, unw_word size, struct unw_state_record *sr)
 746 {
 747   set_reg (sr->curr.reg + UNW_REG_PSP, UNW_WHERE_NONE,
 748            sr->region_start + MIN ((int)t, sr->region_len - 1), 16*size);
 749 }
 750
 751 static inline void
 752 desc_mem_stack_v (unw_word t, struct unw_state_record *sr)
 753 {
 754   sr->curr.reg[UNW_REG_PSP].when
 755     = sr->region_start + MIN ((int)t, sr->region_len - 1);
 756 }
 757
 758 static inline void
 759 desc_reg_gr (unsigned char reg, unsigned char dst, struct unw_state_record *sr)
 760 {
 761   set_reg (sr->curr.reg + reg, UNW_WHERE_GR,
 762            sr->region_start + sr->region_len - 1, dst);
 763 }
 764
 765 static inline void
 766 desc_reg_psprel (unsigned char reg, unw_word pspoff,
 767                  struct unw_state_record *sr)
 768 {
 769   set_reg (sr->curr.reg + reg, UNW_WHERE_PSPREL,
 770            sr->region_start + sr->region_len - 1,
 771            0x10 - 4*pspoff);
 772 }
 773
 774 static inline void
 775 desc_reg_sprel (unsigned char reg, unw_word spoff, struct unw_state_record *sr)
 776 {
 777   set_reg (sr->curr.reg + reg, UNW_WHERE_SPREL,
 778            sr->region_start + sr->region_len - 1,
 779            4*spoff);
 780 }
 781
 782 static inline void
 783 desc_rp_br (unsigned char dst, struct unw_state_record *sr)
 784 {
 785   sr->return_link_reg = dst;
 786 }
 787
 788 static inline void
 789 desc_reg_when (unsigned char regnum, unw_word t, struct unw_state_record *sr)
 790 {
 791   struct unw_reg_info *reg = sr->curr.reg + regnum;
 792
 793   if (reg->where == UNW_WHERE_NONE)
 794     reg->where = UNW_WHERE_GR_SAVE;
 795   reg->when = sr->region_start + MIN ((int)t, sr->region_len - 1);
 796 }
 797
 798 static inline void
 799 desc_spill_base (unw_word pspoff, struct unw_state_record *sr)
 800 {
 801   sr->spill_offset = 0x10 - 4*pspoff;
 802 }
 803
 804 static inline unsigned char *
 805 desc_spill_mask (unsigned char *imaskp, struct unw_state_record *sr)
 806 {
 807   sr->imask = imaskp;
 808   return imaskp + (2*sr->region_len + 7)/8;
 809 }
 810
 811 /*
 812  * Body descriptors.
 813  */
 814 static inline void
 815 desc_epilogue (unw_word t, unw_word ecount, struct unw_state_record *sr)
 816 {
 817   sr->epilogue_start = sr->region_start + sr->region_len - 1 - t;
 818   sr->epilogue_count = ecount + 1;
 819 }
 820
 821 static inline void
 822 desc_copy_state (unw_word label, struct unw_state_record *sr)
 823 {
 824   struct unw_labeled_state *ls;
 825
 826   for (ls = sr->labeled_states; ls; ls = ls->next)
 827     {
 828       if (ls->label == label)
 829         {
 830           free_state_stack (&sr->curr);
 831           memcpy (&sr->curr, &ls->saved_state, sizeof (sr->curr));
 832           sr->curr.next = dup_state_stack (ls->saved_state.next);
 833           return;
 834         }
 835     }
 836   abort ();
 837 }
 838
 839 static inline void
 840 desc_label_state (unw_word label, struct unw_state_record *sr)
 841 {
 842   struct unw_labeled_state *ls = alloc_label_state ();
 843
 844   ls->label = label;
 845   memcpy (&ls->saved_state, &sr->curr, sizeof (ls->saved_state));
 846   ls->saved_state.next = dup_state_stack (sr->curr.next);
 847
 848   /* Insert into list of labeled states.  */
 849   ls->next = sr->labeled_states;
 850   sr->labeled_states = ls;
 851 }
 852
 853 /*
 854  * General descriptors.
 855  */
 856
 857 static inline int
 858 desc_is_active (unsigned char qp, unw_word t, struct unw_state_record *sr)
 859 {
 860   if (sr->when_target <= sr->region_start + MIN ((int)t, sr->region_len - 1))
 861     return 0;
 862   if (qp > 0)
 863     {
 864       if ((sr->pr_val & (1UL << qp)) == 0)
 865         return 0;
 866       sr->pr_mask |= (1UL << qp);
 867     }
 868   return 1;
 869 }
 870
 871 static inline void
 872 desc_restore_p (unsigned char qp, unw_word t, unsigned char abreg,
 873                 struct unw_state_record *sr)
 874 {
 875   struct unw_reg_info *r;
 876
 877   if (! desc_is_active (qp, t, sr))
 878     return;
 879
 880   r = sr->curr.reg + decode_abreg (abreg, 0);
 881   r->where = UNW_WHERE_NONE;
 882   r->when = sr->region_start + MIN ((int)t, sr->region_len - 1);
 883   r->val = 0;
 884 }
 885
 886 static inline void
 887 desc_spill_reg_p (unsigned char qp, unw_word t, unsigned char abreg,
 888                   unsigned char x, unsigned char ytreg,
 889                   struct unw_state_record *sr)
 890 {
 891   enum unw_where where = UNW_WHERE_GR;
 892   struct unw_reg_info *r;
 893
 894   if (! desc_is_active (qp, t, sr))
 895     return;
 896
 897   if (x)
 898     where = UNW_WHERE_BR;
 899   else if (ytreg & 0x80)
 900     where = UNW_WHERE_FR;
 901
 902   r = sr->curr.reg + decode_abreg (abreg, 0);
 903   r->where = where;
 904   r->when = sr->region_start + MIN ((int)t, sr->region_len - 1);
 905   r->val = ytreg & 0x7f;
 906 }
 907
 908 static inline void
 909 desc_spill_psprel_p (unsigned char qp, unw_word t, unsigned char abreg,
 910                      unw_word pspoff, struct unw_state_record *sr)
 911 {
 912   struct unw_reg_info *r;
 913
 914   if (! desc_is_active (qp, t, sr))
 915     return;
 916
 917   r = sr->curr.reg + decode_abreg (abreg, 1);
 918   r->where = UNW_WHERE_PSPREL;
 919   r->when = sr->region_start + MIN((int)t, sr->region_len - 1);
 920   r->val = 0x10 - 4*pspoff;
 921 }
 922
 923 static inline void
 924 desc_spill_sprel_p (unsigned char qp, unw_word t, unsigned char abreg,
 925                     unw_word spoff, struct unw_state_record *sr)
 926 {
 927   struct unw_reg_info *r;
 928
 929   if (! desc_is_active (qp, t, sr))
 930     return;
 931
 932   r = sr->curr.reg + decode_abreg (abreg, 1);
 933   r->where = UNW_WHERE_SPREL;
 934   r->when = sr->region_start + MIN ((int)t, sr->region_len - 1);
 935   r->val = 4*spoff;
 936 }
 937
 938 \f
 939 #define UNW_DEC_BAD_CODE(code)                  abort ();
 940
 941 /* Region headers.  */
 942 #define UNW_DEC_PROLOGUE_GR(fmt,r,m,gr,arg)     desc_prologue(0,r,m,gr,arg)
 943 #define UNW_DEC_PROLOGUE(fmt,b,r,arg)           desc_prologue(b,r,0,32,arg)
 944
 945 /* Prologue descriptors.  */
 946 #define UNW_DEC_ABI(fmt,a,c,arg)                desc_abi(a,c,arg)
 947 #define UNW_DEC_BR_GR(fmt,b,g,arg)              desc_br_gr(b,g,arg)
 948 #define UNW_DEC_BR_MEM(fmt,b,arg)               desc_br_mem(b,arg)
 949 #define UNW_DEC_FRGR_MEM(fmt,g,f,arg)           desc_frgr_mem(g,f,arg)
 950 #define UNW_DEC_FR_MEM(fmt,f,arg)               desc_fr_mem(f,arg)
 951 #define UNW_DEC_GR_GR(fmt,m,g,arg)              desc_gr_gr(m,g,arg)
 952 #define UNW_DEC_GR_MEM(fmt,m,arg)               desc_gr_mem(m,arg)
 953 #define UNW_DEC_MEM_STACK_F(fmt,t,s,arg)        desc_mem_stack_f(t,s,arg)
 954 #define UNW_DEC_MEM_STACK_V(fmt,t,arg)          desc_mem_stack_v(t,arg)
 955 #define UNW_DEC_REG_GR(fmt,r,d,arg)             desc_reg_gr(r,d,arg)
 956 #define UNW_DEC_REG_PSPREL(fmt,r,o,arg)         desc_reg_psprel(r,o,arg)
 957 #define UNW_DEC_REG_SPREL(fmt,r,o,arg)          desc_reg_sprel(r,o,arg)
 958 #define UNW_DEC_REG_WHEN(fmt,r,t,arg)           desc_reg_when(r,t,arg)
 959 #define UNW_DEC_PRIUNAT_WHEN_GR(fmt,t,arg)      desc_reg_when(UNW_REG_PRI_UNAT_GR,t,arg)
 960 #define UNW_DEC_PRIUNAT_WHEN_MEM(fmt,t,arg)     desc_reg_when(UNW_REG_PRI_UNAT_MEM,t,arg)
 961 #define UNW_DEC_PRIUNAT_GR(fmt,r,arg)           desc_reg_gr(UNW_REG_PRI_UNAT_GR,r,arg)
 962 #define UNW_DEC_PRIUNAT_PSPREL(fmt,o,arg)       desc_reg_psprel(UNW_REG_PRI_UNAT_MEM,o,arg)
 963 #define UNW_DEC_PRIUNAT_SPREL(fmt,o,arg)        desc_reg_sprel(UNW_REG_PRI_UNAT_MEM,o,arg)
 964 #define UNW_DEC_RP_BR(fmt,d,arg)                desc_rp_br(d,arg)
 965 #define UNW_DEC_SPILL_BASE(fmt,o,arg)           desc_spill_base(o,arg)
 966 #define UNW_DEC_SPILL_MASK(fmt,m,arg)           (m = desc_spill_mask(m,arg))
 967
 968 /* Body descriptors.  */
 969 #define UNW_DEC_EPILOGUE(fmt,t,c,arg)           desc_epilogue(t,c,arg)
 970 #define UNW_DEC_COPY_STATE(fmt,l,arg)           desc_copy_state(l,arg)
 971 #define UNW_DEC_LABEL_STATE(fmt,l,arg)          desc_label_state(l,arg)
 972
 973 /* General unwind descriptors.  */
 974 #define UNW_DEC_SPILL_REG_P(f,p,t,a,x,y,arg)    desc_spill_reg_p(p,t,a,x,y,arg)
 975 #define UNW_DEC_SPILL_REG(f,t,a,x,y,arg)        desc_spill_reg_p(0,t,a,x,y,arg)
 976 #define UNW_DEC_SPILL_PSPREL_P(f,p,t,a,o,arg)   desc_spill_psprel_p(p,t,a,o,arg)
 977 #define UNW_DEC_SPILL_PSPREL(f,t,a,o,arg)       desc_spill_psprel_p(0,t,a,o,arg)
 978 #define UNW_DEC_SPILL_SPREL_P(f,p,t,a,o,arg)    desc_spill_sprel_p(p,t,a,o,arg)
 979 #define UNW_DEC_SPILL_SPREL(f,t,a,o,arg)        desc_spill_sprel_p(0,t,a,o,arg)
 980 #define UNW_DEC_RESTORE_P(f,p,t,a,arg)          desc_restore_p(p,t,a,arg)
 981 #define UNW_DEC_RESTORE(f,t,a,arg)              desc_restore_p(0,t,a,arg)
 982
 983 \f
 984 /*
 985  * Generic IA-64 unwind info decoder.
 986  *
 987  * This file is used both by the Linux kernel and objdump.  Please keep
 988  * the copies of this file in sync.
 989  *
 990  * You need to customize the decoder by defining the following
 991  * macros/constants before including this file:
 992  *
 993  *  Types:
 994  *      unw_word        Unsigned integer type with at least 64 bits
 995  *
 996  *  Register names:
 997  *      UNW_REG_BSP
 998  *      UNW_REG_BSPSTORE
 999  *      UNW_REG_FPSR
1000  *      UNW_REG_LC
1001  *      UNW_REG_PFS
1002  *      UNW_REG_PR
1003  *      UNW_REG_RNAT
1004  *      UNW_REG_PSP
1005  *      UNW_REG_RP
1006  *      UNW_REG_UNAT
1007  *
1008  *  Decoder action macros:
1009  *      UNW_DEC_BAD_CODE(code)
1010  *      UNW_DEC_ABI(fmt,abi,context,arg)
1011  *      UNW_DEC_BR_GR(fmt,brmask,gr,arg)
1012  *      UNW_DEC_BR_MEM(fmt,brmask,arg)
1013  *      UNW_DEC_COPY_STATE(fmt,label,arg)
1014  *      UNW_DEC_EPILOGUE(fmt,t,ecount,arg)
1015  *      UNW_DEC_FRGR_MEM(fmt,grmask,frmask,arg)
1016  *      UNW_DEC_FR_MEM(fmt,frmask,arg)
1017  *      UNW_DEC_GR_GR(fmt,grmask,gr,arg)
1018  *      UNW_DEC_GR_MEM(fmt,grmask,arg)
1019  *      UNW_DEC_LABEL_STATE(fmt,label,arg)
1020  *      UNW_DEC_MEM_STACK_F(fmt,t,size,arg)
1021  *      UNW_DEC_MEM_STACK_V(fmt,t,arg)
1022  *      UNW_DEC_PRIUNAT_GR(fmt,r,arg)
1023  *      UNW_DEC_PRIUNAT_WHEN_GR(fmt,t,arg)
1024  *      UNW_DEC_PRIUNAT_WHEN_MEM(fmt,t,arg)
1025  *      UNW_DEC_PRIUNAT_WHEN_PSPREL(fmt,pspoff,arg)
1026  *      UNW_DEC_PRIUNAT_WHEN_SPREL(fmt,spoff,arg)
1027  *      UNW_DEC_PROLOGUE(fmt,body,rlen,arg)
1028  *      UNW_DEC_PROLOGUE_GR(fmt,rlen,mask,grsave,arg)
1029  *      UNW_DEC_REG_PSPREL(fmt,reg,pspoff,arg)
1030  *      UNW_DEC_REG_REG(fmt,src,dst,arg)
1031  *      UNW_DEC_REG_SPREL(fmt,reg,spoff,arg)
1032  *      UNW_DEC_REG_WHEN(fmt,reg,t,arg)
1033  *      UNW_DEC_RESTORE(fmt,t,abreg,arg)
1034  *      UNW_DEC_RESTORE_P(fmt,qp,t,abreg,arg)
1035  *      UNW_DEC_SPILL_BASE(fmt,pspoff,arg)
1036  *      UNW_DEC_SPILL_MASK(fmt,imaskp,arg)
1037  *      UNW_DEC_SPILL_PSPREL(fmt,t,abreg,pspoff,arg)
1038  *      UNW_DEC_SPILL_PSPREL_P(fmt,qp,t,abreg,pspoff,arg)
1039  *      UNW_DEC_SPILL_REG(fmt,t,abreg,x,ytreg,arg)
1040  *      UNW_DEC_SPILL_REG_P(fmt,qp,t,abreg,x,ytreg,arg)
1041  *      UNW_DEC_SPILL_SPREL(fmt,t,abreg,spoff,arg)
1042  *      UNW_DEC_SPILL_SPREL_P(fmt,qp,t,abreg,pspoff,arg)
1043  */
1044
1045 static unw_word
1046 unw_decode_uleb128 (unsigned char **dpp)
1047 {
1048   unsigned shift = 0;
1049   unw_word byte, result = 0;
1050   unsigned char *bp = *dpp;
1051
1052   while (1)
1053     {
1054       byte = *bp++;
1055       result |= (byte & 0x7f) << shift;
1056       if ((byte & 0x80) == 0)
1057         break;
1058       shift += 7;
1059     }
1060   *dpp = bp;
1061   return result;
1062 }
1063
1064 static unsigned char *
1065 unw_decode_x1 (unsigned char *dp,
1066                unsigned char code __attribute__((unused)),
1067                void *arg)
1068 {
1069   unsigned char byte1, abreg;
1070   unw_word t, off;
1071
1072   byte1 = *dp++;
1073   t = unw_decode_uleb128 (&dp);
1074   off = unw_decode_uleb128 (&dp);
1075   abreg = (byte1 & 0x7f);
1076   if (byte1 & 0x80)
1077           UNW_DEC_SPILL_SPREL(X1, t, abreg, off, arg);
1078   else
1079           UNW_DEC_SPILL_PSPREL(X1, t, abreg, off, arg);
1080   return dp;
1081 }
1082
1083 static unsigned char *
1084 unw_decode_x2 (unsigned char *dp,
1085                unsigned char code __attribute__((unused)),
1086                void *arg)
1087 {
1088   unsigned char byte1, byte2, abreg, x, ytreg;
1089   unw_word t;
1090
1091   byte1 = *dp++; byte2 = *dp++;
1092   t = unw_decode_uleb128 (&dp);
1093   abreg = (byte1 & 0x7f);
1094   ytreg = byte2;
1095   x = (byte1 >> 7) & 1;
1096   if ((byte1 & 0x80) == 0 && ytreg == 0)
1097     UNW_DEC_RESTORE(X2, t, abreg, arg);
1098   else
1099     UNW_DEC_SPILL_REG(X2, t, abreg, x, ytreg, arg);
1100   return dp;
1101 }
1102
1103 static unsigned char *
1104 unw_decode_x3 (unsigned char *dp,
1105                unsigned char code __attribute__((unused)),
1106                void *arg)
1107 {
1108   unsigned char byte1, byte2, abreg, qp;
1109   unw_word t, off;
1110
1111   byte1 = *dp++; byte2 = *dp++;
1112   t = unw_decode_uleb128 (&dp);
1113   off = unw_decode_uleb128 (&dp);
1114
1115   qp = (byte1 & 0x3f);
1116   abreg = (byte2 & 0x7f);
1117
1118   if (byte1 & 0x80)
1119     UNW_DEC_SPILL_SPREL_P(X3, qp, t, abreg, off, arg);
1120   else
1121     UNW_DEC_SPILL_PSPREL_P(X3, qp, t, abreg, off, arg);
1122   return dp;
1123 }
1124
1125 static unsigned char *
1126 unw_decode_x4 (unsigned char *dp,
1127                unsigned char code __attribute__((unused)),
1128                void *arg)
1129 {
1130   unsigned char byte1, byte2, byte3, qp, abreg, x, ytreg;
1131   unw_word t;
1132
1133   byte1 = *dp++; byte2 = *dp++; byte3 = *dp++;
1134   t = unw_decode_uleb128 (&dp);
1135
1136   qp = (byte1 & 0x3f);
1137   abreg = (byte2 & 0x7f);
1138   x = (byte2 >> 7) & 1;
1139   ytreg = byte3;
1140
1141   if ((byte2 & 0x80) == 0 && byte3 == 0)
1142     UNW_DEC_RESTORE_P(X4, qp, t, abreg, arg);
1143   else
1144     UNW_DEC_SPILL_REG_P(X4, qp, t, abreg, x, ytreg, arg);
1145   return dp;
1146 }
1147
1148 static unsigned char *
1149 unw_decode_r1 (unsigned char *dp, unsigned char code, void *arg)
1150 {
1151   int body = (code & 0x20) != 0;
1152   unw_word rlen;
1153
1154   rlen = (code & 0x1f);
1155   UNW_DEC_PROLOGUE(R1, body, rlen, arg);
1156   return dp;
1157 }
1158
1159 static unsigned char *
1160 unw_decode_r2 (unsigned char *dp, unsigned char code, void *arg)
1161 {
1162   unsigned char byte1, mask, grsave;
1163   unw_word rlen;
1164
1165   byte1 = *dp++;
1166
1167   mask = ((code & 0x7) << 1) | ((byte1 >> 7) & 1);
1168   grsave = (byte1 & 0x7f);
1169   rlen = unw_decode_uleb128 (&dp);
1170   UNW_DEC_PROLOGUE_GR(R2, rlen, mask, grsave, arg);
1171   return dp;
1172 }
1173
1174 static unsigned char *
1175 unw_decode_r3 (unsigned char *dp, unsigned char code, void *arg)
1176 {
1177   unw_word rlen;
1178
1179   rlen = unw_decode_uleb128 (&dp);
1180   UNW_DEC_PROLOGUE(R3, ((code & 0x3) == 1), rlen, arg);
1181   return dp;
1182 }
1183
1184 static unsigned char *
1185 unw_decode_p1 (unsigned char *dp, unsigned char code, void *arg)
1186 {
1187   unsigned char brmask = (code & 0x1f);
1188
1189   UNW_DEC_BR_MEM(P1, brmask, arg);
1190   return dp;
1191 }
1192
1193 static unsigned char *
1194 unw_decode_p2_p5 (unsigned char *dp, unsigned char code, void *arg)
1195 {
1196   if ((code & 0x10) == 0)
1197     {
1198       unsigned char byte1 = *dp++;
1199
1200       UNW_DEC_BR_GR(P2, ((code & 0xf) << 1) | ((byte1 >> 7) & 1),
1201                     (byte1 & 0x7f), arg);
1202     }
1203   else if ((code & 0x08) == 0)
1204     {
1205       unsigned char byte1 = *dp++, r, dst;
1206
1207       r = ((code & 0x7) << 1) | ((byte1 >> 7) & 1);
1208       dst = (byte1 & 0x7f);
1209       switch (r)
1210         {
1211         case 0: UNW_DEC_REG_GR(P3, UNW_REG_PSP, dst, arg); break;
1212         case 1: UNW_DEC_REG_GR(P3, UNW_REG_RP, dst, arg); break;
1213         case 2: UNW_DEC_REG_GR(P3, UNW_REG_PFS, dst, arg); break;
1214         case 3: UNW_DEC_REG_GR(P3, UNW_REG_PR, dst, arg); break;
1215         case 4: UNW_DEC_REG_GR(P3, UNW_REG_UNAT, dst, arg); break;
1216         case 5: UNW_DEC_REG_GR(P3, UNW_REG_LC, dst, arg); break;
1217         case 6: UNW_DEC_RP_BR(P3, dst, arg); break;
1218         case 7: UNW_DEC_REG_GR(P3, UNW_REG_RNAT, dst, arg); break;
1219         case 8: UNW_DEC_REG_GR(P3, UNW_REG_BSP, dst, arg); break;
1220         case 9: UNW_DEC_REG_GR(P3, UNW_REG_BSPSTORE, dst, arg); break;
1221         case 10: UNW_DEC_REG_GR(P3, UNW_REG_FPSR, dst, arg); break;
1222         case 11: UNW_DEC_PRIUNAT_GR(P3, dst, arg); break;
1223         default: UNW_DEC_BAD_CODE(r); break;
1224         }
1225     }
1226   else if ((code & 0x7) == 0)
1227     UNW_DEC_SPILL_MASK(P4, dp, arg);
1228   else if ((code & 0x7) == 1)
1229     {
1230       unw_word grmask, frmask, byte1, byte2, byte3;
1231
1232       byte1 = *dp++; byte2 = *dp++; byte3 = *dp++;
1233       grmask = ((byte1 >> 4) & 0xf);
1234       frmask = ((byte1 & 0xf) << 16) | (byte2 << 8) | byte3;
1235       UNW_DEC_FRGR_MEM(P5, grmask, frmask, arg);
1236     }
1237   else
1238     UNW_DEC_BAD_CODE(code);
1239   return dp;
1240 }
1241
1242 static unsigned char *
1243 unw_decode_p6 (unsigned char *dp, unsigned char code, void *arg)
1244 {
1245   int gregs = (code & 0x10) != 0;
1246   unsigned char mask = (code & 0x0f);
1247
1248   if (gregs)
1249     UNW_DEC_GR_MEM(P6, mask, arg);
1250   else
1251     UNW_DEC_FR_MEM(P6, mask, arg);
1252   return dp;
1253 }
1254
1255 static unsigned char *
1256 unw_decode_p7_p10 (unsigned char *dp, unsigned char code, void *arg)
1257 {
1258   unsigned char r, byte1, byte2;
1259   unw_word t, size;
1260
1261   if ((code & 0x10) == 0)
1262     {
1263       r = (code & 0xf);
1264       t = unw_decode_uleb128 (&dp);
1265       switch (r)
1266         {
1267         case 0:
1268           size = unw_decode_uleb128 (&dp);
1269           UNW_DEC_MEM_STACK_F(P7, t, size, arg);
1270           break;
1271
1272         case 1: UNW_DEC_MEM_STACK_V(P7, t, arg); break;
1273         case 2: UNW_DEC_SPILL_BASE(P7, t, arg); break;
1274         case 3: UNW_DEC_REG_SPREL(P7, UNW_REG_PSP, t, arg); break;
1275         case 4: UNW_DEC_REG_WHEN(P7, UNW_REG_RP, t, arg); break;
1276         case 5: UNW_DEC_REG_PSPREL(P7, UNW_REG_RP, t, arg); break;
1277         case 6: UNW_DEC_REG_WHEN(P7, UNW_REG_PFS, t, arg); break;
1278         case 7: UNW_DEC_REG_PSPREL(P7, UNW_REG_PFS, t, arg); break;
1279         case 8: UNW_DEC_REG_WHEN(P7, UNW_REG_PR, t, arg); break;
1280         case 9: UNW_DEC_REG_PSPREL(P7, UNW_REG_PR, t, arg); break;
1281         case 10: UNW_DEC_REG_WHEN(P7, UNW_REG_LC, t, arg); break;
1282         case 11: UNW_DEC_REG_PSPREL(P7, UNW_REG_LC, t, arg); break;
1283         case 12: UNW_DEC_REG_WHEN(P7, UNW_REG_UNAT, t, arg); break;
1284         case 13: UNW_DEC_REG_PSPREL(P7, UNW_REG_UNAT, t, arg); break;
1285         case 14: UNW_DEC_REG_WHEN(P7, UNW_REG_FPSR, t, arg); break;
1286         case 15: UNW_DEC_REG_PSPREL(P7, UNW_REG_FPSR, t, arg); break;
1287         default: UNW_DEC_BAD_CODE(r); break;
1288         }
1289     }
1290   else
1291     {
1292       switch (code & 0xf)
1293         {
1294         case 0x0: /* p8 */
1295           {
1296             r = *dp++;
1297             t = unw_decode_uleb128 (&dp);
1298             switch (r)
1299               {
1300               case  1: UNW_DEC_REG_SPREL(P8, UNW_REG_RP, t, arg); break;
1301               case  2: UNW_DEC_REG_SPREL(P8, UNW_REG_PFS, t, arg); break;
1302               case  3: UNW_DEC_REG_SPREL(P8, UNW_REG_PR, t, arg); break;
1303               case  4: UNW_DEC_REG_SPREL(P8, UNW_REG_LC, t, arg); break;
1304               case  5: UNW_DEC_REG_SPREL(P8, UNW_REG_UNAT, t, arg); break;
1305               case  6: UNW_DEC_REG_SPREL(P8, UNW_REG_FPSR, t, arg); break;
1306               case  7: UNW_DEC_REG_WHEN(P8, UNW_REG_BSP, t, arg); break;
1307               case  8: UNW_DEC_REG_PSPREL(P8, UNW_REG_BSP, t, arg); break;
1308               case  9: UNW_DEC_REG_SPREL(P8, UNW_REG_BSP, t, arg); break;
1309               case 10: UNW_DEC_REG_WHEN(P8, UNW_REG_BSPSTORE, t, arg); break;
1310               case 11: UNW_DEC_REG_PSPREL(P8, UNW_REG_BSPSTORE, t, arg); break;
1311               case 12: UNW_DEC_REG_SPREL(P8, UNW_REG_BSPSTORE, t, arg); break;
1312               case 13: UNW_DEC_REG_WHEN(P8, UNW_REG_RNAT, t, arg); break;
1313               case 14: UNW_DEC_REG_PSPREL(P8, UNW_REG_RNAT, t, arg); break;
1314               case 15: UNW_DEC_REG_SPREL(P8, UNW_REG_RNAT, t, arg); break;
1315               case 16: UNW_DEC_PRIUNAT_WHEN_GR(P8, t, arg); break;
1316               case 17: UNW_DEC_PRIUNAT_PSPREL(P8, t, arg); break;
1317               case 18: UNW_DEC_PRIUNAT_SPREL(P8, t, arg); break;
1318               case 19: UNW_DEC_PRIUNAT_WHEN_MEM(P8, t, arg); break;
1319               default: UNW_DEC_BAD_CODE(r); break;
1320             }
1321           }
1322           break;
1323
1324         case 0x1:
1325           byte1 = *dp++; byte2 = *dp++;
1326           UNW_DEC_GR_GR(P9, (byte1 & 0xf), (byte2 & 0x7f), arg);
1327           break;
1328
1329         case 0xf: /* p10 */
1330           byte1 = *dp++; byte2 = *dp++;
1331           UNW_DEC_ABI(P10, byte1, byte2, arg);
1332           break;
1333
1334         case 0x9:
1335           return unw_decode_x1 (dp, code, arg);
1336
1337         case 0xa:
1338           return unw_decode_x2 (dp, code, arg);
1339
1340         case 0xb:
1341           return unw_decode_x3 (dp, code, arg);
1342
1343         case 0xc:
1344           return unw_decode_x4 (dp, code, arg);
1345
1346         default:
1347           UNW_DEC_BAD_CODE(code);
1348           break;
1349         }
1350     }
1351   return dp;
1352 }
1353
1354 static unsigned char *
1355 unw_decode_b1 (unsigned char *dp, unsigned char code, void *arg)
1356 {
1357   unw_word label = (code & 0x1f);
1358
1359   if ((code & 0x20) != 0)
1360     UNW_DEC_COPY_STATE(B1, label, arg);
1361   else
1362     UNW_DEC_LABEL_STATE(B1, label, arg);
1363   return dp;
1364 }
1365
1366 static unsigned char *
1367 unw_decode_b2 (unsigned char *dp, unsigned char code, void *arg)
1368 {
1369   unw_word t;
1370
1371   t = unw_decode_uleb128 (&dp);
1372   UNW_DEC_EPILOGUE(B2, t, (code & 0x1f), arg);
1373   return dp;
1374 }
1375
1376 static unsigned char *
1377 unw_decode_b3_x4 (unsigned char *dp, unsigned char code, void *arg)
1378 {
1379   unw_word t, ecount, label;
1380
1381   if ((code & 0x10) == 0)
1382     {
1383       t = unw_decode_uleb128 (&dp);
1384       ecount = unw_decode_uleb128 (&dp);
1385       UNW_DEC_EPILOGUE(B3, t, ecount, arg);
1386     }
1387   else if ((code & 0x07) == 0)
1388     {
1389       label = unw_decode_uleb128 (&dp);
1390       if ((code & 0x08) != 0)
1391         UNW_DEC_COPY_STATE(B4, label, arg);
1392       else
1393         UNW_DEC_LABEL_STATE(B4, label, arg);
1394     }
1395   else
1396     switch (code & 0x7)
1397       {
1398       case 1: return unw_decode_x1 (dp, code, arg);
1399       case 2: return unw_decode_x2 (dp, code, arg);
1400       case 3: return unw_decode_x3 (dp, code, arg);
1401       case 4: return unw_decode_x4 (dp, code, arg);
1402       default: UNW_DEC_BAD_CODE(code); break;
1403       }
1404   return dp;
1405 }
1406
1407 typedef unsigned char *(*unw_decoder) (unsigned char *, unsigned char, void *);
1408
1409 static const unw_decoder unw_decode_table[2][8] =
1410 {
1411   /* prologue table: */
1412   {
1413     unw_decode_r1,      /* 0 */
1414     unw_decode_r1,
1415     unw_decode_r2,
1416     unw_decode_r3,
1417     unw_decode_p1,      /* 4 */
1418     unw_decode_p2_p5,
1419     unw_decode_p6,
1420     unw_decode_p7_p10
1421   },
1422   {
1423     unw_decode_r1,      /* 0 */
1424     unw_decode_r1,
1425     unw_decode_r2,
1426     unw_decode_r3,
1427     unw_decode_b1,      /* 4 */
1428     unw_decode_b1,
1429     unw_decode_b2,
1430     unw_decode_b3_x4
1431   }
1432 };
1433
1434 /*
1435  * Decode one descriptor and return address of next descriptor.
1436  */
1437 static inline unsigned char *
1438 unw_decode (unsigned char *dp, int inside_body, void *arg)
1439 {
1440   unw_decoder decoder;
1441   unsigned char code;
1442
1443   code = *dp++;
1444   decoder = unw_decode_table[inside_body][code >> 5];
1445   dp = (*decoder) (dp, code, arg);
1446   return dp;
1447 }
1448
1449 \f
1450 /* RSE helper functions.  */
1451
1452 static inline unsigned long
1453 ia64_rse_slot_num (unsigned long *addr)
1454 {
1455   return (((unsigned long) addr) >> 3) & 0x3f;
1456 }
1457
1458 /* Return TRUE if ADDR is the address of an RNAT slot.  */
1459 static inline unsigned long
1460 ia64_rse_is_rnat_slot (unsigned long *addr)
1461 {
1462   return ia64_rse_slot_num (addr) == 0x3f;
1463 }
1464
1465 /* Returns the address of the RNAT slot that covers the slot at
1466    address SLOT_ADDR.  */
1467 static inline unsigned long *
1468 ia64_rse_rnat_addr (unsigned long *slot_addr)
1469 {
1470   return (unsigned long *) ((unsigned long) slot_addr | (0x3f << 3));
1471 }
1472
1473 /* Calculate the number of registers in the dirty partition starting at
1474    BSPSTORE with a size of DIRTY bytes.  This isn't simply DIRTY
1475    divided by eight because the 64th slot is used to store ar.rnat.  */
1476 static inline unsigned long
1477 ia64_rse_num_regs (unsigned long *bspstore, unsigned long *bsp)
1478 {
1479   unsigned long slots = (bsp - bspstore);
1480
1481   return slots - (ia64_rse_slot_num (bspstore) + slots)/0x40;
1482 }
1483
1484 /* The inverse of the above: given bspstore and the number of
1485    registers, calculate ar.bsp.  */
1486 static inline unsigned long *
1487 ia64_rse_skip_regs (unsigned long *addr, long num_regs)
1488 {
1489   long delta = ia64_rse_slot_num (addr) + num_regs;
1490
1491   if (num_regs < 0)
1492     delta -= 0x3e;
1493   return addr + num_regs + delta/0x3f;
1494 }
1495
1496 \f
1497 /* Copy register backing store from SRC to DST, LEN words
1498    (which include both saved registers and nat collections).
1499    DST_RNAT is a partial nat collection for DST.  SRC and DST
1500    don't have to be equal modulo 64 slots, so it cannot be
1501    done with a simple memcpy as the nat collections will be
1502    at different relative offsets and need to be combined together.  */
1503 static void
1504 ia64_copy_rbs (struct _Unwind_Context *info, unsigned long dst,
1505                unsigned long src, long len, unsigned long dst_rnat)
1506 {
1507   long count;
1508   unsigned long src_rnat;
1509   unsigned long shift1, shift2;
1510
1511   len <<= 3;
1512   dst_rnat &= (1UL << ((dst >> 3) & 0x3f)) - 1;
1513   src_rnat = src >= info->regstk_top
1514              ? info->rnat : *(unsigned long *) (src | 0x1f8);
1515   src_rnat &= ~((1UL << ((src >> 3) & 0x3f)) - 1);
1516   /* Just to make sure.  */
1517   src_rnat &= ~(1UL << 63);
1518   shift1 = ((dst - src) >> 3) & 0x3f;
1519   if ((dst & 0x1f8) < (src & 0x1f8))
1520     shift1--;
1521   shift2 = 0x3f - shift1;
1522   if ((dst & 0x1f8) >= (src & 0x1f8))
1523     {
1524       count = ~dst & 0x1f8;
1525       goto first;
1526     }
1527   count = ~src & 0x1f8;
1528   goto second;
1529   while (len > 0)
1530     {
1531       src_rnat = src >= info->regstk_top
1532                  ? info->rnat : *(unsigned long *) (src | 0x1f8);
1533       /* Just to make sure.  */
1534       src_rnat &= ~(1UL << 63);
1535       count = shift2 << 3;
1536 first:
1537       if (count > len)
1538         count = len;
1539       memcpy ((char *) dst, (char *) src, count);
1540       dst += count;
1541       src += count;
1542       len -= count;
1543       dst_rnat |= (src_rnat << shift1) & ~(1UL << 63);
1544       if (len <= 0)
1545         break;
1546       *(long *) dst = dst_rnat;
1547       dst += 8;
1548       dst_rnat = 0;
1549       count = shift1 << 3;
1550 second:
1551       if (count > len)
1552         count = len;
1553       memcpy ((char *) dst, (char *) src, count);
1554       dst += count;
1555       src += count + 8;
1556       len -= count + 8;
1557       dst_rnat |= (src_rnat >> shift2);
1558     }
1559   if ((dst & 0x1f8) == 0x1f8)
1560     {
1561       *(long *) dst = dst_rnat;
1562       dst += 8;
1563       dst_rnat = 0;
1564     }
1565   /* Set info->regstk_top to lowest rbs address which will use
1566      info->rnat collection.  */
1567   info->regstk_top = dst & ~0x1ffUL;
1568   info->rnat = dst_rnat;
1569 }
1570
1571 /* Unwind accessors.  */
1572
1573 static void
1574 unw_access_gr (struct _Unwind_Context *info, int regnum,
1575                unsigned long *val, char *nat, int write)
1576 {
1577   unsigned long *addr, *nat_addr = 0, nat_mask = 0, dummy_nat;
1578   struct unw_ireg *ireg;
1579
1580   if ((unsigned) regnum - 1 >= 127)
1581     abort ();
1582
1583   if (regnum < 1)
1584     {
1585       nat_addr = addr = &dummy_nat;
1586       dummy_nat = 0;
1587     }
1588   else if (regnum < 32)
1589     {
1590       /* Access a non-stacked register.  */
1591       ireg = &info->ireg[regnum - 2];
1592       addr = ireg->loc;
1593       if (addr)
1594         {
1595           nat_addr = addr + ireg->nat.off;
1596           switch (ireg->nat.type)
1597             {
1598             case UNW_NAT_VAL:
1599               /* Simulate getf.sig/setf.sig.  */
1600               if (write)
1601                 {
1602                   if (*nat)
1603                     {
1604                       /* Write NaTVal and be done with it.  */
1605                       addr[0] = 0;
1606                       addr[1] = 0x1fffe;
1607                       return;
1608                     }
1609                   addr[1] = 0x1003e;
1610                 }
1611               else if (addr[0] == 0 && addr[1] == 0x1ffe)
1612                 {
1613                   /* Return NaT and be done with it.  */
1614                   *val = 0;
1615                   *nat = 1;
1616                   return;
1617                 }
1618               /* FALLTHRU */
1619
1620             case UNW_NAT_NONE:
1621               dummy_nat = 0;
1622               nat_addr = &dummy_nat;
1623               break;
1624
1625             case UNW_NAT_MEMSTK:
1626               nat_mask = 1UL << ((long) addr & 0x1f8)/8;
1627               break;
1628
1629             case UNW_NAT_REGSTK:
1630               if ((unsigned long) addr >= info->regstk_top)
1631                 nat_addr = &info->rnat;
1632               else
1633                 nat_addr = ia64_rse_rnat_addr (addr);
1634               nat_mask = 1UL << ia64_rse_slot_num (addr);
1635               break;
1636             }
1637         }
1638     }
1639   else
1640     {
1641       /* Access a stacked register.  */
1642       addr = ia64_rse_skip_regs ((unsigned long *) info->bsp, regnum - 32);
1643       if ((unsigned long) addr >= info->regstk_top)
1644         nat_addr = &info->rnat;
1645       else
1646         nat_addr = ia64_rse_rnat_addr (addr);
1647       nat_mask = 1UL << ia64_rse_slot_num (addr);
1648     }
1649
1650   if (write)
1651     {
1652       *addr = *val;
1653       if (*nat)
1654         *nat_addr |= nat_mask;
1655       else
1656         *nat_addr &= ~nat_mask;
1657     }
1658   else
1659     {
1660       *val = *addr;
1661       *nat = (*nat_addr & nat_mask) != 0;
1662     }
1663 }
1664 \f
1665 /* Get the value of register REG as saved in CONTEXT.  */
1666
1667 _Unwind_Word
1668 _Unwind_GetGR (struct _Unwind_Context *context, int index)
1669 {
1670   _Unwind_Word ret;
1671   char nat;
1672
1673   if (index == 1)
1674     return context->gp;
1675   else if (index >= 15 && index <= 18)
1676     return context->eh_data[index - 15];
1677   else
1678     unw_access_gr (context, index, &ret, &nat, 0);
1679
1680   return ret;
1681 }
1682
1683 /* Overwrite the saved value for register REG in CONTEXT with VAL.  */
1684
1685 void
1686 _Unwind_SetGR (struct _Unwind_Context *context, int index, _Unwind_Word val)
1687 {
1688   char nat = 0;
1689
1690   if (index == 1)
1691     context->gp = val;
1692   else if (index >= 15 && index <= 18)
1693     context->eh_data[index - 15] = val;
1694   else
1695     unw_access_gr (context, index, &val, &nat, 1);
1696 }
1697
1698 /* Retrieve the return address for CONTEXT.  */
1699
1700 inline _Unwind_Ptr
1701 _Unwind_GetIP (struct _Unwind_Context *context)
1702 {
1703   return context->rp;
1704 }
1705
1706 inline _Unwind_Ptr
1707 _Unwind_GetIPInfo (struct _Unwind_Context *context, int *ip_before_insn)
1708 {
1709   *ip_before_insn = 0;
1710   return context->rp;
1711 }
1712
1713 /* Overwrite the return address for CONTEXT with VAL.  */
1714
1715 inline void
1716 _Unwind_SetIP (struct _Unwind_Context *context, _Unwind_Ptr val)
1717 {
1718   context->rp = val;
1719 }
1720
1721 void *
1722 _Unwind_GetLanguageSpecificData (struct _Unwind_Context *context)
1723 {
1724   return context->lsda;
1725 }
1726
1727 _Unwind_Ptr
1728 _Unwind_GetRegionStart (struct _Unwind_Context *context)
1729 {
1730   return context->region_start;
1731 }
1732
1733 void *
1734 _Unwind_FindEnclosingFunction (void *pc)
1735 {
1736   struct unw_table_entry *ent;
1737   unsigned long segment_base, gp;
1738
1739   ent = _Unwind_FindTableEntry (pc, &segment_base, &gp);
1740   if (ent == NULL)
1741     return NULL;
1742   else
1743     return (void *)(segment_base + ent->start_offset);
1744 }
1745
1746 /* Get the value of the CFA as saved in CONTEXT.  In GCC/Dwarf2 parlance,
1747    the CFA is the value of the stack pointer on entry; In IA-64 unwind
1748    parlance, this is the PSP.  */
1749
1750 _Unwind_Word
1751 _Unwind_GetCFA (struct _Unwind_Context *context)
1752 {
1753   return (_Unwind_Ptr) context->psp;
1754 }
1755
1756 /* Get the value of the Backing Store Pointer as saved in CONTEXT.  */
1757
1758 _Unwind_Word
1759 _Unwind_GetBSP (struct _Unwind_Context *context)
1760 {
1761   return (_Unwind_Ptr) context->bsp;
1762 }
1763
1764 #ifdef MD_UNWIND_SUPPORT
1765 #include MD_UNWIND_SUPPORT
1766 #endif
1767 \f
1768 static _Unwind_Reason_Code
1769 uw_frame_state_for (struct _Unwind_Context *context, _Unwind_FrameState *fs)
1770 {
1771   struct unw_table_entry *ent;
1772   unsigned long *unw, header, length;
1773   unsigned char *insn, *insn_end;
1774   unsigned long segment_base;
1775   struct unw_reg_info *r;
1776
1777   memset (fs, 0, sizeof (*fs));
1778   for (r = fs->curr.reg; r < fs->curr.reg + UNW_NUM_REGS; ++r)
1779     r->when = UNW_WHEN_NEVER;
1780   context->lsda = 0;
1781
1782   ent = _Unwind_FindTableEntry ((void *) context->rp,
1783                                 &segment_base, &context->gp);
1784   if (ent == NULL)
1785     {
1786       /* Couldn't find unwind info for this function.  Try an
1787          os-specific fallback mechanism.  This will necessarily
1788          not provide a personality routine or LSDA.  */
1789 #ifdef MD_FALLBACK_FRAME_STATE_FOR
1790       if (MD_FALLBACK_FRAME_STATE_FOR (context, fs) == _URC_NO_REASON)
1791         return _URC_NO_REASON;
1792 #endif
1793
1794       /* [SCRA 11.4.1] A leaf function with no memory stack, no exception
1795          handlers, and which keeps the return value in B0 does not need
1796          an unwind table entry.
1797
1798          This can only happen in the frame after unwinding through a signal
1799          handler.  Avoid infinite looping by requiring that B0 != RP.
1800          RP == 0 terminates the chain.  */
1801       if (context->br_loc[0]
1802           && *context->br_loc[0] != context->rp
1803           && context->rp != 0)
1804         goto skip_unwind_info;
1805
1806       return _URC_END_OF_STACK;
1807     }
1808
1809   context->region_start = ent->start_offset + segment_base;
1810   fs->when_target = ((context->rp & -16) - context->region_start) / 16 * 3
1811                     + (context->rp & 15);
1812
1813   unw = (unsigned long *) (ent->info_offset + segment_base);
1814   header = *unw;
1815   length = UNW_LENGTH (header);
1816
1817   /* ??? Perhaps check UNW_VER / UNW_FLAG_OSMASK.  */
1818
1819   if (UNW_FLAG_EHANDLER (header) | UNW_FLAG_UHANDLER (header))
1820     {
1821       fs->personality =
1822         *(_Unwind_Personality_Fn *) (unw[length + 1] + context->gp);
1823       context->lsda = unw + length + 2;
1824     }
1825
1826   insn = (unsigned char *) (unw + 1);
1827   insn_end = (unsigned char *) (unw + 1 + length);
1828   while (!fs->done && insn < insn_end)
1829     insn = unw_decode (insn, fs->in_body, fs);
1830
1831   free_label_states (fs->labeled_states);
1832   free_state_stack (&fs->curr);
1833
1834 #ifdef ENABLE_MALLOC_CHECKING
1835   if (reg_state_alloced || labeled_state_alloced)
1836     abort ();
1837 #endif
1838
1839   /* If we're in the epilogue, sp has been restored and all values
1840      on the memory stack below psp also have been restored.  */
1841   if (fs->when_target > fs->epilogue_start)
1842     {
1843       struct unw_reg_info *r;
1844
1845       fs->curr.reg[UNW_REG_PSP].where = UNW_WHERE_NONE;
1846       fs->curr.reg[UNW_REG_PSP].val = 0;
1847       for (r = fs->curr.reg; r < fs->curr.reg + UNW_NUM_REGS; ++r)
1848         if ((r->where == UNW_WHERE_PSPREL && r->val <= 0x10)
1849             || r->where == UNW_WHERE_SPREL)
1850           r->where = UNW_WHERE_NONE;
1851     }
1852
1853 skip_unwind_info:
1854   /* If RP didn't get saved, generate entry for the return link register.  */
1855   if (fs->curr.reg[UNW_REG_RP].when >= fs->when_target)
1856     {
1857       fs->curr.reg[UNW_REG_RP].where = UNW_WHERE_BR;
1858       fs->curr.reg[UNW_REG_RP].when = -1;
1859       fs->curr.reg[UNW_REG_RP].val = fs->return_link_reg;
1860     }
1861
1862   /* There is a subtlety for the frame after unwinding through a signal
1863      handler: should we restore the cfm as usual or the pfs?  We can't
1864      restore both because we use br.ret to resume execution of user code.
1865      For other frames the procedure is by definition non-leaf so the pfs
1866      is saved and restored and thus effectively dead in the body; only
1867      the cfm need therefore be restored.
1868
1869      Here we have 2 cases:
1870        - either the pfs is saved and restored and thus effectively dead
1871          like in regular frames; then we do nothing special and restore
1872          the cfm.
1873        - or the pfs is not saved and thus live; but in that case the
1874          procedure is necessarily leaf so the cfm is effectively dead
1875          and we restore the pfs.  */
1876   if (context->signal_pfs_loc)
1877     {
1878       if (fs->curr.reg[UNW_REG_PFS].when >= fs->when_target)
1879         context->pfs_loc = context->signal_pfs_loc;
1880       context->signal_pfs_loc = NULL;
1881     }
1882
1883   return _URC_NO_REASON;
1884 }
1885
1886 static void
1887 uw_update_reg_address (struct _Unwind_Context *context,
1888                        _Unwind_FrameState *fs,
1889                        enum unw_register_index regno)
1890 {
1891   struct unw_reg_info *r = fs->curr.reg + regno;
1892   void *addr;
1893   unsigned long rval;
1894
1895   if (r->where == UNW_WHERE_NONE || r->when >= fs->when_target)
1896     return;
1897
1898   rval = r->val;
1899   switch (r->where)
1900     {
1901     case UNW_WHERE_GR:
1902       if (rval >= 32)
1903         addr = ia64_rse_skip_regs ((unsigned long *) context->bsp, rval - 32);
1904       else if (rval >= 2)
1905         addr = context->ireg[rval - 2].loc;
1906       else if (rval == 0)
1907         {
1908           static const unsigned long dummy;
1909           addr = (void *) &dummy;
1910         }
1911       else
1912         abort ();
1913       break;
1914
1915     case UNW_WHERE_FR:
1916       if (rval >= 2 && rval < 32)
1917         addr = context->fr_loc[rval - 2];
1918       else
1919         abort ();
1920       break;
1921
1922     case UNW_WHERE_BR:
1923       /* Note that while RVAL can only be 1-5 from normal descriptors,
1924          we can want to look at B0, B6 and B7 due to having manually unwound a
1925          signal frame.  */
1926       if (rval < 8)
1927         addr = context->br_loc[rval];
1928       else
1929         abort ();
1930       break;
1931
1932     case UNW_WHERE_SPREL:
1933       addr = (void *)(context->sp + rval);
1934       break;
1935
1936     case UNW_WHERE_PSPREL:
1937       addr = (void *)(context->psp + rval);
1938       break;
1939
1940     default:
1941       abort ();
1942     }
1943
1944   switch (regno)
1945     {
1946     case UNW_REG_R2 ... UNW_REG_R31:
1947       context->ireg[regno - UNW_REG_R2].loc = addr;
1948       switch (r->where)
1949       {
1950       case UNW_WHERE_GR:
1951         if (rval >= 32)
1952           {
1953             context->ireg[regno - UNW_REG_R2].nat.type = UNW_NAT_MEMSTK;
1954             context->ireg[regno - UNW_REG_R2].nat.off
1955               = context->pri_unat_loc - (unsigned long *) addr;
1956           }
1957         else if (rval >= 2)
1958           {
1959             context->ireg[regno - UNW_REG_R2].nat
1960               = context->ireg[rval - 2].nat;
1961           }
1962         else if (rval == 0)
1963           {
1964             context->ireg[regno - UNW_REG_R2].nat.type = UNW_NAT_NONE;
1965             context->ireg[regno - UNW_REG_R2].nat.off = 0;
1966           }
1967         else
1968           abort ();
1969         break;
1970
1971       case UNW_WHERE_FR:
1972         context->ireg[regno - UNW_REG_R2].nat.type = UNW_NAT_VAL;
1973         context->ireg[regno - UNW_REG_R2].nat.off = 0;
1974         break;
1975
1976       case UNW_WHERE_BR:
1977         context->ireg[regno - UNW_REG_R2].nat.type = UNW_NAT_NONE;
1978         context->ireg[regno - UNW_REG_R2].nat.off = 0;
1979         break;
1980
1981       case UNW_WHERE_PSPREL:
1982       case UNW_WHERE_SPREL:
1983         context->ireg[regno - UNW_REG_R2].nat.type = UNW_NAT_MEMSTK;
1984         context->ireg[regno - UNW_REG_R2].nat.off
1985           = context->pri_unat_loc - (unsigned long *) addr;
1986         break;
1987
1988       default:
1989         abort ();
1990       }
1991       break;
1992
1993     case UNW_REG_F2 ... UNW_REG_F31:
1994       context->fr_loc[regno - UNW_REG_F2] = addr;
1995       break;
1996
1997     case UNW_REG_B1 ... UNW_REG_B5:
1998       context->br_loc[regno - UNW_REG_B0] = addr;
1999       break;
2000
2001     case UNW_REG_BSP:
2002       context->bsp_loc = addr;
2003       break;
2004     case UNW_REG_BSPSTORE:
2005       context->bspstore_loc = addr;
2006       break;
2007     case UNW_REG_PFS:
2008       context->pfs_loc = addr;
2009       break;
2010     case UNW_REG_RP:
2011       context->rp = *(unsigned long *)addr;
2012       break;
2013     case UNW_REG_UNAT:
2014       context->unat_loc = addr;
2015       break;
2016     case UNW_REG_PR:
2017       context->pr = *(unsigned long *) addr;
2018       break;
2019     case UNW_REG_LC:
2020       context->lc_loc = addr;
2021       break;
2022     case UNW_REG_FPSR:
2023       context->fpsr_loc = addr;
2024       break;
2025
2026     case UNW_REG_PSP:
2027       context->psp = *(unsigned long *)addr;
2028       break;
2029
2030     default:
2031       abort ();
2032     }
2033 }
2034
2035 static void
2036 uw_update_context (struct _Unwind_Context *context, _Unwind_FrameState *fs)
2037 {
2038   long i;
2039
2040 #ifdef MD_HANDLE_UNWABI
2041   MD_HANDLE_UNWABI (context, fs);
2042 #endif
2043
2044   context->sp = context->psp;
2045
2046   /* First, set PSP.  Subsequent instructions may depend on this value.  */
2047   if (fs->when_target > fs->curr.reg[UNW_REG_PSP].when)
2048     {
2049       if (fs->curr.reg[UNW_REG_PSP].where == UNW_WHERE_NONE)
2050         context->psp = context->psp + fs->curr.reg[UNW_REG_PSP].val;
2051       else
2052         uw_update_reg_address (context, fs, UNW_REG_PSP);
2053     }
2054
2055   /* Determine the location of the primary UNaT.  */
2056   {
2057     int i;
2058     if (fs->when_target < fs->curr.reg[UNW_REG_PRI_UNAT_GR].when)
2059       i = UNW_REG_PRI_UNAT_MEM;
2060     else if (fs->when_target < fs->curr.reg[UNW_REG_PRI_UNAT_MEM].when)
2061       i = UNW_REG_PRI_UNAT_GR;
2062     else if (fs->curr.reg[UNW_REG_PRI_UNAT_MEM].when
2063              > fs->curr.reg[UNW_REG_PRI_UNAT_GR].when)
2064       i = UNW_REG_PRI_UNAT_MEM;
2065     else
2066       i = UNW_REG_PRI_UNAT_GR;
2067     uw_update_reg_address (context, fs, i);
2068   }
2069
2070   /* Compute the addresses of all registers saved in this frame.  */
2071   for (i = UNW_REG_BSP; i < UNW_NUM_REGS; ++i)
2072     uw_update_reg_address (context, fs, i);
2073
2074   /* Unwind BSP for the local registers allocated this frame.  */
2075   /* ??? What to do with stored BSP or BSPSTORE registers.  */
2076   /* We assert that we are either at a call site, or we have
2077      just unwound through a signal frame.  In either case
2078      pfs_loc is valid.  */
2079   if (!(fs -> no_reg_stack_frame))
2080     {
2081       unsigned long pfs = *context->pfs_loc;
2082       unsigned long sol = (pfs >> 7) & 0x7f;
2083       context->bsp = (unsigned long)
2084         ia64_rse_skip_regs ((unsigned long *) context->bsp, -sol);
2085     }
2086 }
2087
2088 static void
2089 uw_advance_context (struct _Unwind_Context *context, _Unwind_FrameState *fs)
2090 {
2091   uw_update_context (context, fs);
2092 }
2093
2094 /* Fill in CONTEXT for top-of-stack.  The only valid registers at this
2095    level will be the return address and the CFA.  Note that CFA = SP+16.  */
2096
2097 #define uw_init_context(CONTEXT)                                        \
2098   do {                                                                  \
2099     /* ??? There is a whole lot o code in uw_install_context that       \
2100        tries to avoid spilling the entire machine state here.  We       \
2101        should try to make that work again.  */                          \
2102     __builtin_unwind_init();                                            \
2103     uw_init_context_1 (CONTEXT, __builtin_ia64_bsp ());                 \
2104   } while (0)
2105
2106 static void
2107 uw_init_context_1 (struct _Unwind_Context *context, void *bsp)
2108 {
2109   void *rp = __builtin_extract_return_addr (__builtin_return_address (0));
2110   /* Set psp to the caller's stack pointer.  */
2111   void *psp = __builtin_dwarf_cfa () - 16;
2112   _Unwind_FrameState fs;
2113   unsigned long rnat, tmp1, tmp2;
2114
2115   /* Flush the register stack to memory so that we can access it.
2116      Get rse nat collection for the last incomplete rbs chunk of
2117      registers at the same time.  For this RSE needs to be turned
2118      into the mandatory only mode.  */
2119   asm ("mov.m %1 = ar.rsc;;\n\t"
2120        "and %2 = 0x1c, %1;;\n\t"
2121        "mov.m ar.rsc = %2;;\n\t"
2122        "flushrs;;\n\t"
2123        "mov.m %0 = ar.rnat;;\n\t"
2124        "mov.m ar.rsc = %1\n\t"
2125        : "=r" (rnat), "=r" (tmp1), "=r" (tmp2));
2126
2127   memset (context, 0, sizeof (struct _Unwind_Context));
2128   context->bsp = (unsigned long) bsp;
2129   /* Set context->regstk_top to lowest rbs address which will use
2130      context->rnat collection.  */
2131   context->regstk_top = context->bsp & ~0x1ffULL;
2132   context->rnat = rnat;
2133   context->psp = (unsigned long) psp;
2134   context->rp = (unsigned long) rp;
2135   asm ("mov %0 = sp" : "=r" (context->sp));
2136   asm ("mov %0 = pr" : "=r" (context->pr));
2137   context->pri_unat_loc = &context->initial_unat;       /* ??? */
2138
2139   if (uw_frame_state_for (context, &fs) != _URC_NO_REASON)
2140     abort ();
2141
2142   uw_update_context (context, &fs);
2143 }
2144
2145 /* Install (i.e. longjmp to) the contents of TARGET.  */
2146
2147 static void __attribute__((noreturn))
2148 uw_install_context (struct _Unwind_Context *current __attribute__((unused)),
2149                     struct _Unwind_Context *target)
2150 {
2151   unsigned long ireg_buf[4], ireg_nat = 0, ireg_pr = 0;
2152   long i;
2153
2154   /* Copy integer register data from the target context to a
2155      temporary buffer.  Do this so that we can frob AR.UNAT
2156      to get the NaT bits for these registers set properly.  */
2157   for (i = 4; i <= 7; ++i)
2158     {
2159       char nat;
2160       void *t = target->ireg[i - 2].loc;
2161       if (t)
2162         {
2163           unw_access_gr (target, i, &ireg_buf[i - 4], &nat, 0);
2164           ireg_nat |= (long)nat << (((size_t)&ireg_buf[i - 4] >> 3) & 0x3f);
2165           /* Set p6 - p9.  */
2166           ireg_pr |= 4L << i;
2167         }
2168     }
2169
2170   /* The value in uc_bsp that we've computed is that for the
2171      target function.  The value that we install below will be
2172      adjusted by the BR.RET instruction based on the contents
2173      of AR.PFS.  So we must unadjust that here.  */
2174   target->bsp = (unsigned long)
2175     ia64_rse_skip_regs ((unsigned long *)target->bsp,
2176                         (*target->pfs_loc >> 7) & 0x7f);
2177
2178   if (target->bsp < target->regstk_top)
2179     target->rnat = *ia64_rse_rnat_addr ((unsigned long *) target->bsp);
2180
2181   /* Provide assembly with the offsets into the _Unwind_Context.  */
2182   asm volatile ("uc_rnat = %0"
2183                 : : "i"(offsetof (struct _Unwind_Context, rnat)));
2184   asm volatile ("uc_bsp = %0"
2185                 : : "i"(offsetof (struct _Unwind_Context, bsp)));
2186   asm volatile ("uc_psp = %0"
2187                 : : "i"(offsetof (struct _Unwind_Context, psp)));
2188   asm volatile ("uc_rp = %0"
2189                 : : "i"(offsetof (struct _Unwind_Context, rp)));
2190   asm volatile ("uc_pr = %0"
2191                 : : "i"(offsetof (struct _Unwind_Context, pr)));
2192   asm volatile ("uc_gp = %0"
2193                 : : "i"(offsetof (struct _Unwind_Context, gp)));
2194   asm volatile ("uc_pfs_loc = %0"
2195                 : : "i"(offsetof (struct _Unwind_Context, pfs_loc)));
2196   asm volatile ("uc_unat_loc = %0"
2197                 : : "i"(offsetof (struct _Unwind_Context, unat_loc)));
2198   asm volatile ("uc_lc_loc = %0"
2199                 : : "i"(offsetof (struct _Unwind_Context, lc_loc)));
2200   asm volatile ("uc_fpsr_loc = %0"
2201                 : : "i"(offsetof (struct _Unwind_Context, fpsr_loc)));
2202   asm volatile ("uc_eh_data = %0"
2203                 : : "i"(offsetof (struct _Unwind_Context, eh_data)));
2204   asm volatile ("uc_br_loc = %0"
2205                 : : "i"(offsetof (struct _Unwind_Context, br_loc)));
2206   asm volatile ("uc_fr_loc = %0"
2207                 : : "i"(offsetof (struct _Unwind_Context, fr_loc)));
2208
2209   asm volatile (
2210         /* Load up call-saved non-window integer registers from ireg_buf.  */
2211         "add r20 = 8, %1                        \n\t"
2212         "mov ar.unat = %2                       \n\t"
2213         "mov pr = %3, 0x3c0                     \n\t"
2214         ";;                                     \n\t"
2215         "(p6) ld8.fill r4 = [%1]                \n\t"
2216         "(p7) ld8.fill r5 = [r20]               \n\t"
2217         "add r21 = uc_br_loc + 16, %0           \n\t"
2218         "adds %1 = 16, %1                       \n\t"
2219         "adds r20 = 16, r20                     \n\t"
2220         ";;                                     \n\t"
2221         "(p8) ld8.fill r6 = [%1]                \n\t"
2222         "(p9) ld8.fill r7 = [r20]               \n\t"
2223         "add r20 = uc_br_loc + 8, %0            \n\t"
2224         ";;                                     \n\t"
2225         /* Load up call-saved branch registers.  */
2226         "ld8 r22 = [r20], 16                    \n\t"
2227         "ld8 r23 = [r21], 16                    \n\t"
2228         ";;                                     \n\t"
2229         "ld8 r24 = [r20], 16                    \n\t"
2230         "ld8 r25 = [r21], uc_fr_loc - (uc_br_loc + 32)\n\t"
2231         ";;                                     \n\t"
2232         "ld8 r26 = [r20], uc_fr_loc + 8 - (uc_br_loc + 40)\n\t"
2233         "ld8 r27 = [r21], 24                    \n\t"
2234         "cmp.ne p6, p0 = r0, r22                \n\t"
2235         ";;                                     \n\t"
2236         "ld8 r28 = [r20], 8                     \n\t"
2237         "(p6) ld8 r22 = [r22]                   \n\t"
2238         "cmp.ne p7, p0 = r0, r23                \n\t"
2239         ";;                                     \n\t"
2240         "(p7) ld8 r23 = [r23]                   \n\t"
2241         "cmp.ne p8, p0 = r0, r24                \n\t"
2242         ";;                                     \n\t"
2243         "(p8) ld8 r24 = [r24]                   \n\t"
2244         "(p6) mov b1 = r22                      \n\t"
2245         "cmp.ne p9, p0 = r0, r25                \n\t"
2246         ";;                                     \n\t"
2247         "(p9) ld8 r25 = [r25]                   \n\t"
2248         "(p7) mov b2 = r23                      \n\t"
2249         "cmp.ne p6, p0 = r0, r26                \n\t"
2250         ";;                                     \n\t"
2251         "(p6) ld8 r26 = [r26]                   \n\t"
2252         "(p8) mov b3 = r24                      \n\t"
2253         "cmp.ne p7, p0 = r0, r27                \n\t"
2254         ";;                                     \n\t"
2255         /* Load up call-saved fp registers.  */
2256         "(p7) ldf.fill f2 = [r27]               \n\t"
2257         "(p9) mov b4 = r25                      \n\t"
2258         "cmp.ne p8, p0 = r0, r28                \n\t"
2259         ";;                                     \n\t"
2260         "(p8) ldf.fill f3 = [r28]               \n\t"
2261         "(p6) mov b5 = r26                      \n\t"
2262         ";;                                     \n\t"
2263         "ld8 r29 = [r20], 16*8 - 4*8            \n\t"
2264         "ld8 r30 = [r21], 17*8 - 5*8            \n\t"
2265         ";;                                     \n\t"
2266         "ld8 r22 = [r20], 16                    \n\t"
2267         "ld8 r23 = [r21], 16                    \n\t"
2268         ";;                                     \n\t"
2269         "ld8 r24 = [r20], 16                    \n\t"
2270         "ld8 r25 = [r21]                        \n\t"
2271         "cmp.ne p6, p0 = r0, r29                \n\t"
2272         ";;                                     \n\t"
2273         "ld8 r26 = [r20], 8                     \n\t"
2274         "(p6) ldf.fill f4 = [r29]               \n\t"
2275         "cmp.ne p7, p0 = r0, r30                \n\t"
2276         ";;                                     \n\t"
2277         "ld8 r27 = [r20], 8                     \n\t"
2278         "(p7) ldf.fill f5 = [r30]               \n\t"
2279         "cmp.ne p6, p0 = r0, r22                \n\t"
2280         ";;                                     \n\t"
2281         "ld8 r28 = [r20], 8                     \n\t"
2282         "(p6) ldf.fill f16 = [r22]              \n\t"
2283         "cmp.ne p7, p0 = r0, r23                \n\t"
2284         ";;                                     \n\t"
2285         "ld8 r29 = [r20], 8                     \n\t"
2286         "(p7) ldf.fill f17 = [r23]              \n\t"
2287         "cmp.ne p6, p0 = r0, r24                \n\t"
2288         ";;                                     \n\t"
2289         "ld8 r22 = [r20], 8                     \n\t"
2290         "(p6) ldf.fill f18 = [r24]              \n\t"
2291         "cmp.ne p7, p0 = r0, r25                \n\t"
2292         ";;                                     \n\t"
2293         "ld8 r23 = [r20], 8                     \n\t"
2294         "(p7) ldf.fill f19 = [r25]              \n\t"
2295         "cmp.ne p6, p0 = r0, r26                \n\t"
2296         ";;                                     \n\t"
2297         "ld8 r24 = [r20], 8                     \n\t"
2298         "(p6) ldf.fill f20 = [r26]              \n\t"
2299         "cmp.ne p7, p0 = r0, r27                \n\t"
2300         ";;                                     \n\t"
2301         "ld8 r25 = [r20], 8                     \n\t"
2302         "(p7) ldf.fill f21 = [r27]              \n\t"
2303         "cmp.ne p6, p0 = r0, r28                \n\t"
2304         ";;                                     \n\t"
2305         "ld8 r26 = [r20], 8                     \n\t"
2306         "(p6) ldf.fill f22 = [r28]              \n\t"
2307         "cmp.ne p7, p0 = r0, r29                \n\t"
2308         ";;                                     \n\t"
2309         "ld8 r27 = [r20], 8                     \n\t"
2310         ";;                                     \n\t"
2311         "ld8 r28 = [r20], 8                     \n\t"
2312         "(p7) ldf.fill f23 = [r29]              \n\t"
2313         "cmp.ne p6, p0 = r0, r22                \n\t"
2314         ";;                                     \n\t"
2315         "ld8 r29 = [r20], 8                     \n\t"
2316         "(p6) ldf.fill f24 = [r22]              \n\t"
2317         "cmp.ne p7, p0 = r0, r23                \n\t"
2318         ";;                                     \n\t"
2319         "(p7) ldf.fill f25 = [r23]              \n\t"
2320         "cmp.ne p6, p0 = r0, r24                \n\t"
2321         "cmp.ne p7, p0 = r0, r25                \n\t"
2322         ";;                                     \n\t"
2323         "(p6) ldf.fill f26 = [r24]              \n\t"
2324         "(p7) ldf.fill f27 = [r25]              \n\t"
2325         "cmp.ne p6, p0 = r0, r26                \n\t"
2326         ";;                                     \n\t"
2327         "(p6) ldf.fill f28 = [r26]              \n\t"
2328         "cmp.ne p7, p0 = r0, r27                \n\t"
2329         "cmp.ne p6, p0 = r0, r28                \n\t"
2330         ";;                                     \n\t"
2331         "(p7) ldf.fill f29 = [r27]              \n\t"
2332         "(p6) ldf.fill f30 = [r28]              \n\t"
2333         "cmp.ne p7, p0 = r0, r29                \n\t"
2334         ";;                                     \n\t"
2335         "(p7) ldf.fill f31 = [r29]              \n\t"
2336         "add r20 = uc_rnat, %0                  \n\t"
2337         "add r21 = uc_bsp, %0                   \n\t"
2338         ";;                                     \n\t"
2339         /* Load the balance of the thread state from the context.  */
2340         "ld8 r22 = [r20], uc_psp - uc_rnat      \n\t"
2341         "ld8 r23 = [r21], uc_gp - uc_bsp        \n\t"
2342         ";;                                     \n\t"
2343         "ld8 r24 = [r20], uc_pfs_loc - uc_psp   \n\t"
2344         "ld8 r1 = [r21], uc_rp - uc_gp          \n\t"
2345         ";;                                     \n\t"
2346         "ld8 r25 = [r20], uc_unat_loc - uc_pfs_loc\n\t"
2347         "ld8 r26 = [r21], uc_pr - uc_rp         \n\t"
2348         ";;                                     \n\t"
2349         "ld8 r27 = [r20], uc_lc_loc - uc_unat_loc\n\t"
2350         "ld8 r28 = [r21], uc_fpsr_loc - uc_pr   \n\t"
2351         ";;                                     \n\t"
2352         "ld8 r29 = [r20], uc_eh_data - uc_lc_loc\n\t"
2353         "ld8 r30 = [r21], uc_eh_data + 8 - uc_fpsr_loc\n\t"
2354         ";;                                     \n\t"
2355         /* Load data for the exception handler.  */
2356         "ld8 r15 = [r20], 16                    \n\t"
2357         "ld8 r16 = [r21], 16                    \n\t"
2358         ";;                                     \n\t"
2359         "ld8 r17 = [r20]                        \n\t"
2360         "ld8 r18 = [r21]                        \n\t"
2361         ";;                                     \n\t"
2362         /* Install the balance of the thread state loaded above.  */
2363         "cmp.ne p6, p0 = r0, r25                \n\t"
2364         "cmp.ne p7, p0 = r0, r27                \n\t"
2365         ";;                                     \n\t"
2366         "(p6) ld8 r25 = [r25]                   \n\t"
2367         "(p7) ld8 r27 = [r27]                   \n\t"
2368         ";;                                     \n\t"
2369         "(p7) mov.m ar.unat = r27               \n\t"
2370         "(p6) mov.i ar.pfs = r25                \n\t"
2371         "cmp.ne p9, p0 = r0, r29                \n\t"
2372         ";;                                     \n\t"
2373         "(p9) ld8 r29 = [r29]                   \n\t"
2374         "cmp.ne p6, p0 = r0, r30                \n\t"
2375         ";;                                     \n\t"
2376         "(p6) ld8 r30 = [r30]                   \n\t"
2377         /* Don't clobber p6-p9, which are in use at present.  */
2378         "mov pr = r28, ~0x3c0                   \n\t"
2379         "(p9) mov.i ar.lc = r29                 \n\t"
2380         ";;                                     \n\t"
2381         "mov.m r25 = ar.rsc                     \n\t"
2382         "(p6) mov.m ar.fpsr = r30               \n\t"
2383         ";;                                     \n\t"
2384         "and r29 = 0x1c, r25                    \n\t"
2385         "mov b0 = r26                           \n\t"
2386         ";;                                     \n\t"
2387         "mov.m ar.rsc = r29                     \n\t"
2388         ";;                                     \n\t"
2389         /* This must be done before setting AR.BSPSTORE, otherwise
2390            AR.BSP will be initialized with a random displacement
2391            below the value we want, based on the current number of
2392            dirty stacked registers.  */
2393         "loadrs                                 \n\t"
2394         "invala                                 \n\t"
2395         ";;                                     \n\t"
2396         "mov.m ar.bspstore = r23                \n\t"
2397         ";;                                     \n\t"
2398         "mov.m ar.rnat = r22                    \n\t"
2399         ";;                                     \n\t"
2400         "mov.m ar.rsc = r25                     \n\t"
2401         "mov sp = r24                           \n\t"
2402         "br.ret.sptk.few b0"
2403         : : "r"(target), "r"(ireg_buf), "r"(ireg_nat), "r"(ireg_pr)
2404         : "r15", "r16", "r17", "r18", "r20", "r21", "r22",
2405           "r23", "r24", "r25", "r26", "r27", "r28", "r29",
2406           "r30", "r31");
2407   /* NOTREACHED */
2408   while (1);
2409 }
2410
2411 static inline _Unwind_Ptr
2412 uw_identify_context (struct _Unwind_Context *context)
2413 {
2414   return _Unwind_GetIP (context);
2415 }
2416
2417 #include "unwind.inc"
2418
2419 #if defined (USE_GAS_SYMVER) && defined (SHARED) && defined (USE_LIBUNWIND_EXCEPTIONS)
2420 alias (_Unwind_Backtrace);
2421 alias (_Unwind_DeleteException);
2422 alias (_Unwind_FindEnclosingFunction);
2423 alias (_Unwind_ForcedUnwind);
2424 alias (_Unwind_GetBSP);
2425 alias (_Unwind_GetCFA);
2426 alias (_Unwind_GetGR);
2427 alias (_Unwind_GetIP);
2428 alias (_Unwind_GetLanguageSpecificData);
2429 alias (_Unwind_GetRegionStart);
2430 alias (_Unwind_RaiseException);
2431 alias (_Unwind_Resume);
2432 alias (_Unwind_Resume_or_Rethrow);
2433 alias (_Unwind_SetGR);
2434 alias (_Unwind_SetIP);
2435 #endif
2436
2437 #endif