| blob | 5db7e5e6f308883d9da3ba28a926720105a78dfd |
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 }
1480 /*
1481 * These tests depend on properties of x86 fp arithmetic so they won't work
1482 * on other platforms.
1483 */
1484 /*
1485 d = 0xffffffffffffffff;
1487 if ((ulong)d != 0)
1488 return 2;
1490 if ((ushort)d != 0)
1491 return 3;
1493 if ((byte)d != 0)
1494 return 4;
1495 */
1506 }
1519 }
1528 }
1538 /* wrong exception */
1541 }
1551 /* wrong exception */
1554 }
1559 }
1563 }
1568 // This call make use avoid the 'handler without invoke' restriction in the llvm backend
1573 }
1574 }
1583 }
1584 }
1594 }
1603 }
1604 }
1613 }
1614 }
1624 }
1628 }
1631 // Test that constant folding doesn't cause division by zero exceptions
1646 }
1649 }
1662 }
1671 }
1676 }
1689 }
1698 }
1708 /* wrong exception */
1711 }
1721 /* wrong exception */
1724 }
1729 }
1742 }
1751 }
1756 }
1769 }
1778 }
1783 }
1792 // Illegal conversion; o contains a string not an int
1797 }
1800 }
1802 // Test that double[] can't be cast to double (bug #46027)
1810 }
1812 }
1815 }
1816 }
1818 /* bug# 42190, at least mcs generates a leave for the return that
1819 * jumps out of multiple exception clauses: we used to execute just
1820 * one enclosing finally block.
1821 */
1830 }
1832 finally_level++;
1833 }
1834 }
1842 }
1849 checked { j = (long)i; }
1852 }
1857 }
1865 checked { j = (ulong)i; }
1868 }
1873 }
1884 };
1898 }
1904 }
1906 }
1907 }
1908 }
1912 }
1916 }
1920 }
1931 }
1938 }
1949 }
1950 }
1952 }
1963 }
1964 }
1966 }
1977 }
1978 }
1980 }
1991 }
1992 }
1994 }
2005 }
2006 }
2008 }
2019 }
2020 }
2022 }
2033 }
2034 }
2036 }
2047 }
2048 }
2050 }
2061 }
2062 }
2064 }
2075 }
2076 }
2078 }
2089 }
2090 }
2092 }
2103 }
2104 }
2106 }
2117 }
2118 }
2120 }
2131 }
2132 }
2134 }
2145 }
2146 }
2148 }
2159 }
2160 }
2162 }
2171 }
2172 }
2174 }
2185 }
2186 }
2188 }
2199 }
2200 }
2202 }
2213 }
2214 }
2216 }
2227 }
2228 }
2230 }
2242 }
2243 }
2245 }
2257 }
2258 }
2260 }
2267 }
2271 }
2272 }
2277 }
2279 // This will only happen once even if --regression is used
2280 }
2282 }
2291 }
2292 }
2296 }
2298 // Check that variables written in catch clauses are volatile
2302 }
2305 }
2313 }
2316 }
2317 }
2319 }
2324 }
2334 }
2335 }
2336 }
2338 // Test that a rethrow rethrows the correct exception
2346 }
2348 }
2353 }
2358 /* This disables tailcall opts */
2360 }
2364 // Check that rethrowing an exception preserves the original stack trace
2368 }
2370 // Check that each catch clause has its own exception variable
2371 // If not, the throw below will overwrite the exception used
2372 // by the rethrow
2375 }
2377 }
2380 }
2381 }
2385 }
2388 }
2400 }
2401 }
2410 }
2411 }
2421 }
2422 }
2430 }
2433 }
2438 }
2442 }
2449 }
2451 /* Test that arguments are correctly popped off the stack during unwinding */
2452 /* FIXME: Fails on x86 when llvm is enabled (#5432) */
2453 /*
2454 public static int test_0_stack_unwind () {
2455 addr = new IntPtr [1000];
2456 S s = new S ();
2457 for (int j = 0; j < 1000; j++) {
2458 try {
2459 throw_func (j, s);
2460 }
2461 catch (Exception) {
2462 }
2463 }
2464 return (addr [0].ToInt64 () - addr [100].ToInt64 () < 100) ? 0 : 1;
2465 }
2466 */
2470 }
2472 /* Test that the arguments to the throw trampoline are correctly popped off the stack */
2480 }
2482 }
2483 }
2485 }
2493 }
2495 }
2497 }
2505 }
2507 }
2511 }
2519 }
2522 }
2526 }
2531 }
2536 }
2539 }
2540 }
2544 }
2548 }
2554 }
2557 }
2560 }
2562 // bug #78633
2572 i ++;
2573 }
2575 }
2578 }
2580 // bug #485721
2587 }
2593 }
2595 }
2596 }
2600 }
2602 }
2603 }
2604 }
2607 }
2615 }
2616 }
2618 // for llvm, the end bblock is unreachable
2622 else
2624 }
2628 }
2630 // bug #539550
2633 // The invoke calls a runtime-invoke wrapper which has a filter clause
2634 #if __MOBILE__
2636 #else
2638 #endif
2640 }
2642 }
2647 }
2650 }
2651 }
2656 }
2661 }
2663 }
2664 }
2668 }
2672 }
2674 // #559876
2684 }
2686 }
2695 }
2700 }
2703 }
2705 class Child
2706 {
2708 {
2710 }
2711 }
2713 /* #612206 */
2719 }
2722 }
2726 }
2729 }
2738 }
2741 }
2743 unsafe struct Foo
2744 {
2748 }
2750 /* MS.NET doesn't seem to throw in this case */
2755 }
2758 // Fill up registers with values
2781 }
2783 }
2787 ;
2789 }
2798 /* Make sure this doesn't branch to the finally */
2802 /* Make sure o is register allocated */
2805 else
2809 else
2813 else
2816 }
2817 }
2818 }
2824 }
2830 }
2837 }
2839 }
2849 }
2850 }
2851 }
2858 }
2860 }
2870 }
2876 }
2878 }
2886 }
2888 }
2896 }
2900 }
2906 }
2912 }
2913 }
2923 }
2925 }
2941 }
2944 }
2945 // "2ndcatch_innerFinally_init"
2946 // Console.WriteLine ("res1: " + res);
2953 }
2954 // Console.WriteLine ("res2: " + res);
2956 }
2958 public struct FooStruct
2959 {
2960 public long Part1 { get; }
2961 public long Part2 { get; }
2963 public byte Part3 { get; }
2964 }
2973 }
2975 }
2977 }
2990 }
2998 }
3013 }
3023 }
3032 }
3033 }
3035 #if !__MOBILE__
3037 {
3038 }
3039 #endif