ReactOS  0.4.15-dev-3165-gdf6fff7
pseh.c
Go to the documentation of this file.
1 /*
2  Copyright (c) 2008 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 #include <pseh/pseh2.h>
24 
25 #ifdef __cplusplus
26 extern "C" {
27 #endif
28 
29 #include <wine/test.h>
30 
31 extern void no_op(void);
32 extern int return_arg(int);
33 
34 extern int return_zero(void);
35 extern int return_positive(void);
36 extern int return_negative(void);
37 extern int return_one(void);
38 extern int return_minusone(void);
39 
40 extern int return_zero_2(void *);
41 extern int return_positive_2(void *);
42 extern int return_negative_2(void *);
43 extern int return_one_2(void *);
44 extern int return_minusone_2(void *);
45 
46 extern int return_zero_3(int);
47 extern int return_positive_3(int);
48 extern int return_negative_3(int);
49 extern int return_one_3(int);
50 extern int return_minusone_3(int);
51 
52 extern int return_zero_4(void *, int);
53 extern int return_positive_4(void *, int);
54 extern int return_negative_4(void *, int);
55 extern int return_one_4(void *, int);
56 extern int return_minusone_4(void *, int);
57 
58 extern void set_positive(int *);
59 
60 //static int call_test(int (*)(void));
61 
62 #ifdef __cplusplus
63 } // extern "C"
64 #endif
65 
66 #define DEFINE_TEST(NAME_) static int NAME_(void)
67 
68 /* Empty statements *///{{{
69 DEFINE_TEST(test_empty_1)
70 {
71  _SEH2_TRY { } _SEH2_EXCEPT(0) { } _SEH2_END;
72  return 1;
73 }
74 
75 DEFINE_TEST(test_empty_2)
76 {
77  _SEH2_TRY { } _SEH2_EXCEPT(-1) { } _SEH2_END;
78  return 1;
79 }
80 
81 DEFINE_TEST(test_empty_3)
82 {
83  _SEH2_TRY { } _SEH2_EXCEPT(1) { } _SEH2_END;
84  return 1;
85 }
86 
87 DEFINE_TEST(test_empty_4)
88 {
90  return 1;
91 }
92 
93 DEFINE_TEST(test_empty_5)
94 {
96  return 1;
97 }
98 
99 DEFINE_TEST(test_empty_6)
100 {
102  return 1;
103 }
104 
105 DEFINE_TEST(test_empty_7)
106 {
108  return 1;
109 }
110 
111 DEFINE_TEST(test_empty_8)
112 {
114  return 1;
115 }
116 //}}}
117 
118 /* Static exception filters *///{{{
119 DEFINE_TEST(test_execute_handler_1)
120 {
121  static int ret;
122 
123  ret = return_zero();
124 
125  _SEH2_TRY
126  {
127  RaiseException(0xE00DEAD0, 0, 0, NULL);
128  ret = return_zero();
129  }
131  {
132  ret = return_positive();
133  }
134  _SEH2_END;
135 
136  return ret == return_positive();
137 }
138 
139 DEFINE_TEST(test_continue_execution_1)
140 {
141  static int ret;
142 
143  ret = return_zero();
144 
145  _SEH2_TRY
146  {
147  RaiseException(0xE00DEAD0, 0, 0, NULL);
148  ret = return_positive();
149  }
151  {
152  ret = return_zero();
153  }
154  _SEH2_END;
155 
156  return ret == return_positive();
157 }
158 
159 DEFINE_TEST(test_continue_search_1)
160 {
161  static int ret;
162 
163  ret = return_zero();
164 
165  _SEH2_TRY
166  {
167  _SEH2_TRY
168  {
169  RaiseException(0xE00DEAD0, 0, 0, NULL);
170  ret = return_zero();
171  }
173  {
174  ret = return_zero();
175  }
176  _SEH2_END;
177  }
179  {
180  ret = return_positive();
181  }
182  _SEH2_END;
183 
184  return ret == return_positive();
185 }
186 
187 DEFINE_TEST(test_execute_handler_2)
188 {
189  static int ret;
190 
191  ret = return_zero();
192 
193  _SEH2_TRY
194  {
195  RaiseException(0xE00DEAD0, 0, 0, NULL);
196  ret = return_zero();
197  }
198  _SEH2_EXCEPT(12345)
199  {
200  ret = return_positive();
201  }
202  _SEH2_END;
203 
204  return ret == return_positive();
205 }
206 
207 DEFINE_TEST(test_continue_execution_2)
208 {
209  static int ret;
210 
211  ret = return_zero();
212 
213  _SEH2_TRY
214  {
215  RaiseException(0xE00DEAD0, 0, 0, NULL);
216  ret = return_positive();
217  }
218  _SEH2_EXCEPT(-12345)
219  {
220  ret = return_zero();
221  }
222  _SEH2_END;
223 
224  return ret == return_positive();
225 }
226 //}}}
227 
228 /* Dynamic exception filters *///{{{
229 DEFINE_TEST(test_execute_handler_3)
230 {
231  static int ret;
232 
233  ret = return_zero();
234 
235  _SEH2_TRY
236  {
237  RaiseException(0xE00DEAD0, 0, 0, NULL);
238  ret = return_zero();
239  }
241  {
242  ret = return_positive();
243  }
244  _SEH2_END;
245 
246  return ret == return_positive();
247 }
248 
249 DEFINE_TEST(test_continue_execution_3)
250 {
251  static int ret;
252 
253  ret = return_zero();
254 
255  _SEH2_TRY
256  {
257  RaiseException(0xE00DEAD0, 0, 0, NULL);
258  ret = return_positive();
259  }
261  {
262  ret = return_zero();
263  }
264  _SEH2_END;
265 
266  return ret == return_positive();
267 }
268 
269 DEFINE_TEST(test_continue_search_2)
270 {
271  static int ret;
272 
273  ret = return_zero();
274 
275  _SEH2_TRY
276  {
277  _SEH2_TRY
278  {
279  RaiseException(0xE00DEAD0, 0, 0, NULL);
280  ret = return_zero();
281  }
283  {
284  ret = return_zero();
285  }
286  _SEH2_END;
287  }
289  {
290  ret = return_positive();
291  }
292  _SEH2_END;
293 
294  return ret == return_positive();
295 }
296 
297 DEFINE_TEST(test_execute_handler_4)
298 {
299  static int ret;
300 
301  ret = return_zero();
302 
303  _SEH2_TRY
304  {
305  RaiseException(0xE00DEAD0, 0, 0, NULL);
306  ret = return_zero();
307  }
309  {
310  ret = return_positive();
311  }
312  _SEH2_END;
313 
314  return ret == return_positive();
315 }
316 
317 DEFINE_TEST(test_continue_execution_4)
318 {
319  static int ret;
320 
321  ret = return_zero();
322 
323  _SEH2_TRY
324  {
325  RaiseException(0xE00DEAD0, 0, 0, NULL);
326  ret = return_positive();
327  }
329  {
330  ret = return_zero();
331  }
332  _SEH2_END;
333 
334  return ret == return_positive();
335 }
336 //}}}
337 
338 /* Dynamic exception filters, using _SEH2_GetExceptionInformation() *///{{{
339 DEFINE_TEST(test_execute_handler_5)
340 {
341  static int ret;
342 
343  ret = return_zero();
344 
345  _SEH2_TRY
346  {
347  RaiseException(0xE00DEAD0, 0, 0, NULL);
348  ret = return_zero();
349  }
351  {
352  ret = return_positive();
353  }
354  _SEH2_END;
355 
356  return ret == return_positive();
357 }
358 
359 DEFINE_TEST(test_continue_execution_5)
360 {
361  static int ret;
362 
363  ret = return_zero();
364 
365  _SEH2_TRY
366  {
367  RaiseException(0xE00DEAD0, 0, 0, NULL);
368  ret = return_positive();
369  }
371  {
372  ret = return_zero();
373  }
374  _SEH2_END;
375 
376  return ret == return_positive();
377 }
378 
379 DEFINE_TEST(test_continue_search_3)
380 {
381  static int ret;
382 
383  ret = return_positive();
384 
385  _SEH2_TRY
386  {
387  _SEH2_TRY
388  {
389  RaiseException(0xE00DEAD0, 0, 0, NULL);
390  ret = return_zero();
391  }
393  {
394  ret = return_zero();
395  }
396  _SEH2_END;
397  }
399  {
400  ret = return_arg(ret);
401  }
402  _SEH2_END;
403 
404  return ret == return_positive();
405 }
406 
407 DEFINE_TEST(test_execute_handler_6)
408 {
409  static int ret;
410 
411  ret = return_zero();
412 
413  _SEH2_TRY
414  {
415  RaiseException(0xE00DEAD0, 0, 0, NULL);
416  ret = return_zero();
417  }
419  {
420  ret = return_positive();
421  }
422  _SEH2_END;
423 
424  return ret == return_positive();
425 }
426 
427 DEFINE_TEST(test_continue_execution_6)
428 {
429  static int ret;
430 
431  ret = return_zero();
432 
433  _SEH2_TRY
434  {
435  RaiseException(0xE00DEAD0, 0, 0, NULL);
436  ret = return_positive();
437  }
439  {
440  ret = return_zero();
441  }
442  _SEH2_END;
443 
444  return ret == return_positive();
445 }
446 //}}}
447 
448 /* Dynamic exception filters, using _SEH2_GetExceptionCode() *///{{{
449 DEFINE_TEST(test_execute_handler_7)
450 {
451  static int ret;
452 
453  ret = return_zero();
454 
455  _SEH2_TRY
456  {
457  RaiseException(0xE00DEAD0, 0, 0, NULL);
458  ret = return_zero();
459  }
461  {
462  ret = return_positive();
463  }
464  _SEH2_END;
465 
466  return ret == return_positive();
467 }
468 
469 DEFINE_TEST(test_continue_execution_7)
470 {
471  static int ret;
472 
473  ret = return_zero();
474 
475  _SEH2_TRY
476  {
477  RaiseException(0xE00DEAD0, 0, 0, NULL);
478  ret = return_positive();
479  }
481  {
482  ret = return_zero();
483  }
484  _SEH2_END;
485 
486  return ret == return_positive();
487 }
488 
489 DEFINE_TEST(test_continue_search_4)
490 {
491  static int ret;
492 
493  ret = return_zero();
494 
495  _SEH2_TRY
496  {
497  _SEH2_TRY
498  {
499  RaiseException(0xE00DEAD0, 0, 0, NULL);
500  ret = return_zero();
501  }
503  {
504  ret = return_zero();
505  }
506  _SEH2_END;
507  }
509  {
510  ret = return_positive();
511  }
512  _SEH2_END;
513 
514  return ret == return_positive();
515 }
516 
517 DEFINE_TEST(test_execute_handler_8)
518 {
519  static int ret;
520 
521  ret = return_zero();
522 
523  _SEH2_TRY
524  {
525  RaiseException(0xE00DEAD0, 0, 0, NULL);
526  ret = return_zero();
527  }
529  {
530  ret = return_positive();
531  }
532  _SEH2_END;
533 
534  return ret == return_positive();
535 }
536 
537 DEFINE_TEST(test_continue_execution_8)
538 {
539  static int ret;
540 
541  ret = return_zero();
542 
543  _SEH2_TRY
544  {
545  RaiseException(0xE00DEAD0, 0, 0, NULL);
546  ret = return_positive();
547  }
549  {
550  ret = return_zero();
551  }
552  _SEH2_END;
553 
554  return ret == return_positive();
555 }
556 //}}}
557 
558 /* Dynamic exception filters, using _SEH2_GetExceptionInformation() and _SEH2_GetExceptionCode() *///{{{
559 DEFINE_TEST(test_execute_handler_9)
560 {
561  static int ret;
562 
563  ret = return_zero();
564 
565  _SEH2_TRY
566  {
567  RaiseException(0xE00DEAD0, 0, 0, NULL);
568  ret = return_zero();
569  }
571  {
572  ret = return_positive();
573  }
574  _SEH2_END;
575 
576  return ret == return_positive();
577 }
578 
579 DEFINE_TEST(test_continue_execution_9)
580 {
581  static int ret;
582 
583  ret = return_zero();
584 
585  _SEH2_TRY
586  {
587  RaiseException(0xE00DEAD0, 0, 0, NULL);
588  ret = return_positive();
589  }
591  {
592  ret = return_zero();
593  }
594  _SEH2_END;
595 
596  return ret == return_positive();
597 }
598 
599 DEFINE_TEST(test_continue_search_5)
600 {
601  static int ret;
602 
603  ret = return_zero();
604 
605  _SEH2_TRY
606  {
607  _SEH2_TRY
608  {
609  RaiseException(0xE00DEAD0, 0, 0, NULL);
610  ret = return_zero();
611  }
613  {
614  ret = return_zero();
615  }
616  _SEH2_END;
617  }
619  {
620  ret = return_positive();
621  }
622  _SEH2_END;
623 
624  return ret == return_positive();
625 }
626 
627 DEFINE_TEST(test_execute_handler_10)
628 {
629  static int ret;
630 
631  ret = return_zero();
632 
633  _SEH2_TRY
634  {
635  RaiseException(0xE00DEAD0, 0, 0, NULL);
636  ret = return_zero();
637  }
639  {
640  ret = return_positive();
641  }
642  _SEH2_END;
643 
644  return ret == return_positive();
645 }
646 
647 DEFINE_TEST(test_continue_execution_10)
648 {
649  static int ret;
650 
651  ret = return_zero();
652 
653  _SEH2_TRY
654  {
655  RaiseException(0xE00DEAD0, 0, 0, NULL);
656  ret = return_positive();
657  }
659  {
660  ret = return_zero();
661  }
662  _SEH2_END;
663 
664  return ret == return_positive();
665 }
666 //}}}
667 
668 /* Constant exception filters with side effects *///{{{
669 DEFINE_TEST(test_execute_handler_11)
670 {
671  static int ret;
672 
673  ret = return_zero();
674 
675  _SEH2_TRY
676  {
677  RaiseException(0xE00DEAD0, 0, 0, NULL);
678  ret = return_zero();
679  }
681  {
683  }
684  _SEH2_END;
685 
686  return ret == return_positive();
687 }
688 
689 DEFINE_TEST(test_continue_execution_11)
690 {
691  static int ret;
692 
693  ret = return_zero();
694 
695  _SEH2_TRY
696  {
697  RaiseException(0xE00DEAD0, 0, 0, NULL);
699  }
701  {
702  ret = return_zero();
703  }
704  _SEH2_END;
705 
706  return ret == return_positive();
707 }
708 
709 DEFINE_TEST(test_continue_search_6)
710 {
711  static int ret;
712  static int ret2;
713 
714  ret = return_zero();
715  ret2 = return_zero();
716 
717  _SEH2_TRY
718  {
719  _SEH2_TRY
720  {
721  RaiseException(0xE00DEAD0, 0, 0, NULL);
722  ret = return_zero();
723  ret2 = return_zero();
724  }
726  {
727  ret = return_zero();
728  ret2 = return_zero();
729  }
730  _SEH2_END;
731  }
733  {
734  ret = return_arg(ret);
735  ret2 = return_arg(ret2);
736  }
737  _SEH2_END;
738 
739  return ret == return_positive() && ret2 == return_positive();
740 }
741 
742 DEFINE_TEST(test_execute_handler_12)
743 {
744  static int ret;
745 
746  ret = return_zero();
747 
748  _SEH2_TRY
749  {
750  RaiseException(0xE00DEAD0, 0, 0, NULL);
751  ret = return_zero();
752  }
753  _SEH2_EXCEPT(set_positive(&ret), 12345)
754  {
755  ret = return_arg(ret);
756  }
757  _SEH2_END;
758 
759  return ret == return_positive();
760 }
761 
762 DEFINE_TEST(test_continue_execution_12)
763 {
764  static int ret;
765 
766  ret = return_zero();
767 
768  _SEH2_TRY
769  {
770  RaiseException(0xE00DEAD0, 0, 0, NULL);
771  ret = return_arg(ret);
772  }
773  _SEH2_EXCEPT(set_positive(&ret), -12345)
774  {
775  ret = return_zero();
776  }
777  _SEH2_END;
778 
779  return ret == return_positive();
780 }
781 //}}}
782 
783 /* _SEH2_LEAVE *///{{{
784 DEFINE_TEST(test_leave_1)
785 {
786  static int ret;
787 
788  ret = return_zero();
789 
790  _SEH2_TRY
791  {
792  ret = return_positive();
793  _SEH2_LEAVE;
794  ret = return_zero();
795  }
797  {
798  ret = return_zero();
799  }
800  _SEH2_END;
801 
802  return ret == return_positive();
803 }
804 
805 DEFINE_TEST(test_leave_2)
806 {
807  static int ret;
808 
809  ret = return_zero();
810 
811  _SEH2_TRY
812  {
813  ret = return_positive();
814  _SEH2_LEAVE;
815 
816  RaiseException(0xE00DEAD0, 0, 0, NULL);
817  ret = return_zero();
818  }
820  {
821  ret = return_zero();
822  }
823  _SEH2_END;
824 
825  return ret == return_positive();
826 }
827 
828 DEFINE_TEST(test_leave_3)
829 {
830  static int ret;
831 
832  ret = return_zero();
833 
834  _SEH2_TRY
835  {
836  ret = return_positive();
837 
838  if(return_one())
839  _SEH2_LEAVE;
840 
841  ret = return_zero();
842  }
844  {
845  ret = return_zero();
846  }
847  _SEH2_END;
848 
849  return ret == return_positive();
850 }
851 
852 DEFINE_TEST(test_leave_4)
853 {
854  static int ret;
855 
856  ret = return_zero();
857 
858  _SEH2_TRY
859  {
860  int i;
861  int n = return_one() + return_one();
862 
863  for(i = return_zero(); i < n; ++ i)
864  {
865  if(i == return_one())
866  {
867  ret = return_positive();
868  _SEH2_LEAVE;
869  }
870  }
871 
872  ret = return_zero();
873  }
875  {
876  ret = return_zero();
877  }
878  _SEH2_END;
879 
880  return ret == return_positive();
881 }
882 
883 DEFINE_TEST(test_leave_5)
884 {
885  static int ret;
886 
887  ret = return_zero();
888 
889  _SEH2_TRY
890  {
891  switch(return_one())
892  {
893  case 0: ret = return_zero();
894  case 1: ret = return_positive(); _SEH2_LEAVE;
895  case 2: ret = return_zero();
896  }
897 
898  ret = return_zero();
899  }
901  {
902  ret = return_zero();
903  }
904  _SEH2_END;
905 
906  return ret == return_positive();
907 }
908 
909 DEFINE_TEST(test_leave_6)
910 {
911  static int ret;
912 
913  ret = return_zero();
914 
915  _SEH2_TRY
916  {
917  _SEH2_TRY
918  {
919  _SEH2_LEAVE;
920  }
922  {
923  ret = return_zero();
924  }
925  _SEH2_END;
926 
927  ret = return_positive();
928  }
930  {
931  ret = return_zero();
932  }
933  _SEH2_END;
934 
935  return ret == return_positive();
936 }
937 //}}}
938 
939 /* _SEH2_YIELD() *///{{{
940 static
942 {
943  _SEH2_TRY
944  {
945  _SEH2_YIELD(return return_positive());
946  }
948  {
949  _SEH2_YIELD(return return_zero());
950  }
951  _SEH2_END;
952 
953  return return_zero();
954 }
955 
956 DEFINE_TEST(test_yield_1)
957 {
958  return test_yield_1_helper() == return_positive();
959 }
960 
961 static
963 {
964  _SEH2_TRY
965  {
966  RaiseException(0xE00DEAD0, 0, 0, NULL);
967  _SEH2_YIELD(return return_zero());
968  }
970  {
971  _SEH2_YIELD(return return_positive());
972  }
973  _SEH2_END;
974 
975  return return_zero();
976 }
977 
978 DEFINE_TEST(test_yield_2)
979 {
980  return test_yield_2_helper() == return_positive();
981 }
982 
983 static
985 {
986  _SEH2_TRY
987  {
988  _SEH2_TRY
989  {
990  _SEH2_YIELD(return return_positive());
991  }
993  {
994  _SEH2_YIELD(return return_zero());
995  }
996  _SEH2_END;
997 
998  _SEH2_YIELD(return return_zero());
999  }
1001  {
1002  _SEH2_YIELD(return return_zero());
1003  }
1004  _SEH2_END;
1005 
1006  return return_zero();
1007 }
1008 
1009 DEFINE_TEST(test_yield_3)
1010 {
1011  return test_yield_3_helper() == return_positive();
1012 }
1013 
1014 static
1016 {
1017  _SEH2_TRY
1018  {
1019  _SEH2_TRY
1020  {
1021  RaiseException(0xE00DEAD0, 0, 0, NULL);
1022  _SEH2_YIELD(return return_zero());
1023  }
1025  {
1026  _SEH2_YIELD(return return_positive());
1027  }
1028  _SEH2_END;
1029 
1030  _SEH2_YIELD(return return_zero());
1031  }
1033  {
1034  _SEH2_YIELD(return return_zero());
1035  }
1036  _SEH2_END;
1037 
1038  return return_zero();
1039 }
1040 
1041 DEFINE_TEST(test_yield_4)
1042 {
1043  return test_yield_4_helper() == return_positive();
1044 }
1045 
1046 static int test_yield_5_ret;
1047 
1048 static
1050 {
1052 
1053  _SEH2_TRY
1054  {
1055  _SEH2_YIELD(return return_positive());
1056  }
1058  {
1060  }
1061  _SEH2_END;
1062 
1063  return return_zero();
1064 }
1065 
1066 DEFINE_TEST(test_yield_5)
1067 {
1069 }
1070 
1072 
1073 static
1075 {
1077 
1078  _SEH2_TRY
1079  {
1080  _SEH2_TRY
1081  {
1082  _SEH2_YIELD(return return_positive());
1083  }
1085  {
1087  }
1088  _SEH2_END;
1089  }
1091  {
1093  }
1094  _SEH2_END;
1095 
1096  return return_zero();
1097 }
1098 
1099 DEFINE_TEST(test_yield_6)
1100 {
1102 }
1103 //}}}
1104 
1105 /* Termination blocks *///{{{
1106 DEFINE_TEST(test_finally_1)
1107 {
1108  static int ret;
1109 
1110  ret = return_zero();
1111 
1112  _SEH2_TRY
1113  {
1114  ret = return_arg(ret);
1115  }
1117  {
1118  ret = return_positive();
1119  }
1120  _SEH2_END;
1121 
1122  return ret == return_positive();
1123 }
1124 
1125 DEFINE_TEST(test_finally_2)
1126 {
1127  static int ret;
1128 
1129  ret = return_zero();
1130 
1131  _SEH2_TRY
1132  {
1133  ret = return_arg(ret);
1134  _SEH2_LEAVE;
1135  }
1137  {
1138  ret = return_positive();
1139  }
1140  _SEH2_END;
1141 
1142  return ret == return_positive();
1143 }
1144 
1145 DEFINE_TEST(test_finally_3)
1146 {
1147  static int ret;
1148 
1149  ret = return_zero();
1150 
1151  _SEH2_TRY
1152  {
1153  ret = return_arg(ret);
1154  _SEH2_YIELD(goto leave);
1155  }
1157  {
1158  ret = return_positive();
1159  }
1160  _SEH2_END;
1161 
1162 leave:
1163  return ret == return_positive();
1164 }
1165 
1167 
1168 static int test_finally_4_helper(void)
1169 {
1171 
1172  _SEH2_TRY
1173  {
1175  _SEH2_YIELD(return return_positive());
1176  }
1178  {
1180  }
1181  _SEH2_END;
1182 
1183  return return_zero();
1184 }
1185 
1186 DEFINE_TEST(test_finally_4)
1187 {
1189 }
1190 
1191 DEFINE_TEST(test_finally_5)
1192 {
1193  static int ret;
1194 
1195  ret = return_zero();
1196 
1197  _SEH2_TRY
1198  {
1199  _SEH2_TRY
1200  {
1201  RaiseException(0xE00DEAD0, 0, 0, NULL);
1202  ret = return_zero();
1203  }
1205  {
1206  ret = return_positive();
1207  }
1208  _SEH2_END;
1209  }
1211  {
1212  ret = return_arg(ret);
1213  }
1214  _SEH2_END;
1215 
1216  return ret == return_positive();
1217 }
1218 
1219 DEFINE_TEST(test_finally_6)
1220 {
1221  static int ret;
1222 
1223  ret = return_zero();
1224 
1225  _SEH2_TRY
1226  {
1227  _SEH2_TRY
1228  {
1229  ret = return_arg(ret);
1230  }
1232  {
1233  if(ret == return_zero())
1234  ret = return_positive();
1235  }
1236  _SEH2_END;
1237  }
1239  {
1240  if(ret == return_positive())
1241  ret = return_positive() + return_one();
1242  }
1243  _SEH2_END;
1244 
1245  return ret == return_positive() + return_one();
1246 }
1247 
1248 DEFINE_TEST(test_finally_7)
1249 {
1250  static int ret;
1251 
1252  ret = return_zero();
1253 
1254  _SEH2_TRY
1255  {
1256  _SEH2_TRY
1257  {
1258  ret = return_arg(ret);
1259  _SEH2_LEAVE;
1260  }
1262  {
1263  if(ret == return_zero())
1264  ret = return_positive();
1265  }
1266  _SEH2_END;
1267  }
1269  {
1270  if(ret == return_positive())
1271  ret = return_positive() + return_one();
1272  }
1273  _SEH2_END;
1274 
1275  return ret == return_positive() + return_one();
1276 }
1277 
1278 DEFINE_TEST(test_finally_8)
1279 {
1280  static int ret;
1281 
1282  ret = return_zero();
1283 
1284  _SEH2_TRY
1285  {
1286  _SEH2_TRY
1287  {
1288  ret = return_arg(ret);
1289  _SEH2_YIELD(goto leave);
1290  }
1292  {
1293  if(ret == return_zero())
1294  ret = return_positive();
1295  }
1296  _SEH2_END;
1297  }
1299  {
1300  if(ret == return_positive())
1301  ret = return_positive() + return_one();
1302  }
1303  _SEH2_END;
1304 
1305 leave:
1306  return ret == return_positive() + return_one();
1307 }
1308 
1310 
1311 static int test_finally_9_helper(void)
1312 {
1314 
1315  _SEH2_TRY
1316  {
1317  _SEH2_TRY
1318  {
1320  _SEH2_YIELD(return return_positive());
1321  }
1323  {
1326  }
1327  _SEH2_END;
1328  }
1330  {
1333  }
1334  _SEH2_END;
1335 
1336  return return_zero();
1337 }
1338 
1339 DEFINE_TEST(test_finally_9)
1340 {
1342 }
1343 
1344 DEFINE_TEST(test_finally_10)
1345 {
1346  static int ret;
1347 
1348  ret = return_zero();
1349 
1350  _SEH2_TRY
1351  {
1352  _SEH2_TRY
1353  {
1354  _SEH2_TRY
1355  {
1356  RaiseException(0xE00DEAD0, 0, 0, NULL);
1357  ret = return_zero();
1358  }
1360  {
1361  if(ret == return_zero())
1362  ret = return_positive();
1363  }
1364  _SEH2_END;
1365  }
1367  {
1368  if(ret == return_positive())
1369  ret = return_positive() + return_one();
1370  }
1371  _SEH2_END;
1372  }
1374  {
1375  ret = return_arg(ret);
1376  }
1377  _SEH2_END;
1378 
1379  return ret == return_positive() + return_one();
1380 }
1381 
1382 DEFINE_TEST(test_finally_11)
1383 {
1384  static int ret;
1385 
1386  ret = return_zero();
1387 
1388  _SEH2_TRY
1389  {
1390  _SEH2_TRY
1391  {
1392  _SEH2_TRY
1393  {
1394  ret = return_arg(ret);
1395  }
1397  {
1398  ret = return_zero();
1399  }
1400  _SEH2_END;
1401  }
1403  {
1404  ret = return_positive();
1405  RaiseException(0xE00DEAD0, 0, 0, NULL);
1406  ret = return_zero();
1407  }
1408  _SEH2_END;
1409  }
1411  {
1412  if(ret == return_positive())
1413  ret += return_one();
1414  }
1415  _SEH2_END;
1416 
1417  return ret == return_positive() + return_one();
1418 }
1419 
1420 DEFINE_TEST(test_finally_12)
1421 {
1422  static int ret;
1423 
1424  ret = return_zero();
1425 
1426  _SEH2_TRY
1427  {
1428  _SEH2_TRY
1429  {
1430  _SEH2_TRY
1431  {
1432  ret = return_arg(ret);
1433  }
1435  {
1436  ret = return_positive();
1437  RaiseException(0xE00DEAD0, 0, 0, NULL);
1438  ret = return_zero();
1439  }
1440  _SEH2_END;
1441  }
1443  {
1444  if(ret == return_positive())
1445  ret += return_one();
1446  }
1447  _SEH2_END;
1448  }
1450  {
1451  if(ret == return_positive() + return_one())
1452  ret += return_one();
1453  }
1454  _SEH2_END;
1455 
1456  return ret == return_positive() + return_one() + return_one();
1457 }
1458 
1460 
1461 static
1463 {
1465 
1466  _SEH2_TRY
1467  {
1468  _SEH2_TRY
1469  {
1471  _SEH2_YIELD(return);
1473  }
1475  {
1478  }
1479  _SEH2_END;
1480  }
1482  {
1485 
1486  RaiseException(0xE00DEAD0, 0, 0, NULL);
1488  }
1489  _SEH2_END;
1490 
1492 }
1493 
1494 DEFINE_TEST(test_finally_13)
1495 {
1496  static int ret;
1497 
1498  ret = return_zero();
1499 
1500  _SEH2_TRY
1501  {
1502  ret = return_arg(ret);
1504  ret = return_zero();
1505  }
1507  {
1508  ret = return_positive();
1509  }
1510  _SEH2_END;
1511 
1513 }
1514 
1516 
1517 static
1519 {
1521 
1522  _SEH2_TRY
1523  {
1524  _SEH2_TRY
1525  {
1526  _SEH2_TRY
1527  {
1529  RaiseException(0xE00DEAD0, 0, 0, NULL);
1531  }
1533  {
1536  }
1537  _SEH2_END;
1538  }
1540  {
1543 
1544  RaiseException(0xE00DEAD0, 0, 0, NULL);
1546  }
1547  _SEH2_END;
1548  }
1550  {
1553  }
1554  _SEH2_END;
1555 
1557 }
1558 
1559 DEFINE_TEST(test_finally_14)
1560 {
1561  static int ret;
1562 
1563  ret = return_zero();
1564 
1565  _SEH2_TRY
1566  {
1567  ret = return_arg(ret);
1569  ret = return_positive();
1570  }
1572  {
1573  ret = return_zero();
1574  }
1575  _SEH2_END;
1576 
1578 }
1579 //}}}
1580 
1581 /* _SEH2_GetExceptionInformation() *///{{{
1582 static
1584 {
1585  *ret =
1586  ep &&
1587  ep->ExceptionRecord &&
1588  ep->ContextRecord &&
1592  (argv || !argc) &&
1593  memcmp(ep->ExceptionRecord->ExceptionInformation, argv, sizeof(argv[0]) * argc) == 0;
1594 
1595  if(*ret)
1596  *ret = return_positive();
1597 
1598  return filter;
1599 }
1600 
1601 DEFINE_TEST(test_xpointers_1)
1602 {
1603  static int ret;
1604 
1605  ret = return_zero();
1606 
1607  _SEH2_TRY
1608  {
1609  RaiseException(0xE00DEAD0, 0, 0, NULL);
1610  }
1612  {
1613  ret = return_arg(ret);
1614  }
1615  _SEH2_END;
1616 
1617  return ret == return_positive();
1618 }
1619 
1620 DEFINE_TEST(test_xpointers_2)
1621 {
1622  static int ret;
1623 
1624  ret = return_zero();
1625 
1626  _SEH2_TRY
1627  {
1628  RaiseException(0xE00DEAD0, EXCEPTION_NONCONTINUABLE, 0, NULL);
1629  }
1631  {
1632  ret = return_arg(ret);
1633  }
1634  _SEH2_END;
1635 
1636  return ret == return_positive();
1637 }
1638 
1639 DEFINE_TEST(test_xpointers_3)
1640 {
1641  static int ret;
1642  static const ULONG_PTR args[] = { 1, 2, 12345 };
1643 
1644  ret = return_zero();
1645 
1646  _SEH2_TRY
1647  {
1648  RaiseException(0xE00DEAD0, EXCEPTION_NONCONTINUABLE, 0, args);
1649  }
1651  {
1652  ret = return_arg(ret);
1653  }
1654  _SEH2_END;
1655 
1656  return ret == return_positive();
1657 }
1658 
1659 DEFINE_TEST(test_xpointers_4)
1660 {
1661  static int ret;
1662  static const ULONG_PTR args[] = { 1, 2, 12345 };
1663 
1664  ret = return_zero();
1665 
1666  _SEH2_TRY
1667  {
1668  RaiseException(0xE00DEAD0, EXCEPTION_NONCONTINUABLE, 1, args);
1669  }
1671  {
1672  ret = return_arg(ret);
1673  }
1674  _SEH2_END;
1675 
1676  return ret == return_positive();
1677 }
1678 
1679 DEFINE_TEST(test_xpointers_5)
1680 {
1681  static int ret;
1682  static const ULONG_PTR args[] = { 1, 2, 12345 };
1683 
1684  ret = return_zero();
1685 
1686  _SEH2_TRY
1687  {
1688  RaiseException(0xE00DEAD0, EXCEPTION_NONCONTINUABLE, 2, args);
1689  }
1691  {
1692  ret = return_arg(ret);
1693  }
1694  _SEH2_END;
1695 
1696  return ret == return_positive();
1697 }
1698 
1699 DEFINE_TEST(test_xpointers_6)
1700 {
1701  static int ret;
1702  static const ULONG_PTR args[] = { 1, 2, 12345 };
1703 
1704  ret = return_zero();
1705 
1706  _SEH2_TRY
1707  {
1708  RaiseException(0xE00DEAD0, EXCEPTION_NONCONTINUABLE, 3, args);
1709  }
1711  {
1712  ret = return_arg(ret);
1713  }
1714  _SEH2_END;
1715 
1716  return ret == return_positive();
1717 }
1718 
1719 DEFINE_TEST(test_xpointers_7)
1720 {
1721  static int ret;
1722 
1723  ret = return_zero();
1724 
1725  _SEH2_TRY
1726  {
1727  RaiseException(0xE00DEAD0, 0, 0, NULL);
1728  ret = return_arg(ret);
1729  }
1731  {
1732  ret = return_zero();
1733  }
1734  _SEH2_END;
1735 
1736  return ret == return_positive();
1737 }
1738 
1739 DEFINE_TEST(test_xpointers_8)
1740 {
1741  static int ret;
1742  static const ULONG_PTR args[] = { 1, 2, 12345 };
1743 
1744  ret = return_zero();
1745 
1746  _SEH2_TRY
1747  {
1748  RaiseException(0xE00DEAD0, 0, 0, args);
1749  ret = return_arg(ret);
1750  }
1752  {
1753  ret = return_zero();
1754  }
1755  _SEH2_END;
1756 
1757  return ret == return_positive();
1758 }
1759 
1760 DEFINE_TEST(test_xpointers_9)
1761 {
1762  static int ret;
1763  static const ULONG_PTR args[] = { 1, 2, 12345 };
1764 
1765  ret = return_zero();
1766 
1767  _SEH2_TRY
1768  {
1769  RaiseException(0xE00DEAD0, 0, 1, args);
1770  ret = return_arg(ret);
1771  }
1773  {
1774  ret = return_zero();
1775  }
1776  _SEH2_END;
1777 
1778  return ret == return_positive();
1779 }
1780 
1781 DEFINE_TEST(test_xpointers_10)
1782 {
1783  static int ret;
1784  static const ULONG_PTR args[] = { 1, 2, 12345 };
1785 
1786  ret = return_zero();
1787 
1788  _SEH2_TRY
1789  {
1790  RaiseException(0xE00DEAD0, 0, 2, args);
1791  ret = return_arg(ret);
1792  }
1794  {
1795  ret = return_zero();
1796  }
1797  _SEH2_END;
1798 
1799  return ret == return_positive();
1800 }
1801 
1802 DEFINE_TEST(test_xpointers_11)
1803 {
1804  static int ret;
1805  static const ULONG_PTR args[] = { 1, 2, 12345 };
1806 
1807  ret = return_zero();
1808 
1809  _SEH2_TRY
1810  {
1811  RaiseException(0xE00DEAD0, 0, 3, args);
1812  ret = return_arg(ret);
1813  }
1815  {
1816  ret = return_zero();
1817  }
1818  _SEH2_END;
1819 
1820  return ret == return_positive();
1821 }
1822 
1823 DEFINE_TEST(test_xpointers_12)
1824 {
1825  static int ret;
1826 
1827  ret = return_zero();
1828 
1829  _SEH2_TRY
1830  {
1831  _SEH2_TRY
1832  {
1833  RaiseException(0xE00DEAD0, EXCEPTION_NONCONTINUABLE, 0, NULL);
1834  }
1836  {
1837  ret = return_zero();
1838  }
1839  _SEH2_END;
1840  }
1842  {
1843  ret = return_arg(ret);
1844  }
1845  _SEH2_END;
1846 
1847  return ret == return_positive();
1848 }
1849 
1850 DEFINE_TEST(test_xpointers_13)
1851 {
1852  static int ret;
1853  static const ULONG_PTR args[] = { 1, 2, 12345 };
1854 
1855  ret = return_zero();
1856 
1857  _SEH2_TRY
1858  {
1859  _SEH2_TRY
1860  {
1861  RaiseException(0xE00DEAD0, EXCEPTION_NONCONTINUABLE, 0, args);
1862  }
1864  {
1865  ret = return_zero();
1866  }
1867  _SEH2_END;
1868  }
1870  {
1871  ret = return_arg(ret);
1872  }
1873  _SEH2_END;
1874 
1875  return ret == return_positive();
1876 }
1877 
1878 DEFINE_TEST(test_xpointers_14)
1879 {
1880  static int ret;
1881  static const ULONG_PTR args[] = { 1, 2, 12345 };
1882 
1883  ret = return_zero();
1884 
1885  _SEH2_TRY
1886  {
1887  _SEH2_TRY
1888  {
1889  RaiseException(0xE00DEAD0, EXCEPTION_NONCONTINUABLE, 1, args);
1890  }
1892  {
1893  ret = return_zero();
1894  }
1895  _SEH2_END;
1896  }
1898  {
1899  ret = return_arg(ret);
1900  }
1901  _SEH2_END;
1902 
1903  return ret == return_positive();
1904 }
1905 
1906 DEFINE_TEST(test_xpointers_15)
1907 {
1908  static int ret;
1909  static const ULONG_PTR args[] = { 1, 2, 12345 };
1910 
1911  ret = return_zero();
1912 
1913  _SEH2_TRY
1914  {
1915  _SEH2_TRY
1916  {
1917  RaiseException(0xE00DEAD0, EXCEPTION_NONCONTINUABLE, 2, args);
1918  }
1920  {
1921  ret = return_zero();
1922  }
1923  _SEH2_END;
1924  }
1926  {
1927  ret = return_arg(ret);
1928  }
1929  _SEH2_END;
1930 
1931  return ret == return_positive();
1932 }
1933 
1934 DEFINE_TEST(test_xpointers_16)
1935 {
1936  static int ret;
1937  static const ULONG_PTR args[] = { 1, 2, 12345 };
1938 
1939  ret = return_zero();
1940 
1941  _SEH2_TRY
1942  {
1943  _SEH2_TRY
1944  {
1945  RaiseException(0xE00DEAD0, EXCEPTION_NONCONTINUABLE, 3, args);
1946  }
1948  {
1949  ret = return_zero();
1950  }
1951  _SEH2_END;
1952  }
1954  {
1955  ret = return_arg(ret);
1956  }
1957  _SEH2_END;
1958 
1959  return ret == return_positive();
1960 }
1961 //}}}
1962 
1963 /* _SEH2_GetExceptionCode() *///{{{
1964 static
1965 int verify_xcode(int code, int xcode, int * ret, int filter)
1966 {
1967  *ret = code == xcode;
1968 
1969  if(*ret)
1970  *ret = return_positive();
1971 
1972  return filter;
1973 }
1974 
1975 DEFINE_TEST(test_xcode_1)
1976 {
1977  static int ret;
1978 
1979  ret = return_zero();
1980 
1981  _SEH2_TRY
1982  {
1983  RaiseException(0xE00DEAD0, 0, 0, NULL);
1984  ret = return_zero();
1985  }
1987  {
1988  ret = return_arg(ret);
1989  }
1990  _SEH2_END;
1991 
1992  return ret == return_positive();
1993 }
1994 
1995 DEFINE_TEST(test_xcode_2)
1996 {
1997  static int ret;
1998 
1999  ret = return_zero();
2000 
2001  _SEH2_TRY
2002  {
2003  RaiseException(0xE00DEAD0, 0, 0, NULL);
2004  ret = return_arg(ret);
2005  }
2007  {
2008  ret = return_zero();
2009  }
2010  _SEH2_END;
2011 
2012  return ret == return_positive();
2013 }
2014 
2015 DEFINE_TEST(test_xcode_3)
2016 {
2017  static int ret;
2018 
2019  ret = return_zero();
2020 
2021  _SEH2_TRY
2022  {
2023  _SEH2_TRY
2024  {
2025  RaiseException(0xE00DEAD0, 0, 0, NULL);
2026  ret = return_zero();
2027  }
2029  {
2030  ret = return_zero();
2031  }
2032  _SEH2_END;
2033  }
2035  {
2036  ret = return_arg(ret);
2037  }
2038  _SEH2_END;
2039 
2040  return ret == return_positive();
2041 }
2042 //}}}
2043 
2044 /* _SEH2_AbnormalTermination() *///{{{
2045 DEFINE_TEST(test_abnorm_1)
2046 {
2047  static int ret;
2048 
2049  ret = return_zero();
2050 
2051  _SEH2_TRY
2052  {
2053  ret = return_arg(ret);
2054  }
2056  {
2058  }
2059  _SEH2_END;
2060 
2061  return ret == return_positive();
2062 }
2063 
2064 DEFINE_TEST(test_abnorm_2)
2065 {
2066  static int ret;
2067 
2068  ret = return_zero();
2069 
2070  _SEH2_TRY
2071  {
2072  _SEH2_LEAVE;
2073  }
2075  {
2077  }
2078  _SEH2_END;
2079 
2080  return ret == return_positive();
2081 }
2082 
2083 DEFINE_TEST(test_abnorm_3)
2084 {
2085  static int ret;
2086 
2087  ret = return_zero();
2088 
2089  _SEH2_TRY
2090  {
2091  _SEH2_YIELD(goto leave);
2092  }
2094  {
2096  }
2097  _SEH2_END;
2098 
2099 leave:
2100  return ret == return_positive();
2101 }
2102 
2103 DEFINE_TEST(test_abnorm_4)
2104 {
2105  static int ret;
2106 
2107  ret = return_zero();
2108 
2109  _SEH2_TRY
2110  {
2111  _SEH2_TRY
2112  {
2113  RaiseException(0xE00DEAD0, 0, 0, NULL);
2114  ret = return_zero();
2115  }
2117  {
2119  }
2120  _SEH2_END;
2121  }
2123  {
2124  ret = return_arg(ret);
2125  }
2126  _SEH2_END;
2127 
2128  return ret == return_positive();
2129 }
2130 
2131 DEFINE_TEST(test_abnorm_5)
2132 {
2133  static int ret;
2134 
2135  ret = return_zero();
2136 
2137  _SEH2_TRY
2138  {
2139  _SEH2_TRY
2140  {
2141  ret = return_arg(ret);
2142  }
2144  {
2146  }
2147  _SEH2_END;
2148  }
2150  {
2152  }
2153  _SEH2_END;
2154 
2155  return ret == return_positive() + return_one();
2156 }
2157 
2158 DEFINE_TEST(test_abnorm_6)
2159 {
2160  static int ret;
2161 
2162  ret = return_zero();
2163 
2164  _SEH2_TRY
2165  {
2166  _SEH2_TRY
2167  {
2168  _SEH2_LEAVE;
2169  }
2171  {
2173  }
2174  _SEH2_END;
2175  }
2177  {
2179  }
2180  _SEH2_END;
2181 
2182  return ret == return_positive() + return_one();
2183 }
2184 
2185 DEFINE_TEST(test_abnorm_7)
2186 {
2187  static int ret;
2188 
2189  ret = return_zero();
2190 
2191  _SEH2_TRY
2192  {
2193  _SEH2_TRY
2194  {
2195  _SEH2_YIELD(goto leave);
2196  }
2198  {
2200  }
2201  _SEH2_END;
2202  }
2204  {
2206  }
2207  _SEH2_END;
2208 
2209 leave:
2210  return ret == return_positive() + return_one();
2211 }
2212 
2213 DEFINE_TEST(test_abnorm_8)
2214 {
2215  static int ret;
2216 
2217  ret = return_zero();
2218 
2219  _SEH2_TRY
2220  {
2221  _SEH2_TRY
2222  {
2223  _SEH2_TRY
2224  {
2225  RaiseException(0xE00DEAD0, 0, 0, NULL);
2226  ret = return_zero();
2227  }
2229  {
2231  }
2232  _SEH2_END;
2233  }
2235  {
2237  }
2238  _SEH2_END;
2239  }
2241  {
2242  ret = return_arg(ret);
2243  }
2244  _SEH2_END;
2245 
2246  return ret == return_positive() + return_one();
2247 }
2248 //}}}
2249 
2250 /* Use of local variables from _SEH2_EXCEPT(...) and _SEH2_FINALLY { ... } *///{{{
2251 DEFINE_TEST(test_nested_locals_1)
2252 {
2253  int var1 = return_one();
2254 
2255  _SEH2_TRY
2256  {
2257  RaiseException(0xE00DEAD0, 0, 0, 0);
2258  }
2259  _SEH2_EXCEPT((var1 = (var1 == return_one() ? return_positive() : var1)), EXCEPTION_EXECUTE_HANDLER)
2260  {
2261  if(var1 == return_positive())
2262  var1 = return_positive() + 1;
2263  }
2264  _SEH2_END;
2265 
2266  return var1 == return_positive() + 1;
2267 }
2268 
2269 DEFINE_TEST(test_nested_locals_2)
2270 {
2271  int var1 = return_positive();
2272 
2273  _SEH2_TRY
2274  {
2275  }
2277  {
2278  if(var1 == return_positive())
2279  var1 = return_positive() + 1;
2280  }
2281  _SEH2_END;
2282 
2283  return var1 == return_positive() + 1;
2284 }
2285 
2286 DEFINE_TEST(test_nested_locals_3)
2287 {
2288  int var1 = return_zero();
2289 
2290  _SEH2_TRY
2291  {
2292  _SEH2_TRY
2293  {
2294  var1 = return_one();
2295  RaiseException(0xE00DEAD0, 0, 0, 0);
2296  }
2298  {
2299  if(var1 == return_one())
2300  var1 = return_positive();
2301  }
2302  _SEH2_END;
2303  }
2305  {
2306  if(var1 == return_positive())
2307  var1 = return_positive() + 1;
2308  }
2309  _SEH2_END;
2310 
2311  return var1 == return_positive() + 1;
2312 }
2313 //}}}
2314 
2315 /* System support *///{{{
2316 // TODO
2317 //}}}
2318 
2319 /* CPU faults *///{{{
2320 // TODO
2321 //}}}
2322 
2323 /* Past bugs, to detect regressions *///{{{
2324 /* #4004: volatile registers clobbered when catching across frames (originally misreported) *///{{{
2325 static
2327 {
2328  int i1, i2, i3;
2329 
2330  i1 = return_positive();
2331  i2 = return_positive();
2332  i3 = return_positive();
2333  (void)return_arg(i1 + i2 + i3);
2334 
2335  _SEH2_TRY
2336  {
2337  RaiseException(0xE00DEAD0, 0, 0, NULL);
2338  }
2340  {
2341  }
2342  _SEH2_END;
2343 }
2344 
2345 static
2347 {
2348  _SEH2_TRY
2349  {
2351  }
2353  {
2354  }
2355  _SEH2_END;
2356 }
2357 
2358 DEFINE_TEST(test_bug_4004)
2359 {
2360  int i1, i2, i3;
2361 
2362  i1 = return_positive();
2363  i2 = return_positive();
2364  i3 = return_positive();
2365 
2367 
2368  return return_arg(i1) + return_arg(i2) + return_arg(i3) == return_positive() * 3;
2369 }
2370 //}}}
2371 
2372 /* #4663: *///{{{
2373 DEFINE_TEST(test_bug_4663)
2374 {
2375  int i1, i2;
2376 
2377  i1 = return_positive();
2378  i2 = return_positive();
2379 
2380  _SEH2_TRY
2381  {
2382  _SEH2_TRY
2383  {
2384  RaiseException(0xE00DEAD0, 0, 0, 0);
2385  }
2387  {
2388  if (i1 == return_positive())
2389  {
2390  i1 = return_positive() + 1;
2391  }
2392  }
2393  _SEH2_END;
2394 
2395  if (i1 == return_positive() + 1)
2396  {
2397  i1 = return_negative();
2398  RaiseException(0xE00DEAD0, 0, 0, 0);
2399  }
2400  }
2402  {
2403  i2 = return_negative();
2404  }
2405  _SEH2_END;
2406 
2407  return ((i1 == return_negative()) && (i2 == return_negative()));
2408 }
2409 //}}}
2410 //}}}
2411 
2412 DEFINE_TEST(test_unvolatile)
2413 {
2414  int val = 0;
2415 
2416  _SEH2_TRY
2417  {
2418  val = return_one();
2419  *((char*)(intptr_t)0xc0000000) = 0;
2420  }
2422  {
2423  val = val + 3;
2424  }
2425  _SEH2_END;
2426 
2427  return (val == 4);
2428 }
2429 
2430 DEFINE_TEST(test_unvolatile_2)
2431 {
2432  int val = 0;
2433 
2434  _SEH2_TRY
2435  {
2436  val = 1;
2437  *((char*)(intptr_t)0xc0000000) = 0;
2438  val = 2;
2439  }
2441  {
2442  val = val + 3;
2443  }
2444  _SEH2_END;
2445 
2446  return (val == 3) || (val == 4) || (val == 5);
2447 }
2448 
2449 /* This test is mainly for documentation purpose. As can be seen it doesn't
2450  provide a satisfying result. In fact the compiler could do even more
2451  crazy things like reusing val1 between the assignment to 0 and the last
2452  assignment to 3. This DOES happen with C++ and it's NOT a PSEH bug, but
2453  rather an unavoidable consequence of how the compiler works.
2454  The conclusion: Do not use assignments to a variable inside a __try block
2455  that is being used later inside the __except block, unless it is declared
2456  volatile! */
2457 #ifndef __cplusplus
2458 DEFINE_TEST(test_unvolatile_3)
2459 {
2460  register int val1 = 0, val2 = 0;
2461 
2462  _SEH2_TRY
2463  {
2464  val1 = 1;
2465 
2466  _SEH2_TRY
2467  {
2468  val2 = 1;
2469  *((char*)(intptr_t)0xc0000000) = 0;
2470  val2 = 2;
2471  }
2473  {
2474  val2 |= 4;
2475  }
2476  _SEH2_END;
2477 
2478  val1 = 2;
2479  *((int*)(intptr_t)0xc0000000) = 1;
2480  val1 = 3;
2481  }
2483  {
2484  val1 = val1 * val2;
2485  }
2486  _SEH2_END;
2487 
2488  /* The expected case */
2489  if ((val1 == 10) && (val2 == 5))
2490  return TRUE;
2491 
2492  /* The compiler can optimize away "val1 = 1" and "val1 = 2" and
2493  only use the last "val1 = 3", in this case val1 is still 0
2494  when the outer exception handler kicks in */
2495  if ((val1 == 0) && (val2 == 5))
2496  return TRUE;
2497 
2498  /* Same as above, but this time val2 optimized away */
2499  if (((val1 == 8) && (val2 == 4)) ||
2500  ((val1 == 0) && (val2 == 4)))
2501  return TRUE;
2502 
2503  return FALSE;
2504 }
2505 #endif // __cplusplus
2506 
2507 DEFINE_TEST(test_unvolatile_4)
2508 {
2509  unsigned result = 0xdeadbeef;
2510 
2511  _SEH2_TRY
2512  {
2513  *(char*)(intptr_t)0x80000000 = 1;
2514  }
2515  _SEH2_EXCEPT(result == 0xdeadbeef)
2516  {
2517  result = 2;
2518  }
2519  _SEH2_END;
2520 
2521  result = (result == 0xdeadbeef) ? 0 : result + 1;
2522 
2523  return result == 3;
2524 }
2525 
2526 DEFINE_TEST(test_finally_goto)
2527 {
2528  volatile int val = 0;
2529 
2530  _SEH2_TRY
2531  {
2532  val |= 1;
2533  _SEH2_TRY
2534  {
2535  val |= 2;
2536  goto next;
2537  }
2539  {
2540  val |= 4;
2541  *((char*)(intptr_t)0xdeadc0de) = 0;
2542  val |= 8;
2543  }
2544  _SEH2_END;
2545 
2546  val |= 16;
2547 next:
2548  val |= 32;
2549  *((char*)(intptr_t)0xdeadc0de) = 0;
2550  val |= 64;
2551  }
2552  _SEH2_EXCEPT(1)
2553  {
2554  val |= 128;
2555  }
2556  _SEH2_END;
2557 
2558  return (val == (128|4|2|1));
2559 }
2560 
2561 DEFINE_TEST(test_nested_exception)
2562 {
2563  volatile int val = 0;
2564 
2565  _SEH2_TRY
2566  {
2567  val |= 1;
2568  _SEH2_TRY
2569  {
2570  val |= 2;
2571  *((char*)(intptr_t)0xdeadc0de) = 0;
2572  val |= 4;
2573  }
2574  _SEH2_EXCEPT(1)
2575  {
2576  val |= 8;
2577  *((char*)(intptr_t)0xdeadc0de) = 0;
2578  val |= 16;
2579  }
2580  _SEH2_END;
2581 
2582  val |= 32;
2583  *((char*)(intptr_t)0xdeadc0de) = 0;
2584  val |= 64;
2585  }
2586  _SEH2_EXCEPT(1)
2587  {
2588  val |= 128;
2589  }
2590  _SEH2_END;
2591 
2592  return (val == (1|2|8|128));
2593 }
2594 
2595 static
2597 {
2598  trace("unhandled exception %08lX thrown from %p\n", ExceptionInfo->ExceptionRecord->ExceptionCode, ExceptionInfo->ExceptionRecord->ExceptionAddress);
2600 }
2601 
2602 #if defined(_M_IX86)
2603 struct volatile_context
2604 {
2605  void * esp;
2606  void * ebp;
2607  void * ebx;
2608  void * esi;
2609  void * edi;
2610 };
2611 #else
2613 {
2614  int _ignore;
2615 };
2616 #endif
2617 
2618 static
2621 {
2622  if(ret && memcmp(before, after, sizeof(*before)))
2623  {
2624  trace("volatile context corrupted\n");
2625  return 0;
2626  }
2627 
2628  return ret;
2629 }
2630 
2631 #ifndef _PSEH3_H_
2632 static
2633 int passthrough_handler(struct _EXCEPTION_RECORD * e, void * f, struct _CONTEXT * c, void * d)
2634 {
2635  return ExceptionContinueSearch;
2636 }
2637 #endif
2638 
2639 static
2641 int call_test(int (* func)(void))
2642 {
2643  static int ret;
2644  static struct volatile_context before, after;
2645  static LPTOP_LEVEL_EXCEPTION_FILTER prev_unhandled_exception;
2646 #if defined(_X86_) && !defined(_PSEH3_H_) && !defined(_MSC_VER)
2647  static _SEH2Registration_t * prev_frame;
2648  _SEH2Registration_t passthrough_frame;
2649 #endif
2650 
2651  prev_unhandled_exception = SetUnhandledExceptionFilter(&unhandled_exception);
2652 
2653 #if defined(_X86_) && !defined(_PSEH3_H_) && !defined(_MSC_VER)
2654  prev_frame = (_SEH2Registration_t *)__readfsdword(0);
2655  passthrough_frame.SER_Prev = prev_frame;
2656  passthrough_frame.SER_Handler = passthrough_handler;
2657  __writefsdword(0, (unsigned long)&passthrough_frame);
2658 #endif
2659 
2660 #if defined(__GNUC__) && defined(__i386__)
2661  __asm__ __volatile__
2662  (
2663  "mov %%esp, 0x00 + %c[before]\n"
2664  "mov %%ebp, 0x04 + %c[before]\n"
2665  "mov %%ebx, 0x08 + %c[before]\n"
2666  "mov %%esi, 0x0c + %c[before]\n"
2667  "mov %%edi, 0x10 + %c[before]\n"
2668  "call *%[test]\n"
2669  "mov %%esp, 0x00 + %c[after]\n"
2670  "mov %%ebp, 0x04 + %c[after]\n"
2671  "mov %%ebx, 0x08 + %c[after]\n"
2672  "mov %%esi, 0x0c + %c[after]\n"
2673  "mov %%edi, 0x10 + %c[after]\n"
2674  "push %[after]\n"
2675  "push %[before]\n"
2676  "push %[ret]\n"
2677  "call %c[sanity_check]\n"
2678  "pop %%ecx\n"
2679  "pop %%ecx\n"
2680  "pop %%ecx\n" :
2681  [ret] "=a" (ret) :
2682  [test] "r" (func), [before] "i" (&before), [after] "i" (&after), [sanity_check] "i" (&sanity_check) :
2683  "ebx", "ecx", "edx", "esi", "edi", "flags", "memory"
2684  );
2685 #else
2686  ret = func();
2687 #endif
2688 
2689 #if defined(_X86_) && !defined(_PSEH3_H_) && !defined(_MSC_VER)
2690  if((_SEH2Registration_t *)__readfsdword(0) != &passthrough_frame || passthrough_frame.SER_Prev != prev_frame)
2691  {
2692  trace("exception registration list corrupted\n");
2693  ret = 0;
2694  }
2695 
2696  __writefsdword(0, (unsigned long)prev_frame);
2697 #endif
2698 
2699  SetUnhandledExceptionFilter(prev_unhandled_exception);
2700  return ret;
2701 }
2702 
2703 DEFINE_TEST(test_PSEH3_bug)
2704 {
2705  volatile int count = 0;
2706  int dummy = 0;
2707 
2708  _SEH2_TRY
2709  {
2710  if (count++ == 0)
2711  {
2712  *(volatile int*)0x12345678 = 0x12345678;
2713  }
2714  }
2716  {
2717  dummy = 0;
2718  }
2719  _SEH2_END;
2720 
2721  (void)dummy;
2722  return (count == 1);
2723 }
2724 
2725 void
2727 {
2728  int i;
2729  volatile int arr[512];
2730  for (i = 0; i < 512; i++)
2731  arr[i] = 123;
2732  (void)arr;
2733 }
2734 
2735 DEFINE_TEST(test_PSEH3_bug2)
2736 {
2737  unsigned long status = 0;
2738  _SEH2_TRY
2739  {
2740  *(volatile int*)0x12345678 = 0x12345678;
2741  }
2743  {
2746  }
2747  _SEH2_END;
2748 
2749  return (status == STATUS_ACCESS_VIOLATION);
2750 }
2751 
2752 #define USE_TEST_NAME_(NAME_) # NAME_
2753 #define USE_TEST_NAME(NAME_) USE_TEST_NAME_(NAME_)
2754 #define USE_TEST(NAME_) { USE_TEST_NAME(NAME_), NAME_ }
2755 
2756 struct subtest
2757 {
2758  const char * name;
2759  int (* func)(void);
2760 };
2761 
2763 {
2764  const struct subtest testsuite[] =
2765  {
2766  USE_TEST(test_empty_1),
2767  USE_TEST(test_empty_2),
2768  USE_TEST(test_empty_3),
2769  USE_TEST(test_empty_4),
2770  USE_TEST(test_empty_5),
2771  USE_TEST(test_empty_6),
2772  USE_TEST(test_empty_7),
2773  USE_TEST(test_empty_8),
2774 
2775  USE_TEST(test_execute_handler_1),
2776  USE_TEST(test_continue_execution_1),
2777  USE_TEST(test_continue_search_1),
2778  USE_TEST(test_execute_handler_2),
2779  USE_TEST(test_continue_execution_2),
2780 
2781  USE_TEST(test_execute_handler_3),
2782  USE_TEST(test_continue_execution_3),
2783  USE_TEST(test_continue_search_2),
2784  USE_TEST(test_execute_handler_4),
2785  USE_TEST(test_continue_execution_4),
2786 
2787  USE_TEST(test_execute_handler_5),
2788  USE_TEST(test_continue_execution_5),
2789  USE_TEST(test_continue_search_3),
2790  USE_TEST(test_execute_handler_6),
2791  USE_TEST(test_continue_execution_6),
2792 
2793  USE_TEST(test_execute_handler_7),
2794  USE_TEST(test_continue_execution_7),
2795  USE_TEST(test_continue_search_4),
2796  USE_TEST(test_execute_handler_8),
2797  USE_TEST(test_continue_execution_8),
2798 
2799  USE_TEST(test_execute_handler_9),
2800  USE_TEST(test_continue_execution_9),
2801  USE_TEST(test_continue_search_5),
2802  USE_TEST(test_execute_handler_10),
2803  USE_TEST(test_continue_execution_10),
2804 
2805  USE_TEST(test_execute_handler_11),
2806  USE_TEST(test_continue_execution_11),
2807  USE_TEST(test_continue_search_6),
2808  USE_TEST(test_execute_handler_12),
2809  USE_TEST(test_continue_execution_12),
2810 
2811  USE_TEST(test_leave_1),
2812  USE_TEST(test_leave_2),
2813  USE_TEST(test_leave_3),
2814  USE_TEST(test_leave_4),
2815  USE_TEST(test_leave_5),
2816  USE_TEST(test_leave_6),
2817 
2818  USE_TEST(test_yield_1),
2819  USE_TEST(test_yield_2),
2820  USE_TEST(test_yield_3),
2821  USE_TEST(test_yield_4),
2822  USE_TEST(test_yield_5),
2823  USE_TEST(test_yield_6),
2824 
2825  USE_TEST(test_finally_1),
2826  USE_TEST(test_finally_2),
2827  USE_TEST(test_finally_3),
2828  USE_TEST(test_finally_4),
2829  USE_TEST(test_finally_5),
2830  USE_TEST(test_finally_6),
2831  USE_TEST(test_finally_7),
2832  USE_TEST(test_finally_8),
2833  USE_TEST(test_finally_9),
2834  USE_TEST(test_finally_10),
2835  USE_TEST(test_finally_11),
2836  USE_TEST(test_finally_12),
2837  USE_TEST(test_finally_13),
2838  USE_TEST(test_finally_14),
2839 
2840  USE_TEST(test_xpointers_1),
2841  USE_TEST(test_xpointers_2),
2842  USE_TEST(test_xpointers_3),
2843  USE_TEST(test_xpointers_4),
2844  USE_TEST(test_xpointers_5),
2845  USE_TEST(test_xpointers_6),
2846  USE_TEST(test_xpointers_7),
2847  USE_TEST(test_xpointers_8),
2848  USE_TEST(test_xpointers_9),
2849  USE_TEST(test_xpointers_10),
2850  USE_TEST(test_xpointers_11),
2851  USE_TEST(test_xpointers_12),
2852  USE_TEST(test_xpointers_13),
2853  USE_TEST(test_xpointers_14),
2854  USE_TEST(test_xpointers_15),
2855  USE_TEST(test_xpointers_16),
2856 
2857  USE_TEST(test_xcode_1),
2858  USE_TEST(test_xcode_2),
2859  USE_TEST(test_xcode_3),
2860 
2861  USE_TEST(test_abnorm_1),
2862  USE_TEST(test_abnorm_2),
2863  USE_TEST(test_abnorm_3),
2864  USE_TEST(test_abnorm_4),
2865  USE_TEST(test_abnorm_5),
2866  USE_TEST(test_abnorm_6),
2867  USE_TEST(test_abnorm_7),
2868  USE_TEST(test_abnorm_8),
2869 
2870  USE_TEST(test_nested_locals_1),
2871  USE_TEST(test_nested_locals_2),
2872  USE_TEST(test_nested_locals_3),
2873 
2874  USE_TEST(test_bug_4004),
2875  USE_TEST(test_bug_4663),
2876 
2877  USE_TEST(test_unvolatile),
2878  USE_TEST(test_unvolatile_2),
2879 #ifndef __cplusplus
2880  USE_TEST(test_unvolatile_3),
2881 #endif
2882  USE_TEST(test_unvolatile_4),
2883  USE_TEST(test_finally_goto),
2884  USE_TEST(test_nested_exception),
2885  USE_TEST(test_PSEH3_bug),
2886  USE_TEST(test_PSEH3_bug2),
2887  };
2888 
2889  size_t i;
2890 
2891  for(i = 0; i < sizeof(testsuite) / sizeof(testsuite[0]); ++ i)
2892  ok(call_test(testsuite[i].func), "%s failed\n", testsuite[i].name);
2893 }
2894 
2895 /* EOF */
int return_negative_2(void *)
Definition: psehtest2.c:77
START_TEST(pseh)
Definition: pseh.c:2762
GLenum func
Definition: glext.h:6028
#define DEFINE_TEST(NAME_)
Definition: pseh.c:66
int test_yield_6_ret
Definition: pseh.c:1071
static int argc
Definition: ServiceArgs.c:12
struct png_info_def **typedef void(__cdecl typeof(png_destroy_read_struct))(struct png_struct_def **
Definition: typeof.h:49
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
int return_zero_3(int)
Definition: psehtest2.c:95
GLuint64EXT * result
Definition: glext.h:11304
static int test_finally_4_ret
Definition: pseh.c:1166
static int test_yield_5_ret
Definition: pseh.c:1046
ecx edi ebx edx edi decl ecx esi eax jecxz decl eax andl eax esi movl edx movl TEMP incl eax andl eax ecx incl ebx eax jnz xchgl ecx incl TEMP esp ecx subl ebx pushl ecx ecx edx ecx ecx mm0 mm4 mm0 mm4 mm1 mm5 mm1 mm5 mm2 mm6 mm2 mm6 mm3 mm7 mm3 mm7 paddd mm0 paddd mm4 paddd mm0 paddd mm4 paddd mm0 paddd mm4 movq mm1 movq mm5 mm1 mm5 paddd mm0 paddd mm4 mm0 mm4 packssdw mm0 packssdw mm4 mm1 punpckldq mm0 pand mm1 pand mm0 por mm1 movq edi esi edx edi decl ecx jnz popl ecx ecx jecxz mm0 mm0 mm1 mm1 mm2 mm2 mm3 mm3 paddd mm0 paddd mm0 paddd mm0 movq mm1 mm1 paddd mm0 mm0 packssdw mm0 movd eax movw edi esi edx esi ecx mm0 mm4 mm0 mm4 mm1 mm5 mm1 mm5 mm2 mm6 mm2 mm6 mm3 mm7 mm3 mm7 paddd mm0 paddd mm4 paddd mm0 paddd mm4 paddd mm0 paddd mm4 movq mm1 movq mm5 mm1 mm5 paddd mm1 paddd mm5 mm1 mm5 packssdw mm1 packssdw mm5 psubd mm0 psubd mm4 psubsw mm0 psubsw mm4 mm1 punpckldq mm0 pand mm1 pand mm0 por mm1 movq edi esi edx edi decl ecx jnz mm0 mm0 mm1 mm1 mm2 mm2 mm3 mm3 paddd mm0 paddd mm0 paddd mm0 movq mm1 mm1 paddd mm1 mm1 packssdw mm1 psubd mm0 psubsw mm0 movd eax movw edi emms popl ebx popl esi popl edi mov ebp
Definition: synth_sse3d.h:248
ecx edi ebx edx edi decl ecx esi eax jecxz decl eax andl eax esi movl edx movl TEMP incl eax andl eax ecx incl ebx eax jnz xchgl ecx incl TEMP esi
Definition: synth_sse3d.h:103
#define TRUE
Definition: types.h:120
static int test_yield_3_helper(void)
Definition: pseh.c:984
GLuint GLuint GLsizei count
Definition: gl.h:1545
GLdouble n
Definition: glext.h:7729
#define EXCEPTION_NONCONTINUABLE
Definition: rtltypes.h:154
int return_zero_2(void *)
Definition: psehtest2.c:65
int return_negative_3(int)
Definition: psehtest2.c:107
static int test_yield_4_helper(void)
Definition: pseh.c:1015
__inline int before(__u32 seq1, __u32 seq2)
Definition: tcpcore.h:2414
__asm__("\n\t \ NewInt3Handler:\n\t \ pushl $" STR(REASON_INT3) "\n\t \ // call debugger loop\n\t \ jmp NewInt31Handler\n\t \ ")
#define test
Definition: rosglue.h:37
#define argv
Definition: mplay32.c:18
void no_op(void)
Definition: psehtest2.c:30
Definition: match.c:390
PVOID ExceptionAddress
Definition: compat.h:211
static void test_bug_4004_helper_2(void)
Definition: pseh.c:2346
_SEH2_TRY
Definition: create.c:4226
static int test_finally_9_ret
Definition: pseh.c:1309
uint32_t ULONG_PTR
Definition: typedefs.h:65
#define EXCEPTION_CONTINUE_EXECUTION
Definition: excpt.h:87
DWORD ExceptionCode
Definition: compat.h:208
static int test_finally_4_helper(void)
Definition: pseh.c:1168
void use_lots_of_stack(void)
Definition: pseh.c:2726
Definition: pseh.c:2756
static void test_bug_4004_helper_1(void)
Definition: pseh.c:2326
#define FALSE
Definition: types.h:117
static int test_yield_5_helper(void)
Definition: pseh.c:1049
long LONG
Definition: pedump.c:60
LPTOP_LEVEL_EXCEPTION_FILTER WINAPI DECLSPEC_HOTPATCH SetUnhandledExceptionFilter(IN LPTOP_LEVEL_EXCEPTION_FILTER lpTopLevelExceptionFilter)
Definition: except.c:788
#define e
Definition: ke_i.h:82
static void test_finally_13_helper(void)
Definition: pseh.c:1462
static int test_finally_14_ret
Definition: pseh.c:1515
#define _SEH2_GetExceptionInformation()
Definition: pseh2_64.h:164
static int test_finally_13_ret
Definition: pseh.c:1459
int return_one_2(void *)
Definition: psehtest2.c:83
static int test_yield_1_helper(void)
Definition: pseh.c:941
static int verify_xpointers(struct _EXCEPTION_POINTERS *ep, DWORD code, DWORD flags, DWORD argc, const ULONG_PTR *argv, int *ret, int filter)
Definition: pseh.c:1583
#define _SEH2_AbnormalTermination()
Definition: pseh2_64.h:166
int return_zero_4(void *, int)
Definition: psehtest2.c:125
PPC_QUAL unsigned long __readfsdword(const unsigned long Offset)
Definition: intrin_ppc.h:382
#define leave
Definition: seh.h:23
int return_minusone_3(int)
Definition: psehtest2.c:119
int return_negative(void)
Definition: psehtest2.c:47
GLuint GLfloat * val
Definition: glext.h:7180
int return_zero(void)
Definition: psehtest2.c:35
PCONTEXT ContextRecord
Definition: rtltypes.h:201
int return_one_3(int)
Definition: psehtest2.c:113
GLfloat f
Definition: glext.h:7540
ULONG_PTR ExceptionInformation[EXCEPTION_MAXIMUM_PARAMETERS]
Definition: compat.h:213
#define trace
Definition: atltest.h:70
int intptr_t
Definition: crtdefs.h:304
ecx edi ebx edx edi decl ecx esi eax jecxz decl eax andl eax esi movl edx movl TEMP incl eax andl eax ecx incl ebx eax jnz xchgl ecx incl TEMP esp ecx subl ebx pushl ecx ecx edx ecx ecx mm0 mm4 mm0 mm4 mm1 mm5 mm1 mm5 mm2 mm6 mm2 mm6 mm3 mm7 mm3 mm7 paddd mm0 paddd mm4 paddd mm0 paddd mm4 paddd mm0 paddd mm4 movq mm1 movq mm5 mm1 mm5 paddd mm0 paddd mm4 mm0 mm4 packssdw mm0 packssdw mm4 mm1 punpckldq mm0 pand mm1 pand mm0 por mm1 movq edi esi edx edi decl ecx jnz popl ecx ecx jecxz mm0 mm0 mm1 mm1 mm2 mm2 mm3 mm3 paddd mm0 paddd mm0 paddd mm0 movq mm1 mm1 paddd mm0 mm0 packssdw mm0 movd eax movw edi esi edx edi
Definition: synth_sse3d.h:185
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
static int passthrough_handler(struct _EXCEPTION_RECORD *e, void *f, struct _CONTEXT *c, void *d)
Definition: pseh.c:2633
#define WINAPI
Definition: msvc.h:6
const GLubyte * c
Definition: glext.h:8905
unsigned long DWORD
Definition: ntddk_ex.h:95
ecx edi ebx edx edi decl ecx esi eax jecxz decl eax andl ebx
Definition: synth_sse3d.h:83
const char * name
Definition: pseh.c:2758
GLbitfield flags
Definition: glext.h:7161
int return_negative_4(void *, int)
Definition: psehtest2.c:137
int ret
static void test_finally_14_helper(void)
Definition: pseh.c:1518
PTOP_LEVEL_EXCEPTION_FILTER LPTOP_LEVEL_EXCEPTION_FILTER
Definition: winbase.h:1435
__inline int after(__u32 seq1, __u32 seq2)
Definition: tcpcore.h:2419
Definition: inflate.c:139
static LONG WINAPI unhandled_exception(PEXCEPTION_POINTERS ExceptionInfo)
Definition: pseh.c:2596
int return_positive_3(int)
Definition: psehtest2.c:101
_SEH2_END
Definition: create.c:4400
static unsigned __int64 next
Definition: rand_nt.c:6
VOID WINAPI RaiseException(IN DWORD dwExceptionCode, IN DWORD dwExceptionFlags, IN DWORD nNumberOfArguments, IN CONST ULONG_PTR *lpArguments OPTIONAL)
Definition: except.c:700
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
int return_minusone(void)
Definition: psehtest2.c:59
#define EXCEPTION_CONTINUE_SEARCH
Definition: excpt.h:86
#define STATUS_ACCESS_VIOLATION
Definition: ntstatus.h:242
#define ok(value,...)
Definition: atltest.h:57
int return_positive_4(void *, int)
Definition: psehtest2.c:131
int return_positive(void)
Definition: psehtest2.c:41
_SEH2_FINALLY
Definition: create.c:4371
PPC_QUAL void __writefsdword(const unsigned long Offset, const unsigned long Data)
Definition: intrin_ppc.h:354
#define NULL
Definition: types.h:112
int return_minusone_4(void *, int)
Definition: psehtest2.c:149
static DECLSPEC_NOINLINE int sanity_check(int ret, struct volatile_context *before, struct volatile_context *after)
Definition: pseh.c:2620
int return_one_4(void *, int)
Definition: psehtest2.c:143
int return_positive_2(void *)
Definition: psehtest2.c:71
int return_one(void)
Definition: psehtest2.c:53
#define USE_TEST(NAME_)
Definition: pseh.c:2754
static int test_yield_6_helper(void)
Definition: pseh.c:1074
static int test_yield_2_helper(void)
Definition: pseh.c:962
DWORD ExceptionFlags
Definition: compat.h:209
int return_minusone_2(void *)
Definition: psehtest2.c:89
PEXCEPTION_RECORD ExceptionRecord
Definition: rtltypes.h:200
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:40
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:165
#define _SEH2_YIELD(__stmt)
Definition: pseh2_64.h:168
#define _SEH2_LEAVE
Definition: filesup.c:20
void set_positive(int *)
Definition: psehtest2.c:155
DWORD NumberParameters
Definition: compat.h:212
#define DECLSPEC_NOINLINE
Definition: ntbasedef.h:225
static int verify_xcode(int code, int xcode, int *ret, int filter)
Definition: pseh.c:1965
GLint GLint GLint GLint GLint GLint GLint GLbitfield GLenum filter
Definition: glext.h:7005
static int test_finally_9_helper(void)
Definition: pseh.c:1311
static DECLSPEC_NOINLINE int call_test(int(*func)(void))
Definition: pseh.c:2641
#define d
Definition: ke_i.h:81
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
int return_arg(int)
Definition: psehtest2.c:24
Definition: ps.c:97