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 (get_eit_entry (ucbp, saved_vrs.core.r[R_PC]) != _URC_OK)
 629         return _URC_FAILURE;
 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 (get_eit_entry (ucbp, saved_vrs.core.r[R_PC]) != _URC_OK)
 777         {
 778           code = _URC_FAILURE;
 779           break;
 780         }
 781
 782       /* The dwarf unwinder assumes the context structure holds things
 783          like the function and LSDA pointers.  The ARM implementation
 784          caches these in the exception header (UCB).  To avoid
 785          rewriting everything we make the virtual IP register point at
 786          the UCB.  */
 787       _Unwind_SetGR((_Unwind_Context *)&saved_vrs, 12, (_Unwind_Ptr) ucbp);
 788
 789       /* Call trace function.  */
 790       if ((*trace) ((_Unwind_Context *) &saved_vrs, trace_argument)
 791           != _URC_NO_REASON)
 792         {
 793           code = _URC_FAILURE;
 794           break;
 795         }
 796
 797       /* Call the pr to decide what to do.  */
 798       code = ((personality_routine) UCB_PR_ADDR (ucbp))
 799         (_US_VIRTUAL_UNWIND_FRAME | _US_FORCE_UNWIND,
 800          ucbp, (void *) &saved_vrs);
 801     }
 802   while (code != _URC_END_OF_STACK
 803          && code != _URC_FAILURE);
 804
 805  finish:
 806   restore_non_core_regs (&saved_vrs);
 807   return code;
 808 }
 809
 810
 811 /* Common implementation for ARM ABI defined personality routines.
 812    ID is the index of the personality routine, other arguments are as defined
 813    by __aeabi_unwind_cpp_pr{0,1,2}.  */
 814
 815 static _Unwind_Reason_Code
 816 __gnu_unwind_pr_common (_Unwind_State state,
 817                         _Unwind_Control_Block *ucbp,
 818                         _Unwind_Context *context,
 819                         int id)
 820 {
 821   __gnu_unwind_state uws;
 822   _uw *data;
 823   _uw offset;
 824   _uw len;
 825   _uw rtti_count;
 826   int phase2_call_unexpected_after_unwind = 0;
 827   int in_range = 0;
 828   int forced_unwind = state & _US_FORCE_UNWIND;
 829
 830   state &= _US_ACTION_MASK;
 831
 832   data = (_uw *) ucbp->pr_cache.ehtp;
 833   uws.data = *(data++);
 834   uws.next = data;
 835   if (id == 0)
 836     {
 837       uws.data <<= 8;
 838       uws.words_left = 0;
 839       uws.bytes_left = 3;
 840     }
 841   else
 842     {
 843       uws.words_left = (uws.data >> 16) & 0xff;
 844       uws.data <<= 16;
 845       uws.bytes_left = 2;
 846       data += uws.words_left;
 847     }
 848
 849   /* Restore the saved pointer.  */
 850   if (state == _US_UNWIND_FRAME_RESUME)
 851     data = (_uw *) ucbp->cleanup_cache.bitpattern[0];
 852
 853   if ((ucbp->pr_cache.additional & 1) == 0)
 854     {
 855       /* Process descriptors.  */
 856       while (*data)
 857         {
 858           _uw addr;
 859           _uw fnstart;
 860
 861           if (id == 2)
 862             {
 863               len = ((EHT32 *) data)->length;
 864               offset = ((EHT32 *) data)->offset;
 865               data += 2;
 866             }
 867           else
 868             {
 869               len = ((EHT16 *) data)->length;
 870               offset = ((EHT16 *) data)->offset;
 871               data++;
 872             }
 873
 874           fnstart = ucbp->pr_cache.fnstart + (offset & ~1);
 875           addr = _Unwind_GetGR (context, R_PC);
 876           in_range = (fnstart <= addr && addr < fnstart + (len & ~1));
 877
 878           switch (((offset & 1) << 1) | (len & 1))
 879             {
 880             case 0:
 881               /* Cleanup.  */
 882               if (state != _US_VIRTUAL_UNWIND_FRAME
 883                   && in_range)
 884                 {
 885                   /* Cleanup in range, and we are running cleanups.  */
 886                   _uw lp;
 887
 888                   /* Landing pad address is 31-bit pc-relative offset.  */
 889                   lp = selfrel_offset31 (data);
 890                   data++;
 891                   /* Save the exception data pointer.  */
 892                   ucbp->cleanup_cache.bitpattern[0] = (_uw) data;
 893                   if (!__cxa_begin_cleanup (ucbp))
 894                     return _URC_FAILURE;
 895                   /* Setup the VRS to enter the landing pad.  */
 896                   _Unwind_SetGR (context, R_PC, lp);
 897                   return _URC_INSTALL_CONTEXT;
 898                 }
 899               /* Cleanup not in range, or we are in stage 1.  */
 900               data++;
 901               break;
 902
 903             case 1:
 904               /* Catch handler.  */
 905               if (state == _US_VIRTUAL_UNWIND_FRAME)
 906                 {
 907                   if (in_range)
 908                     {
 909                       /* Check for a barrier.  */
 910                       _uw rtti;
 911                       void *matched;
 912
 913                       /* Check for no-throw areas.  */
 914                       if (data[1] == (_uw) -2)
 915                         return _URC_FAILURE;
 916
 917                       /* The thrown object immediately follows the ECB.  */
 918                       matched = (void *)(ucbp + 1);
 919                       if (data[1] != (_uw) -1)
 920                         {
 921                           /* Match a catch specification.  */
 922                           rtti = _Unwind_decode_target2 ((_uw) &data[1]);
 923                           if (!__cxa_type_match (ucbp, (type_info *) rtti,
 924                                                  &matched))
 925                             matched = (void *)0;
 926                         }
 927
 928                       if (matched)
 929                         {
 930                           ucbp->barrier_cache.sp =
 931                             _Unwind_GetGR (context, R_SP);
 932                           ucbp->barrier_cache.bitpattern[0] = (_uw) matched;
 933                           ucbp->barrier_cache.bitpattern[1] = (_uw) data;
 934                           return _URC_HANDLER_FOUND;
 935                         }
 936                     }
 937                   /* Handler out of range, or not matched.  */
 938                 }
 939               else if (ucbp->barrier_cache.sp == _Unwind_GetGR (context, R_SP)
 940                        && ucbp->barrier_cache.bitpattern[1] == (_uw) data)
 941                 {
 942                   /* Matched a previous propagation barrier.  */
 943                   _uw lp;
 944
 945                   /* Setup for entry to the handler.  */
 946                   lp = selfrel_offset31 (data);
 947                   _Unwind_SetGR (context, R_PC, lp);
 948                   _Unwind_SetGR (context, 0, (_uw) ucbp);
 949                   return _URC_INSTALL_CONTEXT;
 950                 }
 951               /* Catch handler not matched.  Advance to the next descriptor.  */
 952               data += 2;
 953               break;
 954
 955             case 2:
 956               rtti_count = data[0] & 0x7fffffff;
 957               /* Exception specification.  */
 958               if (state == _US_VIRTUAL_UNWIND_FRAME)
 959                 {
 960                   if (in_range && (!forced_unwind || !rtti_count))
 961                     {
 962                       /* Match against the exception specification.  */
 963                       _uw i;
 964                       _uw rtti;
 965                       void *matched;
 966
 967                       for (i = 0; i < rtti_count; i++)
 968                         {
 969                           matched = (void *)(ucbp + 1);
 970                           rtti = _Unwind_decode_target2 ((_uw) &data[i + 1]);
 971                           if (__cxa_type_match (ucbp, (type_info *) rtti,
 972                                                 &matched))
 973                             break;
 974                         }
 975
 976                       if (i == rtti_count)
 977                         {
 978                           /* Exception does not match the spec.  */
 979                           ucbp->barrier_cache.sp =
 980                             _Unwind_GetGR (context, R_SP);
 981                           ucbp->barrier_cache.bitpattern[0] = (_uw) matched;
 982                           ucbp->barrier_cache.bitpattern[1] = (_uw) data;
 983                           return _URC_HANDLER_FOUND;
 984                         }
 985                     }
 986                   /* Handler out of range, or exception is permitted.  */
 987                 }
 988               else if (ucbp->barrier_cache.sp == _Unwind_GetGR (context, R_SP)
 989                        && ucbp->barrier_cache.bitpattern[1] == (_uw) data)
 990                 {
 991                   /* Matched a previous propagation barrier.  */
 992                   _uw lp;
 993                   /* Record the RTTI list for __cxa_call_unexpected.  */
 994                   ucbp->barrier_cache.bitpattern[1] = rtti_count;
 995                   ucbp->barrier_cache.bitpattern[2] = 0;
 996                   ucbp->barrier_cache.bitpattern[3] = 4;
 997                   ucbp->barrier_cache.bitpattern[4] = (_uw) &data[1];
 998
 999                   if (data[0] & uint32_highbit)
1000                     phase2_call_unexpected_after_unwind = 1;
1001                   else
1002                     {
1003                       data += rtti_count + 1;
1004                       /* Setup for entry to the handler.  */
1005                       lp = selfrel_offset31 (data);
1006                       data++;
1007                       _Unwind_SetGR (context, R_PC, lp);
1008                       _Unwind_SetGR (context, 0, (_uw) ucbp);
1009                       return _URC_INSTALL_CONTEXT;
1010                     }
1011                 }
1012               if (data[0] & uint32_highbit)
1013                 data++;
1014               data += rtti_count + 1;
1015               break;
1016
1017             default:
1018               /* Should never happen.  */
1019               return _URC_FAILURE;
1020             }
1021           /* Finished processing this descriptor.  */
1022         }
1023     }
1024
1025   if (__gnu_unwind_execute (context, &uws) != _URC_OK)
1026     return _URC_FAILURE;
1027
1028   if (phase2_call_unexpected_after_unwind)
1029     {
1030       /* Enter __cxa_unexpected as if called from the call site.  */
1031       _Unwind_SetGR (context, R_LR, _Unwind_GetGR (context, R_PC));
1032       _Unwind_SetGR (context, R_PC, (_uw) &__cxa_call_unexpected);
1033       return _URC_INSTALL_CONTEXT;
1034     }
1035
1036   return _URC_CONTINUE_UNWIND;
1037 }
1038
1039
1040 /* ABI defined personality routine entry points.  */
1041
1042 _Unwind_Reason_Code
1043 __aeabi_unwind_cpp_pr0 (_Unwind_State state,
1044                         _Unwind_Control_Block *ucbp,
1045                         _Unwind_Context *context)
1046 {
1047   return __gnu_unwind_pr_common (state, ucbp, context, 0);
1048 }
1049
1050 _Unwind_Reason_Code
1051 __aeabi_unwind_cpp_pr1 (_Unwind_State state,
1052                         _Unwind_Control_Block *ucbp,
1053                         _Unwind_Context *context)
1054 {
1055   return __gnu_unwind_pr_common (state, ucbp, context, 1);
1056 }
1057
1058 _Unwind_Reason_Code
1059 __aeabi_unwind_cpp_pr2 (_Unwind_State state,
1060                         _Unwind_Control_Block *ucbp,
1061                         _Unwind_Context *context)
1062 {
1063   return __gnu_unwind_pr_common (state, ucbp, context, 2);
1064 }
1065
1066 /* These two should never be used.  */
1067 _Unwind_Ptr
1068 _Unwind_GetDataRelBase (_Unwind_Context *context __attribute__ ((unused)))
1069 {
1070   abort ();
1071 }
1072
1073 _Unwind_Ptr
1074 _Unwind_GetTextRelBase (_Unwind_Context *context __attribute__ ((unused)))
1075 {
1076   abort ();
1077 }
1078
1079 #ifdef __FreeBSD__
1080 /* FreeBSD expects these to be functions */
1081 _Unwind_Ptr
1082 _Unwind_GetIP (struct _Unwind_Context *context)
1083 {
1084   return _Unwind_GetGR (context, 15) & ~(_Unwind_Word)1;
1085 }
1086
1087 _Unwind_Ptr
1088 _Unwind_GetIPInfo (struct _Unwind_Context *context, int *ip_before_insn)
1089 {
1090   *ip_before_insn = 0;
1091   return _Unwind_GetGR (context, 15) & ~(_Unwind_Word)1;
1092 }
1093
1094 void
1095 _Unwind_SetIP (struct _Unwind_Context *context, _Unwind_Ptr val)
1096 {
1097   _Unwind_SetGR (context, 15, val | (_Unwind_GetGR (context, 15) & 1));
1098 }
1099
1100 #endif