1 /* ARM EABI compliant unwinding routines.
2 Copyright (C) 2004, 2005 Free Software Foundation, Inc.
3 Contributed by Paul Brook
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
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
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.
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
31 /* We add a prototype for abort here to avoid creating a dependency on
33 extern void abort (void);
35 /* Definitions for C++ runtime support routines. We make these weak
36 declarations to avoid pulling in libsupc++ unnecessarily. */
37 typedef unsigned char bool;
39 typedef struct _ZSt9type_info type_info; /* This names C++ type_info type */
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);
47 _Unwind_Ptr __attribute__((weak))
48 __gnu_Unwind_Find_exidx (_Unwind_Ptr, int *);
56 #define EXIDX_CANTUNWIND 1
57 #define uint32_highbit (((_uw) 1) << 31)
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)
69 /* We use normal integer types here to avoid the compiler generating
70 coprocessor instructions. */
87 /* Unwind descriptors. */
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.
106 During unwinding we hold the coprocessor state in the actual hardware
107 registers and allocate demand-save areas for use during phase1
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. */
120 #define DEMAND_SAVE_VFP 1
122 /* This must match the structure created by the assembly wrappers. */
125 _uw demand_save_flags;
126 struct core_regs core;
130 /* An exception index table entry. */
132 typedef struct __EIT_entry
138 /* Assembly helper functions. */
140 /* Restore core register state. Never returns. */
141 void __attribute__((noreturn)) restore_core_regs (struct core_regs *);
144 /* Coprocessor register state manipulation functions. */
146 void __gnu_Unwind_Save_VFP (struct vfp_regs * p);
147 void __gnu_Unwind_Restore_VFP (struct vfp_regs * p);
149 /* Restore coprocessor state after phase1 unwinding. */
151 restore_non_core_regs (phase1_vrs * vrs)
153 if ((vrs->demand_save_flags & DEMAND_SAVE_VFP) == 0)
154 __gnu_Unwind_Restore_VFP (&vrs->vfp);
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. */
160 extern int __text_start;
161 extern int __data_start;
163 /* The exception index table location. */
164 extern __EIT_entry __exidx_start;
165 extern __EIT_entry __exidx_end;
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));
175 /* ABI defined routine to store a virtual register to memory. */
177 _Unwind_VRS_Result _Unwind_VRS_Get (_Unwind_Context *context,
178 _Unwind_VRS_RegClass regclass,
180 _Unwind_VRS_DataRepresentation representation,
183 phase1_vrs *vrs = (phase1_vrs *) context;
188 if (representation != _UVRSD_UINT32
190 return _UVRSR_FAILED;
191 *(_uw *) valuep = vrs->core.r[regno];
198 return _UVRSR_NOT_IMPLEMENTED;
201 return _UVRSR_FAILED;
206 /* ABI defined function to load a virtual register from memory. */
208 _Unwind_VRS_Result _Unwind_VRS_Set (_Unwind_Context *context,
209 _Unwind_VRS_RegClass regclass,
211 _Unwind_VRS_DataRepresentation representation,
214 phase1_vrs *vrs = (phase1_vrs *) context;
219 if (representation != _UVRSD_UINT32
221 return _UVRSR_FAILED;
223 vrs->core.r[regno] = *(_uw *) valuep;
230 return _UVRSR_NOT_IMPLEMENTED;
233 return _UVRSR_FAILED;
238 /* ABI defined function to pop registers off the stack. */
240 _Unwind_VRS_Result _Unwind_VRS_Pop (_Unwind_Context *context,
241 _Unwind_VRS_RegClass regclass,
243 _Unwind_VRS_DataRepresentation representation)
245 phase1_vrs *vrs = (phase1_vrs *) context;
255 if (representation != _UVRSD_UINT32)
256 return _UVRSR_FAILED;
258 mask = discriminator & 0xffff;
259 ptr = (_uw *) vrs->core.r[R_SP];
260 /* Pop the requested registers. */
261 for (i = 0; i < 16; i++)
264 vrs->core.r[i] = *(ptr++);
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;
274 _uw start = discriminator >> 16;
275 _uw count = discriminator & 0xffff;
280 if ((representation != _UVRSD_VFPX && representation != _UVRSD_DOUBLE)
281 || start + count > 16)
282 return _UVRSR_FAILED;
284 if (vrs->demand_save_flags & DEMAND_SAVE_VFP)
286 /* Demand-save resisters for stage1. */
287 vrs->demand_save_flags &= ~DEMAND_SAVE_VFP;
288 __gnu_Unwind_Save_VFP (&vrs->vfp);
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);
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];
305 /* Skip the pad word */
306 if (representation == _UVRSD_VFPX)
309 /* Set the new stack pointer. */
310 vrs->core.r[R_SP] = (_uw) sp;
312 /* Reload the registers. */
313 __gnu_Unwind_Restore_VFP (&tmp);
320 return _UVRSR_NOT_IMPLEMENTED;
323 return _UVRSR_FAILED;
328 /* Core unwinding functions. */
330 /* Calculate the address encoded by a 31-bit self-relative offset at address
333 selfrel_offset31 (const _uw *p)
338 /* Sign extend to 32 bits. */
339 if (offset & (1 << 30))
342 offset &= ~(1u << 31);
344 return offset + (_uw) p;
348 /* Perform a binary search for RETURN_ADDRESS in TABLE. The table contains
351 static const __EIT_entry *
352 search_EIT_table (const __EIT_entry * table, int nrec, _uw return_address)
359 return (__EIT_entry *) 0;
366 n = (left + right) / 2;
367 this_fn = selfrel_offset31 (&table[n].fnoffset);
369 next_fn = selfrel_offset31 (&table[n + 1].fnoffset) - 1;
371 next_fn = (_uw)0 - 1;
373 if (return_address < this_fn)
376 return (__EIT_entry *) 0;
379 else if (return_address <= next_fn)
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. */
390 static _Unwind_Reason_Code
391 get_eit_entry (_Unwind_Control_Block *ucbp, _uw return_address)
393 const __EIT_entry * eitp;
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. */
403 if (__gnu_Unwind_Find_exidx)
405 eitp = (const __EIT_entry *) __gnu_Unwind_Find_exidx (return_address,
409 UCB_PR_ADDR (ucbp) = 0;
415 eitp = &__exidx_start;
416 nrec = &__exidx_end - &__exidx_start;
419 eitp = search_EIT_table (eitp, nrec, return_address);
423 UCB_PR_ADDR (ucbp) = 0;
426 ucbp->pr_cache.fnstart = selfrel_offset31 (&eitp->fnoffset);
428 /* Can this frame be unwound at all? */
429 if (eitp->content == EXIDX_CANTUNWIND)
431 UCB_PR_ADDR (ucbp) = 0;
432 return _URC_END_OF_STACK;
435 /* Obtain the address of the "real" __EHT_Header word. */
437 if (eitp->content & uint32_highbit)
439 /* It is immediate data. */
440 ucbp->pr_cache.ehtp = (_Unwind_EHT_Header *)&eitp->content;
441 ucbp->pr_cache.additional = 1;
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;
452 /* Discover the personality routine address. */
453 if (*ucbp->pr_cache.ehtp & (1u << 31))
455 /* One of the predefined standard routines. */
456 _uw idx = (*(_uw *) ucbp->pr_cache.ehtp >> 24) & 0xf;
458 UCB_PR_ADDR (ucbp) = (_uw) &__aeabi_unwind_cpp_pr0;
460 UCB_PR_ADDR (ucbp) = (_uw) &__aeabi_unwind_cpp_pr1;
462 UCB_PR_ADDR (ucbp) = (_uw) &__aeabi_unwind_cpp_pr2;
465 UCB_PR_ADDR (ucbp) = 0;
471 /* Execute region offset to PR */
472 UCB_PR_ADDR (ucbp) = selfrel_offset31 (ucbp->pr_cache.ehtp);
478 /* Perform phase2 unwinding. VRS is the initial virtual register state. */
480 static void __attribute__((noreturn))
481 unwind_phase2 (_Unwind_Control_Block * ucbp, phase2_vrs * vrs)
483 _Unwind_Reason_Code pr_result;
487 /* Find the entry for this routine. */
488 if (get_eit_entry (ucbp, vrs->core.r[R_PC]) != _URC_OK)
491 UCB_SAVED_CALLSITE_ADDR (ucbp) = vrs->core.r[R_PC];
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);
497 while (pr_result == _URC_CONTINUE_UNWIND);
499 if (pr_result != _URC_INSTALL_CONTEXT)
502 restore_core_regs (&vrs->core);
505 /* Perform phase2 forced unwinding. */
507 static _Unwind_Reason_Code
508 unwind_phase2_forced (_Unwind_Control_Block *ucbp, phase2_vrs *entry_vrs,
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
516 phase1_vrs saved_vrs, next_vrs;
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;
524 /* Unwind until we reach a propagation barrier. */
527 _Unwind_State action;
528 _Unwind_Reason_Code entry_code;
529 _Unwind_Reason_Code stop_code;
531 /* Find the entry for this routine. */
532 entry_code = get_eit_entry (ucbp, saved_vrs.core.r[R_PC]);
536 action = _US_UNWIND_FRAME_RESUME | _US_FORCE_UNWIND;
540 action = _US_UNWIND_FRAME_STARTING | _US_FORCE_UNWIND;
542 if (entry_code == _URC_OK)
544 UCB_SAVED_CALLSITE_ADDR (ucbp) = saved_vrs.core.r[R_PC];
546 next_vrs = saved_vrs;
548 /* Call the pr to decide what to do. */
549 pr_result = ((personality_routine) UCB_PR_ADDR (ucbp))
550 (action, ucbp, (void *) &next_vrs);
552 saved_vrs.prev_sp = next_vrs.core.r[R_SP];
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;
565 saved_vrs.prev_sp = saved_vrs.core.r[R_SP];
568 stop_code = stop_fn (1, action, ucbp->exception_class, ucbp,
569 (void *)&saved_vrs, stop_arg);
570 if (stop_code != _URC_NO_REASON)
573 if (entry_code != _URC_OK)
576 saved_vrs = next_vrs;
578 while (pr_result == _URC_CONTINUE_UNWIND);
580 if (pr_result != _URC_INSTALL_CONTEXT)
582 /* Some sort of failure has occurred in the pr and probably the
583 pr returned _URC_FAILURE. */
587 restore_core_regs (&saved_vrs.core);
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
598 _Unwind_GetCFA (_Unwind_Context *context)
600 return ((phase1_vrs *) context)->prev_sp;
603 /* Perform phase1 unwinding. UCBP is the exception being thrown, and
604 entry_VRS is the register state on entry to _Unwind_RaiseException. */
607 __gnu_Unwind_RaiseException (_Unwind_Control_Block *, phase2_vrs *);
610 __gnu_Unwind_RaiseException (_Unwind_Control_Block * ucbp,
611 phase2_vrs * entry_vrs)
613 phase1_vrs saved_vrs;
614 _Unwind_Reason_Code pr_result;
616 /* Set the pc to the call site. */
617 entry_vrs->core.r[R_PC] = entry_vrs->core.r[R_LR];
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;
624 /* Unwind until we reach a propagation barrier. */
627 /* Find the entry for this routine. */
628 if (get_eit_entry (ucbp, saved_vrs.core.r[R_PC]) != _URC_OK)
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);
635 while (pr_result == _URC_CONTINUE_UNWIND);
637 /* We've unwound as far as we want to go, so restore the original
639 restore_non_core_regs (&saved_vrs);
640 if (pr_result != _URC_HANDLER_FOUND)
642 /* Some sort of failure has occurred in the pr and probably the
643 pr returned _URC_FAILURE. */
647 unwind_phase2 (ucbp, entry_vrs);
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
654 __gnu_Unwind_ForcedUnwind (_Unwind_Control_Block *,
655 _Unwind_Stop_Fn, void *, phase2_vrs *);
658 __gnu_Unwind_ForcedUnwind (_Unwind_Control_Block *ucbp,
659 _Unwind_Stop_Fn stop_fn, void *stop_arg,
660 phase2_vrs *entry_vrs)
662 UCB_FORCED_STOP_FN (ucbp) = (_uw) stop_fn;
663 UCB_FORCED_STOP_ARG (ucbp) = (_uw) stop_arg;
665 /* Set the pc to the call site. */
666 entry_vrs->core.r[R_PC] = entry_vrs->core.r[R_LR];
668 return unwind_phase2_forced (ucbp, entry_vrs, 0);
672 __gnu_Unwind_Resume (_Unwind_Control_Block *, phase2_vrs *);
675 __gnu_Unwind_Resume (_Unwind_Control_Block * ucbp, phase2_vrs * entry_vrs)
677 _Unwind_Reason_Code pr_result;
679 /* Recover the saved address. */
680 entry_vrs->core.r[R_PC] = UCB_SAVED_CALLSITE_ADDR (ucbp);
682 if (UCB_FORCED_STOP_FN (ucbp))
684 unwind_phase2_forced (ucbp, entry_vrs, 1);
686 /* We can't return failure at this point. */
690 /* Call the cached PR. */
691 pr_result = ((personality_routine) UCB_PR_ADDR (ucbp))
692 (_US_UNWIND_FRAME_RESUME, ucbp, (_Unwind_Context *) entry_vrs);
696 case _URC_INSTALL_CONTEXT:
697 /* Upload the registers to enter the landing pad. */
698 restore_core_regs (&entry_vrs->core);
700 case _URC_CONTINUE_UNWIND:
701 /* Continue unwinding the next frame. */
702 unwind_phase2 (ucbp, entry_vrs);
710 __gnu_Unwind_Resume_or_Rethrow (_Unwind_Control_Block *, phase2_vrs *);
713 __gnu_Unwind_Resume_or_Rethrow (_Unwind_Control_Block * ucbp,
714 phase2_vrs * entry_vrs)
716 if (!UCB_FORCED_STOP_FN (ucbp))
717 return __gnu_Unwind_RaiseException (ucbp, entry_vrs);
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);
725 /* Clean up an exception object when unwinding is complete. */
727 _Unwind_Complete (_Unwind_Control_Block * ucbp __attribute__((unused)))
732 /* Get the _Unwind_Control_Block from an _Unwind_Context. */
734 static inline _Unwind_Control_Block *
735 unwind_UCB_from_context (_Unwind_Context * context)
737 return (_Unwind_Control_Block *) _Unwind_GetGR (context, R_IP);
741 /* Free an exception. */
744 _Unwind_DeleteException (_Unwind_Exception * exc)
746 if (exc->exception_cleanup)
747 (*exc->exception_cleanup) (_URC_FOREIGN_EXCEPTION_CAUGHT, exc);
751 /* Perform stack backtrace through unwind data. */
753 __gnu_Unwind_Backtrace(_Unwind_Trace_Fn trace, void * trace_argument,
754 phase2_vrs * entry_vrs);
756 __gnu_Unwind_Backtrace(_Unwind_Trace_Fn trace, void * trace_argument,
757 phase2_vrs * entry_vrs)
759 phase1_vrs saved_vrs;
760 _Unwind_Reason_Code code;
762 _Unwind_Control_Block ucb;
763 _Unwind_Control_Block *ucbp = &ucb;
765 /* Set the pc to the call site. */
766 entry_vrs->core.r[R_PC] = entry_vrs->core.r[R_LR];
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;
775 /* Find the entry for this routine. */
776 if (get_eit_entry (ucbp, saved_vrs.core.r[R_PC]) != _URC_OK)
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
787 _Unwind_SetGR((_Unwind_Context *)&saved_vrs, 12, (_Unwind_Ptr) ucbp);
789 /* Call trace function. */
790 if ((*trace) ((_Unwind_Context *) &saved_vrs, trace_argument)
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);
802 while (code != _URC_END_OF_STACK
803 && code != _URC_FAILURE);
806 restore_non_core_regs (&saved_vrs);
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}. */
815 static _Unwind_Reason_Code
816 __gnu_unwind_pr_common (_Unwind_State state,
817 _Unwind_Control_Block *ucbp,
818 _Unwind_Context *context,
821 __gnu_unwind_state uws;
826 int phase2_call_unexpected_after_unwind = 0;
828 int forced_unwind = state & _US_FORCE_UNWIND;
830 state &= _US_ACTION_MASK;
832 data = (_uw *) ucbp->pr_cache.ehtp;
833 uws.data = *(data++);
843 uws.words_left = (uws.data >> 16) & 0xff;
846 data += uws.words_left;
849 /* Restore the saved pointer. */
850 if (state == _US_UNWIND_FRAME_RESUME)
851 data = (_uw *) ucbp->cleanup_cache.bitpattern[0];
853 if ((ucbp->pr_cache.additional & 1) == 0)
855 /* Process descriptors. */
863 len = ((EHT32 *) data)->length;
864 offset = ((EHT32 *) data)->offset;
869 len = ((EHT16 *) data)->length;
870 offset = ((EHT16 *) data)->offset;
874 fnstart = ucbp->pr_cache.fnstart + (offset & ~1);
875 addr = _Unwind_GetGR (context, R_PC);
876 in_range = (fnstart <= addr && addr < fnstart + (len & ~1));
878 switch (((offset & 1) << 1) | (len & 1))
882 if (state != _US_VIRTUAL_UNWIND_FRAME
885 /* Cleanup in range, and we are running cleanups. */
888 /* Landing pad address is 31-bit pc-relative offset. */
889 lp = selfrel_offset31 (data);
891 /* Save the exception data pointer. */
892 ucbp->cleanup_cache.bitpattern[0] = (_uw) data;
893 if (!__cxa_begin_cleanup (ucbp))
895 /* Setup the VRS to enter the landing pad. */
896 _Unwind_SetGR (context, R_PC, lp);
897 return _URC_INSTALL_CONTEXT;
899 /* Cleanup not in range, or we are in stage 1. */
905 if (state == _US_VIRTUAL_UNWIND_FRAME)
909 /* Check for a barrier. */
913 /* Check for no-throw areas. */
914 if (data[1] == (_uw) -2)
917 /* The thrown object immediately follows the ECB. */
918 matched = (void *)(ucbp + 1);
919 if (data[1] != (_uw) -1)
921 /* Match a catch specification. */
922 rtti = _Unwind_decode_target2 ((_uw) &data[1]);
923 if (!__cxa_type_match (ucbp, (type_info *) rtti,
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;
937 /* Handler out of range, or not matched. */
939 else if (ucbp->barrier_cache.sp == _Unwind_GetGR (context, R_SP)
940 && ucbp->barrier_cache.bitpattern[1] == (_uw) data)
942 /* Matched a previous propagation barrier. */
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;
951 /* Catch handler not matched. Advance to the next descriptor. */
956 rtti_count = data[0] & 0x7fffffff;
957 /* Exception specification. */
958 if (state == _US_VIRTUAL_UNWIND_FRAME)
960 if (in_range && (!forced_unwind || !rtti_count))
962 /* Match against the exception specification. */
967 for (i = 0; i < rtti_count; i++)
969 matched = (void *)(ucbp + 1);
970 rtti = _Unwind_decode_target2 ((_uw) &data[i + 1]);
971 if (__cxa_type_match (ucbp, (type_info *) rtti,
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;
986 /* Handler out of range, or exception is permitted. */
988 else if (ucbp->barrier_cache.sp == _Unwind_GetGR (context, R_SP)
989 && ucbp->barrier_cache.bitpattern[1] == (_uw) data)
991 /* Matched a previous propagation barrier. */
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];
999 if (data[0] & uint32_highbit)
1000 phase2_call_unexpected_after_unwind = 1;
1003 data += rtti_count + 1;
1004 /* Setup for entry to the handler. */
1005 lp = selfrel_offset31 (data);
1007 _Unwind_SetGR (context, R_PC, lp);
1008 _Unwind_SetGR (context, 0, (_uw) ucbp);
1009 return _URC_INSTALL_CONTEXT;
1012 if (data[0] & uint32_highbit)
1014 data += rtti_count + 1;
1018 /* Should never happen. */
1019 return _URC_FAILURE;
1021 /* Finished processing this descriptor. */
1025 if (__gnu_unwind_execute (context, &uws) != _URC_OK)
1026 return _URC_FAILURE;
1028 if (phase2_call_unexpected_after_unwind)
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;
1036 return _URC_CONTINUE_UNWIND;
1040 /* ABI defined personality routine entry points. */
1043 __aeabi_unwind_cpp_pr0 (_Unwind_State state,
1044 _Unwind_Control_Block *ucbp,
1045 _Unwind_Context *context)
1047 return __gnu_unwind_pr_common (state, ucbp, context, 0);
1051 __aeabi_unwind_cpp_pr1 (_Unwind_State state,
1052 _Unwind_Control_Block *ucbp,
1053 _Unwind_Context *context)
1055 return __gnu_unwind_pr_common (state, ucbp, context, 1);
1059 __aeabi_unwind_cpp_pr2 (_Unwind_State state,
1060 _Unwind_Control_Block *ucbp,
1061 _Unwind_Context *context)
1063 return __gnu_unwind_pr_common (state, ucbp, context, 2);
1066 /* These two should never be used. */
1068 _Unwind_GetDataRelBase (_Unwind_Context *context __attribute__ ((unused)))
1074 _Unwind_GetTextRelBase (_Unwind_Context *context __attribute__ ((unused)))
1080 /* FreeBSD expects these to be functions */
1082 _Unwind_GetIP (struct _Unwind_Context *context)
1084 return _Unwind_GetGR (context, 15) & ~(_Unwind_Word)1;
1088 _Unwind_GetIPInfo (struct _Unwind_Context *context, int *ip_before_insn)
1090 *ip_before_insn = 0;
1091 return _Unwind_GetGR (context, 15) & ~(_Unwind_Word)1;
1095 _Unwind_SetIP (struct _Unwind_Context *context, _Unwind_Ptr val)
1097 _Unwind_SetGR (context, 15, val | (_Unwind_GetGR (context, 15) & 1));