Merge pull request #5714 from alexischr/update_bockbuild

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

diff --git a/mono/mini/gshared.cs b/mono/mini/gshared.cs
index a8bfee03414ab95fe515d69c2dce3f7b178af86a..75ea14aad6a91463ecc7f3ba0eb2769e97f7be1d 100644 (file)
--- a/mono/mini/gshared.cs
+++ b/mono/mini/gshared.cs
@@ -1026,7 +1026,7 @@ public class Tests
                return t.ToString ();
        }
 
-       enum AnEnum {
+       public enum AnEnum {
                One,
                Two
        };
@@ -1106,10 +1106,12 @@ public class Tests
 
        interface IConstrainedCalls {
                Pair<int, int> vtype_ret<T, T2>(T t, T2 t2) where T: IReturnVType;
+               AnEnum enum_ret<T, T2>(T t, T2 t2) where T: IReturnVType;
        }
 
        public interface IReturnVType {
                Pair<int, int> return_vtype ();
+               AnEnum return_enum ();
        }
 
        public class CConstrainedCalls : IConstrainedCalls {
@@ -1117,12 +1119,20 @@ public class Tests
                public Pair<int, int> vtype_ret<T, T2>(T t, T2 t2) where T : IReturnVType {
                        return t.return_vtype ();
                }
+
+               [MethodImplAttribute (MethodImplOptions.NoInlining)]
+               public AnEnum enum_ret<T, T2>(T t, T2 t2) where T : IReturnVType {
+                       return t.return_enum ();
+               }
        }
 
        class ReturnVType : IReturnVType {
                public Pair<int, int> return_vtype () {
                        return new Pair<int, int> () { First = 1, Second = 2 };
                }
+               public AnEnum return_enum () {
+                       return AnEnum.Two;
+               }
        }
 
        public static int test_0_constrained_vtype_ret () {
@@ -1133,6 +1143,14 @@ public class Tests
                return 0;
        }
 
+       public static int test_0_constrained_enum_ret () {
+               IConstrainedCalls c = new CConstrainedCalls ();
+               var r = c.enum_ret<ReturnVType, int> (new ReturnVType (), 1);
+               if (r != AnEnum.Two)
+                       return 1;
+               return 0;
+       }
+
        public struct Pair<T1, T2> {
                public T1 First;
                public T2 Second;
@@ -1659,6 +1677,8 @@ public class Tests
                                   uint i1, uint i2, uint i3, uint i4);
                int Structs (T t, int dummy1, int a2, int a3, int a4, int a5, int a6, int a7, int dummy8,
                                         BStruct s);
+               void Generic<T2> (T t, T2[] arr, int dummy1, int a2, int a3, int a4, int a5, int a6, int a7, int dummy8,
+                                                 T2 i1, T2 i2, T2 i3, T2 i4);
        }
 
        class Foo3<T> : IFoo3<T> {
@@ -1690,6 +1710,13 @@ public class Tests
                                                        BStruct s) {
                        return s.a + s.b + s.c + s.d;
                }
+
+               public void Generic<T2> (T t, T2[] arr, int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8, T2 i1, T2 i2, T2 i3, T2 i4) {
+                       arr [0] = i1;
+                       arr [1] = i2;
+                       arr [2] = i3;
+                       arr [3] = i4;
+               }
        }
 
        // Passing small normal arguments on the stack
@@ -1713,9 +1740,30 @@ public class Tests
                int res6 = o.UInts (new EmptyStruct (), 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4);
                if (res6 != 10)
                        return 6;
+               int[] arr = new int [4];
+               o.Generic<int> (new EmptyStruct (), arr, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4);
+               if (arr [0] != 1 || arr [1] != 2 || arr [2] != 3 || arr [3] != 4)
+                       return 7;
                return 0;
        }
 
+       interface ISmallArg {
+               T foo<T> (string s1, string s2, string s3, string s4, string s5, string s6, string s7, string s8,
+                                 string s9, string s10, string s11, string s12, string s13, T t);
+       }
+
+       class SmallArgClass : ISmallArg {
+                       public T foo<T> (string s1, string s2, string s3, string s4, string s5, string s6, string s7, string s8,
+                                                        string s9, string s10, string s11, string s12, string s13, T t) {
+                               return t;
+                       }
+               }
+
+       public static int test_1_small_gsharedvt_stack_arg_ios () {
+               ISmallArg o = new SmallArgClass ();
+               return o.foo<int> ("", "", "", "", "", "", "", "", "", "", "", "", "", 1);
+       }
+
        // Passing vtype normal arguments on the stack
        public static int test_0_arm64_vtype_stack_args () {
                IFoo3<EmptyStruct> o = (IFoo3<EmptyStruct>)Activator.CreateInstance (typeof (Foo3<>).MakeGenericType (new Type [] { typeof (EmptyStruct) }));
@@ -1775,6 +1823,19 @@ public class Tests
                }
        }
 
+       struct StructTest : IFaceTest {
+
+               int i;
+
+               public StructTest (int arg) {
+                       i = arg;
+               }
+
+               public int iface_method () {
+                       return i;
+               }
+       }
+
        // Test constrained calls on an interface made from gsharedvt methods
        public static int test_42_gsharedvt_constrained_iface () {
                IFaceConstrainedIFace obj = new ConstrainedIFace ();
@@ -1782,6 +1843,12 @@ public class Tests
                return obj.foo<IFaceTest, int> (ref t);
        }
 
+       public static int test_42_gsharedvt_constrained_iface_vtype () {
+               IFaceConstrainedIFace obj = new ConstrainedIFace ();
+               IFaceTest t = new StructTest (42);
+               return obj.foo<IFaceTest, int> (ref t);
+       }
+
        // Sign extension tests
        // 0x55   == 85    == 01010101
        // 0xAA   == 170   == 10101010
@@ -1890,6 +1957,66 @@ public class Tests
                bool success = zz == 0xAAAAAAAAAAAAAAAA;
                return success ? 20 : 1;
        }
+
+       void gsharedvt_try_at_offset_0<T> (ref T disposable)
+               where T : class, IDisposable {
+                       try {
+                               disposable.Dispose ();
+                       } finally {
+                               disposable = null;
+                       }
+               }
+
+       [MethodImplAttribute (MethodImplOptions.NoInlining)]
+       static DateTimeOffset gsharedvt_vphi_inner<T> (T t) {
+               return DateTimeOffset.MinValue;
+       }
+
+       static DateTimeOffset gsharedvt_vphi<T> (T t) {
+               int[] arr = new int [10];
+
+               try {
+                       DateTimeOffset v;
+                       if (arr [0] == 0)
+                               v = gsharedvt_vphi_inner (t);
+                       else
+                               v = gsharedvt_vphi_inner (t);
+                       return v;
+               } catch {
+                       return DateTimeOffset.MinValue;
+               }
+       }
+
+       static int test_0_gsharedvt_vphi_volatile () {
+               gsharedvt_vphi (0);
+               return 0;
+       }
+
+       struct AStruct3<T1, T2, T3> {
+               T1 t1;
+               T2 t2;
+               T3 t3;
+       }
+
+       interface IFaceIsRef {
+               bool is_ref<T> ();
+       }
+
+       class ClassIsRef : IFaceIsRef {
+               [MethodImplAttribute (MethodImplOptions.NoInlining)]
+               public bool is_ref<T> () {
+                       return RuntimeHelpers.IsReferenceOrContainsReferences<T> ();
+               }
+       }
+
+       public static int test_0_isreference_intrins () {
+               IFaceIsRef iface = new ClassIsRef ();
+               if (iface.is_ref<AStruct3<int, int, int>> ())
+                       return 1;
+               if (!iface.is_ref<AStruct3<string, int, int>> ())
+                       return 2;
+               return 0;
+       }
 }
 
 // #13191