ReactOS  0.4.14-dev-52-g6116262
pseh3.h
Go to the documentation of this file.
1 /*
2  * PROJECT: ReactOS system libraries
3  * LICENSE: GNU GPL - See COPYING in the top level directory
4  * PURPOSE: Header for PSEH3
5  * PROGRAMMER: Timo Kreuzer (timo.kreuzer@reactos.org)
6  */
7 
8 /* For additional information see pseh3.c in the related library. */
9 
10 #pragma once
11 #define _PSEH3_H_
12 
13 #include <excpt.h>
14 
15 #ifdef __cplusplus
16 extern "C" {
17 #endif
18 
19 #ifdef __cplusplus
20 #define PRAGMA_DIAGNOSTIC_IGNORED_DECLARATION_AFTER_STATEMENT
21 #else
22 #define PRAGMA_DIAGNOSTIC_IGNORED_DECLARATION_AFTER_STATEMENT _Pragma("GCC diagnostic ignored \"-Wdeclaration-after-statement\"")
23 #endif
24 
25 /* CLANG must safe non-volatiles, because it uses a return-twice algorithm */
26 #if defined(__clang__) && !defined(_SEH3$_FRAME_ALL_NONVOLATILES)
27 #define _SEH3$_FRAME_ALL_NONVOLATILES 1
28 #endif
29 
30 enum
31 {
35 #ifdef __clang__
37 #elif defined(__cplusplus)
39 #else
41 #endif
42 };
43 
44 typedef struct _SEH3$_SCOPE_TABLE
45 {
46  void *Target;
47  void *Filter;
48  unsigned char TryLevel;
49  unsigned char HandlerType;
50 } SEH3$_SCOPE_TABLE, *PSEH3$_SCOPE_TABLE;
51 
53 {
57 
59 {
60  /* First the Windows base record. Don't move this! */
62  void *Handler;
63 
64  /* Points to the end of the internal registration chain */
66 
67  /* Pointer to the static scope table */
69 
70  /* Except handler stores pointer to exception pointers here */
72 
73  /* Except handler stores the exception code here */
74  unsigned long ExceptionCode;
75 
76  /* Registers that we need to save */
77  unsigned long Esp;
78  unsigned long Ebp;
79 
80  char* AllocaFrame;
81 #ifdef _SEH3$_FRAME_ALL_NONVOLATILES
82  unsigned long Ebx;
83  unsigned long Esi;
84  unsigned long Edi;
85 #endif
86 #ifdef __clang__
87  void *ReturnAddress;
88 #endif
90 
91 /* Prevent gcc from inlining functions that use SEH. */
92 static inline __attribute__((always_inline)) __attribute__((returns_twice)) void _SEH3$_PreventInlining() {}
93 
94 /* Unregister the root frame */
95 extern inline __attribute__((always_inline,gnu_inline))
96 void _SEH3$_UnregisterFrame(volatile SEH3$_REGISTRATION_FRAME *RegistrationFrame)
97 {
98  asm volatile ("movl %k[NewHead], %%fs:0"
99  : : [NewHead] "ir" (RegistrationFrame->Next) : "memory");
100 }
101 
102 /* Unregister a trylevel frame */
103 extern inline __attribute__((always_inline,gnu_inline))
104 void _SEH3$_UnregisterTryLevel(
105  volatile SEH3$_REGISTRATION_FRAME *TrylevelFrame)
106 {
107  volatile SEH3$_REGISTRATION_FRAME *RegistrationFrame;
108  asm volatile ("movl %%fs:0, %k[RegistrationFrame]"
109  : [RegistrationFrame] "=r" (RegistrationFrame) : );
110  RegistrationFrame->EndOfChain = TrylevelFrame->Next;
111 }
112 
113 enum
114 {
116 };
117 
118 #ifndef __clang__
119 /* These are global dummy definitions, that get overwritten in the local context of __finally / __except blocks */
120 int __cdecl __attribute__((error ("Can only be used inside a __finally block."))) _abnormal_termination(void);
121 unsigned long __cdecl __attribute__((error("Can only be used inside an exception filter or __except block."))) _exception_code(void);
122 void * __cdecl __attribute__((error("Can only be used inside an exception filter."))) _exception_info(void);
123 #endif
124 
125 /* This attribute allows automatic cleanup of the registered frames */
126 #define _SEH3$_AUTO_CLEANUP __attribute__((cleanup(_SEH3$_AutoCleanup)))
127 
128 int
129 __attribute__((regparm(3)))
130 __attribute__((returns_twice))
131 _SEH3$_RegisterFrameWithNonVolatiles(
132  volatile SEH3$_REGISTRATION_FRAME* RegistrationFrame,
134  void* AllocaFrame);
135 
136 int
137 __attribute__((regparm(3)))
138 __attribute__((returns_twice))
139 _SEH3$_RegisterTryLevelWithNonVolatiles(
140  volatile SEH3$_REGISTRATION_FRAME* RegistrationFrame,
142  void* AllocaFrame);
143 
144 /* CLANG specific definitions! */
145 #ifdef __clang__
146 
147 /* CLANG thinks it is smart and optimizes the alloca away if it is 0 and with it the use of a frame register */
148 #define _SEH3$_EnforceFramePointer() asm volatile ("#\n" : : "m"(*(char*)__builtin_alloca(4)) : "%esp", "memory")
149 
150 /* CLANG doesn't have asm goto! */
151 #define _SEH3$_ASM_GOTO(...)
152 
153 #define _SEH3$_RegisterFrame_(_TrylevelFrame, _DataTable) \
154  do { \
155  int result = _SEH3$_RegisterFrameWithNonVolatiles(_TrylevelFrame, _DataTable, __builtin_alloca(0)); \
156  if (__builtin_expect(result != 0, 0)) \
157  { \
158  if (result == 1) goto _SEH3$_l_FilterOrFinally; \
159  if (result == 2) goto _SEH3$_l_HandlerTarget; \
160  goto _SEH3$_l_BeforeFilterOrFinally; \
161  } \
162  } while(0)
163 
164 #define _SEH3$_RegisterTryLevel_(_TrylevelFrame, _DataTable) \
165  do { \
166  int result = _SEH3$_RegisterTryLevelWithNonVolatiles(_TrylevelFrame, _DataTable, __builtin_alloca(0)); \
167  if (__builtin_expect(result != 0, 0)) \
168  { \
169  if (result == 1) goto _SEH3$_l_FilterOrFinally; \
170  if (result == 2) goto _SEH3$_l_HandlerTarget; \
171  goto _SEH3$_l_BeforeFilterOrFinally; \
172  } \
173  } while(0)
174 
175 #define _SEH3$_SCARE_GCC()
176 
177 #else /* !__clang__ */
178 
179 /* This will make GCC use ebp, even if it was disabled by -fomit-frame-pointer */
180 #define _SEH3$_EnforceFramePointer() asm volatile ("#\n" : : "m"(*(char*)__builtin_alloca(0)) : "%esp", "memory")
181 
182 #define _SEH3$_ASM_GOTO(...) asm goto ("#\n" : : : "memory" : __VA_ARGS__)
183 
184 #ifdef __cplusplus
185 #define _SEH3$_CALL_WRAPPER(_Function, _TrylevelFrame, _DataTable) \
186  asm goto ("leal %0, %%eax\n\t" \
187  "leal %1, %%edx\n\t" \
188  "call " #_Function "WithStackLayout" \
189  : \
190  : "m" (*(_TrylevelFrame)), "m" (*(_DataTable)), "c" (__builtin_alloca(0)), "p" (_SEH3$_RegisterFrameWithNonVolatiles) \
191  : "eax", "edx", "memory" \
192  : _SEH3$_l_BeforeTry, _SEH3$_l_HandlerTarget, _SEH3$_l_OnException, _SEH3$_l_BeforeFilterOrFinally, _SEH3$_l_FilterOrFinally)
193 
194 #else
195 #define _SEH3$_CALL_WRAPPER(_Function, _TrylevelFrame, _DataTable) \
196  asm goto ("leal %0, %%eax\n\t" \
197  "leal %1, %%edx\n\t" \
198  "call " #_Function \
199  : \
200  : "m" (*(_TrylevelFrame)), "m" (*(_DataTable)), "p" (_SEH3$_RegisterFrameWithNonVolatiles) \
201  : "eax", "edx", "ecx", "memory" \
202  : _SEH3$_l_BeforeTry, _SEH3$_l_HandlerTarget, _SEH3$_l_OnException, _SEH3$_l_BeforeFilterOrFinally, _SEH3$_l_FilterOrFinally)
203 #endif
204 
205 /* This is an asm wrapper around _SEH3$_RegisterFrame */
206 #define _SEH3$_RegisterFrame_(_TrylevelFrame, _DataTable) \
207  _SEH3$_CALL_WRAPPER(__SEH3$_RegisterFrame, _TrylevelFrame, _DataTable)
208 
209 /* This is an asm wrapper around _SEH3$_RegisterTryLevel */
210 #define _SEH3$_RegisterTryLevel_(_TrylevelFrame, _DataTable) \
211  _SEH3$_CALL_WRAPPER(__SEH3$_RegisterTryLevel, _TrylevelFrame, _DataTable)
212 
213 /* This construct scares GCC so much, that it will stop moving code
214  around into places that are never executed. */
215 #define _SEH3$_SCARE_GCC() \
216  void *plabel; \
217  _SEH3$_ASM_GOTO(_SEH3$_l_BeforeTry, _SEH3$_l_HandlerTarget, _SEH3$_l_OnException, _SEH3$_l_BeforeFilterOrFinally, _SEH3$_l_FilterOrFinally); \
218  asm volatile ("#" : "=a"(plabel) : "p"(&&_SEH3$_l_BeforeTry), "p"(&&_SEH3$_l_HandlerTarget), "p"(&&_SEH3$_l_OnException), "p"(&&_SEH3$_l_FilterOrFinally) \
219  : "ebx", "ecx", "edx", "esi", "edi", "flags", "memory" ); \
220  goto _SEH3$_l_OnException;
221 
222 #endif /* __clang__ */
223 
224 /* Neither CLANG nor C++ support nested functions */
225 #if defined(__cplusplus) || defined(__clang__)
226 
227 /* Use the global unregister function */
228 void
229 __attribute__((regparm(1)))
230 _SEH3$_AutoCleanup(
231  volatile SEH3$_REGISTRATION_FRAME *Frame);
232 
233 /* These are only dummies here */
234 #define _SEH3$_DECLARE_CLEANUP_FUNC(_Name)
235 #define _SEH3$_DEFINE_CLEANUP_FUNC(_Name)
236 #define _SEH3$_DECLARE_FILTER_FUNC(_Name)
237 #define _SEH3$_DEFINE_DUMMY_FINALLY(_Name)
238 
239 /* On invocation, the AllocaFrame field is loaded with the return esp value */
240 #define _SEH3$_NESTED_FUNC_RETURN(_Result) \
241  /* Restore esp and return to the caller */ \
242  asm volatile ("movl %[FixedEsp], %%esp\n\tret" \
243  : : "a" (_Result), [FixedEsp] "m" (_SEH3$_TrylevelFrame.AllocaFrame) : "ebx", "ecx", "edx", "esi", "edi", "flags", "memory")
244 
245 /* The filter "function" */
246 #define _SEH3$_DEFINE_FILTER_FUNC(_Name, expression) \
247  { \
248  /* Evaluate and return the filter expression */ \
249  asm volatile ("#\n" : : : "eax", "ebx", "ecx", "edx", "esi", "edi", "flags", "memory"); \
250  _SEH3$_NESTED_FUNC_RETURN((expression)); \
251  }
252 
253 #define _SEH3$_FINALLY_FUNC_OPEN(_Name) \
254  { \
255  asm volatile ("#\n" : : : "eax", "ebx", "ecx", "edx", "esi", "edi", "flags", "memory"); \
256  /* This construct makes sure that the finally function returns */ \
257  /* a proper value at the end */ \
258  for (; ; (void)({_SEH3$_NESTED_FUNC_RETURN(0); 0;}))
259 
260 #define _SEH3$_FILTER(_Filter, _FilterExpression) (&&_SEH3$_l_FilterOrFinally)
261 #define _SEH3$_FINALLY(_Finally) (&&_SEH3$_l_FilterOrFinally)
262 
263 #define _SEH3$_DECLARE_EXCEPT_INTRINSICS()
264 
265 /* Since we cannot use nested functions, we declare these globally as macros */
266 #define _abnormal_termination() (_SEH3$_TrylevelFrame.ExceptionPointers != 0)
267 #define _exception_code() (_SEH3$_TrylevelFrame.ExceptionCode)
268 #define _exception_info() (_SEH3$_TrylevelFrame.ExceptionPointers)
269 
270 #else /* __cplusplus || __clang__ */
271 
272 #define _SEH3$_DECLARE_EXCEPT_INTRINSICS() \
273  inline __attribute__((always_inline, gnu_inline)) \
274  unsigned long _exception_code() { return _SEH3$_TrylevelFrame.ExceptionCode; }
275 
276 /* On GCC the filter function is a nested function with __fastcall calling
277  convention. The eax register contains a base address the function uses
278  to address the callers stack frame. __fastcall is chosen, because it gives
279  us an effective was of passing one argument to the function, that we need
280  to tell the function in a first pass to return informtion about the frame
281  base address. Since this is something GCC chooses arbitrarily, we call
282  the function with an arbitrary base address in eax first and then use the
283  result to calculate the correct address for a second call to the function. */
284 #define _SEH3$_DECLARE_FILTER_FUNC(_Name) \
285  auto int __fastcall _Name(int Action)
286 
287 #define _SEH3$_NESTED_FUNC_OPEN(_Name) \
288  int __fastcall _Name(int Action) \
289  { \
290  /* This is a fancy way to get information about the frame layout */ \
291  if (Action == 0) return (int)&_SEH3$_TrylevelFrame;
292 
293 #define _SEH3$_DEFINE_FILTER_FUNC(_Name, expression) \
294  _SEH3$_NESTED_FUNC_OPEN(_Name) \
295  /* Declare the intrinsics for exception filters */ \
296 _Pragma("GCC diagnostic push") \
297 _Pragma("GCC diagnostic ignored \"-Wshadow\"") \
298  inline __attribute__((always_inline, gnu_inline)) \
299  unsigned long _exception_code() { return _SEH3$_TrylevelFrame.ExceptionCode; } \
300  inline __attribute__((always_inline, gnu_inline)) \
301  void * _exception_info() { return _SEH3$_TrylevelFrame.ExceptionPointers; } \
302 _Pragma("GCC diagnostic pop") \
303 \
304  /* Now handle the actual filter expression */ \
305  return (expression); \
306  }
307 
308 #define _SEH3$_FINALLY_FUNC_OPEN(_Name) \
309  _SEH3$_NESTED_FUNC_OPEN(_Name) \
310  /* Declare the intrinsics for the finally function */ \
311  inline __attribute__((always_inline, gnu_inline)) \
312  int _abnormal_termination() { return (_SEH3$_TrylevelFrame.ExceptionPointers != 0); } \
313 \
314  /* This construct makes sure that the finally function returns */ \
315  /* a proper value at the end */ \
316  for (; ; (void)({return 0; 0;}))
317 
318 #define _SEH3$_FILTER(_Filter, _FilterExpression) \
319  (__builtin_constant_p(_FilterExpression) ? (void*)(unsigned long)(unsigned char)(unsigned long)(_FilterExpression) : _Filter)
320 
321 #define _SEH3$_FINALLY(_Finally) (_Finally)
322 
323 #define _SEH3$_DEFINE_DUMMY_FINALLY(_Name) \
324  auto inline __attribute__((always_inline,gnu_inline)) int _Name(int Action) { (void)Action; return 0; }
325 
326 #define _SEH3$_DECLARE_CLEANUP_FUNC(_Name) \
327  auto inline __attribute__((always_inline,gnu_inline)) void _Name(volatile SEH3$_REGISTRATION_FRAME *p)
328 
329 #define _SEH3$_DEFINE_CLEANUP_FUNC(_Name) \
330  _SEH3$_DECLARE_CLEANUP_FUNC(_Name) \
331  { \
332  (void)p; \
333  /* Unregister the frame */ \
334  if (_SEH3$_TryLevel == 1) _SEH3$_UnregisterFrame(&_SEH3$_TrylevelFrame); \
335  else _SEH3$_UnregisterTryLevel(&_SEH3$_TrylevelFrame); \
336 \
337  /* Invoke the finally function (an inline dummy in the __except case) */ \
338  _SEH3$_FinallyFunction(1); \
339  }
340 
341 #endif /* __cplusplus || __clang__ */
342 
343 
344 
345 #define _SEH3_TRY \
346  _SEH3$_PreventInlining(); \
347  /* Enter the outer scope */ \
348  if (1) { \
349  /* Declare local labels */ \
350  __label__ _SEH3$_l_BeforeTry; \
351  __label__ _SEH3$_l_DoTry; \
352  __label__ _SEH3$_l_AfterTry; \
353  __label__ _SEH3$_l_EndTry; \
354  __label__ _SEH3$_l_HandlerTarget; \
355  __label__ _SEH3$_l_OnException; \
356  __label__ _SEH3$_l_BeforeFilterOrFinally; \
357  __label__ _SEH3$_l_FilterOrFinally; \
358  (void)&&_SEH3$_l_OnException; \
359  (void)&&_SEH3$_l_BeforeFilterOrFinally; \
360  (void)&&_SEH3$_l_FilterOrFinally; \
361 \
362 _Pragma("GCC diagnostic push") \
363 PRAGMA_DIAGNOSTIC_IGNORED_DECLARATION_AFTER_STATEMENT \
364 \
365  /* Count the try level. Outside of any __try, _SEH3$_TryLevel is 0 */ \
366  enum { \
367  _SEH3$_PreviousTryLevel = _SEH3$_TryLevel, \
368  _SEH3$_TryLevel = _SEH3$_PreviousTryLevel + 1, \
369  }; \
370 \
371  /* Forward declaration of the auto cleanup function */ \
372  _SEH3$_DECLARE_CLEANUP_FUNC(_SEH3$_AutoCleanup); \
373 \
374  /* Allocate a registration frame */ \
375  volatile SEH3$_REGISTRATION_FRAME _SEH3$_AUTO_CLEANUP _SEH3$_TrylevelFrame; \
376 \
377 _Pragma("GCC diagnostic pop") \
378 \
379  goto _SEH3$_l_BeforeTry; \
380  /* Silence warning */ goto _SEH3$_l_AfterTry; \
381 \
382  _SEH3$_l_DoTry: \
383  if (1)
384 
385 
386 #define _SEH3_EXCEPT(...) \
387  /* End of the try block */ \
388  _SEH3$_l_AfterTry: (void)0; \
389  goto _SEH3$_l_EndTry; \
390 \
391  _SEH3$_l_BeforeTry: (void)0; \
392  _SEH3$_ASM_GOTO(_SEH3$_l_OnException); \
393 \
394 _Pragma("GCC diagnostic push") \
395 PRAGMA_DIAGNOSTIC_IGNORED_DECLARATION_AFTER_STATEMENT \
396 \
397  /* Forward declaration of the filter function */ \
398  _SEH3$_DECLARE_FILTER_FUNC(_SEH3$_FilterFunction); \
399 \
400  /* Create a static data table that contains the jump target and filter function */ \
401  static const SEH3$_SCOPE_TABLE _SEH3$_ScopeTable = { &&_SEH3$_l_HandlerTarget, _SEH3$_FILTER(&_SEH3$_FilterFunction, (__VA_ARGS__)), _SEH3$_TryLevel, _SEH3$_HANDLER_TYPE }; \
402 \
403  /* Register the registration record. */ \
404  if (_SEH3$_TryLevel == 1) _SEH3$_RegisterFrame_(&_SEH3$_TrylevelFrame, &_SEH3$_ScopeTable); \
405  else _SEH3$_RegisterTryLevel_(&_SEH3$_TrylevelFrame, &_SEH3$_ScopeTable); \
406 \
407  /* Define an empty inline finally function */ \
408  _SEH3$_DEFINE_DUMMY_FINALLY(_SEH3$_FinallyFunction) \
409 \
410  /* Allow intrinsics for __except to be used */ \
411  _SEH3$_DECLARE_EXCEPT_INTRINSICS(); \
412 \
413  goto _SEH3$_l_DoTry; \
414 \
415  _SEH3$_l_BeforeFilterOrFinally: (void)0; \
416  /* Make sure the filter function doesn't use esp */ \
417  _SEH3$_EnforceFramePointer(); \
418 \
419  _SEH3$_l_FilterOrFinally: (void)0; \
420  /* Emit the filter function */ \
421  _SEH3$_DEFINE_FILTER_FUNC(_SEH3$_FilterFunction, (__VA_ARGS__)) \
422 \
423  _SEH3$_l_HandlerTarget: (void)0; \
424  _SEH3$_EnforceFramePointer(); \
425 \
426  if (1) \
427  { \
428  /* Prevent this block from being optimized away */ \
429  asm volatile ("#\n"); \
430  if (1)
431 
432 
433 #define _SEH3_FINALLY \
434  /* End of the try block */ \
435  _SEH3$_l_AfterTry: (void)0; \
436  /* Set ExceptionPointers to 0, this is used by _abnormal_termination() */ \
437  _SEH3$_TrylevelFrame.ExceptionPointers = 0; \
438 \
439  goto _SEH3$_l_EndTry; \
440 \
441  _SEH3$_l_BeforeTry: (void)0; \
442  _SEH3$_ASM_GOTO(_SEH3$_l_OnException); \
443 \
444 _Pragma("GCC diagnostic push") \
445 PRAGMA_DIAGNOSTIC_IGNORED_DECLARATION_AFTER_STATEMENT \
446 \
447  /* Forward declaration of the finally function */ \
448  _SEH3$_DECLARE_FILTER_FUNC(_SEH3$_FinallyFunction); \
449 \
450  /* Create a static data table that contains the finally function */ \
451  static const SEH3$_SCOPE_TABLE _SEH3$_ScopeTable = { 0, _SEH3$_FINALLY(&_SEH3$_FinallyFunction), _SEH3$_TryLevel, _SEH3$_HANDLER_TYPE }; \
452 \
453  /* Register the registration record. */ \
454  if (_SEH3$_TryLevel == 1) _SEH3$_RegisterFrame_(&_SEH3$_TrylevelFrame, &_SEH3$_ScopeTable); \
455  else _SEH3$_RegisterTryLevel_(&_SEH3$_TrylevelFrame, &_SEH3$_ScopeTable); \
456  _SEH3$_TrylevelFrame.ExceptionPointers = (PSEH3$_EXCEPTION_POINTERS)1; \
457 \
458  goto _SEH3$_l_DoTry; \
459 \
460  _SEH3$_l_HandlerTarget: (void)0; \
461  _SEH3$_EnforceFramePointer(); \
462 \
463  _SEH3$_l_BeforeFilterOrFinally: (void)0; \
464  _SEH3$_EnforceFramePointer(); \
465  _SEH3$_l_FilterOrFinally: (void)0; \
466  _SEH3$_FINALLY_FUNC_OPEN(_SEH3$_FinallyFunction)
467 
468 
469 #define _SEH3_END \
470  }; \
471  goto _SEH3$_l_EndTry; \
472 \
473  _SEH3$_l_OnException: (void)0; \
474  /* Force GCC to create proper code pathes */ \
475  _SEH3$_SCARE_GCC(); \
476 \
477  _SEH3$_l_EndTry:(void)0; \
478  _SEH3$_ASM_GOTO(_SEH3$_l_OnException); \
479 \
480  /* Implementation of the auto cleanup function */ \
481  _SEH3$_DEFINE_CLEANUP_FUNC(_SEH3$_AutoCleanup); \
482 \
483 _Pragma("GCC diagnostic pop") \
484 \
485  /* Close the outer scope */ \
486  }
487 
488 #define _SEH3_LEAVE goto _SEH3$_l_AfterTry
489 
490 #define _SEH3_VOLATILE volatile
491 
492 
493 #ifdef __cplusplus
494 }; // extern "C"
495 #endif
static unsigned int block
Definition: xmlmemory.c:118
void * Filter
Definition: pseh3.h:47
int const SEH3 $_SCOPE_TABLE * ScopeTable
Definition: pseh3.h:133
#define error(str)
Definition: mkdosfs.c:1605
#define __cdecl
Definition: accygwin.h:79
unsigned long Esp
Definition: pseh3.h:77
void * Handler
Definition: pseh3.h:62
PSEH3 $_SCOPE_TABLE ScopeTable
Definition: pseh3.h:68
static __attribute__((always_inline)) __attribute__((returns_twice)) void _SEH3 $_PreventInlining()
Definition: pseh3.h:92
struct _SEH3 $_REGISTRATION_FRAME * EndOfChain
Definition: pseh3.h:65
unsigned long Ebp
Definition: pseh3.h:78
struct _CONTEXT * ContextRecord
Definition: pseh3.h:55
#define _SEH3
Definition: pseh3.h:329
struct _SEH3 $_REGISTRATION_FRAME * Next
Definition: pseh3.h:61
c used
Definition: write.c:2877
#define volatile
Definition: prototyp.h:117
HRESULT Next([in] ULONG celt, [out, size_is(celt), length_is(*pceltFetched)] STATPROPSETSTG *rgelt, [out] ULONG *pceltFetched)
unsigned char HandlerType
Definition: pseh3.h:49
int const SEH3 $_SCOPE_TABLE void * AllocaFrame
Definition: pseh3.h:133
unsigned long ExceptionCode
Definition: pseh3.h:74
PSEH3 $_EXCEPTION_POINTERS volatile ExceptionPointers
Definition: pseh3.h:71
void * Target
Definition: pseh3.h:46
struct _EXCEPTION_RECORD * ExceptionRecord
Definition: pseh3.h:54
void _abnormal_termination()
Definition: stubs.c:222
unsigned char TryLevel
Definition: pseh3.h:48
char * AllocaFrame
Definition: pseh3.h:80
#define const
Definition: zconf.h:230
GLint GLint GLint GLint GLint GLint GLint GLbitfield GLenum filter
Definition: glext.h:7005