exception.c File Reference

#include <stdarg.h>
#include <stdio.h>
#include <setjmp.h>
#include "ntstatus.h"
#include "windef.h"
#include "winbase.h"
#include "winnt.h"
#include "winreg.h"
#include "winuser.h"
#include "winternl.h"
#include "rtlsupportapi.h"
#include "ddk/wdm.h"
#include "excpt.h"
#include "wine/test.h"
#include "intrin.h"

Include dependency graph for exception.c:

Go to the source code of this file.

Classes
struct	_RTL_UNLOAD_EVENT_TRACE
struct	context_exception_request_thread_param

Macros
#define	WIN32_NO_STATUS
#define	RTL_UNLOAD_EVENT_TRACE_NUMBER   64
#define	TEST_SUSPEND_COUNT(thread, count)   test_suspend_count((thread), (count), __LINE__)
#define	X(f)   p##f = (void*)GetProcAddress(hntdll, #f)
#define	X(f)   p##f = (void*)GetProcAddress(hkernel32, #f)

Typedefs
typedef struct _RTL_UNLOAD_EVENT_TRACE	RTL_UNLOAD_EVENT_TRACE
typedef struct _RTL_UNLOAD_EVENT_TRACE *	PRTL_UNLOAD_EVENT_TRACE

Enumerations
enum	debugger_stages {   STAGE_RTLRAISE_NOT_HANDLED = 1 , STAGE_RTLRAISE_HANDLE_LAST_CHANCE , STAGE_OUTPUTDEBUGSTRINGA_CONTINUE , STAGE_OUTPUTDEBUGSTRINGA_NOT_HANDLED ,   STAGE_OUTPUTDEBUGSTRINGW_CONTINUE , STAGE_OUTPUTDEBUGSTRINGW_NOT_HANDLED , STAGE_RIPEVENT_CONTINUE , STAGE_RIPEVENT_NOT_HANDLED ,   STAGE_SERVICE_CONTINUE , STAGE_SERVICE_NOT_HANDLED , STAGE_BREAKPOINT_CONTINUE , STAGE_BREAKPOINT_NOT_HANDLED ,   STAGE_EXCEPTION_INVHANDLE_CONTINUE , STAGE_EXCEPTION_INVHANDLE_NOT_HANDLED , STAGE_NO_EXCEPTION_INVHANDLE_NOT_HANDLED , STAGE_XSTATE ,   STAGE_XSTATE_LEGACY_SSE , STAGE_SEGMENTS }

Functions
static	NTSTATUS (WINAPI *pNtGetContextThread)(HANDLE
static	PVOID (WINAPI *pRtlUnwind)(PVOID
static	VOID (WINAPI *pRtlCaptureContext)(CONTEXT *)
static	ULONG (WINAPI *pRtlRemoveVectoredExceptionHandler)(PVOID handler)
static	void (WINAPI *pRtlSetUnhandledExceptionFilter)(PRTL_EXCEPTION_FILTER filter)
static	ULONG64 (WINAPI *pRtlGetEnabledExtendedFeatures)(ULONG64)
static void *WINAPI *	pRtlLocateExtendedFeature (CONTEXT_EX *context_ex, ULONG feature_id, ULONG *length)
static void *WINAPI *	pRtlLocateLegacyContext (CONTEXT_EX *context_ex, ULONG *length)
static void *WINAPI *	pRtlPcToFileHeader (PVOID pc, PVOID *address)
static	BOOL (WINAPI *pIsWow64Process)(HANDLE
static void *WINAPI *	pLocateXStateFeature (CONTEXT *context, DWORD feature_id, DWORD *length)
static VOID EXCEPTION_RECORD VOID CONTEXT UNWIND_HISTORY_TABLE *static	BOOLEAN (CDECL *pRtlAddFunctionTable)(RUNTIME_FUNCTION *
static	VOID (CDECL *pRtlRestoreContext)(CONTEXT *
static RTL_UNLOAD_EVENT_TRACE *WINAPI *	pRtlGetUnloadEventTrace (void)
static void CALLBACK	apc_func (ULONG_PTR arg1, ULONG_PTR arg2, ULONG_PTR arg3)
static LONG CALLBACK	outputdebugstring_vectored_handler (EXCEPTION_POINTERS *ExceptionInfo)
static void	test_outputdebugstring (BOOL unicode, DWORD numexc_ansi, BOOL todo_ansi, DWORD numexc_unicode_low, DWORD numexc_unicode_high)
static LONG CALLBACK	outputdebugstring_new_model_vectored_handler (EXCEPTION_POINTERS *ExceptionInfo)
static void	test_outputdebugstring_newmodel (void)
static LONG CALLBACK	ripevent_vectored_handler (EXCEPTION_POINTERS *ExceptionInfo)
static void	test_ripevent (DWORD numexc)
static void	subtest_fastfail (unsigned int code)
static void	test_fastfail (void)
static LONG CALLBACK	breakpoint_handler (EXCEPTION_POINTERS *ExceptionInfo)
static void	test_breakpoint (DWORD numexc)
static LONG CALLBACK	invalid_handle_vectored_handler (EXCEPTION_POINTERS *ExceptionInfo)
static BOOL	is_magic_handle (HANDLE handle)
static void	test_closehandle (DWORD numexc, HANDLE handle)
static void	test_vectored_continue_handler (void)
static void	test_user_apc (void)
static void	test_user_callback (void)
static DWORD WINAPI	suspend_thread_test (void *arg)
static void	test_suspend_count (HANDLE hthread, ULONG expected_count, int line)
static void	test_suspend_thread (void)
static DWORD WINAPI	dummy_thread_proc (void *arg)
static void	suspend_process_proc (void)
static void	test_suspend_process (void)
static void	test_unload_trace (void)
static void	test_backtrace (void)
static LONG CALLBACK	test_context_exception_request_handler (EXCEPTION_POINTERS *info)
static DWORD WINAPI	test_context_exception_request_thread (void *arg)
static void	test_context_exception_request (void)
	START_TEST (exception)

Variables
static void *	code_mem
static HMODULE	hntdll
static BOOL	is_arm64ec
static CONTEXT *static CONTEXT *static PNTAPCFUNC	func
static CONTEXT *static CONTEXT *static PNTAPCFUNC ULONG_PTR	arg1
static CONTEXT *static CONTEXT *static PNTAPCFUNC ULONG_PTR ULONG_PTR	arg2
static CONTEXT *static CONTEXT *static PNTAPCFUNC ULONG_PTR ULONG_PTR ULONG_PTR	arg3
static	PVOID
static	PEXCEPTION_RECORD
static ULONG *	length
static ULONG ULONG64	compaction_mask
static ULONG	context_flags
static ULONG CONTEXT_EX **	context_ex
static DWORD CONTEXT *	src
static ULONG64	feature_mask
static void **static CONTEXT *	context
static void **static CONTEXT BOOL	first_chance
static const void void	SIZE_T
static const void void SIZE_T *static LONG	exit_code
static	THREADINFOCLASS
static	ULONG
static	PULONG
static	PROCESSINFOCLASS
static	PBOOL
static	DWORD
static VOID EXCEPTION_RECORD VOID CONTEXT UNWIND_HISTORY_TABLE *static	DWORD64
static EXCEPTION_RECORD *static void ULONG *static void *	pKiUserApcDispatcher
static void *	pKiUserCallbackDispatcher
static void *	pKiUserExceptionDispatcher
static ULONG **	element_count
static ULONG void **	event_trace
static int	my_argc
static char **	my_argv
static BOOL	is_wow64
static BOOL	old_wow64
static UINT	apc_count
static BOOL	have_vectored_api
static enum debugger_stages	test_stage
static DWORD	outputdebugstring_exceptions_ansi
static DWORD	outputdebugstring_exceptions_unicode
static DWORD	outputdebugstring_exceptions_newmodel_order
static DWORD	outputdebugstring_newmodel_return
static DWORD	ripevent_exceptions
static DWORD	breakpoint_exceptions
static DWORD	invalid_handle_exceptions
static const char *	suspend_process_event_name = "suspend_process_event"
static const char *	suspend_process_event2_name = "suspend_process_event2"
static volatile int *	p_context_exception_request_value
struct context_exception_request_thread_param *	context_exception_request_param

Macro Definition Documentation

RTL_UNLOAD_EVENT_TRACE_NUMBER

#define RTL_UNLOAD_EVENT_TRACE_NUMBER   64

Definition at line 111 of file exception.c.

TEST_SUSPEND_COUNT

#define TEST_SUSPEND_COUNT	(		thread,
			count
	)		test_suspend_count((thread), (count), __LINE__)

WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 26 of file exception.c.

X [1/2]

#define X

(

f

)

p##f = (void*)GetProcAddress(hntdll, #f)

X [2/2]

#define X

(

f

)

p##f = (void*)GetProcAddress(hkernel32, #f)

Typedef Documentation

PRTL_UNLOAD_EVENT_TRACE

typedef struct _RTL_UNLOAD_EVENT_TRACE * PRTL_UNLOAD_EVENT_TRACE

RTL_UNLOAD_EVENT_TRACE

typedef struct _RTL_UNLOAD_EVENT_TRACE RTL_UNLOAD_EVENT_TRACE

Enumeration Type Documentation

debugger_stages

enum debugger_stages

Enumerator
STAGE_RTLRAISE_NOT_HANDLED
STAGE_RTLRAISE_HANDLE_LAST_CHANCE
STAGE_OUTPUTDEBUGSTRINGA_CONTINUE
STAGE_OUTPUTDEBUGSTRINGA_NOT_HANDLED
STAGE_OUTPUTDEBUGSTRINGW_CONTINUE
STAGE_OUTPUTDEBUGSTRINGW_NOT_HANDLED
STAGE_RIPEVENT_CONTINUE
STAGE_RIPEVENT_NOT_HANDLED
STAGE_SERVICE_CONTINUE
STAGE_SERVICE_NOT_HANDLED
STAGE_BREAKPOINT_CONTINUE
STAGE_BREAKPOINT_NOT_HANDLED
STAGE_EXCEPTION_INVHANDLE_CONTINUE
STAGE_EXCEPTION_INVHANDLE_NOT_HANDLED
STAGE_NO_EXCEPTION_INVHANDLE_NOT_HANDLED
STAGE_XSTATE
STAGE_XSTATE_LEGACY_SSE
STAGE_SEGMENTS

Definition at line 164 of file exception.c.

{
    STAGE_RTLRAISE_NOT_HANDLED = 1,
    STAGE_RTLRAISE_HANDLE_LAST_CHANCE,
    STAGE_OUTPUTDEBUGSTRINGA_CONTINUE,
    STAGE_OUTPUTDEBUGSTRINGA_NOT_HANDLED,
    STAGE_OUTPUTDEBUGSTRINGW_CONTINUE,
    STAGE_OUTPUTDEBUGSTRINGW_NOT_HANDLED,
    STAGE_RIPEVENT_CONTINUE,
    STAGE_RIPEVENT_NOT_HANDLED,
    STAGE_SERVICE_CONTINUE,
    STAGE_SERVICE_NOT_HANDLED,
    STAGE_BREAKPOINT_CONTINUE,
    STAGE_BREAKPOINT_NOT_HANDLED,
    STAGE_EXCEPTION_INVHANDLE_CONTINUE,
    STAGE_EXCEPTION_INVHANDLE_NOT_HANDLED,
    STAGE_NO_EXCEPTION_INVHANDLE_NOT_HANDLED,
    STAGE_XSTATE,
    STAGE_XSTATE_LEGACY_SSE,
    STAGE_SEGMENTS,
};

Function Documentation

apc_func()

static void CALLBACK apc_func ( ULONG_PTR  arg1, ULONG_PTR  arg2, ULONG_PTR  arg3  )

static

Definition at line 194 of file exception.c.

{
    ok( arg1 == 0x1234 + apc_count, "wrong arg1 %Ix\n", arg1 );
    ok( arg2 == 0x5678, "wrong arg2 %Ix\n", arg2 );
    ok( arg3 == 0xdeadbeef, "wrong arg3 %Ix\n", arg3 );
    apc_count++;
}

Referenced by test_user_apc().

BOOL()

static BOOL ( WINAPI *  pIsWow64Process )

static

BOOLEAN()

static VOID EXCEPTION_RECORD VOID CONTEXT UNWIND_HISTORY_TABLE *static BOOLEAN ( CDECL *  pRtlAddFunctionTable )

static

breakpoint_handler()

static LONG CALLBACK breakpoint_handler ( EXCEPTION_POINTERS *  ExceptionInfo )

static

Definition at line 9150 of file exception.c.

{
    EXCEPTION_RECORD *rec = ExceptionInfo->ExceptionRecord;
 
    ok(rec->ExceptionCode == EXCEPTION_BREAKPOINT, "ExceptionCode is %08lx instead of %08lx\n",
       rec->ExceptionCode, EXCEPTION_BREAKPOINT);
 
#ifdef __i386__
    ok(ExceptionInfo->ContextRecord->Eip == (DWORD)code_mem + 1,
       "expected Eip = %lx, got %lx\n", (DWORD)code_mem + 1, ExceptionInfo->ContextRecord->Eip);
    ok(rec->NumberParameters == (is_wow64 ? 1 : 3),
       "ExceptionParameters is %ld instead of %d\n", rec->NumberParameters, is_wow64 ? 1 : 3);
    ok(rec->ExceptionInformation[0] == 0,
       "got ExceptionInformation[0] = %Ix\n", rec->ExceptionInformation[0]);
    ExceptionInfo->ContextRecord->Eip = (DWORD)code_mem + 2;
#elif defined(__x86_64__)
    ok(ExceptionInfo->ContextRecord->Rip == (DWORD_PTR)code_mem + 1,
       "expected Rip = %Ix, got %Ix\n", (DWORD_PTR)code_mem + 1, ExceptionInfo->ContextRecord->Rip);
    ok(rec->NumberParameters == 1,
       "ExceptionParameters is %ld instead of 1\n", rec->NumberParameters);
    ok(rec->ExceptionInformation[0] == 0,
       "got ExceptionInformation[0] = %Ix\n", rec->ExceptionInformation[0]);
    ExceptionInfo->ContextRecord->Rip = (DWORD_PTR)code_mem + 2;
#elif defined(__arm__)
    ok(ExceptionInfo->ContextRecord->Pc == (DWORD)code_mem + 1,
       "expected pc = %lx, got %lx\n", (DWORD)code_mem + 1, ExceptionInfo->ContextRecord->Pc);
    ok(rec->NumberParameters == 1,
       "ExceptionParameters is %ld instead of 1\n", rec->NumberParameters);
    ok(rec->ExceptionInformation[0] == 0,
       "got ExceptionInformation[0] = %Ix\n", rec->ExceptionInformation[0]);
    ExceptionInfo->ContextRecord->Pc += 2;
#elif defined(__aarch64__)
    ok(ExceptionInfo->ContextRecord->Pc == (DWORD_PTR)code_mem,
       "expected pc = %p, got %p\n", code_mem, (void *)ExceptionInfo->ContextRecord->Pc);
    ok(rec->NumberParameters == 1,
       "ExceptionParameters is %ld instead of 1\n", rec->NumberParameters);
    ok(rec->ExceptionInformation[0] == 0,
       "got ExceptionInformation[0] = %p\n", (void *)rec->ExceptionInformation[0]);
    ExceptionInfo->ContextRecord->Pc += 4;
#endif
 
    breakpoint_exceptions++;
    return (rec->ExceptionCode == EXCEPTION_BREAKPOINT) ? EXCEPTION_CONTINUE_EXECUTION : EXCEPTION_CONTINUE_SEARCH;
}

Referenced by test_breakpoint().

dummy_thread_proc()

static DWORD WINAPI dummy_thread_proc ( void *  arg )

static

Definition at line 9614 of file exception.c.

{
    return 0;
}

Referenced by suspend_process_proc().

invalid_handle_vectored_handler()

static LONG CALLBACK invalid_handle_vectored_handler ( EXCEPTION_POINTERS *  ExceptionInfo )

static

Definition at line 9319 of file exception.c.

{
    PEXCEPTION_RECORD rec = ExceptionInfo->ExceptionRecord;
 
    ok(rec->ExceptionCode == EXCEPTION_INVALID_HANDLE, "ExceptionCode is %08lx instead of %08lx\n",
       rec->ExceptionCode, EXCEPTION_INVALID_HANDLE);
    ok(rec->NumberParameters == 0, "ExceptionParameters is %ld instead of 0\n", rec->NumberParameters);
 
    invalid_handle_exceptions++;
    return (rec->ExceptionCode == EXCEPTION_INVALID_HANDLE) ? EXCEPTION_CONTINUE_EXECUTION : EXCEPTION_CONTINUE_SEARCH;
}

Referenced by test_closehandle().

is_magic_handle()

static BOOL is_magic_handle ( HANDLE  handle )

inlinestatic

Definition at line 9331 of file exception.c.

{
    return HandleToLong(handle) >= ~5 && HandleToLong(handle) <= ~0;
}

Referenced by test_closehandle().

NTSTATUS()

static NTSTATUS ( WINAPI *  pNtGetContextThread )

static

outputdebugstring_new_model_vectored_handler()

static LONG CALLBACK outputdebugstring_new_model_vectored_handler ( EXCEPTION_POINTERS *  ExceptionInfo )

static

Definition at line 8932 of file exception.c.

{
    PEXCEPTION_RECORD rec = ExceptionInfo->ExceptionRecord;
 
    switch (rec->ExceptionCode)
    {
    case DBG_PRINTEXCEPTION_C:
        ok(rec->NumberParameters == 2, "ExceptionParameters is %ld instead of 2\n", rec->NumberParameters);
        ok(rec->ExceptionInformation[0] == 12, "ExceptionInformation[0] = %ld instead of 12\n", (DWORD)rec->ExceptionInformation[0]);
        ok(!strcmp((char *)rec->ExceptionInformation[1], "Hello World"),
           "ExceptionInformation[1] = '%s' instead of 'Hello World'\n", (char *)rec->ExceptionInformation[1]);
        outputdebugstring_exceptions_newmodel_order =
            (outputdebugstring_exceptions_newmodel_order << 8) | 'A';
        break;
    case DBG_PRINTEXCEPTION_WIDE_C:
        ok(rec->NumberParameters == 4, "ExceptionParameters is %ld instead of 4\n", rec->NumberParameters);
        ok(rec->ExceptionInformation[0] == 12, "ExceptionInformation[0] = %ld instead of 12\n", (DWORD)rec->ExceptionInformation[0]);
        ok(!wcscmp((WCHAR *)rec->ExceptionInformation[1], L"Hello World"),
           "ExceptionInformation[1] = '%s' instead of 'Hello World'\n", (char *)rec->ExceptionInformation[1]);
        ok(rec->ExceptionInformation[2] == 12, "ExceptionInformation[2] = %ld instead of 12\n", (DWORD)rec->ExceptionInformation[2]);
        ok(!strcmp((char *)rec->ExceptionInformation[3], "Hello World"),
           "ExceptionInformation[3] = '%s' instead of 'Hello World'\n", (char *)rec->ExceptionInformation[3]);
        outputdebugstring_exceptions_newmodel_order =
            (outputdebugstring_exceptions_newmodel_order << 8) | 'W';
        break;
    default:
        ok(0, "ExceptionCode is %08lx unexpected\n", rec->ExceptionCode);
        break;
    }
 
    return outputdebugstring_newmodel_return;
}

Referenced by test_outputdebugstring_newmodel().

outputdebugstring_vectored_handler()

static LONG CALLBACK outputdebugstring_vectored_handler ( EXCEPTION_POINTERS *  ExceptionInfo )

static

Definition at line 8864 of file exception.c.

{
    PEXCEPTION_RECORD rec = ExceptionInfo->ExceptionRecord;
 
    switch (rec->ExceptionCode)
    {
    case DBG_PRINTEXCEPTION_C:
        ok(rec->NumberParameters == 2, "ExceptionParameters is %ld instead of 2\n", rec->NumberParameters);
        ok(rec->ExceptionInformation[0] == 12, "ExceptionInformation[0] = %ld instead of 12\n", (DWORD)rec->ExceptionInformation[0]);
        ok(!strcmp((char *)rec->ExceptionInformation[1], "Hello World"),
           "ExceptionInformation[1] = '%s' instead of 'Hello World'\n", (char *)rec->ExceptionInformation[1]);
        outputdebugstring_exceptions_ansi++;
        break;
    case DBG_PRINTEXCEPTION_WIDE_C:
        ok(outputdebugstring_exceptions_ansi == 0, "Unicode exception should come first\n");
        ok(rec->NumberParameters == 4, "ExceptionParameters is %ld instead of 4\n", rec->NumberParameters);
        ok(rec->ExceptionInformation[0] == 12, "ExceptionInformation[0] = %ld instead of 12\n", (DWORD)rec->ExceptionInformation[0]);
        ok(!wcscmp((WCHAR *)rec->ExceptionInformation[1], L"Hello World"),
           "ExceptionInformation[1] = '%s' instead of 'Hello World'\n", (char *)rec->ExceptionInformation[1]);
        ok(rec->ExceptionInformation[2] == 12, "ExceptionInformation[2] = %ld instead of 12\n", (DWORD)rec->ExceptionInformation[2]);
        ok(!strcmp((char *)rec->ExceptionInformation[3], "Hello World"),
           "ExceptionInformation[3] = '%s' instead of 'Hello World'\n", (char *)rec->ExceptionInformation[3]);
        outputdebugstring_exceptions_unicode++;
        break;
    default:
        ok(0, "ExceptionCode is %08lx unexpected\n", rec->ExceptionCode);
        break;
    }
 
    return EXCEPTION_CONTINUE_SEARCH;
}

Referenced by test_outputdebugstring().

pLocateXStateFeature()

static void *WINAPI * pLocateXStateFeature ( CONTEXT *  context, DWORD  feature_id, DWORD *  length  )

static

pRtlGetUnloadEventTrace()

static RTL_UNLOAD_EVENT_TRACE *WINAPI * pRtlGetUnloadEventTrace ( void  )

static

Referenced by test_unload_trace().

pRtlLocateExtendedFeature()

static void *WINAPI * pRtlLocateExtendedFeature ( CONTEXT_EX *  context_ex, ULONG  feature_id, ULONG *  length  )

static

pRtlLocateLegacyContext()

static void *WINAPI * pRtlLocateLegacyContext ( CONTEXT_EX *  context_ex, ULONG *  length  )

static

pRtlPcToFileHeader()

static void *WINAPI * pRtlPcToFileHeader ( PVOID  pc, PVOID *  address  )

static

PVOID()

static PVOID ( WINAPI *  pRtlUnwind )

static

ripevent_vectored_handler()

static LONG CALLBACK ripevent_vectored_handler ( EXCEPTION_POINTERS *  ExceptionInfo )

static

Definition at line 9015 of file exception.c.

{
    PEXCEPTION_RECORD rec = ExceptionInfo->ExceptionRecord;
 
    ok(rec->ExceptionCode == DBG_RIPEXCEPTION, "ExceptionCode is %08lx instead of %08lx\n",
       rec->ExceptionCode, DBG_RIPEXCEPTION);
    ok(rec->NumberParameters == 2, "ExceptionParameters is %ld instead of 2\n", rec->NumberParameters);
    ok(rec->ExceptionInformation[0] == 0x11223344, "ExceptionInformation[0] = %08lx instead of %08x\n",
       (NTSTATUS)rec->ExceptionInformation[0], 0x11223344);
    ok(rec->ExceptionInformation[1] == 0x55667788, "ExceptionInformation[1] = %08lx instead of %08x\n",
       (NTSTATUS)rec->ExceptionInformation[1], 0x55667788);
 
    ripevent_exceptions++;
    return (rec->ExceptionCode == DBG_RIPEXCEPTION) ? EXCEPTION_CONTINUE_EXECUTION : EXCEPTION_CONTINUE_SEARCH;
}

Referenced by test_ripevent().

START_TEST()

START_TEST

(

exception

)

Definition at line 11947 of file exception.c.

{
    HMODULE hkernel32 = GetModuleHandleA("kernel32.dll");
    hntdll = GetModuleHandleA("ntdll.dll");
 
    my_argc = winetest_get_mainargs( &my_argv );
 
    if (my_argc >= 3 && !strcmp(my_argv[2], "suspend_process"))
    {
        suspend_process_proc();
        return;
    }
 
    code_mem = VirtualAlloc(NULL, 65536, MEM_RESERVE | MEM_COMMIT, PAGE_EXECUTE_READWRITE);
    if(!code_mem) {
        trace("VirtualAlloc failed\n");
        return;
    }
 
#define X(f) p##f = (void*)GetProcAddress(hntdll, #f)
    X(NtGetContextThread);
    X(NtSetContextThread);
    X(NtQueueApcThread);
    X(NtContinueEx);
    X(NtReadVirtualMemory);
    X(NtClose);
    X(RtlUnwind);
    X(RtlRaiseException);
    X(RtlCaptureContext);
    X(NtTerminateProcess);
    X(RtlAddVectoredExceptionHandler);
    X(RtlRemoveVectoredExceptionHandler);
    X(RtlAddVectoredContinueHandler);
    X(RtlRemoveVectoredContinueHandler);
    X(RtlSetUnhandledExceptionFilter);
    X(NtQueryInformationThread);
    X(NtSetInformationProcess);
    X(NtSuspendProcess);
    X(NtRaiseException);
    X(NtResumeProcess);
    X(RtlGetUnloadEventTrace);
    X(RtlGetUnloadEventTraceEx);
    X(RtlGetEnabledExtendedFeatures);
    X(RtlGetExtendedContextLength);
    X(RtlGetExtendedContextLength2);
    X(RtlInitializeExtendedContext);
    X(RtlInitializeExtendedContext2);
    X(RtlLocateExtendedFeature);
    X(RtlLocateLegacyContext);
    X(RtlSetExtendedFeaturesMask);
    X(RtlGetExtendedFeaturesMask);
    X(RtlPcToFileHeader);
    X(RtlGetCallersAddress);
    X(RtlCopyContext);
    X(RtlCopyExtendedContext);
    X(KiUserApcDispatcher);
    X(KiUserCallbackDispatcher);
    X(KiUserExceptionDispatcher);
#ifndef __i386__
    X(RtlRestoreContext);
    X(RtlUnwindEx);
    X(RtlAddFunctionTable);
    X(RtlDeleteFunctionTable);
    X(RtlGetNativeSystemInformation);
#endif
 
#ifdef __x86_64__
    if (pRtlGetNativeSystemInformation)
    {
        SYSTEM_CPU_INFORMATION info;
        ULONG len;
        if (!pRtlGetNativeSystemInformation( SystemCpuInformation, &info, sizeof(info), &len ))
            is_arm64ec = (info.ProcessorArchitecture == PROCESSOR_ARCHITECTURE_ARM64);
    }
#endif
#undef X
 
#define X(f) p##f = (void*)GetProcAddress(hkernel32, #f)
    X(IsWow64Process);
    if (!pIsWow64Process || !pIsWow64Process( GetCurrentProcess(), &is_wow64 )) is_wow64 = FALSE;
    if (is_wow64)
    {
        TEB64 *teb64 = ULongToPtr( NtCurrentTeb()->GdiBatchCount );
 
        if (teb64)
        {
            PEB64 *peb64 = ULongToPtr(teb64->Peb);
            old_wow64 = !peb64->LdrData;
        }
    }
 
    X(InitializeContext);
    X(InitializeContext2);
    X(LocateXStateFeature);
    X(SetXStateFeaturesMask);
    X(GetXStateFeaturesMask);
    X(WaitForDebugEventEx);
#undef X
 
    if (pRtlAddVectoredExceptionHandler && pRtlRemoveVectoredExceptionHandler)
        have_vectored_api = TRUE;
    else
        skip("RtlAddVectoredExceptionHandler or RtlRemoveVectoredExceptionHandler not found\n");
 
    my_argc = winetest_get_mainargs( &my_argv );
    if (my_argc >= 4)
    {
        void *addr;
 
        if (strcmp(my_argv[2], "fastfail") == 0)
        {
            __fastfail(strtoul(my_argv[3], NULL, 0));
            return;
        }
 
        sscanf( my_argv[3], "%p", &addr );
 
        if (addr != &test_stage)
        {
            skip( "child process not mapped at same address (%p/%p)\n", &test_stage, addr);
            return;
        }
 
        /* child must be run under a debugger */
        if (!NtCurrentTeb()->Peb->BeingDebugged)
        {
            ok(FALSE, "child process not being debugged?\n");
            return;
        }
 
        if (pRtlRaiseException)
        {
            test_stage = STAGE_RTLRAISE_NOT_HANDLED;
            run_rtlraiseexception_test(0x12345);
            run_rtlraiseexception_test(EXCEPTION_BREAKPOINT);
            run_rtlraiseexception_test(EXCEPTION_INVALID_HANDLE);
            test_stage = STAGE_RTLRAISE_HANDLE_LAST_CHANCE;
            run_rtlraiseexception_test(0x12345);
            run_rtlraiseexception_test(EXCEPTION_BREAKPOINT);
            run_rtlraiseexception_test(EXCEPTION_INVALID_HANDLE);
        }
        else skip( "RtlRaiseException not found\n" );
 
        test_stage = STAGE_OUTPUTDEBUGSTRINGA_CONTINUE;
 
        test_outputdebugstring(FALSE, 0, FALSE, 0, 0);
        test_stage = STAGE_OUTPUTDEBUGSTRINGA_NOT_HANDLED;
        test_outputdebugstring(FALSE, 2, TRUE,  0, 0); /* is 2 a Windows bug? */
        test_stage = STAGE_OUTPUTDEBUGSTRINGW_CONTINUE;
        /* depending on value passed DebugContinue we can get the unicode exception or not */
        test_outputdebugstring(TRUE, 0, FALSE, 0, 1);
        test_stage = STAGE_OUTPUTDEBUGSTRINGW_NOT_HANDLED;
        /* depending on value passed DebugContinue we can get the unicode exception or not */
        test_outputdebugstring(TRUE, 2, TRUE, 0, 1); /* is 2 a Windows bug? */
        test_stage = STAGE_RIPEVENT_CONTINUE;
        test_ripevent(0);
        test_stage = STAGE_RIPEVENT_NOT_HANDLED;
        test_ripevent(1);
        test_stage = STAGE_SERVICE_CONTINUE;
        test_debug_service(0);
        test_stage = STAGE_SERVICE_NOT_HANDLED;
        test_debug_service(1);
        test_stage = STAGE_BREAKPOINT_CONTINUE;
        test_breakpoint(0);
        test_stage = STAGE_BREAKPOINT_NOT_HANDLED;
        test_breakpoint(1);
        test_stage = STAGE_EXCEPTION_INVHANDLE_CONTINUE;
        test_closehandle(0, (HANDLE)0xdeadbeef);
        test_closehandle(0, (HANDLE)0x7fffffff);
        test_stage = STAGE_EXCEPTION_INVHANDLE_NOT_HANDLED;
        test_closehandle(1, (HANDLE)0xdeadbeef);
        test_closehandle(1, (HANDLE)~(ULONG_PTR)6);
        test_stage = STAGE_NO_EXCEPTION_INVHANDLE_NOT_HANDLED; /* special cases */
        test_closehandle(0, 0);
        test_closehandle(0, INVALID_HANDLE_VALUE);
        test_closehandle(0, GetCurrentProcess());
        test_closehandle(0, GetCurrentThread());
        test_closehandle(0, (HANDLE)~(ULONG_PTR)2);
        test_closehandle(0, GetCurrentProcessToken());
        test_closehandle(0, GetCurrentThreadToken());
        test_closehandle(0, GetCurrentThreadEffectiveToken());
#if defined(__i386__) || defined(__x86_64__)
        test_stage = STAGE_XSTATE;
        test_debuggee_xstate();
        test_stage = STAGE_XSTATE_LEGACY_SSE;
        test_debuggee_xstate();
        test_stage = STAGE_SEGMENTS;
        test_debuggee_segments();
#endif
 
        /* rest of tests only run in parent */
        return;
    }
 
#ifdef __i386__
 
    test_unwind();
    test_exceptions();
    test_debug_registers();
    test_debug_service(1);
    test_simd_exceptions();
    test_fpu_exceptions();
    test_dpe_exceptions();
    test_prot_fault();
    test_extended_context();
    test_copy_context();
    test_set_live_context();
    test_hwbpt_in_syscall();
    test_instrumentation_callback();
 
#elif defined(__x86_64__)
 
#define X(f) p##f = (void*)GetProcAddress(hntdll, #f)
    X(__C_specific_handler);
    X(RtlWow64GetThreadContext);
    X(RtlWow64SetThreadContext);
    X(RtlWow64GetCpuAreaInfo);
#undef X
 
    test_exceptions();
    test_debug_registers();
    test_debug_registers_wow64();
    test_debug_service(1);
    test_simd_exceptions();
    test_continue();
    test___C_specific_handler();
    test_restore_context();
    test_prot_fault();
    test_dpe_exceptions();
    test_wow64_context();
    test_nested_exception();
    test_collided_unwind();
    test_extended_context();
    test_copy_context();
    test_set_live_context();
    test_unwind_from_apc();
    test_syscall_clobbered_regs();
    test_raiseexception_regs();
    test_hwbpt_in_syscall();
    test_instrumentation_callback();
    test_direct_syscalls();
 
#elif defined(__aarch64__)
 
    test_continue();
    test_brk();
    test_nested_exception();
    test_collided_unwind();
    test_restore_context();
    test_mrs_currentel();
 
#elif defined(__arm__)
 
    test_nested_exception();
    test_collided_unwind();
    test_restore_context();
 
#endif
 
    test_KiUserExceptionDispatcher();
    test_KiUserApcDispatcher();
    test_KiUserCallbackDispatcher();
    test_rtlraiseexception();
    test_debugger(DBG_EXCEPTION_HANDLED, FALSE);
    test_debugger(DBG_CONTINUE, FALSE);
    test_debugger(DBG_EXCEPTION_HANDLED, TRUE);
    test_debugger(DBG_CONTINUE, TRUE);
    test_thread_context();
    test_outputdebugstring(FALSE, 1, FALSE, 0, 0);
    if (pWaitForDebugEventEx)
    {
        test_outputdebugstring(TRUE, 1, FALSE, 1, 1);
        test_outputdebugstring_newmodel();
    }
    else
        skip("Unsupported new unicode debug string model\n");
 
    test_ripevent(1);
    test_fastfail();
    test_breakpoint(1);
    test_closehandle(0, (HANDLE)0xdeadbeef);
    /* Call of Duty WWII writes to BeingDebugged then closes an invalid handle,
     * crashing the game if an exception is raised. */
    NtCurrentTeb()->Peb->BeingDebugged = 0x98;
    test_closehandle(0, (HANDLE)0xdeadbeef);
    NtCurrentTeb()->Peb->BeingDebugged = 0;
 
    test_user_apc();
    test_user_callback();
    test_vectored_continue_handler();
    test_suspend_thread();
    test_suspend_process();
    test_unload_trace();
    test_backtrace();
    test_context_exception_request();
    VirtualFree(code_mem, 0, MEM_RELEASE);
}

subtest_fastfail()

static void subtest_fastfail ( unsigned int  code )

static

Definition at line 9061 of file exception.c.

{
    char cmdline[MAX_PATH];
    PROCESS_INFORMATION pi;
    STARTUPINFOA si = { 0 };
    DEBUG_EVENT de;
    DWORD continuestatus;
    BOOL ret;
    BOOL had_ff = FALSE, had_se = FALSE;
 
    sprintf(cmdline, "%s %s %s %u", my_argv[0], my_argv[1], "fastfail", code);
    si.cb = sizeof(si);
    ret = CreateProcessA(NULL, cmdline, NULL, NULL, FALSE, DEBUG_PROCESS, NULL, NULL, &si, &pi);
    ok(ret, "could not create child process error: %lu\n", GetLastError());
    if (!ret)
        return;
 
    do
    {
        continuestatus = DBG_CONTINUE;
        ok(WaitForDebugEvent(&de, INFINITE), "reading debug event\n");
 
        if (de.dwDebugEventCode == EXCEPTION_DEBUG_EVENT)
        {
            if (de.u.Exception.ExceptionRecord.ExceptionCode == STATUS_STACK_BUFFER_OVERRUN)
            {
                ok(!de.u.Exception.dwFirstChance, "must be a second chance exception\n");
                ok(de.u.Exception.ExceptionRecord.NumberParameters == 1 || broken(is_arm64ec),
                   "expected exactly one parameter, got %lu\n",
                   de.u.Exception.ExceptionRecord.NumberParameters);
                if (de.u.Exception.ExceptionRecord.NumberParameters >= 1)
                    ok(de.u.Exception.ExceptionRecord.ExceptionInformation[0] == code,
                       "expected %u for code, got %Iu\n",
                       code, de.u.Exception.ExceptionRecord.ExceptionInformation[0]);
                had_ff = TRUE;
            }
 
            if (de.u.Exception.dwFirstChance)
            {
                continuestatus = DBG_EXCEPTION_NOT_HANDLED;
            }
            else
            {
                had_se = TRUE;
                pNtTerminateProcess(pi.hProcess, 0);
            }
        }
 
        ContinueDebugEvent(de.dwProcessId, de.dwThreadId, continuestatus);
 
    } while (de.dwDebugEventCode != EXIT_PROCESS_DEBUG_EVENT);
 
    ok(had_ff || broken(had_se) /* Win7 */, "fast fail did not occur\n");
 
    wait_child_process( pi.hProcess );
    ret = CloseHandle(pi.hThread);
    ok(ret, "error %lu\n", GetLastError());
    ret = CloseHandle(pi.hProcess);
    ok(ret, "error %lu\n", GetLastError());
 
    return;
}

Referenced by test_fastfail().

suspend_process_proc()

static void suspend_process_proc ( void  )

static

Definition at line 9619 of file exception.c.

{
    HANDLE event = OpenEventA(SYNCHRONIZE, FALSE, suspend_process_event_name);
    HANDLE event2 = OpenEventA(SYNCHRONIZE | EVENT_MODIFY_STATE, FALSE, suspend_process_event2_name);
    DWORD count;
    NTSTATUS status;
    HANDLE thread;
 
    ok(event != NULL, "Failed to open event handle.\n");
    ok(event2 != NULL, "Failed to open event handle.\n");
 
    thread = CreateThread(NULL, 0, dummy_thread_proc, 0, CREATE_SUSPENDED, NULL);
    ok(thread != NULL, "Failed to create auxiliary thread.\n");
 
    /* Suspend up to limit. */
    while (!(status = NtSuspendThread(thread, NULL)))
        ;
    ok(status == STATUS_SUSPEND_COUNT_EXCEEDED, "Unexpected status %#lx.\n", status);
 
    for (;;)
    {
        SetEvent(event2);
        if (WaitForSingleObject(event, 100) == WAIT_OBJECT_0)
            break;
    }
 
    status = NtSuspendThread(thread, &count);
    ok(!status, "Failed to suspend a thread, status %#lx.\n", status);
    ok(count == 125, "Unexpected suspend count %lu.\n", count);
 
    status = NtResumeThread(thread, NULL);
    ok(!status, "Failed to resume a thread, status %#lx.\n", status);
 
    CloseHandle(event);
    CloseHandle(event2);
}

suspend_thread_test()

static DWORD WINAPI suspend_thread_test ( void *  arg )

static

Definition at line 9497 of file exception.c.

{
    HANDLE event = arg;
    WaitForSingleObject(event, INFINITE);
    return 0;
}

Referenced by test_suspend_thread().

test_backtrace()

static void test_backtrace ( void  )

static

Definition at line 11590 of file exception.c.

{
    void *buffer[1024];
    WCHAR name[MAX_PATH];
    void *module;
    ULONG hash, hash_expect;
    int i, count = RtlCaptureStackBackTrace( 0, 1024, buffer, &hash );
 
    ok( count > 0, "got %u entries\n", count );
    for (i = hash_expect = 0; i < count; i++) hash_expect += (ULONG_PTR)buffer[i];
    ok( hash == hash_expect, "hash mismatch %lx / %lx\n", hash, hash_expect );
    pRtlPcToFileHeader( buffer[0], &module );
    if (is_arm64ec && module == hntdll)  /* Windows arm64ec has an extra frame for the entry thunk */
    {
        ok( count > 1, "wrong count %u\n", count );
        pRtlPcToFileHeader( buffer[1], &module );
    }
    GetModuleFileNameW( module, name, ARRAY_SIZE(name) );
    ok( module == GetModuleHandleA(0), "wrong module %p %s / %p for %p\n",
        module, debugstr_w(name), GetModuleHandleA(0), buffer[0]);
 
    if (pRtlGetCallersAddress)
    {
        void *caller, *parent;
 
        caller = parent = (void *)0xdeadbeef;
        pRtlGetCallersAddress( &caller, &parent );
        ok( caller == (count > 1 ? buffer[1] : NULL) || broken(is_arm64ec), /* caller is entry thunk */
            "wrong caller %p / %p\n", caller, buffer[1] );
        ok( parent == (count > 2 ? buffer[2] : NULL), "wrong parent %p / %p\n", parent, buffer[2] );
    }
    else win_skip( "RtlGetCallersAddress not supported\n" );
 
    if (count && !buffer[count - 1]) count--;  /* win11 32-bit */
    if (count <= 1) return;
    pRtlPcToFileHeader( buffer[count - 1], &module );
    GetModuleFileNameW( module, name, ARRAY_SIZE(name) );
    ok( module == hntdll, "wrong module %p %s for frame %u %p\n",
        module, debugstr_w(name), count - 1, buffer[count - 1] );
}

test_breakpoint()

static void test_breakpoint ( DWORD  numexc )

static

Definition at line 9203 of file exception.c.

{
    DWORD (CDECL *func)(void) = code_mem;
    void *vectored_handler;
 
#if defined(__REACTOS__)
    if (is_reactos())
    {
        skip("Skipping tests that crash\n");
        return;
    }
#endif
 
    memcpy(code_mem, breakpoint_code, sizeof(breakpoint_code));
#ifdef __arm__
    func = (void *)((char *)code_mem + 1);  /* thumb */
#endif
    vectored_handler = pRtlAddVectoredExceptionHandler(TRUE, &breakpoint_handler);
    ok(vectored_handler != 0, "RtlAddVectoredExceptionHandler failed\n");
 
    breakpoint_exceptions = 0;
    func();
    ok(breakpoint_exceptions == numexc, "int $0x3 generated %lu exceptions, expected %lu\n",
       breakpoint_exceptions, numexc);
 
    pRtlRemoveVectoredExceptionHandler(vectored_handler);
}

test_closehandle()

static void test_closehandle ( DWORD  numexc, HANDLE  handle  )

static

Definition at line 9336 of file exception.c.

{
    NTSTATUS status, expect;
    PVOID vectored_handler;
    BOOL ret, expectret;
 
    if (!pRtlAddVectoredExceptionHandler || !pRtlRemoveVectoredExceptionHandler || !pRtlRaiseException)
    {
        skip("RtlAddVectoredExceptionHandler or RtlRemoveVectoredExceptionHandler or RtlRaiseException not found\n");
        return;
    }
 
    vectored_handler = pRtlAddVectoredExceptionHandler(TRUE, &invalid_handle_vectored_handler);
    ok(vectored_handler != 0, "RtlAddVectoredExceptionHandler failed\n");
 
    invalid_handle_exceptions = 0;
    expectret = is_magic_handle(handle) || broken(numexc && sizeof(handle) == 4); /* < Win10 */
    ret = CloseHandle(handle);
    ok(ret || (GetLastError() == ERROR_INVALID_HANDLE),
        "CloseHandle had wrong GetLastError(), got %lu for %p\n", GetLastError(), handle);
    ok(ret == expectret || broken(HandleToLong(handle) < 0) /* < Win10 */,
        "CloseHandle expected %d, got %d for %p\n", expectret, ret, handle);
    ok(invalid_handle_exceptions == numexc || broken(!numexc && is_magic_handle(handle)), /* < Win10 */
        "CloseHandle generated %ld exceptions, expected %ld for %p\n",
       invalid_handle_exceptions, numexc, handle);
 
    invalid_handle_exceptions = 0;
    expect = expectret ? STATUS_SUCCESS : STATUS_INVALID_HANDLE;
    status = pNtClose(handle);
    ok(status == expect || broken(HandleToLong(handle) < 0), /* < Win10 */
        "NtClose returned unexpected status %#lx, expected %#lx for %p\n", status, expect, handle);
    ok(invalid_handle_exceptions == numexc || broken(!numexc && is_magic_handle(handle)), /* < Win10 */
        "CloseHandle generated %ld exceptions, expected %ld for %p\n",
       invalid_handle_exceptions, numexc, handle);
 
    pRtlRemoveVectoredExceptionHandler(vectored_handler);
}

test_context_exception_request()

static void test_context_exception_request ( void  )

static

Definition at line 11758 of file exception.c.

{
    struct context_exception_request_thread_param p;
    DWORD expected_flags;
    HANDLE thread;
    CONTEXT c;
    BOOL ret;
 
    if (!pRtlAddVectoredExceptionHandler || !pRtlRemoveVectoredExceptionHandler)
    {
        skip( "RtlAddVectoredExceptionHandler or RtlRemoveVectoredExceptionHandler not found.\n" );
        return;
    }
 
    c.ContextFlags = CONTEXT_CONTROL;
    ret = GetThreadContext( GetCurrentThread(), &c );
    ok( ret, "got error %lu.\n", GetLastError() );
    ok( c.ContextFlags == CONTEXT_CONTROL, "got %#lx.\n", c.ContextFlags );
 
    expected_flags = CONTEXT_CONTROL | CONTEXT_EXCEPTION_REQUEST | CONTEXT_EXCEPTION_REPORTING | CONTEXT_SERVICE_ACTIVE;
 
    c.ContextFlags = CONTEXT_CONTROL | CONTEXT_EXCEPTION_REQUEST;
    ret = GetThreadContext( GetCurrentThread(), &c );
    ok( ret, "got error %lu.\n", GetLastError() );
    ok( c.ContextFlags == expected_flags || broken( c.ContextFlags == 0x10001 ) /* Win7 WoW64 */,
        "got %#lx.\n", c.ContextFlags );
    if (c.ContextFlags == 0x10001)
    {
        win_skip( "Old WoW64 behaviour, skipping tests.\n" );
        return;
    }
 
    ret = DuplicateHandle( GetCurrentProcess(), GetCurrentThread(), GetCurrentProcess(), &thread, 0, TRUE, DUPLICATE_SAME_ACCESS );
    ok( ret, "got error %lu.\n", GetLastError() );
    c.ContextFlags = expected_flags | CONTEXT_EXCEPTION_REQUEST;
 
    c.ContextFlags = CONTEXT_CONTROL | CONTEXT_EXCEPTION_REQUEST;
    ret = GetThreadContext( thread, &c );
    ok( ret, "got error %lu.\n", GetLastError() );
    ok( c.ContextFlags == expected_flags, "got %#lx.\n", c.ContextFlags );
    CloseHandle( thread );
 
    c.ContextFlags = CONTEXT_CONTROL | CONTEXT_EXCEPTION_REQUEST | CONTEXT_EXCEPTION_REPORTING | CONTEXT_SERVICE_ACTIVE
                     | CONTEXT_EXCEPTION_ACTIVE;
    ret = GetThreadContext( GetCurrentThread(), &c );
    ok( ret, "got error %lu.\n", GetLastError() );
    ok( c.ContextFlags == expected_flags, "got %#lx.\n", c.ContextFlags );
 
    p.event = CreateEventW( NULL, FALSE, FALSE, NULL );
    thread = CreateThread( NULL, 0, test_context_exception_request_thread, &p, CREATE_SUSPENDED, NULL );
    ok( !!thread, "got error %lu.\n", GetLastError() );
 
    expected_flags = CONTEXT_CONTROL | CONTEXT_EXCEPTION_REQUEST | CONTEXT_EXCEPTION_REPORTING | CONTEXT_EXCEPTION_ACTIVE;
 
    c.ContextFlags = CONTEXT_CONTROL | CONTEXT_EXCEPTION_REQUEST;
    ret = GetThreadContext( thread, &c );
    ok( ret, "got error %lu.\n", GetLastError() );
    ok( c.ContextFlags == expected_flags || broken( c.ContextFlags == (CONTEXT_CONTROL
        | CONTEXT_EXCEPTION_REQUEST | CONTEXT_EXCEPTION_REPORTING)) /* Win7 64 */, "got %#lx.\n", c.ContextFlags );
 
    p.sync = 0;
    ResumeThread(thread);
 
    while (ReadAcquire( &p.sync ) != 1)
        SwitchToThread();
    /* thread is in user code. */
    SuspendThread( thread );
 
    c.ContextFlags = CONTEXT_CONTROL;
    ret = GetThreadContext( thread, &c );
    ok( ret, "got error %lu.\n", GetLastError() );
    ok( c.ContextFlags == CONTEXT_CONTROL, "got %#lx.\n", c.ContextFlags );
 
    c.ContextFlags = CONTEXT_CONTROL | CONTEXT_EXCEPTION_REQUEST | CONTEXT_EXCEPTION_REPORTING | CONTEXT_SERVICE_ACTIVE;
    ret = SetThreadContext( thread, &c );
    ok( ret, "got error %lu.\n", GetLastError() );
 
    expected_flags = CONTEXT_CONTROL | CONTEXT_EXCEPTION_REQUEST | CONTEXT_EXCEPTION_REPORTING;
 
    c.ContextFlags = CONTEXT_CONTROL | CONTEXT_EXCEPTION_REQUEST;
    ret = GetThreadContext( thread, &c );
    ok( ret, "got error %lu.\n", GetLastError() );
    ok( c.ContextFlags == expected_flags, "got %#lx.\n", c.ContextFlags );
 
    c.ContextFlags = CONTEXT_CONTROL | CONTEXT_EXCEPTION_REQUEST | CONTEXT_EXCEPTION_REPORTING | CONTEXT_SERVICE_ACTIVE
                     | CONTEXT_EXCEPTION_ACTIVE;
    ret = GetThreadContext( thread, &c );
    ok( ret, "got error %lu.\n", GetLastError() );
    ok( c.ContextFlags == expected_flags, "got %#lx.\n", c.ContextFlags );
 
    ResumeThread(thread);
    WriteRelease( &p.sync, 2 );
    /* Try to make sure the thread entered WaitForSingleObject(). */
    Sleep(30);
 
    expected_flags = CONTEXT_CONTROL | CONTEXT_EXCEPTION_REQUEST | CONTEXT_EXCEPTION_REPORTING | CONTEXT_SERVICE_ACTIVE;
 
    c.ContextFlags = CONTEXT_CONTROL | CONTEXT_EXCEPTION_REQUEST;
    ret = GetThreadContext( thread, &c );
    ok( ret, "got error %lu.\n", GetLastError() );
    ok( c.ContextFlags == expected_flags, "got %#lx.\n", c.ContextFlags );
 
    c.ContextFlags = CONTEXT_CONTROL;
    ret = SetThreadContext( thread, &c );
    ok( ret, "got error %lu.\n", GetLastError() );
 
    c.ContextFlags = CONTEXT_CONTROL | CONTEXT_EXCEPTION_REQUEST | CONTEXT_EXCEPTION_REPORTING | CONTEXT_SERVICE_ACTIVE
                     | CONTEXT_EXCEPTION_ACTIVE;
    ret = GetThreadContext( thread, &c );
    ok( ret, "got error %lu.\n", GetLastError() );
    ok( c.ContextFlags == expected_flags, "got %#lx.\n", c.ContextFlags );
 
    SetEvent( p.event );
 
    if (is_wow64 && !old_wow64)
    {
        while (ReadAcquire( &p.sync ) != 3)
            SwitchToThread();
        /* thread is in x64 code. */
 
        expected_flags = CONTEXT_CONTROL | CONTEXT_EXCEPTION_REQUEST | CONTEXT_EXCEPTION_REPORTING | CONTEXT_EXCEPTION_ACTIVE;
 
        c.ContextFlags = CONTEXT_CONTROL | CONTEXT_EXCEPTION_REQUEST;
        ret = GetThreadContext( thread, &c );
        ok( ret, "got error %lu.\n", GetLastError() );
        ok( c.ContextFlags == expected_flags, "got %#lx, expected %#lx.\n", c.ContextFlags, expected_flags );
 
        WriteRelease( &p.sync, 4 );
    }
 
    while (ReadAcquire( &p.sync ) != 5)
        SwitchToThread();
 
#if defined(__REACTOS__) && defined(__i386__) && !defined(__GNUC__)
    if (is_wow64)
    {
        win_skip("Skipping on WOW64 with MSVC builds, because it makes the test crash\n");
        CloseHandle( thread );
        CloseHandle( p.event );
        return;
    }
#endif
 
    expected_flags = CONTEXT_CONTROL | CONTEXT_EXCEPTION_REQUEST | CONTEXT_EXCEPTION_REPORTING; // 0xC0010001
 
    c.ContextFlags = CONTEXT_CONTROL | CONTEXT_EXCEPTION_REQUEST;
    ret = GetThreadContext( thread, &c );
    ok( ret, "got error %lu.\n", GetLastError() );
#ifdef __REACTOS__
    if (GetNTVersion() < _WIN32_WINNT_VISTA)
        ok( c.ContextFlags == (expected_flags & ~CONTEXT_EXCEPTION_REPORTING), "got %#lx.\n", c.ContextFlags );
    else
#endif
    ok( c.ContextFlags == expected_flags, "got %#lx.\n", c.ContextFlags );
 
    c.ContextFlags = CONTEXT_CONTROL | CONTEXT_EXCEPTION_REQUEST | CONTEXT_EXCEPTION_REPORTING | CONTEXT_SERVICE_ACTIVE
                     | CONTEXT_EXCEPTION_ACTIVE;
    ret = GetThreadContext( thread, &c );
    ok( ret, "got error %lu.\n", GetLastError() );
#ifdef __REACTOS__
    if (GetNTVersion() < _WIN32_WINNT_VISTA)
        ok( c.ContextFlags == (expected_flags | CONTEXT_SERVICE_ACTIVE | CONTEXT_EXCEPTION_ACTIVE), "got %#lx, expected %#lx.\n", c.ContextFlags, expected_flags );
    else
#endif
    ok( c.ContextFlags == expected_flags, "got %#lx.\n", c.ContextFlags );
 
    WriteRelease( &p.sync, 6 );
 
    if (is_wow64 && !old_wow64)
    {
        while (ReadAcquire( &p.sync ) != 7)
            SwitchToThread();
        /* thread is in x64 code. */
 
        expected_flags = CONTEXT_CONTROL | CONTEXT_EXCEPTION_REQUEST | CONTEXT_EXCEPTION_REPORTING | CONTEXT_EXCEPTION_ACTIVE;
 
        c.ContextFlags = CONTEXT_CONTROL | CONTEXT_EXCEPTION_REQUEST;
        ret = GetThreadContext( thread, &c );
        ok( ret, "got error %lu.\n", GetLastError() );
        ok( c.ContextFlags == expected_flags, "got %#lx, expected %#lx.\n", c.ContextFlags, expected_flags );
 
        WriteRelease( &p.sync, 8 );
    }
 
    WaitForSingleObject( thread, INFINITE );
    CloseHandle( thread );
    CloseHandle( p.event );
}

test_context_exception_request_handler()

static LONG CALLBACK test_context_exception_request_handler ( EXCEPTION_POINTERS *  info )

static

Definition at line 11639 of file exception.c.

{
    PEXCEPTION_RECORD rec = info->ExceptionRecord;
    CONTEXT *c = info->ContextRecord;
    DWORD old_prot;
 
    ok( !(c->ContextFlags & (CONTEXT_EXCEPTION_REQUEST | CONTEXT_EXCEPTION_REPORTING | CONTEXT_SERVICE_ACTIVE
                             | CONTEXT_EXCEPTION_ACTIVE)), "got %#lx.\n", c->ContextFlags );
 
    ok( rec->ExceptionCode == EXCEPTION_ACCESS_VIOLATION, "got %#lx.\n", rec->ExceptionCode );
    VirtualProtect( (void *)p_context_exception_request_value, sizeof(*p_context_exception_request_value),
                    PAGE_READWRITE, &old_prot );
 
    WriteRelease( &context_exception_request_param->sync, 5 );
    while (ReadAcquire( &context_exception_request_param->sync ) != 6)
        ;
 
    return EXCEPTION_CONTINUE_EXECUTION;
}

test_context_exception_request_thread()

static DWORD WINAPI test_context_exception_request_thread ( void *  arg )

static

Definition at line 11707 of file exception.c.

{
#ifdef __i386__
    static BYTE wait_sync_x64_code[] =
    {
        0x89, 0x11,       /* mov %edx,(%rcx) */
        0x83, 0xc2, 0x01, /* add $0x1,%edx */
        0x0f, 0x1f, 0x00, /* 1: nopl   (%rax) */
        0x8b, 0x01,       /* mov (%rcx),%eax */
        0x39, 0xd0,       /* cmp %edx,%eax */
        0x75, 0xfa,       /* jne 1b */
        0xc3,             /* ret */
    };
    ULONG64 args[2];
#endif
    struct context_exception_request_thread_param *p = arg;
    void *vectored_handler;
 
    context_exception_request_param = p;
    vectored_handler = pRtlAddVectoredExceptionHandler( TRUE, test_context_exception_request_handler );
    ok( !!vectored_handler, "failed.\n" );
 
    WriteRelease( &p->sync, 1 );
    while (ReadAcquire( &p->sync ) != 2)
        ;
 
    WaitForSingleObject( p->event, INFINITE );
 
#ifdef __i386__
    memcpy( (char *)code_mem + 1024, wait_sync_x64_code, sizeof(wait_sync_x64_code) );
    args[0] = (ULONG_PTR)&p->sync;
    args[1] = 3;
    if (is_wow64 && !old_wow64) call_func64( (ULONG64)(ULONG_PTR)code_mem + 1024, ARRAY_SIZE(args), args, code_mem );
#endif
 
    p_context_exception_request_value = VirtualAlloc( NULL, sizeof(*p_context_exception_request_value),
                                                      MEM_RESERVE | MEM_COMMIT, PAGE_READONLY );
    ok( !!p_context_exception_request_value, "got NULL.\n" );
    *p_context_exception_request_value = 1;
    ok( *p_context_exception_request_value == 1, "got %d.\n", *p_context_exception_request_value );
    VirtualFree( (void *)p_context_exception_request_value, 0, MEM_RELEASE );
    pRtlRemoveVectoredExceptionHandler( vectored_handler );
 
#ifdef __i386__
    args[1] = 7;
    if (is_wow64 && !old_wow64) call_func64( (ULONG64)(ULONG_PTR)code_mem + 1024, ARRAY_SIZE(args), args, code_mem );
#endif
 
    return 0;
}

test_fastfail()

static void test_fastfail ( void  )

static

Definition at line 9124 of file exception.c.

{
    unsigned int codes[] = {
        FAST_FAIL_LEGACY_GS_VIOLATION,
        FAST_FAIL_VTGUARD_CHECK_FAILURE,
        FAST_FAIL_STACK_COOKIE_CHECK_FAILURE,
        FAST_FAIL_CORRUPT_LIST_ENTRY,
        FAST_FAIL_INCORRECT_STACK,
        FAST_FAIL_INVALID_ARG,
        FAST_FAIL_GS_COOKIE_INIT,
        FAST_FAIL_FATAL_APP_EXIT,
        FAST_FAIL_INVALID_FAST_FAIL_CODE,
        0xdeadbeefUL,
    };
    unsigned int i;
 
    for (i = 0; i < ARRAY_SIZE(codes); i++)
    {
        winetest_push_context("__fastfail(%#x)", codes[i]);
        subtest_fastfail(codes[i]);
        winetest_pop_context();
    }
}

test_outputdebugstring()

static void test_outputdebugstring ( BOOL  unicode, DWORD  numexc_ansi, BOOL  todo_ansi, DWORD  numexc_unicode_low, DWORD  numexc_unicode_high  )

static

Definition at line 8896 of file exception.c.

{
    PVOID vectored_handler;
 
    if (!pRtlAddVectoredExceptionHandler || !pRtlRemoveVectoredExceptionHandler)
    {
        skip("RtlAddVectoredExceptionHandler or RtlRemoveVectoredExceptionHandler not found\n");
        return;
    }
 
    vectored_handler = pRtlAddVectoredExceptionHandler(TRUE, &outputdebugstring_vectored_handler);
    ok(vectored_handler != 0, "RtlAddVectoredExceptionHandler failed\n");
 
    outputdebugstring_exceptions_ansi = outputdebugstring_exceptions_unicode = 0;
 
    if (unicode)
        OutputDebugStringW(L"Hello World");
    else
        OutputDebugStringA("Hello World");
 
    todo_wine_if(todo_ansi)
    ok(outputdebugstring_exceptions_ansi == numexc_ansi,
       "OutputDebugString%c generated %ld ansi exceptions, expected %ld\n",
       unicode ? 'W' : 'A', outputdebugstring_exceptions_ansi, numexc_ansi);
    ok(outputdebugstring_exceptions_unicode >= numexc_unicode_low &&
       outputdebugstring_exceptions_unicode <= numexc_unicode_high,
       "OutputDebugString%c generated %lu unicode exceptions, expected %ld-%ld\n",
       unicode ? 'W' : 'A', outputdebugstring_exceptions_unicode, numexc_unicode_low, numexc_unicode_high);
 
    pRtlRemoveVectoredExceptionHandler(vectored_handler);
}

test_outputdebugstring_newmodel()

static void test_outputdebugstring_newmodel ( void  )

static

Definition at line 8965 of file exception.c.

{
    PVOID vectored_handler;
    struct
    {
        /* input */
        BOOL unicode;
        DWORD ret_code;
        /* expected output */
        DWORD exceptions_order;
    }
    tests[] =
    {
        {FALSE, EXCEPTION_CONTINUE_EXECUTION, 'A'},
        {FALSE, EXCEPTION_CONTINUE_SEARCH,    'A'},
        {TRUE,  EXCEPTION_CONTINUE_EXECUTION, 'W'},
        {TRUE,  EXCEPTION_CONTINUE_SEARCH,    ('W' << 8) | 'A'},
    };
    int i;
 
    if (!pRtlAddVectoredExceptionHandler || !pRtlRemoveVectoredExceptionHandler)
    {
        skip("RtlAddVectoredExceptionHandler or RtlRemoveVectoredExceptionHandler not found\n");
        return;
    }
 
    vectored_handler = pRtlAddVectoredExceptionHandler(TRUE, &outputdebugstring_new_model_vectored_handler);
    ok(vectored_handler != 0, "RtlAddVectoredExceptionHandler failed\n");
 
    for (i = 0; i < ARRAY_SIZE(tests); i++)
    {
        outputdebugstring_exceptions_newmodel_order = 0;
        outputdebugstring_newmodel_return = tests[i].ret_code;
 
        if (tests[i].unicode)
            OutputDebugStringW(L"Hello World");
        else
            OutputDebugStringA("Hello World");
 
        ok(outputdebugstring_exceptions_newmodel_order == tests[i].exceptions_order,
           "OutputDebugString%c/%u generated exceptions %04lxs, expected %04lx\n",
           tests[i].unicode ? 'W' : 'A', i,
           outputdebugstring_exceptions_newmodel_order, tests[i].exceptions_order);
    }
 
    pRtlRemoveVectoredExceptionHandler(vectored_handler);
}

test_ripevent()

static void test_ripevent ( DWORD  numexc )

static

Definition at line 9031 of file exception.c.

{
    EXCEPTION_RECORD record;
    PVOID vectored_handler;
 
    if (!pRtlAddVectoredExceptionHandler || !pRtlRemoveVectoredExceptionHandler || !pRtlRaiseException)
    {
        skip("RtlAddVectoredExceptionHandler or RtlRemoveVectoredExceptionHandler or RtlRaiseException not found\n");
        return;
    }
 
    vectored_handler = pRtlAddVectoredExceptionHandler(TRUE, &ripevent_vectored_handler);
    ok(vectored_handler != 0, "RtlAddVectoredExceptionHandler failed\n");
 
    record.ExceptionCode = DBG_RIPEXCEPTION;
    record.ExceptionFlags = 0;
    record.ExceptionRecord = NULL;
    record.ExceptionAddress = NULL;
    record.NumberParameters = 2;
    record.ExceptionInformation[0] = 0x11223344;
    record.ExceptionInformation[1] = 0x55667788;
 
    ripevent_exceptions = 0;
    pRtlRaiseException(&record);
    ok(ripevent_exceptions == numexc, "RtlRaiseException generated %ld exceptions, expected %ld\n",
       ripevent_exceptions, numexc);
 
    pRtlRemoveVectoredExceptionHandler(vectored_handler);
}

test_suspend_count()

static void test_suspend_count ( HANDLE  hthread, ULONG  expected_count, int  line  )

static

Definition at line 9504 of file exception.c.

{
    static BOOL supported = TRUE;
    NTSTATUS status;
    ULONG count;
 
    if (!supported)
        return;
 
    count = ~0u;
    status = pNtQueryInformationThread(hthread, ThreadSuspendCount, &count, sizeof(count), NULL);
    if (status)
    {
        win_skip("ThreadSuspendCount is not supported.\n");
        supported = FALSE;
        return;
    }
 
    ok_(__FILE__, line)(!status, "Failed to get suspend count, status %#lx.\n", status);
    ok_(__FILE__, line)(count == expected_count, "Unexpected suspend count %lu.\n", count);
}

test_suspend_process()

static void test_suspend_process ( void  )

static

Definition at line 9656 of file exception.c.

{
    PROCESS_INFORMATION info;
    char path_name[MAX_PATH];
    STARTUPINFOA startup;
    HANDLE event, event2;
    NTSTATUS status;
    char **argv;
    DWORD ret;
 
    event = CreateEventA(NULL, FALSE, FALSE, suspend_process_event_name);
    ok(event != NULL, "Failed to create event.\n");
 
    event2 = CreateEventA(NULL, FALSE, FALSE, suspend_process_event2_name);
    ok(event2 != NULL, "Failed to create event.\n");
 
    winetest_get_mainargs(&argv);
    memset(&startup, 0, sizeof(startup));
    startup.cb = sizeof(startup);
    sprintf(path_name, "%s exception suspend_process", argv[0]);
 
    ret = CreateProcessA(NULL, path_name, NULL, NULL, FALSE, 0, NULL, NULL, &startup, &info);
    ok(ret, "Failed to create target process.\n");
 
    /* New process signals this event. */
    ResetEvent(event2);
    ret = WaitForSingleObject(event2, INFINITE);
    ok(ret == WAIT_OBJECT_0, "Wait failed, %#lx.\n", ret);
 
    /* Suspend main thread */
    status = NtSuspendThread(info.hThread, &ret);
    ok(!status && !ret, "Failed to suspend main thread, status %#lx.\n", status);
 
    /* Process wasn't suspended yet. */
    status = pNtResumeProcess(info.hProcess);
    ok(!status, "Failed to resume a process, status %#lx.\n", status);
 
    status = pNtSuspendProcess(0);
    ok(status == STATUS_INVALID_HANDLE, "Unexpected status %#lx.\n", status);
 
    status = pNtResumeProcess(info.hProcess);
    ok(!status, "Failed to resume a process, status %#lx.\n", status);
 
    ResetEvent(event2);
    ret = WaitForSingleObject(event2, 200);
    ok(ret == WAIT_OBJECT_0, "Wait failed.\n");
 
    status = pNtSuspendProcess(info.hProcess);
    ok(!status, "Failed to suspend a process, status %#lx.\n", status);
 
    status = NtSuspendThread(info.hThread, &ret);
    ok(!status && ret == 1, "Failed to suspend main thread, status %#lx.\n", status);
    status = NtResumeThread(info.hThread, &ret);
    ok(!status && ret == 2, "Failed to resume main thread, status %#lx.\n", status);
 
    ResetEvent(event2);
    ret = WaitForSingleObject(event2, 200);
    ok(ret == WAIT_TIMEOUT, "Wait failed.\n");
 
    status = pNtSuspendProcess(info.hProcess);
    ok(!status, "Failed to suspend a process, status %#lx.\n", status);
 
    status = pNtResumeProcess(info.hProcess);
    ok(!status, "Failed to resume a process, status %#lx.\n", status);
 
    ResetEvent(event2);
    ret = WaitForSingleObject(event2, 200);
    ok(ret == WAIT_TIMEOUT, "Wait failed.\n");
 
    status = pNtResumeProcess(info.hProcess);
    ok(!status, "Failed to resume a process, status %#lx.\n", status);
 
    ResetEvent(event2);
    ret = WaitForSingleObject(event2, 1000);
    ok(ret == WAIT_OBJECT_0, "Wait failed.\n");
 
    SetEvent(event);
 
    wait_child_process(info.hProcess);
 
    CloseHandle(info.hProcess);
    CloseHandle(info.hThread);
 
    CloseHandle(event);
    CloseHandle(event2);
}

test_suspend_thread()

static void test_suspend_thread ( void  )

static

Definition at line 9526 of file exception.c.

{
#define TEST_SUSPEND_COUNT(thread, count) test_suspend_count((thread), (count), __LINE__)
    HANDLE thread, event;
    ULONG count, len;
    NTSTATUS status;
    DWORD ret;
 
    status = NtSuspendThread(0, NULL);
    ok(status == STATUS_INVALID_HANDLE, "Unexpected return value %#lx.\n", status);
 
    status = NtResumeThread(0, NULL);
    ok(status == STATUS_INVALID_HANDLE, "Unexpected return value %#lx.\n", status);
 
    event = CreateEventW(NULL, FALSE, FALSE, NULL);
 
    thread = CreateThread(NULL, 0, suspend_thread_test, event, 0, NULL);
    ok(thread != NULL, "Failed to create a thread.\n");
 
    ret = WaitForSingleObject(thread, 0);
    ok(ret == WAIT_TIMEOUT, "Unexpected status %ld.\n", ret);
 
    status = pNtQueryInformationThread(thread, ThreadSuspendCount, &count, sizeof(count), NULL);
    if (!status)
    {
        status = pNtQueryInformationThread(thread, ThreadSuspendCount, NULL, sizeof(count), NULL);
        ok(status == STATUS_ACCESS_VIOLATION, "Unexpected status %#lx.\n", status);
 
        status = pNtQueryInformationThread(thread, ThreadSuspendCount, &count, sizeof(count) / 2, NULL);
        ok(status == STATUS_INFO_LENGTH_MISMATCH, "Unexpected status %#lx.\n", status);
 
        len = 123;
        status = pNtQueryInformationThread(thread, ThreadSuspendCount, &count, sizeof(count) / 2, &len);
        ok(status == STATUS_INFO_LENGTH_MISMATCH, "Unexpected status %#lx.\n", status);
        ok(len == 123, "Unexpected info length %lu.\n", len);
 
        len = 123;
        status = pNtQueryInformationThread(thread, ThreadSuspendCount, NULL, 0, &len);
        ok(status == STATUS_INFO_LENGTH_MISMATCH, "Unexpected status %#lx.\n", status);
        ok(len == 123, "Unexpected info length %lu.\n", len);
 
        count = 10;
        status = pNtQueryInformationThread(0, ThreadSuspendCount, &count, sizeof(count), NULL);
        ok(status, "Unexpected status %#lx.\n", status);
        ok(count == 10, "Unexpected suspend count %lu.\n", count);
    }
 
    status = NtResumeThread(thread, NULL);
    ok(!status, "Unexpected status %#lx.\n", status);
 
    status = NtResumeThread(thread, &count);
    ok(!status, "Unexpected status %#lx.\n", status);
    ok(count == 0, "Unexpected suspended count %lu.\n", count);
 
    TEST_SUSPEND_COUNT(thread, 0);
 
    status = NtSuspendThread(thread, NULL);
    ok(!status, "Failed to suspend a thread, status %#lx.\n", status);
 
    TEST_SUSPEND_COUNT(thread, 1);
 
    status = NtSuspendThread(thread, &count);
    ok(!status, "Failed to suspend a thread, status %#lx.\n", status);
    ok(count == 1, "Unexpected suspended count %lu.\n", count);
 
    TEST_SUSPEND_COUNT(thread, 2);
 
    status = NtResumeThread(thread, &count);
    ok(!status, "Failed to resume a thread, status %#lx.\n", status);
    ok(count == 2, "Unexpected suspended count %lu.\n", count);
 
    TEST_SUSPEND_COUNT(thread, 1);
 
    status = NtResumeThread(thread, NULL);
    ok(!status, "Failed to resume a thread, status %#lx.\n", status);
 
    TEST_SUSPEND_COUNT(thread, 0);
 
    SetEvent(event);
    WaitForSingleObject(thread, INFINITE);
 
    CloseHandle(thread);
#undef TEST_SUSPEND_COUNT
}

test_unload_trace()

static void test_unload_trace ( void  )

static

Definition at line 9743 of file exception.c.

{
    static const WCHAR imageW[] = {'m','s','x','m','l','3','.','d','l','l',0};
    RTL_UNLOAD_EVENT_TRACE *unload_trace, **unload_trace_ex = NULL, *ptr;
    ULONG *element_size, *element_count, size;
    HMODULE hmod;
    BOOL found;
 
    unload_trace = pRtlGetUnloadEventTrace();
    ok(unload_trace != NULL, "Failed to get unload events pointer.\n");
 
    if (pRtlGetUnloadEventTraceEx)
    {
        pRtlGetUnloadEventTraceEx(&element_size, &element_count, (void **)&unload_trace_ex);
        ok(*element_size >= sizeof(*ptr), "Unexpected element size.\n");
        ok(*element_count == RTL_UNLOAD_EVENT_TRACE_NUMBER, "Unexpected trace element count %lu.\n", *element_count);
        ok(unload_trace_ex != NULL, "Unexpected pointer %p.\n", unload_trace_ex);
        size = *element_size;
    }
    else
        size = sizeof(*unload_trace);
 
    hmod = LoadLibraryA("msxml3.dll");
    ok(hmod != NULL, "Failed to load library.\n");
    FreeLibrary(hmod);
 
    found = FALSE;
    ptr = unload_trace;
    while (ptr->BaseAddress != NULL)
    {
        if (!lstrcmpW(imageW, ptr->ImageName))
        {
            found = TRUE;
            break;
        }
        ptr = (RTL_UNLOAD_EVENT_TRACE *)((char *)ptr + size);
    }
    ok(found, "Unloaded module wasn't found.\n");
 
    if (unload_trace_ex)
    {
        found = FALSE;
        ptr = *unload_trace_ex;
        while (ptr->BaseAddress != NULL)
        {
            if (!lstrcmpW(imageW, ptr->ImageName))
            {
                found = TRUE;
                break;
            }
            ptr = (RTL_UNLOAD_EVENT_TRACE *)((char *)ptr + size);
        }
        ok(found, "Unloaded module wasn't found.\n");
    }
}

test_user_apc()

static void test_user_apc ( void  )

static

Definition at line 9411 of file exception.c.

{
    NTSTATUS status;
    CONTEXT context;
    LONG pass;
    int ret;
 
    if (!pNtQueueApcThread)
    {
        win_skip("NtQueueApcThread is not available.\n");
        return;
    }
 
    pass = 0;
    InterlockedIncrement(&pass);
#ifdef __i386__
    {
        /* RtlCaptureContext puts the return address of the caller's stack
         * frame into %eip, so we need a thunk to get it to return here */
        static const BYTE code[] =
        {
            0x55,               /* pushl %ebp */
            0x89, 0xe5,         /* movl %esp, %ebp */
            0xff, 0x75, 0x0c,   /* pushl 0xc(%ebp) */
            0xff, 0x55, 0x08,   /* call *0x8(%ebp) */
            0xc9,               /* leave */
            0xc3,               /* ret */
        };
        int (__cdecl *func)(void *capture, CONTEXT *context) = code_mem;
 
        memcpy(code_mem, code, sizeof(code));
        ret = func(RtlCaptureContext, &context);
        /* work around broken RtlCaptureContext on Windows < 7 which doesn't set
         * ContextFlags */
        context.ContextFlags = CONTEXT_FULL;
    }
#else
    {
        int (WINAPI *func)(CONTEXT *context) = (void *)RtlCaptureContext;
 
        ret = func(&context);
    }
#endif
    InterlockedIncrement(&pass);
 
    if (pass == 2)
    {
        /* Try to make sure context data is far enough below context.Esp. */
        CONTEXT c[4];
 
#ifdef __i386__
        context.Eax = 0xabacab;
#elif defined(__x86_64__)
        context.Rax = 0xabacab;
#elif defined(__arm__)
        context.R0 = 0xabacab;
#elif defined(__aarch64__)
        context.X0 = 0xabacab;
#endif
 
        c[0] = context;
 
        apc_count = 0;
        status = pNtQueueApcThread(GetCurrentThread(), apc_func, 0x1234, 0x5678, 0xdeadbeef);
        ok(!status, "Got unexpected status %#lx.\n", status);
        SleepEx(0, TRUE);
        ok(apc_count == 1, "Test user APC was not called.\n");
        apc_count = 0;
        status = pNtQueueApcThread(GetCurrentThread(), apc_func, 0x1234, 0x5678, 0xdeadbeef);
        ok(!status, "Got unexpected status %#lx.\n", status);
        status = NtContinue(&c[0], TRUE );
 
        ok(0, "Should not get here, status %#lx.\n", status);
        return;
    }
    ok(ret == 0xabacab, "Got return value %#x.\n", ret);
    ok(pass == 3, "Got unexpected pass %ld.\n", pass);
    ok(apc_count > 0, "Test user APC was not called.\n");
}

test_user_callback()

static void test_user_callback ( void  )

static

Definition at line 9491 of file exception.c.

{
    NTSTATUS status = NtCallbackReturn( NULL, 0, STATUS_SUCCESS );
    ok( status == STATUS_NO_CALLBACK_ACTIVE, "failed %lx\n", status );
}

test_vectored_continue_handler()

static void test_vectored_continue_handler ( void  )

static

Definition at line 9374 of file exception.c.

{
    PVOID handler1, handler2;
    ULONG ret;
 
    if (!pRtlAddVectoredContinueHandler || !pRtlRemoveVectoredContinueHandler)
    {
        skip("RtlAddVectoredContinueHandler or RtlRemoveVectoredContinueHandler not found\n");
        return;
    }
 
    handler1 = pRtlAddVectoredContinueHandler(TRUE, (void *)0xdeadbeef);
    ok(handler1 != 0, "RtlAddVectoredContinueHandler failed\n");
 
    handler2 = pRtlAddVectoredContinueHandler(TRUE, (void *)0xdeadbeef);
    ok(handler2 != 0, "RtlAddVectoredContinueHandler failed\n");
    ok(handler1 != handler2, "RtlAddVectoredContinueHandler returned same handler\n");
 
    if (pRtlRemoveVectoredExceptionHandler)
    {
        ret = pRtlRemoveVectoredExceptionHandler(handler1);
        ok(!ret, "RtlRemoveVectoredExceptionHandler succeeded\n");
    }
 
    ret = pRtlRemoveVectoredContinueHandler(handler1);
    ok(ret, "RtlRemoveVectoredContinueHandler failed\n");
 
    ret = pRtlRemoveVectoredContinueHandler(handler2);
    ok(ret, "RtlRemoveVectoredContinueHandler failed\n");
 
    ret = pRtlRemoveVectoredContinueHandler(handler1);
    ok(!ret, "RtlRemoveVectoredContinueHandler succeeded\n");
 
    ret = pRtlRemoveVectoredContinueHandler((void *)0x11223344);
    ok(!ret, "RtlRemoveVectoredContinueHandler succeeded\n");
}

ULONG()

static ULONG ( WINAPI *  pRtlRemoveVectoredExceptionHandler )

static

ULONG64()

static ULONG64 ( WINAPI *  pRtlGetEnabledExtendedFeatures )

static

VOID() [1/2]

static VOID ( CDECL *  pRtlRestoreContext )

static

VOID() [2/2]

static VOID ( WINAPI *  pRtlCaptureContext )

static

void()

static void ( WINAPI *  pRtlSetUnhandledExceptionFilter )

static

Variable Documentation

apc_count

UINT apc_count

static

Definition at line 190 of file exception.c.

Referenced by apc_func(), and test_user_apc().

arg1

CONTEXT *static CONTEXT *static PNTAPCFUNC ULONG_PTR arg1

Definition at line 58 of file exception.c.

arg2

CONTEXT *static CONTEXT *static PNTAPCFUNC ULONG_PTR ULONG_PTR arg2

Definition at line 58 of file exception.c.

arg3

CONTEXT *static CONTEXT *static PNTAPCFUNC ULONG_PTR ULONG_PTR ULONG_PTR arg3

Definition at line 58 of file exception.c.

breakpoint_exceptions

DWORD breakpoint_exceptions

static

Definition at line 9148 of file exception.c.

Referenced by breakpoint_handler(), and test_breakpoint().

code_mem

void* code_mem

static

Definition at line 51 of file exception.c.

Referenced by breakpoint_handler(), test_breakpoint(), test_builtins(), and test_user_apc().

compaction_mask

static DWORD CONTEXT DWORD ULONG64 compaction_mask

Definition at line 70 of file exception.c.

Referenced by InitializeContext2().

context

DWORD CONTEXT** context

Definition at line 82 of file exception.c.

Referenced by test_user_apc().

context_ex

static ULONG CONTEXT_EX ** context_ex

Definition at line 71 of file exception.c.

Referenced by test_cpu_area().

context_exception_request_param

struct context_exception_request_thread_param* context_exception_request_param

Definition at line 11637 of file exception.c.

context_flags

static DWORD context_flags

Definition at line 71 of file exception.c.

Referenced by CopyContext(), InitializeContext(), and InitializeContext2().

DWORD

VOID EXCEPTION_RECORD VOID CONTEXT UNWIND_HISTORY_TABLE *static DWORD

Definition at line 98 of file exception.c.

Referenced by breakpoint_handler(), and test_breakpoint().

DWORD64

VOID EXCEPTION_RECORD VOID CONTEXT UNWIND_HISTORY_TABLE *static DWORD64

Definition at line 101 of file exception.c.

element_count

ULONG** element_count

Definition at line 124 of file exception.c.

Referenced by _fread_nolock(), _fread_nolock_s(), _fwrite_nolock(), _fwrite_nolock_internal(), convert_to_wined3d_declaration(), d3d9_vertex_declaration_GetDeclaration(), d3d_viewport_LightElements(), d3drm_array_reserve(), d3dx_effect_GetMatrixArray(), d3dx_effect_GetMatrixPointerArray(), d3dx_effect_GetMatrixTransposeArray(), d3dx_effect_GetMatrixTransposePointerArray(), d3dx_effect_GetParameterElement(), d3dx_effect_GetVectorArray(), d3dx_effect_SetMatrixPointerArray(), d3dx_effect_SetMatrixTransposePointerArray(), d3dx_set_shader_const_state(), fread(), fread_s(), get_constants_desc(), LoadHistMetadata(), merge_const_set_entries(), shader_glsl_declare_shader_inputs(), shader_glsl_declare_shader_outputs(), shader_glsl_init_transform_feedback(), test_unload_trace(), vertexdeclaration_init(), and wined3d_vertex_declaration_create().

event_trace

ULONG void** event_trace

Definition at line 124 of file exception.c.

exit_code

const void void SIZE_T *static LONG exit_code

Definition at line 84 of file exception.c.

feature_mask

static DWORD64 * feature_mask

Definition at line 78 of file exception.c.

Referenced by __acrt_GetXStateFeaturesMask(), and test_user_shared_data().

first_chance

void **static CONTEXT BOOL first_chance

Definition at line 82 of file exception.c.

Referenced by DECLARE_INTERFACE_().

func

PVECTORED_EXCEPTION_HANDLER func

Definition at line 57 of file exception.c.

Referenced by test_breakpoint(), and test_user_apc().

have_vectored_api

BOOL have_vectored_api

static

Definition at line 191 of file exception.c.

hntdll

HMODULE hntdll

static

Definition at line 52 of file exception.c.

invalid_handle_exceptions

DWORD invalid_handle_exceptions

static

Definition at line 9317 of file exception.c.

Referenced by invalid_handle_vectored_handler(), and test_closehandle().

is_arm64ec

BOOL is_arm64ec

static

Definition at line 53 of file exception.c.

Referenced by subtest_fastfail(), and test_query_architectures().

is_wow64

BOOL is_wow64

static

Definition at line 188 of file exception.c.

Referenced by breakpoint_handler().

length

DWORD CONTEXT DWORD* length

Definition at line 69 of file exception.c.

my_argc

int my_argc

static

Definition at line 186 of file exception.c.

Referenced by main().

my_argv

char** my_argv

static

Definition at line 187 of file exception.c.

Referenced by main(), and subtest_fastfail().

old_wow64

BOOL old_wow64

static

Definition at line 189 of file exception.c.

Referenced by test_thread_processor().

outputdebugstring_exceptions_ansi

DWORD outputdebugstring_exceptions_ansi

static

Definition at line 8861 of file exception.c.

Referenced by outputdebugstring_vectored_handler(), and test_outputdebugstring().

outputdebugstring_exceptions_newmodel_order

DWORD outputdebugstring_exceptions_newmodel_order

static

Definition at line 8929 of file exception.c.

Referenced by outputdebugstring_new_model_vectored_handler(), and test_outputdebugstring_newmodel().

outputdebugstring_exceptions_unicode

DWORD outputdebugstring_exceptions_unicode

static

Definition at line 8862 of file exception.c.

Referenced by outputdebugstring_vectored_handler(), and test_outputdebugstring().

outputdebugstring_newmodel_return

DWORD outputdebugstring_newmodel_return

static

Definition at line 8930 of file exception.c.

Referenced by outputdebugstring_new_model_vectored_handler(), and test_outputdebugstring_newmodel().

p_context_exception_request_value

volatile int* p_context_exception_request_value

static

Definition at line 11636 of file exception.c.

PBOOL

PBOOL

Definition at line 87 of file exception.c.

PEXCEPTION_RECORD

PEXCEPTION_RECORD

Definition at line 61 of file exception.c.

pKiUserApcDispatcher

EXCEPTION_RECORD *static void ULONG* static void* pKiUserApcDispatcher

static

Definition at line 107 of file exception.c.

pKiUserCallbackDispatcher

void* pKiUserCallbackDispatcher

static

Definition at line 108 of file exception.c.

pKiUserExceptionDispatcher

void* pKiUserExceptionDispatcher

static

Definition at line 109 of file exception.c.

PROCESSINFOCLASS

PROCESSINFOCLASS

Definition at line 86 of file exception.c.

PULONG

PULONG

Definition at line 85 of file exception.c.

Referenced by PrintStackTrace().

PVOID

PVOID

Definition at line 61 of file exception.c.

ripevent_exceptions

DWORD ripevent_exceptions

static

Definition at line 9013 of file exception.c.

Referenced by ripevent_vectored_handler(), and test_ripevent().

SIZE_T

const void void SIZE_T

Definition at line 83 of file exception.c.

src

ULONG CONTEXT_EX* src

Definition at line 74 of file exception.c.

suspend_process_event2_name

const char* suspend_process_event2_name = "suspend_process_event2"

static

Definition at line 9612 of file exception.c.

Referenced by suspend_process_proc(), and test_suspend_process().

suspend_process_event_name

const char* suspend_process_event_name = "suspend_process_event"

static

Definition at line 9611 of file exception.c.

Referenced by suspend_process_proc(), and test_suspend_process().

test_stage

enum debugger_stages test_stage

static

Definition at line 192 of file exception.c.

THREADINFOCLASS

THREADINFOCLASS

Definition at line 85 of file exception.c.

ULONG

EXCEPTION_RECORD *static void ULONG

Definition at line 85 of file exception.c.