//
// 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 : Peter A. Buhr
// Last Modified On : Thu Feb 22 18:17:34 2018
// Update Count     : 11
//

// Normally we would get this from the CFA prelude.
#include <stddef.h> // for size_t

#include "exception.h"

// Implementation of the secret header is hardware dependent.
#if !( defined( __x86_64 ) || defined( __i386 ) )
#error Exception Handling: No known architecture detected.
#endif

#include <stdlib.h>
#include <stdio.h>
#include <unwind.h>
#include <bits/debug.hfa>

// 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_t * 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;
//}


// RESUMPTION ================================================================

void __cfaabi_ehm__throw_resume(exception_t * 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_t * 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_t *)(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_t * 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_t * 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_t **)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 many ways, 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. This is an error.
	printf("UNWIND ERROR %d after raise exception\n", ret);
	abort();
}

void __cfaabi_ehm__throw_terminate( exception_t * 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 annotated with
// ".cfi_personality 0x3,__gcfa_personality_v0" this function will be called twice when unwinding.
//  Once in the search phase 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) {
				// In search phase, these means we found a potential handler we must check.

				// 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);

#					if defined( __x86_64 )
					_Unwind_Word match_pos = _Unwind_GetCFA(context) + 8;
#					elif defined( __i386 )
					_Unwind_Word match_pos = _Unwind_GetCFA(context) + 24;
#					endif
					int (*matcher)(exception_t *) = *(int(**)(exception_t *))match_pos;

					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;
}

#pragma GCC push_options
#pragma GCC optimize("O0")

// Try statements are hoisted out see comments for details. While 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_t * except),
		__attribute__((unused)) int (*match_block)(exception_t * 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 and exception table.
#ifdef __PIC__
	asm volatile (".cfi_personality 0x9b,CFA.ref.__gcfa_personality_v0");
	asm volatile (".cfi_lsda 0x1b, .LLSDACFA2");
#else
	asm volatile (".cfi_personality 0x3,__gcfa_personality_v0");
	asm volatile (".cfi_lsda 0x3, .LLSDACFA2");
#endif

	// 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 for when there is no throw.
	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 {*}try_terminate, which is no way generic. Some more works need to be done if we want to
// have a single call to the try routine.

#ifdef __PIC__
asm (
	// HEADER
	".LFECFA1:\n"
	"	.globl	__gcfa_personality_v0\n"
	"	.section	.gcc_except_table,\"a\",@progbits\n"
	// TABLE HEADER (important field is the BODY length at the end)
	".LLSDACFA2:\n"
	"	.byte	0xff\n"
	"	.byte	0xff\n"
	"	.byte	0x1\n"
	"	.uleb128 .LLSDACSECFA2-.LLSDACSBCFA2\n"
	// BODY (language specific data)
	// This uses language specific data and can be modified arbitrarily
	// We use handled area offset, handled area length,
	// handler landing pad offset and 1 (action code, gcc seems to use 0).
	".LLSDACSBCFA2:\n"
	"	.uleb128 .TRYSTART-__cfaabi_ehm__try_terminate\n"
	"	.uleb128 .TRYEND-.TRYSTART\n"
	"	.uleb128 .CATCH-__cfaabi_ehm__try_terminate\n"
	"	.uleb128 1\n"
	".LLSDACSECFA2:\n"
	// TABLE FOOTER
	"	.text\n"
	"	.size	__cfaabi_ehm__try_terminate, .-__cfaabi_ehm__try_terminate\n"
);

// Somehow this piece of helps with the resolution of debug symbols.
__attribute__((unused)) static const int dummy = 0;

asm (
	// Add a hidden symbol which points at the function.
	"	.hidden	CFA.ref.__gcfa_personality_v0\n"
	"	.weak	CFA.ref.__gcfa_personality_v0\n"
	// No clue what this does specifically
	"	.section	.data.rel.local.CFA.ref.__gcfa_personality_v0,\"awG\",@progbits,CFA.ref.__gcfa_personality_v0,comdat\n"
	"	.align 8\n"
	"	.type CFA.ref.__gcfa_personality_v0, @object\n"
	"	.size CFA.ref.__gcfa_personality_v0, 8\n"
	"CFA.ref.__gcfa_personality_v0:\n"
#if defined( __x86_64 )
	"	.quad __gcfa_personality_v0\n"
#else // then __i386
	"   .long __gcfa_personality_v0\n"
#endif
);
#else // __PIC__
asm (
	// HEADER
	".LFECFA1:\n"
	"	.globl	__gcfa_personality_v0\n"
	"	.section	.gcc_except_table,\"a\",@progbits\n"
	// TABLE HEADER (important field is the BODY length at the end)
	".LLSDACFA2:\n"
	"	.byte	0xff\n"
	"	.byte	0xff\n"
	"	.byte	0x1\n"
	"	.uleb128 .LLSDACSECFA2-.LLSDACSBCFA2\n"
	// BODY (language specific data)
	".LLSDACSBCFA2:\n"
	//	Handled area start (relative to start of function)
	"	.uleb128 .TRYSTART-__cfaabi_ehm__try_terminate\n"
	//	Handled area length
	"	.uleb128 .TRYEND-.TRYSTART\n"
	//	Handler landing pad address (relative to start of function)
	"	.uleb128 .CATCH-__cfaabi_ehm__try_terminate\n"
	//	Action code, gcc seems to always use 0.
	"	.uleb128 1\n"
	// TABLE FOOTER
	".LLSDACSECFA2:\n"
	"	.text\n"
	"	.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 // __PIC__

#pragma GCC pop_options