Avoid computing GC maps if precise stack marking is disabled.

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

diff --git a/mono/mini/objects.cs b/mono/mini/objects.cs
index 71317d5d823c7dcffbe072437ca9b38e249c09cd..1454af75c4c9af6e1d849df3631415dfcd455db9 100644 (file)
--- a/mono/mini/objects.cs
+++ b/mono/mini/objects.cs
@@ -100,6 +100,18 @@ enum SampleEnum {
        C
 }
 
+struct Alpha {
+       public long a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v;
+}
+
+struct Beta {
+       public Alpha a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v;
+}
+
+struct Gamma {
+       public Beta a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v;
+}
+
 class Tests {
 
        static int Main () {
@@ -1367,7 +1379,7 @@ ncells ) {
 
        //repro for #506915
        struct Bug506915 { public int val; }
-       static int test_2_ldobj_stobj_optization (string[] args)
+       static int test_2_ldobj_stobj_optization ()
        {
                int i = 99;
                var a = new Bug506915 ();
@@ -1380,5 +1392,100 @@ ncells ) {
                
                return array [1].val;
        }
+
+       /* mcs can't compile this (#646744) */
+#if FALSE
+       static void InitMe (out Gamma noMercyWithTheStack) {
+               noMercyWithTheStack = new Gamma ();
+       }
+
+       static int FunNoInline () {
+               int x = 99;
+               if (x > 344 && x < 22)
+                       return 333;
+               return x;
+       }
+
+       static float DoNothingButDontInline (float a, int b) {
+               if (b > 0)
+                       return a;
+               else if (b < 0 && b > 10)
+                       return 444.0f;
+               return a;
+       }
+
+       /*
+        * The local register allocator emits loadr8_membase and storer8_membase
+        * to do spilling. This code is generated after mono_arch_lowering_pass so
+        * mono_arch_output_basic_block must know how to deal with big offsets.
+        * This only happens because the call in middle forces the temp for "(float)obj"
+        * to be spilled.
+       */
+       public static int test_0_float_load_and_store_with_big_offset ()
+       {
+               object obj = 1.0f;
+               Gamma noMercyWithTheStack;
+               float res;
+
+               InitMe (out noMercyWithTheStack);
+
+               res = DoNothingButDontInline ((float)obj, FunNoInline ());
+
+               if (!(res == 1.0f))
+                       return 1;
+               return 0;
+       }
+#endif
+
+       struct VTypePhi {
+               public int i;
+       }
+
+       static int vtype_phi (VTypePhi v1, VTypePhi v2, bool first) {
+               VTypePhi v = first ? v1 : v2;
+
+               return v.i;
+       }
+
+       static int test_0_vtype_phi ()
+       {
+               VTypePhi v1 = new VTypePhi () { i = 1 };
+               VTypePhi v2 = new VTypePhi () { i = 2 };
+
+               if (vtype_phi (v1, v2, true) != 1)
+                       return 1;
+               if (vtype_phi (v1, v2, false) != 2)
+                       return 2;
+
+               return 0;
+       }
+
+       [MethodImplAttribute (MethodImplOptions.NoInlining)]
+       static void UseValue (int index)
+       {
+       }
+
+       [MethodImplAttribute (MethodImplOptions.NoInlining)]
+       static bool IsFalse ()
+       {
+               return false;
+       }
+
+       static int test_0_llvm_moving_faulting_loads ()
+       {
+               int[] indexes = null;
+
+               if (IsFalse ()) {
+                       indexes = new int[0];
+               }
+                       
+               while (IsFalse ()) {
+                       UseValue (indexes[0]);
+                       UseValue (indexes[0]);
+               }
+
+               return 0;
+       }
+
 }