libgcc/unwind-arm-common.inc

   1 /* Common unwinding code for ARM EABI and C6X.
   2    Copyright (C) 2004-2018 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 3, or (at your option) any
   8    later version.
   9
  10    This file is distributed in the hope that it will be useful, but
  11    WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    General Public License for more details.
  14
  15    Under Section 7 of GPL version 3, you are granted additional
  16    permissions described in the GCC Runtime Library Exception, version
  17    3.1, as published by the Free Software Foundation.
  18
  19    You should have received a copy of the GNU General Public License and
  20    a copy of the GCC Runtime Library Exception along with this program;
  21    see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  22    <http://www.gnu.org/licenses/>.  */
  23
  24 #include "tconfig.h"
  25 #include "tsystem.h"
  26 #include "unwind.h"
  27
  28 /* Used for SystemTap unwinder probe.  */
  29 #ifdef HAVE_SYS_SDT_H
  30 #include <sys/sdt.h>
  31 #endif
  32
  33 /* We add a prototype for abort here to avoid creating a dependency on
  34    target headers.  */
  35 extern void abort (void);
  36
  37 /* Definitions for C++ runtime support routines.  We make these weak
  38    declarations to avoid pulling in libsupc++ unnecessarily.  */
  39 typedef unsigned char bool;
  40
  41 typedef struct _ZSt9type_info type_info; /* This names C++ type_info type */
  42 enum __cxa_type_match_result
  43   {
  44     ctm_failed = 0,
  45     ctm_succeeded = 1,
  46     ctm_succeeded_with_ptr_to_base = 2
  47   };
  48
  49 void __attribute__((weak)) __cxa_call_unexpected(_Unwind_Control_Block *ucbp);
  50 bool __attribute__((weak)) __cxa_begin_cleanup(_Unwind_Control_Block *ucbp);
  51 enum __cxa_type_match_result __attribute__((weak)) __cxa_type_match
  52   (_Unwind_Control_Block *ucbp, const type_info *rttip,
  53    bool is_reference, void **matched_object);
  54
  55 _Unwind_Ptr __attribute__((weak))
  56 __gnu_Unwind_Find_exidx (_Unwind_Ptr, int *);
  57
  58 #define EXIDX_CANTUNWIND 1
  59 #define uint32_highbit (((_uw) 1) << 31)
  60
  61 #define UCB_FORCED_STOP_FN(ucbp) ((ucbp)->unwinder_cache.reserved1)
  62 #define UCB_PR_ADDR(ucbp) ((ucbp)->unwinder_cache.reserved2)
  63 #define UCB_SAVED_CALLSITE_ADDR(ucbp) ((ucbp)->unwinder_cache.reserved3)
  64 #define UCB_FORCED_STOP_ARG(ucbp) ((ucbp)->unwinder_cache.reserved4)
  65
  66 /* Unwind descriptors.  */
  67
  68 typedef struct
  69 {
  70   _uw16 length;
  71   _uw16 offset;
  72 } EHT16;
  73
  74 typedef struct
  75 {
  76   _uw length;
  77   _uw offset;
  78 } EHT32;
  79
  80 /* An exception index table entry.  */
  81
  82 typedef struct __EIT_entry
  83 {
  84   _uw fnoffset;
  85   _uw content;
  86 } __EIT_entry;
  87
  88 /* Assembly helper functions.  */
  89
  90 /* Restore core register state.  Never returns.  */
  91 void __attribute__((noreturn)) restore_core_regs (struct core_regs *);
  92
  93
  94 /* Restore coprocessor state after phase1 unwinding.  */
  95 static void restore_non_core_regs (phase1_vrs * vrs);
  96
  97 /* A better way to do this would probably be to compare the absolute address
  98    with a segment relative relocation of the same symbol.  */
  99
 100 extern int __text_start;
 101 extern int __data_start;
 102
 103 /* The exception index table location.  */
 104 extern __EIT_entry __exidx_start;
 105 extern __EIT_entry __exidx_end;
 106
 107 /* Core unwinding functions.  */
 108
 109 /* Calculate the address encoded by a 31-bit self-relative offset at address
 110    P.  */
 111 static inline _uw selfrel_offset31 (const _uw *p);
 112
 113 static _uw __gnu_unwind_get_pr_addr (int idx);
 114
 115 static void _Unwind_DebugHook (void *, void *)
 116   __attribute__ ((__noinline__, __used__, __noclone__));
 117
 118 /* This function is called during unwinding.  It is intended as a hook
 119    for a debugger to intercept exceptions.  CFA is the CFA of the
 120    target frame.  HANDLER is the PC to which control will be
 121    transferred.  */
 122
 123 static void
 124 _Unwind_DebugHook (void *cfa __attribute__ ((__unused__)),
 125                    void *handler __attribute__ ((__unused__)))
 126 {
 127   /* We only want to use stap probes starting with v3.  Earlier
 128      versions added too much startup cost.  */
 129 #if defined (HAVE_SYS_SDT_H) && defined (STAP_PROBE2) && _SDT_NOTE_TYPE >= 3
 130   STAP_PROBE2 (libgcc, unwind, cfa, handler);
 131 #else
 132   asm ("");
 133 #endif
 134 }
 135
 136 /* This is a wrapper to be called when we need to restore core registers.
 137    It will call `_Unwind_DebugHook' before restoring the registers, thus
 138    making it possible to intercept and debug exceptions.
 139
 140    When calling `_Unwind_DebugHook', the first argument (the CFA) is zero
 141    because we are not interested in it.  However, it must be there (even
 142    being zero) because GDB expects to find it when using the probe.  */
 143
 144 #define uw_restore_core_regs(TARGET, CORE)                                    \
 145   do                                                                          \
 146     {                                                                         \
 147       void *handler = __builtin_frob_return_addr ((void *) VRS_PC (TARGET));  \
 148       _Unwind_DebugHook (0, handler);                                         \
 149       restore_core_regs (CORE);                                               \
 150     }                                                                         \
 151   while (0)
 152
 153 /* Perform a binary search for RETURN_ADDRESS in TABLE.  The table contains
 154    NREC entries.  */
 155
 156 static const __EIT_entry *
 157 search_EIT_table (const __EIT_entry * table, int nrec, _uw return_address)
 158 {
 159   _uw next_fn;
 160   _uw this_fn;
 161   int n, left, right;
 162
 163   if (nrec == 0)
 164     return (__EIT_entry *) 0;
 165
 166   left = 0;
 167   right = nrec - 1;
 168
 169   while (1)
 170     {
 171       n = (left + right) / 2;
 172       this_fn = selfrel_offset31 (&table[n].fnoffset);
 173       if (n != nrec - 1)
 174         next_fn = selfrel_offset31 (&table[n + 1].fnoffset) - 1;
 175       else
 176         next_fn = (_uw)0 - 1;
 177
 178       if (return_address < this_fn)
 179         {
 180           if (n == left)
 181             return (__EIT_entry *) 0;
 182           right = n - 1;
 183         }
 184       else if (return_address <= next_fn)
 185         return &table[n];
 186       else
 187         left = n + 1;
 188     }
 189 }
 190
 191 /* Find the exception index table eintry for the given address.
 192    Fill in the relevant fields of the UCB.
 193    Returns _URC_FAILURE if an error occurred, _URC_OK on success.  */
 194
 195 static _Unwind_Reason_Code
 196 get_eit_entry (_Unwind_Control_Block *ucbp, _uw return_address)
 197 {
 198   const __EIT_entry * eitp;
 199   int nrec;
 200
 201   /* The return address is the address of the instruction following the
 202      call instruction (plus one in thumb mode).  If this was the last
 203      instruction in the function the address will lie in the following
 204      function.  Subtract 2 from the address so that it points within the call
 205      instruction itself.  */
 206   return_address -= 2;
 207
 208   if (__gnu_Unwind_Find_exidx)
 209     {
 210       eitp = (const __EIT_entry *) __gnu_Unwind_Find_exidx (return_address,
 211                                                             &nrec);
 212       if (!eitp)
 213         {
 214           UCB_PR_ADDR (ucbp) = 0;
 215           return _URC_FAILURE;
 216         }
 217     }
 218   else
 219     {
 220       eitp = &__exidx_start;
 221       nrec = &__exidx_end - &__exidx_start;
 222     }
 223
 224   eitp = search_EIT_table (eitp, nrec, return_address);
 225
 226   if (!eitp)
 227     {
 228       UCB_PR_ADDR (ucbp) = 0;
 229       return _URC_FAILURE;
 230     }
 231   ucbp->pr_cache.fnstart = selfrel_offset31 (&eitp->fnoffset);
 232
 233   /* Can this frame be unwound at all?  */
 234   if (eitp->content == EXIDX_CANTUNWIND)
 235     {
 236       UCB_PR_ADDR (ucbp) = 0;
 237       return _URC_END_OF_STACK;
 238     }
 239
 240   /* Obtain the address of the "real" __EHT_Header word.  */
 241
 242   if (eitp->content & uint32_highbit)
 243     {
 244       /* It is immediate data.  */
 245       ucbp->pr_cache.ehtp = (_Unwind_EHT_Header *)&eitp->content;
 246       ucbp->pr_cache.additional = 1;
 247     }
 248   else
 249     {
 250       /* The low 31 bits of the content field are a self-relative
 251          offset to an _Unwind_EHT_Entry structure.  */
 252       ucbp->pr_cache.ehtp =
 253         (_Unwind_EHT_Header *) selfrel_offset31 (&eitp->content);
 254       ucbp->pr_cache.additional = 0;
 255     }
 256
 257   /* Discover the personality routine address.  */
 258   if (*ucbp->pr_cache.ehtp & (1u << 31))
 259     {
 260       /* One of the predefined standard routines.  */
 261       _uw idx = (*(_uw *) ucbp->pr_cache.ehtp >> 24) & 0xf;
 262       UCB_PR_ADDR (ucbp) = __gnu_unwind_get_pr_addr (idx);
 263       if (UCB_PR_ADDR (ucbp) == 0)
 264         {
 265           /* Failed */
 266           return _URC_FAILURE;
 267         }
 268     }
 269   else
 270     {
 271       /* Execute region offset to PR */
 272       UCB_PR_ADDR (ucbp) = selfrel_offset31 (ucbp->pr_cache.ehtp);
 273     }
 274   return _URC_OK;
 275 }
 276
 277
 278 /* Perform phase2 unwinding.  VRS is the initial virtual register state.  */
 279
 280 static void __attribute__((noreturn))
 281 unwind_phase2 (_Unwind_Control_Block * ucbp, phase2_vrs * vrs)
 282 {
 283   _Unwind_Reason_Code pr_result;
 284
 285   do
 286     {
 287       /* Find the entry for this routine.  */
 288       if (get_eit_entry (ucbp, VRS_PC(vrs)) != _URC_OK)
 289         abort ();
 290
 291       UCB_SAVED_CALLSITE_ADDR (ucbp) = VRS_PC(vrs);
 292
 293       /* Call the pr to decide what to do.  */
 294       pr_result = ((personality_routine) UCB_PR_ADDR (ucbp))
 295         (_US_UNWIND_FRAME_STARTING, ucbp, (_Unwind_Context *) vrs);
 296     }
 297   while (pr_result == _URC_CONTINUE_UNWIND);
 298
 299   if (pr_result != _URC_INSTALL_CONTEXT)
 300     abort();
 301
 302   uw_restore_core_regs (vrs, &vrs->core);
 303 }
 304
 305 /* Perform phase2 forced unwinding.  */
 306
 307 static _Unwind_Reason_Code
 308 unwind_phase2_forced (_Unwind_Control_Block *ucbp, phase2_vrs *entry_vrs,
 309                       int resuming)
 310 {
 311   _Unwind_Stop_Fn stop_fn = (_Unwind_Stop_Fn) UCB_FORCED_STOP_FN (ucbp);
 312   void *stop_arg = (void *)UCB_FORCED_STOP_ARG (ucbp);
 313   _Unwind_Reason_Code pr_result = 0;
 314   /* We use phase1_vrs here even though we do not demand save, for the
 315      prev_sp field.  */
 316   phase1_vrs saved_vrs, next_vrs;
 317
 318   /* Save the core registers.  */
 319   saved_vrs.core = entry_vrs->core;
 320   /* We don't need to demand-save the non-core registers, because we
 321      unwind in a single pass.  */
 322   saved_vrs.demand_save_flags = 0;
 323
 324   /* Unwind until we reach a propagation barrier.  */
 325   do
 326     {
 327       _Unwind_State action;
 328       _Unwind_Reason_Code entry_code;
 329       _Unwind_Reason_Code stop_code;
 330
 331       /* Find the entry for this routine.  */
 332       entry_code = get_eit_entry (ucbp, VRS_PC (&saved_vrs));
 333
 334       if (resuming)
 335         {
 336           action = _US_UNWIND_FRAME_RESUME | _US_FORCE_UNWIND;
 337           resuming = 0;
 338         }
 339       else
 340         action = _US_UNWIND_FRAME_STARTING | _US_FORCE_UNWIND;
 341
 342       if (entry_code == _URC_OK)
 343         {
 344           UCB_SAVED_CALLSITE_ADDR (ucbp) = VRS_PC (&saved_vrs);
 345
 346           next_vrs = saved_vrs;
 347
 348           /* Call the pr to decide what to do.  */
 349           pr_result = ((personality_routine) UCB_PR_ADDR (ucbp))
 350             (action, ucbp, (void *) &next_vrs);
 351
 352           saved_vrs.prev_sp = VRS_SP (&next_vrs);
 353         }
 354       else
 355         {
 356           /* Treat any failure as the end of unwinding, to cope more
 357              gracefully with missing EH information.  Mixed EH and
 358              non-EH within one object will usually result in failure,
 359              because the .ARM.exidx tables do not indicate the end
 360              of the code to which they apply; but mixed EH and non-EH
 361              shared objects should return an unwind failure at the
 362              entry of a non-EH shared object.  */
 363           action |= _US_END_OF_STACK;
 364
 365           saved_vrs.prev_sp = VRS_SP (&saved_vrs);
 366         }
 367
 368       stop_code = stop_fn (1, action, ucbp->exception_class, ucbp,
 369                            (void *)&saved_vrs, stop_arg);
 370       if (stop_code != _URC_NO_REASON)
 371         return _URC_FAILURE;
 372
 373       if (entry_code != _URC_OK)
 374         return entry_code;
 375
 376       saved_vrs = next_vrs;
 377     }
 378   while (pr_result == _URC_CONTINUE_UNWIND);
 379
 380   if (pr_result != _URC_INSTALL_CONTEXT)
 381     {
 382       /* Some sort of failure has occurred in the pr and probably the
 383          pr returned _URC_FAILURE.  */
 384       return _URC_FAILURE;
 385     }
 386
 387   uw_restore_core_regs (&saved_vrs, &saved_vrs.core);
 388 }
 389
 390 /* This is a very limited implementation of _Unwind_GetCFA.  It returns
 391    the stack pointer as it is about to be unwound, and is only valid
 392    while calling the stop function during forced unwinding.  If the
 393    current personality routine result is going to run a cleanup, this
 394    will not be the CFA; but when the frame is really unwound, it will
 395    be.  */
 396
 397 _Unwind_Word
 398 _Unwind_GetCFA (_Unwind_Context *context)
 399 {
 400   return ((phase1_vrs *) context)->prev_sp;
 401 }
 402
 403 /* Perform phase1 unwinding.  UCBP is the exception being thrown, and
 404    entry_VRS is the register state on entry to _Unwind_RaiseException.  */
 405
 406 _Unwind_Reason_Code
 407 __gnu_Unwind_RaiseException (_Unwind_Control_Block *, phase2_vrs *);
 408
 409 _Unwind_Reason_Code
 410 __gnu_Unwind_RaiseException (_Unwind_Control_Block * ucbp,
 411                              phase2_vrs * entry_vrs)
 412 {
 413   phase1_vrs saved_vrs;
 414   _Unwind_Reason_Code pr_result;
 415
 416   /* Set the pc to the call site.  */
 417   VRS_PC (entry_vrs) = VRS_RETURN(entry_vrs);
 418
 419   /* Save the core registers.  */
 420   saved_vrs.core = entry_vrs->core;
 421   /* Set demand-save flags.  */
 422   saved_vrs.demand_save_flags = ~(_uw) 0;
 423
 424   /* Unwind until we reach a propagation barrier.  */
 425   do
 426     {
 427       /* Find the entry for this routine.  */
 428       if (get_eit_entry (ucbp, VRS_PC (&saved_vrs)) != _URC_OK)
 429         return _URC_FAILURE;
 430
 431       /* Call the pr to decide what to do.  */
 432       pr_result = ((personality_routine) UCB_PR_ADDR (ucbp))
 433         (_US_VIRTUAL_UNWIND_FRAME, ucbp, (void *) &saved_vrs);
 434     }
 435   while (pr_result == _URC_CONTINUE_UNWIND);
 436
 437   /* We've unwound as far as we want to go, so restore the original
 438      register state.  */
 439   restore_non_core_regs (&saved_vrs);
 440   if (pr_result != _URC_HANDLER_FOUND)
 441     {
 442       /* Some sort of failure has occurred in the pr and probably the
 443          pr returned _URC_FAILURE.  */
 444       return _URC_FAILURE;
 445     }
 446
 447   unwind_phase2 (ucbp, entry_vrs);
 448 }
 449
 450 /* Resume unwinding after a cleanup has been run.  UCBP is the exception
 451    being thrown and ENTRY_VRS is the register state on entry to
 452    _Unwind_Resume.  */
 453 _Unwind_Reason_Code
 454 __gnu_Unwind_ForcedUnwind (_Unwind_Control_Block *,
 455                            _Unwind_Stop_Fn, void *, phase2_vrs *);
 456
 457 _Unwind_Reason_Code
 458 __gnu_Unwind_ForcedUnwind (_Unwind_Control_Block *ucbp,
 459                            _Unwind_Stop_Fn stop_fn, void *stop_arg,
 460                            phase2_vrs *entry_vrs)
 461 {
 462   UCB_FORCED_STOP_FN (ucbp) = (_uw) stop_fn;
 463   UCB_FORCED_STOP_ARG (ucbp) = (_uw) stop_arg;
 464
 465   /* Set the pc to the call site.  */
 466   VRS_PC (entry_vrs) = VRS_RETURN(entry_vrs);
 467
 468   return unwind_phase2_forced (ucbp, entry_vrs, 0);
 469 }
 470
 471 _Unwind_Reason_Code
 472 __gnu_Unwind_Resume (_Unwind_Control_Block *, phase2_vrs *);
 473
 474 _Unwind_Reason_Code
 475 __gnu_Unwind_Resume (_Unwind_Control_Block * ucbp, phase2_vrs * entry_vrs)
 476 {
 477   _Unwind_Reason_Code pr_result;
 478
 479   /* Recover the saved address.  */
 480   VRS_PC (entry_vrs) = UCB_SAVED_CALLSITE_ADDR (ucbp);
 481
 482   if (UCB_FORCED_STOP_FN (ucbp))
 483     {
 484       unwind_phase2_forced (ucbp, entry_vrs, 1);
 485
 486       /* We can't return failure at this point.  */
 487       abort ();
 488     }
 489
 490   /* Call the cached PR.  */
 491   pr_result = ((personality_routine) UCB_PR_ADDR (ucbp))
 492         (_US_UNWIND_FRAME_RESUME, ucbp, (_Unwind_Context *) entry_vrs);
 493
 494   switch (pr_result)
 495     {
 496     case _URC_INSTALL_CONTEXT:
 497       /* Upload the registers to enter the landing pad.  */
 498       uw_restore_core_regs (entry_vrs, &entry_vrs->core);
 499
 500     case _URC_CONTINUE_UNWIND:
 501       /* Continue unwinding the next frame.  */
 502       unwind_phase2 (ucbp, entry_vrs);
 503
 504     default:
 505       abort ();
 506     }
 507 }
 508
 509 _Unwind_Reason_Code
 510 __gnu_Unwind_Resume_or_Rethrow (_Unwind_Control_Block *, phase2_vrs *);
 511
 512 _Unwind_Reason_Code
 513 __gnu_Unwind_Resume_or_Rethrow (_Unwind_Control_Block * ucbp,
 514                                 phase2_vrs * entry_vrs)
 515 {
 516   if (!UCB_FORCED_STOP_FN (ucbp))
 517     return __gnu_Unwind_RaiseException (ucbp, entry_vrs);
 518
 519   /* Set the pc to the call site.  */
 520   VRS_PC (entry_vrs) = VRS_RETURN (entry_vrs);
 521   /* Continue unwinding the next frame.  */
 522   return unwind_phase2_forced (ucbp, entry_vrs, 0);
 523 }
 524
 525 /* Clean up an exception object when unwinding is complete.  */
 526 void
 527 _Unwind_Complete (_Unwind_Control_Block * ucbp __attribute__((unused)))
 528 {
 529 }
 530
 531
 532 /* Free an exception.  */
 533
 534 void
 535 _Unwind_DeleteException (_Unwind_Exception * exc)
 536 {
 537   if (exc->exception_cleanup)
 538     (*exc->exception_cleanup) (_URC_FOREIGN_EXCEPTION_CAUGHT, exc);
 539 }
 540
 541
 542 /* Perform stack backtrace through unwind data.  */
 543 _Unwind_Reason_Code
 544 __gnu_Unwind_Backtrace(_Unwind_Trace_Fn trace, void * trace_argument,
 545                        phase2_vrs * entry_vrs);
 546 _Unwind_Reason_Code
 547 __gnu_Unwind_Backtrace(_Unwind_Trace_Fn trace, void * trace_argument,
 548                        phase2_vrs * entry_vrs)
 549 {
 550   phase1_vrs saved_vrs;
 551   _Unwind_Reason_Code code;
 552
 553   _Unwind_Control_Block ucb;
 554   _Unwind_Control_Block *ucbp = &ucb;
 555
 556   /* Set the pc to the call site.  */
 557   VRS_PC (entry_vrs) = VRS_RETURN (entry_vrs);
 558
 559   /* Save the core registers.  */
 560   saved_vrs.core = entry_vrs->core;
 561   /* Set demand-save flags.  */
 562   saved_vrs.demand_save_flags = ~(_uw) 0;
 563
 564   do
 565     {
 566       /* Find the entry for this routine.  */
 567       if (get_eit_entry (ucbp, VRS_PC (&saved_vrs)) != _URC_OK)
 568         {
 569           code = _URC_FAILURE;
 570           break;
 571         }
 572
 573       /* The dwarf unwinder assumes the context structure holds things
 574          like the function and LSDA pointers.  The ARM implementation
 575          caches these in the exception header (UCB).  To avoid
 576          rewriting everything we make the virtual IP register point at
 577          the UCB.  */
 578       _Unwind_SetGR((_Unwind_Context *)&saved_vrs, UNWIND_POINTER_REG, (_Unwind_Ptr) ucbp);
 579
 580       /* Call trace function.  */
 581       if ((*trace) ((_Unwind_Context *) &saved_vrs, trace_argument)
 582           != _URC_NO_REASON)
 583         {
 584           code = _URC_FAILURE;
 585           break;
 586         }
 587
 588       /* Call the pr to decide what to do.  */
 589       code = ((personality_routine) UCB_PR_ADDR (ucbp))
 590         (_US_VIRTUAL_UNWIND_FRAME | _US_FORCE_UNWIND,
 591          ucbp, (void *) &saved_vrs);
 592     }
 593   while (code != _URC_END_OF_STACK
 594          && code != _URC_FAILURE);
 595
 596   restore_non_core_regs (&saved_vrs);
 597   return code;
 598 }
 599
 600
 601 /* Common implementation for ARM ABI defined personality routines.
 602    ID is the index of the personality routine, other arguments are as defined
 603    by __aeabi_unwind_cpp_pr{0,1,2}.  */
 604
 605 static _Unwind_Reason_Code
 606 __gnu_unwind_pr_common (_Unwind_State state,
 607                         _Unwind_Control_Block *ucbp,
 608                         _Unwind_Context *context,
 609                         int id)
 610 {
 611   __gnu_unwind_state uws;
 612   _uw *data;
 613   _uw offset;
 614   _uw len;
 615   _uw rtti_count;
 616   int phase2_call_unexpected_after_unwind = 0;
 617   int in_range = 0;
 618   int forced_unwind = state & _US_FORCE_UNWIND;
 619
 620   state &= _US_ACTION_MASK;
 621
 622   data = (_uw *) ucbp->pr_cache.ehtp;
 623   uws.data = *(data++);
 624   uws.next = data;
 625   if (id == 0)
 626     {
 627       uws.data <<= 8;
 628       uws.words_left = 0;
 629       uws.bytes_left = 3;
 630     }
 631   else if (id < 3)
 632     {
 633       uws.words_left = (uws.data >> 16) & 0xff;
 634       uws.data <<= 16;
 635       uws.bytes_left = 2;
 636       data += uws.words_left;
 637     }
 638
 639   /* Restore the saved pointer.  */
 640   if (state == _US_UNWIND_FRAME_RESUME)
 641     data = (_uw *) ucbp->cleanup_cache.bitpattern[0];
 642
 643   if ((ucbp->pr_cache.additional & 1) == 0)
 644     {
 645       /* Process descriptors.  */
 646       while (*data)
 647         {
 648           _uw addr;
 649           _uw fnstart;
 650
 651           if (id == 2)
 652             {
 653               len = ((EHT32 *) data)->length;
 654               offset = ((EHT32 *) data)->offset;
 655               data += 2;
 656             }
 657           else
 658             {
 659               len = ((EHT16 *) data)->length;
 660               offset = ((EHT16 *) data)->offset;
 661               data++;
 662             }
 663
 664           fnstart = ucbp->pr_cache.fnstart + (offset & ~1);
 665           addr = _Unwind_GetGR (context, R_PC);
 666           in_range = (fnstart <= addr && addr < fnstart + (len & ~1));
 667
 668           switch (((offset & 1) << 1) | (len & 1))
 669             {
 670             case 0:
 671               /* Cleanup.  */
 672               if (state != _US_VIRTUAL_UNWIND_FRAME
 673                   && in_range)
 674                 {
 675                   /* Cleanup in range, and we are running cleanups.  */
 676                   _uw lp;
 677
 678                   /* Landing pad address is 31-bit pc-relative offset.  */
 679                   lp = selfrel_offset31 (data);
 680                   data++;
 681                   /* Save the exception data pointer.  */
 682                   ucbp->cleanup_cache.bitpattern[0] = (_uw) data;
 683                   if (!__cxa_begin_cleanup (ucbp))
 684                     return _URC_FAILURE;
 685                   /* Setup the VRS to enter the landing pad.  */
 686                   _Unwind_SetGR (context, R_PC, lp);
 687                   return _URC_INSTALL_CONTEXT;
 688                 }
 689               /* Cleanup not in range, or we are in stage 1.  */
 690               data++;
 691               break;
 692
 693             case 1:
 694               /* Catch handler.  */
 695               if (state == _US_VIRTUAL_UNWIND_FRAME)
 696                 {
 697                   if (in_range)
 698                     {
 699                       /* Check for a barrier.  */
 700                       _uw rtti;
 701                       bool is_reference = (data[0] & uint32_highbit) != 0;
 702                       void *matched;
 703                       enum __cxa_type_match_result match_type;
 704
 705                       /* Check for no-throw areas.  */
 706                       if (data[1] == (_uw) -2)
 707                         return _URC_FAILURE;
 708
 709                       /* The thrown object immediately follows the ECB.  */
 710                       matched = (void *)(ucbp + 1);
 711                       if (data[1] != (_uw) -1)
 712                         {
 713                           /* Match a catch specification.  */
 714                           rtti = _Unwind_decode_typeinfo_ptr (0,
 715                                                               (_uw) &data[1]);
 716                           match_type = __cxa_type_match (ucbp,
 717                                                          (type_info *) rtti,
 718                                                          is_reference,
 719                                                          &matched);
 720                         }
 721                       else
 722                         match_type = ctm_succeeded;
 723
 724                       if (match_type)
 725                         {
 726                           ucbp->barrier_cache.sp =
 727                             _Unwind_GetGR (context, R_SP);
 728                           // ctm_succeeded_with_ptr_to_base really
 729                           // means _c_t_m indirected the pointer
 730                           // object.  We have to reconstruct the
 731                           // additional pointer layer by using a temporary.
 732                           if (match_type == ctm_succeeded_with_ptr_to_base)
 733                             {
 734                               ucbp->barrier_cache.bitpattern[2]
 735                                 = (_uw) matched;
 736                               ucbp->barrier_cache.bitpattern[0]
 737                                 = (_uw) &ucbp->barrier_cache.bitpattern[2];
 738                             }
 739                           else
 740                             ucbp->barrier_cache.bitpattern[0] = (_uw) matched;
 741                           ucbp->barrier_cache.bitpattern[1] = (_uw) data;
 742                           return _URC_HANDLER_FOUND;
 743                         }
 744                     }
 745                   /* Handler out of range, or not matched.  */
 746                 }
 747               else if (ucbp->barrier_cache.sp == _Unwind_GetGR (context, R_SP)
 748                        && ucbp->barrier_cache.bitpattern[1] == (_uw) data)
 749                 {
 750                   /* Matched a previous propagation barrier.  */
 751                   _uw lp;
 752
 753                   /* Setup for entry to the handler.  */
 754                   lp = selfrel_offset31 (data);
 755                   _Unwind_SetGR (context, R_PC, lp);
 756                   _Unwind_SetGR (context, 0, (_uw) ucbp);
 757                   return _URC_INSTALL_CONTEXT;
 758                 }
 759               /* Catch handler not matched.  Advance to the next descriptor.  */
 760               data += 2;
 761               break;
 762
 763             case 2:
 764               rtti_count = data[0] & 0x7fffffff;
 765               /* Exception specification.  */
 766               if (state == _US_VIRTUAL_UNWIND_FRAME)
 767                 {
 768                   if (in_range && (!forced_unwind || !rtti_count))
 769                     {
 770                       /* Match against the exception specification.  */
 771                       _uw i;
 772                       _uw rtti;
 773                       void *matched;
 774
 775                       for (i = 0; i < rtti_count; i++)
 776                         {
 777                           matched = (void *)(ucbp + 1);
 778                           rtti = _Unwind_decode_typeinfo_ptr (0,
 779                               (_uw) &data[i + 1]);
 780                           if (__cxa_type_match (ucbp, (type_info *) rtti, 0,
 781                                                 &matched))
 782                             break;
 783                         }
 784
 785                       if (i == rtti_count)
 786                         {
 787                           /* Exception does not match the spec.  */
 788                           ucbp->barrier_cache.sp =
 789                             _Unwind_GetGR (context, R_SP);
 790                           ucbp->barrier_cache.bitpattern[0] = (_uw) matched;
 791                           ucbp->barrier_cache.bitpattern[1] = (_uw) data;
 792                           return _URC_HANDLER_FOUND;
 793                         }
 794                     }
 795                   /* Handler out of range, or exception is permitted.  */
 796                 }
 797               else if (ucbp->barrier_cache.sp == _Unwind_GetGR (context, R_SP)
 798                        && ucbp->barrier_cache.bitpattern[1] == (_uw) data)
 799                 {
 800                   /* Matched a previous propagation barrier.  */
 801                   _uw lp;
 802                   /* Record the RTTI list for __cxa_call_unexpected.  */
 803                   ucbp->barrier_cache.bitpattern[1] = rtti_count;
 804                   ucbp->barrier_cache.bitpattern[2] = 0;
 805                   ucbp->barrier_cache.bitpattern[3] = 4;
 806                   ucbp->barrier_cache.bitpattern[4] = (_uw) &data[1];
 807
 808                   if (data[0] & uint32_highbit)
 809                     {
 810                       data += rtti_count + 1;
 811                       /* Setup for entry to the handler.  */
 812                       lp = selfrel_offset31 (data);
 813                       data++;
 814                       _Unwind_SetGR (context, R_PC, lp);
 815                       _Unwind_SetGR (context, 0, (_uw) ucbp);
 816                       return _URC_INSTALL_CONTEXT;
 817                     }
 818                   else
 819                     phase2_call_unexpected_after_unwind = 1;
 820                 }
 821               if (data[0] & uint32_highbit)
 822                 data++;
 823               data += rtti_count + 1;
 824               break;
 825
 826             default:
 827               /* Should never happen.  */
 828               return _URC_FAILURE;
 829             }
 830           /* Finished processing this descriptor.  */
 831         }
 832     }
 833
 834   if (id >= 3)
 835     {
 836       /* 24-bit ecoding */
 837       if (__gnu_unwind_24bit (context, uws.data, id == 4) != _URC_OK)
 838         return _URC_FAILURE;
 839     }
 840   else
 841     {
 842       if (__gnu_unwind_execute (context, &uws) != _URC_OK)
 843         return _URC_FAILURE;
 844     }
 845
 846   if (phase2_call_unexpected_after_unwind)
 847     {
 848       /* Enter __cxa_unexpected as if called from the call site.  */
 849       _Unwind_SetGR (context, R_LR, _Unwind_GetGR (context, R_PC));
 850       _Unwind_SetGR (context, R_PC, (_uw) &__cxa_call_unexpected);
 851       return _URC_INSTALL_CONTEXT;
 852     }
 853
 854   return _URC_CONTINUE_UNWIND;
 855 }