Index: head/contrib/gcc/config/arm/unwind-arm.h =================================================================== --- head/contrib/gcc/config/arm/unwind-arm.h (revision 246313) +++ head/contrib/gcc/config/arm/unwind-arm.h (revision 246314) @@ -1,271 +1,271 @@ /* Header file for the ARM EABI unwinder Copyright (C) 2003, 2004, 2005, 2006 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 2, or (at your option) any later version. In addition to the permissions in the GNU General Public License, the Free Software Foundation gives you unlimited permission to link the compiled version of this file into combinations with other programs, and to distribute those combinations without any restriction coming from the use of this file. (The General Public License restrictions do apply in other respects; for example, they cover modification of the file, and distribution when not linked into a combine executable.) 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. You should have received a copy of the GNU General Public License along with this program; see the file COPYING. If not, write to the Free Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ /* Language-independent unwinder header public defines. This contains both ABI defined objects, and GNU support routines. */ #ifndef UNWIND_ARM_H #define UNWIND_ARM_H #define __ARM_EABI_UNWINDER__ 1 #ifdef __cplusplus extern "C" { #endif typedef unsigned _Unwind_Word __attribute__((__mode__(__word__))); typedef signed _Unwind_Sword __attribute__((__mode__(__word__))); typedef unsigned _Unwind_Ptr __attribute__((__mode__(__pointer__))); typedef unsigned _Unwind_Internal_Ptr __attribute__((__mode__(__pointer__))); typedef _Unwind_Word _uw; typedef unsigned _uw64 __attribute__((mode(__DI__))); typedef unsigned _uw16 __attribute__((mode(__HI__))); typedef unsigned _uw8 __attribute__((mode(__QI__))); typedef enum { _URC_OK = 0, /* operation completed successfully */ _URC_FOREIGN_EXCEPTION_CAUGHT = 1, _URC_END_OF_STACK = 5, _URC_HANDLER_FOUND = 6, _URC_INSTALL_CONTEXT = 7, _URC_CONTINUE_UNWIND = 8, _URC_FAILURE = 9 /* unspecified failure of some kind */ } _Unwind_Reason_Code; typedef enum { _US_VIRTUAL_UNWIND_FRAME = 0, _US_UNWIND_FRAME_STARTING = 1, _US_UNWIND_FRAME_RESUME = 2, _US_ACTION_MASK = 3, _US_FORCE_UNWIND = 8, _US_END_OF_STACK = 16 } _Unwind_State; /* Provided only for for compatibility with existing code. */ typedef int _Unwind_Action; #define _UA_SEARCH_PHASE 1 #define _UA_CLEANUP_PHASE 2 #define _UA_HANDLER_FRAME 4 #define _UA_FORCE_UNWIND 8 #define _UA_END_OF_STACK 16 #define _URC_NO_REASON _URC_OK typedef struct _Unwind_Control_Block _Unwind_Control_Block; typedef struct _Unwind_Context _Unwind_Context; typedef _uw _Unwind_EHT_Header; /* UCB: */ struct _Unwind_Control_Block { - char exception_class[8]; + unsigned exception_class __attribute__((__mode__(__DI__))); void (*exception_cleanup)(_Unwind_Reason_Code, _Unwind_Control_Block *); /* Unwinder cache, private fields for the unwinder's use */ struct { _uw reserved1; /* Forced unwind stop fn, 0 if not forced */ _uw reserved2; /* Personality routine address */ _uw reserved3; /* Saved callsite address */ _uw reserved4; /* Forced unwind stop arg */ _uw reserved5; } unwinder_cache; /* Propagation barrier cache (valid after phase 1): */ struct { _uw sp; _uw bitpattern[5]; } barrier_cache; /* Cleanup cache (preserved over cleanup): */ struct { _uw bitpattern[4]; } cleanup_cache; /* Pr cache (for pr's benefit): */ struct { _uw fnstart; /* function start address */ _Unwind_EHT_Header *ehtp; /* pointer to EHT entry header word */ _uw additional; /* additional data */ _uw reserved1; } pr_cache; long long int :0; /* Force alignment to 8-byte boundary */ }; /* Virtual Register Set*/ typedef enum { _UVRSC_CORE = 0, /* integer register */ _UVRSC_VFP = 1, /* vfp */ _UVRSC_FPA = 2, /* fpa */ _UVRSC_WMMXD = 3, /* Intel WMMX data register */ _UVRSC_WMMXC = 4 /* Intel WMMX control register */ } _Unwind_VRS_RegClass; typedef enum { _UVRSD_UINT32 = 0, _UVRSD_VFPX = 1, _UVRSD_FPAX = 2, _UVRSD_UINT64 = 3, _UVRSD_FLOAT = 4, _UVRSD_DOUBLE = 5 } _Unwind_VRS_DataRepresentation; typedef enum { _UVRSR_OK = 0, _UVRSR_NOT_IMPLEMENTED = 1, _UVRSR_FAILED = 2 } _Unwind_VRS_Result; /* Frame unwinding state. */ typedef struct { /* The current word (bytes packed msb first). */ _uw data; /* Pointer to the next word of data. */ _uw *next; /* The number of bytes left in this word. */ _uw8 bytes_left; /* The number of words pointed to by ptr. */ _uw8 words_left; } __gnu_unwind_state; typedef _Unwind_Reason_Code (*personality_routine) (_Unwind_State, _Unwind_Control_Block *, _Unwind_Context *); _Unwind_VRS_Result _Unwind_VRS_Set(_Unwind_Context *, _Unwind_VRS_RegClass, _uw, _Unwind_VRS_DataRepresentation, void *); _Unwind_VRS_Result _Unwind_VRS_Get(_Unwind_Context *, _Unwind_VRS_RegClass, _uw, _Unwind_VRS_DataRepresentation, void *); _Unwind_VRS_Result _Unwind_VRS_Pop(_Unwind_Context *, _Unwind_VRS_RegClass, _uw, _Unwind_VRS_DataRepresentation); /* Support functions for the PR. */ #define _Unwind_Exception _Unwind_Control_Block - typedef char _Unwind_Exception_Class[8]; + typedef unsigned _Unwind_Exception_Class __attribute__((__mode__(__DI__))); void * _Unwind_GetLanguageSpecificData (_Unwind_Context *); _Unwind_Ptr _Unwind_GetRegionStart (_Unwind_Context *); /* These two should never be used. */ _Unwind_Ptr _Unwind_GetDataRelBase (_Unwind_Context *); _Unwind_Ptr _Unwind_GetTextRelBase (_Unwind_Context *); /* Interface functions: */ _Unwind_Reason_Code _Unwind_RaiseException(_Unwind_Control_Block *ucbp); void __attribute__((noreturn)) _Unwind_Resume(_Unwind_Control_Block *ucbp); _Unwind_Reason_Code _Unwind_Resume_or_Rethrow (_Unwind_Control_Block *ucbp); typedef _Unwind_Reason_Code (*_Unwind_Stop_Fn) (int, _Unwind_Action, _Unwind_Exception_Class, _Unwind_Control_Block *, struct _Unwind_Context *, void *); _Unwind_Reason_Code _Unwind_ForcedUnwind (_Unwind_Control_Block *, _Unwind_Stop_Fn, void *); _Unwind_Word _Unwind_GetCFA (struct _Unwind_Context *); void _Unwind_Complete(_Unwind_Control_Block *ucbp); void _Unwind_DeleteException (_Unwind_Exception *); _Unwind_Reason_Code __gnu_unwind_frame (_Unwind_Control_Block *, _Unwind_Context *); _Unwind_Reason_Code __gnu_unwind_execute (_Unwind_Context *, __gnu_unwind_state *); /* Decode an R_ARM_TARGET2 relocation. */ static inline _Unwind_Word _Unwind_decode_target2 (_Unwind_Word ptr) { _Unwind_Word tmp; tmp = *(_Unwind_Word *) ptr; /* Zero values are always NULL. */ if (!tmp) return 0; #if defined(linux) || defined(__NetBSD__) /* Pc-relative indirect. */ tmp += ptr; tmp = *(_Unwind_Word *) tmp; #elif defined(__symbian__) /* Absolute pointer. Nothing more to do. */ #else /* Pc-relative pointer. */ tmp += ptr; #endif return tmp; } static inline _Unwind_Word _Unwind_GetGR (_Unwind_Context *context, int regno) { _uw val; _Unwind_VRS_Get (context, _UVRSC_CORE, regno, _UVRSD_UINT32, &val); return val; } /* Return the address of the instruction, not the actual IP value. */ #define _Unwind_GetIP(context) \ (_Unwind_GetGR (context, 15) & ~(_Unwind_Word)1) #define _Unwind_GetIPInfo(context, ip_before_insn) \ (*ip_before_insn = 0, _Unwind_GetGR (context, 15) & ~(_Unwind_Word)1) static inline void _Unwind_SetGR (_Unwind_Context *context, int regno, _Unwind_Word val) { _Unwind_VRS_Set (context, _UVRSC_CORE, regno, _UVRSD_UINT32, &val); } /* The dwarf unwinder doesn't understand arm/thumb state. We assume the landing pad uses the same instruction set as the call site. */ #define _Unwind_SetIP(context, val) \ _Unwind_SetGR (context, 15, val | (_Unwind_GetGR (context, 15) & 1)) #ifdef __cplusplus } /* extern "C" */ #endif #endif /* defined UNWIND_ARM_H */ Index: head/contrib/libstdc++/libsupc++/unwind-cxx.h =================================================================== --- head/contrib/libstdc++/libsupc++/unwind-cxx.h (revision 246313) +++ head/contrib/libstdc++/libsupc++/unwind-cxx.h (revision 246314) @@ -1,251 +1,253 @@ // -*- C++ -*- Exception handling and frame unwind runtime interface routines. // Copyright (C) 2001 Free Software Foundation, Inc. // // This file is part of GCC. // // GCC 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 2, or (at your option) // any later version. // // GCC 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. // // You should have received a copy of the GNU General Public License // along with GCC; see the file COPYING. If not, write to // the Free Software Foundation, 51 Franklin Street, Fifth Floor, // Boston, MA 02110-1301, USA. // As a special exception, you may use this file as part of a free software // library without restriction. Specifically, if other files instantiate // templates or use macros or inline functions from this file, or you compile // this file and link it with other files to produce an executable, this // file does not by itself cause the resulting executable to be covered by // the GNU General Public License. This exception does not however // invalidate any other reasons why the executable file might be covered by // the GNU General Public License. // This is derived from the C++ ABI for IA-64. Where we diverge // for cross-architecture compatibility are noted with "@@@". #ifndef _UNWIND_CXX_H #define _UNWIND_CXX_H 1 // Level 2: C++ ABI #include #include #include #include "unwind.h" #pragma GCC visibility push(default) namespace __cxxabiv1 { // A C++ exception object consists of a header, which is a wrapper around // an unwind object header with additional C++ specific information, // followed by the exception object itself. struct __cxa_exception { // Manage the exception object itself. std::type_info *exceptionType; void (*exceptionDestructor)(void *); // The C++ standard has entertaining rules wrt calling set_terminate // and set_unexpected in the middle of the exception cleanup process. std::unexpected_handler unexpectedHandler; std::terminate_handler terminateHandler; // The caught exception stack threads through here. __cxa_exception *nextException; // How many nested handlers have caught this exception. A negated // value is a signal that this object has been rethrown. int handlerCount; #ifdef __ARM_EABI_UNWINDER__ // Stack of exceptions in cleanups. __cxa_exception* nextPropagatingException; // The nuber of active cleanup handlers for this exception. int propagationCount; #else // Cache parsed handler data from the personality routine Phase 1 // for Phase 2 and __cxa_call_unexpected. int handlerSwitchValue; const unsigned char *actionRecord; const unsigned char *languageSpecificData; _Unwind_Ptr catchTemp; void *adjustedPtr; #endif // The generic exception header. Must be last. _Unwind_Exception unwindHeader; }; // Each thread in a C++ program has access to a __cxa_eh_globals object. struct __cxa_eh_globals { __cxa_exception *caughtExceptions; unsigned int uncaughtExceptions; #ifdef __ARM_EABI_UNWINDER__ __cxa_exception* propagatingExceptions; #endif }; // The __cxa_eh_globals for the current thread can be obtained by using // either of the following functions. The "fast" version assumes at least // one prior call of __cxa_get_globals has been made from the current // thread, so no initialization is necessary. extern "C" __cxa_eh_globals *__cxa_get_globals () throw(); extern "C" __cxa_eh_globals *__cxa_get_globals_fast () throw(); // Allocate memory for the exception plus the thown object. extern "C" void *__cxa_allocate_exception(std::size_t thrown_size) throw(); // Free the space allocated for the exception. extern "C" void __cxa_free_exception(void *thrown_exception) throw(); // Throw the exception. extern "C" void __cxa_throw (void *thrown_exception, std::type_info *tinfo, void (*dest) (void *)) __attribute__((noreturn)); // Used to implement exception handlers. extern "C" void *__cxa_get_exception_ptr (void *) throw(); extern "C" void *__cxa_begin_catch (void *) throw(); extern "C" void __cxa_end_catch (); extern "C" void __cxa_rethrow () __attribute__((noreturn)); // These facilitate code generation for recurring situations. extern "C" void __cxa_bad_cast (); extern "C" void __cxa_bad_typeid (); // @@@ These are not directly specified by the IA-64 C++ ABI. // Handles re-checking the exception specification if unexpectedHandler // throws, and if bad_exception needs to be thrown. Called from the // compiler. extern "C" void __cxa_call_unexpected (void *) __attribute__((noreturn)); extern "C" void __cxa_call_terminate (void*) __attribute__((noreturn)); #ifdef __ARM_EABI_UNWINDER__ // Arm EABI specified routines. typedef enum { ctm_failed = 0, ctm_succeeded = 1, ctm_succeeded_with_ptr_to_base = 2 } __cxa_type_match_result; extern "C" bool __cxa_type_match(_Unwind_Exception*, const std::type_info*, bool, void**); extern "C" void __cxa_begin_cleanup (_Unwind_Exception*); extern "C" void __cxa_end_cleanup (void); #endif // Invokes given handler, dying appropriately if the user handler was // so inconsiderate as to return. extern void __terminate(std::terminate_handler) __attribute__((noreturn)); extern void __unexpected(std::unexpected_handler) __attribute__((noreturn)); // The current installed user handlers. extern std::terminate_handler __terminate_handler; extern std::unexpected_handler __unexpected_handler; // These are explicitly GNU C++ specific. // Acquire the C++ exception header from the C++ object. static inline __cxa_exception * __get_exception_header_from_obj (void *ptr) { return reinterpret_cast<__cxa_exception *>(ptr) - 1; } // Acquire the C++ exception header from the generic exception header. static inline __cxa_exception * __get_exception_header_from_ue (_Unwind_Exception *exc) { return reinterpret_cast<__cxa_exception *>(exc + 1) - 1; } -#ifdef __ARM_EABI_UNWINDER__ +#if defined(__ARM_EABI_UNWINDER__) && !defined(__FreeBSD__) static inline bool __is_gxx_exception_class(_Unwind_Exception_Class c) { // TODO: Take advantage of the fact that c will always be word aligned. return c[0] == 'G' && c[1] == 'N' && c[2] == 'U' && c[3] == 'C' && c[4] == 'C' && c[5] == '+' && c[6] == '+' && c[7] == '\0'; } static inline void __GXX_INIT_EXCEPTION_CLASS(_Unwind_Exception_Class c) { c[0] = 'G'; c[1] = 'N'; c[2] = 'U'; c[3] = 'C'; c[4] = 'C'; c[5] = '+'; c[6] = '+'; c[7] = '\0'; } - -static inline void* -__gxx_caught_object(_Unwind_Exception* eo) -{ - return (void*)eo->barrier_cache.bitpattern[0]; -} -#else // !__ARM_EABI_UNWINDER__ +#else // !__ARM_EABI_UNWINDER__ || __FreeBSD__ // This is the exception class we report -- "GNUCC++\0". const _Unwind_Exception_Class __gxx_exception_class = ((((((((_Unwind_Exception_Class) 'G' << 8 | (_Unwind_Exception_Class) 'N') << 8 | (_Unwind_Exception_Class) 'U') << 8 | (_Unwind_Exception_Class) 'C') << 8 | (_Unwind_Exception_Class) 'C') << 8 | (_Unwind_Exception_Class) '+') << 8 | (_Unwind_Exception_Class) '+') << 8 | (_Unwind_Exception_Class) '\0'); static inline bool __is_gxx_exception_class(_Unwind_Exception_Class c) { return c == __gxx_exception_class; } - #define __GXX_INIT_EXCEPTION_CLASS(c) c = __gxx_exception_class +#endif + +#ifdef __ARM_EABI_UNWINDER__ +static inline void* +__gxx_caught_object(_Unwind_Exception* eo) +{ + return (void*)eo->barrier_cache.bitpattern[0]; +} +#else // !__ARM_EABI_UNWINDER__ // GNU C++ personality routine, Version 0. extern "C" _Unwind_Reason_Code __gxx_personality_v0 (int, _Unwind_Action, _Unwind_Exception_Class, struct _Unwind_Exception *, struct _Unwind_Context *); // GNU C++ sjlj personality routine, Version 0. extern "C" _Unwind_Reason_Code __gxx_personality_sj0 (int, _Unwind_Action, _Unwind_Exception_Class, struct _Unwind_Exception *, struct _Unwind_Context *); static inline void* __gxx_caught_object(_Unwind_Exception* eo) { __cxa_exception* header = __get_exception_header_from_ue (eo); return header->adjustedPtr; } #endif // !__ARM_EABI_UNWINDER__ } /* namespace __cxxabiv1 */ #pragma GCC visibility pop #endif // _UNWIND_CXX_H