head 1.1; branch 1.1.1; access; symbols netbsd-11-0-RC4:1.1.1.10 netbsd-11-0-RC3:1.1.1.10 netbsd-11-0-RC2:1.1.1.10 netbsd-11-0-RC1:1.1.1.10 gcc-14-3-0:1.1.1.11 perseant-exfatfs-base-20250801:1.1.1.10 netbsd-11:1.1.1.10.0.4 netbsd-11-base:1.1.1.10 gcc-12-5-0:1.1.1.10 netbsd-10-1-RELEASE:1.1.1.9 perseant-exfatfs-base-20240630:1.1.1.10 gcc-12-4-0:1.1.1.10 perseant-exfatfs:1.1.1.10.0.2 perseant-exfatfs-base:1.1.1.10 netbsd-8-3-RELEASE:1.1.1.2 netbsd-9-4-RELEASE:1.1.1.4 netbsd-10-0-RELEASE:1.1.1.9 netbsd-10-0-RC6:1.1.1.9 netbsd-10-0-RC5:1.1.1.9 netbsd-10-0-RC4:1.1.1.9 netbsd-10-0-RC3:1.1.1.9 netbsd-10-0-RC2:1.1.1.9 netbsd-10-0-RC1:1.1.1.9 gcc-12-3-0:1.1.1.10 gcc-10-5-0:1.1.1.9 netbsd-10:1.1.1.9.0.6 netbsd-10-base:1.1.1.9 netbsd-9-3-RELEASE:1.1.1.4 gcc-10-4-0:1.1.1.9 cjep_sun2x-base1:1.1.1.9 cjep_sun2x:1.1.1.9.0.4 cjep_sun2x-base:1.1.1.9 cjep_staticlib_x-base1:1.1.1.9 netbsd-9-2-RELEASE:1.1.1.4 cjep_staticlib_x:1.1.1.9.0.2 cjep_staticlib_x-base:1.1.1.9 gcc-10-3-0:1.1.1.9 netbsd-9-1-RELEASE:1.1.1.4 gcc-9-3-0:1.1.1.8 gcc-7-5-0:1.1.1.6 phil-wifi-20200421:1.1.1.5 phil-wifi-20200411:1.1.1.5 is-mlppp:1.1.1.5.0.2 is-mlppp-base:1.1.1.5 phil-wifi-20200406:1.1.1.5 netbsd-8-2-RELEASE:1.1.1.2 gcc-8-4-0:1.1.1.7 netbsd-9-0-RELEASE:1.1.1.4 netbsd-9-0-RC2:1.1.1.4 netbsd-9-0-RC1:1.1.1.4 phil-wifi-20191119:1.1.1.5 gcc-8-3-0:1.1.1.5 netbsd-9:1.1.1.4.0.2 netbsd-9-base:1.1.1.4 phil-wifi-20190609:1.1.1.4 netbsd-8-1-RELEASE:1.1.1.2 netbsd-8-1-RC1:1.1.1.2 pgoyette-compat-merge-20190127:1.1.1.3.2.1 pgoyette-compat-20190127:1.1.1.4 gcc-7-4-0:1.1.1.4 pgoyette-compat-20190118:1.1.1.3 pgoyette-compat-1226:1.1.1.3 pgoyette-compat-1126:1.1.1.3 gcc-6-5-0:1.1.1.3 pgoyette-compat-1020:1.1.1.3 pgoyette-compat-0930:1.1.1.3 pgoyette-compat-0906:1.1.1.3 netbsd-7-2-RELEASE:1.1.1.1 pgoyette-compat-0728:1.1.1.3 netbsd-8-0-RELEASE:1.1.1.2 phil-wifi:1.1.1.3.0.4 phil-wifi-base:1.1.1.3 pgoyette-compat-0625:1.1.1.3 netbsd-8-0-RC2:1.1.1.2 pgoyette-compat-0521:1.1.1.3 pgoyette-compat-0502:1.1.1.3 pgoyette-compat-0422:1.1.1.3 netbsd-8-0-RC1:1.1.1.2 pgoyette-compat-0415:1.1.1.3 pgoyette-compat-0407:1.1.1.3 pgoyette-compat-0330:1.1.1.3 pgoyette-compat-0322:1.1.1.3 pgoyette-compat-0315:1.1.1.3 netbsd-7-1-2-RELEASE:1.1.1.1 pgoyette-compat:1.1.1.3.0.2 pgoyette-compat-base:1.1.1.3 gcc-6-4-0:1.1.1.3 netbsd-7-1-1-RELEASE:1.1.1.1 gcc-5-5-0:1.1.1.2 matt-nb8-mediatek:1.1.1.2.0.12 matt-nb8-mediatek-base:1.1.1.2 perseant-stdc-iso10646:1.1.1.2.0.10 perseant-stdc-iso10646-base:1.1.1.2 netbsd-8:1.1.1.2.0.8 netbsd-8-base:1.1.1.2 prg-localcount2-base3:1.1.1.2 prg-localcount2-base2:1.1.1.2 prg-localcount2-base1:1.1.1.2 prg-localcount2:1.1.1.2.0.6 prg-localcount2-base:1.1.1.2 pgoyette-localcount-20170426:1.1.1.2 bouyer-socketcan-base1:1.1.1.2 pgoyette-localcount-20170320:1.1.1.2 netbsd-7-1:1.1.1.1.0.14 netbsd-7-1-RELEASE:1.1.1.1 netbsd-7-1-RC2:1.1.1.1 netbsd-7-nhusb-base-20170116:1.1.1.1 bouyer-socketcan:1.1.1.2.0.4 bouyer-socketcan-base:1.1.1.2 pgoyette-localcount-20170107:1.1.1.2 netbsd-7-1-RC1:1.1.1.1 pgoyette-localcount-20161104:1.1.1.2 netbsd-7-0-2-RELEASE:1.1.1.1 localcount-20160914:1.1.1.2 netbsd-7-nhusb:1.1.1.1.0.12 netbsd-7-nhusb-base:1.1.1.1 pgoyette-localcount-20160806:1.1.1.2 pgoyette-localcount-20160726:1.1.1.2 pgoyette-localcount:1.1.1.2.0.2 pgoyette-localcount-base:1.1.1.2 gcc-5-4-0:1.1.1.2 netbsd-7-0-1-RELEASE:1.1.1.1 gcc-5-3-0:1.1.1.2 netbsd-7-0:1.1.1.1.0.10 netbsd-7-0-RELEASE:1.1.1.1 gcc-4-8-5-pre-gcc-old-import:1.1.1.1 netbsd-7-0-RC3:1.1.1.1 netbsd-7-0-RC2:1.1.1.1 post-gcc-4-8-5-merge:1.1.1.1 gcc-4-8-5:1.1.1.1 netbsd-7-0-RC1:1.1.1.1 gcc-4-8-4:1.1.1.1 gcc-4-8-20141009:1.1.1.1 tls-maxphys-base:1.1.1.1 tls-maxphys:1.1.1.1.0.8 netbsd-7:1.1.1.1.0.6 netbsd-7-base:1.1.1.1 gcc-4-8-3:1.1.1.1 yamt-pagecache:1.1.1.1.0.4 yamt-pagecache-base9:1.1.1.1 tls-earlyentropy:1.1.1.1.0.2 tls-earlyentropy-base:1.1.1.1 riastradh-xf86-video-intel-2-7-1-pre-2-21-15:1.1.1.1 riastradh-drm2-base3:1.1.1.1 gcc-4-8-3-pre-r208254:1.1.1.1 gcc-4-8-3-pre-r206687:1.1.1.1 FSF:1.1.1; locks; strict; comment @# @; 1.1 date 2014.03.01.08.41.45; author mrg; state Exp; branches 1.1.1.1; next ; commitid TtaB91QNTknAoYqx; 1.1.1.1 date 2014.03.01.08.41.45; author mrg; state Exp; branches 1.1.1.1.4.1 1.1.1.1.8.1; next 1.1.1.2; commitid TtaB91QNTknAoYqx; 1.1.1.2 date 2016.01.24.06.05.57; author mrg; state Exp; branches; next 1.1.1.3; commitid uWWfbLp08zOK79Sy; 1.1.1.3 date 2018.02.02.01.59.07; author mrg; state Exp; branches 1.1.1.3.2.1 1.1.1.3.4.1; next 1.1.1.4; commitid XNKaycqpfhzd5epA; 1.1.1.4 date 2019.01.19.10.14.14; author mrg; state Exp; branches; next 1.1.1.5; commitid VQ8OwWIg5RS9kn8B; 1.1.1.5 date 2019.10.01.09.36.02; author mrg; state Exp; branches; next 1.1.1.6; commitid smvgr2IPAQDr89FB; 1.1.1.6 date 2020.08.11.05.10.42; author mrg; state Exp; branches; next 1.1.1.7; commitid 5dBRDT7i6e65xBjC; 1.1.1.7 date 2020.08.11.05.30.03; author mrg; state Exp; branches; next 1.1.1.8; commitid 7AI4OfpLi4eqEBjC; 1.1.1.8 date 2020.09.05.07.52.03; author mrg; state Exp; branches; next 1.1.1.9; commitid ZRYA7IOuwfMjAPmC; 1.1.1.9 date 2021.04.10.22.09.58; author mrg; state Exp; branches; next 1.1.1.10; commitid eC4g0MRpqTvEkNOC; 1.1.1.10 date 2023.07.30.05.21.15; author mrg; state Exp; branches; next 1.1.1.11; commitid tk6nV4mbc9nVEMyE; 1.1.1.11 date 2025.09.13.23.45.43; author mrg; state Exp; branches; next ; commitid KwhwN4krNWa6XBaG; 1.1.1.1.4.1 date 2014.03.01.08.41.45; author yamt; state dead; branches; next 1.1.1.1.4.2; commitid NrwbWqQnCbhToyBx; 1.1.1.1.4.2 date 2014.05.22.16.36.24; author yamt; state Exp; branches; next ; commitid NrwbWqQnCbhToyBx; 1.1.1.1.8.1 date 2014.03.01.08.41.45; author tls; state dead; branches; next 1.1.1.1.8.2; commitid jTnpym9Qu0o4R1Nx; 1.1.1.1.8.2 date 2014.08.19.23.54.23; author tls; state Exp; branches; next ; commitid jTnpym9Qu0o4R1Nx; 1.1.1.3.2.1 date 2019.01.26.21.59.02; author pgoyette; state Exp; branches; next ; commitid JKpcmvSjdT25dl9B; 1.1.1.3.4.1 date 2019.06.10.21.54.08; author christos; state Exp; branches; next 1.1.1.3.4.2; commitid jtc8rnCzWiEEHGqB; 1.1.1.3.4.2 date 2020.04.13.07.58.04; author martin; state Exp; branches; next ; commitid X01YhRUPVUDaec4C; desc @@ 1.1 log @Initial revision @ text @/* Common unwinding code for ARM EABI and C6X. Copyright (C) 2004-2013 Free Software Foundation, Inc. Contributed by Paul Brook This file is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3, or (at your option) any later version. This file is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. Under Section 7 of GPL version 3, you are granted additional permissions described in the GCC Runtime Library Exception, version 3.1, as published by the Free Software Foundation. You should have received a copy of the GNU General Public License and a copy of the GCC Runtime Library Exception along with this program; see the files COPYING3 and COPYING.RUNTIME respectively. If not, see . */ #include "tconfig.h" #include "tsystem.h" #include "unwind.h" /* Used for SystemTap unwinder probe. */ #ifdef HAVE_SYS_SDT_H #include #endif /* We add a prototype for abort here to avoid creating a dependency on target headers. */ extern void abort (void); /* Definitions for C++ runtime support routines. We make these weak declarations to avoid pulling in libsupc++ unnecessarily. */ typedef unsigned char bool; typedef struct _ZSt9type_info type_info; /* This names C++ type_info type */ enum __cxa_type_match_result { ctm_failed = 0, ctm_succeeded = 1, ctm_succeeded_with_ptr_to_base = 2 }; void __attribute__((weak)) __cxa_call_unexpected(_Unwind_Control_Block *ucbp); bool __attribute__((weak)) __cxa_begin_cleanup(_Unwind_Control_Block *ucbp); enum __cxa_type_match_result __attribute__((weak)) __cxa_type_match (_Unwind_Control_Block *ucbp, const type_info *rttip, bool is_reference, void **matched_object); _Unwind_Ptr __attribute__((weak)) __gnu_Unwind_Find_exidx (_Unwind_Ptr, int *); #define EXIDX_CANTUNWIND 1 #define uint32_highbit (((_uw) 1) << 31) #define UCB_FORCED_STOP_FN(ucbp) ((ucbp)->unwinder_cache.reserved1) #define UCB_PR_ADDR(ucbp) ((ucbp)->unwinder_cache.reserved2) #define UCB_SAVED_CALLSITE_ADDR(ucbp) ((ucbp)->unwinder_cache.reserved3) #define UCB_FORCED_STOP_ARG(ucbp) ((ucbp)->unwinder_cache.reserved4) /* Unwind descriptors. */ typedef struct { _uw16 length; _uw16 offset; } EHT16; typedef struct { _uw length; _uw offset; } EHT32; /* An exception index table entry. */ typedef struct __EIT_entry { _uw fnoffset; _uw content; } __EIT_entry; /* Assembly helper functions. */ /* Restore core register state. Never returns. */ void __attribute__((noreturn)) restore_core_regs (struct core_regs *); /* Restore coprocessor state after phase1 unwinding. */ static void restore_non_core_regs (phase1_vrs * vrs); /* A better way to do this would probably be to compare the absolute address with a segment relative relocation of the same symbol. */ extern int __text_start; extern int __data_start; /* The exception index table location. */ extern __EIT_entry __exidx_start; extern __EIT_entry __exidx_end; /* Core unwinding functions. */ /* Calculate the address encoded by a 31-bit self-relative offset at address P. */ static inline _uw selfrel_offset31 (const _uw *p); static _uw __gnu_unwind_get_pr_addr (int idx); static void _Unwind_DebugHook (void *, void *) __attribute__ ((__noinline__, __used__, __noclone__)); /* This function is called during unwinding. It is intended as a hook for a debugger to intercept exceptions. CFA is the CFA of the target frame. HANDLER is the PC to which control will be transferred. */ static void _Unwind_DebugHook (void *cfa __attribute__ ((__unused__)), void *handler __attribute__ ((__unused__))) { /* We only want to use stap probes starting with v3. Earlier versions added too much startup cost. */ #if defined (HAVE_SYS_SDT_H) && defined (STAP_PROBE2) && _SDT_NOTE_TYPE >= 3 STAP_PROBE2 (libgcc, unwind, cfa, handler); #else asm (""); #endif } /* This is a wrapper to be called when we need to restore core registers. It will call `_Unwind_DebugHook' before restoring the registers, thus making it possible to intercept and debug exceptions. When calling `_Unwind_DebugHook', the first argument (the CFA) is zero because we are not interested in it. However, it must be there (even being zero) because GDB expects to find it when using the probe. */ #define uw_restore_core_regs(TARGET, CORE) \ do \ { \ void *handler = __builtin_frob_return_addr ((void *) VRS_PC (TARGET)); \ _Unwind_DebugHook (0, handler); \ restore_core_regs (CORE); \ } \ while (0) /* Perform a binary search for RETURN_ADDRESS in TABLE. The table contains NREC entries. */ static const __EIT_entry * search_EIT_table (const __EIT_entry * table, int nrec, _uw return_address) { _uw next_fn; _uw this_fn; int n, left, right; if (nrec == 0) return (__EIT_entry *) 0; left = 0; right = nrec - 1; while (1) { n = (left + right) / 2; this_fn = selfrel_offset31 (&table[n].fnoffset); if (n != nrec - 1) next_fn = selfrel_offset31 (&table[n + 1].fnoffset) - 1; else next_fn = (_uw)0 - 1; if (return_address < this_fn) { if (n == left) return (__EIT_entry *) 0; right = n - 1; } else if (return_address <= next_fn) return &table[n]; else left = n + 1; } } /* Find the exception index table eintry for the given address. Fill in the relevant fields of the UCB. Returns _URC_FAILURE if an error occurred, _URC_OK on success. */ static _Unwind_Reason_Code get_eit_entry (_Unwind_Control_Block *ucbp, _uw return_address) { const __EIT_entry * eitp; int nrec; /* The return address is the address of the instruction following the call instruction (plus one in thumb mode). If this was the last instruction in the function the address will lie in the following function. Subtract 2 from the address so that it points within the call instruction itself. */ return_address -= 2; if (__gnu_Unwind_Find_exidx) { eitp = (const __EIT_entry *) __gnu_Unwind_Find_exidx (return_address, &nrec); if (!eitp) { UCB_PR_ADDR (ucbp) = 0; return _URC_FAILURE; } } else { eitp = &__exidx_start; nrec = &__exidx_end - &__exidx_start; } eitp = search_EIT_table (eitp, nrec, return_address); if (!eitp) { UCB_PR_ADDR (ucbp) = 0; return _URC_FAILURE; } ucbp->pr_cache.fnstart = selfrel_offset31 (&eitp->fnoffset); /* Can this frame be unwound at all? */ if (eitp->content == EXIDX_CANTUNWIND) { UCB_PR_ADDR (ucbp) = 0; return _URC_END_OF_STACK; } /* Obtain the address of the "real" __EHT_Header word. */ if (eitp->content & uint32_highbit) { /* It is immediate data. */ ucbp->pr_cache.ehtp = (_Unwind_EHT_Header *)&eitp->content; ucbp->pr_cache.additional = 1; } else { /* The low 31 bits of the content field are a self-relative offset to an _Unwind_EHT_Entry structure. */ ucbp->pr_cache.ehtp = (_Unwind_EHT_Header *) selfrel_offset31 (&eitp->content); ucbp->pr_cache.additional = 0; } /* Discover the personality routine address. */ if (*ucbp->pr_cache.ehtp & (1u << 31)) { /* One of the predefined standard routines. */ _uw idx = (*(_uw *) ucbp->pr_cache.ehtp >> 24) & 0xf; UCB_PR_ADDR (ucbp) = __gnu_unwind_get_pr_addr (idx); if (UCB_PR_ADDR (ucbp) == 0) { /* Failed */ return _URC_FAILURE; } } else { /* Execute region offset to PR */ UCB_PR_ADDR (ucbp) = selfrel_offset31 (ucbp->pr_cache.ehtp); } return _URC_OK; } /* Perform phase2 unwinding. VRS is the initial virtual register state. */ static void __attribute__((noreturn)) unwind_phase2 (_Unwind_Control_Block * ucbp, phase2_vrs * vrs) { _Unwind_Reason_Code pr_result; do { /* Find the entry for this routine. */ if (get_eit_entry (ucbp, VRS_PC(vrs)) != _URC_OK) abort (); UCB_SAVED_CALLSITE_ADDR (ucbp) = VRS_PC(vrs); /* Call the pr to decide what to do. */ pr_result = ((personality_routine) UCB_PR_ADDR (ucbp)) (_US_UNWIND_FRAME_STARTING, ucbp, (_Unwind_Context *) vrs); } while (pr_result == _URC_CONTINUE_UNWIND); if (pr_result != _URC_INSTALL_CONTEXT) abort(); uw_restore_core_regs (vrs, &vrs->core); } /* Perform phase2 forced unwinding. */ static _Unwind_Reason_Code unwind_phase2_forced (_Unwind_Control_Block *ucbp, phase2_vrs *entry_vrs, int resuming) { _Unwind_Stop_Fn stop_fn = (_Unwind_Stop_Fn) UCB_FORCED_STOP_FN (ucbp); void *stop_arg = (void *)UCB_FORCED_STOP_ARG (ucbp); _Unwind_Reason_Code pr_result = 0; /* We use phase1_vrs here even though we do not demand save, for the prev_sp field. */ phase1_vrs saved_vrs, next_vrs; /* Save the core registers. */ saved_vrs.core = entry_vrs->core; /* We don't need to demand-save the non-core registers, because we unwind in a single pass. */ saved_vrs.demand_save_flags = 0; /* Unwind until we reach a propagation barrier. */ do { _Unwind_State action; _Unwind_Reason_Code entry_code; _Unwind_Reason_Code stop_code; /* Find the entry for this routine. */ entry_code = get_eit_entry (ucbp, VRS_PC (&saved_vrs)); if (resuming) { action = _US_UNWIND_FRAME_RESUME | _US_FORCE_UNWIND; resuming = 0; } else action = _US_UNWIND_FRAME_STARTING | _US_FORCE_UNWIND; if (entry_code == _URC_OK) { UCB_SAVED_CALLSITE_ADDR (ucbp) = VRS_PC (&saved_vrs); next_vrs = saved_vrs; /* Call the pr to decide what to do. */ pr_result = ((personality_routine) UCB_PR_ADDR (ucbp)) (action, ucbp, (void *) &next_vrs); saved_vrs.prev_sp = VRS_SP (&next_vrs); } else { /* Treat any failure as the end of unwinding, to cope more gracefully with missing EH information. Mixed EH and non-EH within one object will usually result in failure, because the .ARM.exidx tables do not indicate the end of the code to which they apply; but mixed EH and non-EH shared objects should return an unwind failure at the entry of a non-EH shared object. */ action |= _US_END_OF_STACK; saved_vrs.prev_sp = VRS_SP (&saved_vrs); } stop_code = stop_fn (1, action, ucbp->exception_class, ucbp, (void *)&saved_vrs, stop_arg); if (stop_code != _URC_NO_REASON) return _URC_FAILURE; if (entry_code != _URC_OK) return entry_code; saved_vrs = next_vrs; } while (pr_result == _URC_CONTINUE_UNWIND); if (pr_result != _URC_INSTALL_CONTEXT) { /* Some sort of failure has occurred in the pr and probably the pr returned _URC_FAILURE. */ return _URC_FAILURE; } uw_restore_core_regs (&saved_vrs, &saved_vrs.core); } /* This is a very limited implementation of _Unwind_GetCFA. It returns the stack pointer as it is about to be unwound, and is only valid while calling the stop function during forced unwinding. If the current personality routine result is going to run a cleanup, this will not be the CFA; but when the frame is really unwound, it will be. */ _Unwind_Word _Unwind_GetCFA (_Unwind_Context *context) { return ((phase1_vrs *) context)->prev_sp; } /* Perform phase1 unwinding. UCBP is the exception being thrown, and entry_VRS is the register state on entry to _Unwind_RaiseException. */ _Unwind_Reason_Code __gnu_Unwind_RaiseException (_Unwind_Control_Block *, phase2_vrs *); _Unwind_Reason_Code __gnu_Unwind_RaiseException (_Unwind_Control_Block * ucbp, phase2_vrs * entry_vrs) { phase1_vrs saved_vrs; _Unwind_Reason_Code pr_result; /* Set the pc to the call site. */ VRS_PC (entry_vrs) = VRS_RETURN(entry_vrs); /* Save the core registers. */ saved_vrs.core = entry_vrs->core; /* Set demand-save flags. */ saved_vrs.demand_save_flags = ~(_uw) 0; /* Unwind until we reach a propagation barrier. */ do { /* Find the entry for this routine. */ if (get_eit_entry (ucbp, VRS_PC (&saved_vrs)) != _URC_OK) return _URC_FAILURE; /* Call the pr to decide what to do. */ pr_result = ((personality_routine) UCB_PR_ADDR (ucbp)) (_US_VIRTUAL_UNWIND_FRAME, ucbp, (void *) &saved_vrs); } while (pr_result == _URC_CONTINUE_UNWIND); /* We've unwound as far as we want to go, so restore the original register state. */ restore_non_core_regs (&saved_vrs); if (pr_result != _URC_HANDLER_FOUND) { /* Some sort of failure has occurred in the pr and probably the pr returned _URC_FAILURE. */ return _URC_FAILURE; } unwind_phase2 (ucbp, entry_vrs); } /* Resume unwinding after a cleanup has been run. UCBP is the exception being thrown and ENTRY_VRS is the register state on entry to _Unwind_Resume. */ _Unwind_Reason_Code __gnu_Unwind_ForcedUnwind (_Unwind_Control_Block *, _Unwind_Stop_Fn, void *, phase2_vrs *); _Unwind_Reason_Code __gnu_Unwind_ForcedUnwind (_Unwind_Control_Block *ucbp, _Unwind_Stop_Fn stop_fn, void *stop_arg, phase2_vrs *entry_vrs) { UCB_FORCED_STOP_FN (ucbp) = (_uw) stop_fn; UCB_FORCED_STOP_ARG (ucbp) = (_uw) stop_arg; /* Set the pc to the call site. */ VRS_PC (entry_vrs) = VRS_RETURN(entry_vrs); return unwind_phase2_forced (ucbp, entry_vrs, 0); } _Unwind_Reason_Code __gnu_Unwind_Resume (_Unwind_Control_Block *, phase2_vrs *); _Unwind_Reason_Code __gnu_Unwind_Resume (_Unwind_Control_Block * ucbp, phase2_vrs * entry_vrs) { _Unwind_Reason_Code pr_result; /* Recover the saved address. */ VRS_PC (entry_vrs) = UCB_SAVED_CALLSITE_ADDR (ucbp); if (UCB_FORCED_STOP_FN (ucbp)) { unwind_phase2_forced (ucbp, entry_vrs, 1); /* We can't return failure at this point. */ abort (); } /* Call the cached PR. */ pr_result = ((personality_routine) UCB_PR_ADDR (ucbp)) (_US_UNWIND_FRAME_RESUME, ucbp, (_Unwind_Context *) entry_vrs); switch (pr_result) { case _URC_INSTALL_CONTEXT: /* Upload the registers to enter the landing pad. */ uw_restore_core_regs (entry_vrs, &entry_vrs->core); case _URC_CONTINUE_UNWIND: /* Continue unwinding the next frame. */ unwind_phase2 (ucbp, entry_vrs); default: abort (); } } _Unwind_Reason_Code __gnu_Unwind_Resume_or_Rethrow (_Unwind_Control_Block *, phase2_vrs *); _Unwind_Reason_Code __gnu_Unwind_Resume_or_Rethrow (_Unwind_Control_Block * ucbp, phase2_vrs * entry_vrs) { if (!UCB_FORCED_STOP_FN (ucbp)) return __gnu_Unwind_RaiseException (ucbp, entry_vrs); /* Set the pc to the call site. */ VRS_PC (entry_vrs) = VRS_RETURN (entry_vrs); /* Continue unwinding the next frame. */ return unwind_phase2_forced (ucbp, entry_vrs, 0); } /* Clean up an exception object when unwinding is complete. */ void _Unwind_Complete (_Unwind_Control_Block * ucbp __attribute__((unused))) { } /* Free an exception. */ void _Unwind_DeleteException (_Unwind_Exception * exc) { if (exc->exception_cleanup) (*exc->exception_cleanup) (_URC_FOREIGN_EXCEPTION_CAUGHT, exc); } /* Perform stack backtrace through unwind data. */ _Unwind_Reason_Code __gnu_Unwind_Backtrace(_Unwind_Trace_Fn trace, void * trace_argument, phase2_vrs * entry_vrs); _Unwind_Reason_Code __gnu_Unwind_Backtrace(_Unwind_Trace_Fn trace, void * trace_argument, phase2_vrs * entry_vrs) { phase1_vrs saved_vrs; _Unwind_Reason_Code code; _Unwind_Control_Block ucb; _Unwind_Control_Block *ucbp = &ucb; /* Set the pc to the call site. */ VRS_PC (entry_vrs) = VRS_RETURN (entry_vrs); /* Save the core registers. */ saved_vrs.core = entry_vrs->core; /* Set demand-save flags. */ saved_vrs.demand_save_flags = ~(_uw) 0; do { /* Find the entry for this routine. */ if (get_eit_entry (ucbp, VRS_PC (&saved_vrs)) != _URC_OK) { code = _URC_FAILURE; break; } /* The dwarf unwinder assumes the context structure holds things like the function and LSDA pointers. The ARM implementation caches these in the exception header (UCB). To avoid rewriting everything we make the virtual IP register point at the UCB. */ _Unwind_SetGR((_Unwind_Context *)&saved_vrs, UNWIND_POINTER_REG, (_Unwind_Ptr) ucbp); /* Call trace function. */ if ((*trace) ((_Unwind_Context *) &saved_vrs, trace_argument) != _URC_NO_REASON) { code = _URC_FAILURE; break; } /* Call the pr to decide what to do. */ code = ((personality_routine) UCB_PR_ADDR (ucbp)) (_US_VIRTUAL_UNWIND_FRAME | _US_FORCE_UNWIND, ucbp, (void *) &saved_vrs); } while (code != _URC_END_OF_STACK && code != _URC_FAILURE); restore_non_core_regs (&saved_vrs); return code; } /* Common implementation for ARM ABI defined personality routines. ID is the index of the personality routine, other arguments are as defined by __aeabi_unwind_cpp_pr{0,1,2}. */ static _Unwind_Reason_Code __gnu_unwind_pr_common (_Unwind_State state, _Unwind_Control_Block *ucbp, _Unwind_Context *context, int id) { __gnu_unwind_state uws; _uw *data; _uw offset; _uw len; _uw rtti_count; int phase2_call_unexpected_after_unwind = 0; int in_range = 0; int forced_unwind = state & _US_FORCE_UNWIND; state &= _US_ACTION_MASK; data = (_uw *) ucbp->pr_cache.ehtp; uws.data = *(data++); uws.next = data; if (id == 0) { uws.data <<= 8; uws.words_left = 0; uws.bytes_left = 3; } else if (id < 3) { uws.words_left = (uws.data >> 16) & 0xff; uws.data <<= 16; uws.bytes_left = 2; data += uws.words_left; } /* Restore the saved pointer. */ if (state == _US_UNWIND_FRAME_RESUME) data = (_uw *) ucbp->cleanup_cache.bitpattern[0]; if ((ucbp->pr_cache.additional & 1) == 0) { /* Process descriptors. */ while (*data) { _uw addr; _uw fnstart; if (id == 2) { len = ((EHT32 *) data)->length; offset = ((EHT32 *) data)->offset; data += 2; } else { len = ((EHT16 *) data)->length; offset = ((EHT16 *) data)->offset; data++; } fnstart = ucbp->pr_cache.fnstart + (offset & ~1); addr = _Unwind_GetGR (context, R_PC); in_range = (fnstart <= addr && addr < fnstart + (len & ~1)); switch (((offset & 1) << 1) | (len & 1)) { case 0: /* Cleanup. */ if (state != _US_VIRTUAL_UNWIND_FRAME && in_range) { /* Cleanup in range, and we are running cleanups. */ _uw lp; /* Landing pad address is 31-bit pc-relative offset. */ lp = selfrel_offset31 (data); data++; /* Save the exception data pointer. */ ucbp->cleanup_cache.bitpattern[0] = (_uw) data; if (!__cxa_begin_cleanup (ucbp)) return _URC_FAILURE; /* Setup the VRS to enter the landing pad. */ _Unwind_SetGR (context, R_PC, lp); return _URC_INSTALL_CONTEXT; } /* Cleanup not in range, or we are in stage 1. */ data++; break; case 1: /* Catch handler. */ if (state == _US_VIRTUAL_UNWIND_FRAME) { if (in_range) { /* Check for a barrier. */ _uw rtti; bool is_reference = (data[0] & uint32_highbit) != 0; void *matched; enum __cxa_type_match_result match_type; /* Check for no-throw areas. */ if (data[1] == (_uw) -2) return _URC_FAILURE; /* The thrown object immediately follows the ECB. */ matched = (void *)(ucbp + 1); if (data[1] != (_uw) -1) { /* Match a catch specification. */ rtti = _Unwind_decode_typeinfo_ptr (0, (_uw) &data[1]); match_type = __cxa_type_match (ucbp, (type_info *) rtti, is_reference, &matched); } else match_type = ctm_succeeded; if (match_type) { ucbp->barrier_cache.sp = _Unwind_GetGR (context, R_SP); // ctm_succeeded_with_ptr_to_base really // means _c_t_m indirected the pointer // object. We have to reconstruct the // additional pointer layer by using a temporary. if (match_type == ctm_succeeded_with_ptr_to_base) { ucbp->barrier_cache.bitpattern[2] = (_uw) matched; ucbp->barrier_cache.bitpattern[0] = (_uw) &ucbp->barrier_cache.bitpattern[2]; } else ucbp->barrier_cache.bitpattern[0] = (_uw) matched; ucbp->barrier_cache.bitpattern[1] = (_uw) data; return _URC_HANDLER_FOUND; } } /* Handler out of range, or not matched. */ } else if (ucbp->barrier_cache.sp == _Unwind_GetGR (context, R_SP) && ucbp->barrier_cache.bitpattern[1] == (_uw) data) { /* Matched a previous propagation barrier. */ _uw lp; /* Setup for entry to the handler. */ lp = selfrel_offset31 (data); _Unwind_SetGR (context, R_PC, lp); _Unwind_SetGR (context, 0, (_uw) ucbp); return _URC_INSTALL_CONTEXT; } /* Catch handler not matched. Advance to the next descriptor. */ data += 2; break; case 2: rtti_count = data[0] & 0x7fffffff; /* Exception specification. */ if (state == _US_VIRTUAL_UNWIND_FRAME) { if (in_range && (!forced_unwind || !rtti_count)) { /* Match against the exception specification. */ _uw i; _uw rtti; void *matched; for (i = 0; i < rtti_count; i++) { matched = (void *)(ucbp + 1); rtti = _Unwind_decode_typeinfo_ptr (0, (_uw) &data[i + 1]); if (__cxa_type_match (ucbp, (type_info *) rtti, 0, &matched)) break; } if (i == rtti_count) { /* Exception does not match the spec. */ ucbp->barrier_cache.sp = _Unwind_GetGR (context, R_SP); ucbp->barrier_cache.bitpattern[0] = (_uw) matched; ucbp->barrier_cache.bitpattern[1] = (_uw) data; return _URC_HANDLER_FOUND; } } /* Handler out of range, or exception is permitted. */ } else if (ucbp->barrier_cache.sp == _Unwind_GetGR (context, R_SP) && ucbp->barrier_cache.bitpattern[1] == (_uw) data) { /* Matched a previous propagation barrier. */ _uw lp; /* Record the RTTI list for __cxa_call_unexpected. */ ucbp->barrier_cache.bitpattern[1] = rtti_count; ucbp->barrier_cache.bitpattern[2] = 0; ucbp->barrier_cache.bitpattern[3] = 4; ucbp->barrier_cache.bitpattern[4] = (_uw) &data[1]; if (data[0] & uint32_highbit) { data += rtti_count + 1; /* Setup for entry to the handler. */ lp = selfrel_offset31 (data); data++; _Unwind_SetGR (context, R_PC, lp); _Unwind_SetGR (context, 0, (_uw) ucbp); return _URC_INSTALL_CONTEXT; } else phase2_call_unexpected_after_unwind = 1; } if (data[0] & uint32_highbit) data++; data += rtti_count + 1; break; default: /* Should never happen. */ return _URC_FAILURE; } /* Finished processing this descriptor. */ } } if (id >= 3) { /* 24-bit ecoding */ if (__gnu_unwind_24bit (context, uws.data, id == 4) != _URC_OK) return _URC_FAILURE; } else { if (__gnu_unwind_execute (context, &uws) != _URC_OK) return _URC_FAILURE; } if (phase2_call_unexpected_after_unwind) { /* Enter __cxa_unexpected as if called from the call site. */ _Unwind_SetGR (context, R_LR, _Unwind_GetGR (context, R_PC)); _Unwind_SetGR (context, R_PC, (_uw) &__cxa_call_unexpected); return _URC_INSTALL_CONTEXT; } return _URC_CONTINUE_UNWIND; } @ 1.1.1.1 log @import GCC 4.8 branch at r206687. highlights from: http://gcc.gnu.org/gcc-4.6/changes.html GCC now has stricter checks for invalid command-line options New -Wunused-but-set-variable and -Wunused-but-set-parameter warnings Many platforms have been obsoleted Link-time optimization improvements A new switch -fstack-usage has been added A new function attribute leaf was introduced A new warning, enabled by -Wdouble-promotion Support for selectively enabling and disabling warnings via #pragma GCC diagnostic has been added There is now experimental support for some features from the upcoming C1X revision of the ISO C standard Improved experimental support for the upcoming C++0x ISO C++ standard G++ now issues clearer diagnostics in several cases Updates for ARM, x86, MIPS, PPC/PPC64, SPARC Darwin, FreeBSD, Solaris 2, MinGW and Cygwin now all support __float128 on 32-bit and 64-bit x86 targets. [*1] highlights from: http://gcc.gnu.org/gcc-4.7/changes.html The -fconserve-space flag has been deprecated Support for a new parameter --param case-values-threshold=n was added Interprocedural and Link-time optimization improvements A new built-in, __builtin_assume_aligned, has been added A new warning option -Wunused-local-typedefs was added A new experimental command-line option -ftrack-macro-expansion was added Support for atomic operations specifying the C++11/C11 memory model has been added There is support for some more features from the C11 revision of the ISO C standard Improved experimental support for the new ISO C++ standard, C++11 Updates for ARM, x86, MIPS, PPC/PPC64, SH, SPARC, TILE* A new option (-grecord-gcc-switches) was added highlights from: http://gcc.gnu.org/gcc-4.8/changes.html GCC now uses C++ as its implementation language. This means that to build GCC from sources, you will need a C++ compiler that understands C++ 2003 DWARF4 is now the default when generating DWARF debug information A new general optimization level, -Og, has been introduced A new option -ftree-partial-pre was added The option -fconserve-space has been removed The command-line options -fipa-struct-reorg and -fipa-matrix-reorg have been removed Interprocedural and Link-time optimization improvements AddressSanitizer, a fast memory error detector, has been added [*2] A new -Wsizeof-pointer-memaccess warning has been added G++ now supports a -std=c++1y option for experimentation with features proposed for the next revision of the standard, expected around 2014 Improved experimental support for the new ISO C++ standard, C++11 A new port has been added to support AArch64 Updates for ARM, x86, MIPS, PPC/PPC64, SH, SPARC, TILE* [*1] we should support this too! [*2] we should look into this. https://code.google.com/p/address-sanitizer/ @ text @@ 1.1.1.2 log @import GCC 5.3.0. see these urls for details which are too large to include here: http://gcc.gnu.org/gcc-4.9/changes.html http://gcc.gnu.org/gcc-5/changes.html (note that GCC 5.x is a release stream like GCC 4.9.x, 4.8.x, etc.) the main issues we will have are: The default mode for C is now -std=gnu11 instead of -std=gnu89. ARM: The deprecated option -mwords-little-endian has been removed. The options -mapcs, -mapcs-frame, -mtpcs-frame and -mtpcs-leaf-frame which are only applicable to the old ABI have been deprecated. MIPS: The o32 ABI has been modified and extended. The o32 64-bit floating-point register support is now obsolete and has been removed. It has been replaced by three ABI extensions FPXX, FP64A, and FP64. The meaning of the -mfp64 command-line option has changed. It is now used to enable the FP64A and FP64 ABI extensions. @ text @d2 1 a2 1 Copyright (C) 2004-2015 Free Software Foundation, Inc. @ 1.1.1.3 log @import GCC 6.4.0. see this url for details which are too large to include here: http://gcc.gnu.org/gcc-6/changes.html the main visible changes appear to be: - The default mode for C++ is now -std=gnu++14 instead of -std=gnu++98. - The C and C++ compilers now support attributes on enumerators. - Diagnostics can now contain "fix-it hints" - more warnings (some added to -Wall) @ text @d2 1 a2 1 Copyright (C) 2004-2016 Free Software Foundation, Inc. @ 1.1.1.3.4.1 log @Sync with HEAD @ text @d2 1 a2 1 Copyright (C) 2004-2017 Free Software Foundation, Inc. @ 1.1.1.3.4.2 log @Mostly merge changes from HEAD upto 20200411 @ text @d2 1 a2 1 Copyright (C) 2004-2018 Free Software Foundation, Inc. @ 1.1.1.3.2.1 log @Sync with HEAD @ text @d2 1 a2 1 Copyright (C) 2004-2017 Free Software Foundation, Inc. @ 1.1.1.4 log @import GCC 7.4.0. main changes include: The non-standard C++0x type traits has_trivial_default_constructor, has_trivial_copy_constructor and has_trivial_copy_assign have been removed. On ARM targets (arm*-*-*), a bug introduced in GCC 5 that affects conformance to the procedure call standard (AAPCS) has been fixed. Many optimiser improvements DWARF-5 support. Many new and enhanced warnings. Warnings about format strings now underline the pertinent part of the string, and can offer suggested fixes. Several new warnings related to buffer overflows and buffer truncation. New __builtin_add_overflow_p, __builtin_sub_overflow_p, __builtin_mul_overflow_p built-ins added that test for overflow. The C++ front end has experimental support for all of the current C++17 draft. The -fverbose-asm option has been expanded to prints comments showing the source lines that correspond to the assembly. The gcc and g++ driver programs will now provide suggestions for misspelled arguments to command-line options. AArch64 specific: GCC has been updated to the latest revision of the procedure call standard (AAPCS64) to provide support for parameter passing when data types have been over-aligned. The ARMv8.2-A and ARMv8.3-A architecture are now supported. ARM specific: Support for the ARMv5 and ARMv5E architectures has been deprecated (which have no known implementations). A new command-line option -mpure-code has been added. It does not allow constant data to be placed in code sections. x86 specific: Support for the AVX-512 4FMAPS, 4VNNIW, VPOPCNTDQ and Software Guard Extensions (SGX) ISA extensions has been added. PPC specific: GCC now diagnoses inline assembly that clobbers register r2. RISC-V specific: Support for the RISC-V instruction set has been added. SH specific: Support for SH5/SH64 has been removed. Support for SH2A has been enhanced. @ text @d2 1 a2 1 Copyright (C) 2004-2017 Free Software Foundation, Inc. @ 1.1.1.5 log @import GCC 8.3. it includes these new features: - many optimisations improved: inter-procedural, profile-directed, LTO, loops including user-controllable unroll support, and more. - columns numbers added to line numbers in dwarf - gcov extended significantly - many sanitizer updates - many new warning messages - many better hints and more useful error messages - minor ABI changes on x86-64 libstdc++, and some c++17 modes - draft c++2a features - better c++17 experimental support - Armv8.4-A supported, better 8.2-A and 8.3-A support, including 32 bit arm port. cortex a-55, a-75 and a-55.a-75 combo support. - in the GCC bugzilla, 8.1 shows 1149 bugs fixed, 8.2 shows 100, and 8.3 shows 158. @ text @d2 1 a2 1 Copyright (C) 2004-2018 Free Software Foundation, Inc. @ 1.1.1.6 log @import GCC 7.5.0. doing this here so that the vendor branch has the code we'll merge into gcc.old and the netbsd-9 tree gcc tree. GCC 8.4.0 will be imported immediately on top of this again, restoring the current status. these PRs in the GCC bugzilla are fixed with this update: 89869 80693 89795 84272 85593 86669 87148 87647 87895 88103 88107 88563 88870 88976 89002 89187 89195 89234 89303 89314 89354 89361 89403 89412 89512 89520 89590 89621 89663 89679 89704 89734 89872 89933 90090 90208 87075 85870 89009 89242 88167 80864 81933 85890 86608 87145 88857 89024 89119 89214 89511 89612 89705 89400 81740 82186 84552 86554 87609 88105 88149 88415 88739 88903 89135 89223 89296 89505 89572 89677 89698 89710 90006 90020 90071 90328 90474 91126 91162 91812 91887 90075 88998 89945 87047 87506 88074 88656 88740 91137 89008 84010 89349 91136 91347 91995 89397 87030 60702 78884 85594 87649 87725 88181 88470 88553 88568 88588 88620 88644 88906 88949 89246 89587 89726 89768 89796 89998 90108 90756 90950 91704 88825 88983 86538 51333 89446 90220 91308 92143 89392 90213 90278 91131 91200 91510 89037 91481 87673 88418 88938 88948 90547 27221 58321 61250 67183 67958 77583 83531 86215 88648 88720 88726 89091 89466 89629 90105 90329 90585 90760 90924 91087 89222 81956 71861 35031 69455 81849 82993 85798 88138 88155 88169 88205 88206 88228 88249 88269 88376 77703 80260 82077 86248 88393 90786 57048 66089 66695 67679 68009 71723 72714 84394 85544 87734 88298 90937 91557 63891 64132 65342 68649 68717 71066 71860 71935 77746 78421 78645 78865 78983 79485 79540 85953 88326 89651 90744 @ text @d2 1 a2 1 Copyright (C) 2004-2017 Free Software Foundation, Inc. @ 1.1.1.7 log @re-import GCC 8.4.0. @ text @d2 1 a2 1 Copyright (C) 2004-2018 Free Software Foundation, Inc. @ 1.1.1.8 log @initial import of GCC 9.3.0. changes include: - live patching support - shell completion help - generally better diagnostic output (less verbose/more useful) - diagnostics and optimisation choices can be emitted in json - asan memory usage reduction - many general, and specific to switch, inter-procedure, profile and link-time optimisations. from the release notes: "Overall compile time of Firefox 66 and LibreOffice 6.2.3 on an 8-core machine was reduced by about 5% compared to GCC 8.3" - OpenMP 5.0 support - better spell-guesser - partial experimental support for c2x and c++2a - c++17 is no longer experimental - arm AAPCS GCC 6-8 structure passing bug fixed, may cause incompatibility (restored compat with GCC 5 and earlier.) - openrisc support @ text @d2 1 a2 1 Copyright (C) 2004-2019 Free Software Foundation, Inc. @ 1.1.1.9 log @initial import of GCC 10.3.0. main changes include: caveats: - ABI issue between c++14 and c++17 fixed - profile mode is removed from libstdc++ - -fno-common is now the default new features: - new flags -fallocation-dce, -fprofile-partial-training, -fprofile-reproducible, -fprofile-prefix-path, and -fanalyzer - many new compile and link time optimisations - enhanced drive optimisations - openacc 2.6 support - openmp 5.0 features - new warnings: -Wstring-compare and -Wzero-length-bounds - extended warnings: -Warray-bounds, -Wformat-overflow, -Wrestrict, -Wreturn-local-addr, -Wstringop-overflow, -Warith-conversion, -Wmismatched-tags, and -Wredundant-tags - some likely C2X features implemented - more C++20 implemented - many new arm & intel CPUs known hundreds of reported bugs are fixed. full list of changes can be found at: https://gcc.gnu.org/gcc-10/changes.html @ text @d2 1 a2 1 Copyright (C) 2004-2020 Free Software Foundation, Inc. a32 20 #if __FDPIC__ /* Load r7 with rt_sigreturn value. */ #define ARM_SET_R7_RT_SIGRETURN 0xe3a070ad /* mov r7, #0xad */ #define THUMB2_SET_R7_RT_SIGRETURN 0x07adf04f /* mov.w r7, #0xad */ /* FDPIC jump to restorer sequence. */ #define FDPIC_LDR_R12_WITH_FUNCDESC 0xe59fc004 /* ldr r12, [pc, #4] */ #define FDPIC_LDR_R9_WITH_GOT 0xe59c9004 /* ldr r9, [r12, #4] */ #define FDPIC_LDR_PC_WITH_RESTORER 0xe59cf000 /* ldr pc, [r12] */ #define FDPIC_T2_LDR_R12_WITH_FUNCDESC 0xc008f8df /* ldr.w r12, [pc, #8] */ #define FDPIC_T2_LDR_R9_WITH_GOT 0x9004f8dc /* ldr.w r9, [r12, #4] */ #define FDPIC_T2_LDR_PC_WITH_RESTORER 0xf000f8dc /* ldr.w pc, [r12] */ #define FDPIC_FUNCDESC_OFFSET 12 /* Signal frame offsets. */ #define ARM_NEW_RT_SIGFRAME_UCONTEXT 0x80 #define ARM_UCONTEXT_SIGCONTEXT 0x14 #define ARM_SIGCONTEXT_R0 0xc #endif a64 1 #define UCB_PR_GOT(ucbp) ((ucbp)->unwinder_cache.reserved5) a87 10 #ifdef __FDPIC__ /* Only used in FDPIC case. */ struct funcdesc_t { unsigned int ptr; unsigned int got; }; #endif a190 39 #if __FDPIC__ /* VFP is not restored, but this is sufficient to allow unwinding. */ static _Unwind_Reason_Code __gnu_personality_sigframe_fdpic (_Unwind_State state, _Unwind_Control_Block *ucbp, _Unwind_Context *context) { unsigned int sp; unsigned int pc; unsigned int funcdesc; unsigned int handler; unsigned int first_handler_instruction; int i; _Unwind_VRS_Get (context, _UVRSC_CORE, R_SP, _UVRSD_UINT32, &sp); _Unwind_VRS_Get (context, _UVRSC_CORE, R_PC, _UVRSD_UINT32, &pc); funcdesc = *(unsigned int *)((pc & ~1) + FDPIC_FUNCDESC_OFFSET); handler = *(unsigned int *)(funcdesc); first_handler_instruction = *(unsigned int *)(handler & ~1); /* Adjust SP to point to the start of registers according to signal type. */ if (first_handler_instruction == ARM_SET_R7_RT_SIGRETURN || first_handler_instruction == THUMB2_SET_R7_RT_SIGRETURN) sp += ARM_NEW_RT_SIGFRAME_UCONTEXT + ARM_UCONTEXT_SIGCONTEXT + ARM_SIGCONTEXT_R0; else sp += ARM_UCONTEXT_SIGCONTEXT + ARM_SIGCONTEXT_R0; /* Restore regs saved on stack by the kernel. */ for (i = 0; i < 16; i++) _Unwind_VRS_Set (context, _UVRSC_CORE, i, _UVRSD_UINT32, sp + 4 * i); return _URC_CONTINUE_UNWIND; } #endif a213 21 #if __FDPIC__ /* If we are unwinding a signal handler then perhaps we have reached a trampoline. Try to detect jump to restorer sequence. */ _uw *pc = (_uw *)((return_address+2) & ~1); if ((pc[0] == FDPIC_LDR_R12_WITH_FUNCDESC && pc[1] == FDPIC_LDR_R9_WITH_GOT && pc[2] == FDPIC_LDR_PC_WITH_RESTORER) || (pc[0] == FDPIC_T2_LDR_R12_WITH_FUNCDESC && pc[1] == FDPIC_T2_LDR_R9_WITH_GOT && pc[2] == FDPIC_T2_LDR_PC_WITH_RESTORER)) { struct funcdesc_t *funcdesc = (struct funcdesc_t *) &__gnu_personality_sigframe_fdpic; UCB_PR_ADDR (ucbp) = funcdesc->ptr; UCB_PR_GOT (ucbp) = funcdesc->got; return _URC_OK; } #endif a227 21 #if __FDPIC__ /* If we are unwinding a signal handler then perhaps we have reached a trampoline. Try to detect jump to restorer sequence. */ _uw *pc = (_uw *)((return_address+2) & ~1); if ((pc[0] == FDPIC_LDR_R12_WITH_FUNCDESC && pc[1] == FDPIC_LDR_R9_WITH_GOT && pc[2] == FDPIC_LDR_PC_WITH_RESTORER) || (pc[0] == FDPIC_T2_LDR_R12_WITH_FUNCDESC && pc[1] == FDPIC_T2_LDR_R9_WITH_GOT && pc[2] == FDPIC_T2_LDR_PC_WITH_RESTORER)) { struct funcdesc_t *funcdesc = (struct funcdesc_t *) &__gnu_personality_sigframe_fdpic; UCB_PR_ADDR (ucbp) = funcdesc->ptr; UCB_PR_GOT (ucbp) = funcdesc->got; return _URC_OK; } #endif a235 21 #if __FDPIC__ /* If we are unwinding a signal handler then perhaps we have reached a trampoline. Try to detect jump to restorer sequence. */ _uw *pc = (_uw *)((return_address+2) & ~1); if ((pc[0] == FDPIC_LDR_R12_WITH_FUNCDESC && pc[1] == FDPIC_LDR_R9_WITH_GOT && pc[2] == FDPIC_LDR_PC_WITH_RESTORER) || (pc[0] == FDPIC_T2_LDR_R12_WITH_FUNCDESC && pc[1] == FDPIC_T2_LDR_R9_WITH_GOT && pc[2] == FDPIC_T2_LDR_PC_WITH_RESTORER)) { struct funcdesc_t *funcdesc = (struct funcdesc_t *) &__gnu_personality_sigframe_fdpic; UCB_PR_ADDR (ucbp) = funcdesc->ptr; UCB_PR_GOT (ucbp) = funcdesc->got; return _URC_OK; } #endif a261 13 #if __FDPIC__ { struct funcdesc_t *funcdesc = (struct funcdesc_t *) __gnu_unwind_get_pr_addr (idx); if (funcdesc) { UCB_PR_ADDR (ucbp) = funcdesc->ptr; UCB_PR_GOT (ucbp) = funcdesc->got; } else UCB_PR_ADDR (ucbp) = 0; } #else a262 1 #endif a272 4 #if __FDPIC__ UCB_PR_GOT (ucbp) = (unsigned int) _Unwind_gnu_Find_got ((_Unwind_Ptr) UCB_PR_ADDR (ucbp)); #endif a293 9 #if __FDPIC__ { volatile struct funcdesc_t funcdesc; funcdesc.ptr = UCB_PR_ADDR (ucbp); funcdesc.got = UCB_PR_GOT (ucbp); pr_result = ((personality_routine) &funcdesc) (_US_UNWIND_FRAME_STARTING, ucbp, (_Unwind_Context *) vrs); } #else a295 1 #endif a301 5 #if __FDPIC__ /* r9 could have been lost due to PLT jump. Restore correct value. */ vrs->core.r[FDPIC_REGNUM] = _Unwind_gnu_Find_got (VRS_PC (vrs)); #endif a348 9 #if __FDPIC__ { volatile struct funcdesc_t funcdesc; funcdesc.ptr = UCB_PR_ADDR (ucbp); funcdesc.got = UCB_PR_GOT (ucbp); pr_result = ((personality_routine) &funcdesc) (action, ucbp, (void *) &next_vrs); } #else a350 1 #endif a386 5 #if __FDPIC__ /* r9 could have been lost due to PLT jump. Restore correct value. */ saved_vrs.core.r[FDPIC_REGNUM] = _Unwind_gnu_Find_got (VRS_PC (&saved_vrs)); #endif a431 9 #if __FDPIC__ { volatile struct funcdesc_t funcdesc; funcdesc.ptr = UCB_PR_ADDR (ucbp); funcdesc.got = UCB_PR_GOT (ucbp); pr_result = ((personality_routine) &funcdesc) (_US_VIRTUAL_UNWIND_FRAME, ucbp, (void *) &saved_vrs); } #else a433 1 #endif a490 9 #if __FDPIC__ { volatile struct funcdesc_t funcdesc; funcdesc.ptr = UCB_PR_ADDR (ucbp); funcdesc.got = UCB_PR_GOT (ucbp); pr_result = ((personality_routine) &funcdesc) (_US_UNWIND_FRAME_RESUME, ucbp, (_Unwind_Context *) entry_vrs); } #else a492 1 #endif a497 4 #if __FDPIC__ /* r9 could have been lost due to PLT jump. Restore correct value. */ entry_vrs->core.r[FDPIC_REGNUM] = _Unwind_gnu_Find_got (VRS_PC (entry_vrs)); #endif a588 10 #if __FDPIC__ { volatile struct funcdesc_t funcdesc; funcdesc.ptr = UCB_PR_ADDR (ucbp); funcdesc.got = UCB_PR_GOT (ucbp); code = ((personality_routine) &funcdesc) (_US_VIRTUAL_UNWIND_FRAME | _US_FORCE_UNWIND, ucbp, (void *) &saved_vrs); } #else a591 1 #endif @ 1.1.1.10 log @initial import of GCC 12.3.0. major changes in GCC 11 included: - The default mode for C++ is now -std=gnu++17 instead of -std=gnu++14. - When building GCC itself, the host compiler must now support C++11, rather than C++98. - Some short options of the gcov tool have been renamed: -i to -j and -j to -H. - ThreadSanitizer improvements. - Introduce Hardware-assisted AddressSanitizer support. - For targets that produce DWARF debugging information GCC now defaults to DWARF version 5. This can produce up to 25% more compact debug information compared to earlier versions. - Many optimisations. - The existing malloc attribute has been extended so that it can be used to identify allocator/deallocator API pairs. A pair of new -Wmismatched-dealloc and -Wmismatched-new-delete warnings are added. - Other new warnings: -Wsizeof-array-div, enabled by -Wall, warns about divisions of two sizeof operators when the first one is applied to an array and the divisor does not equal the size of the array element. -Wstringop-overread, enabled by default, warns about calls to string functions reading past the end of the arrays passed to them as arguments. -Wtsan, enabled by default, warns about unsupported features in ThreadSanitizer (currently std::atomic_thread_fence). - Enchanced warnings: -Wfree-nonheap-object detects many more instances of calls to deallocation functions with pointers not returned from a dynamic memory allocation function. -Wmaybe-uninitialized diagnoses passing pointers or references to uninitialized memory to functions taking const-qualified arguments. -Wuninitialized detects reads from uninitialized dynamically allocated memory. -Warray-parameter warns about functions with inconsistent array forms. -Wvla-parameter warns about functions with inconsistent VLA forms. - Several new features from the upcoming C2X revision of the ISO C standard are supported with -std=c2x and -std=gnu2x. - Several C++20 features have been implemented. - The C++ front end has experimental support for some of the upcoming C++23 draft. - Several new C++ warnings. - Enhanced Arm, AArch64, x86, and RISC-V CPU support. - The implementation of how program state is tracked within -fanalyzer has been completely rewritten with many enhancements. see https://gcc.gnu.org/gcc-11/changes.html for a full list. major changes in GCC 12 include: - An ABI incompatibility between C and C++ when passing or returning by value certain aggregates containing zero width bit-fields has been discovered on various targets. x86-64, ARM and AArch64 will always ignore them (so there is a C ABI incompatibility between GCC 11 and earlier with GCC 12 or later), PowerPC64 ELFv2 always take them into account (so there is a C++ ABI incompatibility, GCC 4.4 and earlier compatible with GCC 12 or later, incompatible with GCC 4.5 through GCC 11). RISC-V has changed the handling of these already starting with GCC 10. As the ABI requires, MIPS takes them into account handling function return values so there is a C++ ABI incompatibility with GCC 4.5 through 11. - STABS: Support for emitting the STABS debugging format is deprecated and will be removed in the next release. All ports now default to emit DWARF (version 2 or later) debugging info or are obsoleted. - Vectorization is enabled at -O2 which is now equivalent to the original -O2 -ftree-vectorize -fvect-cost-model=very-cheap. - GCC now supports the ShadowCallStack sanitizer. - Support for __builtin_shufflevector compatible with the clang language extension was added. - Support for attribute unavailable was added. - Support for __builtin_dynamic_object_size compatible with the clang language extension was added. - New warnings: -Wbidi-chars warns about potentially misleading UTF-8 bidirectional control characters. -Warray-compare warns about comparisons between two operands of array type. - Some new features from the upcoming C2X revision of the ISO C standard are supported with -std=c2x and -std=gnu2x. - Several C++23 features have been implemented. - Many C++ enhancements across warnings and -f options. see https://gcc.gnu.org/gcc-12/changes.html for a full list. @ text @d2 1 a2 1 Copyright (C) 2004-2022 Free Software Foundation, Inc. d53 4 @ 1.1.1.11 log @initial import of GCC 14.3.0. major changes in GCC 13: - improved sanitizer - zstd debug info compression - LTO improvements - SARIF based diagnostic support - new warnings: -Wxor-used-as-pow, -Wenum-int-mismatch, -Wself-move, -Wdangling-reference - many new -Wanalyzer* specific warnings - enhanced warnings: -Wpessimizing-move, -Wredundant-move - new attributes to mark file descriptors, c++23 "assume" - several C23 features added - several C++23 features added - many new features for Arm, x86, RISC-V major changes in GCC 14: - more strict C99 or newer support - ia64* marked deprecated (but seemingly still in GCC 15.) - several new hardening features - support for "hardbool", which can have user supplied values of true/false - explicit support for stack scrubbing upon function exit - better auto-vectorisation support - added clang-compatible __has_feature and __has_extension - more C23, including -std=c23 - several C++26 features added - better diagnostics in C++ templates - new warnings: -Wnrvo, Welaborated-enum-base - many new features for Arm, x86, RISC-V - possible ABI breaking change for SPARC64 and small structures with arrays of floats. @ text @d2 1 a2 1 Copyright (C) 2004-2024 Free Software Foundation, Inc. d251 1 a251 1 _Unwind_VRS_Set (context, _UVRSC_CORE, i, _UVRSD_UINT32, (void *)(sp + 4 * i)); @ 1.1.1.1.8.1 log @file unwind-arm-common.inc was added on branch tls-maxphys on 2014-08-19 23:54:23 +0000 @ text @d1 855 @ 1.1.1.1.8.2 log @Rebase to HEAD as of a few days ago. @ text @a0 855 /* Common unwinding code for ARM EABI and C6X. Copyright (C) 2004-2013 Free Software Foundation, Inc. Contributed by Paul Brook This file is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3, or (at your option) any later version. This file is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. Under Section 7 of GPL version 3, you are granted additional permissions described in the GCC Runtime Library Exception, version 3.1, as published by the Free Software Foundation. You should have received a copy of the GNU General Public License and a copy of the GCC Runtime Library Exception along with this program; see the files COPYING3 and COPYING.RUNTIME respectively. If not, see . */ #include "tconfig.h" #include "tsystem.h" #include "unwind.h" /* Used for SystemTap unwinder probe. */ #ifdef HAVE_SYS_SDT_H #include #endif /* We add a prototype for abort here to avoid creating a dependency on target headers. */ extern void abort (void); /* Definitions for C++ runtime support routines. We make these weak declarations to avoid pulling in libsupc++ unnecessarily. */ typedef unsigned char bool; typedef struct _ZSt9type_info type_info; /* This names C++ type_info type */ enum __cxa_type_match_result { ctm_failed = 0, ctm_succeeded = 1, ctm_succeeded_with_ptr_to_base = 2 }; void __attribute__((weak)) __cxa_call_unexpected(_Unwind_Control_Block *ucbp); bool __attribute__((weak)) __cxa_begin_cleanup(_Unwind_Control_Block *ucbp); enum __cxa_type_match_result __attribute__((weak)) __cxa_type_match (_Unwind_Control_Block *ucbp, const type_info *rttip, bool is_reference, void **matched_object); _Unwind_Ptr __attribute__((weak)) __gnu_Unwind_Find_exidx (_Unwind_Ptr, int *); #define EXIDX_CANTUNWIND 1 #define uint32_highbit (((_uw) 1) << 31) #define UCB_FORCED_STOP_FN(ucbp) ((ucbp)->unwinder_cache.reserved1) #define UCB_PR_ADDR(ucbp) ((ucbp)->unwinder_cache.reserved2) #define UCB_SAVED_CALLSITE_ADDR(ucbp) ((ucbp)->unwinder_cache.reserved3) #define UCB_FORCED_STOP_ARG(ucbp) ((ucbp)->unwinder_cache.reserved4) /* Unwind descriptors. */ typedef struct { _uw16 length; _uw16 offset; } EHT16; typedef struct { _uw length; _uw offset; } EHT32; /* An exception index table entry. */ typedef struct __EIT_entry { _uw fnoffset; _uw content; } __EIT_entry; /* Assembly helper functions. */ /* Restore core register state. Never returns. */ void __attribute__((noreturn)) restore_core_regs (struct core_regs *); /* Restore coprocessor state after phase1 unwinding. */ static void restore_non_core_regs (phase1_vrs * vrs); /* A better way to do this would probably be to compare the absolute address with a segment relative relocation of the same symbol. */ extern int __text_start; extern int __data_start; /* The exception index table location. */ extern __EIT_entry __exidx_start; extern __EIT_entry __exidx_end; /* Core unwinding functions. */ /* Calculate the address encoded by a 31-bit self-relative offset at address P. */ static inline _uw selfrel_offset31 (const _uw *p); static _uw __gnu_unwind_get_pr_addr (int idx); static void _Unwind_DebugHook (void *, void *) __attribute__ ((__noinline__, __used__, __noclone__)); /* This function is called during unwinding. It is intended as a hook for a debugger to intercept exceptions. CFA is the CFA of the target frame. HANDLER is the PC to which control will be transferred. */ static void _Unwind_DebugHook (void *cfa __attribute__ ((__unused__)), void *handler __attribute__ ((__unused__))) { /* We only want to use stap probes starting with v3. Earlier versions added too much startup cost. */ #if defined (HAVE_SYS_SDT_H) && defined (STAP_PROBE2) && _SDT_NOTE_TYPE >= 3 STAP_PROBE2 (libgcc, unwind, cfa, handler); #else asm (""); #endif } /* This is a wrapper to be called when we need to restore core registers. It will call `_Unwind_DebugHook' before restoring the registers, thus making it possible to intercept and debug exceptions. When calling `_Unwind_DebugHook', the first argument (the CFA) is zero because we are not interested in it. However, it must be there (even being zero) because GDB expects to find it when using the probe. */ #define uw_restore_core_regs(TARGET, CORE) \ do \ { \ void *handler = __builtin_frob_return_addr ((void *) VRS_PC (TARGET)); \ _Unwind_DebugHook (0, handler); \ restore_core_regs (CORE); \ } \ while (0) /* Perform a binary search for RETURN_ADDRESS in TABLE. The table contains NREC entries. */ static const __EIT_entry * search_EIT_table (const __EIT_entry * table, int nrec, _uw return_address) { _uw next_fn; _uw this_fn; int n, left, right; if (nrec == 0) return (__EIT_entry *) 0; left = 0; right = nrec - 1; while (1) { n = (left + right) / 2; this_fn = selfrel_offset31 (&table[n].fnoffset); if (n != nrec - 1) next_fn = selfrel_offset31 (&table[n + 1].fnoffset) - 1; else next_fn = (_uw)0 - 1; if (return_address < this_fn) { if (n == left) return (__EIT_entry *) 0; right = n - 1; } else if (return_address <= next_fn) return &table[n]; else left = n + 1; } } /* Find the exception index table eintry for the given address. Fill in the relevant fields of the UCB. Returns _URC_FAILURE if an error occurred, _URC_OK on success. */ static _Unwind_Reason_Code get_eit_entry (_Unwind_Control_Block *ucbp, _uw return_address) { const __EIT_entry * eitp; int nrec; /* The return address is the address of the instruction following the call instruction (plus one in thumb mode). If this was the last instruction in the function the address will lie in the following function. Subtract 2 from the address so that it points within the call instruction itself. */ return_address -= 2; if (__gnu_Unwind_Find_exidx) { eitp = (const __EIT_entry *) __gnu_Unwind_Find_exidx (return_address, &nrec); if (!eitp) { UCB_PR_ADDR (ucbp) = 0; return _URC_FAILURE; } } else { eitp = &__exidx_start; nrec = &__exidx_end - &__exidx_start; } eitp = search_EIT_table (eitp, nrec, return_address); if (!eitp) { UCB_PR_ADDR (ucbp) = 0; return _URC_FAILURE; } ucbp->pr_cache.fnstart = selfrel_offset31 (&eitp->fnoffset); /* Can this frame be unwound at all? */ if (eitp->content == EXIDX_CANTUNWIND) { UCB_PR_ADDR (ucbp) = 0; return _URC_END_OF_STACK; } /* Obtain the address of the "real" __EHT_Header word. */ if (eitp->content & uint32_highbit) { /* It is immediate data. */ ucbp->pr_cache.ehtp = (_Unwind_EHT_Header *)&eitp->content; ucbp->pr_cache.additional = 1; } else { /* The low 31 bits of the content field are a self-relative offset to an _Unwind_EHT_Entry structure. */ ucbp->pr_cache.ehtp = (_Unwind_EHT_Header *) selfrel_offset31 (&eitp->content); ucbp->pr_cache.additional = 0; } /* Discover the personality routine address. */ if (*ucbp->pr_cache.ehtp & (1u << 31)) { /* One of the predefined standard routines. */ _uw idx = (*(_uw *) ucbp->pr_cache.ehtp >> 24) & 0xf; UCB_PR_ADDR (ucbp) = __gnu_unwind_get_pr_addr (idx); if (UCB_PR_ADDR (ucbp) == 0) { /* Failed */ return _URC_FAILURE; } } else { /* Execute region offset to PR */ UCB_PR_ADDR (ucbp) = selfrel_offset31 (ucbp->pr_cache.ehtp); } return _URC_OK; } /* Perform phase2 unwinding. VRS is the initial virtual register state. */ static void __attribute__((noreturn)) unwind_phase2 (_Unwind_Control_Block * ucbp, phase2_vrs * vrs) { _Unwind_Reason_Code pr_result; do { /* Find the entry for this routine. */ if (get_eit_entry (ucbp, VRS_PC(vrs)) != _URC_OK) abort (); UCB_SAVED_CALLSITE_ADDR (ucbp) = VRS_PC(vrs); /* Call the pr to decide what to do. */ pr_result = ((personality_routine) UCB_PR_ADDR (ucbp)) (_US_UNWIND_FRAME_STARTING, ucbp, (_Unwind_Context *) vrs); } while (pr_result == _URC_CONTINUE_UNWIND); if (pr_result != _URC_INSTALL_CONTEXT) abort(); uw_restore_core_regs (vrs, &vrs->core); } /* Perform phase2 forced unwinding. */ static _Unwind_Reason_Code unwind_phase2_forced (_Unwind_Control_Block *ucbp, phase2_vrs *entry_vrs, int resuming) { _Unwind_Stop_Fn stop_fn = (_Unwind_Stop_Fn) UCB_FORCED_STOP_FN (ucbp); void *stop_arg = (void *)UCB_FORCED_STOP_ARG (ucbp); _Unwind_Reason_Code pr_result = 0; /* We use phase1_vrs here even though we do not demand save, for the prev_sp field. */ phase1_vrs saved_vrs, next_vrs; /* Save the core registers. */ saved_vrs.core = entry_vrs->core; /* We don't need to demand-save the non-core registers, because we unwind in a single pass. */ saved_vrs.demand_save_flags = 0; /* Unwind until we reach a propagation barrier. */ do { _Unwind_State action; _Unwind_Reason_Code entry_code; _Unwind_Reason_Code stop_code; /* Find the entry for this routine. */ entry_code = get_eit_entry (ucbp, VRS_PC (&saved_vrs)); if (resuming) { action = _US_UNWIND_FRAME_RESUME | _US_FORCE_UNWIND; resuming = 0; } else action = _US_UNWIND_FRAME_STARTING | _US_FORCE_UNWIND; if (entry_code == _URC_OK) { UCB_SAVED_CALLSITE_ADDR (ucbp) = VRS_PC (&saved_vrs); next_vrs = saved_vrs; /* Call the pr to decide what to do. */ pr_result = ((personality_routine) UCB_PR_ADDR (ucbp)) (action, ucbp, (void *) &next_vrs); saved_vrs.prev_sp = VRS_SP (&next_vrs); } else { /* Treat any failure as the end of unwinding, to cope more gracefully with missing EH information. Mixed EH and non-EH within one object will usually result in failure, because the .ARM.exidx tables do not indicate the end of the code to which they apply; but mixed EH and non-EH shared objects should return an unwind failure at the entry of a non-EH shared object. */ action |= _US_END_OF_STACK; saved_vrs.prev_sp = VRS_SP (&saved_vrs); } stop_code = stop_fn (1, action, ucbp->exception_class, ucbp, (void *)&saved_vrs, stop_arg); if (stop_code != _URC_NO_REASON) return _URC_FAILURE; if (entry_code != _URC_OK) return entry_code; saved_vrs = next_vrs; } while (pr_result == _URC_CONTINUE_UNWIND); if (pr_result != _URC_INSTALL_CONTEXT) { /* Some sort of failure has occurred in the pr and probably the pr returned _URC_FAILURE. */ return _URC_FAILURE; } uw_restore_core_regs (&saved_vrs, &saved_vrs.core); } /* This is a very limited implementation of _Unwind_GetCFA. It returns the stack pointer as it is about to be unwound, and is only valid while calling the stop function during forced unwinding. If the current personality routine result is going to run a cleanup, this will not be the CFA; but when the frame is really unwound, it will be. */ _Unwind_Word _Unwind_GetCFA (_Unwind_Context *context) { return ((phase1_vrs *) context)->prev_sp; } /* Perform phase1 unwinding. UCBP is the exception being thrown, and entry_VRS is the register state on entry to _Unwind_RaiseException. */ _Unwind_Reason_Code __gnu_Unwind_RaiseException (_Unwind_Control_Block *, phase2_vrs *); _Unwind_Reason_Code __gnu_Unwind_RaiseException (_Unwind_Control_Block * ucbp, phase2_vrs * entry_vrs) { phase1_vrs saved_vrs; _Unwind_Reason_Code pr_result; /* Set the pc to the call site. */ VRS_PC (entry_vrs) = VRS_RETURN(entry_vrs); /* Save the core registers. */ saved_vrs.core = entry_vrs->core; /* Set demand-save flags. */ saved_vrs.demand_save_flags = ~(_uw) 0; /* Unwind until we reach a propagation barrier. */ do { /* Find the entry for this routine. */ if (get_eit_entry (ucbp, VRS_PC (&saved_vrs)) != _URC_OK) return _URC_FAILURE; /* Call the pr to decide what to do. */ pr_result = ((personality_routine) UCB_PR_ADDR (ucbp)) (_US_VIRTUAL_UNWIND_FRAME, ucbp, (void *) &saved_vrs); } while (pr_result == _URC_CONTINUE_UNWIND); /* We've unwound as far as we want to go, so restore the original register state. */ restore_non_core_regs (&saved_vrs); if (pr_result != _URC_HANDLER_FOUND) { /* Some sort of failure has occurred in the pr and probably the pr returned _URC_FAILURE. */ return _URC_FAILURE; } unwind_phase2 (ucbp, entry_vrs); } /* Resume unwinding after a cleanup has been run. UCBP is the exception being thrown and ENTRY_VRS is the register state on entry to _Unwind_Resume. */ _Unwind_Reason_Code __gnu_Unwind_ForcedUnwind (_Unwind_Control_Block *, _Unwind_Stop_Fn, void *, phase2_vrs *); _Unwind_Reason_Code __gnu_Unwind_ForcedUnwind (_Unwind_Control_Block *ucbp, _Unwind_Stop_Fn stop_fn, void *stop_arg, phase2_vrs *entry_vrs) { UCB_FORCED_STOP_FN (ucbp) = (_uw) stop_fn; UCB_FORCED_STOP_ARG (ucbp) = (_uw) stop_arg; /* Set the pc to the call site. */ VRS_PC (entry_vrs) = VRS_RETURN(entry_vrs); return unwind_phase2_forced (ucbp, entry_vrs, 0); } _Unwind_Reason_Code __gnu_Unwind_Resume (_Unwind_Control_Block *, phase2_vrs *); _Unwind_Reason_Code __gnu_Unwind_Resume (_Unwind_Control_Block * ucbp, phase2_vrs * entry_vrs) { _Unwind_Reason_Code pr_result; /* Recover the saved address. */ VRS_PC (entry_vrs) = UCB_SAVED_CALLSITE_ADDR (ucbp); if (UCB_FORCED_STOP_FN (ucbp)) { unwind_phase2_forced (ucbp, entry_vrs, 1); /* We can't return failure at this point. */ abort (); } /* Call the cached PR. */ pr_result = ((personality_routine) UCB_PR_ADDR (ucbp)) (_US_UNWIND_FRAME_RESUME, ucbp, (_Unwind_Context *) entry_vrs); switch (pr_result) { case _URC_INSTALL_CONTEXT: /* Upload the registers to enter the landing pad. */ uw_restore_core_regs (entry_vrs, &entry_vrs->core); case _URC_CONTINUE_UNWIND: /* Continue unwinding the next frame. */ unwind_phase2 (ucbp, entry_vrs); default: abort (); } } _Unwind_Reason_Code __gnu_Unwind_Resume_or_Rethrow (_Unwind_Control_Block *, phase2_vrs *); _Unwind_Reason_Code __gnu_Unwind_Resume_or_Rethrow (_Unwind_Control_Block * ucbp, phase2_vrs * entry_vrs) { if (!UCB_FORCED_STOP_FN (ucbp)) return __gnu_Unwind_RaiseException (ucbp, entry_vrs); /* Set the pc to the call site. */ VRS_PC (entry_vrs) = VRS_RETURN (entry_vrs); /* Continue unwinding the next frame. */ return unwind_phase2_forced (ucbp, entry_vrs, 0); } /* Clean up an exception object when unwinding is complete. */ void _Unwind_Complete (_Unwind_Control_Block * ucbp __attribute__((unused))) { } /* Free an exception. */ void _Unwind_DeleteException (_Unwind_Exception * exc) { if (exc->exception_cleanup) (*exc->exception_cleanup) (_URC_FOREIGN_EXCEPTION_CAUGHT, exc); } /* Perform stack backtrace through unwind data. */ _Unwind_Reason_Code __gnu_Unwind_Backtrace(_Unwind_Trace_Fn trace, void * trace_argument, phase2_vrs * entry_vrs); _Unwind_Reason_Code __gnu_Unwind_Backtrace(_Unwind_Trace_Fn trace, void * trace_argument, phase2_vrs * entry_vrs) { phase1_vrs saved_vrs; _Unwind_Reason_Code code; _Unwind_Control_Block ucb; _Unwind_Control_Block *ucbp = &ucb; /* Set the pc to the call site. */ VRS_PC (entry_vrs) = VRS_RETURN (entry_vrs); /* Save the core registers. */ saved_vrs.core = entry_vrs->core; /* Set demand-save flags. */ saved_vrs.demand_save_flags = ~(_uw) 0; do { /* Find the entry for this routine. */ if (get_eit_entry (ucbp, VRS_PC (&saved_vrs)) != _URC_OK) { code = _URC_FAILURE; break; } /* The dwarf unwinder assumes the context structure holds things like the function and LSDA pointers. The ARM implementation caches these in the exception header (UCB). To avoid rewriting everything we make the virtual IP register point at the UCB. */ _Unwind_SetGR((_Unwind_Context *)&saved_vrs, UNWIND_POINTER_REG, (_Unwind_Ptr) ucbp); /* Call trace function. */ if ((*trace) ((_Unwind_Context *) &saved_vrs, trace_argument) != _URC_NO_REASON) { code = _URC_FAILURE; break; } /* Call the pr to decide what to do. */ code = ((personality_routine) UCB_PR_ADDR (ucbp)) (_US_VIRTUAL_UNWIND_FRAME | _US_FORCE_UNWIND, ucbp, (void *) &saved_vrs); } while (code != _URC_END_OF_STACK && code != _URC_FAILURE); restore_non_core_regs (&saved_vrs); return code; } /* Common implementation for ARM ABI defined personality routines. ID is the index of the personality routine, other arguments are as defined by __aeabi_unwind_cpp_pr{0,1,2}. */ static _Unwind_Reason_Code __gnu_unwind_pr_common (_Unwind_State state, _Unwind_Control_Block *ucbp, _Unwind_Context *context, int id) { __gnu_unwind_state uws; _uw *data; _uw offset; _uw len; _uw rtti_count; int phase2_call_unexpected_after_unwind = 0; int in_range = 0; int forced_unwind = state & _US_FORCE_UNWIND; state &= _US_ACTION_MASK; data = (_uw *) ucbp->pr_cache.ehtp; uws.data = *(data++); uws.next = data; if (id == 0) { uws.data <<= 8; uws.words_left = 0; uws.bytes_left = 3; } else if (id < 3) { uws.words_left = (uws.data >> 16) & 0xff; uws.data <<= 16; uws.bytes_left = 2; data += uws.words_left; } /* Restore the saved pointer. */ if (state == _US_UNWIND_FRAME_RESUME) data = (_uw *) ucbp->cleanup_cache.bitpattern[0]; if ((ucbp->pr_cache.additional & 1) == 0) { /* Process descriptors. */ while (*data) { _uw addr; _uw fnstart; if (id == 2) { len = ((EHT32 *) data)->length; offset = ((EHT32 *) data)->offset; data += 2; } else { len = ((EHT16 *) data)->length; offset = ((EHT16 *) data)->offset; data++; } fnstart = ucbp->pr_cache.fnstart + (offset & ~1); addr = _Unwind_GetGR (context, R_PC); in_range = (fnstart <= addr && addr < fnstart + (len & ~1)); switch (((offset & 1) << 1) | (len & 1)) { case 0: /* Cleanup. */ if (state != _US_VIRTUAL_UNWIND_FRAME && in_range) { /* Cleanup in range, and we are running cleanups. */ _uw lp; /* Landing pad address is 31-bit pc-relative offset. */ lp = selfrel_offset31 (data); data++; /* Save the exception data pointer. */ ucbp->cleanup_cache.bitpattern[0] = (_uw) data; if (!__cxa_begin_cleanup (ucbp)) return _URC_FAILURE; /* Setup the VRS to enter the landing pad. */ _Unwind_SetGR (context, R_PC, lp); return _URC_INSTALL_CONTEXT; } /* Cleanup not in range, or we are in stage 1. */ data++; break; case 1: /* Catch handler. */ if (state == _US_VIRTUAL_UNWIND_FRAME) { if (in_range) { /* Check for a barrier. */ _uw rtti; bool is_reference = (data[0] & uint32_highbit) != 0; void *matched; enum __cxa_type_match_result match_type; /* Check for no-throw areas. */ if (data[1] == (_uw) -2) return _URC_FAILURE; /* The thrown object immediately follows the ECB. */ matched = (void *)(ucbp + 1); if (data[1] != (_uw) -1) { /* Match a catch specification. */ rtti = _Unwind_decode_typeinfo_ptr (0, (_uw) &data[1]); match_type = __cxa_type_match (ucbp, (type_info *) rtti, is_reference, &matched); } else match_type = ctm_succeeded; if (match_type) { ucbp->barrier_cache.sp = _Unwind_GetGR (context, R_SP); // ctm_succeeded_with_ptr_to_base really // means _c_t_m indirected the pointer // object. We have to reconstruct the // additional pointer layer by using a temporary. if (match_type == ctm_succeeded_with_ptr_to_base) { ucbp->barrier_cache.bitpattern[2] = (_uw) matched; ucbp->barrier_cache.bitpattern[0] = (_uw) &ucbp->barrier_cache.bitpattern[2]; } else ucbp->barrier_cache.bitpattern[0] = (_uw) matched; ucbp->barrier_cache.bitpattern[1] = (_uw) data; return _URC_HANDLER_FOUND; } } /* Handler out of range, or not matched. */ } else if (ucbp->barrier_cache.sp == _Unwind_GetGR (context, R_SP) && ucbp->barrier_cache.bitpattern[1] == (_uw) data) { /* Matched a previous propagation barrier. */ _uw lp; /* Setup for entry to the handler. */ lp = selfrel_offset31 (data); _Unwind_SetGR (context, R_PC, lp); _Unwind_SetGR (context, 0, (_uw) ucbp); return _URC_INSTALL_CONTEXT; } /* Catch handler not matched. Advance to the next descriptor. */ data += 2; break; case 2: rtti_count = data[0] & 0x7fffffff; /* Exception specification. */ if (state == _US_VIRTUAL_UNWIND_FRAME) { if (in_range && (!forced_unwind || !rtti_count)) { /* Match against the exception specification. */ _uw i; _uw rtti; void *matched; for (i = 0; i < rtti_count; i++) { matched = (void *)(ucbp + 1); rtti = _Unwind_decode_typeinfo_ptr (0, (_uw) &data[i + 1]); if (__cxa_type_match (ucbp, (type_info *) rtti, 0, &matched)) break; } if (i == rtti_count) { /* Exception does not match the spec. */ ucbp->barrier_cache.sp = _Unwind_GetGR (context, R_SP); ucbp->barrier_cache.bitpattern[0] = (_uw) matched; ucbp->barrier_cache.bitpattern[1] = (_uw) data; return _URC_HANDLER_FOUND; } } /* Handler out of range, or exception is permitted. */ } else if (ucbp->barrier_cache.sp == _Unwind_GetGR (context, R_SP) && ucbp->barrier_cache.bitpattern[1] == (_uw) data) { /* Matched a previous propagation barrier. */ _uw lp; /* Record the RTTI list for __cxa_call_unexpected. */ ucbp->barrier_cache.bitpattern[1] = rtti_count; ucbp->barrier_cache.bitpattern[2] = 0; ucbp->barrier_cache.bitpattern[3] = 4; ucbp->barrier_cache.bitpattern[4] = (_uw) &data[1]; if (data[0] & uint32_highbit) { data += rtti_count + 1; /* Setup for entry to the handler. */ lp = selfrel_offset31 (data); data++; _Unwind_SetGR (context, R_PC, lp); _Unwind_SetGR (context, 0, (_uw) ucbp); return _URC_INSTALL_CONTEXT; } else phase2_call_unexpected_after_unwind = 1; } if (data[0] & uint32_highbit) data++; data += rtti_count + 1; break; default: /* Should never happen. */ return _URC_FAILURE; } /* Finished processing this descriptor. */ } } if (id >= 3) { /* 24-bit ecoding */ if (__gnu_unwind_24bit (context, uws.data, id == 4) != _URC_OK) return _URC_FAILURE; } else { if (__gnu_unwind_execute (context, &uws) != _URC_OK) return _URC_FAILURE; } if (phase2_call_unexpected_after_unwind) { /* Enter __cxa_unexpected as if called from the call site. */ _Unwind_SetGR (context, R_LR, _Unwind_GetGR (context, R_PC)); _Unwind_SetGR (context, R_PC, (_uw) &__cxa_call_unexpected); return _URC_INSTALL_CONTEXT; } return _URC_CONTINUE_UNWIND; } @ 1.1.1.1.4.1 log @file unwind-arm-common.inc was added on branch yamt-pagecache on 2014-05-22 16:36:23 +0000 @ text @d1 855 @ 1.1.1.1.4.2 log @sync with head. for a reference, the tree before this commit was tagged as yamt-pagecache-tag8. this commit was splitted into small chunks to avoid a limitation of cvs. ("Protocol error: too many arguments") @ text @a0 855 /* Common unwinding code for ARM EABI and C6X. Copyright (C) 2004-2013 Free Software Foundation, Inc. Contributed by Paul Brook This file is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3, or (at your option) any later version. This file is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. Under Section 7 of GPL version 3, you are granted additional permissions described in the GCC Runtime Library Exception, version 3.1, as published by the Free Software Foundation. You should have received a copy of the GNU General Public License and a copy of the GCC Runtime Library Exception along with this program; see the files COPYING3 and COPYING.RUNTIME respectively. If not, see . */ #include "tconfig.h" #include "tsystem.h" #include "unwind.h" /* Used for SystemTap unwinder probe. */ #ifdef HAVE_SYS_SDT_H #include #endif /* We add a prototype for abort here to avoid creating a dependency on target headers. */ extern void abort (void); /* Definitions for C++ runtime support routines. We make these weak declarations to avoid pulling in libsupc++ unnecessarily. */ typedef unsigned char bool; typedef struct _ZSt9type_info type_info; /* This names C++ type_info type */ enum __cxa_type_match_result { ctm_failed = 0, ctm_succeeded = 1, ctm_succeeded_with_ptr_to_base = 2 }; void __attribute__((weak)) __cxa_call_unexpected(_Unwind_Control_Block *ucbp); bool __attribute__((weak)) __cxa_begin_cleanup(_Unwind_Control_Block *ucbp); enum __cxa_type_match_result __attribute__((weak)) __cxa_type_match (_Unwind_Control_Block *ucbp, const type_info *rttip, bool is_reference, void **matched_object); _Unwind_Ptr __attribute__((weak)) __gnu_Unwind_Find_exidx (_Unwind_Ptr, int *); #define EXIDX_CANTUNWIND 1 #define uint32_highbit (((_uw) 1) << 31) #define UCB_FORCED_STOP_FN(ucbp) ((ucbp)->unwinder_cache.reserved1) #define UCB_PR_ADDR(ucbp) ((ucbp)->unwinder_cache.reserved2) #define UCB_SAVED_CALLSITE_ADDR(ucbp) ((ucbp)->unwinder_cache.reserved3) #define UCB_FORCED_STOP_ARG(ucbp) ((ucbp)->unwinder_cache.reserved4) /* Unwind descriptors. */ typedef struct { _uw16 length; _uw16 offset; } EHT16; typedef struct { _uw length; _uw offset; } EHT32; /* An exception index table entry. */ typedef struct __EIT_entry { _uw fnoffset; _uw content; } __EIT_entry; /* Assembly helper functions. */ /* Restore core register state. Never returns. */ void __attribute__((noreturn)) restore_core_regs (struct core_regs *); /* Restore coprocessor state after phase1 unwinding. */ static void restore_non_core_regs (phase1_vrs * vrs); /* A better way to do this would probably be to compare the absolute address with a segment relative relocation of the same symbol. */ extern int __text_start; extern int __data_start; /* The exception index table location. */ extern __EIT_entry __exidx_start; extern __EIT_entry __exidx_end; /* Core unwinding functions. */ /* Calculate the address encoded by a 31-bit self-relative offset at address P. */ static inline _uw selfrel_offset31 (const _uw *p); static _uw __gnu_unwind_get_pr_addr (int idx); static void _Unwind_DebugHook (void *, void *) __attribute__ ((__noinline__, __used__, __noclone__)); /* This function is called during unwinding. It is intended as a hook for a debugger to intercept exceptions. CFA is the CFA of the target frame. HANDLER is the PC to which control will be transferred. */ static void _Unwind_DebugHook (void *cfa __attribute__ ((__unused__)), void *handler __attribute__ ((__unused__))) { /* We only want to use stap probes starting with v3. Earlier versions added too much startup cost. */ #if defined (HAVE_SYS_SDT_H) && defined (STAP_PROBE2) && _SDT_NOTE_TYPE >= 3 STAP_PROBE2 (libgcc, unwind, cfa, handler); #else asm (""); #endif } /* This is a wrapper to be called when we need to restore core registers. It will call `_Unwind_DebugHook' before restoring the registers, thus making it possible to intercept and debug exceptions. When calling `_Unwind_DebugHook', the first argument (the CFA) is zero because we are not interested in it. However, it must be there (even being zero) because GDB expects to find it when using the probe. */ #define uw_restore_core_regs(TARGET, CORE) \ do \ { \ void *handler = __builtin_frob_return_addr ((void *) VRS_PC (TARGET)); \ _Unwind_DebugHook (0, handler); \ restore_core_regs (CORE); \ } \ while (0) /* Perform a binary search for RETURN_ADDRESS in TABLE. The table contains NREC entries. */ static const __EIT_entry * search_EIT_table (const __EIT_entry * table, int nrec, _uw return_address) { _uw next_fn; _uw this_fn; int n, left, right; if (nrec == 0) return (__EIT_entry *) 0; left = 0; right = nrec - 1; while (1) { n = (left + right) / 2; this_fn = selfrel_offset31 (&table[n].fnoffset); if (n != nrec - 1) next_fn = selfrel_offset31 (&table[n + 1].fnoffset) - 1; else next_fn = (_uw)0 - 1; if (return_address < this_fn) { if (n == left) return (__EIT_entry *) 0; right = n - 1; } else if (return_address <= next_fn) return &table[n]; else left = n + 1; } } /* Find the exception index table eintry for the given address. Fill in the relevant fields of the UCB. Returns _URC_FAILURE if an error occurred, _URC_OK on success. */ static _Unwind_Reason_Code get_eit_entry (_Unwind_Control_Block *ucbp, _uw return_address) { const __EIT_entry * eitp; int nrec; /* The return address is the address of the instruction following the call instruction (plus one in thumb mode). If this was the last instruction in the function the address will lie in the following function. Subtract 2 from the address so that it points within the call instruction itself. */ return_address -= 2; if (__gnu_Unwind_Find_exidx) { eitp = (const __EIT_entry *) __gnu_Unwind_Find_exidx (return_address, &nrec); if (!eitp) { UCB_PR_ADDR (ucbp) = 0; return _URC_FAILURE; } } else { eitp = &__exidx_start; nrec = &__exidx_end - &__exidx_start; } eitp = search_EIT_table (eitp, nrec, return_address); if (!eitp) { UCB_PR_ADDR (ucbp) = 0; return _URC_FAILURE; } ucbp->pr_cache.fnstart = selfrel_offset31 (&eitp->fnoffset); /* Can this frame be unwound at all? */ if (eitp->content == EXIDX_CANTUNWIND) { UCB_PR_ADDR (ucbp) = 0; return _URC_END_OF_STACK; } /* Obtain the address of the "real" __EHT_Header word. */ if (eitp->content & uint32_highbit) { /* It is immediate data. */ ucbp->pr_cache.ehtp = (_Unwind_EHT_Header *)&eitp->content; ucbp->pr_cache.additional = 1; } else { /* The low 31 bits of the content field are a self-relative offset to an _Unwind_EHT_Entry structure. */ ucbp->pr_cache.ehtp = (_Unwind_EHT_Header *) selfrel_offset31 (&eitp->content); ucbp->pr_cache.additional = 0; } /* Discover the personality routine address. */ if (*ucbp->pr_cache.ehtp & (1u << 31)) { /* One of the predefined standard routines. */ _uw idx = (*(_uw *) ucbp->pr_cache.ehtp >> 24) & 0xf; UCB_PR_ADDR (ucbp) = __gnu_unwind_get_pr_addr (idx); if (UCB_PR_ADDR (ucbp) == 0) { /* Failed */ return _URC_FAILURE; } } else { /* Execute region offset to PR */ UCB_PR_ADDR (ucbp) = selfrel_offset31 (ucbp->pr_cache.ehtp); } return _URC_OK; } /* Perform phase2 unwinding. VRS is the initial virtual register state. */ static void __attribute__((noreturn)) unwind_phase2 (_Unwind_Control_Block * ucbp, phase2_vrs * vrs) { _Unwind_Reason_Code pr_result; do { /* Find the entry for this routine. */ if (get_eit_entry (ucbp, VRS_PC(vrs)) != _URC_OK) abort (); UCB_SAVED_CALLSITE_ADDR (ucbp) = VRS_PC(vrs); /* Call the pr to decide what to do. */ pr_result = ((personality_routine) UCB_PR_ADDR (ucbp)) (_US_UNWIND_FRAME_STARTING, ucbp, (_Unwind_Context *) vrs); } while (pr_result == _URC_CONTINUE_UNWIND); if (pr_result != _URC_INSTALL_CONTEXT) abort(); uw_restore_core_regs (vrs, &vrs->core); } /* Perform phase2 forced unwinding. */ static _Unwind_Reason_Code unwind_phase2_forced (_Unwind_Control_Block *ucbp, phase2_vrs *entry_vrs, int resuming) { _Unwind_Stop_Fn stop_fn = (_Unwind_Stop_Fn) UCB_FORCED_STOP_FN (ucbp); void *stop_arg = (void *)UCB_FORCED_STOP_ARG (ucbp); _Unwind_Reason_Code pr_result = 0; /* We use phase1_vrs here even though we do not demand save, for the prev_sp field. */ phase1_vrs saved_vrs, next_vrs; /* Save the core registers. */ saved_vrs.core = entry_vrs->core; /* We don't need to demand-save the non-core registers, because we unwind in a single pass. */ saved_vrs.demand_save_flags = 0; /* Unwind until we reach a propagation barrier. */ do { _Unwind_State action; _Unwind_Reason_Code entry_code; _Unwind_Reason_Code stop_code; /* Find the entry for this routine. */ entry_code = get_eit_entry (ucbp, VRS_PC (&saved_vrs)); if (resuming) { action = _US_UNWIND_FRAME_RESUME | _US_FORCE_UNWIND; resuming = 0; } else action = _US_UNWIND_FRAME_STARTING | _US_FORCE_UNWIND; if (entry_code == _URC_OK) { UCB_SAVED_CALLSITE_ADDR (ucbp) = VRS_PC (&saved_vrs); next_vrs = saved_vrs; /* Call the pr to decide what to do. */ pr_result = ((personality_routine) UCB_PR_ADDR (ucbp)) (action, ucbp, (void *) &next_vrs); saved_vrs.prev_sp = VRS_SP (&next_vrs); } else { /* Treat any failure as the end of unwinding, to cope more gracefully with missing EH information. Mixed EH and non-EH within one object will usually result in failure, because the .ARM.exidx tables do not indicate the end of the code to which they apply; but mixed EH and non-EH shared objects should return an unwind failure at the entry of a non-EH shared object. */ action |= _US_END_OF_STACK; saved_vrs.prev_sp = VRS_SP (&saved_vrs); } stop_code = stop_fn (1, action, ucbp->exception_class, ucbp, (void *)&saved_vrs, stop_arg); if (stop_code != _URC_NO_REASON) return _URC_FAILURE; if (entry_code != _URC_OK) return entry_code; saved_vrs = next_vrs; } while (pr_result == _URC_CONTINUE_UNWIND); if (pr_result != _URC_INSTALL_CONTEXT) { /* Some sort of failure has occurred in the pr and probably the pr returned _URC_FAILURE. */ return _URC_FAILURE; } uw_restore_core_regs (&saved_vrs, &saved_vrs.core); } /* This is a very limited implementation of _Unwind_GetCFA. It returns the stack pointer as it is about to be unwound, and is only valid while calling the stop function during forced unwinding. If the current personality routine result is going to run a cleanup, this will not be the CFA; but when the frame is really unwound, it will be. */ _Unwind_Word _Unwind_GetCFA (_Unwind_Context *context) { return ((phase1_vrs *) context)->prev_sp; } /* Perform phase1 unwinding. UCBP is the exception being thrown, and entry_VRS is the register state on entry to _Unwind_RaiseException. */ _Unwind_Reason_Code __gnu_Unwind_RaiseException (_Unwind_Control_Block *, phase2_vrs *); _Unwind_Reason_Code __gnu_Unwind_RaiseException (_Unwind_Control_Block * ucbp, phase2_vrs * entry_vrs) { phase1_vrs saved_vrs; _Unwind_Reason_Code pr_result; /* Set the pc to the call site. */ VRS_PC (entry_vrs) = VRS_RETURN(entry_vrs); /* Save the core registers. */ saved_vrs.core = entry_vrs->core; /* Set demand-save flags. */ saved_vrs.demand_save_flags = ~(_uw) 0; /* Unwind until we reach a propagation barrier. */ do { /* Find the entry for this routine. */ if (get_eit_entry (ucbp, VRS_PC (&saved_vrs)) != _URC_OK) return _URC_FAILURE; /* Call the pr to decide what to do. */ pr_result = ((personality_routine) UCB_PR_ADDR (ucbp)) (_US_VIRTUAL_UNWIND_FRAME, ucbp, (void *) &saved_vrs); } while (pr_result == _URC_CONTINUE_UNWIND); /* We've unwound as far as we want to go, so restore the original register state. */ restore_non_core_regs (&saved_vrs); if (pr_result != _URC_HANDLER_FOUND) { /* Some sort of failure has occurred in the pr and probably the pr returned _URC_FAILURE. */ return _URC_FAILURE; } unwind_phase2 (ucbp, entry_vrs); } /* Resume unwinding after a cleanup has been run. UCBP is the exception being thrown and ENTRY_VRS is the register state on entry to _Unwind_Resume. */ _Unwind_Reason_Code __gnu_Unwind_ForcedUnwind (_Unwind_Control_Block *, _Unwind_Stop_Fn, void *, phase2_vrs *); _Unwind_Reason_Code __gnu_Unwind_ForcedUnwind (_Unwind_Control_Block *ucbp, _Unwind_Stop_Fn stop_fn, void *stop_arg, phase2_vrs *entry_vrs) { UCB_FORCED_STOP_FN (ucbp) = (_uw) stop_fn; UCB_FORCED_STOP_ARG (ucbp) = (_uw) stop_arg; /* Set the pc to the call site. */ VRS_PC (entry_vrs) = VRS_RETURN(entry_vrs); return unwind_phase2_forced (ucbp, entry_vrs, 0); } _Unwind_Reason_Code __gnu_Unwind_Resume (_Unwind_Control_Block *, phase2_vrs *); _Unwind_Reason_Code __gnu_Unwind_Resume (_Unwind_Control_Block * ucbp, phase2_vrs * entry_vrs) { _Unwind_Reason_Code pr_result; /* Recover the saved address. */ VRS_PC (entry_vrs) = UCB_SAVED_CALLSITE_ADDR (ucbp); if (UCB_FORCED_STOP_FN (ucbp)) { unwind_phase2_forced (ucbp, entry_vrs, 1); /* We can't return failure at this point. */ abort (); } /* Call the cached PR. */ pr_result = ((personality_routine) UCB_PR_ADDR (ucbp)) (_US_UNWIND_FRAME_RESUME, ucbp, (_Unwind_Context *) entry_vrs); switch (pr_result) { case _URC_INSTALL_CONTEXT: /* Upload the registers to enter the landing pad. */ uw_restore_core_regs (entry_vrs, &entry_vrs->core); case _URC_CONTINUE_UNWIND: /* Continue unwinding the next frame. */ unwind_phase2 (ucbp, entry_vrs); default: abort (); } } _Unwind_Reason_Code __gnu_Unwind_Resume_or_Rethrow (_Unwind_Control_Block *, phase2_vrs *); _Unwind_Reason_Code __gnu_Unwind_Resume_or_Rethrow (_Unwind_Control_Block * ucbp, phase2_vrs * entry_vrs) { if (!UCB_FORCED_STOP_FN (ucbp)) return __gnu_Unwind_RaiseException (ucbp, entry_vrs); /* Set the pc to the call site. */ VRS_PC (entry_vrs) = VRS_RETURN (entry_vrs); /* Continue unwinding the next frame. */ return unwind_phase2_forced (ucbp, entry_vrs, 0); } /* Clean up an exception object when unwinding is complete. */ void _Unwind_Complete (_Unwind_Control_Block * ucbp __attribute__((unused))) { } /* Free an exception. */ void _Unwind_DeleteException (_Unwind_Exception * exc) { if (exc->exception_cleanup) (*exc->exception_cleanup) (_URC_FOREIGN_EXCEPTION_CAUGHT, exc); } /* Perform stack backtrace through unwind data. */ _Unwind_Reason_Code __gnu_Unwind_Backtrace(_Unwind_Trace_Fn trace, void * trace_argument, phase2_vrs * entry_vrs); _Unwind_Reason_Code __gnu_Unwind_Backtrace(_Unwind_Trace_Fn trace, void * trace_argument, phase2_vrs * entry_vrs) { phase1_vrs saved_vrs; _Unwind_Reason_Code code; _Unwind_Control_Block ucb; _Unwind_Control_Block *ucbp = &ucb; /* Set the pc to the call site. */ VRS_PC (entry_vrs) = VRS_RETURN (entry_vrs); /* Save the core registers. */ saved_vrs.core = entry_vrs->core; /* Set demand-save flags. */ saved_vrs.demand_save_flags = ~(_uw) 0; do { /* Find the entry for this routine. */ if (get_eit_entry (ucbp, VRS_PC (&saved_vrs)) != _URC_OK) { code = _URC_FAILURE; break; } /* The dwarf unwinder assumes the context structure holds things like the function and LSDA pointers. The ARM implementation caches these in the exception header (UCB). To avoid rewriting everything we make the virtual IP register point at the UCB. */ _Unwind_SetGR((_Unwind_Context *)&saved_vrs, UNWIND_POINTER_REG, (_Unwind_Ptr) ucbp); /* Call trace function. */ if ((*trace) ((_Unwind_Context *) &saved_vrs, trace_argument) != _URC_NO_REASON) { code = _URC_FAILURE; break; } /* Call the pr to decide what to do. */ code = ((personality_routine) UCB_PR_ADDR (ucbp)) (_US_VIRTUAL_UNWIND_FRAME | _US_FORCE_UNWIND, ucbp, (void *) &saved_vrs); } while (code != _URC_END_OF_STACK && code != _URC_FAILURE); restore_non_core_regs (&saved_vrs); return code; } /* Common implementation for ARM ABI defined personality routines. ID is the index of the personality routine, other arguments are as defined by __aeabi_unwind_cpp_pr{0,1,2}. */ static _Unwind_Reason_Code __gnu_unwind_pr_common (_Unwind_State state, _Unwind_Control_Block *ucbp, _Unwind_Context *context, int id) { __gnu_unwind_state uws; _uw *data; _uw offset; _uw len; _uw rtti_count; int phase2_call_unexpected_after_unwind = 0; int in_range = 0; int forced_unwind = state & _US_FORCE_UNWIND; state &= _US_ACTION_MASK; data = (_uw *) ucbp->pr_cache.ehtp; uws.data = *(data++); uws.next = data; if (id == 0) { uws.data <<= 8; uws.words_left = 0; uws.bytes_left = 3; } else if (id < 3) { uws.words_left = (uws.data >> 16) & 0xff; uws.data <<= 16; uws.bytes_left = 2; data += uws.words_left; } /* Restore the saved pointer. */ if (state == _US_UNWIND_FRAME_RESUME) data = (_uw *) ucbp->cleanup_cache.bitpattern[0]; if ((ucbp->pr_cache.additional & 1) == 0) { /* Process descriptors. */ while (*data) { _uw addr; _uw fnstart; if (id == 2) { len = ((EHT32 *) data)->length; offset = ((EHT32 *) data)->offset; data += 2; } else { len = ((EHT16 *) data)->length; offset = ((EHT16 *) data)->offset; data++; } fnstart = ucbp->pr_cache.fnstart + (offset & ~1); addr = _Unwind_GetGR (context, R_PC); in_range = (fnstart <= addr && addr < fnstart + (len & ~1)); switch (((offset & 1) << 1) | (len & 1)) { case 0: /* Cleanup. */ if (state != _US_VIRTUAL_UNWIND_FRAME && in_range) { /* Cleanup in range, and we are running cleanups. */ _uw lp; /* Landing pad address is 31-bit pc-relative offset. */ lp = selfrel_offset31 (data); data++; /* Save the exception data pointer. */ ucbp->cleanup_cache.bitpattern[0] = (_uw) data; if (!__cxa_begin_cleanup (ucbp)) return _URC_FAILURE; /* Setup the VRS to enter the landing pad. */ _Unwind_SetGR (context, R_PC, lp); return _URC_INSTALL_CONTEXT; } /* Cleanup not in range, or we are in stage 1. */ data++; break; case 1: /* Catch handler. */ if (state == _US_VIRTUAL_UNWIND_FRAME) { if (in_range) { /* Check for a barrier. */ _uw rtti; bool is_reference = (data[0] & uint32_highbit) != 0; void *matched; enum __cxa_type_match_result match_type; /* Check for no-throw areas. */ if (data[1] == (_uw) -2) return _URC_FAILURE; /* The thrown object immediately follows the ECB. */ matched = (void *)(ucbp + 1); if (data[1] != (_uw) -1) { /* Match a catch specification. */ rtti = _Unwind_decode_typeinfo_ptr (0, (_uw) &data[1]); match_type = __cxa_type_match (ucbp, (type_info *) rtti, is_reference, &matched); } else match_type = ctm_succeeded; if (match_type) { ucbp->barrier_cache.sp = _Unwind_GetGR (context, R_SP); // ctm_succeeded_with_ptr_to_base really // means _c_t_m indirected the pointer // object. We have to reconstruct the // additional pointer layer by using a temporary. if (match_type == ctm_succeeded_with_ptr_to_base) { ucbp->barrier_cache.bitpattern[2] = (_uw) matched; ucbp->barrier_cache.bitpattern[0] = (_uw) &ucbp->barrier_cache.bitpattern[2]; } else ucbp->barrier_cache.bitpattern[0] = (_uw) matched; ucbp->barrier_cache.bitpattern[1] = (_uw) data; return _URC_HANDLER_FOUND; } } /* Handler out of range, or not matched. */ } else if (ucbp->barrier_cache.sp == _Unwind_GetGR (context, R_SP) && ucbp->barrier_cache.bitpattern[1] == (_uw) data) { /* Matched a previous propagation barrier. */ _uw lp; /* Setup for entry to the handler. */ lp = selfrel_offset31 (data); _Unwind_SetGR (context, R_PC, lp); _Unwind_SetGR (context, 0, (_uw) ucbp); return _URC_INSTALL_CONTEXT; } /* Catch handler not matched. Advance to the next descriptor. */ data += 2; break; case 2: rtti_count = data[0] & 0x7fffffff; /* Exception specification. */ if (state == _US_VIRTUAL_UNWIND_FRAME) { if (in_range && (!forced_unwind || !rtti_count)) { /* Match against the exception specification. */ _uw i; _uw rtti; void *matched; for (i = 0; i < rtti_count; i++) { matched = (void *)(ucbp + 1); rtti = _Unwind_decode_typeinfo_ptr (0, (_uw) &data[i + 1]); if (__cxa_type_match (ucbp, (type_info *) rtti, 0, &matched)) break; } if (i == rtti_count) { /* Exception does not match the spec. */ ucbp->barrier_cache.sp = _Unwind_GetGR (context, R_SP); ucbp->barrier_cache.bitpattern[0] = (_uw) matched; ucbp->barrier_cache.bitpattern[1] = (_uw) data; return _URC_HANDLER_FOUND; } } /* Handler out of range, or exception is permitted. */ } else if (ucbp->barrier_cache.sp == _Unwind_GetGR (context, R_SP) && ucbp->barrier_cache.bitpattern[1] == (_uw) data) { /* Matched a previous propagation barrier. */ _uw lp; /* Record the RTTI list for __cxa_call_unexpected. */ ucbp->barrier_cache.bitpattern[1] = rtti_count; ucbp->barrier_cache.bitpattern[2] = 0; ucbp->barrier_cache.bitpattern[3] = 4; ucbp->barrier_cache.bitpattern[4] = (_uw) &data[1]; if (data[0] & uint32_highbit) { data += rtti_count + 1; /* Setup for entry to the handler. */ lp = selfrel_offset31 (data); data++; _Unwind_SetGR (context, R_PC, lp); _Unwind_SetGR (context, 0, (_uw) ucbp); return _URC_INSTALL_CONTEXT; } else phase2_call_unexpected_after_unwind = 1; } if (data[0] & uint32_highbit) data++; data += rtti_count + 1; break; default: /* Should never happen. */ return _URC_FAILURE; } /* Finished processing this descriptor. */ } } if (id >= 3) { /* 24-bit ecoding */ if (__gnu_unwind_24bit (context, uws.data, id == 4) != _URC_OK) return _URC_FAILURE; } else { if (__gnu_unwind_execute (context, &uws) != _URC_OK) return _URC_FAILURE; } if (phase2_call_unexpected_after_unwind) { /* Enter __cxa_unexpected as if called from the call site. */ _Unwind_SetGR (context, R_LR, _Unwind_GetGR (context, R_PC)); _Unwind_SetGR (context, R_PC, (_uw) &__cxa_call_unexpected); return _URC_INSTALL_CONTEXT; } return _URC_CONTINUE_UNWIND; } @