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 #include "unwind.h"
  29
  30 /* We add a prototype for abort here to avoid creating a dependency on
  31    target headers.  */
  32 extern void abort (void);
  33
  34 /* Definitions for C++ runtime support routines.  We make these weak
  35    declarations to avoid pulling in libsupc++ unnecessarily.  */
  36 typedef unsigned char bool;
  37
  38 typedef struct _ZSt9type_info type_info; /* This names C++ type_info type */
  39
  40 void __attribute__((weak)) __cxa_call_unexpected(_Unwind_Control_Block *ucbp);
  41 bool __attribute__((weak)) __cxa_begin_cleanup(_Unwind_Control_Block *ucbp);
  42 bool __attribute__((weak)) __cxa_type_match(_Unwind_Control_Block *ucbp,
  43                                             const type_info *rttip,
  44                                             bool is_reference,
  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 /* Common implementation for ARM ABI defined personality routines.
 752    ID is the index of the personality routine, other arguments are as defined
 753    by __aeabi_unwind_cpp_pr{0,1,2}.  */
 754
 755 static _Unwind_Reason_Code
 756 __gnu_unwind_pr_common (_Unwind_State state,
 757                         _Unwind_Control_Block *ucbp,
 758                         _Unwind_Context *context,
 759                         int id)
 760 {
 761   __gnu_unwind_state uws;
 762   _uw *data;
 763   _uw offset;
 764   _uw len;
 765   _uw rtti_count;
 766   int phase2_call_unexpected_after_unwind = 0;
 767   int in_range = 0;
 768   int forced_unwind = state & _US_FORCE_UNWIND;
 769
 770   state &= _US_ACTION_MASK;
 771
 772   data = (_uw *) ucbp->pr_cache.ehtp;
 773   uws.data = *(data++);
 774   uws.next = data;
 775   if (id == 0)
 776     {
 777       uws.data <<= 8;
 778       uws.words_left = 0;
 779       uws.bytes_left = 3;
 780     }
 781   else
 782     {
 783       uws.words_left = (uws.data >> 16) & 0xff;
 784       uws.data <<= 16;
 785       uws.bytes_left = 2;
 786       data += uws.words_left;
 787     }
 788
 789   /* Restore the saved pointer.  */
 790   if (state == _US_UNWIND_FRAME_RESUME)
 791     data = (_uw *) ucbp->cleanup_cache.bitpattern[0];
 792
 793   if ((ucbp->pr_cache.additional & 1) == 0)
 794     {
 795       /* Process descriptors.  */
 796       while (*data)
 797         {
 798           _uw addr;
 799           _uw fnstart;
 800
 801           if (id == 2)
 802             {
 803               len = ((EHT32 *) data)->length;
 804               offset = ((EHT32 *) data)->offset;
 805               data += 2;
 806             }
 807           else
 808             {
 809               len = ((EHT16 *) data)->length;
 810               offset = ((EHT16 *) data)->offset;
 811               data++;
 812             }
 813
 814           fnstart = ucbp->pr_cache.fnstart + (offset & ~1);
 815           addr = _Unwind_GetGR (context, R_PC);
 816           in_range = (fnstart <= addr && addr < fnstart + (len & ~1));
 817
 818           switch (((offset & 1) << 1) | (len & 1))
 819             {
 820             case 0:
 821               /* Cleanup.  */
 822               if (state != _US_VIRTUAL_UNWIND_FRAME
 823                   && in_range)
 824                 {
 825                   /* Cleanup in range, and we are running cleanups.  */
 826                   _uw lp;
 827
 828                   /* Landing pad address is 31-bit pc-relative offset.  */
 829                   lp = selfrel_offset31 (data);
 830                   data++;
 831                   /* Save the exception data pointer.  */
 832                   ucbp->cleanup_cache.bitpattern[0] = (_uw) data;
 833                   if (!__cxa_begin_cleanup (ucbp))
 834                     return _URC_FAILURE;
 835                   /* Setup the VRS to enter the landing pad.  */
 836                   _Unwind_SetGR (context, R_PC, lp);
 837                   return _URC_INSTALL_CONTEXT;
 838                 }
 839               /* Cleanup not in range, or we are in stage 1.  */
 840               data++;
 841               break;
 842
 843             case 1:
 844               /* Catch handler.  */
 845               if (state == _US_VIRTUAL_UNWIND_FRAME)
 846                 {
 847                   if (in_range)
 848                     {
 849                       /* Check for a barrier.  */
 850                       _uw rtti;
 851                       bool is_reference = (data[0] & uint32_highbit) != 0;
 852                       void *matched;
 853
 854                       /* Check for no-throw areas.  */
 855                       if (data[1] == (_uw) -2)
 856                         return _URC_FAILURE;
 857
 858                       /* The thrown object immediately follows the ECB.  */
 859                       matched = (void *)(ucbp + 1);
 860                       if (data[1] != (_uw) -1)
 861                         {
 862                           /* Match a catch specification.  */
 863                           rtti = _Unwind_decode_target2 ((_uw) &data[1]);
 864                           if (!__cxa_type_match (ucbp, (type_info *) rtti,
 865                                                  is_reference,
 866                                                  &matched))
 867                             matched = (void *)0;
 868                         }
 869
 870                       if (matched)
 871                         {
 872                           ucbp->barrier_cache.sp =
 873                             _Unwind_GetGR (context, R_SP);
 874                           ucbp->barrier_cache.bitpattern[0] = (_uw) matched;
 875                           ucbp->barrier_cache.bitpattern[1] = (_uw) data;
 876                           return _URC_HANDLER_FOUND;
 877                         }
 878                     }
 879                   /* Handler out of range, or not matched.  */
 880                 }
 881               else if (ucbp->barrier_cache.sp == _Unwind_GetGR (context, R_SP)
 882                        && ucbp->barrier_cache.bitpattern[1] == (_uw) data)
 883                 {
 884                   /* Matched a previous propagation barrier.  */
 885                   _uw lp;
 886
 887                   /* Setup for entry to the handler.  */
 888                   lp = selfrel_offset31 (data);
 889                   _Unwind_SetGR (context, R_PC, lp);
 890                   _Unwind_SetGR (context, 0, (_uw) ucbp);
 891                   return _URC_INSTALL_CONTEXT;
 892                 }
 893               /* Catch handler not matched.  Advance to the next descriptor.  */
 894               data += 2;
 895               break;
 896
 897             case 2:
 898               rtti_count = data[0] & 0x7fffffff;
 899               /* Exception specification.  */
 900               if (state == _US_VIRTUAL_UNWIND_FRAME)
 901                 {
 902                   if (in_range && (!forced_unwind || !rtti_count))
 903                     {
 904                       /* Match against the exception specification.  */
 905                       _uw i;
 906                       _uw rtti;
 907                       void *matched;
 908
 909                       for (i = 0; i < rtti_count; i++)
 910                         {
 911                           matched = (void *)(ucbp + 1);
 912                           rtti = _Unwind_decode_target2 ((_uw) &data[i + 1]);
 913                           if (__cxa_type_match (ucbp, (type_info *) rtti, 0,
 914                                                 &matched))
 915                             break;
 916                         }
 917
 918                       if (i == rtti_count)
 919                         {
 920                           /* Exception does not match the spec.  */
 921                           ucbp->barrier_cache.sp =
 922                             _Unwind_GetGR (context, R_SP);
 923                           ucbp->barrier_cache.bitpattern[0] = (_uw) matched;
 924                           ucbp->barrier_cache.bitpattern[1] = (_uw) data;
 925                           return _URC_HANDLER_FOUND;
 926                         }
 927                     }
 928                   /* Handler out of range, or exception is permitted.  */
 929                 }
 930               else if (ucbp->barrier_cache.sp == _Unwind_GetGR (context, R_SP)
 931                        && ucbp->barrier_cache.bitpattern[1] == (_uw) data)
 932                 {
 933                   /* Matched a previous propagation barrier.  */
 934                   _uw lp;
 935                   /* Record the RTTI list for __cxa_call_unexpected.  */
 936                   ucbp->barrier_cache.bitpattern[1] = rtti_count;
 937                   ucbp->barrier_cache.bitpattern[2] = 0;
 938                   ucbp->barrier_cache.bitpattern[3] = 4;
 939                   ucbp->barrier_cache.bitpattern[4] = (_uw) &data[1];
 940
 941                   if (data[0] & uint32_highbit)
 942                     phase2_call_unexpected_after_unwind = 1;
 943                   else
 944                     {
 945                       data += rtti_count + 1;
 946                       /* Setup for entry to the handler.  */
 947                       lp = selfrel_offset31 (data);
 948                       data++;
 949                       _Unwind_SetGR (context, R_PC, lp);
 950                       _Unwind_SetGR (context, 0, (_uw) ucbp);
 951                       return _URC_INSTALL_CONTEXT;
 952                     }
 953                 }
 954               if (data[0] & uint32_highbit)
 955                 data++;
 956               data += rtti_count + 1;
 957               break;
 958
 959             default:
 960               /* Should never happen.  */
 961               return _URC_FAILURE;
 962             }
 963           /* Finished processing this descriptor.  */
 964         }
 965     }
 966
 967   if (__gnu_unwind_execute (context, &uws) != _URC_OK)
 968     return _URC_FAILURE;
 969
 970   if (phase2_call_unexpected_after_unwind)
 971     {
 972       /* Enter __cxa_unexpected as if called from the call site.  */
 973       _Unwind_SetGR (context, R_LR, _Unwind_GetGR (context, R_PC));
 974       _Unwind_SetGR (context, R_PC, (_uw) &__cxa_call_unexpected);
 975       return _URC_INSTALL_CONTEXT;
 976     }
 977
 978   return _URC_CONTINUE_UNWIND;
 979 }
 980
 981
 982 /* ABI defined personality routine entry points.  */
 983
 984 _Unwind_Reason_Code
 985 __aeabi_unwind_cpp_pr0 (_Unwind_State state,
 986                         _Unwind_Control_Block *ucbp,
 987                         _Unwind_Context *context)
 988 {
 989   return __gnu_unwind_pr_common (state, ucbp, context, 0);
 990 }
 991
 992 _Unwind_Reason_Code
 993 __aeabi_unwind_cpp_pr1 (_Unwind_State state,
 994                         _Unwind_Control_Block *ucbp,
 995                         _Unwind_Context *context)
 996 {
 997   return __gnu_unwind_pr_common (state, ucbp, context, 1);
 998 }
 999
1000 _Unwind_Reason_Code
1001 __aeabi_unwind_cpp_pr2 (_Unwind_State state,
1002                         _Unwind_Control_Block *ucbp,
1003                         _Unwind_Context *context)
1004 {
1005   return __gnu_unwind_pr_common (state, ucbp, context, 2);
1006 }