2 * Unit test suite for ntdll exceptions
4 * Copyright 2005 Alexandre Julliard
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
25 #define _WIN32_WINNT 0x500 /* For NTSTATUS */
29 #define WIN32_NO_STATUS
36 #include "wine/test.h"
40 static char** my_argv
;
41 static int test_stage
;
43 static struct _TEB
* (WINAPI
*pNtCurrentTeb
)(void);
44 static NTSTATUS (WINAPI
*pNtGetContextThread
)(HANDLE
,CONTEXT
*);
45 static NTSTATUS (WINAPI
*pNtSetContextThread
)(HANDLE
,CONTEXT
*);
46 static NTSTATUS (WINAPI
*pRtlRaiseException
)(EXCEPTION_RECORD
*rec
);
47 static PVOID (WINAPI
*pRtlAddVectoredExceptionHandler
)(ULONG first
, PVECTORED_EXCEPTION_HANDLER func
);
48 static ULONG (WINAPI
*pRtlRemoveVectoredExceptionHandler
)(PVOID handler
);
49 static NTSTATUS (WINAPI
*pNtReadVirtualMemory
)(HANDLE
, const void*, void*, SIZE_T
, SIZE_T
*);
50 static NTSTATUS (WINAPI
*pNtTerminateProcess
)(HANDLE handle
, LONG exit_code
);
51 static void *code_mem
;
53 /* Test various instruction combinations that cause a protection fault on the i386,
54 * and check what the resulting exception looks like.
57 static const struct exception
59 BYTE code
[18]; /* asm code */
60 BYTE offset
; /* offset of faulting instruction */
61 BYTE length
; /* length of faulting instruction */
62 NTSTATUS status
; /* expected status code */
63 DWORD nb_params
; /* expected number of parameters */
64 DWORD params
[4]; /* expected parameters */
67 /* test some privileged instructions */
68 { { 0xfb, 0xc3 }, /* 0: sti; ret */
69 0, 1, STATUS_PRIVILEGED_INSTRUCTION
, 0 },
70 { { 0x6c, 0xc3 }, /* 1: insb (%dx); ret */
71 0, 1, STATUS_PRIVILEGED_INSTRUCTION
, 0 },
72 { { 0x6d, 0xc3 }, /* 2: insl (%dx); ret */
73 0, 1, STATUS_PRIVILEGED_INSTRUCTION
, 0 },
74 { { 0x6e, 0xc3 }, /* 3: outsb (%dx); ret */
75 0, 1, STATUS_PRIVILEGED_INSTRUCTION
, 0 },
76 { { 0x6f, 0xc3 }, /* 4: outsl (%dx); ret */
77 0, 1, STATUS_PRIVILEGED_INSTRUCTION
, 0 },
78 { { 0xe4, 0x11, 0xc3 }, /* 5: inb $0x11,%al; ret */
79 0, 2, STATUS_PRIVILEGED_INSTRUCTION
, 0 },
80 { { 0xe5, 0x11, 0xc3 }, /* 6: inl $0x11,%eax; ret */
81 0, 2, STATUS_PRIVILEGED_INSTRUCTION
, 0 },
82 { { 0xe6, 0x11, 0xc3 }, /* 7: outb %al,$0x11; ret */
83 0, 2, STATUS_PRIVILEGED_INSTRUCTION
, 0 },
84 { { 0xe7, 0x11, 0xc3 }, /* 8: outl %eax,$0x11; ret */
85 0, 2, STATUS_PRIVILEGED_INSTRUCTION
, 0 },
86 { { 0xed, 0xc3 }, /* 9: inl (%dx),%eax; ret */
87 0, 1, STATUS_PRIVILEGED_INSTRUCTION
, 0 },
88 { { 0xee, 0xc3 }, /* 10: outb %al,(%dx); ret */
89 0, 1, STATUS_PRIVILEGED_INSTRUCTION
, 0 },
90 { { 0xef, 0xc3 }, /* 11: outl %eax,(%dx); ret */
91 0, 1, STATUS_PRIVILEGED_INSTRUCTION
, 0 },
92 { { 0xf4, 0xc3 }, /* 12: hlt; ret */
93 0, 1, STATUS_PRIVILEGED_INSTRUCTION
, 0 },
94 { { 0xfa, 0xc3 }, /* 13: cli; ret */
95 0, 1, STATUS_PRIVILEGED_INSTRUCTION
, 0 },
97 /* test long jump to invalid selector */
98 { { 0xea, 0, 0, 0, 0, 0, 0, 0xc3 }, /* 14: ljmp $0,$0; ret */
99 0, 7, STATUS_ACCESS_VIOLATION
, 2, { 0, 0xffffffff } },
101 /* test iret to invalid selector */
102 { { 0x6a, 0x00, 0x6a, 0x00, 0x6a, 0x00, 0xcf, 0x83, 0xc4, 0x0c, 0xc3 },
103 /* 15: pushl $0; pushl $0; pushl $0; iret; addl $12,%esp; ret */
104 6, 1, STATUS_ACCESS_VIOLATION
, 2, { 0, 0xffffffff } },
106 /* test loading an invalid selector */
107 { { 0xb8, 0xef, 0xbe, 0x00, 0x00, 0x8e, 0xe8, 0xc3 }, /* 16: mov $beef,%ax; mov %ax,%gs; ret */
108 5, 2, STATUS_ACCESS_VIOLATION
, 2, { 0, 0xbee8 } }, /* 0xbee8 or 0xffffffff */
110 /* test accessing a zero selector */
111 { { 0x06, 0x31, 0xc0, 0x8e, 0xc0, 0x26, 0xa1, 0, 0, 0, 0, 0x07, 0xc3 },
112 /* 17: push %es; xor %eax,%eax; mov %ax,%es; mov %es:(0),%ax; pop %es; ret */
113 5, 6, STATUS_ACCESS_VIOLATION
, 2, { 0, 0xffffffff } },
115 /* test moving %cs -> %ss */
116 { { 0x0e, 0x17, 0x58, 0xc3 }, /* 18: pushl %cs; popl %ss; popl %eax; ret */
117 1, 1, STATUS_ACCESS_VIOLATION
, 2, { 0, 0xffffffff } },
119 /* 19: test overlong instruction (limit is 16 bytes) */
120 { { 0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0xfa,0xc3 },
121 0, 16, STATUS_ILLEGAL_INSTRUCTION
, 0 },
122 { { 0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0xfa,0xc3 },
123 0, 15, STATUS_PRIVILEGED_INSTRUCTION
, 0 },
125 /* test invalid interrupt */
126 { { 0xcd, 0xff, 0xc3 }, /* 21: int $0xff; ret */
127 0, 2, STATUS_ACCESS_VIOLATION
, 2, { 0, 0xffffffff } },
129 /* test moves to/from Crx */
130 { { 0x0f, 0x20, 0xc0, 0xc3 }, /* 22: movl %cr0,%eax; ret */
131 0, 3, STATUS_PRIVILEGED_INSTRUCTION
, 0 },
132 { { 0x0f, 0x20, 0xe0, 0xc3 }, /* 23: movl %cr4,%eax; ret */
133 0, 3, STATUS_PRIVILEGED_INSTRUCTION
, 0 },
134 { { 0x0f, 0x22, 0xc0, 0xc3 }, /* 24: movl %eax,%cr0; ret */
135 0, 3, STATUS_PRIVILEGED_INSTRUCTION
, 0 },
136 { { 0x0f, 0x22, 0xe0, 0xc3 }, /* 25: movl %eax,%cr4; ret */
137 0, 3, STATUS_PRIVILEGED_INSTRUCTION
, 0 },
139 /* test moves to/from Drx */
140 { { 0x0f, 0x21, 0xc0, 0xc3 }, /* 26: movl %dr0,%eax; ret */
141 0, 3, STATUS_PRIVILEGED_INSTRUCTION
, 0 },
142 { { 0x0f, 0x21, 0xc8, 0xc3 }, /* 27: movl %dr1,%eax; ret */
143 0, 3, STATUS_PRIVILEGED_INSTRUCTION
, 0 },
144 { { 0x0f, 0x21, 0xf8, 0xc3 }, /* 28: movl %dr7,%eax; ret */
145 0, 3, STATUS_PRIVILEGED_INSTRUCTION
, 0 },
146 { { 0x0f, 0x23, 0xc0, 0xc3 }, /* 29: movl %eax,%dr0; ret */
147 0, 3, STATUS_PRIVILEGED_INSTRUCTION
, 0 },
148 { { 0x0f, 0x23, 0xc8, 0xc3 }, /* 30: movl %eax,%dr1; ret */
149 0, 3, STATUS_PRIVILEGED_INSTRUCTION
, 0 },
150 { { 0x0f, 0x23, 0xf8, 0xc3 }, /* 31: movl %eax,%dr7; ret */
151 0, 3, STATUS_PRIVILEGED_INSTRUCTION
, 0 },
153 /* test memory reads */
154 { { 0xa1, 0xfc, 0xff, 0xff, 0xff, 0xc3 }, /* 32: movl 0xfffffffc,%eax; ret */
155 0, 5, STATUS_ACCESS_VIOLATION
, 2, { 0, 0xfffffffc } },
156 { { 0xa1, 0xfd, 0xff, 0xff, 0xff, 0xc3 }, /* 33: movl 0xfffffffd,%eax; ret */
157 0, 5, STATUS_ACCESS_VIOLATION
, 2, { 0, 0xfffffffd } },
158 { { 0xa1, 0xfe, 0xff, 0xff, 0xff, 0xc3 }, /* 34: movl 0xfffffffe,%eax; ret */
159 0, 5, STATUS_ACCESS_VIOLATION
, 2, { 0, 0xfffffffe } },
160 { { 0xa1, 0xff, 0xff, 0xff, 0xff, 0xc3 }, /* 35: movl 0xffffffff,%eax; ret */
161 0, 5, STATUS_ACCESS_VIOLATION
, 2, { 0, 0xffffffff } },
163 /* test memory writes */
164 { { 0xa3, 0xfc, 0xff, 0xff, 0xff, 0xc3 }, /* 36: movl %eax,0xfffffffc; ret */
165 0, 5, STATUS_ACCESS_VIOLATION
, 2, { 1, 0xfffffffc } },
166 { { 0xa3, 0xfd, 0xff, 0xff, 0xff, 0xc3 }, /* 37: movl %eax,0xfffffffd; ret */
167 0, 5, STATUS_ACCESS_VIOLATION
, 2, { 1, 0xfffffffd } },
168 { { 0xa3, 0xfe, 0xff, 0xff, 0xff, 0xc3 }, /* 38: movl %eax,0xfffffffe; ret */
169 0, 5, STATUS_ACCESS_VIOLATION
, 2, { 1, 0xfffffffe } },
170 { { 0xa3, 0xff, 0xff, 0xff, 0xff, 0xc3 }, /* 39: movl %eax,0xffffffff; ret */
171 0, 5, STATUS_ACCESS_VIOLATION
, 2, { 1, 0xffffffff } },
173 /* 40: test exception with cleared %ds and %es */
174 { { 0x1e, 0x06, 0x31, 0xc0, 0x8e, 0xd8, 0x8e, 0xc0, 0xfa, 0x07, 0x1f, 0xc3 },
175 /* push %ds; push %es; xorl %eax,%eax; mov %ax,%ds; mov %ax,%es; cli; pop %es; pop %ds; ret */
176 8, 1, STATUS_PRIVILEGED_INSTRUCTION
, 0 },
179 static int got_exception
;
180 static BOOL have_vectored_api
;
182 static void run_exception_test(void *handler
, const void* context
,
183 const void *code
, unsigned int code_size
)
186 EXCEPTION_REGISTRATION_RECORD frame
;
189 void (*func
)(void) = code_mem
;
191 exc_frame
.frame
.Handler
= handler
;
192 exc_frame
.frame
.Prev
= pNtCurrentTeb()->Tib
.ExceptionList
;
193 exc_frame
.context
= context
;
195 memcpy(code_mem
, code
, code_size
);
197 pNtCurrentTeb()->Tib
.ExceptionList
= &exc_frame
.frame
;
199 pNtCurrentTeb()->Tib
.ExceptionList
= exc_frame
.frame
.Prev
;
202 static LONG CALLBACK
rtlraiseexception_vectored_handler(EXCEPTION_POINTERS
*ExceptionInfo
)
204 PCONTEXT context
= ExceptionInfo
->ContextRecord
;
205 PEXCEPTION_RECORD rec
= ExceptionInfo
->ExceptionRecord
;
206 trace("vect. handler %08x addr:%p context.Eip:%x\n", rec
->ExceptionCode
,
207 rec
->ExceptionAddress
, context
->Eip
);
209 ok(rec
->ExceptionAddress
== (char *)code_mem
+ 0xb, "ExceptionAddress at %p instead of %p\n",
210 rec
->ExceptionAddress
, (char *)code_mem
+ 0xb);
212 if (pNtCurrentTeb()->Peb
->BeingDebugged
)
213 ok((void *)context
->Eax
== pRtlRaiseException
, "debugger managed to modify Eax to %x should be %p\n",
214 context
->Eax
, pRtlRaiseException
);
216 /* check that context.Eip is fixed up only for EXCEPTION_BREAKPOINT
217 * even if raised by RtlRaiseException
219 if(rec
->ExceptionCode
== EXCEPTION_BREAKPOINT
)
221 ok(context
->Eip
== (DWORD
)code_mem
+ 0xa ||
222 broken(context
->Eip
== (DWORD
)code_mem
+ 0xb), /* win2k3 */
223 "Eip at %x instead of %x or %x\n", context
->Eip
,
224 (DWORD
)code_mem
+ 0xa, (DWORD
)code_mem
+ 0xb);
228 ok(context
->Eip
== (DWORD
)code_mem
+ 0xb, "Eip at %x instead of %x\n",
229 context
->Eip
, (DWORD
)code_mem
+ 0xb);
232 /* test if context change is preserved from vectored handler to stack handlers */
233 context
->Eax
= 0xf00f00f0;
234 return EXCEPTION_CONTINUE_SEARCH
;
237 static DWORD
rtlraiseexception_handler( EXCEPTION_RECORD
*rec
, EXCEPTION_REGISTRATION_RECORD
*frame
,
238 CONTEXT
*context
, EXCEPTION_REGISTRATION_RECORD
**dispatcher
)
240 trace( "exception: %08x flags:%x addr:%p context: Eip:%x\n",
241 rec
->ExceptionCode
, rec
->ExceptionFlags
, rec
->ExceptionAddress
, context
->Eip
);
243 ok(rec
->ExceptionAddress
== (char *)code_mem
+ 0xb, "ExceptionAddress at %p instead of %p\n",
244 rec
->ExceptionAddress
, (char *)code_mem
+ 0xb);
246 /* check that context.Eip is fixed up only for EXCEPTION_BREAKPOINT
247 * even if raised by RtlRaiseException
249 if(rec
->ExceptionCode
== EXCEPTION_BREAKPOINT
)
251 ok(context
->Eip
== (DWORD
)code_mem
+ 0xa ||
252 broken(context
->Eip
== (DWORD
)code_mem
+ 0xb), /* win2k3 */
253 "Eip at %x instead of %x or %x\n", context
->Eip
,
254 (DWORD
)code_mem
+ 0xa, (DWORD
)code_mem
+ 0xb);
258 ok(context
->Eip
== (DWORD
)code_mem
+ 0xb, "Eip at %x instead of %x\n",
259 context
->Eip
, (DWORD
)code_mem
+ 0xb);
262 if(have_vectored_api
)
263 ok(context
->Eax
== 0xf00f00f0, "Eax is %x, should have been set to 0xf00f00f0 in vectored handler\n",
266 /* give the debugger a chance to examine the state a second time */
267 /* without the exception handler changing Eip */
269 return ExceptionContinueSearch
;
271 /* Eip in context is decreased by 1
272 * Increase it again, else execution will continue in the middle of a instruction */
273 if(rec
->ExceptionCode
== EXCEPTION_BREAKPOINT
&& (context
->Eip
== (DWORD
)code_mem
+ 0xa))
275 return ExceptionContinueExecution
;
279 static const BYTE call_one_arg_code
[] = {
280 0x8b, 0x44, 0x24, 0x08, /* mov 0x8(%esp),%eax */
281 0x50, /* push %eax */
282 0x8b, 0x44, 0x24, 0x08, /* mov 0x8(%esp),%eax */
283 0xff, 0xd0, /* call *%eax */
292 static void run_rtlraiseexception_test(DWORD exceptioncode
)
294 EXCEPTION_REGISTRATION_RECORD frame
;
295 EXCEPTION_RECORD record
;
296 PVOID vectored_handler
= NULL
;
298 void (*func
)(void* function
, EXCEPTION_RECORD
* record
) = code_mem
;
300 record
.ExceptionCode
= exceptioncode
;
301 record
.ExceptionFlags
= 0;
302 record
.ExceptionRecord
= NULL
;
303 record
.ExceptionAddress
= NULL
; /* does not matter, copied return address */
304 record
.NumberParameters
= 0;
306 frame
.Handler
= rtlraiseexception_handler
;
307 frame
.Prev
= pNtCurrentTeb()->Tib
.ExceptionList
;
309 memcpy(code_mem
, call_one_arg_code
, sizeof(call_one_arg_code
));
311 pNtCurrentTeb()->Tib
.ExceptionList
= &frame
;
312 if (have_vectored_api
)
314 vectored_handler
= pRtlAddVectoredExceptionHandler(TRUE
, &rtlraiseexception_vectored_handler
);
315 ok(vectored_handler
!= 0, "RtlAddVectoredExceptionHandler failed\n");
318 func(pRtlRaiseException
, &record
);
319 ok( record
.ExceptionAddress
== (char *)code_mem
+ 0x0b,
320 "address set to %p instead of %p\n", record
.ExceptionAddress
, (char *)code_mem
+ 0x0b );
322 if (have_vectored_api
)
323 pRtlRemoveVectoredExceptionHandler(vectored_handler
);
324 pNtCurrentTeb()->Tib
.ExceptionList
= frame
.Prev
;
327 static void test_rtlraiseexception(void)
329 if (!pRtlRaiseException
)
331 skip("RtlRaiseException not found\n");
335 /* test without debugger */
336 run_rtlraiseexception_test(0x12345);
337 run_rtlraiseexception_test(EXCEPTION_BREAKPOINT
);
338 run_rtlraiseexception_test(EXCEPTION_INVALID_HANDLE
);
341 static DWORD
handler( EXCEPTION_RECORD
*rec
, EXCEPTION_REGISTRATION_RECORD
*frame
,
342 CONTEXT
*context
, EXCEPTION_REGISTRATION_RECORD
**dispatcher
)
344 const struct exception
*except
= *(const struct exception
**)(frame
+ 1);
345 unsigned int i
, entry
= except
- exceptions
;
348 trace( "exception: %x flags:%x addr:%p\n",
349 rec
->ExceptionCode
, rec
->ExceptionFlags
, rec
->ExceptionAddress
);
351 ok( rec
->ExceptionCode
== except
->status
,
352 "%u: Wrong exception code %x/%x\n", entry
, rec
->ExceptionCode
, except
->status
);
353 ok( rec
->ExceptionAddress
== (char*)code_mem
+ except
->offset
,
354 "%u: Wrong exception address %p/%p\n", entry
,
355 rec
->ExceptionAddress
, (char*)code_mem
+ except
->offset
);
357 ok( rec
->NumberParameters
== except
->nb_params
,
358 "%u: Wrong number of parameters %u/%u\n", entry
, rec
->NumberParameters
, except
->nb_params
);
360 /* Most CPUs (except Intel Core apparently) report a segment limit violation */
361 /* instead of page faults for accesses beyond 0xffffffff */
362 if (except
->nb_params
== 2 && except
->params
[1] >= 0xfffffffd)
364 if (rec
->ExceptionInformation
[0] == 0 && rec
->ExceptionInformation
[1] == 0xffffffff)
368 /* Seems that both 0xbee8 and 0xfffffffff can be returned in windows */
369 if (except
->nb_params
== 2 && rec
->NumberParameters
== 2
370 && except
->params
[1] == 0xbee8 && rec
->ExceptionInformation
[1] == 0xffffffff
371 && except
->params
[0] == rec
->ExceptionInformation
[0])
376 for (i
= 0; i
< rec
->NumberParameters
; i
++)
377 ok( rec
->ExceptionInformation
[i
] == except
->params
[i
],
378 "%u: Wrong parameter %d: %lx/%x\n",
379 entry
, i
, rec
->ExceptionInformation
[i
], except
->params
[i
] );
382 /* don't handle exception if it's not the address we expected */
383 if (rec
->ExceptionAddress
!= (char*)code_mem
+ except
->offset
) return ExceptionContinueSearch
;
385 context
->Eip
+= except
->length
;
386 return ExceptionContinueExecution
;
389 static void test_prot_fault(void)
393 for (i
= 0; i
< sizeof(exceptions
)/sizeof(exceptions
[0]); i
++)
396 run_exception_test(handler
, &exceptions
[i
], &exceptions
[i
].code
,
397 sizeof(exceptions
[i
].code
));
398 if (!i
&& !got_exception
)
400 trace( "No exception, assuming win9x, no point in testing further\n" );
403 ok( got_exception
== (exceptions
[i
].status
!= 0),
404 "%u: bad exception count %d\n", i
, got_exception
);
408 /* test handling of debug registers */
409 static DWORD
dreg_handler( EXCEPTION_RECORD
*rec
, EXCEPTION_REGISTRATION_RECORD
*frame
,
410 CONTEXT
*context
, EXCEPTION_REGISTRATION_RECORD
**dispatcher
)
412 context
->Eip
+= 2; /* Skips the popl (%eax) */
413 context
->Dr0
= 0x42424242;
418 context
->Dr7
= 0x155;
419 return ExceptionContinueExecution
;
422 static const BYTE segfault_code
[5] = {
423 0x31, 0xc0, /* xor %eax,%eax */
424 0x8f, 0x00, /* popl (%eax) - cause exception */
428 /* test the single step exception behaviour */
429 static DWORD
single_step_handler( EXCEPTION_RECORD
*rec
, EXCEPTION_REGISTRATION_RECORD
*frame
,
430 CONTEXT
*context
, EXCEPTION_REGISTRATION_RECORD
**dispatcher
)
433 ok (!(context
->EFlags
& 0x100), "eflags has single stepping bit set\n");
435 if( got_exception
< 3)
436 context
->EFlags
|= 0x100; /* single step until popf instruction */
438 /* show that the last single step exception on the popf instruction
439 * (which removed the TF bit), still is a EXCEPTION_SINGLE_STEP exception */
440 ok( rec
->ExceptionCode
== EXCEPTION_SINGLE_STEP
,
441 "exception is not EXCEPTION_SINGLE_STEP: %x\n", rec
->ExceptionCode
);
444 return ExceptionContinueExecution
;
447 static const BYTE single_stepcode
[] = {
450 0x0d,0,1,0,0, /* or $0x100,%eax */
451 0x50, /* push %eax */
453 0x35,0,1,0,0, /* xor $0x100,%eax */
454 0x50, /* push %eax */
459 /* Test the alignment check (AC) flag handling. */
460 static const BYTE align_check_code
[] = {
461 0x55, /* push %ebp */
462 0x89,0xe5, /* mov %esp,%ebp */
465 0x0d,0,0,4,0, /* or $0x40000,%eax */
466 0x50, /* push %eax */
468 0x89,0xe0, /* mov %esp, %eax */
469 0x8b,0x40,0x1, /* mov 0x1(%eax), %eax - cause exception */
472 0x35,0,0,4,0, /* xor $0x40000,%eax */
473 0x50, /* push %eax */
479 static DWORD
align_check_handler( EXCEPTION_RECORD
*rec
, EXCEPTION_REGISTRATION_RECORD
*frame
,
480 CONTEXT
*context
, EXCEPTION_REGISTRATION_RECORD
**dispatcher
)
482 ok (!(context
->EFlags
& 0x40000), "eflags has AC bit set\n");
484 return ExceptionContinueExecution
;
487 /* Test the direction flag handling. */
488 static const BYTE direction_flag_code
[] = {
489 0x55, /* push %ebp */
490 0x89,0xe5, /* mov %esp,%ebp */
492 0xfa, /* cli - cause exception */
497 static DWORD
direction_flag_handler( EXCEPTION_RECORD
*rec
, EXCEPTION_REGISTRATION_RECORD
*frame
,
498 CONTEXT
*context
, EXCEPTION_REGISTRATION_RECORD
**dispatcher
)
502 __asm__("pushfl; popl %0; cld" : "=r" (flags
) );
503 /* older windows versions don't clear DF properly so don't test */
504 if (flags
& 0x400) trace( "eflags has DF bit set\n" );
506 ok( context
->EFlags
& 0x400, "context eflags has DF bit cleared\n" );
508 context
->Eip
++; /* skip cli */
509 context
->EFlags
&= ~0x400; /* make sure it is cleared on return */
510 return ExceptionContinueExecution
;
513 /* test single stepping over hardware breakpoint */
514 static DWORD
bpx_handler( EXCEPTION_RECORD
*rec
, EXCEPTION_REGISTRATION_RECORD
*frame
,
515 CONTEXT
*context
, EXCEPTION_REGISTRATION_RECORD
**dispatcher
)
518 ok( rec
->ExceptionCode
== EXCEPTION_SINGLE_STEP
,
519 "wrong exception code: %x\n", rec
->ExceptionCode
);
521 if(got_exception
== 1) {
522 /* hw bp exception on first nop */
523 ok( context
->Eip
== (DWORD
)code_mem
, "eip is wrong: %x instead of %x\n",
524 context
->Eip
, (DWORD
)code_mem
);
525 ok( (context
->Dr6
& 0xf) == 1, "B0 flag is not set in Dr6\n");
526 ok( !(context
->Dr6
& 0x4000), "BS flag is set in Dr6\n");
527 context
->Dr0
= context
->Dr0
+ 1; /* set hw bp again on next instruction */
528 context
->EFlags
|= 0x100; /* enable single stepping */
529 } else if( got_exception
== 2) {
530 /* single step exception on second nop */
531 ok( context
->Eip
== (DWORD
)code_mem
+ 1, "eip is wrong: %x instead of %x\n",
532 context
->Eip
, (DWORD
)code_mem
+ 1);
533 ok( (context
->Dr6
& 0x4000), "BS flag is not set in Dr6\n");
534 /* depending on the win version the B0 bit is already set here as well
535 ok( (context->Dr6 & 0xf) == 0, "B0...3 flags in Dr6 shouldn't be set\n"); */
536 context
->EFlags
|= 0x100;
537 } else if( got_exception
== 3) {
538 /* hw bp exception on second nop */
539 ok( context
->Eip
== (DWORD
)code_mem
+ 1, "eip is wrong: %x instead of %x\n",
540 context
->Eip
, (DWORD
)code_mem
+ 1);
541 ok( (context
->Dr6
& 0xf) == 1, "B0 flag is not set in Dr6\n");
542 ok( !(context
->Dr6
& 0x4000), "BS flag is set in Dr6\n");
543 context
->Dr0
= 0; /* clear breakpoint */
544 context
->EFlags
|= 0x100;
546 /* single step exception on ret */
547 ok( context
->Eip
== (DWORD
)code_mem
+ 2, "eip is wrong: %x instead of %x\n",
548 context
->Eip
, (DWORD
)code_mem
+ 2);
549 ok( (context
->Dr6
& 0xf) == 0, "B0...3 flags in Dr6 shouldn't be set\n");
550 ok( (context
->Dr6
& 0x4000), "BS flag is not set in Dr6\n");
553 context
->Dr6
= 0; /* clear status register */
554 return ExceptionContinueExecution
;
557 static const BYTE dummy_code
[] = { 0x90, 0x90, 0xc3 }; /* nop, nop, ret */
559 /* test int3 handling */
560 static DWORD
int3_handler( EXCEPTION_RECORD
*rec
, EXCEPTION_REGISTRATION_RECORD
*frame
,
561 CONTEXT
*context
, EXCEPTION_REGISTRATION_RECORD
**dispatcher
)
563 ok( rec
->ExceptionAddress
== code_mem
, "exception address not at: %p, but at %p\n",
564 code_mem
, rec
->ExceptionAddress
);
565 ok( context
->Eip
== (DWORD
)code_mem
, "eip not at: %p, but at %#x\n", code_mem
, context
->Eip
);
566 if(context
->Eip
== (DWORD
)code_mem
) context
->Eip
++; /* skip breakpoint */
568 return ExceptionContinueExecution
;
571 static const BYTE int3_code
[] = { 0xCC, 0xc3 }; /* int 3, ret */
574 static void test_exceptions(void)
579 if (!pNtGetContextThread
|| !pNtSetContextThread
)
581 skip( "NtGetContextThread/NtSetContextThread not found\n" );
585 /* test handling of debug registers */
586 run_exception_test(dreg_handler
, NULL
, &segfault_code
, sizeof(segfault_code
));
588 ctx
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
589 res
= pNtGetContextThread(GetCurrentThread(), &ctx
);
590 ok (res
== STATUS_SUCCESS
,"NtGetContextThread failed with %x\n", res
);
591 ok(ctx
.Dr0
== 0x42424242,"failed to set debugregister 0 to 0x42424242, got %x\n", ctx
.Dr0
);
592 ok((ctx
.Dr7
& ~0xdc00) == 0x155,"failed to set debugregister 7 to 0x155, got %x\n", ctx
.Dr7
);
594 /* test single stepping behavior */
596 run_exception_test(single_step_handler
, NULL
, &single_stepcode
, sizeof(single_stepcode
));
597 ok(got_exception
== 3, "expected 3 single step exceptions, got %d\n", got_exception
);
599 /* test alignment exceptions */
601 run_exception_test(align_check_handler
, NULL
, align_check_code
, sizeof(align_check_code
));
602 ok(got_exception
== 0, "got %d alignment faults, expected 0\n", got_exception
);
604 /* test direction flag */
606 run_exception_test(direction_flag_handler
, NULL
, direction_flag_code
, sizeof(direction_flag_code
));
607 ok(got_exception
== 1, "got %d exceptions, expected 1\n", got_exception
);
609 /* test single stepping over hardware breakpoint */
610 memset(&ctx
, 0, sizeof(ctx
));
611 ctx
.Dr0
= (DWORD
) code_mem
; /* set hw bp on first nop */
613 ctx
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
614 res
= pNtSetContextThread( GetCurrentThread(), &ctx
);
615 ok( res
== STATUS_SUCCESS
, "NtSetContextThread faild with %x\n", res
);
618 run_exception_test(bpx_handler
, NULL
, dummy_code
, sizeof(dummy_code
));
619 ok( got_exception
== 4,"expected 4 exceptions, got %d\n", got_exception
);
621 /* test int3 handling */
622 run_exception_test(int3_handler
, NULL
, int3_code
, sizeof(int3_code
));
625 static void test_debugger(void)
627 char cmdline
[MAX_PATH
];
628 PROCESS_INFORMATION pi
;
629 STARTUPINFO si
= { 0 };
631 DWORD continuestatus
;
632 PVOID code_mem_address
= NULL
;
639 if(!pNtGetContextThread
|| !pNtSetContextThread
|| !pNtReadVirtualMemory
|| !pNtTerminateProcess
)
641 skip("NtGetContextThread, NtSetContextThread, NtReadVirtualMemory or NtTerminateProcess not found\n)");
645 sprintf(cmdline
, "%s %s %s %p", my_argv
[0], my_argv
[1], "debuggee", &test_stage
);
646 ret
= CreateProcess(NULL
, cmdline
, NULL
, NULL
, FALSE
, DEBUG_PROCESS
, NULL
, NULL
, &si
, &pi
);
647 ok(ret
, "could not create child process error: %u\n", GetLastError());
653 continuestatus
= DBG_CONTINUE
;
654 ok(WaitForDebugEvent(&de
, INFINITE
), "reading debug event\n");
656 if (de
.dwThreadId
!= pi
.dwThreadId
)
658 trace("event %d not coming from main thread, ignoring\n", de
.dwDebugEventCode
);
659 ContinueDebugEvent(de
.dwProcessId
, de
.dwThreadId
, DBG_CONTINUE
);
663 if (de
.dwDebugEventCode
== CREATE_PROCESS_DEBUG_EVENT
)
665 if(de
.u
.CreateProcessInfo
.lpBaseOfImage
!= pNtCurrentTeb()->Peb
->ImageBaseAddress
)
667 skip("child process loaded at different address, terminating it\n");
668 pNtTerminateProcess(pi
.hProcess
, 0);
671 else if (de
.dwDebugEventCode
== EXCEPTION_DEBUG_EVENT
)
677 status
= pNtReadVirtualMemory(pi
.hProcess
, &code_mem
, &code_mem_address
,
678 sizeof(code_mem_address
), &size_read
);
679 ok(!status
,"NtReadVirtualMemory failed with 0x%x\n", status
);
680 status
= pNtReadVirtualMemory(pi
.hProcess
, &test_stage
, &stage
,
681 sizeof(stage
), &size_read
);
682 ok(!status
,"NtReadVirtualMemory failed with 0x%x\n", status
);
684 ctx
.ContextFlags
= CONTEXT_FULL
;
685 status
= pNtGetContextThread(pi
.hThread
, &ctx
);
686 ok(!status
, "NtGetContextThread failed with 0x%x\n", status
);
688 trace("exception 0x%x at %p firstchance=%d Eip=0x%x, Eax=0x%x\n",
689 de
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
690 de
.u
.Exception
.ExceptionRecord
.ExceptionAddress
, de
.u
.Exception
.dwFirstChance
, ctx
.Eip
, ctx
.Eax
);
694 ok(FALSE
, "got way too many exceptions, probaby caught in a infinite loop, terminating child\n");
695 pNtTerminateProcess(pi
.hProcess
, 1);
697 else if (counter
>= 2) /* skip startup breakpoint */
701 ok((char *)ctx
.Eip
== (char *)code_mem_address
+ 0xb, "Eip at %x instead of %p\n",
702 ctx
.Eip
, (char *)code_mem_address
+ 0xb);
703 /* setting the context from debugger does not affect the context, the exception handlers gets */
704 /* uncomment once wine is fixed */
705 /* ctx.Eip = 0x12345; */
706 ctx
.Eax
= 0xf00f00f1;
708 /* let the debuggee handle the exception */
709 continuestatus
= DBG_EXCEPTION_NOT_HANDLED
;
713 if (de
.u
.Exception
.dwFirstChance
)
715 /* debugger gets first chance exception with unmodified ctx.Eip */
716 ok((char *)ctx
.Eip
== (char *)code_mem_address
+ 0xb, "Eip at 0x%x instead of %p\n",
717 ctx
.Eip
, (char *)code_mem_address
+ 0xb);
719 /* setting the context from debugger does not affect the context, the exception handlers gets */
720 /* uncomment once wine is fixed */
721 /* ctx.Eip = 0x12345; */
722 ctx
.Eax
= 0xf00f00f1;
724 /* pass exception to debuggee
725 * exception will not be handled and
726 * a second chance exception will be raised */
727 continuestatus
= DBG_EXCEPTION_NOT_HANDLED
;
731 /* debugger gets context after exception handler has played with it */
732 /* ctx.Eip is the same value the exception handler got */
733 if (de
.u
.Exception
.ExceptionRecord
.ExceptionCode
== EXCEPTION_BREAKPOINT
)
735 ok((char *)ctx
.Eip
== (char *)code_mem_address
+ 0xa, "Eip at 0x%x instead of %p\n",
736 ctx
.Eip
, (char *)code_mem_address
+ 0xa);
737 /* need to fixup Eip for debuggee */
738 if ((char *)ctx
.Eip
== (char *)code_mem_address
+ 0xa)
742 ok((char *)ctx
.Eip
== (char *)code_mem_address
+ 0xb, "Eip at 0x%x instead of %p\n",
743 ctx
.Eip
, (char *)code_mem_address
+ 0xb);
744 /* here we handle exception */
748 ok(FALSE
, "unexpected stage %x\n", stage
);
750 status
= pNtSetContextThread(pi
.hThread
, &ctx
);
751 ok(!status
, "NtSetContextThread failed with 0x%x\n", status
);
755 ContinueDebugEvent(de
.dwProcessId
, de
.dwThreadId
, continuestatus
);
757 } while (de
.dwDebugEventCode
!= EXIT_PROCESS_DEBUG_EVENT
);
759 winetest_wait_child_process( pi
.hProcess
);
760 ok(CloseHandle(pi
.hThread
) != 0, "error %u\n", GetLastError());
761 ok(CloseHandle(pi
.hProcess
) != 0, "error %u\n", GetLastError());
766 static DWORD
simd_fault_handler( EXCEPTION_RECORD
*rec
, EXCEPTION_REGISTRATION_RECORD
*frame
,
767 CONTEXT
*context
, EXCEPTION_REGISTRATION_RECORD
**dispatcher
)
769 int *stage
= *(int **)(frame
+ 1);
774 /* fault while executing sse instruction */
775 context
->Eip
+= 3; /* skip addps */
776 return ExceptionContinueExecution
;
779 /* stage 2 - divide by zero fault */
780 if( rec
->ExceptionCode
== EXCEPTION_ILLEGAL_INSTRUCTION
)
781 skip("system doesn't support SIMD exceptions\n");
783 ok( rec
->ExceptionCode
== STATUS_FLOAT_MULTIPLE_TRAPS
,
784 "exception code: %#x, should be %#x\n",
785 rec
->ExceptionCode
, STATUS_FLOAT_MULTIPLE_TRAPS
);
786 ok( rec
->NumberParameters
== 1, "# of params: %i, should be 1\n",
787 rec
->NumberParameters
);
788 if( rec
->NumberParameters
== 1 )
789 ok( rec
->ExceptionInformation
[0] == 0, "param #1: %lx, should be 0\n", rec
->ExceptionInformation
[0]);
792 context
->Eip
+= 3; /* skip divps */
794 return ExceptionContinueExecution
;
797 static const BYTE simd_exception_test
[] = {
798 0x83, 0xec, 0x4, /* sub $0x4, %esp */
799 0x0f, 0xae, 0x1c, 0x24, /* stmxcsr (%esp) */
800 0x66, 0x81, 0x24, 0x24, 0xff, 0xfd, /* andw $0xfdff,(%esp) * enable divide by */
801 0x0f, 0xae, 0x14, 0x24, /* ldmxcsr (%esp) * zero exceptions */
802 0x6a, 0x01, /* push $0x1 */
803 0x6a, 0x01, /* push $0x1 */
804 0x6a, 0x01, /* push $0x1 */
805 0x6a, 0x01, /* push $0x1 */
806 0x0f, 0x10, 0x0c, 0x24, /* movups (%esp),%xmm1 * fill dividend */
807 0x0f, 0x57, 0xc0, /* xorps %xmm0,%xmm0 * clear divisor */
808 0x0f, 0x5e, 0xc8, /* divps %xmm0,%xmm1 * generate fault */
809 0x83, 0xc4, 0x10, /* add $0x10,%esp */
810 0x66, 0x81, 0x0c, 0x24, 0x00, 0x02, /* orw $0x200,(%esp) * disable exceptions */
811 0x0f, 0xae, 0x14, 0x24, /* ldmxcsr (%esp) */
812 0x83, 0xc4, 0x04, /* add $0x4,%esp */
816 static const BYTE sse_check
[] = {
817 0x0f, 0x58, 0xc8, /* addps %xmm0,%xmm1 */
821 static void test_simd_exceptions(void)
825 /* test if CPU & OS can do sse */
828 run_exception_test(simd_fault_handler
, &stage
, sse_check
, sizeof(sse_check
));
830 skip("system doesn't support SSE\n");
834 /* generate a SIMD exception */
837 run_exception_test(simd_fault_handler
, &stage
, simd_exception_test
,
838 sizeof(simd_exception_test
));
839 ok( got_exception
== 1, "got exception: %i, should be 1\n", got_exception
);
842 struct fpu_exception_info
844 DWORD exception_code
;
845 DWORD exception_offset
;
849 static DWORD
fpu_exception_handler(EXCEPTION_RECORD
*rec
, EXCEPTION_REGISTRATION_RECORD
*frame
,
850 CONTEXT
*context
, EXCEPTION_REGISTRATION_RECORD
**dispatcher
)
852 struct fpu_exception_info
*info
= *(struct fpu_exception_info
**)(frame
+ 1);
854 info
->exception_code
= rec
->ExceptionCode
;
855 info
->exception_offset
= (BYTE
*)rec
->ExceptionAddress
- (BYTE
*)code_mem
;
856 info
->eip_offset
= context
->Eip
- (DWORD
)code_mem
;
859 return ExceptionContinueExecution
;
862 static void test_fpu_exceptions(void)
864 static const BYTE fpu_exception_test_ie
[] =
866 0x83, 0xec, 0x04, /* sub $0x4,%esp */
867 0x66, 0xc7, 0x04, 0x24, 0xfe, 0x03, /* movw $0x3fe,(%esp) */
868 0x9b, 0xd9, 0x7c, 0x24, 0x02, /* fstcw 0x2(%esp) */
869 0xd9, 0x2c, 0x24, /* fldcw (%esp) */
870 0xd9, 0xee, /* fldz */
871 0xd9, 0xe8, /* fld1 */
872 0xde, 0xf1, /* fdivp */
873 0xdd, 0xd8, /* fstp %st(0) */
874 0xdd, 0xd8, /* fstp %st(0) */
876 0xdb, 0xe2, /* fnclex */
877 0xd9, 0x6c, 0x24, 0x02, /* fldcw 0x2(%esp) */
878 0x83, 0xc4, 0x04, /* add $0x4,%esp */
882 static const BYTE fpu_exception_test_de
[] =
884 0x83, 0xec, 0x04, /* sub $0x4,%esp */
885 0x66, 0xc7, 0x04, 0x24, 0xfb, 0x03, /* movw $0x3fb,(%esp) */
886 0x9b, 0xd9, 0x7c, 0x24, 0x02, /* fstcw 0x2(%esp) */
887 0xd9, 0x2c, 0x24, /* fldcw (%esp) */
888 0xdd, 0xd8, /* fstp %st(0) */
889 0xd9, 0xee, /* fldz */
890 0xd9, 0xe8, /* fld1 */
891 0xde, 0xf1, /* fdivp */
893 0xdb, 0xe2, /* fnclex */
894 0xdd, 0xd8, /* fstp %st(0) */
895 0xdd, 0xd8, /* fstp %st(0) */
896 0xd9, 0x6c, 0x24, 0x02, /* fldcw 0x2(%esp) */
897 0x83, 0xc4, 0x04, /* add $0x4,%esp */
901 struct fpu_exception_info info
;
903 memset(&info
, 0, sizeof(info
));
904 run_exception_test(fpu_exception_handler
, &info
, fpu_exception_test_ie
, sizeof(fpu_exception_test_ie
));
905 ok(info
.exception_code
== EXCEPTION_FLT_STACK_CHECK
,
906 "Got exception code %#x, expected EXCEPTION_FLT_STACK_CHECK\n", info
.exception_code
);
907 ok(info
.exception_offset
== 0x19, "Got exception offset %#x, expected 0x19\n", info
.exception_offset
);
908 ok(info
.eip_offset
== 0x1b, "Got EIP offset %#x, expected 0x1b\n", info
.eip_offset
);
910 memset(&info
, 0, sizeof(info
));
911 run_exception_test(fpu_exception_handler
, &info
, fpu_exception_test_de
, sizeof(fpu_exception_test_de
));
912 ok(info
.exception_code
== EXCEPTION_FLT_DIVIDE_BY_ZERO
,
913 "Got exception code %#x, expected EXCEPTION_FLT_DIVIDE_BY_ZERO\n", info
.exception_code
);
914 ok(info
.exception_offset
== 0x17, "Got exception offset %#x, expected 0x17\n", info
.exception_offset
);
915 ok(info
.eip_offset
== 0x19, "Got EIP offset %#x, expected 0x19\n", info
.eip_offset
);
918 #endif /* __i386__ */
920 START_TEST(exception
)
923 HMODULE hntdll
= GetModuleHandleA("ntdll.dll");
925 pNtCurrentTeb
= (void *)GetProcAddress( hntdll
, "NtCurrentTeb" );
926 pNtGetContextThread
= (void *)GetProcAddress( hntdll
, "NtGetContextThread" );
927 pNtSetContextThread
= (void *)GetProcAddress( hntdll
, "NtSetContextThread" );
928 pNtReadVirtualMemory
= (void *)GetProcAddress( hntdll
, "NtReadVirtualMemory" );
929 pRtlRaiseException
= (void *)GetProcAddress( hntdll
, "RtlRaiseException" );
930 pNtTerminateProcess
= (void *)GetProcAddress( hntdll
, "NtTerminateProcess" );
931 pRtlAddVectoredExceptionHandler
= (void *)GetProcAddress( hntdll
,
932 "RtlAddVectoredExceptionHandler" );
933 pRtlRemoveVectoredExceptionHandler
= (void *)GetProcAddress( hntdll
,
934 "RtlRemoveVectoredExceptionHandler" );
937 skip( "NtCurrentTeb not found\n" );
941 if (pRtlAddVectoredExceptionHandler
&& pRtlRemoveVectoredExceptionHandler
)
942 have_vectored_api
= TRUE
;
944 skip("RtlAddVectoredExceptionHandler or RtlRemoveVectoredExceptionHandler not found\n");
946 /* 1024 byte should be sufficient */
947 code_mem
= VirtualAlloc(NULL
, 1024, MEM_RESERVE
| MEM_COMMIT
, PAGE_EXECUTE_READWRITE
);
949 trace("VirtualAlloc failed\n");
953 my_argc
= winetest_get_mainargs( &my_argv
);
957 sscanf( my_argv
[3], "%p", &addr
);
959 if (addr
!= &test_stage
)
961 skip( "child process not mapped at same address (%p/%p)\n", &test_stage
, addr
);
965 /* child must be run under a debugger */
966 if (!pNtCurrentTeb()->Peb
->BeingDebugged
)
968 ok(FALSE
, "child process not being debugged?\n");
972 if (pRtlRaiseException
)
975 run_rtlraiseexception_test(0x12345);
976 run_rtlraiseexception_test(EXCEPTION_BREAKPOINT
);
977 run_rtlraiseexception_test(EXCEPTION_INVALID_HANDLE
);
979 run_rtlraiseexception_test(0x12345);
980 run_rtlraiseexception_test(EXCEPTION_BREAKPOINT
);
981 run_rtlraiseexception_test(EXCEPTION_INVALID_HANDLE
);
984 skip( "RtlRaiseException not found\n" );
986 /* rest of tests only run in parent */
992 test_rtlraiseexception();
994 test_simd_exceptions();
995 test_fpu_exceptions();
997 VirtualFree(code_mem
, 1024, MEM_RELEASE
);