contrib/gcc/config/arm/unwind-arm.c

   1 /* ARM EABI compliant unwinding routines.
   2    Copyright (C) 2004, 2005 Free Software Foundation, Inc.
   3    Contributed by Paul Brook
   4
   5    This file is free software; you can redistribute it and/or modify it
   6    under the terms of the GNU General Public License as published by the
   7    Free Software Foundation; either version 2, or (at your option) any
   8    later version.
   9
  10    In addition to the permissions in the GNU General Public License, the
  11    Free Software Foundation gives you unlimited permission to link the
  12    compiled version of this file into combinations with other programs,
  13    and to distribute those combinations without any restriction coming
  14    from the use of this file.  (The General Public License restrictions
  15    do apply in other respects; for example, they cover modification of
  16    the file, and distribution when not linked into a combine
  17    executable.)
  18
  19    This file is distributed in the hope that it will be useful, but
  20    WITHOUT ANY WARRANTY; without even the implied warranty of
  21    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  22    General Public License for more details.
  23
  24    You should have received a copy of the GNU General Public License
  25    along with this program; see the file COPYING.  If not, write to
  26    the Free Software Foundation, 51 Franklin Street, Fifth Floor,
  27    Boston, MA 02110-1301, USA.  */
  28 #define __ARM_STATIC_INLINE
  29 #include "unwind.h"
  30
  31 /* We add a prototype for abort here to avoid creating a dependency on
  32    target headers.  */
  33 extern void abort (void);
  34
  35 /* Definitions for C++ runtime support routines.  We make these weak
  36    declarations to avoid pulling in libsupc++ unnecessarily.  */
  37 typedef unsigned char bool;
  38
  39 typedef struct _ZSt9type_info type_info; /* This names C++ type_info type */
  40
  41 void __attribute__((weak)) __cxa_call_unexpected(_Unwind_Control_Block *ucbp);
  42 bool __attribute__((weak)) __cxa_begin_cleanup(_Unwind_Control_Block *ucbp);
  43 bool __attribute__((weak)) __cxa_type_match(_Unwind_Control_Block *ucbp,
  44                                             const type_info *rttip,
  45                                             void **matched_object);
  46
  47 _Unwind_Ptr __attribute__((weak))
  48 __gnu_Unwind_Find_exidx (_Unwind_Ptr, int *);
  49
  50 /* Misc constants.  */
  51 #define R_IP    12
  52 #define R_SP    13
  53 #define R_LR    14
  54 #define R_PC    15
  55
  56 #define EXIDX_CANTUNWIND 1
  57 #define uint32_highbit (((_uw) 1) << 31)
  58
  59 #define UCB_FORCED_STOP_FN(ucbp) ((ucbp)->unwinder_cache.reserved1)
  60 #define UCB_PR_ADDR(ucbp) ((ucbp)->unwinder_cache.reserved2)
  61 #define UCB_SAVED_CALLSITE_ADDR(ucbp) ((ucbp)->unwinder_cache.reserved3)
  62 #define UCB_FORCED_STOP_ARG(ucbp) ((ucbp)->unwinder_cache.reserved4)
  63
  64 struct core_regs
  65 {
  66   _uw r[16];
  67 };
  68
  69 /* We use normal integer types here to avoid the compiler generating
  70    coprocessor instructions.  */
  71 struct vfp_regs
  72 {
  73   _uw64 d[16];
  74   _uw pad;
  75 };
  76
  77 struct fpa_reg
  78 {
  79   _uw w[3];
  80 };
  81
  82 struct fpa_regs
  83 {
  84   struct fpa_reg f[8];
  85 };
  86
  87 /* Unwind descriptors.  */
  88
  89 typedef struct
  90 {
  91   _uw16 length;
  92   _uw16 offset;
  93 } EHT16;
  94
  95 typedef struct
  96 {
  97   _uw length;
  98   _uw offset;
  99 } EHT32;
 100
 101 /* The ABI specifies that the unwind routines may only use core registers,
 102    except when actually manipulating coprocessor state.  This allows
 103    us to write one implementation that works on all platforms by
 104    demand-saving coprocessor registers.
 105
 106    During unwinding we hold the coprocessor state in the actual hardware
 107    registers and allocate demand-save areas for use during phase1
 108    unwinding.  */
 109
 110 typedef struct
 111 {
 112   /* The first fields must be the same as a phase2_vrs.  */
 113   _uw demand_save_flags;
 114   struct core_regs core;
 115   _uw prev_sp; /* Only valid during forced unwinding.  */
 116   struct vfp_regs vfp;
 117   struct fpa_regs fpa;
 118 } phase1_vrs;
 119
 120 #define DEMAND_SAVE_VFP 1
 121
 122 /* This must match the structure created by the assembly wrappers.  */
 123 typedef struct
 124 {
 125   _uw demand_save_flags;
 126   struct core_regs core;
 127 } phase2_vrs;
 128
 129
 130 /* An exception index table entry.  */
 131
 132 typedef struct __EIT_entry
 133 {
 134   _uw fnoffset;
 135   _uw content;
 136 } __EIT_entry;
 137
 138 /* Assembly helper functions.  */
 139
 140 /* Restore core register state.  Never returns.  */
 141 void __attribute__((noreturn)) restore_core_regs (struct core_regs *);
 142
 143
 144 /* Coprocessor register state manipulation functions.  */
 145
 146 void __gnu_Unwind_Save_VFP (struct vfp_regs * p);
 147 void __gnu_Unwind_Restore_VFP (struct vfp_regs * p);
 148
 149 /* Restore coprocessor state after phase1 unwinding.  */
 150 static void
 151 restore_non_core_regs (phase1_vrs * vrs)
 152 {
 153   if ((vrs->demand_save_flags & DEMAND_SAVE_VFP) == 0)
 154     __gnu_Unwind_Restore_VFP (&vrs->vfp);
 155 }
 156
 157 /* A better way to do this would probably be to compare the absolute address
 158    with a segment relative relocation of the same symbol.  */
 159
 160 extern int __text_start;
 161 extern int __data_start;
 162
 163 /* The exception index table location.  */
 164 extern __EIT_entry __exidx_start;
 165 extern __EIT_entry __exidx_end;
 166
 167 /* ABI defined personality routines.  */
 168 extern _Unwind_Reason_Code __aeabi_unwind_cpp_pr0 (_Unwind_State,
 169     _Unwind_Control_Block *, _Unwind_Context *);// __attribute__((weak));
 170 extern _Unwind_Reason_Code __aeabi_unwind_cpp_pr1 (_Unwind_State,
 171     _Unwind_Control_Block *, _Unwind_Context *) __attribute__((weak));
 172 extern _Unwind_Reason_Code __aeabi_unwind_cpp_pr2 (_Unwind_State,
 173     _Unwind_Control_Block *, _Unwind_Context *) __attribute__((weak));
 174
 175 /* ABI defined routine to store a virtual register to memory.  */
 176
 177 _Unwind_VRS_Result _Unwind_VRS_Get (_Unwind_Context *context,
 178                                     _Unwind_VRS_RegClass regclass,
 179                                     _uw regno,
 180                                     _Unwind_VRS_DataRepresentation representation,
 181                                     void *valuep)
 182 {
 183   phase1_vrs *vrs = (phase1_vrs *) context;
 184
 185   switch (regclass)
 186     {
 187     case _UVRSC_CORE:
 188       if (representation != _UVRSD_UINT32
 189           || regno > 15)
 190         return _UVRSR_FAILED;
 191       *(_uw *) valuep = vrs->core.r[regno];
 192       return _UVRSR_OK;
 193
 194     case _UVRSC_VFP:
 195     case _UVRSC_FPA:
 196     case _UVRSC_WMMXD:
 197     case _UVRSC_WMMXC:
 198       return _UVRSR_NOT_IMPLEMENTED;
 199
 200     default:
 201       return _UVRSR_FAILED;
 202     }
 203 }
 204
 205
 206 /* ABI defined function to load a virtual register from memory.  */
 207
 208 _Unwind_VRS_Result _Unwind_VRS_Set (_Unwind_Context *context,
 209                                     _Unwind_VRS_RegClass regclass,
 210                                     _uw regno,
 211                                     _Unwind_VRS_DataRepresentation representation,
 212                                     void *valuep)
 213 {
 214   phase1_vrs *vrs = (phase1_vrs *) context;
 215
 216   switch (regclass)
 217     {
 218     case _UVRSC_CORE:
 219       if (representation != _UVRSD_UINT32
 220           || regno > 15)
 221         return _UVRSR_FAILED;
 222
 223       vrs->core.r[regno] = *(_uw *) valuep;
 224       return _UVRSR_OK;
 225
 226     case _UVRSC_VFP:
 227     case _UVRSC_FPA:
 228     case _UVRSC_WMMXD:
 229     case _UVRSC_WMMXC:
 230       return _UVRSR_NOT_IMPLEMENTED;
 231
 232     default:
 233       return _UVRSR_FAILED;
 234     }
 235 }
 236
 237
 238 /* ABI defined function to pop registers off the stack.  */
 239
 240 _Unwind_VRS_Result _Unwind_VRS_Pop (_Unwind_Context *context,
 241                                     _Unwind_VRS_RegClass regclass,
 242                                     _uw discriminator,
 243                                     _Unwind_VRS_DataRepresentation representation)
 244 {
 245   phase1_vrs *vrs = (phase1_vrs *) context;
 246
 247   switch (regclass)
 248     {
 249     case _UVRSC_CORE:
 250       {
 251         _uw *ptr;
 252         _uw mask;
 253         int i;
 254
 255         if (representation != _UVRSD_UINT32)
 256           return _UVRSR_FAILED;
 257
 258         mask = discriminator & 0xffff;
 259         ptr = (_uw *) vrs->core.r[R_SP];
 260         /* Pop the requested registers.  */
 261         for (i = 0; i < 16; i++)
 262           {
 263             if (mask & (1 << i))
 264               vrs->core.r[i] = *(ptr++);
 265           }
 266         /* Writeback the stack pointer value if it wasn't restored.  */
 267         if ((mask & (1 << R_SP)) == 0)
 268           vrs->core.r[R_SP] = (_uw) ptr;
 269       }
 270       return _UVRSR_OK;
 271
 272     case _UVRSC_VFP:
 273       {
 274         _uw start = discriminator >> 16;
 275         _uw count = discriminator & 0xffff;
 276         struct vfp_regs tmp;
 277         _uw *sp;
 278         _uw *dest;
 279
 280         if ((representation != _UVRSD_VFPX && representation != _UVRSD_DOUBLE)
 281             || start + count > 16)
 282           return _UVRSR_FAILED;
 283
 284         if (vrs->demand_save_flags & DEMAND_SAVE_VFP)
 285           {
 286             /* Demand-save resisters for stage1.  */
 287             vrs->demand_save_flags &= ~DEMAND_SAVE_VFP;
 288             __gnu_Unwind_Save_VFP (&vrs->vfp);
 289           }
 290
 291         /* Restore the registers from the stack.  Do this by saving the
 292            current VFP registers to a memory area, moving the in-memory
 293            values into that area, and restoring from the whole area.
 294            For _UVRSD_VFPX we assume FSTMX standard format 1.  */
 295         __gnu_Unwind_Save_VFP (&tmp);
 296
 297         /* The stack address is only guaranteed to be word aligned, so
 298            we can't use doubleword copies.  */
 299         sp = (_uw *) vrs->core.r[R_SP];
 300         dest = (_uw *) &tmp.d[start];
 301         count *= 2;
 302         while (count--)
 303           *(dest++) = *(sp++);
 304
 305         /* Skip the pad word */
 306         if (representation == _UVRSD_VFPX)
 307           sp++;
 308
 309         /* Set the new stack pointer.  */
 310         vrs->core.r[R_SP] = (_uw) sp;
 311
 312         /* Reload the registers.  */
 313         __gnu_Unwind_Restore_VFP (&tmp);
 314       }
 315       return _UVRSR_OK;
 316
 317     case _UVRSC_FPA:
 318     case _UVRSC_WMMXD:
 319     case _UVRSC_WMMXC:
 320       return _UVRSR_NOT_IMPLEMENTED;
 321
 322     default:
 323       return _UVRSR_FAILED;
 324     }
 325 }
 326
 327
 328 /* Core unwinding functions.  */
 329
 330 /* Calculate the address encoded by a 31-bit self-relative offset at address
 331    P.  */
 332 static inline _uw
 333 selfrel_offset31 (const _uw *p)
 334 {
 335   _uw offset;
 336
 337   offset = *p;
 338   /* Sign extend to 32 bits.  */
 339   if (offset & (1 << 30))
 340     offset |= 1u << 31;
 341   else
 342     offset &= ~(1u << 31);
 343
 344   return offset + (_uw) p;
 345 }
 346
 347
 348 /* Perform a binary search for RETURN_ADDRESS in TABLE.  The table contains
 349    NREC entries.  */
 350
 351 static const __EIT_entry *
 352 search_EIT_table (const __EIT_entry * table, int nrec, _uw return_address)
 353 {
 354   _uw next_fn;
 355   _uw this_fn;
 356   int n, left, right;
 357
 358   if (nrec == 0)
 359     return (__EIT_entry *) 0;
 360
 361   left = 0;
 362   right = nrec - 1;
 363
 364   while (1)
 365     {
 366       n = (left + right) / 2;
 367       this_fn = selfrel_offset31 (&table[n].fnoffset);
 368       if (n != nrec - 1)
 369         next_fn = selfrel_offset31 (&table[n + 1].fnoffset) - 1;
 370       else
 371         next_fn = (_uw)0 - 1;
 372
 373       if (return_address < this_fn)
 374         {
 375           if (n == left)
 376             return (__EIT_entry *) 0;
 377           right = n - 1;
 378         }
 379       else if (return_address <= next_fn)
 380         return &table[n];
 381       else
 382         left = n + 1;
 383     }
 384 }
 385
 386 /* Find the exception index table eintry for the given address.
 387    Fill in the relevant fields of the UCB.
 388    Returns _URC_FAILURE if an error occurred, _URC_OK on success.  */
 389
 390 static _Unwind_Reason_Code
 391 get_eit_entry (_Unwind_Control_Block *ucbp, _uw return_address)
 392 {
 393   const __EIT_entry * eitp;
 394   int nrec;
 395
 396   /* The return address is the address of the instruction following the
 397      call instruction (plus one in thumb mode).  If this was the last
 398      instruction in the function the address will lie in the following
 399      function.  Subtract 2 from the address so that it points within the call
 400      instruction itself.  */
 401   return_address -= 2;
 402
 403   if (__gnu_Unwind_Find_exidx)
 404     {
 405       eitp = (const __EIT_entry *) __gnu_Unwind_Find_exidx (return_address,
 406                                                             &nrec);
 407       if (!eitp)
 408         {
 409           UCB_PR_ADDR (ucbp) = 0;
 410           return _URC_FAILURE;
 411         }
 412     }
 413   else
 414     {
 415       eitp = &__exidx_start;
 416       nrec = &__exidx_end - &__exidx_start;
 417     }
 418
 419   eitp = search_EIT_table (eitp, nrec, return_address);
 420
 421   if (!eitp)
 422     {
 423       UCB_PR_ADDR (ucbp) = 0;
 424       return _URC_FAILURE;
 425     }
 426   ucbp->pr_cache.fnstart = selfrel_offset31 (&eitp->fnoffset);
 427
 428   /* Can this frame be unwound at all?  */
 429   if (eitp->content == EXIDX_CANTUNWIND)
 430     {
 431       UCB_PR_ADDR (ucbp) = 0;
 432       return _URC_END_OF_STACK;
 433     }
 434
 435   /* Obtain the address of the "real" __EHT_Header word.  */
 436
 437   if (eitp->content & uint32_highbit)
 438     {
 439       /* It is immediate data.  */
 440       ucbp->pr_cache.ehtp = (_Unwind_EHT_Header *)&eitp->content;
 441       ucbp->pr_cache.additional = 1;
 442     }
 443   else
 444     {
 445       /* The low 31 bits of the content field are a self-relative
 446          offset to an _Unwind_EHT_Entry structure.  */
 447       ucbp->pr_cache.ehtp =
 448         (_Unwind_EHT_Header *) selfrel_offset31 (&eitp->content);
 449       ucbp->pr_cache.additional = 0;
 450     }
 451
 452   /* Discover the personality routine address.  */
 453   if (*ucbp->pr_cache.ehtp & (1u << 31))
 454     {
 455       /* One of the predefined standard routines.  */
 456       _uw idx = (*(_uw *) ucbp->pr_cache.ehtp >> 24) & 0xf;
 457       if (idx == 0)
 458         UCB_PR_ADDR (ucbp) = (_uw) &__aeabi_unwind_cpp_pr0;
 459       else if (idx == 1)
 460         UCB_PR_ADDR (ucbp) = (_uw) &__aeabi_unwind_cpp_pr1;
 461       else if (idx == 2)
 462         UCB_PR_ADDR (ucbp) = (_uw) &__aeabi_unwind_cpp_pr2;
 463       else
 464         { /* Failed */
 465           UCB_PR_ADDR (ucbp) = 0;
 466           return _URC_FAILURE;
 467         }
 468     }
 469   else
 470     {
 471       /* Execute region offset to PR */
 472       UCB_PR_ADDR (ucbp) = selfrel_offset31 (ucbp->pr_cache.ehtp);
 473     }
 474   return _URC_OK;
 475 }
 476
 477
 478 /* Perform phase2 unwinding.  VRS is the initial virtual register state.  */
 479
 480 static void __attribute__((noreturn))
 481 unwind_phase2 (_Unwind_Control_Block * ucbp, phase2_vrs * vrs)
 482 {
 483   _Unwind_Reason_Code pr_result;
 484
 485   do
 486     {
 487       /* Find the entry for this routine.  */
 488       if (get_eit_entry (ucbp, vrs->core.r[R_PC]) != _URC_OK)
 489         abort ();
 490
 491       UCB_SAVED_CALLSITE_ADDR (ucbp) = vrs->core.r[R_PC];
 492
 493       /* Call the pr to decide what to do.  */
 494       pr_result = ((personality_routine) UCB_PR_ADDR (ucbp))
 495         (_US_UNWIND_FRAME_STARTING, ucbp, (_Unwind_Context *) vrs);
 496     }
 497   while (pr_result == _URC_CONTINUE_UNWIND);
 498
 499   if (pr_result != _URC_INSTALL_CONTEXT)
 500     abort();
 501
 502   restore_core_regs (&vrs->core);
 503 }
 504
 505 /* Perform phase2 forced unwinding.  */
 506
 507 static _Unwind_Reason_Code
 508 unwind_phase2_forced (_Unwind_Control_Block *ucbp, phase2_vrs *entry_vrs,
 509                       int resuming)
 510 {
 511   _Unwind_Stop_Fn stop_fn = (_Unwind_Stop_Fn) UCB_FORCED_STOP_FN (ucbp);
 512   void *stop_arg = (void *)UCB_FORCED_STOP_ARG (ucbp);
 513   _Unwind_Reason_Code pr_result = 0;
 514   /* We use phase1_vrs here even though we do not demand save, for the
 515      prev_sp field.  */
 516   phase1_vrs saved_vrs, next_vrs;
 517
 518   /* Save the core registers.  */
 519   saved_vrs.core = entry_vrs->core;
 520   /* We don't need to demand-save the non-core registers, because we
 521      unwind in a single pass.  */
 522   saved_vrs.demand_save_flags = 0;
 523
 524   /* Unwind until we reach a propagation barrier.  */
 525   do
 526     {
 527       _Unwind_State action;
 528       _Unwind_Reason_Code entry_code;
 529       _Unwind_Reason_Code stop_code;
 530
 531       /* Find the entry for this routine.  */
 532       entry_code = get_eit_entry (ucbp, saved_vrs.core.r[R_PC]);
 533
 534       if (resuming)
 535         {
 536           action = _US_UNWIND_FRAME_RESUME | _US_FORCE_UNWIND;
 537           resuming = 0;
 538         }
 539       else
 540         action = _US_UNWIND_FRAME_STARTING | _US_FORCE_UNWIND;
 541
 542       if (entry_code == _URC_OK)
 543         {
 544           UCB_SAVED_CALLSITE_ADDR (ucbp) = saved_vrs.core.r[R_PC];
 545
 546           next_vrs = saved_vrs;
 547
 548           /* Call the pr to decide what to do.  */
 549           pr_result = ((personality_routine) UCB_PR_ADDR (ucbp))
 550             (action, ucbp, (void *) &next_vrs);
 551
 552           saved_vrs.prev_sp = next_vrs.core.r[R_SP];
 553         }
 554       else
 555         {
 556           /* Treat any failure as the end of unwinding, to cope more
 557              gracefully with missing EH information.  Mixed EH and
 558              non-EH within one object will usually result in failure,
 559              because the .ARM.exidx tables do not indicate the end
 560              of the code to which they apply; but mixed EH and non-EH
 561              shared objects should return an unwind failure at the
 562              entry of a non-EH shared object.  */
 563           action |= _US_END_OF_STACK;
 564
 565           saved_vrs.prev_sp = saved_vrs.core.r[R_SP];
 566         }
 567
 568       stop_code = stop_fn (1, action, ucbp->exception_class, ucbp,
 569                            (void *)&saved_vrs, stop_arg);
 570       if (stop_code != _URC_NO_REASON)
 571         return _URC_FAILURE;
 572
 573       if (entry_code != _URC_OK)
 574         return entry_code;
 575
 576       saved_vrs = next_vrs;
 577     }
 578   while (pr_result == _URC_CONTINUE_UNWIND);
 579
 580   if (pr_result != _URC_INSTALL_CONTEXT)
 581     {
 582       /* Some sort of failure has occurred in the pr and probably the
 583          pr returned _URC_FAILURE.  */
 584       return _URC_FAILURE;
 585     }
 586
 587   restore_core_regs (&saved_vrs.core);
 588 }
 589
 590 /* This is a very limited implementation of _Unwind_GetCFA.  It returns
 591    the stack pointer as it is about to be unwound, and is only valid
 592    while calling the stop function during forced unwinding.  If the
 593    current personality routine result is going to run a cleanup, this
 594    will not be the CFA; but when the frame is really unwound, it will
 595    be.  */
 596
 597 _Unwind_Word
 598 _Unwind_GetCFA (_Unwind_Context *context)
 599 {
 600   return ((phase1_vrs *) context)->prev_sp;
 601 }
 602
 603 /* Perform phase1 unwinding.  UCBP is the exception being thrown, and
 604    entry_VRS is the register state on entry to _Unwind_RaiseException.  */
 605
 606 _Unwind_Reason_Code
 607 __gnu_Unwind_RaiseException (_Unwind_Control_Block *, phase2_vrs *);
 608
 609 _Unwind_Reason_Code
 610 __gnu_Unwind_RaiseException (_Unwind_Control_Block * ucbp,
 611                              phase2_vrs * entry_vrs)
 612 {
 613   phase1_vrs saved_vrs;
 614   _Unwind_Reason_Code pr_result;
 615
 616   /* Set the pc to the call site.  */
 617   entry_vrs->core.r[R_PC] = entry_vrs->core.r[R_LR];
 618
 619   /* Save the core registers.  */
 620   saved_vrs.core = entry_vrs->core;
 621   /* Set demand-save flags.  */
 622   saved_vrs.demand_save_flags = ~(_uw) 0;
 623
 624   /* Unwind until we reach a propagation barrier.  */
 625   do
 626     {
 627       /* Find the entry for this routine.  */
 628       if ((pr_result = get_eit_entry (ucbp, saved_vrs.core.r[R_PC])) != _URC_OK)
 629         return pr_result;
 630
 631       /* Call the pr to decide what to do.  */
 632       pr_result = ((personality_routine) UCB_PR_ADDR (ucbp))
 633         (_US_VIRTUAL_UNWIND_FRAME, ucbp, (void *) &saved_vrs);
 634     }
 635   while (pr_result == _URC_CONTINUE_UNWIND);
 636
 637   /* We've unwound as far as we want to go, so restore the original
 638      register state.  */
 639   restore_non_core_regs (&saved_vrs);
 640   if (pr_result != _URC_HANDLER_FOUND)
 641     {
 642       /* Some sort of failure has occurred in the pr and probably the
 643          pr returned _URC_FAILURE.  */
 644       return _URC_FAILURE;
 645     }
 646
 647   unwind_phase2 (ucbp, entry_vrs);
 648 }
 649
 650 /* Resume unwinding after a cleanup has been run.  UCBP is the exception
 651    being thrown and ENTRY_VRS is the register state on entry to
 652    _Unwind_Resume.  */
 653 _Unwind_Reason_Code
 654 __gnu_Unwind_ForcedUnwind (_Unwind_Control_Block *,
 655                            _Unwind_Stop_Fn, void *, phase2_vrs *);
 656
 657 _Unwind_Reason_Code
 658 __gnu_Unwind_ForcedUnwind (_Unwind_Control_Block *ucbp,
 659                            _Unwind_Stop_Fn stop_fn, void *stop_arg,
 660                            phase2_vrs *entry_vrs)
 661 {
 662   UCB_FORCED_STOP_FN (ucbp) = (_uw) stop_fn;
 663   UCB_FORCED_STOP_ARG (ucbp) = (_uw) stop_arg;
 664
 665   /* Set the pc to the call site.  */
 666   entry_vrs->core.r[R_PC] = entry_vrs->core.r[R_LR];
 667
 668   return unwind_phase2_forced (ucbp, entry_vrs, 0);
 669 }
 670
 671 _Unwind_Reason_Code
 672 __gnu_Unwind_Resume (_Unwind_Control_Block *, phase2_vrs *);
 673
 674 _Unwind_Reason_Code
 675 __gnu_Unwind_Resume (_Unwind_Control_Block * ucbp, phase2_vrs * entry_vrs)
 676 {
 677   _Unwind_Reason_Code pr_result;
 678
 679   /* Recover the saved address.  */
 680   entry_vrs->core.r[R_PC] = UCB_SAVED_CALLSITE_ADDR (ucbp);
 681
 682   if (UCB_FORCED_STOP_FN (ucbp))
 683     {
 684       unwind_phase2_forced (ucbp, entry_vrs, 1);
 685
 686       /* We can't return failure at this point.  */
 687       abort ();
 688     }
 689
 690   /* Call the cached PR.  */
 691   pr_result = ((personality_routine) UCB_PR_ADDR (ucbp))
 692         (_US_UNWIND_FRAME_RESUME, ucbp, (_Unwind_Context *) entry_vrs);
 693
 694   switch (pr_result)
 695     {
 696     case _URC_INSTALL_CONTEXT:
 697       /* Upload the registers to enter the landing pad.  */
 698       restore_core_regs (&entry_vrs->core);
 699
 700     case _URC_CONTINUE_UNWIND:
 701       /* Continue unwinding the next frame.  */
 702       unwind_phase2 (ucbp, entry_vrs);
 703
 704     default:
 705       abort ();
 706     }
 707 }
 708
 709 _Unwind_Reason_Code
 710 __gnu_Unwind_Resume_or_Rethrow (_Unwind_Control_Block *, phase2_vrs *);
 711
 712 _Unwind_Reason_Code
 713 __gnu_Unwind_Resume_or_Rethrow (_Unwind_Control_Block * ucbp,
 714                                 phase2_vrs * entry_vrs)
 715 {
 716   if (!UCB_FORCED_STOP_FN (ucbp))
 717     return __gnu_Unwind_RaiseException (ucbp, entry_vrs);
 718
 719   /* Set the pc to the call site.  */
 720   entry_vrs->core.r[R_PC] = entry_vrs->core.r[R_LR];
 721   /* Continue unwinding the next frame.  */
 722   return unwind_phase2_forced (ucbp, entry_vrs, 0);
 723 }
 724
 725 /* Clean up an exception object when unwinding is complete.  */
 726 void
 727 _Unwind_Complete (_Unwind_Control_Block * ucbp __attribute__((unused)))
 728 {
 729 }
 730
 731
 732 /* Get the _Unwind_Control_Block from an _Unwind_Context.  */
 733
 734 static inline _Unwind_Control_Block *
 735 unwind_UCB_from_context (_Unwind_Context * context)
 736 {
 737   return (_Unwind_Control_Block *) _Unwind_GetGR (context, R_IP);
 738 }
 739
 740
 741 /* Free an exception.  */
 742
 743 void
 744 _Unwind_DeleteException (_Unwind_Exception * exc)
 745 {
 746   if (exc->exception_cleanup)
 747     (*exc->exception_cleanup) (_URC_FOREIGN_EXCEPTION_CAUGHT, exc);
 748 }
 749
 750
 751 /* Perform stack backtrace through unwind data.  */
 752 _Unwind_Reason_Code
 753 __gnu_Unwind_Backtrace(_Unwind_Trace_Fn trace, void * trace_argument,
 754                        phase2_vrs * entry_vrs);
 755 _Unwind_Reason_Code
 756 __gnu_Unwind_Backtrace(_Unwind_Trace_Fn trace, void * trace_argument,
 757                        phase2_vrs * entry_vrs)
 758 {
 759   phase1_vrs saved_vrs;
 760   _Unwind_Reason_Code code;
 761
 762   _Unwind_Control_Block ucb;
 763   _Unwind_Control_Block *ucbp = &ucb;
 764
 765   /* Set the pc to the call site.  */
 766   entry_vrs->core.r[R_PC] = entry_vrs->core.r[R_LR];
 767
 768   /* Save the core registers.  */
 769   saved_vrs.core = entry_vrs->core;
 770   /* Set demand-save flags.  */
 771   saved_vrs.demand_save_flags = ~(_uw) 0;
 772
 773   do
 774     {
 775       /* Find the entry for this routine.  */
 776       if ((code = get_eit_entry (ucbp, saved_vrs.core.r[R_PC])) != _URC_OK)
 777           break;
 778
 779       /* The dwarf unwinder assumes the context structure holds things
 780          like the function and LSDA pointers.  The ARM implementation
 781          caches these in the exception header (UCB).  To avoid
 782          rewriting everything we make the virtual IP register point at
 783          the UCB.  */
 784       _Unwind_SetGR((_Unwind_Context *)&saved_vrs, 12, (_Unwind_Ptr) ucbp);
 785
 786       /* Call trace function.  */
 787       if ((*trace) ((_Unwind_Context *) &saved_vrs, trace_argument)
 788           != _URC_NO_REASON)
 789         {
 790           code = _URC_FAILURE;
 791           break;
 792         }
 793
 794       /* Call the pr to decide what to do.  */
 795       code = ((personality_routine) UCB_PR_ADDR (ucbp))
 796         (_US_VIRTUAL_UNWIND_FRAME | _US_FORCE_UNWIND,
 797          ucbp, (void *) &saved_vrs);
 798     }
 799   while (code != _URC_END_OF_STACK
 800          && code != _URC_FAILURE);
 801
 802  finish:
 803   restore_non_core_regs (&saved_vrs);
 804   return code;
 805 }
 806
 807
 808 /* Common implementation for ARM ABI defined personality routines.
 809    ID is the index of the personality routine, other arguments are as defined
 810    by __aeabi_unwind_cpp_pr{0,1,2}.  */
 811
 812 static _Unwind_Reason_Code
 813 __gnu_unwind_pr_common (_Unwind_State state,
 814                         _Unwind_Control_Block *ucbp,
 815                         _Unwind_Context *context,
 816                         int id)
 817 {
 818   __gnu_unwind_state uws;
 819   _uw *data;
 820   _uw offset;
 821   _uw len;
 822   _uw rtti_count;
 823   int phase2_call_unexpected_after_unwind = 0;
 824   int in_range = 0;
 825   int forced_unwind = state & _US_FORCE_UNWIND;
 826
 827   state &= _US_ACTION_MASK;
 828
 829   data = (_uw *) ucbp->pr_cache.ehtp;
 830   uws.data = *(data++);
 831   uws.next = data;
 832   if (id == 0)
 833     {
 834       uws.data <<= 8;
 835       uws.words_left = 0;
 836       uws.bytes_left = 3;
 837     }
 838   else
 839     {
 840       uws.words_left = (uws.data >> 16) & 0xff;
 841       uws.data <<= 16;
 842       uws.bytes_left = 2;
 843       data += uws.words_left;
 844     }
 845
 846   /* Restore the saved pointer.  */
 847   if (state == _US_UNWIND_FRAME_RESUME)
 848     data = (_uw *) ucbp->cleanup_cache.bitpattern[0];
 849
 850   if ((ucbp->pr_cache.additional & 1) == 0)
 851     {
 852       /* Process descriptors.  */
 853       while (*data)
 854         {
 855           _uw addr;
 856           _uw fnstart;
 857
 858           if (id == 2)
 859             {
 860               len = ((EHT32 *) data)->length;
 861               offset = ((EHT32 *) data)->offset;
 862               data += 2;
 863             }
 864           else
 865             {
 866               len = ((EHT16 *) data)->length;
 867               offset = ((EHT16 *) data)->offset;
 868               data++;
 869             }
 870
 871           fnstart = ucbp->pr_cache.fnstart + (offset & ~1);
 872           addr = _Unwind_GetGR (context, R_PC);
 873           in_range = (fnstart <= addr && addr < fnstart + (len & ~1));
 874
 875           switch (((offset & 1) << 1) | (len & 1))
 876             {
 877             case 0:
 878               /* Cleanup.  */
 879               if (state != _US_VIRTUAL_UNWIND_FRAME
 880                   && in_range)
 881                 {
 882                   /* Cleanup in range, and we are running cleanups.  */
 883                   _uw lp;
 884
 885                   /* Landing pad address is 31-bit pc-relative offset.  */
 886                   lp = selfrel_offset31 (data);
 887                   data++;
 888                   /* Save the exception data pointer.  */
 889                   ucbp->cleanup_cache.bitpattern[0] = (_uw) data;
 890                   if (!__cxa_begin_cleanup (ucbp))
 891                     return _URC_FAILURE;
 892                   /* Setup the VRS to enter the landing pad.  */
 893                   _Unwind_SetGR (context, R_PC, lp);
 894                   return _URC_INSTALL_CONTEXT;
 895                 }
 896               /* Cleanup not in range, or we are in stage 1.  */
 897               data++;
 898               break;
 899
 900             case 1:
 901               /* Catch handler.  */
 902               if (state == _US_VIRTUAL_UNWIND_FRAME)
 903                 {
 904                   if (in_range)
 905                     {
 906                       /* Check for a barrier.  */
 907                       _uw rtti;
 908                       void *matched;
 909
 910                       /* Check for no-throw areas.  */
 911                       if (data[1] == (_uw) -2)
 912                         return _URC_FAILURE;
 913
 914                       /* The thrown object immediately follows the ECB.  */
 915                       matched = (void *)(ucbp + 1);
 916                       if (data[1] != (_uw) -1)
 917                         {
 918                           /* Match a catch specification.  */
 919                           rtti = _Unwind_decode_target2 ((_uw) &data[1]);
 920                           if (!__cxa_type_match (ucbp, (type_info *) rtti,
 921                                                  &matched))
 922                             matched = (void *)0;
 923                         }
 924
 925                       if (matched)
 926                         {
 927                           ucbp->barrier_cache.sp =
 928                             _Unwind_GetGR (context, R_SP);
 929                           ucbp->barrier_cache.bitpattern[0] = (_uw) matched;
 930                           ucbp->barrier_cache.bitpattern[1] = (_uw) data;
 931                           return _URC_HANDLER_FOUND;
 932                         }
 933                     }
 934                   /* Handler out of range, or not matched.  */
 935                 }
 936               else if (ucbp->barrier_cache.sp == _Unwind_GetGR (context, R_SP)
 937                        && ucbp->barrier_cache.bitpattern[1] == (_uw) data)
 938                 {
 939                   /* Matched a previous propagation barrier.  */
 940                   _uw lp;
 941
 942                   /* Setup for entry to the handler.  */
 943                   lp = selfrel_offset31 (data);
 944                   _Unwind_SetGR (context, R_PC, lp);
 945                   _Unwind_SetGR (context, 0, (_uw) ucbp);
 946                   return _URC_INSTALL_CONTEXT;
 947                 }
 948               /* Catch handler not matched.  Advance to the next descriptor.  */
 949               data += 2;
 950               break;
 951
 952             case 2:
 953               rtti_count = data[0] & 0x7fffffff;
 954               /* Exception specification.  */
 955               if (state == _US_VIRTUAL_UNWIND_FRAME)
 956                 {
 957                   if (in_range && (!forced_unwind || !rtti_count))
 958                     {
 959                       /* Match against the exception specification.  */
 960                       _uw i;
 961                       _uw rtti;
 962                       void *matched;
 963
 964                       for (i = 0; i < rtti_count; i++)
 965                         {
 966                           matched = (void *)(ucbp + 1);
 967                           rtti = _Unwind_decode_target2 ((_uw) &data[i + 1]);
 968                           if (__cxa_type_match (ucbp, (type_info *) rtti,
 969                                                 &matched))
 970                             break;
 971                         }
 972
 973                       if (i == rtti_count)
 974                         {
 975                           /* Exception does not match the spec.  */
 976                           ucbp->barrier_cache.sp =
 977                             _Unwind_GetGR (context, R_SP);
 978                           ucbp->barrier_cache.bitpattern[0] = (_uw) matched;
 979                           ucbp->barrier_cache.bitpattern[1] = (_uw) data;
 980                           return _URC_HANDLER_FOUND;
 981                         }
 982                     }
 983                   /* Handler out of range, or exception is permitted.  */
 984                 }
 985               else if (ucbp->barrier_cache.sp == _Unwind_GetGR (context, R_SP)
 986                        && ucbp->barrier_cache.bitpattern[1] == (_uw) data)
 987                 {
 988                   /* Matched a previous propagation barrier.  */
 989                   _uw lp;
 990                   /* Record the RTTI list for __cxa_call_unexpected.  */
 991                   ucbp->barrier_cache.bitpattern[1] = rtti_count;
 992                   ucbp->barrier_cache.bitpattern[2] = 0;
 993                   ucbp->barrier_cache.bitpattern[3] = 4;
 994                   ucbp->barrier_cache.bitpattern[4] = (_uw) &data[1];
 995
 996                   if (data[0] & uint32_highbit)
 997                     phase2_call_unexpected_after_unwind = 1;
 998                   else
 999                     {
1000                       data += rtti_count + 1;
1001                       /* Setup for entry to the handler.  */
1002                       lp = selfrel_offset31 (data);
1003                       data++;
1004                       _Unwind_SetGR (context, R_PC, lp);
1005                       _Unwind_SetGR (context, 0, (_uw) ucbp);
1006                       return _URC_INSTALL_CONTEXT;
1007                     }
1008                 }
1009               if (data[0] & uint32_highbit)
1010                 data++;
1011               data += rtti_count + 1;
1012               break;
1013
1014             default:
1015               /* Should never happen.  */
1016               return _URC_FAILURE;
1017             }
1018           /* Finished processing this descriptor.  */
1019         }
1020     }
1021
1022   if (__gnu_unwind_execute (context, &uws) != _URC_OK)
1023     return _URC_FAILURE;
1024
1025   if (phase2_call_unexpected_after_unwind)
1026     {
1027       /* Enter __cxa_unexpected as if called from the call site.  */
1028       _Unwind_SetGR (context, R_LR, _Unwind_GetGR (context, R_PC));
1029       _Unwind_SetGR (context, R_PC, (_uw) &__cxa_call_unexpected);
1030       return _URC_INSTALL_CONTEXT;
1031     }
1032
1033   return _URC_CONTINUE_UNWIND;
1034 }
1035
1036
1037 /* ABI defined personality routine entry points.  */
1038
1039 _Unwind_Reason_Code
1040 __aeabi_unwind_cpp_pr0 (_Unwind_State state,
1041                         _Unwind_Control_Block *ucbp,
1042                         _Unwind_Context *context)
1043 {
1044   return __gnu_unwind_pr_common (state, ucbp, context, 0);
1045 }
1046
1047 _Unwind_Reason_Code
1048 __aeabi_unwind_cpp_pr1 (_Unwind_State state,
1049                         _Unwind_Control_Block *ucbp,
1050                         _Unwind_Context *context)
1051 {
1052   return __gnu_unwind_pr_common (state, ucbp, context, 1);
1053 }
1054
1055 _Unwind_Reason_Code
1056 __aeabi_unwind_cpp_pr2 (_Unwind_State state,
1057                         _Unwind_Control_Block *ucbp,
1058                         _Unwind_Context *context)
1059 {
1060   return __gnu_unwind_pr_common (state, ucbp, context, 2);
1061 }
1062
1063 /* These two should never be used.  */
1064 _Unwind_Ptr
1065 _Unwind_GetDataRelBase (_Unwind_Context *context __attribute__ ((unused)))
1066 {
1067   abort ();
1068 }
1069
1070 _Unwind_Ptr
1071 _Unwind_GetTextRelBase (_Unwind_Context *context __attribute__ ((unused)))
1072 {
1073   abort ();
1074 }
1075
1076 #ifdef __FreeBSD__
1077 /* FreeBSD expects these to be functions */
1078 _Unwind_Ptr
1079 _Unwind_GetIP (struct _Unwind_Context *context)
1080 {
1081   return _Unwind_GetGR (context, 15) & ~(_Unwind_Word)1;
1082 }
1083
1084 _Unwind_Ptr
1085 _Unwind_GetIPInfo (struct _Unwind_Context *context, int *ip_before_insn)
1086 {
1087   *ip_before_insn = 0;
1088   return _Unwind_GetGR (context, 15) & ~(_Unwind_Word)1;
1089 }
1090
1091 void
1092 _Unwind_SetIP (struct _Unwind_Context *context, _Unwind_Ptr val)
1093 {
1094   _Unwind_SetGR (context, 15, val | (_Unwind_GetGR (context, 15) & 1));
1095 }
1096
1097 #endif