pseh3.c File Reference

#include <stdarg.h>
#include <windef.h>
#include <winnt.h>
#include "pseh3.h"
#include "pseh3_asmdef.h"

Include dependency graph for pseh3.c:

Go to the source code of this file.

Macros
#define	_SEH3   $_FRAME_ALL_NONVOLATILES 1
#define	ASSERT(exp)   if (!(exp)) __int2c();

Enumerations
enum	{ _SEH3$_NESTED_HANDLER = 0 , _SEH3$_CPP_HANDLER = 1 , _SEH3$_CLANG_HANDLER = 2 }

Functions
	C_ASSERT (SEH3_REGISTRATION_FRAME_Next==FIELD_OFFSET(SEH3$_REGISTRATION_FRAME, Next))
	C_ASSERT (SEH3_REGISTRATION_FRAME_Handler==FIELD_OFFSET(SEH3$_REGISTRATION_FRAME, Handler))
	C_ASSERT (SEH3_REGISTRATION_FRAME_ScopeTable==FIELD_OFFSET(SEH3$_REGISTRATION_FRAME, ScopeTable))
	C_ASSERT (SEH3_REGISTRATION_FRAME_TryLevel==FIELD_OFFSET(SEH3$_REGISTRATION_FRAME, TryLevel))
	C_ASSERT (SEH3_REGISTRATION_FRAME_EndOfChain==FIELD_OFFSET(SEH3$_REGISTRATION_FRAME, EndOfChain))
	C_ASSERT (SEH3_REGISTRATION_FRAME_ExceptionPointers==FIELD_OFFSET(SEH3$_REGISTRATION_FRAME, ExceptionPointers))
	C_ASSERT (SEH3_REGISTRATION_FRAME_ExceptionCode==FIELD_OFFSET(SEH3$_REGISTRATION_FRAME, ExceptionCode))
	C_ASSERT (SEH3_REGISTRATION_FRAME_Esp==FIELD_OFFSET(SEH3$_REGISTRATION_FRAME, Esp))
	C_ASSERT (SEH3_REGISTRATION_FRAME_Ebp==FIELD_OFFSET(SEH3$_REGISTRATION_FRAME, Ebp))
	C_ASSERT (SEH3_REGISTRATION_FRAME_AllocaFrame==FIELD_OFFSET(SEH3$_REGISTRATION_FRAME, AllocaFrame))
	C_ASSERT (SEH3_REGISTRATION_FRAME_Ebx==FIELD_OFFSET(SEH3$_REGISTRATION_FRAME, Ebx))
	C_ASSERT (SEH3_REGISTRATION_FRAME_Esi==FIELD_OFFSET(SEH3$_REGISTRATION_FRAME, Esi))
	C_ASSERT (SEH3_REGISTRATION_FRAME_Edi==FIELD_OFFSET(SEH3$_REGISTRATION_FRAME, Edi))
	C_ASSERT (SEH3_SCOPE_TABLE_Filter==FIELD_OFFSET(SEH3$_SCOPE_TABLE, Filter))
	C_ASSERT (SEH3_SCOPE_TABLE_Target==FIELD_OFFSET(SEH3$_SCOPE_TABLE, Target))
void	__attribute__ ((regparm(1)))
static LONG	_SEH3$_InvokeNestedFunctionFilter (volatile SEH3$_REGISTRATION_FRAME *RegistrationFrame, PVOID Filter)
static LONG	_SEH3$_GetFilterResult (PSEH3$_REGISTRATION_FRAME Record, int HandlerType)
static VOID	_SEH3$_CallFinally (PSEH3$_REGISTRATION_FRAME Record, int HandlerType)
	__attribute__ ((noreturn))
void __fastcall	_SEH3$_CallRtlUnwind (PSEH3$_REGISTRATION_FRAME RegistrationFrame)
int __cdecl	__attribute__ ((__target__("cld")))
int __cdecl	_SEH3$_C_except_handler (struct _EXCEPTION_RECORD *ExceptionRecord, PSEH3$_REGISTRATION_FRAME EstablisherFrame, struct _CONTEXT *ContextRecord, void *DispatcherContext)
int __cdecl	_SEH3$_CPP_except_handler (struct _EXCEPTION_RECORD *ExceptionRecord, PSEH3$_REGISTRATION_FRAME EstablisherFrame, struct _CONTEXT *ContextRecord, void *DispatcherContext)
void __stdcall	_SEH3$_longjmp_unwind (_JUMP_BUFFER *_Buf)

Macro Definition Documentation

_SEH3

#define _SEH3   $_FRAME_ALL_NONVOLATILES 1

Definition at line 34 of file pseh3.c.

ASSERT

#define ASSERT

(

exp

)

if (!(exp)) __int2c();

Definition at line 40 of file pseh3.c.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
_SEH3$_NESTED_HANDLER
_SEH3$_CPP_HANDLER
_SEH3$_CLANG_HANDLER

Definition at line 67 of file pseh3.c.

{
    _SEH3$_NESTED_HANDLER = 0,
    _SEH3$_CPP_HANDLER = 1,
    _SEH3$_CLANG_HANDLER = 2,
};

Function Documentation

__attribute__() [1/3]

int __cdecl __attribute__

(

(__target__("cld"))

)

Definition at line 322 of file pseh3.c.

{
    PSEH3$_REGISTRATION_FRAME CurrentFrame, TargetFrame;
    SEH3$_EXCEPTION_POINTERS ExceptionPointers;
    LONG FilterResult;
 
    /* Clear the direction flag. */
    asm volatile ("cld" : : : "memory");
 
    /* Save the exception pointers on the stack */
    ExceptionPointers.ExceptionRecord = ExceptionRecord;
    ExceptionPointers.ContextRecord = ContextRecord;
 
    /* Check if this is an unwind */
    if (IS_UNWINDING(ExceptionRecord->ExceptionFlags))
    {
        /* Unwind all local frames */
        TargetFrame = EstablisherFrame->Next;
    }
    else
    {
        /* Loop all frames for this registration */
        CurrentFrame = EstablisherFrame->EndOfChain;
        for (;;)
        {
            /* Check if we have an exception handler */
            if (CurrentFrame->ScopeTable->Target != NULL)
            {
                /* Set exception pointers and code for this frame */
                CurrentFrame->ExceptionPointers = &ExceptionPointers;
                CurrentFrame->ExceptionCode = ExceptionRecord->ExceptionCode;
 
                /* Get the filter result */
                FilterResult = _SEH3$_GetFilterResult(CurrentFrame, HandlerType);
 
                /* Check, if continuuing is requested */
                if (FilterResult == EXCEPTION_CONTINUE_EXECUTION)
                {
                    return ExceptionContinueExecution;
                }
 
                /* Check if the except handler shall be executed */
                if (FilterResult == EXCEPTION_EXECUTE_HANDLER) break;
            }
 
            /* Bail out if this is the last handler */
            if (CurrentFrame == EstablisherFrame)
                return ExceptionContinueSearch;
 
            /* Go to the next frame */
            CurrentFrame = CurrentFrame->Next;
        }
 
        /* Call RtlUnwind to unwind the frames below this one */
        _SEH3$_CallRtlUnwind(EstablisherFrame);
 
        /* Do a local unwind up to this frame */
        TargetFrame = CurrentFrame;
    }
 
    /* Loop frames up to the target frame */
    for (CurrentFrame = EstablisherFrame->EndOfChain;
         CurrentFrame != TargetFrame;
         CurrentFrame = CurrentFrame->Next)
    {
        /* Manually unregister the frame */
        _SEH3$_Unregister(CurrentFrame);
 
        /* Check if this is an unwind frame */
        if (CurrentFrame->ScopeTable->Target == NULL)
        {
            /* Set exception pointers and code for this frame */
            CurrentFrame->ExceptionPointers = &ExceptionPointers;
            CurrentFrame->ExceptionCode = ExceptionRecord->ExceptionCode;
 
            /* Call the finally function */
            _SEH3$_CallFinally(CurrentFrame, HandlerType);
        }
    }
 
    /* Check if this was an unwind */
    if (ExceptionRecord->ExceptionFlags & EXCEPTION_UNWINDING)
    {
        return ExceptionContinueSearch;
    }
 
    /* Unregister the frame. It will be unregistered again at the end of the
       __except block, due to auto cleanup, but that doesn't hurt.
       All we do is set either fs:[0] or EstablisherFrame->EndOfChain to
       CurrentFrame->Next, which will not change it's value. */
    _SEH3$_Unregister(CurrentFrame);
 
    /* Jump to the __except block (does not return) */
    _SEH3$_JumpToTarget(CurrentFrame);
}

__attribute__() [2/3]

__attribute__

(

(noreturn)

)

Definition at line 266 of file pseh3.c.

{
#ifdef __clang__
        asm volatile (
            /* Load the registers */
            "movl 24(%%ecx), %%esp\n\t"
            "movl 28(%%ecx), %%ebp\n\t"
 
            "movl 36(%%ecx), %%ebx\n\t"
            "movl 40(%%ecx), %%esi\n\t"
            "movl 44(%%ecx), %%edi\n\t"
 
            /* Stack pointer is 4 off from the call to __SEH3$_RegisterFrame */
            "addl $4, %%esp\n\t"
 
            /* Jump into the exception handler */
            "jmp *%[Target]"
            : :
            "c" (RegistrationFrame),
            "a" (RegistrationFrame->ScopeTable),
             [Target] "m" (RegistrationFrame->ScopeTable->Target)
        );
#else
        asm volatile (
            /* Load the registers */
            "movl 24(%%ecx), %%esp\n\t"
            "movl 28(%%ecx), %%ebp\n\t"
 
            /* Stack pointer is 4 off from the call to __SEH3$_RegisterFrame */
            "addl $4, %%esp\n\t"
 
            /* Jump into the exception handler */
            "jmp *%[Target]"
            : :
            "c" (RegistrationFrame),
            "a" (RegistrationFrame->ScopeTable),
             [Target] "m" (RegistrationFrame->ScopeTable->Target)
        );
#endif
 
    __builtin_unreachable();
}

__attribute__() [3/3]

void __attribute__

(

(regparm(1))

)

Definition at line 75 of file pseh3.c.

{
    volatile SEH3$_REGISTRATION_FRAME *CurrentFrame;
 
    /* Check if the frame has a handler (then it's the registered frame) */
    if (Frame->Handler != NULL)
    {
        /* There shouldn't be any more nested try-level frames */
        ASSERT(Frame->EndOfChain == Frame);
 
        /* During unwinding on Windows ExecuteHandler2 installs its own EH frame,
           so there can be one or even multiple frames before our own one and we
           need to search for the link that points to our head frame. */
        CurrentFrame = (SEH3$_REGISTRATION_FRAME*)__readfsdword(0);
        if (Frame == CurrentFrame)
        {
            /* The target frame is the first installed frame, remove it */
            __writefsdword(0, (ULONG)Frame->Next);
            return;
        }
 
        /* Loop to find the frame that links the target frame */
        while (CurrentFrame->Next != Frame)
        {
            CurrentFrame = CurrentFrame->Next;
        }
 
        /* Remove the frame from the linked list */
        CurrentFrame->Next = Frame->Next;
    }
    else
    {
        /* Search for the head frame */
        CurrentFrame = Frame->Next;
        while (CurrentFrame->Handler == NULL)
        {
            CurrentFrame = CurrentFrame->Next;
        }
 
        /* Make sure the head frame points to our frame */
        ASSERT(CurrentFrame->EndOfChain == Frame);
 
        /* Remove this frame from the internal linked list */
        CurrentFrame->EndOfChain = Frame->Next;
    }
}

_SEH3$_C_except_handler()

int __cdecl _SEH3$_C_except_handler	(	struct _EXCEPTION_RECORD *	ExceptionRecord,
		PSEH3$_REGISTRATION_FRAME	EstablisherFrame,
		struct _CONTEXT *	ContextRecord,
		void *	DispatcherContext
	)

Definition at line 427 of file pseh3.c.

{
#ifdef __clang__
    return _SEH3$_common_except_handler(ExceptionRecord, EstablisherFrame, ContextRecord, DispatcherContext, _SEH3$_CLANG_HANDLER);
#else
    return _SEH3$_common_except_handler(ExceptionRecord, EstablisherFrame, ContextRecord, DispatcherContext, _SEH3$_NESTED_HANDLER);
#endif
}

Referenced by _SEH3$_longjmp_unwind().

_SEH3$_CallFinally()

static VOID _SEH3$_CallFinally ( PSEH3$_REGISTRATION_FRAME  Record, int  HandlerType  )

inlinestatic

Definition at line 259 of file pseh3.c.

{
    _SEH3$_InvokeFilter(Record, Record->ScopeTable->Filter, HandlerType);
}

Referenced by __attribute__(), and _SEH3$_longjmp_unwind().

_SEH3$_CallRtlUnwind()

void __fastcall _SEH3$_CallRtlUnwind

(

PSEH3$_REGISTRATION_FRAME

RegistrationFrame

)

Referenced by __attribute__().

_SEH3$_CPP_except_handler()

int __cdecl _SEH3$_CPP_except_handler	(	struct _EXCEPTION_RECORD *	ExceptionRecord,
		PSEH3$_REGISTRATION_FRAME	EstablisherFrame,
		struct _CONTEXT *	ContextRecord,
		void *	DispatcherContext
	)

Definition at line 442 of file pseh3.c.

{
    return _SEH3$_common_except_handler(ExceptionRecord, EstablisherFrame, ContextRecord, DispatcherContext, _SEH3$_CPP_HANDLER);
}

Referenced by _SEH3$_longjmp_unwind().

_SEH3$_GetFilterResult()

static LONG _SEH3$_GetFilterResult ( PSEH3$_REGISTRATION_FRAME  Record, int  HandlerType  )

inlinestatic

Definition at line 232 of file pseh3.c.

{
    PVOID Filter = Record->ScopeTable->Filter;
    LONG Result;
 
    /* Check if we have a constant filter */
    if (((ULONG)Filter & 0xFFFFFF00) == 0)
    {
        /* Lowest 8 bit are sign extended to give the result */
        Result = (LONG)(CHAR)(ULONG)Filter;
    }
    else
    {
        /* Call the filter function */
        Result = _SEH3$_InvokeFilter(Record, Filter, HandlerType);
    }
 
    /* Normalize the result */
    if (Result < 0) return EXCEPTION_CONTINUE_EXECUTION;
    else if (Result > 0) return EXCEPTION_EXECUTE_HANDLER;
    else return EXCEPTION_CONTINUE_SEARCH;
}

Referenced by __attribute__().

_SEH3$_InvokeNestedFunctionFilter()

static LONG _SEH3$_InvokeNestedFunctionFilter ( volatile SEH3$_REGISTRATION_FRAME *  RegistrationFrame, PVOID  Filter  )

inlinestatic

Definition at line 126 of file pseh3.c.

{
    LONG FilterResult;
 
    asm volatile (
        /* First call with param = 0 to get the frame layout */
        "xorl %%ecx, %%ecx\n\t"
        "xorl %%eax, %%eax\n\t"
        "call *%[Filter]\n\t"
 
        /* The result is the frame base address that we passed in (0) plus the
           offset to the registration record. */
        "negl %%eax\n\t"
        "addl %[RegistrationFrame], %%eax\n\t"
 
        /* Second call to get the filter result */
        "mov $1, %%ecx\n\t"
        "call *%[Filter]"
        : "=a" (FilterResult)
        : [RegistrationFrame] "m" (RegistrationFrame), [Filter] "m" (Filter)
        : "ecx", "edx");
 
    return FilterResult;
}

_SEH3$_longjmp_unwind()

void __stdcall _SEH3$_longjmp_unwind

(

_JUMP_BUFFER *

_Buf

)

Definition at line 453 of file pseh3.c.

{
    PSEH3$_REGISTRATION_FRAME RegisteredFrame = (PSEH3$_REGISTRATION_FRAME)_Buf->Registration;
    PSEH3$_REGISTRATION_FRAME CurrentFrame;
 
    /* Native SEH registers the EH frame at the start of the function, so a call to
       _setjmp(3) will always save that EH frame. PSEH only registers the frame
       when entering a try block, so a call to _setjmp outside of a try block
       would save a previously installed EH frame, which can be of a different
       type (e.g. native EH3/EH4). We need to check whether the frame is ours
       by comparing its address to the saved ebp value, which marks the boundary
       of the stack frame for the caller of _setjmp. */
    if (_Buf->Registration > _Buf->Ebp)
    {
        /* The registration frame is not ours, we don't need to do anything */
        return;
    }
 
    /* Loop all frames for this registration */
    for (CurrentFrame = RegisteredFrame->EndOfChain;
         CurrentFrame->TryLevel != _Buf->TryLevel;
         CurrentFrame = CurrentFrame->Next)
    {
        /* Check if this is a termination handler */
        if (CurrentFrame->ScopeTable->Target == NULL)
        {
            /* Call the termination handler */
            if (RegisteredFrame->Handler == _SEH3$_C_except_handler)
            {
#ifdef __clang__
                _SEH3$_CallFinally(CurrentFrame, _SEH3$_CLANG_HANDLER);
#else
                _SEH3$_CallFinally(CurrentFrame, _SEH3$_NESTED_HANDLER);
#endif
            }
            else
            {
                ASSERT(CurrentFrame->Handler == _SEH3$_CPP_except_handler);
                _SEH3$_CallFinally(CurrentFrame, _SEH3$_CPP_HANDLER);
            }
        }
    }
}

C_ASSERT() [1/15]

C_ASSERT

(

SEH3_REGISTRATION_FRAME_AllocaFrame

= =FIELD_OFFSET(SEH3$_REGISTRATION_FRAME, AllocaFrame)

)

C_ASSERT() [2/15]

C_ASSERT

(

SEH3_REGISTRATION_FRAME_Ebp

= =FIELD_OFFSET(SEH3$_REGISTRATION_FRAME, Ebp)

)

C_ASSERT() [3/15]

C_ASSERT

(

SEH3_REGISTRATION_FRAME_Ebx

= =FIELD_OFFSET(SEH3$_REGISTRATION_FRAME, Ebx)

)

C_ASSERT() [4/15]

C_ASSERT

(

SEH3_REGISTRATION_FRAME_Edi

= =FIELD_OFFSET(SEH3$_REGISTRATION_FRAME, Edi)

)

C_ASSERT() [5/15]

C_ASSERT

(

SEH3_REGISTRATION_FRAME_EndOfChain

= =FIELD_OFFSET(SEH3$_REGISTRATION_FRAME, EndOfChain)

)

C_ASSERT() [6/15]

C_ASSERT

(

SEH3_REGISTRATION_FRAME_Esi

= =FIELD_OFFSET(SEH3$_REGISTRATION_FRAME, Esi)

)

C_ASSERT() [7/15]

C_ASSERT

(

SEH3_REGISTRATION_FRAME_Esp

= =FIELD_OFFSET(SEH3$_REGISTRATION_FRAME, Esp)

)

C_ASSERT() [8/15]

C_ASSERT

(

SEH3_REGISTRATION_FRAME_ExceptionCode

= =FIELD_OFFSET(SEH3$_REGISTRATION_FRAME, ExceptionCode)

)

C_ASSERT() [9/15]

C_ASSERT

(

SEH3_REGISTRATION_FRAME_ExceptionPointers

= =FIELD_OFFSET(SEH3$_REGISTRATION_FRAME, ExceptionPointers)

)

C_ASSERT() [10/15]

C_ASSERT

(

SEH3_REGISTRATION_FRAME_Handler

= =FIELD_OFFSET(SEH3$_REGISTRATION_FRAME, Handler)

)

C_ASSERT() [11/15]

C_ASSERT

(

SEH3_REGISTRATION_FRAME_Next

= =FIELD_OFFSET(SEH3$_REGISTRATION_FRAME, Next)

)

C_ASSERT() [12/15]

C_ASSERT

(

SEH3_REGISTRATION_FRAME_ScopeTable

= =FIELD_OFFSET(SEH3$_REGISTRATION_FRAME, ScopeTable)

)

C_ASSERT() [13/15]

C_ASSERT

(

SEH3_REGISTRATION_FRAME_TryLevel

= =FIELD_OFFSET(SEH3$_REGISTRATION_FRAME, TryLevel)

)

C_ASSERT() [14/15]

C_ASSERT

(

SEH3_SCOPE_TABLE_Filter

= =FIELD_OFFSET(SEH3$_SCOPE_TABLE, Filter)

)

C_ASSERT() [15/15]

C_ASSERT

(

SEH3_SCOPE_TABLE_Target

= =FIELD_OFFSET(SEH3$_SCOPE_TABLE, Target)

)