SEH for gcc

seh.cc

/*
Copyright (c) 2012- kikairoya

Boost Software License - Version 1.0 - August 17th, 2003

Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following:

The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by
a source language processor.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE. 
*/

#include <stdio.h>
#include <windows.h>
#include <excpt.h>
#include <functional>

#pragma GCC optimize ("no-omit-frame-pointer")

//#define SEH_NO_CALL_DESTRUCTORS

#define SEH_ENABLE_TRACE

#ifdef SEH_ENABLE_TRACE
#define SEH_TRACE_2(line, func, ...) (printf("trace %d (%s): ", line, func), printf(__VA_ARGS__))
#else
#define SEH_TRACE_2(...) ((void)0, (int)0)
#endif
#define SEH_TRACE_1(line, func, ...) SEH_TRACE_2(line, func, __VA_ARGS__)
#define SEH_TRACE(...) SEH_TRACE_1(__LINE__, __func__, __VA_ARGS__)

volatile unsigned long *start_esp;

void dump_stack(const char *name) {
	volatile unsigned long *end_esp;
	asm volatile ("mov %%esp, %0": "=g"(end_esp));
	FILE *fp = fopen(name, "w");
	while (start_esp > end_esp) {
		fprintf(fp, "%p: %08lX %08lX %08lX %08lX\n", end_esp, end_esp[0], end_esp[1], end_esp[2], end_esp[3]);
		end_esp += 4;
	}
	fclose(fp);
}

namespace seh {
	struct simple_safe_bool_t_base;
	typedef simple_safe_bool_t_base *simple_safe_bool_t;

	struct seh_jmp_context;
	int __attribute__((__returns_twice__)) seh_setjmp(volatile seh_jmp_context &);
	int __attribute__((__noreturn__)) seh_longjmp(const volatile seh_jmp_context &, int);

	struct seh_unwinder { };

	struct at_scope_exit {
		template <typename F>
		at_scope_exit(const F &f): f(f) { SEH_TRACE("register at_scope_exit %p\n", &this->f); }
		at_scope_exit() = default;
		~at_scope_exit() throw (seh_unwinder) {
			if (f) {
				SEH_TRACE("execute at_scope_exit %p\n", &f);
				const auto g = f;
				f = []{};
				g();
			}
		}
		std::function<void ()> f;
		operator simple_safe_bool_t() const volatile { return 0; }
	};

	enum class unwind_state {
		normal_exit,
		unwinding,
		unwind_to_here,
	};

	__attribute__((noreturn)) void throw_seh_unwinder() {
		throw seh_unwinder();
	}

	template <typename T>
	struct value_wrapper {
		T &operator ()() { return v; }
		volatile T &operator ()() volatile { return v; }
		const T &operator ()() const { return v; }
		const volatile T &operator ()() const volatile { return v; }
		value_wrapper(const T &v): v(v) { }
		T v;
		operator simple_safe_bool_t() const volatile { return 0; }
	};
	template <typename T, typename U>
	inline bool operator ==(const value_wrapper<T> &x, const value_wrapper<U> &y) { return x.v == y.v; }
	template <typename T, typename U>
	inline bool operator ==(const value_wrapper<T> &x, const U &y) { return x.v == y; }
	template <typename T, typename U>
	inline bool operator ==(const T &x, const value_wrapper<U> &y) { return x == y.v; }

	struct stack_tracer {
		__attribute__((noinline)) static uintptr_t get_ebp() {
			uintptr_t r;
			asm volatile ("mov (%%ebp), %0" : "=r"(r) : : "cc");
			return r;
		}
		typedef uintptr_t reg_t;
		reg_t ebp;
		stack_tracer(reg_t r = get_ebp()): ebp(r) { }
		static uintptr_t dereference(uintptr_t r) { return *reinterpret_cast<uintptr_t *>(r); }
		stack_tracer &operator ++() {
			ebp = dereference(ebp);
			return *this;
		}
		stack_tracer operator ++(int) {
			stack_tracer o(*this);
			++*this;
			return o;
		}
		uintptr_t get_callee() const { return dereference(ebp+sizeof(ebp)); }
	};
}

#ifdef __x86_64__

#error x86_64 target is not supported.

#undef __try
#define __try try

#undef __except
#define __except(filter) catch (::seh::seh_unwinder &)

#undef __finally
#define __finally catch (...)

#else

namespace seh {

	struct seh_jmp_context {
		uintptr_t ebp;
		uintptr_t ebx;
		uintptr_t edi;
		uintptr_t esi;
		uintptr_t esp;
		uintptr_t eip;
	};

	void print_jb(const seh_jmp_context &jb) {
		printf("jmp_buf(%p):\n"
			   " ebp=%x\n"
			   " ebx=%x\n"
			   " edi=%x\n"
			   " esi=%x\n"
			   " esp=%x\n"
			   " eip=%x\n",
			   &jb, jb.ebp, jb.ebx, jb.edi, jb.esi, jb.esp, jb.eip);
	}

	void print_ctx(const CONTEXT *pctx) {
		printf("CONTEXT(%p):\n"
			   " ebp=%lx\n"
			   " ebx=%lx\n"
			   " edi=%lx\n"
			   " esi=%lx\n"
			   " esp=%lx\n"
			   " eip=%lx\n",
			   pctx, pctx->Ebp, pctx->Ebx, pctx->Edi, pctx->Esi, pctx->Esp, pctx->Eip);
	}

	struct exception_registration {
		exception_registration *prev;
		int (*handler)(PEXCEPTION_RECORD rec, exception_registration *reg, PCONTEXT ctx, void *);
		unsigned magic;
		seh_jmp_context jb_try;
		EXCEPTION_POINTERS ptrs;
		exception_registration *chain;
		std::function<int ()> filter;
		unwind_state state;
		operator simple_safe_bool_t() const volatile { return 0; }
	};

	__attribute__((noreturn)) void throw_seh_unwinder(const seh_jmp_context &b) {
		asm volatile (
			"movl %[bp], %%ebp\n\t"
			"pushl %[ip]\n\t"
			"jmp __ZN3seh18throw_seh_unwinderEv"
			:
			: [bp]"g"(b.ebp), [ip]"r"(b.eip), "b"(b.ebx), "S"(b.esi), "D"(b.edi)
			: "memory");
		__builtin_unreachable();
	}
	__attribute__((noreturn)) void throw_seh_unwinder(PCONTEXT pctx) {
		seh_jmp_context b;
		b.ebx = pctx->Ebx;
		b.esi = pctx->Esi;
		b.edi = pctx->Edi;
		b.ebp = pctx->Ebp;
		b.esp = pctx->Esp;
		b.eip = pctx->Eip;
		throw_seh_unwinder(b);
		__builtin_unreachable();
	}

	exception_registration *search_except_block(exception_registration *reg, int &code) {
		if (reg->chain) {
			reg->chain->ptrs = reg->ptrs;
			exception_registration *p = search_except_block(reg->chain, code);
			if (p) return p;
		}
		
		code = reg->filter();
		return code ? reg : 0;
	}

	int exception_handler(PEXCEPTION_RECORD prec, exception_registration *reg,  PCONTEXT pctx, void *xxx) {
		static __thread seh_jmp_context leaf_jb;
		static __thread unsigned char *volatile callee_stack_top;
		static __thread unsigned char *volatile save_stack_ptr;

		SEH_TRACE("args: (%p, %p, %p, %p), exception: %x, flags: %x, eip: %p, ebp: %p\n",
			   prec, reg, pctx, xxx,
			   (unsigned)prec->ExceptionCode, (unsigned)prec->ExceptionFlags, (void*)pctx->Eip, (void*)pctx->Ebp);

		if (prec->ExceptionFlags & EXCEPTION_UNWINDING) {
			if (reg->chain) exception_handler(prec, reg->chain, pctx, xxx);

			SEH_TRACE("unwind step %p\n", reg);
			reg->state = unwind_state::unwinding;
#ifndef SEH_NO_CALL_DESTRUCTORS
			seh_jmp_context r = leaf_jb;
#endif
			leaf_jb = reg->jb_try;

			if (seh_setjmp(reg->jb_try)) {
				asm ("": : : "memory");
				SEH_TRACE("restore %d bytes from %p to %p\n", callee_stack_top - (unsigned char *)__builtin_frame_address(0), save_stack_ptr, (unsigned char *)__builtin_frame_address(0));
				memcpy(__builtin_frame_address(0), save_stack_ptr, callee_stack_top - (unsigned char *)__builtin_frame_address(0));
				asm ("": : : "memory");
				free(save_stack_ptr);
				save_stack_ptr = 0;
				SEH_TRACE("finish unwind %p\n", reg);
				return 1;
			} else {
				save_stack_ptr = (unsigned char *)malloc(callee_stack_top - (unsigned char *)__builtin_frame_address(0));
				SEH_TRACE("save %d bytes from %p to %p\n", callee_stack_top - (unsigned char *)__builtin_frame_address(0), (unsigned char *)__builtin_frame_address(0), save_stack_ptr);
				memcpy(save_stack_ptr, __builtin_frame_address(0), callee_stack_top - (unsigned char *)__builtin_frame_address(0));
#ifdef SEH_NO_CALL_DESTRUCTORS
				seh_longjmp(leaf_jb, 1);
#else
				throw_seh_unwinder(r);
#endif
			}
			__builtin_unreachable();
		}
		if (prec->ExceptionFlags & EXCEPTION_NONCONTINUABLE) {
			return 1;
		}

		reg->ptrs.ExceptionRecord = prec;
		reg->ptrs.ContextRecord = pctx;

		int code = 0;
		exception_registration *p = search_except_block(reg, code);
		if (!p || p->magic != 0xDEADBEEF) return 1;
		if (code < 0) return 0;

		callee_stack_top = (unsigned char *)__builtin_frame_address(1);
		save_stack_ptr = 0;
#ifndef SEH_NO_CALL_DESTRUCTORS
		leaf_jb.ebx = pctx->Ebx;
		leaf_jb.edi = pctx->Edi;
		leaf_jb.esi = pctx->Esi;
		leaf_jb.ebp = pctx->Ebp;
		leaf_jb.esp = pctx->Esp;
		leaf_jb.eip = pctx->Eip;
#endif
		SEH_TRACE("start unwind\n");
		asm volatile (
			"pushl $0\n\t"
			"pushl $0\n\t"
			"pushl $1f\n\t"
			"pushl %0\n\t"
			"call _RtlUnwind@16\n\t"
			"1: nop\n\t"
			:
			: "a"(reg)
			: "ecx", "edx", "ebx", "esi", "edi", "esp", "cc", "memory"
			);
		SEH_TRACE("finish unwind\n");
		p->state = unwind_state::unwind_to_here;
#ifdef SEH_NO_CALL_DESTRUCTORS
		seh_longjmp(p->jb_try, 1);
#else
		throw_seh_unwinder(leaf_jb);
#endif
		__builtin_unreachable();
	}

#define _exception_info() ((EXCEPTION_POINTERS *)&seh_exc_reg.ptrs)
#define _exception_code() (seh_exc_reg.ptrs.ExceptionRecord->ExceptionCode)
#define _abnormal_termination() (seh_exc_reg.state != ::seh::unwind_state::normal_exit)

	struct seh_register_helper {
		seh_register_helper(exception_registration &seh_exc_reg, exception_registration &prev): seh_exc_reg(seh_exc_reg), prev(prev) {
			if (!prev.filter) {
				asm volatile ("movl %%fs:0, %0\n\t"
							  "movl %1, %%fs:0"
							  : "=&r"(seh_exc_reg.prev)
							  : "r"(&seh_exc_reg)
							  : "cc");
			} else {
				prev.chain = &seh_exc_reg;
			}
			SEH_TRACE("register %p\n", &seh_exc_reg);
		}
		seh_register_helper(const seh_register_helper &) = delete;
		~seh_register_helper() {
			if (!prev.filter) asm volatile ("movl %0, %%fs:0" : : "r" (seh_exc_reg.prev): "cc"); \
			else prev.chain = 0; \
			SEH_TRACE("unregister %p\n", &seh_exc_reg);
		}
		exception_registration &seh_exc_reg;
		exception_registration &prev;
		operator simple_safe_bool_t() const volatile { return 0; }
	};
}

#undef __try
#ifdef SEH_NO_CALL_DESTRUCTORS
#define __try \
	if (::seh::value_wrapper< ::seh::exception_registration &> seh_prev_reg = seh_exc_reg) ; \
	else if (::seh::exception_registration seh_exc_reg = { 0, &::seh::exception_handler, 0xDEADBEEF, {0}, {0}}); \
	else if (::seh::seh_register_helper seh_reg_help = {seh_exc_reg, seh_prev_reg()}); \
	else if (::seh::at_scope_exit seh_finally_hopper = []{}) ; \
	else if (::seh::value_wrapper<int> seh_state = ::seh::seh_setjmp(seh_exc_reg.jb_try)) ;\
	else if (seh_state == 3)
#else
#define __try \
	if (::seh::value_wrapper< ::seh::exception_registration &> seh_prev_reg = seh_exc_reg) ; \
	else if (::seh::exception_registration seh_exc_reg = { 0, &::seh::exception_handler, 0xDEADBEEF, {0}, {0}}); \
	else if (::seh::seh_register_helper seh_reg_help = {seh_exc_reg, seh_prev_reg()}); \
	else if (::seh::at_scope_exit seh_finally_hopper = []{}) ; \
	else if (::seh::value_wrapper<int> seh_state = ::seh::seh_setjmp(seh_exc_reg.jb_try)) ;\
	else if (seh_state == 3) try
#endif

#undef __except
#ifdef SEH_NO_CALL_DESTRUCTORS
#define __except_1(filter_expr, line) \
	else if (seh_state == 0) { \
		seh_exc_reg.filter = [&] { return filter_expr; }; \
		SEH_TRACE("start __try\n");\
		::seh::seh_longjmp(seh_exc_reg.jb_try, 3); \
	} else if (seh_state == 1) { \
		seh_state = 2; \
		if (seh_exc_reg.state != ::seh::unwind_state::unwind_to_here) ::seh::seh_longjmp(seh_exc_reg.jb_try, 1); \
		else goto seh_label ## line; \
	} else seh_label ## line: if (seh_state == 2)
#else
#define __except_1(filter_expr, line) \
	catch (::seh::seh_unwinder &) { \
		SEH_TRACE("catch(except)\n"); \
		seh_state = 2; \
		if (seh_exc_reg.state == ::seh::unwind_state::unwind_to_here) { SEH_TRACE("start __except\n"); goto seh_label ## line; } \
		else seh_finally_hopper.f = [&seh_exc_reg] { ::seh::seh_longjmp(seh_exc_reg.jb_try, 1); }; \
	} else if (seh_state == 0) { \
		seh_exc_reg.filter = [&] { return filter_expr; }; \
		SEH_TRACE("start __try\n");\
		::seh::seh_longjmp(seh_exc_reg.jb_try, 3); \
	} else if (seh_state == 1) { \
		if (seh_exc_reg.state != ::seh::unwind_state::unwind_to_here) ::seh::seh_longjmp(seh_exc_reg.jb_try, 1); \
	} else seh_label ## line: if (seh_state == 2)
#endif

#define __except_2(filter_expr, line) __except_1(filter_expr, line)
#define __except(filter_expr) __except_2(filter_expr, __LINE__)

#undef __finally
#ifdef SEH_NO_CALL_DESTRUCTORS
#define __finally_1(line) \
	else if (seh_state == 0) { \
		seh_exc_reg.filter = [] { return 0; }; \
		seh_finally_hopper.f = [&seh_exc_reg] { \
			SEH_TRACE("start __finally\n");\
			::seh::seh_longjmp(seh_exc_reg.jb_try, 4); \
		}; \
		SEH_TRACE("start __try\n");\
		::seh::seh_longjmp(seh_exc_reg.jb_try, 3); \
	} else if (seh_state == 1) { \
		seh_finally_hopper.f = [&seh_exc_reg] { ::seh::seh_longjmp(seh_exc_reg.jb_try, 1); }; \
		seh_state = 4; \
		goto seh_label ## line; \
	} else seh_label ## line: if (seh_state == 4)
#else
#define __finally_1(line) \
	catch (::seh::seh_unwinder &) { \
		SEH_TRACE("catch(finally)\n"); \
		seh_finally_hopper.f = [&seh_exc_reg] { ::seh::seh_longjmp(seh_exc_reg.jb_try, 1); }; \
		seh_state = 4; \
		goto seh_label ## line; \
	} else if (seh_state == 0) { \
		seh_exc_reg.filter = [] { return 0; }; \
		seh_finally_hopper.f = [&seh_exc_reg] { \
			SEH_TRACE("start __finally\n");\
			::seh::seh_longjmp(seh_exc_reg.jb_try, 4); \
		}; \
		SEH_TRACE("start __try\n");\
		::seh::seh_longjmp(seh_exc_reg.jb_try, 3); \
	} else if (seh_state == 1) { \
		seh_finally_hopper.f = [&seh_exc_reg] { ::seh::seh_longjmp(seh_exc_reg.jb_try, 1); }; \
	} else seh_label ## line: if (seh_state == 4)
#endif

#define __finally_2(line) __finally_1(line)
#define __finally __finally_2(__LINE__)

#undef __leave
#define __leave (throw (SEH_TRACE("leave %p\n", &seh_exc_reg), ::seh::seh_unwinder()))

extern ::seh::exception_registration seh_exc_reg;


#endif

int filter(unsigned int code, volatile _EXCEPTION_POINTERS *ep) {
	printf("in filter. code: %x\n", code);
	if (code == EXCEPTION_ACCESS_VIOLATION) {
		puts("caught AV as expected.");
		return EXCEPTION_EXECUTE_HANDLER;
	} else {
		puts("didn't catch AV, unexpected.");
		return EXCEPTION_CONTINUE_SEARCH;
	};
}

void fn_5(volatile int *p) {
	seh::at_scope_exit f = [] { puts(" this line should appear between throw and 3:c++ catch"); };
	// needs -fnon-call-exceptions
	*p = 0;
}

void fn_3(volatile int *p) {
	__try {
		puts("3:in try");
		__try {
			puts("4:in try");
			__try {
				puts("5: in try");
				fn_5(p);
				//__leave;
				*p = 0;
				RaiseException(0xC0000005, 0, 0, 0);
			} __except(0) {
				puts("5: in except");
			}
		} __finally {
			puts("4:in finally");
		}
		*p = 0;
	} __except(0) {
		puts("3:in except");
	}
}

void fn_4() {
	seh::at_scope_exit f = [] { puts(" this line should appear between 3:unreg and 2:c++ catch"); };
	fn_3(0);
}

void fn_2() {
	int p = 0;
	// test: force grow stack
	volatile int large[1024];
	for (int n = 0; n < 1024; ++n) large[n] = n;
	__try {
		puts("2:in try");
		fn_4();
	} __finally {
		puts("2:in finally");
		for (int n = 0; n < 1024; ++n) p += large[n];
		printf("%d\n", p);
		
	}
}

int main() {
	asm volatile ("mov %%esp, %0": "=g"(start_esp));
	printf("%d\n", sizeof(seh::exception_registration::filter));
	puts("hello");
	__try {
		puts("1:in try");
		fn_2();
	} __except (filter(GetExceptionCode(), GetExceptionInformation())) {
		puts("1:in except");
	}
	puts("leave try");
	puts("world");
	return 0;
}


#ifdef __x86_64__

#else

::seh::exception_registration seh_exc_reg;

asm(".section .text");
asm(".global __ZN3seh10seh_setjmpERVNS_15seh_jmp_contextE");
asm("__ZN3seh10seh_setjmpERVNS_15seh_jmp_contextE:");
asm("movl	4(%esp), %ecx");
asm("movl	%ebp, 0(%ecx)");
asm("movl	%ebx, 4(%ecx)");
asm("movl	%edi, 8(%ecx)");
asm("movl	%esi, 12(%ecx)");
asm("popl	%edx");
asm("movl	%esp, 16(%ecx)");
asm("movl	%edx, 20(%ecx)");
asm("xorl	%eax, %eax");
asm("jmp	*%edx");

asm(".global __ZN3seh11seh_longjmpERVKNS_15seh_jmp_contextEi");
asm("__ZN3seh11seh_longjmpERVKNS_15seh_jmp_contextEi:");
asm("movl	8(%esp), %eax");
asm("movl	4(%esp), %ecx");
asm("movl	0(%ecx), %ebp");
asm("movl	4(%ecx), %ebx");
asm("movl	8(%ecx), %edi");
asm("movl	12(%ecx), %esi");
asm("movl	16(%ecx), %esp");
asm("jmp	*20(%ecx)");

#endif

This is amazing work!

Would it be possible to include an explicit license in it?

Added the sentence of Boost Software License.

💯

Thank you!