// // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo // // The contents of this file are covered under the licence agreement in the // file "LICENCE" distributed with Cforall. // // exception.c -- // // Author : Andrew Beach // Created On : Mon Jun 26 15:13:00 2017 // Last Modified By : Andrew Beach // Last Modified On : Thr Aug 17 15:45:00 2017 // Update Count : 7 // #include // for size_t #include "exception.h" // Implementation of the secret header. #include #include #include #include // FIX ME: temporary hack to keep ARM build working #ifndef _URC_FATAL_PHASE1_ERROR #define _URC_FATAL_PHASE1_ERROR 2 #endif // ! _URC_FATAL_PHASE1_ERROR #ifndef _URC_FATAL_PHASE2_ERROR #define _URC_FATAL_PHASE2_ERROR 2 #endif // ! _URC_FATAL_PHASE2_ERROR #include "lsda.h" // Base exception vtable is abstract, you should not have base exceptions. struct __cfaabi_ehm__base_exception_t_vtable ___cfaabi_ehm__base_exception_t_vtable_instance = { .parent = NULL, .size = 0, .copy = NULL, .free = NULL, .msg = NULL }; // Temperary global exception context. Does not work with concurency. struct exception_context_t { struct __cfaabi_ehm__try_resume_node * top_resume; struct __cfaabi_ehm__try_resume_node * current_resume; exception * current_exception; int current_handler_index; } shared_stack = {NULL, NULL, 0, 0}; // Get the current exception context. // There can be a single global until multithreading occurs, then each stack // needs its own. It will have to be updated to handle that. struct exception_context_t * this_exception_context() { return &shared_stack; } //#define SAVE_EXCEPTION_CONTEXT(to_name) //struct exception_context_t * to_name = this_exception_context(); //exception * this_exception() { // return this_exception_context()->current_exception; //} // This macro should be the only thing that needs to change across machines. Used in the personality function, way down // in termination. // struct _Unwind_Context * -> _Unwind_Reason_Code(*)(exception *) #define MATCHER_FROM_CONTEXT(ptr_to_context) \ (*(_Unwind_Reason_Code(**)(exception*))(_Unwind_GetCFA(ptr_to_context) + 8)) // RESUMPTION ================================================================ void __cfaabi_ehm__throw_resume(exception * except) { __cfaabi_dbg_print_safe("Throwing resumption exception\n"); struct __cfaabi_ehm__try_resume_node * original_head = shared_stack.current_resume; struct __cfaabi_ehm__try_resume_node * current = (original_head) ? original_head->next : shared_stack.top_resume; for ( ; current ; current = current->next) { shared_stack.current_resume = current; if (current->handler(except)) { shared_stack.current_resume = original_head; return; } } __cfaabi_dbg_print_safe("Unhandled exception\n"); shared_stack.current_resume = original_head; // Fall back to termination: __cfaabi_ehm__throw_terminate(except); // TODO: Default handler for resumption. } // Do we control where exceptions get thrown even with concurency? If not these are not quite thread safe, the cleanup // hook has to be added after the node is built but before it is made the top node. void __cfaabi_ehm__try_resume_setup(struct __cfaabi_ehm__try_resume_node * node, _Bool (*handler)(exception * except)) { node->next = shared_stack.top_resume; node->handler = handler; shared_stack.top_resume = node; } void __cfaabi_ehm__try_resume_cleanup(struct __cfaabi_ehm__try_resume_node * node) { shared_stack.top_resume = node->next; } // TERMINATION =============================================================== // MEMORY MANAGEMENT (still for integers) // May have to move to cfa for constructors and destructors (references). struct __cfaabi_ehm__node { struct __cfaabi_ehm__node * next; }; #define NODE_TO_EXCEPT(node) ((exception *)(1 + (node))) #define EXCEPT_TO_NODE(except) ((struct __cfaabi_ehm__node *)(except) - 1) // Creates a copy of the indicated exception and sets current_exception to it. static void __cfaabi_ehm__allocate_exception( exception * except ) { struct exception_context_t * context = this_exception_context(); // Allocate memory for the exception. struct __cfaabi_ehm__node * store = malloc( sizeof( struct __cfaabi_ehm__node ) + except->virtual_table->size ); if ( ! store ) { // Failure: cannot allocate exception. Terminate thread. abort(); // <- Although I think it might be the process. } // Add the node to the list: store->next = EXCEPT_TO_NODE(context->current_exception); context->current_exception = NODE_TO_EXCEPT(store); // Copy the exception to storage. except->virtual_table->copy( context->current_exception, except ); } // Delete the provided exception, unsetting current_exception if relivant. static void __cfaabi_ehm__delete_exception( exception * except ) { struct exception_context_t * context = this_exception_context(); __cfaabi_dbg_print_safe("Deleting Exception\n"); // Remove the exception from the list. struct __cfaabi_ehm__node * to_free = EXCEPT_TO_NODE(except); struct __cfaabi_ehm__node * node; if ( context->current_exception == except ) { node = to_free->next; context->current_exception = (node) ? NODE_TO_EXCEPT(node) : 0; } else { node = EXCEPT_TO_NODE(context->current_exception); // It may always be in the first or second position. while( to_free != node->next ) { node = node->next; } node->next = to_free->next; } // Free the old exception node. except->virtual_table->free( except ); free( to_free ); } // If this isn't a rethrow (*except==0), delete the provided exception. void __cfaabi_ehm__cleanup_terminate( void * except ) { if ( *(void**)except ) __cfaabi_ehm__delete_exception( *(exception**)except ); } // We need a piece of storage to raise the exception struct _Unwind_Exception this_exception_storage; // Function needed by force unwind // It basically says to unwind the whole stack and then exit when we reach the end of the stack static _Unwind_Reason_Code _Stop_Fn( int version, _Unwind_Action actions, _Unwind_Exception_Class exceptionClass, struct _Unwind_Exception * unwind_exception, struct _Unwind_Context * context, void * some_param) { if( actions & _UA_END_OF_STACK ) exit(1); if( actions & _UA_CLEANUP_PHASE ) return _URC_NO_REASON; return _URC_FATAL_PHASE2_ERROR; } // The exception that is being thrown must already be stored. __attribute__((noreturn)) void __cfaabi_ehm__begin_unwind(void) { if ( ! this_exception_context()->current_exception ) { printf("UNWIND ERROR missing exception in begin unwind\n"); abort(); } // Call stdlibc to raise the exception _Unwind_Reason_Code ret = _Unwind_RaiseException( &this_exception_storage ); // If we reach here it means something happened. For resumption to work we need to find a way to return back to // here. Most of them will probably boil down to setting a global flag and making the phase 1 either stop or // fail. Causing an error on purpose may help avoiding unnecessary work but it might have some weird side // effects. If we just pretend no handler was found that would work but may be expensive for no reason since we // will always search the whole stack. if( ret == _URC_END_OF_STACK ) { // No proper handler was found. This can be handled in several way. C++ calls std::terminate Here we // force unwind the stack, basically raising a cancellation. printf("Uncaught exception %p\n", &this_exception_storage); ret = _Unwind_ForcedUnwind( &this_exception_storage, _Stop_Fn, (void*)0x22 ); printf("UNWIND ERROR %d after force unwind\n", ret); abort(); } // We did not simply reach the end of the stack without finding a handler. Something wen't wrong printf("UNWIND ERROR %d after raise exception\n", ret); abort(); } void __cfaabi_ehm__throw_terminate( exception * val ) { __cfaabi_dbg_print_safe("Throwing termination exception\n"); __cfaabi_ehm__allocate_exception( val ); __cfaabi_ehm__begin_unwind(); } void __cfaabi_ehm__rethrow_terminate(void) { __cfaabi_dbg_print_safe("Rethrowing termination exception\n"); __cfaabi_ehm__begin_unwind(); } // This is our personality routine. For every stack frame anotated with ".cfi_personality 0x3,__gcfa_personality_v0". // This function will be called twice when unwinding. Once in the search phased and once in the cleanup phase. _Unwind_Reason_Code __gcfa_personality_v0 ( int version, _Unwind_Action actions, unsigned long long exceptionClass, struct _Unwind_Exception* unwind_exception, struct _Unwind_Context* context) { //__cfaabi_dbg_print_safe("CFA: 0x%lx\n", _Unwind_GetCFA(context)); __cfaabi_dbg_print_safe("Personality function (%d, %x, %llu, %p, %p):", version, actions, exceptionClass, unwind_exception, context); // If we've reached the end of the stack then there is nothing much we can do... if( actions & _UA_END_OF_STACK ) return _URC_END_OF_STACK; if (actions & _UA_SEARCH_PHASE) { __cfaabi_dbg_print_safe(" lookup phase"); } else if (actions & _UA_CLEANUP_PHASE) { __cfaabi_dbg_print_safe(" cleanup phase"); } // Just in case, probably can't actually happen else { printf(" error\n"); return _URC_FATAL_PHASE1_ERROR; } // Get a pointer to the language specific data from which we will read what we need const unsigned char * lsd = (const unsigned char*) _Unwind_GetLanguageSpecificData( context ); if( !lsd ) { //Nothing to do, keep unwinding printf(" no LSD"); goto UNWIND; } // Get the instuction pointer and a reading pointer into the exception table lsda_header_info lsd_info; const unsigned char * cur_ptr = parse_lsda_header( context, lsd, &lsd_info); _Unwind_Ptr instruction_ptr = _Unwind_GetIP( context ); // Linearly search the table for stuff to do while( cur_ptr < lsd_info.action_table ) { _Unwind_Ptr callsite_start; _Unwind_Ptr callsite_len; _Unwind_Ptr callsite_landing_pad; _uleb128_t callsite_action; // Decode the common stuff we have in here cur_ptr = read_encoded_value (0, lsd_info.call_site_encoding, cur_ptr, &callsite_start); cur_ptr = read_encoded_value (0, lsd_info.call_site_encoding, cur_ptr, &callsite_len); cur_ptr = read_encoded_value (0, lsd_info.call_site_encoding, cur_ptr, &callsite_landing_pad); cur_ptr = read_uleb128 (cur_ptr, &callsite_action); // Have we reach the correct frame info yet? if( lsd_info.Start + callsite_start + callsite_len < instruction_ptr ) { #ifdef __CFA_DEBUG_PRINT__ void * ls = (void*)lsd_info.Start; void * cs = (void*)callsite_start; void * cl = (void*)callsite_len; void * bp = (void*)lsd_info.Start + callsite_start; void * ep = (void*)lsd_info.Start + callsite_start + callsite_len; void * ip = (void*)instruction_ptr; __cfaabi_dbg_print_safe("\nfound %p - %p (%p, %p, %p), looking for %p\n", bp, ep, ls, cs, cl, ip); #endif // __CFA_DEBUG_PRINT__ continue; } // Have we gone too far if( lsd_info.Start + callsite_start > instruction_ptr ) { printf(" gone too far"); break; } // Something to do? if( callsite_landing_pad ) { // Which phase are we in if (actions & _UA_SEARCH_PHASE) { // Search phase, this means we probably found a potential handler and must check if it is a match // If we have arbitrarily decided that 0 means nothing to do and 1 means there is a potential handler // This doesn't seem to conflict the gcc default behavior if (callsite_action != 0) { // Now we want to run some code to see if the handler matches // This is the tricky part where we want to the power to run arbitrary code // However, generating a new exception table entry and try routine every time // is way more expansive than we might like // The information we have is : // - The GR (Series of registers) // GR1=GP Global Pointer of frame ref by context // - The instruction pointer // - The instruction pointer info (???) // - The CFA (Canonical Frame Address) // - The BSP (Probably the base stack pointer) // The current apprach uses one exception table entry per try block _uleb128_t imatcher; // Get the relative offset to the cur_ptr = read_uleb128 (cur_ptr, &imatcher); // Get a function pointer from the relative offset and call it // _Unwind_Reason_Code (*matcher)() = (_Unwind_Reason_Code (*)())lsd_info.LPStart + imatcher; _Unwind_Reason_Code (*matcher)(exception *) = MATCHER_FROM_CONTEXT(context); int index = matcher(shared_stack.current_exception); _Unwind_Reason_Code ret = (0 == index) ? _URC_CONTINUE_UNWIND : _URC_HANDLER_FOUND; shared_stack.current_handler_index = index; // Based on the return value, check if we matched the exception if( ret == _URC_HANDLER_FOUND) { __cfaabi_dbg_print_safe(" handler found\n"); } else { __cfaabi_dbg_print_safe(" no handler\n"); } return ret; } // This is only a cleanup handler, ignore it __cfaabi_dbg_print_safe(" no action"); } else if (actions & _UA_CLEANUP_PHASE) { if( (callsite_action != 0) && !(actions & _UA_HANDLER_FRAME) ){ // If this is a potential exception handler // but not the one that matched the exception in the seach phase, // just ignore it goto UNWIND; } // We need to run some clean-up or a handler // These statment do the right thing but I don't know any specifics at all _Unwind_SetGR( context, __builtin_eh_return_data_regno(0), (_Unwind_Ptr) unwind_exception ); _Unwind_SetGR( context, __builtin_eh_return_data_regno(1), 0 ); // I assume this sets the instruction pointer to the adress of the landing pad // It doesn't actually set it, it only state the value that needs to be set once we return _URC_INSTALL_CONTEXT _Unwind_SetIP( context, ((lsd_info.LPStart) + (callsite_landing_pad)) ); __cfaabi_dbg_print_safe(" action\n"); // Return have some action to run return _URC_INSTALL_CONTEXT; } } // Nothing to do, move along __cfaabi_dbg_print_safe(" no landing pad"); } // No handling found __cfaabi_dbg_print_safe(" table end reached\n"); UNWIND: __cfaabi_dbg_print_safe(" unwind\n"); // Keep unwinding the stack return _URC_CONTINUE_UNWIND; } // Try statements are hoisted out see comments for details. With this could probably be unique and simply linked from // libcfa but there is one problem left, see the exception table for details __attribute__((noinline)) void __cfaabi_ehm__try_terminate(void (*try_block)(), void (*catch_block)(int index, exception * except), __attribute__((unused)) int (*match_block)(exception * except)) { //! volatile int xy = 0; //! printf("%p %p %p %p\n", &try_block, &catch_block, &match_block, &xy); // Setup statments: These 2 statments won't actually result in any code, they only setup global tables. // However, they clobber gcc cancellation support from gcc. We can replace the personality routine but // replacing the exception table gcc generates is not really doable, it generates labels based on how the // assembly works. // Setup the personality routine asm volatile (".cfi_personality 0x3,__gcfa_personality_v0"); // Setup the exception table asm volatile (".cfi_lsda 0x3, .LLSDACFA2"); // Label which defines the start of the area for which the handler is setup. asm volatile (".TRYSTART:"); // The actual statements of the try blocks try_block(); // asm statement to prevent deadcode removal asm volatile goto ("" : : : : CATCH ); // Normal return return; // Exceptionnal path CATCH : __attribute__(( unused )); // Label which defines the end of the area for which the handler is setup. asm volatile (".TRYEND:"); // Label which defines the start of the exception landing pad. Basically what is called when the exception is // caught. Note, if multiple handlers are given, the multiplexing should be done by the generated code, not the // exception runtime. asm volatile (".CATCH:"); // Exception handler catch_block( shared_stack.current_handler_index, shared_stack.current_exception ); } // Exception table data we need to generate. While this is almost generic, the custom data refers to foo_try_match try // match, which is no way generic. Some more works need to be done if we want to have a single call to the try routine. #if defined( __x86_64__ ) || defined( __i386__ ) asm ( //HEADER ".LFECFA1:\n" " .globl __gcfa_personality_v0\n" " .section .gcc_except_table,\"a\",@progbits\n" ".LLSDACFA2:\n" //TABLE header " .byte 0xff\n" " .byte 0xff\n" " .byte 0x1\n" " .uleb128 .LLSDACSECFA2-.LLSDACSBCFA2\n" // BODY length // Body uses language specific data and therefore could be modified arbitrarily ".LLSDACSBCFA2:\n" // BODY start " .uleb128 .TRYSTART-__cfaabi_ehm__try_terminate\n" // Handled area start (relative to start of function) " .uleb128 .TRYEND-.TRYSTART\n" // Handled area length " .uleb128 .CATCH-__cfaabi_ehm__try_terminate\n" // Hanlder landing pad adress (relative to start of function) " .uleb128 1\n" // Action code, gcc seems to use always 0 ".LLSDACSECFA2:\n" // BODY end " .text\n" // TABLE footer " .size __cfaabi_ehm__try_terminate, .-__cfaabi_ehm__try_terminate\n" " .ident \"GCC: (Ubuntu 6.2.0-3ubuntu11~16.04) 6.2.0 20160901\"\n" // " .section .note.GNU-stack,\"x\",@progbits\n" ); #endif // __x86_64__ || __i386__