Index: src/libcfa/exception.c
===================================================================
--- src/libcfa/exception.c	(revision fa4805fa298698201db6b7292ed9cb1cc00af9ef)
+++ src/libcfa/exception.c	(revision fa4805fa298698201db6b7292ed9cb1cc00af9ef)
@@ -0,0 +1,395 @@
+//
+// 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 : Mon Nov 26 15:11:00 2017
+// Update Count     : 0
+//
+
+#include "exception.h"
+
+// Implementation of the secret header.
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <unwind.h>
+
+#include "lsda.h"
+
+// Temperary global exception context. Does not work with concurency.
+struct shared_stack_t {
+    struct __cfaehm__try_resume_node * top_resume;
+    struct __cfaehm__try_resume_node * current_resume;
+
+    exception current_exception;
+    int current_handler_index;
+} shared_stack = {NULL, NULL, 0, 0};
+
+
+
+// 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 __cfaehm__throw_resume(exception except) {
+
+	// DEBUG
+	printf("Throwing resumption exception %d\n", except);
+
+	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:
+	__cfaehm__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 __try_resume_setup(struct __try_resume_node * node,
+                        bool (*handler)(exception except)) {
+	node->next = shared_stack.top_resume;
+	node->try_to_handle = handler;
+	shared_stack.top_resume = node;
+}
+
+void __try_resume_cleanup(struct __try_resume_node * node) {
+	shared_stack.top_resume = node->next;
+}
+
+
+// TERMINATION ===============================================================
+
+// Requires -fexceptions to work.
+
+// Global which defines the current exception
+// Currently an int just to make matching easier
+//int this_exception; (became shared_stack.current_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;
+}
+
+void __cfaehm__throw_terminate( int val ) {
+	// Store the current exception
+	shared_stack.current_exception = val;
+
+	// DEBUG
+	printf("Throwing termination exception %d\n", val);
+
+	// 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();
+}
+
+// Nesting this the other way would probably be faster.
+void __cfaehm__rethrow_terminate(void) {
+	// DEBUG
+	printf("Rethrowing termination exception\n");
+
+	__cfaehm__throw_terminate(shared_stack.current_exception);
+}
+
+// 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)
+{
+
+	// DEBUG
+	//printf("CFA: 0x%lx\n", _Unwind_GetCFA(context));
+	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;
+}
+
+// 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"
+);
