exception_filter.cpp File Reference

#include <corecrt_internal.h>
#include <float.h>
#include <signal.h>
#include <stddef.h>

Include dependency graph for exception_filter.cpp:

Go to the source code of this file.

Functions
static __crt_signal_action_t *__cdecl	xcptlookup (unsigned long const xcptnum, __crt_signal_action_t *const action_table) throw ()
int __cdecl	_seh_filter_dll (unsigned long const xcptnum, PEXCEPTION_POINTERS const pxcptinfoptrs)
int __cdecl	_seh_filter_exe (unsigned long const xcptnum, PEXCEPTION_POINTERS const pxcptinfoptrs)

Variables
struct __crt_signal_action_t const	__acrt_exception_action_table []
size_t const	__acrt_signal_action_first_fpe_index = 3
size_t const	__acrt_signal_action_fpe_count = 9
size_t const	__acrt_signal_action_table_size = sizeof(__acrt_exception_action_table)
size_t const	__acrt_signal_action_table_count = sizeof(__acrt_exception_action_table) / sizeof(__acrt_exception_action_table[0])

Function Documentation

_seh_filter_dll()

int __cdecl _seh_filter_dll	(	unsigned long const	xcptnum,
		PEXCEPTION_POINTERS const	pxcptinfoptrs
	)

Definition at line 75 of file exception_filter.cpp.

{
    if (xcptnum != ('msc' | 0xE0000000))
        return EXCEPTION_CONTINUE_SEARCH;
 
    return _seh_filter_exe(xcptnum,pxcptinfoptrs);
}

_seh_filter_exe()

int __cdecl _seh_filter_exe	(	unsigned long const	xcptnum,
		PEXCEPTION_POINTERS const	pxcptinfoptrs
	)

Definition at line 120 of file exception_filter.cpp.

{
    // Get the PTD and find the action for this exception.  If either of these
    // fails, return to let the handler search continue.
    __acrt_ptd* const ptd = __acrt_getptd_noexit();
    if (ptd == nullptr)
        return EXCEPTION_CONTINUE_SEARCH;
 
    __crt_signal_action_t* const pxcptact = xcptlookup(xcptnum, ptd->_pxcptacttab);
    if (pxcptact == nullptr)
        return EXCEPTION_CONTINUE_SEARCH;
 
    __crt_signal_handler_t const phandler = pxcptact->_action;
 
    // The default behavior (SIG_DFL) is not to handle the exception:
    if (phandler == SIG_DFL)
        return EXCEPTION_CONTINUE_SEARCH;
 
    // If the behavior is to die, execute the handler:
    if (phandler == SIG_DIE)
    {
        // Reset the _action (in case of recursion) and enter the __except:
        pxcptact->_action = SIG_DFL;
        return EXCEPTION_EXECUTE_HANDLER;
    }
 
    // If an exception is ignored, just ignore it:
    if (phandler == SIG_IGN)
        return EXCEPTION_CONTINUE_EXECUTION;
 
    // The remaining exceptions all correspond to C signals which have signal
    // handlers associated with them.  For some, special setup is required
    // before the signal handler is called.  In all cases, if the signal handler
    // returns, -1 is returned by this function to resume execution at the point
    // where the exception occurred.
 
    // Save the old exception pointers in case this is a nested exception/signal.
    PEXCEPTION_POINTERS const old_pxcptinfoptrs = ptd->_tpxcptinfoptrs;
    ptd->_tpxcptinfoptrs = pxcptinfoptrs;
 
    // Call the user-supplied signal handler.  Floating point exceptions must be
    // handled specially since, from the C point of view, there is only one
    // signal.  The exact identity of the exception is passed in the per-thread
    // variable _tfpecode.
    if (pxcptact->_signal_number == SIGFPE)
    {
        // Reset the _action field to the default for all SIGFPE entries:
        __crt_signal_action_t* const first = ptd->_pxcptacttab + __acrt_signal_action_first_fpe_index;
        __crt_signal_action_t* const last  = first + __acrt_signal_action_fpe_count;
 
        for (__crt_signal_action_t* it = first; it != last; ++it)
            it->_action = SIG_DFL;
 
        // Save the current _tfpecode in case this is a nested floating point
        // exception.  It's not clear that we need to support this, but it's
        // easy to support.
        int const old_fpecode = ptd->_tfpecode;
 
        // Note:  There are no exceptions corresponding to _FPE_UNEMULATED and
        // _FPE_SQRTNEG.  Furthermore, STATUS_FLOATING_STACK_CHECK is raised for
        // both stack overflow and underflow, thus the exception does not
        // distinguish between _FPE_STACKOVERFLOW and _FPE_STACKUNDERFLOW.
        // Arbitrarily, _tfpecode is set to the formr value.
        switch (pxcptact->_exception_number)
        {
        case STATUS_FLOAT_DIVIDE_BY_ZERO:    ptd->_tfpecode = _FPE_ZERODIVIDE;      break;
        case STATUS_FLOAT_INVALID_OPERATION: ptd->_tfpecode = _FPE_INVALID;         break;
        case STATUS_FLOAT_OVERFLOW:          ptd->_tfpecode = _FPE_OVERFLOW;        break;
        case STATUS_FLOAT_UNDERFLOW:         ptd->_tfpecode = _FPE_UNDERFLOW;       break;
        case STATUS_FLOAT_DENORMAL_OPERAND:  ptd->_tfpecode = _FPE_DENORMAL;        break;
        case STATUS_FLOAT_INEXACT_RESULT:    ptd->_tfpecode = _FPE_INEXACT;         break;
        case STATUS_FLOAT_STACK_CHECK:       ptd->_tfpecode = _FPE_STACKOVERFLOW;   break;
        case STATUS_FLOAT_MULTIPLE_TRAPS:    ptd->_tfpecode = _FPE_MULTIPLE_TRAPS;  break;
        case STATUS_FLOAT_MULTIPLE_FAULTS:   ptd->_tfpecode = _FPE_MULTIPLE_FAULTS; break;
        }
 
        // Call the SIGFPE handler.  Note that we cast to the given function
        // type to support old MS C programs whose SIGFPE handlers expect two
        // arguments.
        //
        // CRT_REFACTOR TODO Can we remove this support?  It's not clear that
        // this is correct for all architectures (e.g. x64 and ARM).
        reinterpret_cast<void (__cdecl *)(int, int)>(phandler)(SIGFPE, ptd->_tfpecode);
 
        // Restore the stored value of _tfpecode:
        ptd->_tfpecode = old_fpecode;
    }
    else
    {
        // Reset the _action field to the default, then call the user-
        // supplied handler:
        pxcptact->_action = SIG_DFL;
        phandler(pxcptact->_signal_number);
    }
 
    // Restore the stored value of _pxcptinfoptrs:
    ptd->_tpxcptinfoptrs = old_pxcptinfoptrs;
 
    return EXCEPTION_CONTINUE_EXECUTION;
}

Referenced by _seh_filter_dll().

xcptlookup()

static __crt_signal_action_t *__cdecl xcptlookup ( unsigned long const  xcptnum, __crt_signal_action_t *const  action_table  ) throw ( )

static

Definition at line 55 of file exception_filter.cpp.

{
    __crt_signal_action_t* const first = action_table;
    __crt_signal_action_t* const last  = first + __acrt_signal_action_table_count;
 
    // Search for the matching entry and return it if we find it:
    for (__crt_signal_action_t* it = first; it != last; ++it)
        if (it->_exception_number == xcptnum)
            return it;
 
    // Otherwise, return nullptr on failure:
    return nullptr;
}

Referenced by _seh_filter_exe().

Variable Documentation

__acrt_exception_action_table

struct __crt_signal_action_t const __acrt_exception_action_table[]

Initial value:

=
{
 
 
    { STATUS_ACCESS_VIOLATION,         SIGSEGV, SIG_DFL },
    { STATUS_ILLEGAL_INSTRUCTION,      SIGILL,  SIG_DFL },
    { STATUS_PRIVILEGED_INSTRUCTION,   SIGILL,  SIG_DFL },
    { STATUS_FLOAT_DENORMAL_OPERAND,   SIGFPE,  SIG_DFL },
    { STATUS_FLOAT_DIVIDE_BY_ZERO,     SIGFPE,  SIG_DFL },
    { STATUS_FLOAT_INEXACT_RESULT,     SIGFPE,  SIG_DFL },
    { STATUS_FLOAT_INVALID_OPERATION,  SIGFPE,  SIG_DFL },
    { STATUS_FLOAT_OVERFLOW,           SIGFPE,  SIG_DFL },
    { STATUS_FLOAT_STACK_CHECK,        SIGFPE,  SIG_DFL },
    { STATUS_FLOAT_UNDERFLOW,          SIGFPE,  SIG_DFL },
    { STATUS_FLOAT_MULTIPLE_FAULTS,    SIGFPE,  SIG_DFL },
    { STATUS_FLOAT_MULTIPLE_TRAPS,     SIGFPE,  SIG_DFL },
}

Definition at line 20 of file exception_filter.cpp.

Referenced by construct_ptd(), destroy_ptd(), and signal().

__acrt_signal_action_first_fpe_index

size_t const __acrt_signal_action_first_fpe_index = 3

Definition at line 41 of file exception_filter.cpp.

Referenced by _seh_filter_exe(), and raise().

__acrt_signal_action_fpe_count

size_t const __acrt_signal_action_fpe_count = 9

Definition at line 44 of file exception_filter.cpp.

Referenced by _seh_filter_exe(), and raise().

__acrt_signal_action_table_count

size_t const __acrt_signal_action_table_count = sizeof(__acrt_exception_action_table) / sizeof(__acrt_exception_action_table[0])

Definition at line 50 of file exception_filter.cpp.

Referenced by siglookup(), signal(), and xcptlookup().

__acrt_signal_action_table_size

size_t const __acrt_signal_action_table_size = sizeof(__acrt_exception_action_table)

Definition at line 47 of file exception_filter.cpp.

Referenced by signal().