Index: doc/working/exception/impl/except.c
===================================================================
--- doc/working/exception/impl/except.c	(revision 6065b3aad7ca045ec48fc6103d1c55f0b5fb74b0)
+++ doc/working/exception/impl/except.c	(revision 49c977357660cc1dd2b3d7775733ba7cdc52aa4c)
@@ -97,8 +97,9 @@
 					//is way more expansive than we might like
 					//The information we have is :
-					//  - The GR (???)
+					//  - The GR (Series of registers)
+					//    GR1=GP Global Pointer of frame ref by context
 					//  - The instruction pointer
 					//  - The instruction pointer info (???)
-					//  - The CFA (???)
+					//  - The CFA (Canonical Frame Address)
 					//  - The BSP (Probably the base stack pointer)
 
Index: doc/working/exception/impl/main.c
===================================================================
--- doc/working/exception/impl/main.c	(revision 6065b3aad7ca045ec48fc6103d1c55f0b5fb74b0)
+++ doc/working/exception/impl/main.c	(revision 49c977357660cc1dd2b3d7775733ba7cdc52aa4c)
@@ -33,4 +33,5 @@
 //libcfa but there is one problem left, see the exception table 
 //for details
+__attribute__((noinline))
 void try( void (*try_block)(), void (*catch_block)() )
 {
@@ -129,5 +130,5 @@
 	raii_t a = { "Main dtor" };
 
-	foo();
+	for (unsigned int i = 0 ; i < 100000000 ; ++i) foo();
 
 	printf("End of program reached\n");
Index: doc/working/exception/impl/resume-main.c
===================================================================
--- doc/working/exception/impl/resume-main.c	(revision 49c977357660cc1dd2b3d7775733ba7cdc52aa4c)
+++ doc/working/exception/impl/resume-main.c	(revision 49c977357660cc1dd2b3d7775733ba7cdc52aa4c)
@@ -0,0 +1,152 @@
+#include <stdio.h>
+#include <stdbool.h>
+
+// Proof of concept for resumption exception handling.
+// Names, checks promises and so on all would have to be improved.
+
+struct resume_group;
+
+// Stackwise information (global for single stack)
+struct code_stack_data {
+	struct resume_group * top_resume;
+	struct resume_group * current_resume;
+} stack = {NULL, NULL};
+
+// private exception header begin ============================================
+
+struct resume_group {
+	struct resume_group * next;
+	bool (*try_to_handle)(int);
+};
+
+void __resume_group_dtor(struct resume_group * this) {
+	stack.top_resume = this->next;
+}
+
+void __cfa_eh__throw_resume(int except) {
+	struct resume_group * original_head = stack.current_resume;
+	struct resume_group * current =
+		(original_head) ? original_head->next : stack.top_resume;
+
+	for ( ; current ; current = current->next) {
+		stack.current_resume = current;
+		if (current->try_to_handle(except)) {
+			stack.current_resume = original_head;
+			return;
+		}
+	}
+
+	printf("Unhandled exception %d\n", except);
+}
+
+// private exception header end ==============================================
+
+// Set up of unwind checker type.
+struct type_raii_t {
+	char * msg;
+};
+
+void dtor( struct type_raii_t * this ) {
+	printf("%s\n", this->msg);
+}
+
+#define raii_t __attribute__((cleanup(dtor))) struct type_raii_t
+
+void bar() {
+	raii_t a = { "Bar dtor" };
+
+	__cfa_eh__throw_resume( 3 );
+}
+
+void foo() {
+	raii_t a = { "Foo dtor" };
+
+	{
+		bool foo_catch_resume(int exception_id) {
+			if (exception_id == 3) {
+				printf("Exception caught\n");
+				return true;
+			}
+			return false;
+		}
+		struct resume_group __attribute__((cleanup(__resume_group_dtor)))
+			foo_try_resume = {stack.top_resume, foo_catch_resume};
+		stack.top_resume = &foo_try_resume;
+		{
+			raii_t b = { "Foo try dtor" };
+
+			bar();
+
+			printf("Called bar successfully\n");
+		}
+	}
+	printf( "Foo exited normally\n" );
+}
+
+// Not in main.cfa
+void foe() {
+	raii_t a = { "Foe dtor" };
+
+	printf("Foe throws\n");
+	__cfa_eh__throw_resume( 4 );
+
+	printf("Foe exits normally\n");
+}
+
+void fy() {
+	raii_t a = { "Fy dtor" };
+
+	{
+		bool fy_catch_resume(int exception_id) {
+			if (4 == exception_id) {
+				printf("Rethrow in fy\n");
+				__cfa_eh__throw_resume(exception_id);
+				return true;
+			}
+			return false;
+		}
+		struct resume_group __attribute__((cleanup(__resume_group_dtor)))
+			fy_try_resume = {stack.top_resume, fy_catch_resume};
+		stack.top_resume = &fy_try_resume;
+		{
+			raii_t b = { "Fy try dtor" };
+			foe();
+		}
+	}
+
+	printf("Fy exits normally\n");
+}
+
+void fee() {
+	raii_t a = { "Fee dtor" };
+
+	{
+		bool fee_catch_resume(int exception_id) {
+			if (4 == exception_id) {
+				printf("fee caught exception\n");
+				return true;
+			}
+			return false;
+		}
+		struct resume_group __attribute__((cleanup(__resume_group_dtor)))
+			fee_try_resume = {stack.top_resume, fee_catch_resume};
+		stack.top_resume = &fee_try_resume;
+		{
+			raii_t b = { "Fee try dtor" };
+			fy();
+		}
+	}
+
+	printf("Fee exits normally\n");
+}
+// End not in main.cfa
+
+int main() {
+	raii_t a = { "Main dtor" };
+
+	foo();
+
+	fee();
+
+	printf("End of program reached\n");
+}
Index: doc/working/exception/reference.c
===================================================================
--- doc/working/exception/reference.c	(revision 49c977357660cc1dd2b3d7775733ba7cdc52aa4c)
+++ doc/working/exception/reference.c	(revision 49c977357660cc1dd2b3d7775733ba7cdc52aa4c)
@@ -0,0 +1,125 @@
+// Reference to all sorts of information for exception handling.
+
+// C++ Interface to exception handlers.
+
+void * __cxa_allocate_exception(size_t thrown_size);
+// Creates space for the exception.
+
+void __cxa_free_exception(void * thrown_exception);
+
+void __cxa_throw(void * thrown_exception, struct type_info * tinfo,
+		void (*dest)(void*));
+// Throws the exception, is not supposed to return but ours should,
+// to handle resumption exceptions.
+
+void __cxa_begin_catch(); -> void * __cxa_begin_catch(void * exceptionObject);
+void __cxa_end_catch();
+// Not sure, beginning and end of catch block maybe?
+
+
+/* Unwind Module
+ * Full list: https://itanium-cxx-abi.github.io/cxx-abi/abi-eh.html
+ * Avaible at: /usr/lib/gcc/x86_64-linux-gnu/{5}/include/unwind.h
+ */
+
+typedef _Unwind_Reason_Code (*_Unwind_Personality_Fn)
+     (int, _Unwind_Action, _Unwind_Exception_Class,
+      struct _Unwind_Exception *, struct _Unwind_Context *);
+/* Type of the personality function, which does not have a set name.
+ *   So far `__gcfa_personality_v0` has been used.
+ * Called by _Unwind_RaiseException (called by __cxa_throw)
+ *   or by _Unwind_ForcedUnwind's personality wrapper.
+ * Params:
+ *   int version: Repersents unwind convention standard.
+ *   _Unwind_Action actions: Set of actions, used as instructions.
+ *   _Unwind_Exception_Class: 8-byte identifer: high 4 vendor, low 4 language.
+ *   _Unwind_Exception unwind_exception: Pointer to exception data.
+ *   _Unwind_Context context: Information on the current stack frame.
+ * Return:
+ *   _Unwind_Reason_Code: Requests an action from the unwinder.
+ */
+
+
+// _Unwind_Action flags (multiple may be set):
+_UA_SEARCH_PHASE  // Seaching for the handler
+_UA_CLEANUP_PHASE // Cleanup until handler found.
+_UA_HANDLER_FRAME // Previous search found handler here.
+_UA_FORCE_UNWIND  // Unwind, do not decide if we have reached the handler.
+_UA_END_OF_STACK  // We have reached the end of the stack.
+
+
+// _Unwind_Reason_Code values (one may be selected):
+_URC_NO_REASON          // Containues force unwind.
+_URC_FOREIGN_EXCEPTION_CAUGHT // Cross between runtime environments.
+_URC_FATAL_PHASE2_ERROR // Error in cleanup, not otherwise defined. (Rare?)
+_URC_FATAL_PHASE1_ERROR // Error in search, not otherwise defined.
+_URC_NORMAL_STOP
+_URC_END_OF_STACK       // eos found before a handler.
+_URC_HANDLER_FOUND      // Just the signal (search?)
+_URC_INSTALL_CONTEXT    // Handler found, resume execution (cleanup?)
+_URC_CONTINUE_UNWIND    // No handler found (search&cleanup)
+
+
+// Exception Header: (?)
+typedef void (*_Unwind_Exception_Cleanup_Fn)
+		(_Unwind_Reason_Code reason, struct _Unwind_Exception *exc);
+
+struct _Unwind_Exception {
+	uint64 exception_class;
+	_Unwind_Exception_Cleanup_Fn exception_cleanup;
+	uint64 private_1; // Do not access.
+	uint64 private_2; // Do not access.
+};
+
+
+// There are two functions to access the unwind "operation".
+// The standard exception handler, uses the personality function.
+_Unwind_Reason_Code _Unwind_RaiseException(
+	struct _Unwind_Exception * exception_object);
+
+// Helper for force unwind.
+typedef _Unwind_Reason_Code (*_Unwind_Stop_Fn)(
+	int version,
+	_Unwind_Action actions,
+	uint64 exceptionClass,
+	struct _Unwind_Exception * exceptionObject,
+	struct _Unwind_Context * context,
+	void * stop_parameter);
+
+// Special unwinder, wraps the personality function.
+_Unwind_Reason_Code _Unwind_ForcedUnwind(
+	struct _Unwind_Exception * exception_object,
+	_Unwind_Stop_Fn stop,
+	void * stop_parameter);
+
+// Continues unwinding
+void _Unwind_Resume(struct _Unwind_Exception * exception_object);
+// Seems to be for finally and deconstrctors, not so much rethrow.
+// However I haven't figured out the difference.
+
+
+/* _Unwind Helper functions:
+ *
+ * _Unwind_GetLanguageSpecificData - LSDA (destructors and landing pads)
+ * _Unwind_GetRegionStart - Function pointer to current stack frame.
+ * _Unwind_GetIP - Get frame's instruction pointer
+ *   This might be the actual function pointer or the call site up stack.
+ *
+ * All three have the same signature. */
+uint64 _Unwind_Get*(struct _Unwind_Context * context);
+
+void _Unwind_SetIP(struct _Unwind_Context * context, uint64 new_value);
+uint64 _Unwind_GetGR(struct _Unwind_Context * context, int index);
+void _Unwind_SetGR(struct _Unwind_Context * <>, int index, uint64 <>);
+// __builtin_eh_return_data_regno(^) ^=[0..3]? gives index.
+
+
+// GCC (Dwarf2 ?) Frame Layout Macros
+// https://gcc.gnu.org/onlinedocs/gccint/Frame-Layout.html
+
+FIRST_PARAM_OFFSET(fundecl)
+// Offset from argument pointer to first arguments address, or above that
+// address if ARGS_GROW_DOWNWARD.
+
+ARG_POINTER_CFA_OFFSET(fundecl)
+// Default: FIRST_PARM_OFFSET(fundecl) + crtl->args.pretend_args_size