- Revert 44301
[reactos.git] / lib / pseh / framebased.c
1 /*
2 Copyright (c) 2004/2005 KJK::Hyperion
3
4 Permission is hereby granted, free of charge, to any person obtaining a
5 copy of this software and associated documentation files (the "Software"),
6 to deal in the Software without restriction, including without limitation
7 the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 and/or sell copies of the Software, and to permit persons to whom the
9 Software is furnished to do so, subject to the following conditions:
10
11 The above copyright notice and this permission notice shall be included in
12 all copies or substantial portions of the Software.
13
14 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
19 FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
20 DEALINGS IN THE SOFTWARE.
21 */
22
23 #define _NTSYSTEM_
24 #define STRICT
25 #define WIN32_LEAN_AND_MEAN
26 #include <windows.h>
27
28 #include <pseh/pseh.h>
29 #include <pseh/framebased/internal.h>
30 #include <pseh/excpt.h>
31 #include <pseh/framebased.h>
32
33 #include <excpt.h>
34
35 /* Tracing */
36 #ifdef _SEH_ENABLE_TRACE
37 extern unsigned long __cdecl DbgPrint(const char * format, ...);
38
39 #define _SEH_TRACE_HEADER_(FRAME_) \
40 DbgPrint("[PSEH:%p]%s:%d:", FRAME_, __FILE__, __LINE__);
41
42 #define _SEH_TRACE_TRAILER_ \
43 DbgPrint("\n");
44
45 #define _SEH_FILTER_RET_STRING_(RET_) \
46 (((int)(RET_) < 0) ? "_SEH_CONTINUE_EXECUTION" : (((int)(RET_) > 0) ? "_SEH_EXECUTE_HANDLER" : "_SEH_CONTINUE_SEARCH"))
47
48 #define _SEH_TRACE_LINE_(FRAME_, ARGS_) \
49 { \
50 _SEH_TRACE_HEADER_(FRAME_); \
51 DbgPrint ARGS_; \
52 _SEH_TRACE_TRAILER_; \
53 }
54
55 #define _SEH_TRACE_ENTER(FRAME_, FUNCNAME_, ARGS_) \
56 { \
57 if((FRAME_)->SPF_Tracing & _SEH_DO_TRACE_ENTER_LEAVE) \
58 { \
59 _SEH_TRACE_HEADER_(FRAME_); \
60 DbgPrint(">>> %s(", (FUNCNAME_)); \
61 DbgPrint ARGS_; \
62 DbgPrint(")"); \
63 _SEH_TRACE_TRAILER_; \
64 } \
65 }
66
67 #define _SEH_TRACE_LEAVE(FRAME_, FUNCNAME_, ARGS_) \
68 { \
69 if((FRAME_)->SPF_Tracing & _SEH_DO_TRACE_ENTER_LEAVE) \
70 { \
71 _SEH_TRACE_HEADER_(FRAME_); \
72 DbgPrint("<<< %s => ", (FUNCNAME_)); \
73 DbgPrint ARGS_; \
74 _SEH_TRACE_TRAILER_; \
75 } \
76 }
77
78 #define _SEH_TRACE_EXCEPTION_RECORD(FRAME_, ER_) \
79 { \
80 if((FRAME_)->SPF_Tracing & _SEH_DO_TRACE_EXCEPTION_RECORD) \
81 { \
82 _SEH_TRACE_LINE_ \
83 ( \
84 (FRAME_), \
85 ( \
86 "ExceptionRecord %p = { ExceptionCode : %08X, ExceptionFlags : %08X, ExceptionRecord : %p, ExceptionAddress : %p }", \
87 (ER_), \
88 (ER_)->ExceptionCode, \
89 (ER_)->ExceptionFlags, \
90 (ER_)->ExceptionRecord, \
91 (ER_)->ExceptionAddress \
92 ) \
93 ); \
94 } \
95 }
96
97 #ifdef _X86_
98 #define _SEH_TRACE_CONTEXT(FRAME_, CONTEXT_) \
99 { \
100 if((FRAME_)->SPF_Tracing & _SEH_DO_TRACE_CONTEXT) \
101 { \
102 if(((CONTEXT_)->ContextFlags & CONTEXT_INTEGER) == CONTEXT_INTEGER) \
103 { \
104 _SEH_TRACE_LINE_ \
105 ( \
106 (FRAME_), \
107 ( \
108 "eax=%08X ebx=%08X ecx=%08X edx=%08X esi=%08X edi=%08X", \
109 (CONTEXT_)->Eax, \
110 (CONTEXT_)->Ebx, \
111 (CONTEXT_)->Ecx, \
112 (CONTEXT_)->Edx, \
113 (CONTEXT_)->Esi, \
114 (CONTEXT_)->Edi \
115 ) \
116 ); \
117 } \
118 \
119 if(((CONTEXT_)->ContextFlags & CONTEXT_CONTROL) == CONTEXT_CONTROL) \
120 { \
121 _SEH_TRACE_LINE_ \
122 ( \
123 (FRAME_), \
124 ( \
125 "eip=%08X esp=%08X ebp=%08X efl=%08X cs=%08X ss=%08X", \
126 (CONTEXT_)->Eip, \
127 (CONTEXT_)->Esp, \
128 (CONTEXT_)->Ebp, \
129 (CONTEXT_)->EFlags, \
130 (CONTEXT_)->SegCs, \
131 (CONTEXT_)->SegSs \
132 ) \
133 ); \
134 } \
135 \
136 if(((CONTEXT_)->ContextFlags & CONTEXT_SEGMENTS) == CONTEXT_SEGMENTS) \
137 { \
138 _SEH_TRACE_LINE_ \
139 ( \
140 (FRAME_), \
141 ( \
142 "ds=%08X es=%08X fs=%08X gs=%08X", \
143 (CONTEXT_)->SegDs, \
144 (CONTEXT_)->SegEs, \
145 (CONTEXT_)->SegFs, \
146 (CONTEXT_)->SegGs \
147 ) \
148 ); \
149 } \
150 } \
151 }
152 #else
153 #define _SEH_TRACE_CONTEXT(FRAME_, CONTEXT_)
154 #endif
155
156 #define _SEH_TRACE_UNWIND(FRAME_, ARGS_) \
157 { \
158 if((FRAME_)->SPF_Tracing & _SEH_DO_TRACE_UNWIND) \
159 { \
160 _SEH_TRACE_LINE_((FRAME_), ARGS_); \
161 } \
162 }
163
164 #define _SEH_TRACE_TRYLEVEL(FRAME_, TRYLEVEL_) \
165 { \
166 if((FRAME_)->SPF_Tracing & _SEH_DO_TRACE_TRYLEVEL) \
167 { \
168 _SEH_TRACE_LINE_((FRAME_), ("trylevel %p, filter %p", (TRYLEVEL_), (TRYLEVEL_)->SPT_Handlers.SH_Filter)); \
169 } \
170 }
171
172 #define _SEH_TRACE_ENTER_CALL_FILTER(FRAME_, TRYLEVEL_, ER_) \
173 { \
174 if((FRAME_)->SPF_Tracing & _SEH_DO_TRACE_CALL_FILTER) \
175 { \
176 _SEH_TRACE_LINE_ \
177 ( \
178 (FRAME_), \
179 ( \
180 "trylevel %p, calling filter %p, ExceptionCode %08X", \
181 (TRYLEVEL_), \
182 (TRYLEVEL_)->SPT_Handlers.SH_Filter, \
183 (ER_)->ExceptionCode \
184 ) \
185 ); \
186 } \
187 }
188
189 #define _SEH_TRACE_LEAVE_CALL_FILTER(FRAME_, TRYLEVEL_, RET_) \
190 { \
191 if((FRAME_)->SPF_Tracing & _SEH_DO_TRACE_CALL_FILTER) \
192 { \
193 _SEH_TRACE_LINE_ \
194 ( \
195 (FRAME_), \
196 ( \
197 "trylevel %p, filter %p => %s", \
198 (TRYLEVEL_), \
199 (TRYLEVEL_)->SPT_Handlers.SH_Filter, \
200 _SEH_FILTER_RET_STRING_(RET_) \
201 ) \
202 ); \
203 } \
204 }
205
206 #define _SEH_TRACE_FILTER(FRAME_, TRYLEVEL_, RET_) \
207 { \
208 if((FRAME_)->SPF_Tracing & _SEH_DO_TRACE_FILTER) \
209 { \
210 _SEH_TRACE_LINE_ \
211 ( \
212 (FRAME_), \
213 ( \
214 "trylevel %p => %s", \
215 (TRYLEVEL_), \
216 _SEH_FILTER_RET_STRING_(RET_) \
217 ) \
218 ); \
219 } \
220 }
221
222 #define _SEH_TRACE_ENTER_CALL_HANDLER(FRAME_, TRYLEVEL_) \
223 { \
224 if((FRAME_)->SPF_Tracing & _SEH_DO_TRACE_CALL_HANDLER) \
225 { \
226 _SEH_TRACE_LINE_((FRAME_), ("trylevel %p, handling", (TRYLEVEL_))); \
227 } \
228 }
229
230 #define _SEH_TRACE_ENTER_CALL_FINALLY(FRAME_, TRYLEVEL_) \
231 { \
232 if((FRAME_)->SPF_Tracing & _SEH_DO_TRACE_CALL_FINALLY) \
233 { \
234 _SEH_TRACE_LINE_ \
235 ( \
236 (FRAME_), \
237 ( \
238 "trylevel %p, calling exit routine %p", \
239 (TRYLEVEL_), \
240 (TRYLEVEL_)->SPT_Handlers.SH_Finally \
241 ) \
242 ); \
243 } \
244 }
245
246 #define _SEH_TRACE_LEAVE_CALL_FINALLY(FRAME_, TRYLEVEL_) \
247 { \
248 if((FRAME_)->SPF_Tracing & _SEH_DO_TRACE_CALL_FINALLY) \
249 { \
250 _SEH_TRACE_LINE_ \
251 ( \
252 (FRAME_), \
253 ( \
254 "trylevel %p, exit routine %p returned", \
255 (TRYLEVEL_), \
256 (TRYLEVEL_)->SPT_Handlers.SH_Finally \
257 ) \
258 ); \
259 } \
260 }
261
262 #else
263 #define _SEH_TRACE_ENTER(FRAME_, FUNCNAME_, ARGS_)
264 #define _SEH_TRACE_LEAVE(FRAME_, FUNCNAME_, ARGS_)
265 #define _SEH_TRACE_EXCEPTION_RECORD(FRAME_, ER_)
266 #define _SEH_TRACE_CONTEXT(FRAME_, CONTEXT_)
267 #define _SEH_TRACE_UNWIND(FRAME_, ARGS_)
268 #define _SEH_TRACE_TRYLEVEL(FRAME_, TRYLEVEL_)
269 #define _SEH_TRACE_ENTER_CALL_FILTER(FRAME_, TRYLEVEL_, ER_)
270 #define _SEH_TRACE_LEAVE_CALL_FILTER(FRAME_, TRYLEVEL_, RET_)
271 #define _SEH_TRACE_FILTER(FRAME_, TRYLEVEL_, RET_)
272 #define _SEH_TRACE_ENTER_CALL_HANDLER(FRAME_, TRYLEVEL_)
273 #define _SEH_TRACE_ENTER_CALL_FINALLY(FRAME_, TRYLEVEL_)
274 #define _SEH_TRACE_LEAVE_CALL_FINALLY(FRAME_, TRYLEVEL_)
275 #endif
276
277 /* Assembly helpers, see i386/framebased.asm */
278 extern void __cdecl _SEHCleanHandlerEnvironment(void);
279 extern struct __SEHRegistration * __cdecl _SEHRegisterFrame(_SEHRegistration_t *);
280 extern void __cdecl _SEHUnregisterFrame(void);
281 extern void __cdecl _SEHGlobalUnwind(_SEHPortableFrame_t *);
282 extern _SEHRegistration_t * __cdecl _SEHCurrentRegistration(void);
283
284 /* Borland C++ uses a different decoration (i.e. none) for stdcall functions */
285 extern void __stdcall RtlUnwind(void *, void *, PEXCEPTION_RECORD, void *);
286 void const * _SEHRtlUnwind = RtlUnwind;
287
288 static void __stdcall _SEHLocalUnwind
289 (
290 _SEHPortableFrame_t * frame,
291 _SEHPortableTryLevel_t * dsttrylevel
292 )
293 {
294 _SEHPortableTryLevel_t * trylevel;
295
296 _SEH_TRACE_UNWIND(frame, ("enter local unwind from %p to %p", frame->SPF_TopTryLevel, dsttrylevel));
297
298 for
299 (
300 trylevel = frame->SPF_TopTryLevel;
301 trylevel != dsttrylevel;
302 trylevel = trylevel->SPT_Next
303 )
304 {
305 _SEHFinally_t pfnFinally;
306
307 /* ASSERT(trylevel); */
308
309 pfnFinally = trylevel->SPT_Handlers.SH_Finally;
310
311 if(pfnFinally)
312 {
313 _SEH_TRACE_ENTER_CALL_FINALLY(frame, trylevel);
314 pfnFinally(frame);
315 _SEH_TRACE_LEAVE_CALL_FINALLY(frame, trylevel);
316 }
317 }
318
319 _SEH_TRACE_UNWIND(frame, ("leave local unwind from %p to %p", frame->SPF_TopTryLevel, dsttrylevel));
320 }
321
322 static void __cdecl _SEHCallHandler
323 (
324 _SEHPortableFrame_t * frame,
325 _SEHPortableTryLevel_t * trylevel
326 )
327 {
328 _SEHGlobalUnwind(frame);
329 _SEHLocalUnwind(frame, trylevel);
330 _SEH_TRACE_ENTER_CALL_HANDLER(frame, trylevel);
331 frame->SPF_Handler(trylevel);
332 /* ASSERT(0); */
333 }
334
335 static int __cdecl _SEHFrameHandler
336 (
337 struct _EXCEPTION_RECORD * ExceptionRecord,
338 void * EstablisherFrame,
339 struct _CONTEXT * ContextRecord,
340 void * DispatcherContext
341 )
342 {
343 _SEHPortableFrame_t * frame;
344
345 _SEHCleanHandlerEnvironment();
346
347 frame = EstablisherFrame;
348
349 _SEH_TRACE_ENTER
350 (
351 frame,
352 "_SEHFrameHandler",
353 (
354 "%p, %p, %p, %p",
355 ExceptionRecord,
356 EstablisherFrame,
357 ContextRecord,
358 DispatcherContext
359 )
360 );
361
362 _SEH_TRACE_EXCEPTION_RECORD(frame, ExceptionRecord);
363 _SEH_TRACE_CONTEXT(frame, ContextRecord);
364
365 /* Unwinding */
366 if(ExceptionRecord->ExceptionFlags & (4 | 2))
367 {
368 _SEH_TRACE_UNWIND(frame, ("enter forced unwind"));
369 _SEHLocalUnwind(frame, NULL);
370 _SEH_TRACE_UNWIND(frame, ("leave forced unwind"));
371 }
372 /* Handling */
373 else
374 {
375 int ret;
376 _SEHPortableTryLevel_t * trylevel;
377
378 if(ExceptionRecord->ExceptionCode)
379 frame->SPF_Code = ExceptionRecord->ExceptionCode;
380 else
381 frame->SPF_Code = 0xC0000001;
382
383 for
384 (
385 trylevel = frame->SPF_TopTryLevel;
386 trylevel != NULL;
387 trylevel = trylevel->SPT_Next
388 )
389 {
390 _SEHFilter_t pfnFilter = trylevel->SPT_Handlers.SH_Filter;
391
392 _SEH_TRACE_TRYLEVEL(frame, trylevel);
393
394 switch((UINT_PTR)pfnFilter)
395 {
396 case (UINT_PTR)_SEH_STATIC_FILTER(_SEH_EXECUTE_HANDLER):
397 case (UINT_PTR)_SEH_STATIC_FILTER(_SEH_CONTINUE_SEARCH):
398 case (UINT_PTR)_SEH_STATIC_FILTER(_SEH_CONTINUE_EXECUTION):
399 {
400 ret = (int)((UINT_PTR)pfnFilter) - 2;
401 break;
402 }
403
404 default:
405 {
406 if(trylevel->SPT_Handlers.SH_Filter)
407 {
408 EXCEPTION_POINTERS ep;
409
410 ep.ExceptionRecord = ExceptionRecord;
411 ep.ContextRecord = ContextRecord;
412
413 _SEH_TRACE_ENTER_CALL_FILTER(frame, trylevel, ExceptionRecord);
414 ret = pfnFilter(&ep, frame);
415 _SEH_TRACE_LEAVE_CALL_FILTER(frame, trylevel, ret);
416 }
417 else
418 ret = _SEH_CONTINUE_SEARCH;
419
420 break;
421 }
422 }
423
424 _SEH_TRACE_FILTER(frame, trylevel, ret);
425
426 /* _SEH_CONTINUE_EXECUTION */
427 if(ret < 0)
428 {
429 _SEH_TRACE_LEAVE(frame, "_SEHFrameHandler", ("ExceptionContinueExecution"));
430 return ExceptionContinueExecution;
431 }
432 /* _SEH_EXECUTE_HANDLER */
433 else if(ret > 0)
434 _SEHCallHandler(frame, trylevel);
435 /* _SEH_CONTINUE_SEARCH */
436 else
437 continue;
438 }
439
440 /* FALLTHROUGH */
441 }
442
443 _SEH_TRACE_LEAVE(frame, "_SEHFrameHandler", ("ExceptionContinueSearch"));
444 return ExceptionContinueSearch;
445 }
446
447 void __stdcall _SEHEnterFrame_s(_SEHPortableFrame_t * frame)
448 {
449 _SEHEnterFrame_f(frame);
450 }
451
452 void __stdcall _SEHLeaveFrame_s(void)
453 {
454 _SEHLeaveFrame_f();
455 }
456
457 void __stdcall _SEHReturn_s(void)
458 {
459 _SEHReturn_f();
460 }
461
462 void _SEH_FASTCALL _SEHEnterFrame_f(_SEHPortableFrame_t * frame)
463 {
464 /* ASSERT(frame); */
465 /* ASSERT(trylevel); */
466 frame->SPF_Registration.SER_Handler = _SEHFrameHandler;
467 frame->SPF_Code = 0;
468 _SEHRegisterFrame(&frame->SPF_Registration);
469 }
470
471 void _SEH_FASTCALL _SEHLeaveFrame_f(void)
472 {
473 _SEHPortableFrame_t * frame;
474
475 frame = _SEH_CONTAINING_RECORD
476 (
477 _SEHCurrentRegistration(),
478 _SEHPortableFrame_t,
479 SPF_Registration
480 );
481
482 /* ASSERT(frame); */
483 /* ASSERT(frame->SPF_TopTryLevel == NULL) */
484
485 _SEHUnregisterFrame();
486 }
487
488 void _SEH_FASTCALL _SEHReturn_f(void)
489 {
490 _SEHPortableFrame_t * frame;
491
492 frame = _SEH_CONTAINING_RECORD
493 (
494 _SEHCurrentRegistration(),
495 _SEHPortableFrame_t,
496 SPF_Registration
497 );
498
499 _SEHLocalUnwind(frame, NULL);
500 _SEHUnregisterFrame();
501 }
502
503 /* EOF */