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. */
30 /* We add a prototype for abort here to avoid creating a dependency on
32 extern void abort (void);
34 /* Definitions for C++ runtime support routines. We make these weak
35 declarations to avoid pulling in libsupc++ unnecessarily. */
36 typedef unsigned char bool;
38 typedef struct _ZSt9type_info type_info; /* This names C++ type_info type */
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 void **matched_object);
46 _Unwind_Ptr __attribute__((weak))
47 __gnu_Unwind_Find_exidx (_Unwind_Ptr, int *);
55 #define EXIDX_CANTUNWIND 1
56 #define uint32_highbit (((_uw) 1) << 31)
58 #define UCB_FORCED_STOP_FN(ucbp) ((ucbp)->unwinder_cache.reserved1)
59 #define UCB_PR_ADDR(ucbp) ((ucbp)->unwinder_cache.reserved2)
60 #define UCB_SAVED_CALLSITE_ADDR(ucbp) ((ucbp)->unwinder_cache.reserved3)
61 #define UCB_FORCED_STOP_ARG(ucbp) ((ucbp)->unwinder_cache.reserved4)
68 /* We use normal integer types here to avoid the compiler generating
69 coprocessor instructions. */
86 /* Unwind descriptors. */
100 /* The ABI specifies that the unwind routines may only use core registers,
101 except when actually manipulating coprocessor state. This allows
102 us to write one implementation that works on all platforms by
103 demand-saving coprocessor registers.
105 During unwinding we hold the coprocessor state in the actual hardware
106 registers and allocate demand-save areas for use during phase1
111 /* The first fields must be the same as a phase2_vrs. */
112 _uw demand_save_flags;
113 struct core_regs core;
114 _uw prev_sp; /* Only valid during forced unwinding. */
119 #define DEMAND_SAVE_VFP 1
121 /* This must match the structure created by the assembly wrappers. */
124 _uw demand_save_flags;
125 struct core_regs core;
129 /* An exception index table entry. */
131 typedef struct __EIT_entry
137 /* Assembly helper functions. */
139 /* Restore core register state. Never returns. */
140 void __attribute__((noreturn)) restore_core_regs (struct core_regs *);
143 /* Coprocessor register state manipulation functions. */
145 void __gnu_Unwind_Save_VFP (struct vfp_regs * p);
146 void __gnu_Unwind_Restore_VFP (struct vfp_regs * p);
148 /* Restore coprocessor state after phase1 unwinding. */
150 restore_non_core_regs (phase1_vrs * vrs)
152 if ((vrs->demand_save_flags & DEMAND_SAVE_VFP) == 0)
153 __gnu_Unwind_Restore_VFP (&vrs->vfp);
156 /* A better way to do this would probably be to compare the absolute address
157 with a segment relative relocation of the same symbol. */
159 extern int __text_start;
160 extern int __data_start;
162 /* The exception index table location. */
163 extern __EIT_entry __exidx_start;
164 extern __EIT_entry __exidx_end;
166 /* ABI defined personality routines. */
167 extern _Unwind_Reason_Code __aeabi_unwind_cpp_pr0 (_Unwind_State,
168 _Unwind_Control_Block *, _Unwind_Context *);// __attribute__((weak));
169 extern _Unwind_Reason_Code __aeabi_unwind_cpp_pr1 (_Unwind_State,
170 _Unwind_Control_Block *, _Unwind_Context *) __attribute__((weak));
171 extern _Unwind_Reason_Code __aeabi_unwind_cpp_pr2 (_Unwind_State,
172 _Unwind_Control_Block *, _Unwind_Context *) __attribute__((weak));
174 /* ABI defined routine to store a virtual register to memory. */
176 _Unwind_VRS_Result _Unwind_VRS_Get (_Unwind_Context *context,
177 _Unwind_VRS_RegClass regclass,
179 _Unwind_VRS_DataRepresentation representation,
182 phase1_vrs *vrs = (phase1_vrs *) context;
187 if (representation != _UVRSD_UINT32
189 return _UVRSR_FAILED;
190 *(_uw *) valuep = vrs->core.r[regno];
197 return _UVRSR_NOT_IMPLEMENTED;
200 return _UVRSR_FAILED;
205 /* ABI defined function to load a virtual register from memory. */
207 _Unwind_VRS_Result _Unwind_VRS_Set (_Unwind_Context *context,
208 _Unwind_VRS_RegClass regclass,
210 _Unwind_VRS_DataRepresentation representation,
213 phase1_vrs *vrs = (phase1_vrs *) context;
218 if (representation != _UVRSD_UINT32
220 return _UVRSR_FAILED;
222 vrs->core.r[regno] = *(_uw *) valuep;
229 return _UVRSR_NOT_IMPLEMENTED;
232 return _UVRSR_FAILED;
237 /* ABI defined function to pop registers off the stack. */
239 _Unwind_VRS_Result _Unwind_VRS_Pop (_Unwind_Context *context,
240 _Unwind_VRS_RegClass regclass,
242 _Unwind_VRS_DataRepresentation representation)
244 phase1_vrs *vrs = (phase1_vrs *) context;
254 if (representation != _UVRSD_UINT32)
255 return _UVRSR_FAILED;
257 mask = discriminator & 0xffff;
258 ptr = (_uw *) vrs->core.r[R_SP];
259 /* Pop the requested registers. */
260 for (i = 0; i < 16; i++)
263 vrs->core.r[i] = *(ptr++);
265 /* Writeback the stack pointer value if it wasn't restored. */
266 if ((mask & (1 << R_SP)) == 0)
267 vrs->core.r[R_SP] = (_uw) ptr;
273 _uw start = discriminator >> 16;
274 _uw count = discriminator & 0xffff;
279 if ((representation != _UVRSD_VFPX && representation != _UVRSD_DOUBLE)
280 || start + count > 16)
281 return _UVRSR_FAILED;
283 if (vrs->demand_save_flags & DEMAND_SAVE_VFP)
285 /* Demand-save resisters for stage1. */
286 vrs->demand_save_flags &= ~DEMAND_SAVE_VFP;
287 __gnu_Unwind_Save_VFP (&vrs->vfp);
290 /* Restore the registers from the stack. Do this by saving the
291 current VFP registers to a memory area, moving the in-memory
292 values into that area, and restoring from the whole area.
293 For _UVRSD_VFPX we assume FSTMX standard format 1. */
294 __gnu_Unwind_Save_VFP (&tmp);
296 /* The stack address is only guaranteed to be word aligned, so
297 we can't use doubleword copies. */
298 sp = (_uw *) vrs->core.r[R_SP];
299 dest = (_uw *) &tmp.d[start];
304 /* Skip the pad word */
305 if (representation == _UVRSD_VFPX)
308 /* Set the new stack pointer. */
309 vrs->core.r[R_SP] = (_uw) sp;
311 /* Reload the registers. */
312 __gnu_Unwind_Restore_VFP (&tmp);
319 return _UVRSR_NOT_IMPLEMENTED;
322 return _UVRSR_FAILED;
327 /* Core unwinding functions. */
329 /* Calculate the address encoded by a 31-bit self-relative offset at address
332 selfrel_offset31 (const _uw *p)
337 /* Sign extend to 32 bits. */
338 if (offset & (1 << 30))
341 offset &= ~(1u << 31);
343 return offset + (_uw) p;
347 /* Perform a binary search for RETURN_ADDRESS in TABLE. The table contains
350 static const __EIT_entry *
351 search_EIT_table (const __EIT_entry * table, int nrec, _uw return_address)
358 return (__EIT_entry *) 0;
365 n = (left + right) / 2;
366 this_fn = selfrel_offset31 (&table[n].fnoffset);
368 next_fn = selfrel_offset31 (&table[n + 1].fnoffset) - 1;
370 next_fn = (_uw)0 - 1;
372 if (return_address < this_fn)
375 return (__EIT_entry *) 0;
378 else if (return_address <= next_fn)
385 /* Find the exception index table eintry for the given address.
386 Fill in the relevant fields of the UCB.
387 Returns _URC_FAILURE if an error occurred, _URC_OK on success. */
389 static _Unwind_Reason_Code
390 get_eit_entry (_Unwind_Control_Block *ucbp, _uw return_address)
392 const __EIT_entry * eitp;
395 /* The return address is the address of the instruction following the
396 call instruction (plus one in thumb mode). If this was the last
397 instruction in the function the address will lie in the following
398 function. Subtract 2 from the address so that it points within the call
399 instruction itself. */
402 if (__gnu_Unwind_Find_exidx)
404 eitp = (const __EIT_entry *) __gnu_Unwind_Find_exidx (return_address,
408 UCB_PR_ADDR (ucbp) = 0;
414 eitp = &__exidx_start;
415 nrec = &__exidx_end - &__exidx_start;
418 eitp = search_EIT_table (eitp, nrec, return_address);
422 UCB_PR_ADDR (ucbp) = 0;
425 ucbp->pr_cache.fnstart = selfrel_offset31 (&eitp->fnoffset);
427 /* Can this frame be unwound at all? */
428 if (eitp->content == EXIDX_CANTUNWIND)
430 UCB_PR_ADDR (ucbp) = 0;
431 return _URC_END_OF_STACK;
434 /* Obtain the address of the "real" __EHT_Header word. */
436 if (eitp->content & uint32_highbit)
438 /* It is immediate data. */
439 ucbp->pr_cache.ehtp = (_Unwind_EHT_Header *)&eitp->content;
440 ucbp->pr_cache.additional = 1;
444 /* The low 31 bits of the content field are a self-relative
445 offset to an _Unwind_EHT_Entry structure. */
446 ucbp->pr_cache.ehtp =
447 (_Unwind_EHT_Header *) selfrel_offset31 (&eitp->content);
448 ucbp->pr_cache.additional = 0;
451 /* Discover the personality routine address. */
452 if (*ucbp->pr_cache.ehtp & (1u << 31))
454 /* One of the predefined standard routines. */
455 _uw idx = (*(_uw *) ucbp->pr_cache.ehtp >> 24) & 0xf;
457 UCB_PR_ADDR (ucbp) = (_uw) &__aeabi_unwind_cpp_pr0;
459 UCB_PR_ADDR (ucbp) = (_uw) &__aeabi_unwind_cpp_pr1;
461 UCB_PR_ADDR (ucbp) = (_uw) &__aeabi_unwind_cpp_pr2;
464 UCB_PR_ADDR (ucbp) = 0;
470 /* Execute region offset to PR */
471 UCB_PR_ADDR (ucbp) = selfrel_offset31 (ucbp->pr_cache.ehtp);
477 /* Perform phase2 unwinding. VRS is the initial virtual register state. */
479 static void __attribute__((noreturn))
480 unwind_phase2 (_Unwind_Control_Block * ucbp, phase2_vrs * vrs)
482 _Unwind_Reason_Code pr_result;
486 /* Find the entry for this routine. */
487 if (get_eit_entry (ucbp, vrs->core.r[R_PC]) != _URC_OK)
490 UCB_SAVED_CALLSITE_ADDR (ucbp) = vrs->core.r[R_PC];
492 /* Call the pr to decide what to do. */
493 pr_result = ((personality_routine) UCB_PR_ADDR (ucbp))
494 (_US_UNWIND_FRAME_STARTING, ucbp, (_Unwind_Context *) vrs);
496 while (pr_result == _URC_CONTINUE_UNWIND);
498 if (pr_result != _URC_INSTALL_CONTEXT)
501 restore_core_regs (&vrs->core);
504 /* Perform phase2 forced unwinding. */
506 static _Unwind_Reason_Code
507 unwind_phase2_forced (_Unwind_Control_Block *ucbp, phase2_vrs *entry_vrs,
510 _Unwind_Stop_Fn stop_fn = (_Unwind_Stop_Fn) UCB_FORCED_STOP_FN (ucbp);
511 void *stop_arg = (void *)UCB_FORCED_STOP_ARG (ucbp);
512 _Unwind_Reason_Code pr_result = 0;
513 /* We use phase1_vrs here even though we do not demand save, for the
515 phase1_vrs saved_vrs, next_vrs;
517 /* Save the core registers. */
518 saved_vrs.core = entry_vrs->core;
519 /* We don't need to demand-save the non-core registers, because we
520 unwind in a single pass. */
521 saved_vrs.demand_save_flags = 0;
523 /* Unwind until we reach a propagation barrier. */
526 _Unwind_State action;
527 _Unwind_Reason_Code entry_code;
528 _Unwind_Reason_Code stop_code;
530 /* Find the entry for this routine. */
531 entry_code = get_eit_entry (ucbp, saved_vrs.core.r[R_PC]);
535 action = _US_UNWIND_FRAME_RESUME | _US_FORCE_UNWIND;
539 action = _US_UNWIND_FRAME_STARTING | _US_FORCE_UNWIND;
541 if (entry_code == _URC_OK)
543 UCB_SAVED_CALLSITE_ADDR (ucbp) = saved_vrs.core.r[R_PC];
545 next_vrs = saved_vrs;
547 /* Call the pr to decide what to do. */
548 pr_result = ((personality_routine) UCB_PR_ADDR (ucbp))
549 (action, ucbp, (void *) &next_vrs);
551 saved_vrs.prev_sp = next_vrs.core.r[R_SP];
555 /* Treat any failure as the end of unwinding, to cope more
556 gracefully with missing EH information. Mixed EH and
557 non-EH within one object will usually result in failure,
558 because the .ARM.exidx tables do not indicate the end
559 of the code to which they apply; but mixed EH and non-EH
560 shared objects should return an unwind failure at the
561 entry of a non-EH shared object. */
562 action |= _US_END_OF_STACK;
564 saved_vrs.prev_sp = saved_vrs.core.r[R_SP];
567 stop_code = stop_fn (1, action, ucbp->exception_class, ucbp,
568 (void *)&saved_vrs, stop_arg);
569 if (stop_code != _URC_NO_REASON)
572 if (entry_code != _URC_OK)
575 saved_vrs = next_vrs;
577 while (pr_result == _URC_CONTINUE_UNWIND);
579 if (pr_result != _URC_INSTALL_CONTEXT)
581 /* Some sort of failure has occurred in the pr and probably the
582 pr returned _URC_FAILURE. */
586 restore_core_regs (&saved_vrs.core);
589 /* This is a very limited implementation of _Unwind_GetCFA. It returns
590 the stack pointer as it is about to be unwound, and is only valid
591 while calling the stop function during forced unwinding. If the
592 current personality routine result is going to run a cleanup, this
593 will not be the CFA; but when the frame is really unwound, it will
597 _Unwind_GetCFA (_Unwind_Context *context)
599 return ((phase1_vrs *) context)->prev_sp;
602 /* Perform phase1 unwinding. UCBP is the exception being thrown, and
603 entry_VRS is the register state on entry to _Unwind_RaiseException. */
606 __gnu_Unwind_RaiseException (_Unwind_Control_Block *, phase2_vrs *);
609 __gnu_Unwind_RaiseException (_Unwind_Control_Block * ucbp,
610 phase2_vrs * entry_vrs)
612 phase1_vrs saved_vrs;
613 _Unwind_Reason_Code pr_result;
615 /* Set the pc to the call site. */
616 entry_vrs->core.r[R_PC] = entry_vrs->core.r[R_LR];
618 /* Save the core registers. */
619 saved_vrs.core = entry_vrs->core;
620 /* Set demand-save flags. */
621 saved_vrs.demand_save_flags = ~(_uw) 0;
623 /* Unwind until we reach a propagation barrier. */
626 /* Find the entry for this routine. */
627 if (get_eit_entry (ucbp, saved_vrs.core.r[R_PC]) != _URC_OK)
630 /* Call the pr to decide what to do. */
631 pr_result = ((personality_routine) UCB_PR_ADDR (ucbp))
632 (_US_VIRTUAL_UNWIND_FRAME, ucbp, (void *) &saved_vrs);
634 while (pr_result == _URC_CONTINUE_UNWIND);
636 /* We've unwound as far as we want to go, so restore the original
638 restore_non_core_regs (&saved_vrs);
639 if (pr_result != _URC_HANDLER_FOUND)
641 /* Some sort of failure has occurred in the pr and probably the
642 pr returned _URC_FAILURE. */
646 unwind_phase2 (ucbp, entry_vrs);
649 /* Resume unwinding after a cleanup has been run. UCBP is the exception
650 being thrown and ENTRY_VRS is the register state on entry to
653 __gnu_Unwind_ForcedUnwind (_Unwind_Control_Block *,
654 _Unwind_Stop_Fn, void *, phase2_vrs *);
657 __gnu_Unwind_ForcedUnwind (_Unwind_Control_Block *ucbp,
658 _Unwind_Stop_Fn stop_fn, void *stop_arg,
659 phase2_vrs *entry_vrs)
661 UCB_FORCED_STOP_FN (ucbp) = (_uw) stop_fn;
662 UCB_FORCED_STOP_ARG (ucbp) = (_uw) stop_arg;
664 /* Set the pc to the call site. */
665 entry_vrs->core.r[R_PC] = entry_vrs->core.r[R_LR];
667 return unwind_phase2_forced (ucbp, entry_vrs, 0);
671 __gnu_Unwind_Resume (_Unwind_Control_Block *, phase2_vrs *);
674 __gnu_Unwind_Resume (_Unwind_Control_Block * ucbp, phase2_vrs * entry_vrs)
676 _Unwind_Reason_Code pr_result;
678 /* Recover the saved address. */
679 entry_vrs->core.r[R_PC] = UCB_SAVED_CALLSITE_ADDR (ucbp);
681 if (UCB_FORCED_STOP_FN (ucbp))
683 unwind_phase2_forced (ucbp, entry_vrs, 1);
685 /* We can't return failure at this point. */
689 /* Call the cached PR. */
690 pr_result = ((personality_routine) UCB_PR_ADDR (ucbp))
691 (_US_UNWIND_FRAME_RESUME, ucbp, (_Unwind_Context *) entry_vrs);
695 case _URC_INSTALL_CONTEXT:
696 /* Upload the registers to enter the landing pad. */
697 restore_core_regs (&entry_vrs->core);
699 case _URC_CONTINUE_UNWIND:
700 /* Continue unwinding the next frame. */
701 unwind_phase2 (ucbp, entry_vrs);
709 __gnu_Unwind_Resume_or_Rethrow (_Unwind_Control_Block *, phase2_vrs *);
712 __gnu_Unwind_Resume_or_Rethrow (_Unwind_Control_Block * ucbp,
713 phase2_vrs * entry_vrs)
715 if (!UCB_FORCED_STOP_FN (ucbp))
716 return __gnu_Unwind_RaiseException (ucbp, entry_vrs);
718 /* Set the pc to the call site. */
719 entry_vrs->core.r[R_PC] = entry_vrs->core.r[R_LR];
720 /* Continue unwinding the next frame. */
721 return unwind_phase2_forced (ucbp, entry_vrs, 0);
724 /* Clean up an exception object when unwinding is complete. */
726 _Unwind_Complete (_Unwind_Control_Block * ucbp __attribute__((unused)))
731 /* Get the _Unwind_Control_Block from an _Unwind_Context. */
733 static inline _Unwind_Control_Block *
734 unwind_UCB_from_context (_Unwind_Context * context)
736 return (_Unwind_Control_Block *) _Unwind_GetGR (context, R_IP);
740 /* Free an exception. */
743 _Unwind_DeleteException (_Unwind_Exception * exc)
745 if (exc->exception_cleanup)
746 (*exc->exception_cleanup) (_URC_FOREIGN_EXCEPTION_CAUGHT, exc);
750 /* Perform stack backtrace through unwind data. */
752 __gnu_Unwind_Backtrace(_Unwind_Trace_Fn trace, void * trace_argument,
753 phase2_vrs * entry_vrs);
755 __gnu_Unwind_Backtrace(_Unwind_Trace_Fn trace, void * trace_argument,
756 phase2_vrs * entry_vrs)
758 phase1_vrs saved_vrs;
759 _Unwind_Reason_Code code;
761 _Unwind_Control_Block ucb;
762 _Unwind_Control_Block *ucbp = &ucb;
764 /* Set the pc to the call site. */
765 entry_vrs->core.r[R_PC] = entry_vrs->core.r[R_LR];
767 /* Save the core registers. */
768 saved_vrs.core = entry_vrs->core;
769 /* Set demand-save flags. */
770 saved_vrs.demand_save_flags = ~(_uw) 0;
774 /* Find the entry for this routine. */
775 if (get_eit_entry (ucbp, saved_vrs.core.r[R_PC]) != _URC_OK)
781 /* The dwarf unwinder assumes the context structure holds things
782 like the function and LSDA pointers. The ARM implementation
783 caches these in the exception header (UCB). To avoid
784 rewriting everything we make the virtual IP register point at
786 _Unwind_SetGR((_Unwind_Context *)&saved_vrs, 12, (_Unwind_Ptr) ucbp);
788 /* Call trace function. */
789 if ((*trace) ((_Unwind_Context *) &saved_vrs, trace_argument)
796 /* Call the pr to decide what to do. */
797 code = ((personality_routine) UCB_PR_ADDR (ucbp))
798 (_US_VIRTUAL_UNWIND_FRAME | _US_FORCE_UNWIND,
799 ucbp, (void *) &saved_vrs);
801 while (code != _URC_END_OF_STACK
802 && code != _URC_FAILURE);
805 restore_non_core_regs (&saved_vrs);
810 /* Common implementation for ARM ABI defined personality routines.
811 ID is the index of the personality routine, other arguments are as defined
812 by __aeabi_unwind_cpp_pr{0,1,2}. */
814 static _Unwind_Reason_Code
815 __gnu_unwind_pr_common (_Unwind_State state,
816 _Unwind_Control_Block *ucbp,
817 _Unwind_Context *context,
820 __gnu_unwind_state uws;
825 int phase2_call_unexpected_after_unwind = 0;
827 int forced_unwind = state & _US_FORCE_UNWIND;
829 state &= _US_ACTION_MASK;
831 data = (_uw *) ucbp->pr_cache.ehtp;
832 uws.data = *(data++);
842 uws.words_left = (uws.data >> 16) & 0xff;
845 data += uws.words_left;
848 /* Restore the saved pointer. */
849 if (state == _US_UNWIND_FRAME_RESUME)
850 data = (_uw *) ucbp->cleanup_cache.bitpattern[0];
852 if ((ucbp->pr_cache.additional & 1) == 0)
854 /* Process descriptors. */
862 len = ((EHT32 *) data)->length;
863 offset = ((EHT32 *) data)->offset;
868 len = ((EHT16 *) data)->length;
869 offset = ((EHT16 *) data)->offset;
873 fnstart = ucbp->pr_cache.fnstart + (offset & ~1);
874 addr = _Unwind_GetGR (context, R_PC);
875 in_range = (fnstart <= addr && addr < fnstart + (len & ~1));
877 switch (((offset & 1) << 1) | (len & 1))
881 if (state != _US_VIRTUAL_UNWIND_FRAME
884 /* Cleanup in range, and we are running cleanups. */
887 /* Landing pad address is 31-bit pc-relative offset. */
888 lp = selfrel_offset31 (data);
890 /* Save the exception data pointer. */
891 ucbp->cleanup_cache.bitpattern[0] = (_uw) data;
892 if (!__cxa_begin_cleanup (ucbp))
894 /* Setup the VRS to enter the landing pad. */
895 _Unwind_SetGR (context, R_PC, lp);
896 return _URC_INSTALL_CONTEXT;
898 /* Cleanup not in range, or we are in stage 1. */
904 if (state == _US_VIRTUAL_UNWIND_FRAME)
908 /* Check for a barrier. */
912 /* Check for no-throw areas. */
913 if (data[1] == (_uw) -2)
916 /* The thrown object immediately follows the ECB. */
917 matched = (void *)(ucbp + 1);
918 if (data[1] != (_uw) -1)
920 /* Match a catch specification. */
921 rtti = _Unwind_decode_target2 ((_uw) &data[1]);
922 if (!__cxa_type_match (ucbp, (type_info *) rtti,
929 ucbp->barrier_cache.sp =
930 _Unwind_GetGR (context, R_SP);
931 ucbp->barrier_cache.bitpattern[0] = (_uw) matched;
932 ucbp->barrier_cache.bitpattern[1] = (_uw) data;
933 return _URC_HANDLER_FOUND;
936 /* Handler out of range, or not matched. */
938 else if (ucbp->barrier_cache.sp == _Unwind_GetGR (context, R_SP)
939 && ucbp->barrier_cache.bitpattern[1] == (_uw) data)
941 /* Matched a previous propagation barrier. */
944 /* Setup for entry to the handler. */
945 lp = selfrel_offset31 (data);
946 _Unwind_SetGR (context, R_PC, lp);
947 _Unwind_SetGR (context, 0, (_uw) ucbp);
948 return _URC_INSTALL_CONTEXT;
950 /* Catch handler not matched. Advance to the next descriptor. */
955 rtti_count = data[0] & 0x7fffffff;
956 /* Exception specification. */
957 if (state == _US_VIRTUAL_UNWIND_FRAME)
959 if (in_range && (!forced_unwind || !rtti_count))
961 /* Match against the exception specification. */
966 for (i = 0; i < rtti_count; i++)
968 matched = (void *)(ucbp + 1);
969 rtti = _Unwind_decode_target2 ((_uw) &data[i + 1]);
970 if (__cxa_type_match (ucbp, (type_info *) rtti,
977 /* Exception does not match the spec. */
978 ucbp->barrier_cache.sp =
979 _Unwind_GetGR (context, R_SP);
980 ucbp->barrier_cache.bitpattern[0] = (_uw) matched;
981 ucbp->barrier_cache.bitpattern[1] = (_uw) data;
982 return _URC_HANDLER_FOUND;
985 /* Handler out of range, or exception is permitted. */
987 else if (ucbp->barrier_cache.sp == _Unwind_GetGR (context, R_SP)
988 && ucbp->barrier_cache.bitpattern[1] == (_uw) data)
990 /* Matched a previous propagation barrier. */
992 /* Record the RTTI list for __cxa_call_unexpected. */
993 ucbp->barrier_cache.bitpattern[1] = rtti_count;
994 ucbp->barrier_cache.bitpattern[2] = 0;
995 ucbp->barrier_cache.bitpattern[3] = 4;
996 ucbp->barrier_cache.bitpattern[4] = (_uw) &data[1];
998 if (data[0] & uint32_highbit)
999 phase2_call_unexpected_after_unwind = 1;
1002 data += rtti_count + 1;
1003 /* Setup for entry to the handler. */
1004 lp = selfrel_offset31 (data);
1006 _Unwind_SetGR (context, R_PC, lp);
1007 _Unwind_SetGR (context, 0, (_uw) ucbp);
1008 return _URC_INSTALL_CONTEXT;
1011 if (data[0] & uint32_highbit)
1013 data += rtti_count + 1;
1017 /* Should never happen. */
1018 return _URC_FAILURE;
1020 /* Finished processing this descriptor. */
1024 if (__gnu_unwind_execute (context, &uws) != _URC_OK)
1025 return _URC_FAILURE;
1027 if (phase2_call_unexpected_after_unwind)
1029 /* Enter __cxa_unexpected as if called from the call site. */
1030 _Unwind_SetGR (context, R_LR, _Unwind_GetGR (context, R_PC));
1031 _Unwind_SetGR (context, R_PC, (_uw) &__cxa_call_unexpected);
1032 return _URC_INSTALL_CONTEXT;
1035 return _URC_CONTINUE_UNWIND;
1039 /* ABI defined personality routine entry points. */
1042 __aeabi_unwind_cpp_pr0 (_Unwind_State state,
1043 _Unwind_Control_Block *ucbp,
1044 _Unwind_Context *context)
1046 return __gnu_unwind_pr_common (state, ucbp, context, 0);
1050 __aeabi_unwind_cpp_pr1 (_Unwind_State state,
1051 _Unwind_Control_Block *ucbp,
1052 _Unwind_Context *context)
1054 return __gnu_unwind_pr_common (state, ucbp, context, 1);
1058 __aeabi_unwind_cpp_pr2 (_Unwind_State state,
1059 _Unwind_Control_Block *ucbp,
1060 _Unwind_Context *context)
1062 return __gnu_unwind_pr_common (state, ucbp, context, 2);
1065 /* These two should never be used. */
1067 _Unwind_GetDataRelBase (_Unwind_Context *context __attribute__ ((unused)))
1073 _Unwind_GetTextRelBase (_Unwind_Context *context __attribute__ ((unused)))
1079 /* FreeBSD expects these to be functions */
1081 _Unwind_GetIP (struct _Unwind_Context *context)
1083 return _Unwind_GetGR (context, 15) & ~(_Unwind_Word)1;
1087 _Unwind_GetIPInfo (struct _Unwind_Context *context, int *ip_before_insn)
1089 *ip_before_insn = 0;
1090 return _Unwind_GetGR (context, 15) & ~(_Unwind_Word)1;