cppexcept.h File Reference

#include <fpieee.h>
#include "cxx.h"

Include dependency graph for cppexcept.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	ipmap_info
struct	catchblock_info
struct	tryblock_info
struct	unwind_info
struct	cxx_function_descr
struct	exception_ptr

Macros
#define	CXX_FRAME_MAGIC_VC6   0x19930520
#define	CXX_FRAME_MAGIC_VC7   0x19930521
#define	CXX_FRAME_MAGIC_VC8   0x19930522
#define	CXX_EXCEPTION   0xe06d7363
#define	CXX_EXCEPTION_PARAMS   4
#define	FUNC_DESCR_SYNCHRONOUS   1 /* synchronous exceptions only (built with /EHs and /EHsc) */
#define	FUNC_DESCR_NOEXCEPT   4 /* noexcept function */
#define	CLASS_IS_SIMPLE_TYPE   1
#define	CLASS_HAS_VIRTUAL_BASE_CLASS   4
#define	TYPE_FLAG_CONST   1
#define	TYPE_FLAG_VOLATILE   2
#define	TYPE_FLAG_REFERENCE   8
#define	TRACE_EXCEPTION_TYPE(type, base)
#define	EXCEPTION_MANGLED_NAME   ".?AVexception@@"
#define	CREATE_EXCEPTION_OBJECT(exception_name)

Functions
DECLSPEC_NORETURN void WINAPI	_CxxThrowException (void *, const cxx_exception_type *)
static BOOL	is_cxx_exception (EXCEPTION_RECORD *rec)
void	throw_exception (const char *)
void	exception_ptr_from_record (exception_ptr *, EXCEPTION_RECORD *)
void __cdecl	__ExceptionPtrCreate (exception_ptr *)
void __cdecl	__ExceptionPtrDestroy (exception_ptr *)
void __cdecl	__ExceptionPtrRethrow (const exception_ptr *)
BOOL __cdecl	__uncaught_exception (void)
static const char *	dbgstr_type_info (const type_info *info)
static void *	get_this_pointer (const this_ptr_offsets *off, void *object)
static void	call_copy_ctor (void *func, void *this, void *src, int has_vbase)
static void	call_dtor (void *func, void *this)
static const cxx_type_info *	find_caught_type (cxx_exception_type *exc_type, uintptr_t base, const type_info *catch_ti, UINT catch_flags)
static void	copy_exception (void *object, void **dest, UINT catch_flags, const cxx_type_info *type, uintptr_t base)
void	dump_function_descr (const cxx_function_descr *descr, uintptr_t base)
void *	find_catch_handler (void *object, uintptr_t frame, uintptr_t exc_base, const tryblock_info *tryblock, cxx_exception_type *exc_type, uintptr_t image_base)
int	handle_fpieee_flt (__msvcrt_ulong exception_code, EXCEPTION_POINTERS *ep, int(__cdecl *handler)(_FPIEEE_RECORD *))
void *	call_catch_handler (EXCEPTION_RECORD *rec)
void *	call_unwind_handler (void *func, uintptr_t frame, DISPATCHER_CONTEXT *dispatch)
ULONG_PTR	get_exception_pc (DISPATCHER_CONTEXT *dispatch)

Macro Definition Documentation

CLASS_HAS_VIRTUAL_BASE_CLASS

#define CLASS_HAS_VIRTUAL_BASE_CLASS   4

Definition at line 138 of file cppexcept.h.

CLASS_IS_SIMPLE_TYPE

#define CLASS_IS_SIMPLE_TYPE   1

Definition at line 137 of file cppexcept.h.

CREATE_EXCEPTION_OBJECT

#define CREATE_EXCEPTION_OBJECT

(

exception_name

)

Definition at line 300 of file cppexcept.h.

CXX_EXCEPTION

#define CXX_EXCEPTION   0xe06d7363

Definition at line 34 of file cppexcept.h.

CXX_EXCEPTION_PARAMS

#define CXX_EXCEPTION_PARAMS   4

Definition at line 89 of file cppexcept.h.

CXX_FRAME_MAGIC_VC6

#define CXX_FRAME_MAGIC_VC6   0x19930520

Definition at line 31 of file cppexcept.h.

CXX_FRAME_MAGIC_VC7

#define CXX_FRAME_MAGIC_VC7   0x19930521

Definition at line 32 of file cppexcept.h.

CXX_FRAME_MAGIC_VC8

#define CXX_FRAME_MAGIC_VC8   0x19930522

Definition at line 33 of file cppexcept.h.

EXCEPTION_MANGLED_NAME

#define EXCEPTION_MANGLED_NAME   ".?AVexception@@"

Definition at line 297 of file cppexcept.h.

FUNC_DESCR_NOEXCEPT

#define FUNC_DESCR_NOEXCEPT   4 /* noexcept function */

Definition at line 135 of file cppexcept.h.

FUNC_DESCR_SYNCHRONOUS

#define FUNC_DESCR_SYNCHRONOUS   1 /* synchronous exceptions only (built with /EHs and /EHsc) */

Definition at line 134 of file cppexcept.h.

TRACE_EXCEPTION_TYPE

#define TRACE_EXCEPTION_TYPE	(		type,
			base
	)

Value:

    do { \
    const cxx_type_info_table *table = rtti_rva( type->type_info_table, base ); \
    unsigned int i; \
    TRACE( "flags %x destr %p handler %p type info %p\n", \
           type->flags, rtti_rva( type->destructor, base ), \
           type->custom_handler ? rtti_rva( type->custom_handler, base ) : NULL, table ); \
    for (i = 0; i < table->count; i++) \
    { \
        const cxx_type_info *type = rtti_rva( table->info[i], base ); \
        const type_info *info = rtti_rva( type->type_info, base ); \
        TRACE( "    %d: flags %x type %p %s offsets %d,%d,%d size %d copy ctor %p\n", \
               i, type->flags, info, dbgstr_type_info( info ), \
               type->offsets.this_offset, type->offsets.vbase_descr, type->offsets.vbase_offset, \
               type->size, rtti_rva( type->copy_ctor, base )); \
    } \
} while(0)

Definition at line 265 of file cppexcept.h.

TYPE_FLAG_CONST

#define TYPE_FLAG_CONST   1

Definition at line 140 of file cppexcept.h.

TYPE_FLAG_REFERENCE

#define TYPE_FLAG_REFERENCE   8

Definition at line 142 of file cppexcept.h.

TYPE_FLAG_VOLATILE

#define TYPE_FLAG_VOLATILE   2

Definition at line 141 of file cppexcept.h.

Function Documentation

__ExceptionPtrCreate()

void __cdecl __ExceptionPtrCreate

(

exception_ptr *

)

__ExceptionPtrDestroy()

void __cdecl __ExceptionPtrDestroy

(

exception_ptr *

)

__ExceptionPtrRethrow()

void __cdecl __ExceptionPtrRethrow

(

const exception_ptr *

ep

)

Definition at line 1245 of file cpp.c.

{
    TRACE("(%p)\n", ep);
 
    if (!ep->rec)
    {
        static const char *exception_msg = "bad exception";
        exception e;
 
        exception_ctor(&e, &exception_msg);
        _CxxThrowException(&e, &exception_exception_type);
        return;
    }
 
    RaiseException(ep->rec->ExceptionCode, ep->rec->ExceptionFlags & (~EH_UNWINDING),
            ep->rec->NumberParameters, ep->rec->ExceptionInformation);
}

__uncaught_exception()

BOOL __cdecl __uncaught_exception

(

void

)

Definition at line 821 of file except.c.

{
    return msvcrt_get_thread_data()->processing_throw != 0;
}

_CxxThrowException()

DECLSPEC_NORETURN void WINAPI _CxxThrowException	(	void *	object,
		const cxx_exception_type *	type
	)

Definition at line 890 of file cpp.c.

{
    ULONG_PTR args[CXX_EXCEPTION_PARAMS];
 
    args[0] = CXX_FRAME_MAGIC_VC6;
    args[1] = (ULONG_PTR)object;
    args[2] = (ULONG_PTR)type;
    if (CXX_EXCEPTION_PARAMS == 4) args[3] = rtti_rva_base( type );
    for (;;) RaiseException( CXX_EXCEPTION, EXCEPTION_NONCONTINUABLE, CXX_EXCEPTION_PARAMS, args );
}

call_catch_handler()

void * call_catch_handler

(

EXCEPTION_RECORD *

rec

)

Referenced by call_catch_block().

call_copy_ctor()

static void call_copy_ctor ( void *  func, void *  this, void *  src, int  has_vbase  )

inlinestatic

Definition at line 200 of file cppexcept.h.

{
    if (has_vbase)
        ((void (__thiscall*)(void*, void*, BOOL))func)(this, src, 1);
    else
        ((void (__thiscall*)(void*, void*))func)(this, src);
}

Referenced by copy_exception().

call_dtor()

static void call_dtor ( void *  func, void *  this  )

inlinestatic

Definition at line 207 of file cppexcept.h.

{
    ((void (__thiscall*)(void*))func)( this );
}

Referenced by __DestructExceptionObject().

call_unwind_handler()

void * call_unwind_handler	(	void *	func,
		uintptr_t	frame,
		DISPATCHER_CONTEXT *	dispatch
	)

Referenced by cxx_local_unwind().

copy_exception()

static void copy_exception ( void *  object, void **  dest, UINT  catch_flags, const cxx_type_info *  type, uintptr_t  base  )

inlinestatic

Definition at line 241 of file cppexcept.h.

{
    if (catch_flags & TYPE_FLAG_REFERENCE)
    {
        *dest = get_this_pointer( &type->offsets, object );
    }
    else if (type->flags & CLASS_IS_SIMPLE_TYPE)
    {
        memmove( dest, object, type->size );
        /* if it is a pointer, adjust it */
        if (type->size == sizeof(void*)) *dest = get_this_pointer( &type->offsets, *dest );
    }
    else  /* copy the object */
    {
        if (type->copy_ctor)
            call_copy_ctor( rtti_rva( type->copy_ctor, base ), dest,
                            get_this_pointer( &type->offsets, object ),
                            (type->flags & CLASS_HAS_VIRTUAL_BASE_CLASS) );
        else
            memmove( dest, get_this_pointer( &type->offsets, object ), type->size );
    }
}

Referenced by __CxxExceptionFilter(), and find_catch_handler().

dbgstr_type_info()

static const char * dbgstr_type_info ( const type_info *  info )

inlinestatic

Definition at line 169 of file cppexcept.h.

{
    if (!info) return "{}";
    return wine_dbg_sprintf( "{vtable=%p name=%s (%s)}",
                             info->vtable, info->mangled, info->name ? info->name : "" );
}

Referenced by __RTDynamicCast(), dump_function_descr(), and dump_obj_locator().

dump_function_descr()

void dump_function_descr	(	const cxx_function_descr *	descr,
		uintptr_t	base
	)

Definition at line 50 of file except.c.

{
    unwind_info *unwind_table = rtti_rva( descr->unwind_table, base );
    tryblock_info *tryblock = rtti_rva( descr->tryblock, base );
    ipmap_info *ipmap = rtti_rva( descr->ipmap, base );
    UINT i, j;
 
    TRACE( "magic %x\n", descr->magic );
    TRACE( "unwind table: %p %d\n", unwind_table, descr->unwind_count );
    for (i = 0; i < descr->unwind_count; i++)
    {
        TRACE("    %d: prev %d func %p\n", i, unwind_table[i].prev,
              unwind_table[i].handler ? rtti_rva( unwind_table[i].handler, base ) : NULL );
    }
    TRACE( "try table: %p %d\n", tryblock, descr->tryblock_count );
    for (i = 0; i < descr->tryblock_count; i++)
    {
        catchblock_info *catchblock = rtti_rva( tryblock[i].catchblock, base );
 
        TRACE( "    %d: start %d end %d catchlevel %d catch %p %d\n", i,
               tryblock[i].start_level, tryblock[i].end_level,
               tryblock[i].catch_level, catchblock, tryblock[i].catchblock_count);
        for (j = 0; j < tryblock[i].catchblock_count; j++)
        {
            type_info *type_info = catchblock[j].type_info ? rtti_rva( catchblock[j].type_info, base ) : NULL;
            TRACE( "        %d: flags %x offset %d handler %p",
                   j, catchblock[j].flags, catchblock[j].offset,
                   catchblock[j].handler ? rtti_rva(catchblock[j].handler, base) : NULL );
#ifdef _WIN64
            TRACE( " frame %x", catchblock[j].frame );
#endif
            TRACE( " type %p %s\n", type_info, dbgstr_type_info(type_info) );
        }
    }
    TRACE( "ipmap: %p %d\n", ipmap, descr->ipmap_count );
    for (i = 0; i < descr->ipmap_count; i++)
        TRACE( "    %d: ip %x state %d\n", i, ipmap[i].ip, ipmap[i].state );
#ifdef RTTI_USE_RVA
    TRACE( "unwind_help %+d\n", descr->unwind_help );
#endif
    if (descr->magic <= CXX_FRAME_MAGIC_VC6) return;
    TRACE( "expect list: %p\n", rtti_rva( descr->expect_list, base ) );
    if (descr->magic <= CXX_FRAME_MAGIC_VC7) return;
    TRACE( "flags: %08x\n", descr->flags );
}

Referenced by cxx_frame_handler().

exception_ptr_from_record()

void exception_ptr_from_record	(	exception_ptr *	,
		EXCEPTION_RECORD *
	)

find_catch_handler()

void * find_catch_handler	(	void *	object,
		uintptr_t	frame,
		uintptr_t	exc_base,
		const tryblock_info *	tryblock,
		cxx_exception_type *	exc_type,
		uintptr_t	image_base
	)

Definition at line 96 of file except.c.

{
    unsigned int i;
    const catchblock_info *catchblock = rtti_rva( tryblock->catchblock, image_base );
    const cxx_type_info *type;
    const type_info *catch_ti;
 
    for (i = 0; i < tryblock->catchblock_count; i++)
    {
        if (exc_type)
        {
            catch_ti = catchblock[i].type_info ? rtti_rva( catchblock[i].type_info, image_base ) : NULL;
            type = find_caught_type( exc_type, exc_base, catch_ti, catchblock[i].flags );
            if (!type) continue;
 
            TRACE( "matched type %p in catchblock %d\n", type, i );
 
            if (catch_ti && catch_ti->mangled[0] && catchblock[i].offset)
            {
                /* copy the exception to its destination on the stack */
                void **dest = (void **)(frame + catchblock[i].offset);
                copy_exception( object, dest, catchblock[i].flags, type, exc_base );
            }
        }
        else
        {
            /* no CXX_EXCEPTION only proceed with a catch(...) block*/
            if (catchblock[i].type_info) continue;
            TRACE( "found catch(...) block\n" );
        }
        return rtti_rva( catchblock[i].handler, image_base );
    }
    return NULL;
}

Referenced by find_catch_block().

find_caught_type()

static const cxx_type_info * find_caught_type ( cxx_exception_type *  exc_type, uintptr_t  base, const type_info *  catch_ti, UINT  catch_flags  )

inlinestatic

Definition at line 214 of file cppexcept.h.

{
    const cxx_type_info_table *type_info_table = rtti_rva( exc_type->type_info_table, base );
    UINT i;
 
    for (i = 0; i < type_info_table->count; i++)
    {
        const cxx_type_info *type = rtti_rva( type_info_table->info[i], base );
        const type_info *ti = rtti_rva( type->type_info, base );
 
        if (!catch_ti) return type;   /* catch(...) matches any type */
        if (catch_ti != ti)
        {
            if (strcmp( catch_ti->mangled, ti->mangled )) continue;
        }
        /* type is the same, now check the flags */
        if ((exc_type->flags & TYPE_FLAG_CONST) &&
            !(catch_flags & TYPE_FLAG_CONST)) continue;
        if ((exc_type->flags & TYPE_FLAG_VOLATILE) &&
            !(catch_flags & TYPE_FLAG_VOLATILE)) continue;
        return type;  /* it matched */
    }
    return NULL;
}

Referenced by __CxxExceptionFilter(), and find_catch_handler().

get_exception_pc()

ULONG_PTR get_exception_pc

(

DISPATCHER_CONTEXT *

dispatch

)

Referenced by cxx_frame_handler(), cxx_local_unwind(), and find_catch_block().

get_this_pointer()

static void * get_this_pointer ( const this_ptr_offsets *  off, void *  object  )

inlinestatic

Definition at line 177 of file cppexcept.h.

{
    if (!object) return NULL;
 
    if (off->vbase_descr >= 0)
    {
        int *offset_ptr;
 
        /* move this ptr to vbase descriptor */
        object = (char *)object + off->vbase_descr;
        /* and fetch additional offset from vbase descriptor */
        offset_ptr = (int *)(*(char **)object + off->vbase_offset);
        object = (char *)object + *offset_ptr;
    }
 
    object = (char *)object + off->this_offset;
    return object;
}

Referenced by __RTDynamicCast(), and copy_exception().

handle_fpieee_flt()

int handle_fpieee_flt	(	__msvcrt_ulong	exception_code,
		EXCEPTION_POINTERS *	ep,
		int(__cdecl *handler)(_FPIEEE_RECORD *)
	)

Referenced by _fpieee_flt().

is_cxx_exception()

static BOOL is_cxx_exception ( EXCEPTION_RECORD *  rec )

inlinestatic

Definition at line 146 of file cppexcept.h.

{
    if (rec->ExceptionCode != CXX_EXCEPTION) return FALSE;
    if (rec->NumberParameters != CXX_EXCEPTION_PARAMS) return FALSE;
    return (rec->ExceptionInformation[0] >= CXX_FRAME_MAGIC_VC6 &&
            rec->ExceptionInformation[0] <= CXX_FRAME_MAGIC_VC8);
}

Referenced by __CxxDetectRethrow(), __CxxExceptionFilter(), and __DestructExceptionObject().

throw_exception()

void throw_exception

(

const char *

msg

)

Definition at line 606 of file cpp.c.

{
    exception e;
    __exception_ctor(&e, msg, &exception_vtable);
    _CxxThrowException(&e, &exception_exception_type);
}