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 () {
return 1;
}
+ struct AStruct2 {
+ public int i;
+ public int j;
+ }
+
+ static float pass_vtype_return_float (AStruct2 s) {
+ return s.i + s.j == 6 ? 1.0f : -1.0f;
+ }
+
+ public static int test_0_vtype_arg_soft_float () {
+ return pass_vtype_return_float (new AStruct2 () { i = 2, j = 4 }) > 0.0 ? 0 : 1;
+ }
+
static int range_check_strlen (int i, string s) {
if (i < 0 || i > s.Length)
return 1;
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;
+ }
+
+ public static bool flag;
+
+ class B {
+
+ internal static B[] d;
+
+ static B () {
+ flag = true;
+ }
+ }
+
+ [MethodImplAttribute (MethodImplOptions.NoInlining)]
+ static int regress_679467_inner () {
+ if (flag == true)
+ return 1;
+ var o = B.d;
+ var o2 = B.d;
+ return 0;
+ }
+
+ /*
+ * FIXME: This fails with AOT #703317.
+ */
+ /*
+ static int test_0_multiple_cctor_calls_regress_679467 () {
+ flag = false;
+ return regress_679467_inner ();
+ }
+ */
+
+ static int test_0_char_ctor () {
+ string s = new String (new char[] { 'A', 'B' }, 0, 1);
+ return 0;
+ }
+
+ static object mInstance = null;
+
+ [MethodImpl(MethodImplOptions.Synchronized)]
+ public static object getInstance() {
+ if (mInstance == null)
+ mInstance = new object();
+ return mInstance;
+ }
+
+ static int test_0_synchronized () {
+ getInstance ();
+ return 0;
+ }
}