From afcf7ac5f63e08355f6afa217b2d88421cfd554a Mon Sep 17 00:00:00 2001 From: Howard Hinnant Date: Sun, 22 Jan 2012 19:14:27 +0000 Subject: I kept getting confused among the __cxa_exception*, the _Unwind_Exception* and the void* to the thrown object. So I've gone through these two files and attempted to institute a consistent variable naming scheme, and in a few instances, turned void* into a concrete* to have the type system help me out. No change in functionality for this commit is intended. llvm-svn: 148663 --- libcxxabi/src/cxa_exception.cpp | 307 ++++++++++++++++++++++---------------- libcxxabi/src/cxa_personality.cpp | 67 +++++---- 2 files changed, 216 insertions(+), 158 deletions(-) (limited to 'libcxxabi') diff --git a/libcxxabi/src/cxa_exception.cpp b/libcxxabi/src/cxa_exception.cpp index ff2afc3852e0..96868f5aff2d 100644 --- a/libcxxabi/src/cxa_exception.cpp +++ b/libcxxabi/src/cxa_exception.cpp @@ -21,48 +21,76 @@ #include "cxa_exception.hpp" #include "cxa_handlers.hpp" +// +---------------------------+-----------------------------+---------------+ +// | __cxa_exception | _Unwind_Exception CLNGC++\0 | thrown object | +// +---------------------------+-----------------------------+---------------+ +// ^ +// | +// +-------------------------------------------------------+ +// | +// +---------------------------+-----------------------------+ +// | __cxa_dependent_exception | _Unwind_Exception CLNGC++\1 | +// +---------------------------+-----------------------------+ + + namespace __cxxabiv1 { static const uint64_t kOurExceptionClass = 0x434C4E47432B2B00; // CLNGC++\0 static const uint64_t kOurDependentExceptionClass = 0x434C4E47432B2B01; // CLNGC++\1 // Utility routines -static inline __cxa_exception *exception_from_thrown_object(void *p) throw() { - return ((__cxa_exception *) p) - 1; -} - -static inline void * thrown_object_from_exception(void *p) throw() { - return (void *) (((__cxa_exception *) p) + 1 ); +static +inline +__cxa_exception* +cxa_exception_from_thrown_object(void* thrown_object) throw() +{ + return static_cast<__cxa_exception*>(thrown_object) - 1; } -static inline size_t object_size_from_exception_size(size_t size) throw() { - return size + sizeof (__cxa_exception); +// Note: This is never called when exception_header is masquerading as a +// __cxa_dependent_exception. +static +inline +void* +thrown_object_from_cxa_exception(__cxa_exception* exception_header) throw() +{ + return static_cast(exception_header + 1); } // Get the exception object from the unwind pointer. // Relies on the structure layout, where the unwind pointer is right in // front of the user's exception object -static __cxa_exception * -exception_from_exception_object(void *ptr) throw() { - _Unwind_Exception *p = reinterpret_cast<_Unwind_Exception *>(ptr); - return exception_from_thrown_object(p + 1 ); +static +inline +__cxa_exception* +cxa_exception_from_exception_unwind_exception(_Unwind_Exception* unwind_exception) throw() +{ + return cxa_exception_from_thrown_object(unwind_exception + 1 ); } -static void setExceptionClass(_Unwind_Exception *unwind) throw() { - unwind->exception_class = kOurExceptionClass; +static +inline +size_t +cxa_exception_size_from_exception_thrown_size(size_t size) throw() +{ + return size + sizeof (__cxa_exception); +} + +static void setExceptionClass(_Unwind_Exception* unwind_exception) throw() { + unwind_exception->exception_class = kOurExceptionClass; } -static void setDependentExceptionClass(_Unwind_Exception *unwind) throw() { - unwind->exception_class = kOurDependentExceptionClass; +static void setDependentExceptionClass(_Unwind_Exception* unwind_exception) throw() { + unwind_exception->exception_class = kOurDependentExceptionClass; } // Is it one of ours? -static bool isOurExceptionClass(_Unwind_Exception *unwind) throw() { - return(unwind->exception_class == kOurExceptionClass)|| - (unwind->exception_class == kOurDependentExceptionClass); +static bool isOurExceptionClass(_Unwind_Exception* unwind_exception) throw() { + return(unwind_exception->exception_class == kOurExceptionClass)|| + (unwind_exception->exception_class == kOurDependentExceptionClass); } -static bool isDependentException(_Unwind_Exception *unwind) throw() { - return (unwind->exception_class & 0xFF) == 0x01; +static bool isDependentException(_Unwind_Exception* unwind_exception) throw() { + return (unwind_exception->exception_class & 0xFF) == 0x01; } // This does not need to be atomic @@ -85,29 +113,32 @@ static void *do_malloc(size_t size) throw() { return ptr; } -// Didn't know you could "return " from a void function, did you? -// Well, you can, if the type of the expression is "void" also. static void do_free(void *ptr) throw() { - return is_fallback_ptr(ptr) ? fallback_free(ptr) : std::free(ptr); + is_fallback_ptr(ptr) ? fallback_free(ptr) : std::free(ptr); } /* If reason isn't _URC_FOREIGN_EXCEPTION_CAUGHT, then the terminateHandler stored in exc is called. Otherwise the exceptionDestructor stored in exc is called, and then the memory for the exception is deallocated. + + This is never called for a __cxa_dependent_exception. */ -static void exception_cleanup_func(_Unwind_Reason_Code reason, struct _Unwind_Exception* exc) { - __cxa_exception *exception = exception_from_exception_object(exc); +static +void +exception_cleanup_func(_Unwind_Reason_Code reason, _Unwind_Exception* unwind_exception) +{ + __cxa_exception* exception_header = cxa_exception_from_exception_unwind_exception(unwind_exception); if (_URC_FOREIGN_EXCEPTION_CAUGHT != reason) - std::__terminate(exception->terminateHandler); - - void * thrown_object = thrown_object_from_exception(exception); - if (NULL != exception->exceptionDestructor) - exception->exceptionDestructor(thrown_object); + std::__terminate(exception_header->terminateHandler); + + void * thrown_object = thrown_object_from_cxa_exception(exception_header); + if (NULL != exception_header->exceptionDestructor) + exception_header->exceptionDestructor(thrown_object); __cxa_free_exception(thrown_object); } -static LIBCXXABI_NORETURN void failed_throw(__cxa_exception *exception) throw() { +static LIBCXXABI_NORETURN void failed_throw(__cxa_exception* exception_header) throw() { // Section 2.5.3 says: // * For purposes of this ABI, several things are considered exception handlers: // ** A terminate() call due to a throw. @@ -115,8 +146,8 @@ static LIBCXXABI_NORETURN void failed_throw(__cxa_exception *exception) throw() // * Upon entry, Following initialization of the catch parameter, // a handler must call: // * void *__cxa_begin_catch(void *exceptionObject ); - (void) __cxa_begin_catch(&exception->unwindHeader); - std::__terminate(exception->terminateHandler); + (void) __cxa_begin_catch(&exception_header->unwindHeader); + std::__terminate(exception_header->terminateHandler); } extern "C" { @@ -127,18 +158,18 @@ extern "C" { // std::terminate. Return a pointer to the memory to be used for the // user's exception object. void * __cxa_allocate_exception (size_t thrown_size) throw() { - size_t actual_size = object_size_from_exception_size(thrown_size); - void *ptr = do_malloc(actual_size); - if (NULL == ptr) + size_t actual_size = cxa_exception_size_from_exception_thrown_size(thrown_size); + __cxa_exception* exception_header = static_cast<__cxa_exception*>(do_malloc(actual_size)); + if (NULL == exception_header) std::terminate(); - std::memset(ptr, 0, actual_size); - return thrown_object_from_exception(ptr); + std::memset(exception_header, 0, actual_size); + return thrown_object_from_cxa_exception(exception_header); } // Free a __cxa_exception object allocated with __cxa_allocate_exception. -void __cxa_free_exception (void * thrown_exception) throw() { - do_free(exception_from_thrown_object(thrown_exception)); +void __cxa_free_exception (void * thrown_object) throw() { + do_free(cxa_exception_from_thrown_object(thrown_object)); } @@ -188,34 +219,45 @@ handler, _Unwind_RaiseException may return. In that case, __cxa_throw will call terminate, assuming that there was no handler for the exception. */ -LIBCXXABI_NORETURN void -__cxa_throw(void * thrown_exception, std::type_info * tinfo, void (*dest)(void *)) { +LIBCXXABI_NORETURN +void +__cxa_throw(void* thrown_object, std::type_info* tinfo, void (*dest)(void*)) +{ __cxa_eh_globals *globals = __cxa_get_globals(); - __cxa_exception *exception = exception_from_thrown_object(thrown_exception); - - exception->unexpectedHandler = std::get_unexpected(); - exception->terminateHandler = std::get_terminate(); - exception->exceptionType = tinfo; - exception->exceptionDestructor = dest; - setExceptionClass(&exception->unwindHeader); - exception->referenceCount = 1; // This is a newly allocated exception, no need for thread safety. + __cxa_exception* exception_header = cxa_exception_from_thrown_object(thrown_object); + + exception_header->unexpectedHandler = std::get_unexpected(); + exception_header->terminateHandler = std::get_terminate(); + exception_header->exceptionType = tinfo; + exception_header->exceptionDestructor = dest; + setExceptionClass(&exception_header->unwindHeader); + exception_header->referenceCount = 1; // This is a newly allocated exception, no need for thread safety. globals->uncaughtExceptions += 1; // Not atomically, since globals are thread-local - exception->unwindHeader.exception_cleanup = exception_cleanup_func; + exception_header->unwindHeader.exception_cleanup = exception_cleanup_func; #if __arm__ - _Unwind_SjLj_RaiseException(&exception->unwindHeader); + _Unwind_SjLj_RaiseException(&exception_header->unwindHeader); #else - _Unwind_RaiseException(&exception->unwindHeader); + _Unwind_RaiseException(&exception_header->unwindHeader); #endif // If we get here, some kind of unwinding error has occurred. - failed_throw(exception); + failed_throw(exception_header); } // 2.5.3 Exception Handlers -extern void * __cxa_get_exception_ptr(void * exceptionObject) throw() { -// TODO: This must return the *adjusted* pointer to the exception object. - return exception_from_exception_object(exceptionObject); +/* +The adjusted pointer is computed by the personality routine during phase 1 + and saved in the exception header (either __cxa_exception or + __cxa_dependent_exception). +*/ +void* +__cxa_get_exception_ptr(void* unwind_exception) throw() +{ + return cxa_exception_from_exception_unwind_exception + ( + static_cast<_Unwind_Exception*>(unwind_exception) + )->adjustedPtr; } @@ -227,24 +269,30 @@ This routine: * Decrements the uncaught_exception count. * Returns the adjusted pointer to the exception object. */ -void * __cxa_begin_catch(void * exceptionObject) throw() { +void* +__cxa_begin_catch(void* unwind_exception) throw() +{ __cxa_eh_globals *globals = __cxa_get_globals(); - __cxa_exception *exception = exception_from_exception_object(exceptionObject); + __cxa_exception* exception_header = + cxa_exception_from_exception_unwind_exception + ( + static_cast<_Unwind_Exception*>(unwind_exception) + ); // TODO: Handle foreign exceptions? How? // Increment the handler count, removing the flag about being rethrown - exception->handlerCount = exception->handlerCount < 0 ? - -exception->handlerCount + 1 : exception->handlerCount + 1; + exception_header->handlerCount = exception_header->handlerCount < 0 ? + -exception_header->handlerCount + 1 : exception_header->handlerCount + 1; // place the exception on the top of the stack if it's not there. - if (exception != globals->caughtExceptions) { - exception->nextException = globals->caughtExceptions; - globals->caughtExceptions = exception; + if (exception_header != globals->caughtExceptions) { + exception_header->nextException = globals->caughtExceptions; + globals->caughtExceptions = exception_header; } globals->uncaughtExceptions -= 1; // Not atomically, since globals are thread-local - return __cxa_get_exception_ptr(exceptionObject); + return exception_header->adjustedPtr; } @@ -262,55 +310,52 @@ This routine: exception is a dependent exception, it destroys that. */ void __cxa_end_catch() { + static_assert(sizeof(__cxa_exception) == sizeof(__cxa_dependent_exception), + "sizeof(__cxa_exception) must be equal to sizeof(__cxa_dependent_exception)"); __cxa_eh_globals *globals = __cxa_get_globals_fast(); // __cxa_get_globals called in __cxa_begin_catch - __cxa_exception *current_exception = globals->caughtExceptions; + __cxa_exception *exception_header = globals->caughtExceptions; - if (NULL != current_exception) { + if (NULL != exception_header) { // TODO: Handle foreign exceptions? How? - if (current_exception->handlerCount < 0) { + if (exception_header->handlerCount < 0) { // The exception has been rethrown - if (0 == incrementHandlerCount(current_exception)) { + if (0 == incrementHandlerCount(exception_header)) { // Remove from the chain of uncaught exceptions - globals->caughtExceptions = current_exception->nextException; + globals->caughtExceptions = exception_header->nextException; // but don't destroy } } else { // The exception has not been rethrown - if (0 == decrementHandlerCount(current_exception)) { + if (0 == decrementHandlerCount(exception_header)) { // Remove from the chain of uncaught exceptions - globals->caughtExceptions = current_exception->nextException; - if (isDependentException(¤t_exception->unwindHeader)) { - // Reset current_exception to primaryException and deallocate the dependent exception - __cxa_dependent_exception* deh = - reinterpret_cast<__cxa_dependent_exception*>(current_exception + 1) - 1; - current_exception = static_cast<__cxa_exception*>(deh->primaryException) - 1; - __cxa_free_dependent_exception(deh); + globals->caughtExceptions = exception_header->nextException; + if (isDependentException(&exception_header->unwindHeader)) { + // Reset exception_header to primaryException and deallocate the dependent exception + __cxa_dependent_exception* dep_exception_header = + reinterpret_cast<__cxa_dependent_exception*>(exception_header); + exception_header = + cxa_exception_from_thrown_object(dep_exception_header->primaryException); + __cxa_free_dependent_exception(dep_exception_header); } // Destroy the primary exception only if its referenceCount goes to 0 // (this decrement must be atomic) - __cxa_decrement_exception_refcount(thrown_object_from_exception(current_exception)); + __cxa_decrement_exception_refcount(thrown_object_from_cxa_exception(exception_header)); } } } } - +// Note: exception_header may be masquerading as a __cxa_dependent_exception +// and that's ok. exceptionType is there too. std::type_info * __cxa_current_exception_type() { -// FIXME: I don't think we need to drill down into __cxa_dependent_exception -// because the exceptionType is replicated in the __cxa_dependent_exception // get the current exception __cxa_eh_globals *globals = __cxa_get_globals_fast(); if (NULL == globals) return NULL; // If there have never been any exceptions, there are none now. - __cxa_exception *current_exception = globals->caughtExceptions; - if (NULL == current_exception) + __cxa_exception *exception_header = globals->caughtExceptions; + if (NULL == exception_header) return NULL; // No current exception - if (isDependentException(¤t_exception->unwindHeader)) { - __cxa_dependent_exception* deh = - reinterpret_cast<__cxa_dependent_exception*>(current_exception + 1) - 1; - current_exception = static_cast<__cxa_exception*>(deh->primaryException) - 1; - } - return current_exception->exceptionType; + return exception_header->exceptionType; } // 2.5.4 Rethrowing Exceptions @@ -321,29 +366,31 @@ std::type_info * __cxa_current_exception_type() { (see [C++FDIS] [except.throw], 15.1.8). * It then calls _Unwind_Resume_or_Rethrow which should not return (terminate if it does). + Note: exception_header may be masquerading as a __cxa_dependent_exception + and that's ok. */ extern LIBCXXABI_NORETURN void __cxa_rethrow() { __cxa_eh_globals *globals = __cxa_get_globals(); - __cxa_exception *exception = globals->caughtExceptions; + __cxa_exception *exception_header = globals->caughtExceptions; - if (NULL == exception) // there's no current exception! + if (NULL == exception_header) // there's no current exception! std::terminate (); // TODO: Handle foreign exceptions? How? // Mark the exception as being rethrown (reverse the effects of __cxa_begin_catch) - exception->handlerCount = -exception->handlerCount; + exception_header->handlerCount = -exception_header->handlerCount; globals->uncaughtExceptions += 1; // __cxa_end_catch will remove this exception from the caughtExceptions stack if necessary #if __arm__ - (void) _Unwind_SjLj_Resume_or_Rethrow(&exception->unwindHeader); + (void) _Unwind_SjLj_Resume_or_Rethrow(&exception_header->unwindHeader); #else - (void) _Unwind_Resume_or_Rethrow (&exception->unwindHeader); + (void) _Unwind_Resume_or_Rethrow (&exception_header->unwindHeader); #endif // If we get here, some kind of unwinding error has occurred. - failed_throw(exception); + failed_throw(exception_header); } /* @@ -351,12 +398,12 @@ extern LIBCXXABI_NORETURN void __cxa_rethrow() { __cxa_exception header associated with the thrown object referred to by p. */ void -__cxa_increment_exception_refcount(void* p) throw() +__cxa_increment_exception_refcount(void* thrown_object) throw() { - if (p != NULL ) + if (thrown_object != NULL ) { - __cxa_exception* header = exception_from_thrown_object(p); - __sync_add_and_fetch(&header->referenceCount, 1); + __cxa_exception* exception_header = cxa_exception_from_thrown_object(thrown_object); + __sync_add_and_fetch(&exception_header->referenceCount, 1); } } @@ -370,11 +417,11 @@ __cxa_decrement_exception_refcount(void* thrown_object) throw() { if (thrown_object != NULL ) { - __cxa_exception* header = exception_from_thrown_object(thrown_object); - if (__sync_sub_and_fetch(&header->referenceCount, size_t(1)) == 0) + __cxa_exception* exception_header = cxa_exception_from_thrown_object(thrown_object); + if (__sync_sub_and_fetch(&exception_header->referenceCount, size_t(1)) == 0) { - if (NULL != header->exceptionDestructor) - header->exceptionDestructor(thrown_object); + if (NULL != exception_header->exceptionDestructor) + exception_header->exceptionDestructor(thrown_object); __cxa_free_exception(thrown_object); } } @@ -396,15 +443,15 @@ __cxa_current_primary_exception() throw() __cxa_eh_globals* globals = __cxa_get_globals_fast(); if (NULL == globals) return NULL; // If there are no globals, there is no exception - __cxa_exception* current_exception = globals->caughtExceptions; - if (NULL == current_exception) + __cxa_exception* exception_header = globals->caughtExceptions; + if (NULL == exception_header) return NULL; // No current exception - if (isDependentException(¤t_exception->unwindHeader)) { - __cxa_dependent_exception* deh = - reinterpret_cast<__cxa_dependent_exception*>(current_exception + 1) - 1; - current_exception = static_cast<__cxa_exception*>(deh->primaryException) - 1; + if (isDependentException(&exception_header->unwindHeader)) { + __cxa_dependent_exception* dep_exception_header = + reinterpret_cast<__cxa_dependent_exception*>(exception_header); + exception_header = cxa_exception_from_thrown_object(dep_exception_header->primaryException); } - void* thrown_object = thrown_object_from_exception(current_exception); + void* thrown_object = thrown_object_from_cxa_exception(exception_header); __cxa_increment_exception_refcount(thrown_object); return thrown_object; } @@ -417,14 +464,14 @@ __cxa_current_primary_exception() throw() */ static void -dependent_exception_cleanup(_Unwind_Reason_Code reason, struct _Unwind_Exception* exc) +dependent_exception_cleanup(_Unwind_Reason_Code reason, _Unwind_Exception* unwind_exception) { - __cxa_dependent_exception* deh = - reinterpret_cast<__cxa_dependent_exception*>(exc + 1) - 1; + __cxa_dependent_exception* dep_exception_header = + reinterpret_cast<__cxa_dependent_exception*>(unwind_exception + 1) - 1; if (_URC_FOREIGN_EXCEPTION_CAUGHT != reason) - std::__terminate(deh->terminateHandler); - __cxa_decrement_exception_refcount(deh->primaryException); - __cxa_free_dependent_exception(deh); + std::__terminate(dep_exception_header->terminateHandler); + __cxa_decrement_exception_refcount(dep_exception_header->primaryException); + __cxa_free_dependent_exception(dep_exception_header); } /* @@ -436,24 +483,24 @@ __cxa_rethrow_primary_exception(void* thrown_object) { if ( thrown_object != NULL ) { - __cxa_exception* header = exception_from_thrown_object(thrown_object); - __cxa_dependent_exception* deh = - (__cxa_dependent_exception*)__cxa_allocate_dependent_exception(); - deh->primaryException = thrown_object; + __cxa_exception* exception_header = cxa_exception_from_thrown_object(thrown_object); + __cxa_dependent_exception* dep_exception_header = + static_cast<__cxa_dependent_exception*>(__cxa_allocate_dependent_exception()); + dep_exception_header->primaryException = thrown_object; __cxa_increment_exception_refcount(thrown_object); - deh->exceptionType = header->exceptionType; - deh->unexpectedHandler = std::get_unexpected(); - deh->terminateHandler = std::get_terminate(); - setDependentExceptionClass(&deh->unwindHeader); + dep_exception_header->exceptionType = exception_header->exceptionType; + dep_exception_header->unexpectedHandler = std::get_unexpected(); + dep_exception_header->terminateHandler = std::get_terminate(); + setDependentExceptionClass(&dep_exception_header->unwindHeader); __cxa_get_globals()->uncaughtExceptions += 1; - deh->unwindHeader.exception_cleanup = dependent_exception_cleanup; + dep_exception_header->unwindHeader.exception_cleanup = dependent_exception_cleanup; #if __arm__ - _Unwind_SjLj_RaiseException(&deh->unwindHeader); + _Unwind_SjLj_RaiseException(&dep_exception_header->unwindHeader); #else - _Unwind_RaiseException(&deh->unwindHeader); + _Unwind_RaiseException(&dep_exception_header->unwindHeader); #endif // Some sort of unwinding error. Note that terminate is a handler. - __cxa_begin_catch(&deh->unwindHeader); + __cxa_begin_catch(&dep_exception_header->unwindHeader); } // If we return client will call terminate() } diff --git a/libcxxabi/src/cxa_personality.cpp b/libcxxabi/src/cxa_personality.cpp index 6fd570278de4..15621879e4f8 100644 --- a/libcxxabi/src/cxa_personality.cpp +++ b/libcxxabi/src/cxa_personality.cpp @@ -18,6 +18,17 @@ #include #include +// +---------------------------+-----------------------------+---------------+ +// | __cxa_exception | _Unwind_Exception CLNGC++\0 | thrown object | +// +---------------------------+-----------------------------+---------------+ +// ^ +// | +// +-------------------------------------------------------+ +// | +// +---------------------------+-----------------------------+ +// | __cxa_dependent_exception | _Unwind_Exception CLNGC++\1 | +// +---------------------------+-----------------------------+ + namespace __cxxabiv1 { @@ -220,16 +231,16 @@ getTTypeEntry(int64_t typeOffset, const uint8_t* classInfo, uint8_t ttypeEncodin /// @param classInfo our array of type info pointers (to globals) /// @param actionEntry index into above type info array or 0 (clean up). /// We do not support filters. -/// @param exceptionObject thrown _Unwind_Exception instance. +/// @param unwind_exception thrown _Unwind_Exception instance. /// @returns whether or not a type info was found. False is returned if only /// a cleanup was found static bool handleActionValue(const uint8_t* classInfo, uintptr_t actionEntry, - _Unwind_Exception* exceptionObject, uint8_t ttypeEncoding) + _Unwind_Exception* unwind_exception, uint8_t ttypeEncoding) { - __cxa_exception* excp = (__cxa_exception*)(exceptionObject+1) - 1; - const std::type_info* excpType = excp->exceptionType; + __cxa_exception* exception_header = (__cxa_exception*)(unwind_exception+1) - 1; + const std::type_info* excpType = exception_header->exceptionType; const uint8_t* actionPos = (uint8_t*)actionEntry; while (true) { @@ -250,8 +261,8 @@ handleActionValue(const uint8_t* classInfo, uintptr_t actionEntry, // catchType == 0 -> catch (...) if (catchType == 0 || excpType == catchType) { - excp->handlerSwitchValue = typeOffset; - excp->actionRecord = SactionPos; + exception_header->handlerSwitchValue = typeOffset; + exception_header->actionRecord = SactionPos; return true; } } @@ -273,14 +284,14 @@ handleActionValue(const uint8_t* classInfo, uintptr_t actionEntry, // catchTemp and adjustedPtr here. static bool -contains_handler(_Unwind_Exception* exceptionObject, _Unwind_Context* context) +contains_handler(_Unwind_Exception* unwind_exception, _Unwind_Context* context) { - __cxa_exception* excp = (__cxa_exception*)(exceptionObject+1) - 1; + __cxa_exception* exception_header = (__cxa_exception*)(unwind_exception+1) - 1; const uint8_t* lsda = (const uint8_t*)_Unwind_GetLanguageSpecificData(context); - excp->languageSpecificData = lsda; + exception_header->languageSpecificData = lsda; // set adjustedPtr! __cxa_get_exception_ptr and __cxa_begin_catch use it. // TODO: Put it where it is supposed to be and adjust it properly - excp->adjustedPtr = exceptionObject+1; + exception_header->adjustedPtr = unwind_exception+1; if (lsda) { // Get the current instruction pointer and offset it before next @@ -328,11 +339,11 @@ contains_handler(_Unwind_Exception* exceptionObject, _Unwind_Context* context) actionEntry += ((uintptr_t)actionTableStart) - 1; if ((start <= pcOffset) && (pcOffset < (start + length))) { - excp->catchTemp = (void*)(funcStart + landingPad); + exception_header->catchTemp = (void*)(funcStart + landingPad); if (actionEntry) return handleActionValue(classInfo, actionEntry, - exceptionObject, + unwind_exception, ttypeEncoding); // Note: Only non-clean up handlers are marked as // found. Otherwise the clean up handlers will be @@ -348,24 +359,24 @@ contains_handler(_Unwind_Exception* exceptionObject, _Unwind_Context* context) static _Unwind_Reason_Code -transfer_control_to_landing_pad(_Unwind_Exception* exceptionObject, +transfer_control_to_landing_pad(_Unwind_Exception* unwind_exception, _Unwind_Context* context) { - __cxa_exception* excp = (__cxa_exception*)(exceptionObject+1) - 1; - _Unwind_SetGR(context, __builtin_eh_return_data_regno(0), (uintptr_t)exceptionObject); - _Unwind_SetGR(context, __builtin_eh_return_data_regno(1), excp->handlerSwitchValue); - _Unwind_SetIP(context, (uintptr_t)excp->catchTemp); + __cxa_exception* exception_header = (__cxa_exception*)(unwind_exception+1) - 1; + _Unwind_SetGR(context, __builtin_eh_return_data_regno(0), (uintptr_t)unwind_exception); + _Unwind_SetGR(context, __builtin_eh_return_data_regno(1), exception_header->handlerSwitchValue); + _Unwind_SetIP(context, (uintptr_t)exception_header->catchTemp); return _URC_INSTALL_CONTEXT; } static _Unwind_Reason_Code -perform_cleanup(_Unwind_Exception* exceptionObject, _Unwind_Context* context) +perform_cleanup(_Unwind_Exception* unwind_exception, _Unwind_Context* context) { - __cxa_exception* excp = (__cxa_exception*)(exceptionObject+1) - 1; - _Unwind_SetGR(context, __builtin_eh_return_data_regno(0), (uintptr_t)exceptionObject); + __cxa_exception* exception_header = (__cxa_exception*)(unwind_exception+1) - 1; + _Unwind_SetGR(context, __builtin_eh_return_data_regno(0), (uintptr_t)unwind_exception); _Unwind_SetGR(context, __builtin_eh_return_data_regno(1), 0); - _Unwind_SetIP(context, (uintptr_t)excp->catchTemp); + _Unwind_SetIP(context, (uintptr_t)exception_header->catchTemp); return _URC_INSTALL_CONTEXT; } @@ -376,13 +387,13 @@ perform_cleanup(_Unwind_Exception* exceptionObject, _Unwind_Context* context) // == _UA_CLEANUP_PHASE, or // == _UA_CLEANUP_PHASE | _UA_HANDLER_FRAME, or // == _UA_CLEANUP_PHASE | _UA_FORCE_UNWIND -// exceptionObject != nullptr +// unwind_exception != nullptr // context != nullptr _Unwind_Reason_Code __gxx_personality_v0(int version, _Unwind_Action actions, uint64_t exceptionClass, - _Unwind_Exception* exceptionObject, _Unwind_Context* context) + _Unwind_Exception* unwind_exception, _Unwind_Context* context) { - if (version == 1 && exceptionObject != 0 && context != 0) + if (version == 1 && unwind_exception != 0 && context != 0) { bool native_exception = (exceptionClass & 0xFFFFFF00) == 0x432B2B00; bool force_unwind = actions & _UA_FORCE_UNWIND; @@ -392,7 +403,7 @@ __gxx_personality_v0(int version, _Unwind_Action actions, uint64_t exceptionClas { if (actions & _UA_CLEANUP_PHASE) return _URC_FATAL_PHASE1_ERROR; - if (contains_handler(exceptionObject, context)) + if (contains_handler(unwind_exception, context)) return _URC_HANDLER_FOUND; return _URC_CONTINUE_UNWIND; } @@ -401,10 +412,10 @@ __gxx_personality_v0(int version, _Unwind_Action actions, uint64_t exceptionClas if (actions & _UA_HANDLER_FRAME) { // return _URC_INSTALL_CONTEXT or _URC_FATAL_PHASE2_ERROR - return transfer_control_to_landing_pad(exceptionObject, context); + return transfer_control_to_landing_pad(unwind_exception, context); } // return _URC_CONTINUE_UNWIND or _URC_FATAL_PHASE2_ERROR - return perform_cleanup(exceptionObject, context); + return perform_cleanup(unwind_exception, context); } } else // foreign exception or force_unwind @@ -420,7 +431,7 @@ __gxx_personality_v0(int version, _Unwind_Action actions, uint64_t exceptionClas if (actions & _UA_HANDLER_FRAME) return _URC_FATAL_PHASE2_ERROR; // return _URC_CONTINUE_UNWIND or _URC_FATAL_PHASE2_ERROR - return perform_cleanup(exceptionObject, context); + return perform_cleanup(unwind_exception, context); } } } -- cgit v1.2.3