| blob | fe5bc32817096bcf0f0460b270ae429cdbf1c23e |
5 /*
6 * Regression tests for the mono JIT.
7 *
8 * Each test needs to be of the form:
9 *
10 * public static int test_<result>_<name> ();
11 *
12 * where <result> is an integer (the value that needs to be returned by
13 * the method to make it pass.
14 * <name> is a user-displayed name used to identify the test.
15 *
16 * The tests can be driven in two ways:
17 * *) running the program directly: Main() uses reflection to find and invoke
18 * the test methods (this is useful mostly to check that the tests are correct)
19 * *) with the --regression switch of the jit (this is the preferred way since
20 * all the tests will be run with optimizations on and off)
21 *
22 * The reflection logic could be moved to a .dll since we need at least another
23 * regression test file written in IL code to have better control on how
24 * the IL code looks.
25 */
27 #if __MOBILE__
28 class ExceptionTests
29 #else
30 class Tests
31 #endif
32 {
34 #if !__MOBILE__
37 }
38 #endif
48 }
50 }
61 }
64 }
75 }
77 }
89 }
90 }
92 }
106 }
109 }
120 }
123 }
135 }
138 }
149 }
152 }
163 }
166 }
177 }
180 }
191 }
194 }
205 }
208 }
219 }
222 }
233 }
236 }
247 }
250 }
261 }
264 }
275 }
276 }
279 }
286 }
299 }
302 }
313 }
316 }
327 }
330 }
341 }
344 }
355 }
358 }
369 }
372 }
383 }
386 }
397 }
400 }
411 }
414 }
425 }
428 }
439 }
442 }
453 }
456 }
467 }
470 }
481 }
484 }
495 }
498 }
509 }
512 }
523 }
526 }
537 }
540 }
551 }
554 }
565 }
568 }
579 }
580 }
583 }
590 }
604 }
607 }
616 }
619 }
628 }
631 }
640 }
643 }
652 }
655 }
664 }
667 }
676 }
679 }
688 }
691 }
700 }
703 }
712 }
715 }
724 }
727 }
736 }
739 }
748 }
751 }
756 }
769 }
772 }
781 }
784 }
793 }
796 }
805 }
808 }
817 }
820 }
829 }
832 }
841 }
844 }
853 }
856 }
865 }
868 }
877 }
880 }
889 }
892 }
901 }
904 }
913 }
916 }
925 }
928 }
937 }
940 }
950 }
953 }
962 }
965 }
974 }
977 }
982 }
994 }
997 }
1006 }
1009 }
1019 }
1022 }
1032 }
1035 }
1044 }
1047 }
1056 }
1059 }
1069 }
1072 }
1082 }
1085 }
1094 }
1095 }
1098 }
1107 }
1108 }
1111 }
1120 }
1121 }
1124 }
1128 {
1133 }
1134 }
1137 }
1149 }
1152 }
1161 }
1164 }
1173 }
1176 }
1185 }
1188 }
1197 }
1200 }
1209 }
1212 }
1221 }
1224 }
1233 }
1236 }
1245 }
1246 }
1249 }
1253 {
1258 }
1259 }
1262 }
1266 /*
1267 * These tests depend on properties of x86 fp arithmetic so they won't work
1268 * on other platforms.
1269 */
1270 /*
1271 long a;
1272 bool failed;
1274 try {
1275 double d = System.Int64.MaxValue - 512.0;
1276 failed = true;
1277 checked {
1278 a = (long)d;
1279 }
1280 } catch (OverflowException) {
1281 failed = false;
1282 }
1283 if (failed)
1284 return 1;
1286 try {
1287 double d = System.Int64.MaxValue - 513.0;
1288 failed = false;
1289 checked {
1290 a = (long)d;
1291 }
1292 } catch (OverflowException) {
1293 failed = true;
1294 }
1295 if (failed)
1296 return 2;
1298 try {
1299 double d = System.Int64.MinValue - 1024.0;
1300 failed = false;
1301 checked {
1302 a = (long)d;
1303 }
1304 } catch (OverflowException) {
1305 failed = true;
1306 }
1307 if (failed)
1308 return 3;
1310 try {
1311 double d = System.Int64.MinValue - 1025.0;
1312 failed = true;
1313 checked {
1314 a = (long)d;
1315 }
1316 } catch (OverflowException) {
1317 failed = false;
1318 }
1319 if (failed)
1320 return 4;
1321 */
1323 {
1328 }
1329 }
1332 }
1334 /* Github issue 13284 */
1346 // Console.WriteLine ($"u64 ({x} - {y} >= {z}) => {a} [{(a == false ? "OK" : "NG")}]");
1349 // Console.WriteLine ($"u64 ({x} - {y} >= {z}) => overflow [NG]");
1350 }
1356 // Console.WriteLine ($"u64 ({t} >= {z}) => {a} [{(a == false ? "OK" : "NG")}]");
1359 // Console.WriteLine ($"u64 ({t} >= {z}) => overflow [NG]");
1360 }
1366 else
1368 // Console.WriteLine ($"u64 ({x} - {y} - {z} >= 0) => {a} [NG]");
1371 // Console.WriteLine ($"u64 ({x} - {y} - {z} >= 0) => overflow [OK]");
1372 }
1373 }
1374 }
1380 /*
1381 * These tests depend on properties of x86 fp arithmetic so they won't work
1382 * on other platforms.
1383 */
1385 /*
1386 try {
1387 double d = System.UInt64.MaxValue - 1024.0;
1388 failed = true;
1389 checked {
1390 a = (ulong)d;
1391 }
1392 } catch (OverflowException) {
1393 failed = false;
1394 }
1395 if (failed)
1396 return 1;
1398 try {
1399 double d = System.UInt64.MaxValue - 1025.0;
1400 failed = false;
1401 checked {
1402 a = (ulong)d;
1403 }
1404 } catch (OverflowException) {
1405 failed = true;
1406 }
1407 if (failed)
1408 return 2;
1409 */
1416 }
1419 }
1428 }
1431 }
1435 {
1440 }
1441 }
1448 }
1449 }
1452 }
1461 }
1462 }
1465 }
1470 }
1479 /*
1480 * These tests depend on properties of x86 fp arithmetic so they won't work
1481 * on other platforms.
1482 */
1483 /*
1484 d = 0xffffffffffffffff;
1486 if ((ulong)d != 0)
1487 return 2;
1489 if ((ushort)d != 0)
1490 return 3;
1492 if ((byte)d != 0)
1493 return 4;
1494 */
1505 }
1518 }
1527 }
1537 /* wrong exception */
1540 }
1550 /* wrong exception */
1553 }
1558 }
1562 }
1567 // This call make use avoid the 'handler without invoke' restriction in the llvm backend
1572 }
1573 }
1582 }
1583 }
1593 }
1602 }
1603 }
1612 }
1613 }
1623 }
1627 }
1630 // Test that constant folding doesn't cause division by zero exceptions
1645 }
1648 }
1661 }
1670 }
1675 }
1688 }
1697 }
1707 /* wrong exception */
1710 }
1720 /* wrong exception */
1723 }
1728 }
1741 }
1750 }
1755 }
1768 }
1777 }
1782 }
1791 // Illegal conversion; o contains a string not an int
1796 }
1799 }
1801 // Test that double[] can't be cast to double (bug #46027)
1809 }
1811 }
1814 }
1815 }
1817 /* bug# 42190, at least mcs generates a leave for the return that
1818 * jumps out of multiple exception clauses: we used to execute just
1819 * one enclosing finally block.
1820 */
1829 }
1831 finally_level++;
1832 }
1833 }
1841 }
1848 checked { j = (long)i; }
1851 }
1856 }
1864 checked { j = (ulong)i; }
1867 }
1872 }
1883 };
1897 }
1903 }
1905 }
1906 }
1907 }
1911 }
1915 }
1919 }
1930 }
1937 }
1948 }
1949 }
1951 }
1962 }
1963 }
1965 }
1976 }
1977 }
1979 }
1990 }
1991 }
1993 }
2004 }
2005 }
2007 }
2018 }
2019 }
2021 }
2032 }
2033 }
2035 }
2046 }
2047 }
2049 }
2060 }
2061 }
2063 }
2074 }
2075 }
2077 }
2088 }
2089 }
2091 }
2102 }
2103 }
2105 }
2116 }
2117 }
2119 }
2130 }
2131 }
2133 }
2144 }
2145 }
2147 }
2158 }
2159 }
2161 }
2170 }
2171 }
2173 }
2184 }
2185 }
2187 }
2198 }
2199 }
2201 }
2212 }
2213 }
2215 }
2226 }
2227 }
2229 }
2241 }
2242 }
2244 }
2256 }
2257 }
2259 }
2266 }
2270 }
2271 }
2276 }
2278 // This will only happen once even if --regression is used
2279 }
2281 }
2290 }
2291 }
2295 }
2297 // Check that variables written in catch clauses are volatile
2301 }
2304 }
2312 }
2315 }
2316 }
2318 }
2323 }
2333 }
2334 }
2335 }
2337 // Test that a rethrow rethrows the correct exception
2345 }
2347 }
2352 }
2357 /* This disables tailcall opts */
2359 }
2363 // Check that rethrowing an exception preserves the original stack trace
2367 }
2369 // Check that each catch clause has its own exception variable
2370 // If not, the throw below will overwrite the exception used
2371 // by the rethrow
2374 }
2376 }
2379 }
2380 }
2384 }
2387 }
2399 }
2400 }
2409 }
2410 }
2420 }
2421 }
2429 }
2432 }
2437 }
2441 }
2448 }
2450 /* Test that arguments are correctly popped off the stack during unwinding */
2451 /* FIXME: Fails on x86 when llvm is enabled (#5432) */
2452 /*
2453 public static int test_0_stack_unwind () {
2454 addr = new IntPtr [1000];
2455 S s = new S ();
2456 for (int j = 0; j < 1000; j++) {
2457 try {
2458 throw_func (j, s);
2459 }
2460 catch (Exception) {
2461 }
2462 }
2463 return (addr [0].ToInt64 () - addr [100].ToInt64 () < 100) ? 0 : 1;
2464 }
2465 */
2469 }
2471 /* Test that the arguments to the throw trampoline are correctly popped off the stack */
2479 }
2481 }
2482 }
2484 }
2492 }
2494 }
2496 }
2504 }
2506 }
2510 }
2518 }
2521 }
2525 }
2530 }
2535 }
2538 }
2539 }
2543 }
2547 }
2553 }
2556 }
2559 }
2561 // bug #78633
2571 i ++;
2572 }
2574 }
2577 }
2579 // bug #485721
2586 }
2592 }
2594 }
2595 }
2599 }
2601 }
2602 }
2603 }
2606 }
2614 }
2615 }
2617 // for llvm, the end bblock is unreachable
2621 else
2623 }
2627 }
2629 // bug #539550
2632 // The invoke calls a runtime-invoke wrapper which has a filter clause
2633 #if __MOBILE__
2635 #else
2637 #endif
2639 }
2641 }
2646 }
2649 }
2650 }
2655 }
2660 }
2662 }
2663 }
2667 }
2671 }
2673 // #559876
2683 }
2685 }
2694 }
2699 }
2702 }
2704 class Child
2705 {
2707 {
2709 }
2710 }
2712 /* #612206 */
2718 }
2721 }
2725 }
2728 }
2737 }
2740 }
2742 unsafe struct Foo
2743 {
2747 }
2749 /* MS.NET doesn't seem to throw in this case */
2754 }
2757 // Fill up registers with values
2780 }
2782 }
2786 ;
2788 }
2797 /* Make sure this doesn't branch to the finally */
2801 /* Make sure o is register allocated */
2804 else
2808 else
2812 else
2815 }
2816 }
2817 }
2823 }
2829 }
2836 }
2838 }
2848 }
2849 }
2850 }
2857 }
2859 }
2869 }
2875 }
2877 }
2885 }
2887 }
2895 }
2899 }
2905 }
2911 }
2912 }
2922 }
2924 }
2940 }
2943 }
2944 // "2ndcatch_innerFinally_init"
2945 // Console.WriteLine ("res1: " + res);
2952 }
2953 // Console.WriteLine ("res2: " + res);
2955 }
2957 public struct FooStruct
2958 {
2959 public long Part1 { get; }
2960 public long Part2 { get; }
2962 public byte Part3 { get; }
2963 }
2972 }
2974 }
2976 }
2989 }
2997 }
3012 }
3022 }
3031 }
3032 }
3034 #if !__MOBILE__
3036 {
3037 }
3038 #endif