X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fmini%2Fbasic-calls.cs;h=5ad874b3dfaf90d4ab35b0f176b809ef6b29b5c2;hb=ce992c6c6fd36ae236298c819e324bab81129642;hp=db7354e6607f7b9503eff06b5931c081a98c629e;hpb=a47b3bb8df83a9f4ff2e49289832d5bec2a1acef;p=mono.git

diff --git a/mono/mini/basic-calls.cs b/mono/mini/basic-calls.cs
index db7354e6607..5ad874b3dfa 100644
--- a/mono/mini/basic-calls.cs
+++ b/mono/mini/basic-calls.cs
@@ -6,7 +6,7 @@ using System.Reflection;
  *
  * Each test needs to be of the form:
  *
- * static int test_<result>_<name> ();
+ * public static int test_<result>_<name> ();
  *
  * where <result> is an integer (the value that needs to be returned by
  * the method to make it pass.
@@ -32,7 +32,7 @@ class Tests {
 	static void dummy () {
 	}
 
-	static int test_0_return () {
+	public static int test_0_return () {
 		dummy ();
 		return 0;
 	}
@@ -41,7 +41,7 @@ class Tests {
 		return 1;
 	}
 
-	static int test_2_int_return () {
+	public static int test_2_int_return () {
 		int r = dummy1 ();
 		if (r == 1)
 			return 2;
@@ -52,7 +52,7 @@ class Tests {
 		return val + 1;
 	}
 
-	static int test_1_int_pass () {
+	public static int test_1_int_pass () {
 		int r = add1 (5);
 		if (r == 6)
 			return 1;
@@ -63,7 +63,7 @@ class Tests {
 		return val + t + b + da;
 	}
 
-	static int test_1_int_pass_many () {
+	public static int test_1_int_pass_many () {
 		byte b = 6;
 		int r = add_many (5, 2, b, 1);
 		if (r == 14)
@@ -81,7 +81,7 @@ class Tests {
 		}
 
 	/* bug #42134 */
-	static int test_2_inline_saved_arg_type () {
+	public static int test_2_inline_saved_arg_type () {
 		float f = 100.0f;
 		return GetFloat (f) == f? 2: 1;
 	}
@@ -90,7 +90,7 @@ class Tests {
 		return a + (int)b + c + (int)d;
 	}
 
-	static int test_5_pass_longs () {
+	public static int test_5_pass_longs () {
 		return pass_many_types (1, 2, -5, 7);
 	}
 
@@ -98,7 +98,7 @@ class Tests {
 		return a+b+c+d+e+f+g+h+i+j;
 	}
 
-	static int test_55_pass_even_more () {
+	public static int test_55_pass_even_more () {
 		return overflow_registers (1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
 	}
 
@@ -106,7 +106,7 @@ class Tests {
 		return (int)(a + b + c + d + e + f + g);
 	}
 
-	static int test_1_sparc_argument_passing () {
+	public static int test_1_sparc_argument_passing () {
 		// The 4. argument tests split reg/mem argument passing
 		// The 5. argument tests mem argument passing
 		// The 7. argument tests passing longs in misaligned memory
@@ -118,7 +118,7 @@ class Tests {
 		return (int)(a + b + c + d + e + f + g);
 	}
 
-	static int test_21_sparc_byte_argument_passing () {
+	public static int test_21_sparc_byte_argument_passing () {
 		return pass_bytes (0, 1, 2, 3, 4, 5, 6);
 	}
 
@@ -126,7 +126,7 @@ class Tests {
 		return (int)(a + b + c + d + e + f + g);
 	}
 
-	static int test_21_sparc_sbyte_argument_passing () {
+	public static int test_21_sparc_sbyte_argument_passing () {
 		return pass_sbytes (0, 1, 2, 3, 4, 5, 6);
 	}
 
@@ -134,7 +134,7 @@ class Tests {
 		return (int)(a + b + c + d + e + f + g);
 	}
 
-	static int test_21_sparc_short_argument_passing () {
+	public static int test_21_sparc_short_argument_passing () {
 		return pass_shorts (0, 1, 2, 3, 4, 5, 6);
 	}
 
@@ -142,24 +142,67 @@ class Tests {
 		return (int)(a + b + c + d + e + f + g);
 	}
 
-	static int test_721_sparc_float_argument_passing () {
+	public static int test_721_sparc_float_argument_passing () {
 		return pass_floats_doubles (100.0f, 101.0, 102.0, 103.0, 104.0, 105.0f, 106.0);
 	}
 
-	static int pass_byref_ints_longs (ref int a, ref long b, ref byte c, ref short d, ref long e, ref int f, ref long g) {
+	static float pass_floats (float a, float b, float c, float d, float e, float f, float g, float h, float i, float j) {
+		return a + b + c + d + e + f + g + h + i + j;
+	}
+
+	public static int test_55_sparc_float_argument_passing2 () {
+		return (int)pass_floats (1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f);
+	}
+
+	public static bool is_small (float value) {
+		double d = (double)value;
+		double d2 = 7.183757E-41;
+		return d - d2 < 0.000001;
+	}
+		
+	public static int test_0_float_argument_passing_precision () {
+		float f = 7.183757E-41f;
+		return is_small (f) ? 0 : 1;
+	}
+
+	// The first argument must be passed on a dword aligned stack location
+	static int pass_byref_ints_longs (ref long a, ref int b, ref byte c, ref short d, ref long e, ref int f, ref long g) {
 		return (int)(a + b + c + d + e + f + g);
 	}
 
-	static int pass_takeaddr_ints_longs (int a, long b, byte c, short d, long e, int f, long g) {
+	static int pass_takeaddr_ints_longs (long a, int b, byte c, short d, long e, int f, long g) {
 		return pass_byref_ints_longs (ref a, ref b, ref c, ref d, ref e, ref f, ref g);
 	}
 
 	// Test that arguments are moved to the stack from incoming registers
 	// when the argument must reside in the stack because its address is taken
-	static int test_2_sparc_takeaddr_argument_passing () {
+	public static int test_2_sparc_takeaddr_argument_passing () {
 		return pass_takeaddr_ints_longs (1, 2, 253, -253, System.Int64.MaxValue, 0, System.Int64.MinValue);
 	}
 
+	static int pass_byref_floats_doubles (ref float a, ref double b, ref double c, ref double d, ref double e, ref float f, ref double g) {
+		return (int)(a + b + c + d + e + f + g);
+	}
+
+	static int pass_takeaddr_floats_doubles (float a, double b, double c, double d, double e, float f, double g) {
+		return pass_byref_floats_doubles (ref a, ref b, ref c, ref d, ref e, ref f, ref g);
+	}
+
+	public static int test_721_sparc_takeaddr_argument_passing2 () {
+		return pass_takeaddr_floats_doubles (100.0f, 101.0, 102.0, 103.0, 104.0, 105.0f, 106.0);
+	}
+
+	static void pass_byref_double (out double d) {
+		d = 5.0;
+	}
+
+	// Test byref double argument passing
+	public static int test_0_sparc_byref_double_argument_passing () {
+		double d;
+		pass_byref_double (out d);
+		return (d == 5.0) ? 0 : 1;
+	}
+
 	static void shift_un_arg (ulong value) {
 		do {
 			value = value >> 4;
@@ -167,7 +210,7 @@ class Tests {
 	}
 
 	// Test that assignment to long arguments work
-	static int test_0_long_arg_assign ()
+	public static int test_0_long_arg_assign ()
 	{
 		ulong c = 0x800000ff00000000;
 			
@@ -181,7 +224,7 @@ class Tests {
 		return ptr;
 	}
 
-	static unsafe int test_0_ptr_return ()
+	public static unsafe int test_0_ptr_return ()
 	{
 		void *ptr = new IntPtr (55).ToPointer ();
 
@@ -195,9 +238,77 @@ class Tests {
 		return (f != f);
 	}
 
-	static int test_0_isnan () {
+	public static int test_0_isnan () {
 		float f = 1.0f;
 		return isnan (f) ? 1 : 0;
 	}
+
+	static int first_is_zero (int v1, int v2) {
+		if (v1 != 0)
+			return -1;
+		return v2;
+	}
+	public static int test_1_handle_dup_stloc () {
+		int index = 0;
+		int val = first_is_zero (index, ++index);
+		if (val != 1)
+			return 2;
+		return 1;
+	}
+
+	static long return_5low () {
+		return 5;
+	}
+	
+	static long return_5high () {
+		return 0x500000000;
+	}
+
+	public static int test_3_long_ret () {
+		long val = return_5low ();
+		return (int) (val - 2);
+	}
+
+	public static int test_1_long_ret2 () {
+		long val = return_5high ();
+		if (val > 0xffffffff)
+			return 1;
+		return 0;
+	}
+
+	public static void use_long_arg (ulong l) {
+		for (int i = 0; i < 10; ++i)
+			l ++;
+	}
+
+	public static ulong return_long_arg (object o, ulong perm) {
+		use_long_arg (perm);
+
+        perm = 0x8000000000000FFF;
+
+		use_long_arg (perm);
+
+		return perm;
+	}
+
+    public static int test_0_sparc_long_ret_regress_541577 () {
+        ulong perm = 0x8000000000000FFF;
+
+        ulong work = return_long_arg (null, perm);
+
+		return work == perm ? 0 : 1;
+	}
+
+	static void doit (double value, out long m) {
+		m = (long) value;
+	}
+
+	public static int test_0_ftol_clobber () {
+		long m;
+		doit (1.3, out m);
+		if (m != 1)
+			return 2;
+		return 0;
+	}
 }