X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fmini%2Fexceptions.cs;h=cf7dc613c0461c90f077bdb19ef223bc06f4bb57;hb=e5e4c9e781c079092ea212a7301f9b47bf6f1e88;hp=815a20a2f2bca25bd7f71fbb3e3beb37a51944e1;hpb=948dbf8d4581ac17f5420cc4f7dc375e3c502576;p=mono.git

diff --git a/mono/mini/exceptions.cs b/mono/mini/exceptions.cs
index 815a20a2f2b..cf7dc613c04 100644
--- a/mono/mini/exceptions.cs
+++ b/mono/mini/exceptions.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Reflection;
+using System.Runtime.CompilerServices;
 
 /*
  * Regression tests for the mono JIT.
@@ -1104,6 +1105,18 @@ class Tests {
 		if (failed)
 			return 10;
 
+		try {
+			ulong ul = UInt64.MaxValue;
+			failed = true;
+			checked {
+				a = (int)ul;
+			}
+		}
+		catch (OverflowException) {
+			failed = false;
+		}
+		if (failed)
+			return 11;
 
 		{
 			int i; 
@@ -1809,241 +1822,326 @@ class Tests {
 		return 2;
 	}
 
-	public static int test_0_ovf () {
-		int ocount = 0;
+	public static int test_0_ovf1 () {
+		int exception = 0;
 		
 		checked {
-
-			ocount = 0;
 			try {
 				ulong a =  UInt64.MaxValue - 1;
 				ulong t = a++;
 			} catch {
-				ocount++;
+				exception = 1;
 			}
-			if (ocount != 0)
-				return 1;
+		}
+		return exception;
+	}
 
-			ocount = 0;
+	public static int test_1_ovf2 () {
+		int exception = 0;
+
+		checked {
 			try {
 				ulong a =  UInt64.MaxValue;
 				ulong t = a++;
 			} catch {
-				ocount++;
+				exception = 1;
 			}
-			if (ocount != 1)
-				return 2;
+		}
+		return exception;
+	}
 
-			ocount = 0;
+	public static int test_0_ovf3 () {
+		int exception = 0;
+
+		long a = Int64.MaxValue - 1;
+		checked {
 			try {
-				long a = Int64.MaxValue - 1;
 				long t = a++;
 			} catch {
-				ocount++;
+				exception = 1;
 			}
-			if (ocount != 0)
-				return 3;
+		}
+		return exception;
+	}
+
+	public static int test_1_ovf4 () {
+		int exception = 0;
 
+		long a = Int64.MaxValue;
+		checked {
 			try {
-				long a = Int64.MaxValue;
 				long t = a++;
 			} catch {
-				ocount++;
+				exception = 1;
 			}
-			if (ocount != 1)
-				return 4;
+		}
+		return exception;
+	}
+
+	public static int test_0_ovf5 () {
+		int exception = 0;
 
-			ocount = 0;
+		ulong a = UInt64.MaxValue - 1;
+		checked {
 			try {
-				ulong a = UInt64.MaxValue - 1;
 				ulong t = a++;
 			} catch {
-				ocount++;
+				exception = 1;
 			}
-			if (ocount != 0)
-				return 5;
+		}
+		return exception;
+	}
 
+	public static int test_1_ovf6 () {
+		int exception = 0;
+
+		ulong a = UInt64.MaxValue;
+		checked {
 			try {
-				ulong a = UInt64.MaxValue;
 				ulong t = a++;
 			} catch {
-				ocount++;
+				exception = 1;
 			}
-			if (ocount != 1)
-				return 6;
+		}
+		return exception;
+	}
+
+	public static int test_0_ovf7 () {
+		int exception = 0;
 
-			ocount = 0;
+		long a = Int64.MinValue + 1;
+		checked {
 			try {
-				long a = Int64.MinValue + 1;
 				long t = a--;
 			} catch {
-				ocount++;
+				exception = 1;
 			}
-			if (ocount != 0)
-				return 7;
+		}
+		return 0;
+	}
 
-			ocount = 0;
+	public static int test_1_ovf8 () {
+		int exception = 0;
+
+		long a = Int64.MinValue;
+		checked {
 			try {
-				long a = Int64.MinValue;
 				long t = a--;
 			} catch {
-				ocount++;
+				exception = 1;
 			}
-			if (ocount != 1)
-				return 8;
+		}
+		return exception;
+	}
+
+	public static int test_0_ovf9 () {
+		int exception = 0;
 
-			ocount = 0;
+		ulong a = UInt64.MinValue + 1;
+		checked {
 			try {
-				ulong a = UInt64.MinValue + 1;
 				ulong t = a--;
 			} catch {
-				ocount++;
+				exception = 1;
 			}
-			if (ocount != 0)
-				return 9;
+		}
+		return exception;
+	}
+
+	public static int test_1_ovf10 () {
+		int exception = 0;
 
-			ocount = 0;
+		ulong a = UInt64.MinValue;
+		checked {
 			try {
-				ulong a = UInt64.MinValue;
 				ulong t = a--;
 			} catch {
-				ocount++;
+				exception = 1;
 			}
-			if (ocount != 1)
-				return 10;
+		}
+		return exception;
+	}
 
-			ocount = 0;
+	public static int test_0_ovf11 () {
+		int exception = 0;
+
+		int a = Int32.MinValue + 1;
+		checked {
 			try {
-				int a = Int32.MinValue + 1;
 				int t = a--;
 			} catch {
-				ocount++;
+				exception = 1;
 			}
-			if (ocount != 0)
-				return 11;
+		}
+		return exception;
+	}
+
+	public static int test_1_ovf12 () {
+		int exception = 0;
 
-			ocount = 0;
+		int a = Int32.MinValue;
+		checked {
 			try {
-				int a = Int32.MinValue;
 				int t = a--;
 			} catch {
-				ocount++;
+				exception = 1;
 			}
-			if (ocount != 1)
-				return 12;
+		}
+		return exception;
+	}
+
+	public static int test_0_ovf13 () {
+		int exception = 0;
 
-			ocount = 0;
+		uint a = 1;
+		checked {
 			try {
-				uint a = 1;
 				uint t = a--;
 			} catch {
-				ocount++;
+				exception = 1;
 			}
-			if (ocount != 0)
-				return 13;
+		}
+		return exception;
+	}
 
-			ocount = 0;
+	public static int test_1_ovf14 () {
+		int exception = 0;
+
+		uint a = 0;
+		checked {
 			try {
-				uint a = 0;
 				uint t = a--;
 			} catch {
-				ocount++;
+				exception = 1;
 			}
-			if (ocount != 1)
-				return 14;
+		}
+		return exception;
+	}
 
-			ocount = 0;
+	public static int test_0_ovf15 () {
+		int exception = 0;
+
+		sbyte a = 126;
+		checked {
 			try {
-				sbyte a = 126;
 				sbyte t = a++;
 			} catch {
-				ocount++;
+				exception = 1;
 			}
-			if (ocount != 0)
-				return 15;
+		}
+		return exception;
+	}
+
+	public static int test_1_ovf16 () {
+		int exception = 0;
 
-			ocount = 0;
+		sbyte a = 127;
+		checked {
 			try {
-				sbyte a = 127;
 				sbyte t = a++;
 			} catch {
-				ocount++;
+				exception = 1;
 			}
-			if (ocount != 1)
-				return 16;
+		}
+		return exception;
+	}
+
+	public static int test_0_ovf17 () {
+		int exception = 0;
 
-			ocount = 0;
+		checked {
 			try {
 			} catch {
-				ocount++;
+				exception = 1;
 			}
-			if (ocount != 0)
-				return 17;
+		}
+		return exception;
+	}
 
-			ocount = 0;
+	public static int test_0_ovf18 () {
+		int exception = 0;
+
+		int a = 1 << 29;
+		checked {
 			try {
-				int a = 1 << 29;
 				int t = a*2;
 			} catch {
-				ocount++;
+				exception = 1;
 			}
-			if (ocount != 0)
-				return 18;
+		}
+		return exception;
+	}
+
+	public static int test_1_ovf19 () {
+		int exception = 0;
 
-			ocount = 0;
+		int a = 1 << 30;
+		checked {
 			try {
-				int a = 1 << 30;
 				int t = a*2;
 			} catch {
-				ocount++;
+				exception = 1;
 			}
-			if (ocount != 1)
-				return 19;
+		}
+		return exception;
+	}
+
+	public static int test_0_ovf20 () {
+		int exception = 0;
 
-			ocount = 0;
+		checked {
 			try {
 				ulong a = 0xffffffffff;
 				ulong t = a*0x0ffffff;
 			} catch {
-				ocount++;
+				exception = 1;
 			}
-			if (ocount != 0)
-				return 20;
+		}
+		return exception;
+	}
 
-			ocount = 0;
+	public static int test_1_ovf21 () {
+		int exception = 0;
+
+		ulong a = 0xffffffffff;
+		checked {
 			try {
-				ulong a = 0xffffffffff;
 				ulong t = a*0x0fffffff;
 			} catch {
-				ocount++;
+				exception = 1;
 			}
-			if (ocount != 1)
-				return 21;
+		}
+		return exception;
+	}
+
+	public static int test_1_ovf22 () {
+		int exception = 0;
 
-			ocount = 0;
+		long a = Int64.MinValue;
+		long b = 10;
+		checked {
 			try {
-				long a = Int64.MinValue;
-				long b = 10;
 				long v = a * b;
 			} catch {
-				ocount ++;
+				exception = 1;
 			}
-			if (ocount != 1)
-				return 22;
+		}
+		return exception;
+	}
 
-			ocount = 0;
+	public static int test_1_ovf23 () {
+		int exception = 0;
+
+		long a = 10;
+		long b = Int64.MinValue;
+		checked {
 			try {
-				long a = 10;
-				long b = Int64.MinValue;
 				long v = a * b;
 			} catch {
-				ocount ++;
+				exception = 1;
 			}
-			if (ocount != 1)
-				return 23;
 		}
-		
-		return 0;
+		return exception;
 	}
 
 	class Broken {
@@ -2110,6 +2208,30 @@ class Tests {
 		return i;
 	}
 
+	public static void rethrow () {
+		try {
+			throw new ApplicationException();
+		} catch (ApplicationException) {
+			try {
+				throw new OverflowException();
+			} catch (Exception) {
+				throw;
+			}
+		}
+	}
+
+	// Test that a rethrow rethrows the correct exception
+	public static int test_0_rethrow_nested () {
+		try {
+			rethrow ();
+		} catch (OverflowException) {
+			return 0;
+		} catch (Exception) {
+			return 1;
+		}
+		return 2;
+	}
+
 	/* MarshalByRefObject prevents the methods from being inlined */
 	class ThrowClass : MarshalByRefObject {
 		public static void rethrow1 () {
@@ -2254,5 +2376,197 @@ class Tests {
 		}
 		return 1;
 	}
+
+	public int amethod () {
+		return 1;
+	}
+
+	public static int test_0_nonvirt_nullref_at_clause_start () {
+		Tests t = null;
+		try {
+			t.amethod ();
+		} catch (NullReferenceException) {
+			return 0;
+		}
+
+		return 1;
+	}
+
+	public static int throw_only () {
+		throw new Exception ();
+	}
+
+	[MethodImpl(MethodImplOptions.NoInlining)] 
+	public static int throw_only2 () {
+		return throw_only ();
+	}
+
+	public static int test_0_inline_throw_only () {
+		try {
+			return throw_only2 ();
+		}
+		catch (Exception ex) {
+			return 0;
+		}
+	}
+
+	public static string GetText (string s) {
+		return s;
+	}
+
+	public static int throw_only_gettext () {
+		throw new Exception (GetText ("FOO"));
+	}
+
+	public static int test_0_inline_throw_only_gettext () {
+		object o = null;
+		try {
+			o = throw_only_gettext ();
+		}
+		catch (Exception ex) {
+			return 0;
+		}
+
+		return o != null ? 0 : 1;
+	}
+
+	// bug #78633
+	public static int test_0_throw_to_branch_opt_outer_clause () {
+		int i = 0;
+
+		try {
+			try {
+				string [] files = new string[1];
+
+				string s = files[2];
+			} finally {
+				i ++;
+			}
+		} catch {
+		}
+
+		return (i == 1) ? 0 : 1;
+	}		
+
+	// bug #485721
+	public static int test_0_try_inside_finally_cmov_opt () {
+		bool Reconect = false;
+
+		object o = new object ();
+
+		try {
+		}
+		catch (Exception ExCon) {
+			if (o != null)
+				Reconect = true;
+
+			try {
+			}
+			catch (Exception Last) {
+			}
+		}
+		finally {
+			if (Reconect == true) {
+				try {
+				}
+				catch (Exception ex) {
+				}
+			}
+		}
+
+		return 0;
+	}
+
+	public static int test_0_inline_throw () {
+		try {
+			inline_throw1 (5);
+			return 1;
+		} catch {
+			return 0;
+		}
+	}
+
+	// for llvm, the end bblock is unreachable
+	public static int inline_throw1 (int i) {
+		if (i == 0)
+			throw new Exception ();
+		else
+			return inline_throw2 (i);
+	}
+
+	public static int inline_throw2 (int i) {
+		throw new Exception ();
+	}
+
+	// bug #539550
+	public static int test_0_lmf_filter () {
+		try {
+			// The invoke calls a runtime-invoke wrapper which has a filter clause
+			typeof (Tests).GetMethod ("lmf_filter").Invoke (null, new object [] { });
+		} catch (TargetInvocationException) {
+		}
+		return 0;
+	}
+
+    public static void lmf_filter () {
+        try {
+            Connect ();
+        }
+        catch {
+            throw new NotImplementedException ();
+        }
+    }
+
+    public static void Connect () {
+        Stop ();
+        throw new Exception();
+    }
+
+    public static void Stop () {
+        try {
+            lock (null) {}
+        }
+        catch {
+        }
+    }
+
+	private static void do_raise () {
+		throw new System.Exception ();
+	}
+
+	private static int int_func (int i) {
+		return i;
+	}
+
+	// #559876
+	public static int test_8_local_deadce_causes () {
+      int myb = 4;
+  
+      try {
+        myb = int_func (8);
+        do_raise();
+        myb = int_func (2);
+      } catch (System.Exception) {
+		  return myb;
+	  }
+	  return 0;
+	}
+
+	public static int test_0_except_opt_two_clauses () {
+		int size;
+		size = -1;
+		uint ui = (uint)size;
+		try {
+			checked {
+				uint v = ui * (uint)4;
+			}
+		} catch (OverflowException e) {
+			return 0;
+		} catch (Exception) {
+			return 1;
+		}
+
+		return 2;
+	}
 }