Merge pull request #2333 from joelmartinez/docs-classic-fix

[mono.git] / mono / mini / exceptions.cs

diff --git a/mono/mini/exceptions.cs b/mono/mini/exceptions.cs
index 49dca8d1ba12e720ceb0b07cf3fd67595e88c161..e84abc68b019d0994e72115d53373ee2097a8f99 100644 (file)
--- a/mono/mini/exceptions.cs
+++ b/mono/mini/exceptions.cs
@@ -24,11 +24,18 @@ using System.Runtime.CompilerServices;
  * the IL code looks.
  */
 
-class Tests {
-
+#if __MOBILE__
+class ExceptionTests
+#else
+class Tests
+#endif
+{
+
+#if !__MOBILE__
        public static int Main (string[] args) {
                return TestDriver.RunTests (typeof (Tests), args);
        }
+#endif
 
        public static int test_0_catch () {
                Exception x = new Exception ();
@@ -1509,6 +1516,71 @@ class Tests {
                return 0;
        }
 
+       [MethodImplAttribute (MethodImplOptions.NoInlining)]
+       static void dummy () {
+       }
+
+       [MethodImplAttribute (MethodImplOptions.NoInlining)]
+       static int div_zero_llvm_inner (int i) {
+               try {
+                       // This call make use avoid the 'handler without invoke' restriction in the llvm backend
+                       dummy ();
+                       return 5 / i;
+               } catch (Exception ex) {
+                       return 0;
+               }
+       }
+
+       [MethodImplAttribute (MethodImplOptions.NoInlining)]
+       static long div_zero_llvm_inner_long (long l) {
+               try {
+                       dummy ();
+                       return (long)5 / l;
+               } catch (Exception ex) {
+                       return 0;
+               }
+       }
+
+       public static int test_0_div_zero_llvm () {
+           long r = div_zero_llvm_inner (0);
+               if (r != 0)
+                       return 1;
+           r = div_zero_llvm_inner_long (0);
+               if (r != 0)
+                       return 2;
+               return 0;
+       }
+
+       [MethodImplAttribute (MethodImplOptions.NoInlining)]
+       static int div_overflow_llvm_inner (int i) {
+               try {
+                       dummy ();
+                       return Int32.MinValue / i;
+               } catch (Exception ex) {
+                       return 0;
+               }
+       }
+
+       [MethodImplAttribute (MethodImplOptions.NoInlining)]
+       static long div_overflow_llvm_inner_long (long l) {
+               try {
+                       dummy ();
+                       return Int64.MinValue / l;
+               } catch (Exception ex) {
+                       return 0;
+               }
+       }
+
+       public static int test_0_div_overflow_llvm () {
+               long r = div_overflow_llvm_inner (-1);
+               if (r != 0)
+                       return 1;
+               r = div_overflow_llvm_inner_long ((long)-1);
+               if (r != 0)
+                       return 2;
+               return 0;
+       }
+
        public static int return_55 () {
                return 55;
        }
@@ -2234,24 +2306,23 @@ class Tests {
                return 2;
        }
 
-       /* MarshalByRefObject prevents the methods from being inlined */
-       class ThrowClass : MarshalByRefObject {
-               public static void rethrow1 () {
-                       throw new Exception ();
-               }
+       [MethodImplAttribute (MethodImplOptions.NoInlining)]
+       public static void rethrow1 () {
+               throw new Exception ();
+       }
 
-               public static void rethrow2 () {
-                       rethrow1 ();
-                       /* This disables tailcall opts */
-                       Console.WriteLine ();
-               }
+       [MethodImplAttribute (MethodImplOptions.NoInlining)]
+       public static void rethrow2 () {
+               rethrow1 ();
+               /* This disables tailcall opts */
+               Console.WriteLine ();
        }
 
        public static int test_0_rethrow_stacktrace () {
                // Check that rethrowing an exception preserves the original stack trace
                try {
                        try {
-                               ThrowClass.rethrow2 ();
+                               rethrow2 ();
                        }
                        catch (Exception ex) {
                                // Check that each catch clause has its own exception variable
@@ -2311,16 +2382,6 @@ class Tests {
        public static int test_0_array_size () {
                bool failed;
 
-               try {
-                       failed = true;
-                       int[] mem1 = new int [Int32.MaxValue];
-               }
-               catch (OutOfMemoryException e) {
-                       failed = false;
-               }
-               if (failed)
-                       return 1;
-
                try {
                        failed = true;
                        int[,] mem2 = new int [Int32.MaxValue, Int32.MaxValue];
@@ -2408,7 +2469,7 @@ class Tests {
        }
 
        public static int test_0_nonvirt_nullref_at_clause_start () {
-               Tests t = null;
+               ExceptionTests t = null;
                try {
                        t.amethod ();
                } catch (NullReferenceException) {
@@ -2528,7 +2589,11 @@ class Tests {
        public static int test_0_lmf_filter () {
                try {
                        // The invoke calls a runtime-invoke wrapper which has a filter clause
+#if __MOBILE__
+                       typeof (ExceptionTests).GetMethod ("lmf_filter").Invoke (null, new object [] { });
+#else
                        typeof (Tests).GetMethod ("lmf_filter").Invoke (null, new object [] { });
+#endif
                } catch (TargetInvocationException) {
                }
                return 0;
@@ -2730,5 +2795,59 @@ class Tests {
                }
                return 1;
        }
+
+       static bool finally_called = false;
+
+       static void regress_30472 (int a, int b) {
+                       checked {
+                               try {
+                                       int sum = a + b;
+                               } finally {
+                                       finally_called = true;
+                               }
+            }
+               }
+
+       public static int test_0_regress_30472 () {
+               finally_called = false;
+               try {
+                   regress_30472 (Int32.MaxValue - 1, 2);
+               } catch (Exception ex) {
+               }
+               return finally_called ? 0 : 1;
+       }
+
+       static int array_len_1 = 1;
+
+       public static int test_0_bounds_check_negative_constant () {
+               try {
+                       byte[] arr = new byte [array_len_1];
+                       byte b = arr [-1];
+                       return 1;
+               } catch {
+               }
+               try {
+                       byte[] arr = new byte [array_len_1];
+                       arr [-1] = 1;
+                       return 2;
+               } catch {
+               }
+               return 0;
+       }
+
+       public static int test_0_string_bounds_check_negative_constant () {
+               try {
+                       string s = "A";
+                       char c = s [-1];
+                       return 1;
+               } catch {
+               }
+               return 0;
+       }
 }
 
+#if !__MOBILE__
+class ExceptionTests : Tests
+{
+}
+#endif