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

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_EndOfChain==FIELD_OFFSET(SEH3$_REGISTRATION_FRAME, EndOfChain))
	C_ASSERT (SEH3_REGISTRATION_FRAME_ScopeTable==FIELD_OFFSET(SEH3$_REGISTRATION_FRAME, ScopeTable))
	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)
static VOID	_SEH3$_CallFinally (PSEH3$_REGISTRATION_FRAME Record)
	__attribute__ ((noreturn))
void __fastcall	_SEH3$_CallRtlUnwind (PSEH3$_REGISTRATION_FRAME RegistrationFrame)
EXCEPTION_DISPOSITION __cdecl	__attribute__ ((__target__("cld")))

Macro Definition Documentation

_SEH3

#define _SEH3   $_FRAME_ALL_NONVOLATILES 1

Definition at line 38 of file pseh3.c.

Function Documentation

__attribute__() [1/3]

EXCEPTION_DISPOSITION __cdecl __attribute__

(

(__target__("cld"))

)

Definition at line 260 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 (ExceptionRecord->ExceptionFlags & EXCEPTION_UNWINDING)
    {
        /* 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);
 
                /* 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);
        }
    }
 
    /* 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 201 of file pseh3.c.

{
    if (RegistrationFrame->ScopeTable->HandlerType == _SEH3$_CLANG_HANDLER)
    {
        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)
        );
    }
 
    __builtin_unreachable();
}

__attribute__() [3/3]

void __attribute__

(

(regparm(1))

)

Definition at line 64 of file pseh3.c.

{
    if (Frame->Handler)
        _SEH3$_UnregisterFrame(Frame);
    else
        _SEH3$_UnregisterTryLevel(Frame);
}

_SEH3$_CallFinally()

static VOID _SEH3$_CallFinally ( PSEH3$_REGISTRATION_FRAME  Record )

inlinestatic

Definition at line 195 of file pseh3.c.

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

Referenced by __attribute__().

_SEH3$_CallRtlUnwind()

void __fastcall _SEH3$_CallRtlUnwind

(

PSEH3$_REGISTRATION_FRAME

RegistrationFrame

)

Referenced by __attribute__().

_SEH3$_GetFilterResult()

static LONG _SEH3$_GetFilterResult ( PSEH3$_REGISTRATION_FRAME  Record )

inlinestatic

Definition at line 163 of file pseh3.c.

{
    PVOID Filter = Record->ScopeTable->Filter;
    LONG Result;
 
    /* Check for __finally frames */
    if (Record->ScopeTable->Target == NULL)
    {
        return EXCEPTION_CONTINUE_SEARCH;
    }
 
    /* 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);
    }
 
    /* 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 76 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;
}

C_ASSERT() [1/14]

C_ASSERT

(

SEH3_REGISTRATION_FRAME_AllocaFrame

= =FIELD_OFFSET(SEH3$_REGISTRATION_FRAME, AllocaFrame)

)

C_ASSERT() [2/14]

C_ASSERT

(

SEH3_REGISTRATION_FRAME_Ebp

= =FIELD_OFFSET(SEH3$_REGISTRATION_FRAME, Ebp)

)

C_ASSERT() [3/14]

C_ASSERT

(

SEH3_REGISTRATION_FRAME_Ebx

= =FIELD_OFFSET(SEH3$_REGISTRATION_FRAME, Ebx)

)

C_ASSERT() [4/14]

C_ASSERT

(

SEH3_REGISTRATION_FRAME_Edi

= =FIELD_OFFSET(SEH3$_REGISTRATION_FRAME, Edi)

)

C_ASSERT() [5/14]

C_ASSERT

(

SEH3_REGISTRATION_FRAME_EndOfChain

= =FIELD_OFFSET(SEH3$_REGISTRATION_FRAME, EndOfChain)

)

C_ASSERT() [6/14]

C_ASSERT

(

SEH3_REGISTRATION_FRAME_Esi

= =FIELD_OFFSET(SEH3$_REGISTRATION_FRAME, Esi)

)

C_ASSERT() [7/14]

C_ASSERT

(

SEH3_REGISTRATION_FRAME_Esp

= =FIELD_OFFSET(SEH3$_REGISTRATION_FRAME, Esp)

)

C_ASSERT() [8/14]

C_ASSERT

(

SEH3_REGISTRATION_FRAME_ExceptionCode

= =FIELD_OFFSET(SEH3$_REGISTRATION_FRAME, ExceptionCode)

)

C_ASSERT() [9/14]

C_ASSERT

(

SEH3_REGISTRATION_FRAME_ExceptionPointers

= =FIELD_OFFSET(SEH3$_REGISTRATION_FRAME, ExceptionPointers)

)

C_ASSERT() [10/14]

C_ASSERT

(

SEH3_REGISTRATION_FRAME_Handler

= =FIELD_OFFSET(SEH3$_REGISTRATION_FRAME, Handler)

)

C_ASSERT() [11/14]

C_ASSERT

(

SEH3_REGISTRATION_FRAME_Next

= =FIELD_OFFSET(SEH3$_REGISTRATION_FRAME, Next)

)

C_ASSERT() [12/14]

C_ASSERT

(

SEH3_REGISTRATION_FRAME_ScopeTable

= =FIELD_OFFSET(SEH3$_REGISTRATION_FRAME, ScopeTable)

)

C_ASSERT() [13/14]

C_ASSERT

(

SEH3_SCOPE_TABLE_Filter

= =FIELD_OFFSET(SEH3$_SCOPE_TABLE, Filter)

)

C_ASSERT() [14/14]

C_ASSERT

(

SEH3_SCOPE_TABLE_Target

= =FIELD_OFFSET(SEH3$_SCOPE_TABLE, Target)

)