Index: doc/working/exception/impl/exception.c =================================================================== --- doc/working/exception/impl/exception.c (revision 35dd0f42a24565056364798f0857efa19e720bf2) +++ doc/working/exception/impl/exception.c (revision 35dd0f42a24565056364798f0857efa19e720bf2) @@ -0,0 +1,366 @@ +#include "exception.h" + +// Implementation of the secret header. + +#include +#include +#include + +#include "lsda.h" + +struct shared_stack_t shared_stack; + + +// 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(*)() +#define MATCHER_FROM_CONTEXT(ptr_to_context) \ + (*(_Unwind_Reason_Code(**)())(_Unwind_GetCFA(ptr_to_context) + 8)) + + +// RESUMPTION ================================================================ + +void __throw_resume(exception except) { + void noop() { printf("do nothing\n");} + struct __cleanup_hook __blarg __attribute__((cleanup(noop))); + + struct __try_resume_node * original_head = shared_stack.current_resume; + struct __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->try_to_handle(except)) { + shared_stack.current_resume = original_head; + return; + } + } + + printf("Unhandled exception %d\n", except); + shared_stack.current_resume = original_head; + + // Fall back to termination: + __throw_terminate(except); + // TODO: Default handler for resumption. +} + +/* __try_resume_node functions: + * Currently I was planning to generate this code inline, and even if I don't + * putting it in the header so it can be inlined might be worth while. + * And if we put them in Cforall code we can use the operators. + */ +void __try_resume_node_new(struct __try_resume_node * node, + _Bool (*handler)(exception except)) { + node->next = shared_stack.top_resume; + shared_stack.top_resume = node; + node->try_to_handle = handler; +} + +void __try_resume_node_delete(struct __try_resume_node * node) { + shared_stack.top_resume = node->next; +} + + +// TERMINATION =============================================================== + +// Requires -fexceptions to work. + +// 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 __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 will be 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 +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-__try_terminate\n" // Handled area start (relative to start of function) + " .uleb128 .TRYEND-.TRYSTART\n" // Handled area length + " .uleb128 .CATCH-__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 __try_terminate, .-__try_terminate\n" + " .ident \"GCC: (Ubuntu 6.2.0-3ubuntu11~16.04) 6.2.0 20160901\"\n" + " .section .note.GNU-stack,\"x\",@progbits\n" +); + +// Global which defines the current exception +// Currently an int just to make matching easier +int this_exception; + +// 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; +} + +// Example throw routine +void __throw_terminate( int val ) { + // Store the current exception + this_exception = val; + + // DEBUG + printf("Throwing exception %d\n", this_exception); + + // 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(); +} + +// 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) +{ + printf("CFA: 0x%lx\n", _Unwind_GetCFA(context)); + + // DEBUG + printf("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; + + // DEBUG + if (actions & _UA_SEARCH_PHASE) { + printf(" lookup phase"); + } + // DEBUG + else if (actions & _UA_CLEANUP_PHASE) { + printf(" 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 ) { + //DEBUG BEGIN + 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; + printf("\nfound %p - %p (%p, %p, %p), looking for %p\n", bp, ep, ls, cs, cl, ip); + //DEBUG END + 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)() = + 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) printf(" handler found\n"); + else printf(" no handler\n"); + return ret; + } + + // This is only a cleanup handler, ignore it + printf(" 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 ); + + // DEBUG + printf(" action\n"); + + // Return have some action to run + return _URC_INSTALL_CONTEXT; + } + } + + // Nothing to do, move along + printf(" no landing pad"); + } + // No handling found + printf(" table end reached\n"); + + // DEBUG + UNWIND: + printf(" unwind\n"); + + // Keep unwinding the stack + return _URC_CONTINUE_UNWIND; +} Index: doc/working/exception/impl/exception.h =================================================================== --- doc/working/exception/impl/exception.h (revision 35dd0f42a24565056364798f0857efa19e720bf2) +++ doc/working/exception/impl/exception.h (revision 35dd0f42a24565056364798f0857efa19e720bf2) @@ -0,0 +1,34 @@ +// Trying to create the new secret header for the exception handling mechanism. + +// This will have to go in the public header later. +typedef int exception; + + + +// These might be given simpler names and made public. +void __throw_terminate(exception except) __attribute__((noreturn)); +void __throw_resume(exception except); + +void __try_terminate(void (*try_block)(), + void (*catch_block)(int index, exception except), + int (*match_block)(exception except)); + +struct __try_resume_node { + struct __try_resume_node * next; + _Bool (*try_to_handle)(exception except); +}; + +struct __cleanup_hook {}; + + +// When I have it working in a single threaded environment. +struct shared_stack_t { + //struct lock lock; + struct __try_resume_node * top_resume; + struct __try_resume_node * current_resume; + + exception current_exception; + int current_handler_index; +}; + +extern struct shared_stack_t stared_stack; Index: doc/working/exception/impl/test-main.c =================================================================== --- doc/working/exception/impl/test-main.c (revision 35dd0f42a24565056364798f0857efa19e720bf2) +++ doc/working/exception/impl/test-main.c (revision 35dd0f42a24565056364798f0857efa19e720bf2) @@ -0,0 +1,90 @@ +#include "exception.h" + +#include + +// Translation Helpers: +#define CLEANUP(function) \ + struct __cleanup_hook __hidden_hook __attribute__((cleanup(function))) + + +// Local Print On Exit: +struct raii_base_type { + const char * area; +}; + +void raii_dtor(struct raii_base_type * this) { + printf("Exiting: %s\n", this->area); +} + +#define raii_t __attribute__((cleanup(raii_dtor))) struct raii_base_type + +// Runtime code (post-translation). +void terminate(int except_value) { + raii_t a = {"terminate function"}; + __throw_terminate(except_value); + printf("terminate returned\n"); +} + +void resume(int except_value) { + raii_t a = {"resume function"}; + __throw_resume(except_value); + printf("resume returned\n"); +} + +// Termination Test: Two handlers: no catch, catch +void bar() { + void bar_try1() { + terminate(4); + } + void bar_catch1(int index, exception except) { + switch(except) { + case 1: + printf("bar caught exception.\n"); + break; + default: + printf("INVALID INDEX in bar: %d\n", except); + } + } + int bar_match1(exception except) { + if (3 == except) { + return 1; + } else { + return 0; + } + } + __try_terminate(bar_try1, bar_catch1, bar_match1); +} + +void foo() { + void foo_try1() { + bar(); + } + void foo_catch1(int index, exception except) { + switch(except) { + case 1: + printf("foo caught exception 4.\n"); + break; + case 2: + printf("foo caught exception 2.\n"); + break; + default: + printf("INVALID INDEX in foo: %d\n", except); + } + } + int foo_match1(exception except) { + if (4 == except) { + return 1; + } else if (2 == except) { + return 2; + } else { + return 0; + } + } + __try_terminate(foo_try1, foo_catch1, foo_match1); +} + +int main(int argc, char * argv[]) { + raii_t a = {"main function"}; + + foo(); +}