Compiler Explorer

Source code

////////////////////////////////////////////////////////////////////////////
// P3166 "Static Exceptions"
// https://wg21.link/P3166
//
// This example explores how lowering of a static throw expression where the
// exception is caught locally might be implemented on an architecture that
// uses the Itanium C++ ABI for exception-handling.
//
// In particular, showing what the code-generation might be needed to support
// features like calling 'std::uncaught_exceptions()' during unwind and
// 'std::current_exception()' during the handler.
//
// These changes would require a corresponding change to the implementations of
// the Itanium C++ ABI functions to support a new 'exception_class' that corresponded
// to a static exception object that functions like __cxa_rethrow() or
// __cxa_get_exception_ptr() know that they need to on-demand copy the static
// exception object to a new dynamic exception object.
////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////
// The following switches allow exploring different code-gen / optimizations
// based on different situations in code - largely based on whether certain
// parts of the unwind and exception-handler are making opaque calls or can
// be inlined.
//
// Feel free to toggle on/off each of the settings to explore what the resulting
// code-generation looks like under the various scenarios.
////////////////////////////////////////////////////////////////////////////

// Whether or not there are opaque calls that run during unwind between the
// throw expression and the handler.
// This demonstrates whether or not the code for incrementing/decrementing
// the "uncaught exceptions" thread-local state can be optimized away when
// there are no opaque calls on the unwind path.
#define OPAQUE_CALLS_DURING_UNWIND 0 // 0 or 1

// Whether or not the constructor/destructor of the exception object should
// be an opaque call or whether it should be visible.
#define OPAQUE_EXCEPTION_OBJECT 0 // 0 or 1

// Whether or not there are opaque calls that run during the execution of the
// handler.
//
// This demonstrates the code-gen overhead needed for interaction with potential
// calls to uncaught_exceptions() or 'throw;' inside opaque calls within the
// body of the handler.
// We need to register an exception record with the Itanium ABI so that when someone
// calls __cxa_rethrow() that it can know where to find the current exception object
// to rethrow.
//
// If there are no opaque calls in the handler then the address of the local
// exception record does not escape and the compiler optimizes it away.
#define OPAQUE_CALLS_DURING_HANDLER 0 // 0 or 1

// The P3166 paper contains a section that explores the idea of a "catch static"
// handler which indicates to the compiler that the handler does not require
// the use of dynamic-rethrow expressions or `std::current_exception()` within
// the dynamic scope of the handler.
//
// This lets the compiler avoid needing to register information about the currently
// handled exception object with the thread-local state, regardless of whether there
// are opaque function-calls within the handler body. This can help reduce generated
// code-size for the handler.
//
// Set this macro to 1 to simulate what code-generation might look like if the
// user wrote a 'catch static' handler.
#define ENABLE_STATIC_CATCH 1 // 0 or 1

#include <cstdint>
#include <typeinfo>
#include <exception>

// Itanium ABI
extern "C" {

typedef void (*unexpected_handler)();

typedef enum {
	_URC_NO_REASON = 0,
	_URC_FOREIGN_EXCEPTION_CAUGHT = 1,
	_URC_FATAL_PHASE2_ERROR = 2,
	_URC_FATAL_PHASE1_ERROR = 3,
	_URC_NORMAL_STOP = 4,
	_URC_END_OF_STACK = 5,
	_URC_HANDLER_FOUND = 6,
	_URC_INSTALL_CONTEXT = 7,
	_URC_CONTINUE_UNWIND = 8
} _Unwind_Reason_Code;

typedef int _Unwind_Action;
inline const _Unwind_Action _UA_SEARCH_PHASE = 1;
inline const _Unwind_Action _UA_CLEANUP_PHASE = 2;
inline const _Unwind_Action _UA_HANDLER_FRAME = 4;
inline const _Unwind_Action _UA_FORCE_UNWIND = 8;

typedef void (*_Unwind_Exception_Cleanup_Fn)
    (_Unwind_Reason_Code reason,
        struct _Unwind_Exception *exc);

struct _Unwind_Exception {
	    uint64_t			 exception_class;
	    _Unwind_Exception_Cleanup_Fn exception_cleanup;
	    uint64_t			 private_1;
	    uint64_t			 private_2;
    };

_Unwind_Reason_Code _Unwind_RaiseException
	      ( struct _Unwind_Exception *exception_object );

typedef _Unwind_Reason_Code (*_Unwind_Stop_Fn)
		(int version,
		 _Unwind_Action actions,
		 uint64_t exceptionClass,
		 struct _Unwind_Exception *exceptionObject,
		 struct _Unwind_Context *context,
		 void *stop_parameter );

_Unwind_Reason_Code _Unwind_ForcedUnwind
	      ( struct _Unwind_Exception *exception_object,
		_Unwind_Stop_Fn stop,
		void *stop_parameter );

void _Unwind_DeleteException
	      (struct _Unwind_Exception *exception_object);

uint64_t _Unwind_GetGR
	    (struct _Unwind_Context *context, int index);

void _Unwind_SetGR
	  (struct _Unwind_Context *context,
	   int index,
	   uint64_t new_value);

uint64_t _Unwind_GetRegionStart
	    (struct _Unwind_Context *context);

typedef _Unwind_Reason_Code (*__personality_routine)
	    (int version,
	     _Unwind_Action actions,
	     uint64_t exceptionClass,
	     struct _Unwind_Exception *exceptionObject,
	     struct _Unwind_Context *context);

// Itanium C++ ABI

struct __cxa_exception { 
	const std::type_info *	exceptionType;
	void (*exceptionDestructor) (void *); 
	unexpected_handler	unexpectedHandler;
	std::terminate_handler	terminateHandler;
	__cxa_exception *	nextException;

int			handlerCount;
	int			handlerSwitchValue;
	const char *		actionRecord;
	const char *		languageSpecificData;
	void *			catchTemp;
	void *			adjustedPtr;

_Unwind_Exception	unwindHeader;
};

struct __cxa_eh_globals {
	__cxa_exception *	caughtExceptions;
	unsigned int		uncaughtExceptions;
};

// NOTE: I've added the annotations 'const' here as the implementation
// of these should always return the same value and has no observable side-effects
// from the perspective of the caller and so it's ok to elide the call if it's
// result is not used, or to cache the result of a prior call.
// These attribute enables all of the overhead of the exception control flow
// to be optimized away under ideal conditions.

// get pointer to thread-local - initializing if necessary
__attribute__((const)) __cxa_eh_globals *__cxa_get_globals(void);
// get pointer to thread-local - without initialization
__attribute__((const)) __cxa_eh_globals *__cxa_get_globals_fast(void);

void *__cxa_allocate_exception(size_t thrown_size);
void __cxa_free_exception(void* thrown_exception);
void __cxa_throw (void *thrown_exception, std::type_info *tinfo, void (*dest) (void *) );
void __cxa_rethrow ();

void* __cxa_begin_catch( void *exceptionObject );
void __cxa_end_catch ();
void* __cxa_get_exception_ptr( void *exceptionObject );
std::type_info* __cxa_current_exception_type ();

// raises std::bad_cast
[[noreturn]] void __cxa_bad_cast();
// raises std::bad_typeid
[[noreturn]] void __cxa_bad_typeid();

} // extern "C"

#include <new>
#include <memory>

namespace std
{
    inline int uncaught_exceptions() noexcept {
        return __cxa_get_globals()->uncaughtExceptions;
    }
}

//
// Helpers
// 
#if ENABLE_STATIC_CATCH

struct __static_eh_scope
{
    template<typename E>
    __static_eh_scope(__cxa_eh_globals* globals, E& ex) noexcept
    : __globals(globals)
    , __prev_ex(globals->caughtExceptions) {
        globals->caughtExceptions = nullptr;
    }

~__static_eh_scope() {
        __globals->caughtExceptions = __prev_ex;
    }

__cxa_eh_globals* __globals;
    __cxa_exception* __prev_ex;
};

#else

struct __static_eh_scope 
{
    __attribute__((const, noinline))
    static __cxa_exception _init_static_eh_record() noexcept {
        __cxa_exception ex;
        ex.exceptionType = nullptr;
        ex.exceptionDestructor = nullptr;
        ex.unexpectedHandler = nullptr;
        ex.terminateHandler = nullptr;
        ex.nextException = nullptr;
        ex.handlerCount = 1;
        ex.handlerSwitchValue = 0;
        ex.actionRecord = nullptr;
        ex.languageSpecificData = nullptr;
        ex.catchTemp = nullptr;
        ex.adjustedPtr = nullptr;
        __builtin_memcpy(
            &ex.unwindHeader.exception_class,
            "SExOC++", // static-exception object tag
            8);
        ex.unwindHeader.exception_cleanup = nullptr;
        ex.unwindHeader.private_1 = 0;
        ex.unwindHeader.private_2 = 0;
        return ex;
    }

template<typename E>
    __static_eh_scope(__cxa_eh_globals* globals, E& ex) noexcept
    :  __ex(_init_static_eh_record()) {
        obj = std::addressof(ex);
        __ex.exceptionType = &typeid(E);
        __ex.nextException = globals->caughtExceptions;
        // Assign some type-erased function that can be used to copy the object.
        __ex.adjustedPtr = reinterpret_cast<void*>(
            +[](void* dst, void* src) noexcept(noexcept(E(static_cast<const E&>(ex)))) {
                ::new(dst) E(*reinterpret_cast<const E*>(src));
            });
        globals->caughtExceptions = &__ex;
    }

~__static_eh_scope() {
        if (__globals->caughtExceptions == &__ex) {
            __globals->caughtExceptions = __ex.nextException;
        }
    }

__cxa_eh_globals* __globals;
    __cxa_exception __ex;
    void* obj;
};

#endif // !ENABLE_STATIC_CATCH

template<typename T>
union manual_lifetime {
    manual_lifetime() noexcept {}
    ~manual_lifetime() {}
    manual_lifetime(const manual_lifetime&) = delete;
    manual_lifetime(manual_lifetime&&) = delete;

T obj;
};

struct X {
    X() noexcept;
    ~X();
    X(const X& x) noexcept;

void print() noexcept
#if OPAQUE_CALLS_DURING_HANDLER
    ;
#else
    {}
#endif

int i;
};

#if !OPAQUE_CALLS_DURING_UNWIND
inline X::X(const X& x) noexcept : i(x.i) {}
#endif

#if !OPAQUE_EXCEPTION_OBJECT
inline X::X() noexcept : i(42) {}
inline X::~X() {}
#endif

// Simulate a scope_failure-style class that asks for the uncaught_exceptions()
// on construction and then again in the destructor and compares them.
struct Y {
    explicit Y(bool& failed) noexcept : failed(failed) {
        entry_uncaught = std::uncaught_exceptions();
    }
    ~Y();

bool& failed;
    int entry_uncaught;
};

#if !OPAQUE_CALLS_DURING_UNWIND
inline Y::~Y() {
    if (std::uncaught_exceptions() != entry_uncaught) {
        failed = true;
    }
}
#endif

//
// Example 1: Exception object thrown and caught locally
//
// With static exceptions paper this should be a guaranteed stack-allocated
// exception
// object.
//
bool local_throw_example() {
    bool failed = false;
    try {
        Y y(failed);
        throw X{};
    } catch /* static */ (X x)  {
        x.print();
    }
    return failed;
}

//
// The above example should get translated into something like the following.
//
bool local_throw_example_lowered() {
    __cxa_eh_globals* __eh_globals = nullptr;

manual_lifetime<X> __ex1;

bool failed = false;

{
        manual_lifetime<Y> y;

// Y y(failed);
        std::construct_at(&y.obj, failed);

// throw X{};
        std::construct_at(&__ex1.obj);
        __eh_globals = __cxa_get_globals();
        ++__eh_globals->uncaughtExceptions;

// exit scopes
        std::destroy_at(&y.obj);

// Transfer execution to handler
        goto __handler1;
    }

// catch(X)
    __handler1:
    {
        manual_lifetime<X> x;
        std::construct_at(&x.obj, __ex1.obj);

--__eh_globals->uncaughtExceptions;

{
            // Registers exception object on stack of handled exception objects
            // so that nested call to current_exception() inside some opaque call
            // does the right thing.
            __static_eh_scope __eh_scope(__eh_globals, __ex1.obj);

// handler body
            x.obj.print();
        }

// Destroy 'x' exception object from exception declaration
        std::destroy_at(&x.obj);
        // Destroy underlying static exception object
        std::destroy_at(&__ex1.obj);
    }

// after-catch

return failed;
}