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 ((pr_result = 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 ((code = get_eit_entry (ucbp, saved_vrs.core.r[R_PC])) != _URC_OK)
779 /* The dwarf unwinder assumes the context structure holds things
780 like the function and LSDA pointers. The ARM implementation
781 caches these in the exception header (UCB). To avoid
782 rewriting everything we make the virtual IP register point at
784 _Unwind_SetGR((_Unwind_Context *)&saved_vrs, 12, (_Unwind_Ptr) ucbp);
786 /* Call trace function. */
787 if ((*trace) ((_Unwind_Context *) &saved_vrs, trace_argument)
794 /* Call the pr to decide what to do. */
795 code = ((personality_routine) UCB_PR_ADDR (ucbp))
796 (_US_VIRTUAL_UNWIND_FRAME | _US_FORCE_UNWIND,
797 ucbp, (void *) &saved_vrs);
799 while (code != _URC_END_OF_STACK
800 && code != _URC_FAILURE);
803 restore_non_core_regs (&saved_vrs);
808 /* Common implementation for ARM ABI defined personality routines.
809 ID is the index of the personality routine, other arguments are as defined
810 by __aeabi_unwind_cpp_pr{0,1,2}. */
812 static _Unwind_Reason_Code
813 __gnu_unwind_pr_common (_Unwind_State state,
814 _Unwind_Control_Block *ucbp,
815 _Unwind_Context *context,
818 __gnu_unwind_state uws;
823 int phase2_call_unexpected_after_unwind = 0;
825 int forced_unwind = state & _US_FORCE_UNWIND;
827 state &= _US_ACTION_MASK;
829 data = (_uw *) ucbp->pr_cache.ehtp;
830 uws.data = *(data++);
840 uws.words_left = (uws.data >> 16) & 0xff;
843 data += uws.words_left;
846 /* Restore the saved pointer. */
847 if (state == _US_UNWIND_FRAME_RESUME)
848 data = (_uw *) ucbp->cleanup_cache.bitpattern[0];
850 if ((ucbp->pr_cache.additional & 1) == 0)
852 /* Process descriptors. */
860 len = ((EHT32 *) data)->length;
861 offset = ((EHT32 *) data)->offset;
866 len = ((EHT16 *) data)->length;
867 offset = ((EHT16 *) data)->offset;
871 fnstart = ucbp->pr_cache.fnstart + (offset & ~1);
872 addr = _Unwind_GetGR (context, R_PC);
873 in_range = (fnstart <= addr && addr < fnstart + (len & ~1));
875 switch (((offset & 1) << 1) | (len & 1))
879 if (state != _US_VIRTUAL_UNWIND_FRAME
882 /* Cleanup in range, and we are running cleanups. */
885 /* Landing pad address is 31-bit pc-relative offset. */
886 lp = selfrel_offset31 (data);
888 /* Save the exception data pointer. */
889 ucbp->cleanup_cache.bitpattern[0] = (_uw) data;
890 if (!__cxa_begin_cleanup (ucbp))
892 /* Setup the VRS to enter the landing pad. */
893 _Unwind_SetGR (context, R_PC, lp);
894 return _URC_INSTALL_CONTEXT;
896 /* Cleanup not in range, or we are in stage 1. */
902 if (state == _US_VIRTUAL_UNWIND_FRAME)
906 /* Check for a barrier. */
910 /* Check for no-throw areas. */
911 if (data[1] == (_uw) -2)
914 /* The thrown object immediately follows the ECB. */
915 matched = (void *)(ucbp + 1);
916 if (data[1] != (_uw) -1)
918 /* Match a catch specification. */
919 rtti = _Unwind_decode_target2 ((_uw) &data[1]);
920 if (!__cxa_type_match (ucbp, (type_info *) rtti,
927 ucbp->barrier_cache.sp =
928 _Unwind_GetGR (context, R_SP);
929 ucbp->barrier_cache.bitpattern[0] = (_uw) matched;
930 ucbp->barrier_cache.bitpattern[1] = (_uw) data;
931 return _URC_HANDLER_FOUND;
934 /* Handler out of range, or not matched. */
936 else if (ucbp->barrier_cache.sp == _Unwind_GetGR (context, R_SP)
937 && ucbp->barrier_cache.bitpattern[1] == (_uw) data)
939 /* Matched a previous propagation barrier. */
942 /* Setup for entry to the handler. */
943 lp = selfrel_offset31 (data);
944 _Unwind_SetGR (context, R_PC, lp);
945 _Unwind_SetGR (context, 0, (_uw) ucbp);
946 return _URC_INSTALL_CONTEXT;
948 /* Catch handler not matched. Advance to the next descriptor. */
953 rtti_count = data[0] & 0x7fffffff;
954 /* Exception specification. */
955 if (state == _US_VIRTUAL_UNWIND_FRAME)
957 if (in_range && (!forced_unwind || !rtti_count))
959 /* Match against the exception specification. */
964 for (i = 0; i < rtti_count; i++)
966 matched = (void *)(ucbp + 1);
967 rtti = _Unwind_decode_target2 ((_uw) &data[i + 1]);
968 if (__cxa_type_match (ucbp, (type_info *) rtti,
975 /* Exception does not match the spec. */
976 ucbp->barrier_cache.sp =
977 _Unwind_GetGR (context, R_SP);
978 ucbp->barrier_cache.bitpattern[0] = (_uw) matched;
979 ucbp->barrier_cache.bitpattern[1] = (_uw) data;
980 return _URC_HANDLER_FOUND;
983 /* Handler out of range, or exception is permitted. */
985 else if (ucbp->barrier_cache.sp == _Unwind_GetGR (context, R_SP)
986 && ucbp->barrier_cache.bitpattern[1] == (_uw) data)
988 /* Matched a previous propagation barrier. */
990 /* Record the RTTI list for __cxa_call_unexpected. */
991 ucbp->barrier_cache.bitpattern[1] = rtti_count;
992 ucbp->barrier_cache.bitpattern[2] = 0;
993 ucbp->barrier_cache.bitpattern[3] = 4;
994 ucbp->barrier_cache.bitpattern[4] = (_uw) &data[1];
996 if (data[0] & uint32_highbit)
997 phase2_call_unexpected_after_unwind = 1;
1000 data += rtti_count + 1;
1001 /* Setup for entry to the handler. */
1002 lp = selfrel_offset31 (data);
1004 _Unwind_SetGR (context, R_PC, lp);
1005 _Unwind_SetGR (context, 0, (_uw) ucbp);
1006 return _URC_INSTALL_CONTEXT;
1009 if (data[0] & uint32_highbit)
1011 data += rtti_count + 1;
1015 /* Should never happen. */
1016 return _URC_FAILURE;
1018 /* Finished processing this descriptor. */
1022 if (__gnu_unwind_execute (context, &uws) != _URC_OK)
1023 return _URC_FAILURE;
1025 if (phase2_call_unexpected_after_unwind)
1027 /* Enter __cxa_unexpected as if called from the call site. */
1028 _Unwind_SetGR (context, R_LR, _Unwind_GetGR (context, R_PC));
1029 _Unwind_SetGR (context, R_PC, (_uw) &__cxa_call_unexpected);
1030 return _URC_INSTALL_CONTEXT;
1033 return _URC_CONTINUE_UNWIND;
1037 /* ABI defined personality routine entry points. */
1040 __aeabi_unwind_cpp_pr0 (_Unwind_State state,
1041 _Unwind_Control_Block *ucbp,
1042 _Unwind_Context *context)
1044 return __gnu_unwind_pr_common (state, ucbp, context, 0);
1048 __aeabi_unwind_cpp_pr1 (_Unwind_State state,
1049 _Unwind_Control_Block *ucbp,
1050 _Unwind_Context *context)
1052 return __gnu_unwind_pr_common (state, ucbp, context, 1);
1056 __aeabi_unwind_cpp_pr2 (_Unwind_State state,
1057 _Unwind_Control_Block *ucbp,
1058 _Unwind_Context *context)
1060 return __gnu_unwind_pr_common (state, ucbp, context, 2);
1063 /* These two should never be used. */
1065 _Unwind_GetDataRelBase (_Unwind_Context *context __attribute__ ((unused)))
1071 _Unwind_GetTextRelBase (_Unwind_Context *context __attribute__ ((unused)))
1077 /* FreeBSD expects these to be functions */
1079 _Unwind_GetIP (struct _Unwind_Context *context)
1081 return _Unwind_GetGR (context, 15) & ~(_Unwind_Word)1;
1085 _Unwind_GetIPInfo (struct _Unwind_Context *context, int *ip_before_insn)
1087 *ip_before_insn = 0;
1088 return _Unwind_GetGR (context, 15) & ~(_Unwind_Word)1;
1092 _Unwind_SetIP (struct _Unwind_Context *context, _Unwind_Ptr val)
1094 _Unwind_SetGR (context, 15, val | (_Unwind_GetGR (context, 15) & 1));