mono/mini/objects.cs

   1 using System;
   2 using System.Text;
   3 using System.Reflection;
   4 using System.Collections.Generic;
   5 using System.Runtime.InteropServices;
   6 using System.Runtime.CompilerServices;
   7
   8 /*
   9  * Regression tests for the mono JIT.
  10  *
  11  * Each test needs to be of the form:
  12  *
  13  * static int test_<result>_<name> ();
  14  *
  15  * where <result> is an integer (the value that needs to be returned by
  16  * the method to make it pass.
  17  * <name> is a user-displayed name used to identify the test.
  18  *
  19  * The tests can be driven in two ways:
  20  * *) running the program directly: Main() uses reflection to find and invoke
  21  *      the test methods (this is useful mostly to check that the tests are correct)
  22  * *) with the --regression switch of the jit (this is the preferred way since
  23  *      all the tests will be run with optimizations on and off)
  24  *
  25  * The reflection logic could be moved to a .dll since we need at least another
  26  * regression test file written in IL code to have better control on how
  27  * the IL code looks.
  28  */
  29
  30 #if __MOBILE__
  31 namespace ObjectTests
  32 {
  33 #endif
  34
  35 struct Simple {
  36         public int a;
  37         public byte b;
  38         public short c;
  39         public long d;
  40 }
  41
  42 struct Small {
  43         public byte b1;
  44         public byte b2;
  45 }
  46
  47 // Size=2, Align=1
  48 struct Foo {
  49         bool b1;
  50         bool b2;
  51 }
  52
  53 struct Large {
  54         int one;
  55         int two;
  56         long three;
  57         long four;
  58         int five;
  59         long six;
  60         int seven;
  61         long eight;
  62         long nine;
  63         long ten;
  64
  65         public void populate ()
  66         {
  67                 one = 1; two = 2;
  68                 three = 3; four = 4;
  69                 five = 5; six = 6;
  70                 seven = 7; eight = 8;
  71                 nine = 9; ten = 10;
  72         }
  73         public bool check ()
  74         {
  75                 return one == 1  && two == 2  &&
  76                         three == 3  && four == 4  &&
  77                         five == 5  && six == 6  &&
  78                         seven == 7  && eight == 8  &&
  79                         nine == 9  && ten == 10;
  80         }
  81 }
  82
  83 class Sample {
  84         public int a;
  85         public Sample (int v) {
  86                 a = v;
  87         }
  88 }
  89
  90 [StructLayout ( LayoutKind.Explicit )]
  91 struct StructWithBigOffsets {
  92                 [ FieldOffset(10000) ] public byte b;
  93                 [ FieldOffset(10001) ] public sbyte sb;
  94                 [ FieldOffset(11000) ] public short s;
  95                 [ FieldOffset(11002) ] public ushort us;
  96                 [ FieldOffset(12000) ] public uint i;
  97                 [ FieldOffset(12004) ] public int si;
  98                 [ FieldOffset(13000) ] public long l;
  99                 [ FieldOffset(14000) ] public float f;
 100                 [ FieldOffset(15000) ] public double d;
 101 }
 102
 103 enum SampleEnum {
 104         A,
 105         B,
 106         C
 107 }
 108
 109 struct Alpha {
 110         public long a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v;
 111 }
 112
 113 struct Beta {
 114         public Alpha a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v;
 115 }
 116
 117 struct Gamma {
 118         public Beta a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v;
 119 }
 120
 121 class Tests {
 122
 123 #if !__MOBILE__
 124         public static int Main (string[] args) {
 125                 return TestDriver.RunTests (typeof (Tests), args);
 126         }
 127 #endif
 128
 129         public static int test_0_return () {
 130                 Simple s;
 131                 s.a = 1;
 132                 s.b = 2;
 133                 s.c = (short)(s.a + s.b);
 134                 s.d = 4;
 135                 return s.a - 1;
 136         }
 137
 138         public static int test_0_string_access () {
 139                 string s = "Hello";
 140                 if (s [1] != 'e')
 141                         return 1;
 142                 return 0;
 143         }
 144
 145         public static int test_0_string_virtual_call () {
 146                 string s = "Hello";
 147                 string s2 = s.ToString ();
 148                 if (s2 [1] != 'e')
 149                         return 1;
 150                 return 0;
 151         }
 152
 153         public static int test_0_iface_call () {
 154                 string s = "Hello";
 155                 object o = ((ICloneable)s).Clone ();
 156                 return 0;
 157         }
 158
 159         public static int test_5_newobj () {
 160                 Sample s = new Sample (5);
 161                 return s.a;
 162         }
 163
 164         public static int test_4_box () {
 165                 object obj = 4;
 166                 return (int)obj;
 167         }
 168
 169         public static int test_0_enum_unbox () {
 170                 SampleEnum x = SampleEnum.A;
 171                 object o = x;
 172
 173                 int res = 1;
 174
 175                 res = (int)o;
 176
 177                 return res;
 178         }
 179
 180         static Simple get_simple (int v) {
 181                 Simple r = new Simple ();
 182                 r.a = v;
 183                 r.b = (byte)(v + 1);
 184                 r.c = (short)(v + 2);
 185                 r.d = v + 3;
 186
 187                 return r;
 188         }
 189
 190         public static int test_3_return_struct () {
 191                 Simple v = get_simple (1);
 192
 193                 if (v.a != 1)
 194                         return 0;
 195                 if (v.b != 2)
 196                         return 0;
 197                 if (v.c != 3)
 198                         return 0;
 199                 if (v.d != 4)
 200                         return 0;
 201                 return 3;
 202         }
 203
 204         public virtual Simple v_get_simple (int v)
 205         {
 206                 return get_simple (v);
 207         }
 208
 209         public static int test_2_return_struct_virtual () {
 210                 Tests t = new Tests ();
 211                 Simple v = t.v_get_simple (2);
 212
 213                 if (v.a != 2)
 214                         return 0;
 215                 if (v.b != 3)
 216                         return 0;
 217                 if (v.c != 4)
 218                         return 0;
 219                 if (v.d != 5)
 220                         return 0;
 221                 return 2;
 222         }
 223
 224         static int receive_simple (int a, Simple v, int b) {
 225                 if (v.a != 1)
 226                         return 1;
 227                 if (v.b != 2)
 228                         return 2;
 229                 if (v.c != 3)
 230                         return 3;
 231                 if (v.d != 4)
 232                         return 4;
 233                 if (a != 7)
 234                         return 5;
 235                 if (b != 9)
 236                         return 6;
 237                 return 0;
 238         }
 239
 240         public static int test_5_pass_struct () {
 241                 Simple v = get_simple (1);
 242                 if (receive_simple (7, v, 9) != 0)
 243                         return 0;
 244                 if (receive_simple (7, get_simple (1), 9) != 0)
 245                         return 1;
 246                 return 5;
 247         }
 248
 249         static Simple s_v;
 250         public static int test_5_pass_static_struct () {
 251                 s_v = get_simple (1);
 252                 if (receive_simple (7, s_v, 9) != 0)
 253                         return 0;
 254                 return 5;
 255         }
 256
 257         // Test alignment of small structs
 258
 259         static Small get_small (byte v) {
 260                 Small r = new Small ();
 261
 262                 r.b1 = v;
 263                 r.b2 = (byte)(v + 1);
 264
 265                 return r;
 266         }
 267
 268         static Small return_small (Small s) {
 269                 return s;
 270         }
 271
 272         static int receive_small (int a, Small v, int b) {
 273                 if (v.b1 != 1)
 274                         return 1;
 275                 if (v.b2 != 2)
 276                         return 2;
 277                 return 0;
 278         }
 279
 280         static int receive_small_sparc_many_args (int a, int a2, int a3, int a4, int a5, int a6, Small v, int b) {
 281                 if (v.b1 != 1)
 282                         return 1;
 283                 if (v.b2 != 2)
 284                         return 2;
 285                 return 0;
 286         }
 287
 288         public static int test_5_pass_small_struct () {
 289                 Small v = get_small (1);
 290                 if (receive_small (7, v, 9) != 0)
 291                         return 0;
 292                 if (receive_small (7, get_small (1), 9) != 0)
 293                         return 1;
 294                 if (receive_small_sparc_many_args (1, 2, 3, 4, 5, 6, v, 9) != 0)
 295                         return 2;
 296                 v = return_small (v);
 297                 if (v.b1 != 1)
 298                         return 3;
 299                 if (v.b2 != 2)
 300                         return 4;
 301                 return 5;
 302         }
 303
 304         // 64-bits, 32-bit aligned
 305         struct struct1 {
 306                 public int      a;
 307                 public int      b;
 308         };
 309
 310         static int check_struct1(struct1 x) {
 311                 if (x.a != 1)
 312                         return 1;
 313                 if (x.b != 2)
 314                         return 2;
 315                 return 0;
 316         }
 317
 318         static int pass_struct1(int a, int b, struct1 x) {
 319                 if (a != 3)
 320                         return 3;
 321                 if (b != 4)
 322                         return 4;
 323                 return check_struct1(x);
 324         }
 325
 326         static int pass_struct1(int a, struct1 x) {
 327                 if (a != 3)
 328                         return 3;
 329                 return check_struct1(x);
 330         }
 331
 332         static int pass_struct1(struct1 x) {
 333                 return check_struct1(x);
 334         }
 335
 336         public static int test_0_struct1_args () {
 337                 int r;
 338                 struct1 x;
 339
 340                 x.a = 1;
 341                 x.b = 2;
 342                 if ((r = check_struct1(x)) != 0)
 343                         return r;
 344                 if ((r = pass_struct1(x)) != 0)
 345                         return r + 10;
 346                 if ((r = pass_struct1(3, x)) != 0)
 347                         return r + 20;
 348                 if ((r = pass_struct1(3, 4, x)) != 0)
 349                         return r + 30;
 350                 return 0;
 351         }
 352
 353         // 64-bits, 64-bit aligned
 354         struct struct2 {
 355                 public long     a;
 356         };
 357
 358         static int check_struct2(struct2 x) {
 359                 if (x.a != 1)
 360                         return 1;
 361                 return 0;
 362         }
 363
 364         static int pass_struct2(int a, int b, int c, struct2 x) {
 365                 if (a != 3)
 366                         return 3;
 367                 if (b != 4)
 368                         return 4;
 369                 if (c != 5)
 370                         return 5;
 371                 return check_struct2(x);
 372         }
 373
 374         static int pass_struct2(int a, int b, struct2 x) {
 375                 if (a != 3)
 376                         return 3;
 377                 if (b != 4)
 378                         return 4;
 379                 return check_struct2(x);
 380         }
 381
 382         static int pass_struct2(int a, struct2 x) {
 383                 if (a != 3)
 384                         return 3;
 385                 return check_struct2(x);
 386         }
 387
 388         static int pass_struct2(struct2 x) {
 389                 return check_struct2(x);
 390         }
 391
 392         public static int test_0_struct2_args () {
 393                 int r;
 394                 struct2 x;
 395
 396                 x.a = 1;
 397                 if ((r = check_struct2(x)) != 0)
 398                         return r;
 399                 if ((r = pass_struct2(x)) != 0)
 400                         return r + 10;
 401                 if ((r = pass_struct2(3, x)) != 0)
 402                         return r + 20;
 403                 if ((r = pass_struct2(3, 4, x)) != 0)
 404                         return r + 30;
 405                 if ((r = pass_struct2(3, 4, 5, x)) != 0)
 406                         return r + 40;
 407                 return 0;
 408         }
 409
 410         // 128 bits
 411         struct Struct3 {
 412                 public long i, j, k, l;
 413         }
 414
 415         static int pass_struct3 (int i, int j, int k, int l, int m, int n, int o, int p, Struct3 s, int q) {
 416                 if (s.i + s.j + s.k + s.l != 10)
 417                         return 1;
 418                 else
 419                         return 0;
 420         }
 421
 422         public static int test_0_struct3_args () {
 423                 Struct3 s = new Struct3 ();
 424                 s.i = 1;
 425                 s.j = 2;
 426                 s.k = 3;
 427                 s.l = 4;
 428
 429                 return pass_struct3 (1, 2, 3, 4, 5, 6, 7, 8, s, 9);
 430         }
 431
 432         // Struct with unaligned size on 64 bit machines
 433         struct Struct4 {
 434         public int i, j, k, l, m;
 435                 public int i1, i2, i3, i4, i5, i6;
 436         }
 437
 438         static int pass_struct4 (Struct4 s) {
 439                 if (s.i + s.j + s.k + s.l + s.m != 15)
 440                         return 1;
 441                 else
 442                         return 0;
 443         }
 444
 445         public static int test_0_struct4_args () {
 446                 Struct4 s = new Struct4 ();
 447                 s.i = 1;
 448                 s.j = 2;
 449                 s.k = 3;
 450                 s.l = 4;
 451                 s.m = 5;
 452
 453                 return pass_struct4 (s);
 454         }
 455
 456
 457
 458         struct AStruct {
 459                 public int i;
 460
 461                 public AStruct (int i) {
 462                         this.i = i;
 463                 }
 464
 465                 public override int GetHashCode () {
 466                         return i;
 467                 }
 468         }
 469
 470         // Test that vtypes are unboxed during a virtual call
 471         public static int test_44_unbox_trampoline () {
 472                 AStruct s = new AStruct (44);
 473                 object o = s;
 474                 return o.GetHashCode ();
 475         }
 476
 477         public static int test_0_unbox_trampoline2 () {
 478                 int i = 12;
 479                 object o = i;
 480
 481                 if (i.ToString () != "12")
 482                         return 1;
 483                 if (((Int32)o).ToString () != "12")
 484                         return 2;
 485                 if (o.ToString () != "12")
 486                         return 3;
 487                 return 0;
 488         }
 489
 490         // Test fields with big offsets
 491         public static int test_0_fields_with_big_offsets () {
 492                 StructWithBigOffsets s = new StructWithBigOffsets ();
 493                 StructWithBigOffsets s2 = new StructWithBigOffsets ();
 494
 495                 s.b = 0xde;
 496                 s.sb = 0xe;
 497                 s.s = 0x12de;
 498                 s.us = 0x12da;
 499                 s.i = 0xdeadbeef;
 500                 s.si = 0xcafe;
 501                 s.l = 0xcafebabe;
 502                 s.f = 3.14F;
 503                 s.d = 3.14;
 504
 505                 s2.b = s.b;
 506                 s2.sb = s.sb;
 507                 s2.s = s.s;
 508                 s2.us = s.us;
 509                 s2.i = s.i;
 510                 s2.si = s.si;
 511                 s2.l = s.l;
 512                 s2.f = s.f;
 513                 s2.d = s.d;
 514
 515                 if (s2.b != 0xde)
 516                         return 1;
 517                 if (s2.s != 0x12de)
 518                         return 2;
 519                 if (s2.i != 0xdeadbeef)
 520                         return 3;
 521                 if (s2.l != 0xcafebabe)
 522                         return 4;
 523                 if (s2.f != 3.14F)
 524                         return 5;
 525                 if (s2.d != 3.14)
 526                         return 6;
 527                 if (s2.sb != 0xe)
 528                         return 7;
 529                 if (s2.us != 0x12da)
 530                         return 9;
 531                 if (s2.si != 0xcafe)
 532                         return 10;
 533
 534                 return 0;
 535         }
 536
 537         class TestRegA {
 538
 539                 long buf_start;
 540                 int buf_length, buf_offset;
 541
 542                 public TestRegA () {
 543                         buf_start = 0;
 544                         buf_length = 0;
 545                         buf_offset = 0;
 546                 }
 547
 548                 public long Seek (long position) {
 549                         long pos = position;
 550                         /* interaction between the register allocator and
 551                          * allocating arguments to registers */
 552                         if (pos >= buf_start && pos <= buf_start + buf_length) {
 553                                 buf_offset = (int) (pos - buf_start);
 554                                 return pos;
 555                         }
 556                         return buf_start;
 557                 }
 558
 559         }
 560
 561         public static int test_0_seektest () {
 562                 TestRegA t = new TestRegA ();
 563                 return (int)t.Seek (0);
 564         }
 565
 566         class Super : ICloneable {
 567                 public virtual object Clone () {
 568                         return null;
 569                 }
 570         }
 571         class Duper: Super {
 572         }
 573
 574         public static int test_0_null_cast () {
 575                 object o = null;
 576
 577                 Super s = (Super)o;
 578
 579                 return 0;
 580         }
 581
 582         public static int test_0_super_cast () {
 583                 Duper d = new Duper ();
 584                 Super sup = d;
 585                 Object o = d;
 586
 587                 if (!(o is Super))
 588                         return 1;
 589                 try {
 590                         d = (Duper)sup;
 591                 } catch {
 592                         return 2;
 593                 }
 594                 if (!(d is Object))
 595                         return 3;
 596                 try {
 597                         d = (Duper)(object)sup;
 598                 } catch {
 599                         return 4;
 600                 }
 601                 return 0;
 602         }
 603
 604         public static int test_0_super_cast_array () {
 605                 Duper[] d = new Duper [0];
 606                 Super[] sup = d;
 607                 Object[] o = d;
 608
 609                 if (!(o is Super[]))
 610                         return 1;
 611                 try {
 612                         d = (Duper[])sup;
 613                 } catch {
 614                         return 2;
 615                 }
 616                 if (!(d is Object[]))
 617                         return 3;
 618                 try {
 619                         d = (Duper[])(object[])sup;
 620                 } catch {
 621                         return 4;
 622                 }
 623                 return 0;
 624         }
 625
 626         public static int test_0_multi_array_cast () {
 627                 Duper[,] d = new Duper [1, 1];
 628                 object[,] o = d;
 629
 630                 try {
 631                         o [0, 0] = new Super ();
 632                         return 1;
 633                 }
 634                 catch (ArrayTypeMismatchException) {
 635                 }
 636
 637                 return 0;
 638         }
 639
 640         public static int test_0_vector_array_cast () {
 641                 Array arr1 = Array.CreateInstance (typeof (int), new int[] {1}, new int[] {0});
 642                 Array arr2 = Array.CreateInstance (typeof (int), new int[] {1}, new int[] {10});
 643                 Array arr5 = Array.CreateInstance (typeof (string), new int[] {1}, new int[] {10});
 644
 645                 if (arr1.GetType () != typeof (int[]))
 646                         return 1;
 647
 648                 if (arr2.GetType () == typeof (int[]))
 649                         return 2;
 650
 651                 int[] b;
 652
 653                 b = (int[])arr1;
 654
 655                 try {
 656                         b = (int[])arr2;
 657                         return 3;
 658                 }
 659                 catch (InvalidCastException) {
 660                 }
 661
 662                 if (arr2 is int[])
 663                         return 4;
 664                 var as_object_arr = arr5 as object [];
 665                 if (as_object_arr != null)
 666                         return 5;
 667
 668                 int [,] [] arr3 = new int [1, 1] [];
 669                 object o = arr3;
 670                 int [,] [] arr4 = (int [,] [])o;
 671
 672                 return 0;
 673         }
 674
 675         public static int test_0_enum_array_cast () {
 676                 TypeCode[] tc = new TypeCode [0];
 677                 object[] oa;
 678                 ValueType[] vta;
 679                 int[] inta;
 680                 Array a = tc;
 681                 bool ok;
 682
 683                 if (a is object[])
 684                         return 1;
 685                 if (a is ValueType[])
 686                         return 2;
 687                 if (a is Enum[])
 688                         return 3;
 689                 try {
 690                         ok = false;
 691                         oa = (object[])a;
 692                 } catch {
 693                         ok = true;
 694                 }
 695                 if (!ok)
 696                         return 4;
 697                 try {
 698                         ok = false;
 699                         vta = (ValueType[])a;
 700                 } catch {
 701                         ok = true;
 702                 }
 703                 if (!ok)
 704                         return 5;
 705                 try {
 706                         ok = true;
 707                         inta = (int[])a;
 708                 } catch {
 709                         ok = false;
 710                 }
 711                 if (!ok)
 712                         return 6;
 713                 return 0;
 714         }
 715
 716         public static int test_0_more_cast_corner_cases () {
 717                 ValueType[] vta = new ValueType [0];
 718                 Enum[] ea = new Enum [0];
 719                 Array a = vta;
 720                 object[] oa;
 721                 bool ok;
 722
 723                 if (!(a is object[]))
 724                         return 1;
 725                 if (!(a is ValueType[]))
 726                         return 2;
 727                 if (a is Enum[])
 728                         return 3;
 729                 a = ea;
 730                 if (!(a is object[]))
 731                         return 4;
 732                 if (!(a is ValueType[]))
 733                         return 5;
 734                 if (!(a is Enum[]))
 735                         return 6;
 736
 737                 try {
 738                         ok = true;
 739                         oa = (object[])a;
 740                 } catch {
 741                         ok = false;
 742                 }
 743                 if (!ok)
 744                         return 7;
 745
 746                 try {
 747                         ok = true;
 748                         oa = (Enum[])a;
 749                 } catch {
 750                         ok = false;
 751                 }
 752                 if (!ok)
 753                         return 8;
 754
 755                 try {
 756                         ok = true;
 757                         oa = (ValueType[])a;
 758                 } catch {
 759                         ok = false;
 760                 }
 761                 if (!ok)
 762                         return 9;
 763
 764                 a = vta;
 765                 try {
 766                         ok = true;
 767                         oa = (object[])a;
 768                 } catch {
 769                         ok = false;
 770                 }
 771                 if (!ok)
 772                         return 10;
 773
 774                 try {
 775                         ok = true;
 776                         oa = (ValueType[])a;
 777                 } catch {
 778                         ok = false;
 779                 }
 780                 if (!ok)
 781                         return 11;
 782
 783                 try {
 784                         ok = false;
 785                         vta = (Enum[])a;
 786                 } catch {
 787                         ok = true;
 788                 }
 789                 if (!ok)
 790                         return 12;
 791
 792                 object arr = new int [10];
 793                 if (arr is IList<int?>)
 794                         return 13;
 795
 796                 return 0;
 797         }
 798
 799         public static int test_0_cast_iface_array () {
 800                 object o = new ICloneable [0];
 801                 object o2 = new Duper [0];
 802                 object t;
 803                 bool ok;
 804
 805                 if (!(o is object[]))
 806                         return 1;
 807                 if (!(o2 is ICloneable[]))
 808                         return 2;
 809
 810                 try {
 811                         ok = true;
 812                         t = (object[])o;
 813                 } catch {
 814                         ok = false;
 815                 }
 816                 if (!ok)
 817                         return 3;
 818
 819                 try {
 820                         ok = true;
 821                         t = (ICloneable[])o2;
 822                 } catch {
 823                         ok = false;
 824                 }
 825                 if (!ok)
 826                         return 4;
 827
 828                 try {
 829                         ok = true;
 830                         t = (ICloneable[])o;
 831                 } catch {
 832                         ok = false;
 833                 }
 834                 if (!ok)
 835                         return 5;
 836
 837                 if (!(o is ICloneable[]))
 838                         return 6;
 839
 840                 /* add tests for interfaces that 'inherit' interfaces */
 841                 return 0;
 842         }
 843
 844         public static unsafe int test_0_pointer_array() {
 845                 int*[] ipa = new int* [0];
 846                 Array a = ipa;
 847
 848
 849                 if (a is object[])
 850                         return 1;
 851                 if (!(a is int*[]))
 852                         return 2;
 853                 if (a is ValueType[])
 854                         return 3;
 855                 if (a is Enum[])
 856                         return 4;
 857                 if (a is char*[])
 858                         return 5;
 859
 860                 return 0;
 861         }
 862
 863         public static string[] StringValues = { "Val1", "Val2", "Val3" };
 864
 865         public static IEnumerable<string> GetStringValues ()
 866         {
 867                 foreach (string val in StringValues)
 868                         yield return val;
 869         }
 870
 871         public static int test_0_cast_special_iface () {
 872                 try {
 873                         IEnumerable<string> strings = GetStringValues ();
 874                         IList<string> stringIList = (IList<string>) strings;
 875
 876                         // No exception thrown. Maybe it's an actual IList ?
 877                         // Make sure it's not bluffing
 878                         if (!"Val2".Equals (stringIList [1]))
 879                                 return 1;
 880                 } catch (InvalidCastException) {
 881                 }
 882
 883                 return 0;
 884         }
 885
 886         private static int[] daysmonthleap = { 0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
 887
 888         private static int AbsoluteDays (int year, int month, int day)
 889         {
 890                 int temp = 0, m = 1;
 891                 int[] days = daysmonthleap;
 892                 while (m < month)
 893                         temp += days[m++];
 894                 return ((day-1) + temp + (365* (year-1)) + ((year-1)/4) - ((year-1)/100) + ((year-1)/400));
 895         }
 896
 897         public static int test_719162_complex_div () {
 898                 int adays = AbsoluteDays (1970, 1, 1);
 899                 return adays;
 900         }
 901
 902         delegate int GetIntDel ();
 903
 904         static int return4 () {
 905                 return 4;
 906         }
 907
 908         int return5 () {
 909                 return 5;
 910         }
 911
 912         public static int test_2_static_delegate () {
 913                 GetIntDel del = new GetIntDel (return4);
 914                 int v = del ();
 915                 if (v != 4)
 916                         return 0;
 917                 return 2;
 918         }
 919
 920         public static int test_2_instance_delegate () {
 921                 Tests t = new Tests ();
 922                 GetIntDel del = new GetIntDel (t.return5);
 923                 int v = del ();
 924                 if (v != 5)
 925                         return 0;
 926                 return 2;
 927         }
 928
 929         class InstanceDelegateTest {
 930                 public int a;
 931
 932                 public int return_field () {
 933                         return a;
 934                 }
 935         }
 936
 937         public static int test_2_instance_delegate_with_field () {
 938                 InstanceDelegateTest t = new InstanceDelegateTest () { a = 1337 };
 939                 GetIntDel del = new GetIntDel (t.return_field);
 940                 int v = del ();
 941                 if (v != 1337)
 942                         return 0;
 943                 return 2;
 944         }
 945
 946         interface IFaceVirtualDel {
 947                 int return_field ();
 948         }
 949
 950         struct VtypeVirtualDelStruct : IFaceVirtualDel {
 951                 public int f;
 952                 public int return_field_nonvirt () {
 953                         return f;
 954                 }
 955                 public int return_field () {
 956                         return f;
 957                 }
 958         }
 959
 960         public static int test_42_vtype_delegate () {
 961                 var s = new VtypeVirtualDelStruct () { f = 42 };
 962                 Func<int> f = s.return_field_nonvirt;
 963                 return f ();
 964         }
 965
 966         public static int test_42_vtype_virtual_delegate () {
 967                 IFaceVirtualDel s = new VtypeVirtualDelStruct () { f = 42 };
 968                 Func<int> f = s.return_field;
 969                 return f ();
 970         }
 971
 972         public static int test_1_store_decimal () {
 973                 decimal[,] a = {{1}};
 974
 975                 if (a[0,0] != 1m)
 976                         return 0;
 977                 return 1;
 978         }
 979
 980         public static int test_2_intptr_stobj () {
 981                 System.IntPtr [] arr = { new System.IntPtr () };
 982
 983                 if (arr [0] != (System.IntPtr)0)
 984                         return 1;
 985                 return 2;
 986         }
 987
 988         static int llmult (int a, int b, int c, int d) {
 989                 return a + b + c + d;
 990         }
 991
 992         /*
 993          * Test that evaluation of complex arguments does not overwrite the
 994          * arguments already in outgoing registers.
 995          */
 996         public static int test_155_regalloc () {
 997                 int a = 10;
 998                 int b = 10;
 999
1000                 int c = 0;
1001                 int d = 0;
1002                 int[] arr = new int [5];
1003
1004                 return llmult (arr [c + d], 150, 5, 0);
1005         }
1006
1007         static bool large_struct_test (Large a, Large b, Large c, Large d)
1008         {
1009                 if (!a.check ()) return false;
1010                 if (!b.check ()) return false;
1011                 if (!c.check ()) return false;
1012                 if (!d.check ()) return false;
1013                 return true;
1014         }
1015
1016         public static int test_2_large_struct_pass ()
1017         {
1018                 Large a, b, c, d;
1019                 a = new Large ();
1020                 b = new Large ();
1021                 c = new Large ();
1022                 d = new Large ();
1023                 a.populate ();
1024                 b.populate ();
1025                 c.populate ();
1026                 d.populate ();
1027                 if (large_struct_test (a, b, c, d))
1028                         return 2;
1029                 return 0;
1030         }
1031
1032         public static unsafe int test_0_pin_string () {
1033                 string x = "xxx";
1034                 fixed (char *c = x) {
1035                         if (*c != 'x')
1036                                 return 1;
1037                 }
1038                 return 0;
1039         }
1040
1041         public static int my_flags;
1042         public static int test_0_and_cmp_static ()
1043         {
1044
1045                 /* various forms of test [mem], imm */
1046
1047                 my_flags = 0x01020304;
1048
1049                 if ((my_flags & 0x01020304) == 0)
1050                         return 1;
1051
1052                 if ((my_flags & 0x00000304) == 0)
1053                         return 2;
1054
1055                 if ((my_flags & 0x00000004) == 0)
1056                         return 3;
1057
1058                 if ((my_flags & 0x00000300) == 0)
1059                         return 4;
1060
1061                 if ((my_flags & 0x00020000) == 0)
1062                         return 5;
1063
1064                 if ((my_flags & 0x01000000) == 0)
1065                         return 6;
1066
1067                 return 0;
1068         }
1069
1070         static byte b;
1071         public static int test_0_byte_compares ()
1072         {
1073                 b = 0xff;
1074                 if (b == -1)
1075                         return 1;
1076                 b = 0;
1077                 if (!(b < System.Byte.MaxValue))
1078                         return 2;
1079
1080                 if (!(b <= System.Byte.MaxValue))
1081                         return 3;
1082
1083                 return 0;
1084         }
1085
1086         static Nullable<bool> s_nullb;
1087         static AStruct s_struct1;
1088
1089         /* test if VES uses correct sizes for value type write to static field */
1090         public static int test_0_static_nullable_bool () {
1091                 s_struct1 = new AStruct (0x1337dead);
1092                 s_nullb = true;
1093                 /* make sure that the write to s_nullb didn't smash the value after it */
1094                 if (s_struct1.i != 0x1337dead)
1095                         return 2;
1096                 return 0;
1097         }
1098
1099         public static int test_71_long_shift_right () {
1100                 ulong value = 38654838087;
1101                 int x = 0;
1102                 byte [] buffer = new byte [1];
1103                 buffer [x] = ((byte)(value >> x));
1104                 return buffer [x];
1105         }
1106
1107         static long x;
1108         public static int test_0_addsub_mem ()
1109         {
1110                 x = 0;
1111                 x += 5;
1112
1113                 if (x != 5)
1114                         return 1;
1115
1116                 x -= 10;
1117
1118                 if (x != -5)
1119                         return 2;
1120
1121                 return 0;
1122         }
1123
1124         static ulong y;
1125         public static int test_0_sh32_mem ()
1126         {
1127                 y = 0x0102130405060708;
1128                 y >>= 32;
1129
1130                 if (y != 0x01021304)
1131                         return 1;
1132
1133                 y = 0x0102130405060708;
1134                 y <<= 32;
1135
1136                 if (y != 0x0506070800000000)
1137                         return 2;
1138
1139                 x = 0x0102130405060708;
1140                 x <<= 32;
1141
1142                 if (x != 0x0506070800000000)
1143                         return 2;
1144
1145                 return 0;
1146         }
1147
1148
1149         static uint dum_de_dum = 1;
1150         public static int test_0_long_arg_opt ()
1151         {
1152                 return Foo (0x1234567887654321, dum_de_dum);
1153         }
1154
1155         static int Foo (ulong x, ulong y)
1156         {
1157                 if (x != 0x1234567887654321)
1158                         return 1;
1159
1160                 if (y != 1)
1161                         return 2;
1162
1163                 return 0;
1164         }
1165
1166         public static int test_0_long_ret_opt ()
1167         {
1168                 ulong x = X ();
1169                 if (x != 0x1234567887654321)
1170                         return 1;
1171                 ulong y = Y ();
1172                 if (y != 1)
1173                         return 2;
1174
1175                 return 0;
1176         }
1177
1178         static ulong X ()
1179         {
1180                 return 0x1234567887654321;
1181         }
1182
1183         static ulong Y ()
1184         {
1185                 return dum_de_dum;
1186         }
1187
1188         /* from bug# 71515 */
1189         static int counter = 0;
1190         static bool WriteStuff () {
1191                 counter = 10;
1192                 return true;
1193         }
1194         public static int test_0_cond_branch_side_effects () {
1195                 counter = 5;
1196                 if (WriteStuff()) {
1197                 }
1198                 if (counter == 10)
1199                         return 0;
1200                 return 1;
1201         }
1202
1203         // bug #74992
1204         public static int arg_only_written (string file_name, int[]
1205 ncells ) {
1206                 if (file_name == null)
1207                         return 1;
1208
1209                 ncells = foo ();
1210                 bar (ncells [0]);
1211
1212                 return 0;
1213         }
1214
1215         public static int[] foo () {
1216                 return new int [3];
1217         }
1218
1219         public static void bar (int i) {
1220         }
1221
1222
1223         public static int test_0_arg_only_written ()
1224         {
1225                 return arg_only_written ("md.in", null);
1226         }
1227
1228         static long position = 0;
1229
1230         public static int test_4_static_inc_long () {
1231
1232                 int count = 4;
1233
1234                 position = 0;
1235
1236                 position += count;
1237
1238                 return (int)position;
1239         }
1240
1241         struct FooStruct {
1242
1243                 public FooStruct (long l) {
1244                 }
1245         }
1246
1247         public static int test_0_calls_opcode_emulation () {
1248                 // Test that emulated opcodes do not clobber arguments already in
1249                 // out registers
1250                 checked {
1251                         long val = 10000;
1252                         new FooStruct (val * 10000);
1253                 }
1254                 return 0;
1255         }
1256
1257         public static int test_0_intrins_string_length () {
1258                 string s = "ABC";
1259
1260                 return (s.Length == 3) ? 0 : 1;
1261         }
1262
1263         public static int test_0_intrins_string_chars () {
1264                 string s = "ABC";
1265
1266                 return (s [0] == 'A' && s [1] == 'B' && s [2] == 'C') ? 0 : 1;
1267         }
1268
1269         public static int test_0_intrins_object_gettype () {
1270                 object o = 1;
1271
1272                 return (o.GetType () == typeof (int)) ? 0 : 1;
1273         }
1274
1275         public static int test_0_intrins_object_gethashcode () {
1276                 object o = new Object ();
1277
1278                 return (o.GetHashCode () == o.GetHashCode ()) ? 0 : 1;
1279         }
1280
1281         class FooClass {
1282         }
1283
1284         public static int test_0_intrins_object_ctor () {
1285                 object o = new FooClass ();
1286
1287                 return (o != null) ? 0 : 1;
1288         }
1289
1290         public static int test_0_intrins_array_rank () {
1291                 int[,] a = new int [10, 10];
1292
1293                 return (a.Rank == 2) ? 0 : 1;
1294         }
1295
1296         public static int test_0_intrins_array_length () {
1297                 int[,] a = new int [10, 10];
1298                 Array a2 = a;
1299
1300                 return (a2.Length == 100) ? 0 : 1;
1301         }
1302
1303         public static int test_0_intrins_runtimehelpers_offset_to_string_data () {
1304                 int i = RuntimeHelpers.OffsetToStringData;
1305
1306                 return i - i;
1307         }
1308
1309         public static int test_0_intrins_string_setchar () {
1310                 StringBuilder sb = new StringBuilder ("ABC");
1311
1312                 sb [1] = 'D';
1313
1314                 return sb.ToString () == "ADC" ? 0 : 1;
1315         }
1316
1317         enum FlagsEnum {
1318                 None = 0,
1319                 A = 1,
1320                 B = 2,
1321                 C = 4
1322         }
1323
1324         public static int test_0_intrins_enum_hasflag () {
1325                 var e = FlagsEnum.A | FlagsEnum.B;
1326
1327                 if (!e.HasFlag (FlagsEnum.A))
1328                         return 1;
1329                 if (!e.HasFlag (FlagsEnum.A | FlagsEnum.B))
1330                         return 2;
1331                 if (!e.HasFlag (FlagsEnum.None))
1332                         return 3;
1333                 if (e.HasFlag (FlagsEnum.C))
1334                         return 4;
1335                 return 0;
1336         }
1337
1338         public class Bar {
1339                 bool allowLocation = true;
1340         Foo f = new Foo ();
1341         }
1342
1343         public static int test_0_regress_78990_unaligned_structs () {
1344                 new Bar ();
1345
1346                 return 0;
1347         }
1348
1349         public static unsafe int test_97_negative_index () {
1350                 char[] arr = new char[] {'a', 'b'};
1351                 fixed (char *p = arr) {
1352                         char *i = p + 2;
1353                         char a = i[-2];
1354                         return a;
1355                 }
1356         }
1357
1358         /* bug #82281 */
1359         public static int test_0_unsigned_right_shift_imm0 () {
1360                 uint temp = 0;
1361                 byte[] data = new byte[256];
1362                 for (int i = 0; i < 1; i ++)
1363                         temp = (uint)(data[temp >> 24] | data[temp >> 0]);
1364                 return 0;
1365         }
1366
1367         class Foo2 {
1368                 public virtual int foo () {
1369                         return 0;
1370                 }
1371         }
1372
1373         sealed class Bar2 : Foo2 {
1374                 public override int foo () {
1375                         return 0;
1376                 }
1377         }
1378
1379         public static int test_0_abcrem_check_this_removal () {
1380                 Bar2 b = new Bar2 ();
1381
1382                 // The check_this generated here by the JIT should be removed
1383                 b.foo ();
1384
1385                 return 0;
1386         }
1387
1388         static int invoke_twice (Bar2 b) {
1389                 b.foo ();
1390                 // The check_this generated here by the JIT should be removed
1391                 b.foo ();
1392
1393                 return 0;
1394         }
1395
1396         public static int test_0_abcrem_check_this_removal2 () {
1397                 Bar2 b = new Bar2 ();
1398
1399                 invoke_twice (b);
1400
1401                 return 0;
1402         }
1403
1404         /* #346563 */
1405         public static int test_0_array_access_64_bit () {
1406                 int[] arr2 = new int [10];
1407                 for (int i = 0; i < 10; ++i)
1408                         arr2 [i] = i;
1409                 string s = "ABCDEFGH";
1410
1411                 byte[] arr = new byte [4];
1412                 arr [0] = 252;
1413                 arr [1] = 255;
1414                 arr [2] = 255;
1415                 arr [3] = 255;
1416
1417                 int len = arr [0] | (arr [1] << 8) | (arr [2] << 16) | (arr [3] << 24);
1418                 int len2 = - (len + 2);
1419
1420                 // Test array and string access with a 32 bit value whose upper 32 bits are
1421                 // undefined
1422                 // len2 = 3
1423                 if (arr2 [len2] != 2)
1424                         return 1;
1425                 if (s [len2] != 'C')
1426                         return 2;
1427                 return 0;
1428         }
1429
1430         public static float return_float () {
1431                 return 1.4e-45f;
1432         }
1433
1434 #if !NO_BITCODE
1435         [Category ("!BITCODE")] // bug #59953
1436         public static int test_0_float_return_spill () {
1437                 // The return value of return_float () is spilled because of the
1438                 // boxing call
1439                 object o = return_float ();
1440                 float f = return_float ();
1441                 return (float)o == f ? 0 : 1;
1442         }
1443 #endif
1444
1445         class R4Holder {
1446                 public static float pi = 3.14f;
1447
1448                 public float float_field;
1449         }
1450
1451         public static int test_0_ldsfld_soft_float () {
1452                 if (R4Holder.pi == 3.14f)
1453                         return 0;
1454                 else
1455                         return 1;
1456         }
1457
1458         public static int test_0_ldfld_stfld_soft_float () {
1459                 R4Holder h = new R4Holder ();
1460                 h.float_field = 3.14f;
1461
1462                 if (h.float_field == 3.14f)
1463                         return 0;
1464                 else
1465                         return 1;
1466         }
1467
1468         class R4HolderRemote : MarshalByRefObject {
1469                 public static float pi = 3.14f;
1470
1471                 public float float_field;
1472         }
1473
1474         public static int test_0_ldfld_stfld_soft_float_remote () {
1475                 R4HolderRemote h = new R4HolderRemote ();
1476                 h.float_field = 3.14f;
1477
1478                 if (h.float_field == 3.14f)
1479                         return 0;
1480                 else
1481                         return 1;
1482         }
1483
1484         public static int test_0_locals_soft_float () {
1485                 float f = 0.0f;
1486
1487                 f = 3.14f;
1488
1489                 if (f == 3.14f)
1490                         return 0;
1491                 else
1492                         return 1;
1493         }
1494
1495         struct AStruct2 {
1496                 public int i;
1497                 public int j;
1498         }
1499
1500         static float pass_vtype_return_float (AStruct2 s) {
1501                 return s.i + s.j == 6 ? 1.0f : -1.0f;
1502         }
1503
1504         public static int test_0_vtype_arg_soft_float () {
1505                 return pass_vtype_return_float (new AStruct2 () { i = 2, j = 4 }) > 0.0 ? 0 : 1;
1506         }
1507
1508         static int range_check_strlen (int i, string s) {
1509                 if (i < 0 || i > s.Length)
1510                         return 1;
1511                 else
1512                         return 0;
1513         }
1514
1515         public static int test_0_range_check_opt () {
1516                 if (range_check_strlen (0, "A") != 0)
1517                         return 1;
1518                 if (range_check_strlen (1, "A") != 0)
1519                         return 2;
1520                 if (range_check_strlen (2, "A") != 1)
1521                         return 3;
1522                 if (range_check_strlen (-100, "A") != 1)
1523                         return 4;
1524                 return 0;
1525         }
1526
1527         static int test_0_array_get_set_soft_float () {
1528                 float[,] arr = new float [2, 2];
1529                 arr [0, 0] = 256f;
1530                 return arr [0, 0] == 256f ? 0 : 1;
1531         }
1532
1533         //repro for #506915
1534         struct Bug506915 { public int val; }
1535         static int test_2_ldobj_stobj_optization ()
1536         {
1537                 int i = 99;
1538                 var a = new Bug506915 ();
1539                 var b = new Bug506915 ();
1540                 if (i.GetHashCode () == 99)
1541                         i = 44;
1542                 var array = new Bug506915 [2];
1543                 array [0].val = 2;
1544                 array [1] = (i == 0) ? a : array [0];
1545
1546                 return array [1].val;
1547         }
1548
1549         /* mcs can't compile this (#646744) */
1550 #if FALSE
1551         static void InitMe (out Gamma noMercyWithTheStack) {
1552                 noMercyWithTheStack = new Gamma ();
1553         }
1554
1555         static int FunNoInline () {
1556                 int x = 99;
1557                 if (x > 344 && x < 22)
1558                         return 333;
1559                 return x;
1560         }
1561
1562         static float DoNothingButDontInline (float a, int b) {
1563                 if (b > 0)
1564                         return a;
1565                 else if (b < 0 && b > 10)
1566                         return 444.0f;
1567                 return a;
1568         }
1569
1570         /*
1571          * The local register allocator emits loadr8_membase and storer8_membase
1572          * to do spilling. This code is generated after mono_arch_lowering_pass so
1573          * mono_arch_output_basic_block must know how to deal with big offsets.
1574          * This only happens because the call in middle forces the temp for "(float)obj"
1575          * to be spilled.
1576         */
1577         public static int test_0_float_load_and_store_with_big_offset ()
1578         {
1579                 object obj = 1.0f;
1580                 Gamma noMercyWithTheStack;
1581                 float res;
1582
1583                 InitMe (out noMercyWithTheStack);
1584
1585                 res = DoNothingButDontInline ((float)obj, FunNoInline ());
1586
1587                 if (!(res == 1.0f))
1588                         return 1;
1589                 return 0;
1590         }
1591 #endif
1592
1593         struct VTypePhi {
1594                 public int i;
1595         }
1596
1597         static int vtype_phi (VTypePhi v1, VTypePhi v2, bool first) {
1598                 VTypePhi v = first ? v1 : v2;
1599
1600                 return v.i;
1601         }
1602
1603         static int test_0_vtype_phi ()
1604         {
1605                 VTypePhi v1 = new VTypePhi () { i = 1 };
1606                 VTypePhi v2 = new VTypePhi () { i = 2 };
1607
1608                 if (vtype_phi (v1, v2, true) != 1)
1609                         return 1;
1610                 if (vtype_phi (v1, v2, false) != 2)
1611                         return 2;
1612
1613                 return 0;
1614         }
1615
1616         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1617         static void UseValue (int index)
1618         {
1619         }
1620
1621         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1622         static bool IsFalse ()
1623         {
1624                 return false;
1625         }
1626
1627         static int test_0_llvm_moving_faulting_loads ()
1628         {
1629                 int[] indexes = null;
1630
1631                 if (IsFalse ()) {
1632                         indexes = new int[0];
1633                 }
1634
1635                 while (IsFalse ()) {
1636                         UseValue (indexes[0]);
1637                         UseValue (indexes[0]);
1638                 }
1639
1640                 return 0;
1641         }
1642
1643         public static bool flag;
1644
1645         class B {
1646
1647                 internal static B[] d;
1648
1649                 static B () {
1650                         flag = true;
1651                 }
1652         }
1653
1654         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1655         static int regress_679467_inner () {
1656                 if (flag == true)
1657                         return 1;
1658                 var o = B.d;
1659                 var o2 = B.d;
1660                 return 0;
1661         }
1662
1663         /*
1664          * FIXME: This fails with AOT #703317.
1665          */
1666         /*
1667         static int test_0_multiple_cctor_calls_regress_679467 () {
1668                 flag = false;
1669                 return regress_679467_inner ();
1670         }
1671         */
1672
1673         static int test_0_char_ctor () {
1674                 string s = new String (new char[] { 'A', 'B' }, 0, 1);
1675                 return 0;
1676         }
1677
1678         static object mInstance = null;
1679
1680         [MethodImpl(MethodImplOptions.Synchronized)]
1681         public static object getInstance() {
1682                 if (mInstance == null)
1683                         mInstance = new object();
1684                 return mInstance;
1685         }
1686
1687         static int test_0_synchronized () {
1688                 getInstance ();
1689                 return 0;
1690         }
1691
1692         struct BStruct {
1693                 public Type t;
1694         }
1695
1696         class Del<T> {
1697                 public static BStruct foo () {
1698                         return new BStruct () { t = typeof (T) };
1699                 }
1700         }
1701
1702         delegate BStruct ADelegate ();
1703
1704         static int test_0_regress_10601 () {
1705                 var act = (ADelegate)(Del<string>.foo);
1706                 BStruct b = act ();
1707                 if (b.t != typeof (string))
1708                         return 1;
1709                 return 0;
1710         }
1711
1712         static int test_0_regress_11058 () {
1713                 int foo = -252674008;
1714                 int foo2 = (int)(foo ^ 0xF0F0F0F0); // = 28888
1715                 var arr = new byte[foo2].Length;
1716                 return 0;
1717         }
1718
1719         public static void do_throw () {
1720                 throw new Exception ();
1721         }
1722
1723         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1724         static void empty () {
1725         }
1726
1727         // #11297
1728         public static int test_0_llvm_inline_throw () {
1729                 try {
1730                         empty ();
1731                 } catch (Exception) {
1732                         do_throw ();
1733                 }
1734
1735                 return 0;
1736         }
1737
1738         enum ByteEnum : byte {
1739         Zero = 0
1740     }
1741
1742     struct BugStruct {
1743         public ByteEnum f1;
1744         public ByteEnum f2;
1745         public ByteEnum f3;
1746         public byte f4;
1747         public byte f5;
1748         public byte f6;
1749         public byte f7;
1750     }
1751
1752         public static int test_0_14217 () {
1753                 t_14217_inner (new BugStruct ());
1754                 return 0;
1755         }
1756
1757         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1758         static void t_14217_inner (BugStruct bug) {
1759     }
1760
1761         [StructLayout(LayoutKind.Sequential)]
1762         public struct EmptyStruct {
1763         }
1764
1765         class EmptyClass {
1766                 public static EmptyStruct s;
1767         }
1768
1769         // #20349
1770         static int test_0_empty_struct_as_static () {
1771                 var s = EmptyClass.s;
1772                 return 0;
1773         }
1774
1775         // #25487
1776         static int test_0_int_to_r4 () {
1777                 return int_to_r4_inner (255);
1778         }
1779
1780         static int int_to_r4_inner (int value1) {
1781                 int sub = -value1;
1782                 float mult = sub * 1f;
1783                 if (mult != -255.0f)
1784                         return 1;
1785                 else
1786                         return 0;
1787         }
1788
1789         struct HFA4D {
1790                 public double a, b, c, d;
1791         }
1792
1793         static double arm64_hfa_on_stack_inner (double d1, double d2, double d3, double d4, double d5, double d6, double d7, double d8, HFA4D s) {
1794                 return s.a + s.b + s.c + s.d;
1795         }
1796
1797         static int test_0_arm64_hfa_on_stack () {
1798                 var s = new HFA4D () { a = 1.0, b = 2.0, c = 3.0, d = 4.0 };
1799                 var res = arm64_hfa_on_stack_inner (1, 2, 3, 4, 5, 6, 7, 8, s);
1800                 return res == 10.0 ? 0 : 1;
1801         }
1802
1803         class MulOvfClass {
1804                 [MethodImplAttribute (MethodImplOptions.NoInlining)]
1805                 public unsafe void EncodeIntoBuffer(char* value, int valueLength, char* buffer, int bufferLength) {
1806                 }
1807         }
1808
1809         static unsafe int test_0_mul_ovf_regress_36052 () {
1810                 var p = new MulOvfClass ();
1811
1812                 string typeName = typeof(int).Name;
1813                 int bufferSize = 45;
1814
1815                 fixed (char* value = typeName) {
1816                         char* buffer = stackalloc char[bufferSize];
1817                         p.EncodeIntoBuffer(value, typeName.Length, buffer, bufferSize);
1818                 }
1819                 return 0;
1820         }
1821
1822         struct Struct16 {
1823                 public int a, b, c, d;
1824         }
1825
1826         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1827         static int pass_struct16 (object o0, object o2, object o3, object o4, object o5, object o6, object o7, Struct16 o8) {
1828                 // This disables LLVM
1829                 try {
1830                 } catch {
1831                 }
1832                 return o8.a;
1833         }
1834
1835         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1836         static int pass_struct16 (object o0, object o2, object o3, object o6, object o7, Struct16 o8) {
1837                 return pass_struct16 (o0, o2, null, o3, null, o6, o7, o8);
1838         }
1839
1840         public static int test_42_pass_16byte_struct_split () {
1841                 return pass_struct16 (null, null, null, null, null, new Struct16 () { a = 42 });
1842         }
1843
1844         public interface IComparer2
1845         {
1846                 Type foo<T> ();
1847         }
1848
1849         public class AClass : IComparer2 {
1850                 public Type foo<T> () {
1851                         return typeof(T);
1852                 }
1853         }
1854
1855         public static int test_0_delegate_to_virtual_generic_on_ifaces () {
1856                 IComparer2 c = new AClass ();
1857
1858                 Func<Type> f = c.foo<string>;
1859                 return f () == typeof(string) ? 0 : 1;
1860         }
1861
1862         public enum ByteEnum2 : byte {
1863                 High = 142
1864         }
1865
1866         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1867         public static int enum_arg_zero_extend (ByteEnum2 b) {
1868                 return (int)b;
1869         }
1870
1871         public static int test_142_byte_enum_arg_zero_extend () {
1872                 return enum_arg_zero_extend (ByteEnum2.High);
1873         }
1874
1875         enum Mine { One, Two }
1876
1877         public static int test_0_enum_gethashcode_opt () {
1878                 int sum = 0;
1879         for (int i = 0; i < 1000000; ++i)
1880                         sum += Mine.Two.GetHashCode();
1881
1882         return 0;
1883     }
1884
1885         public static int test_0_typedref () {
1886                 int i = 5;
1887                 System.TypedReference r = __makeref(i);
1888                 System.Type t = __reftype(r);
1889
1890                 if (t != typeof (int))
1891                         return 1;
1892                 int j = __refvalue(r, int);
1893                 if (j != 5)
1894                         return 2;
1895
1896                 try {
1897                         object o = __refvalue (r, object);
1898                 } catch (InvalidCastException) {
1899                 }
1900
1901                 return 0;
1902         }
1903
1904         enum FooEnum { Bar }
1905         //https://github.com/mono/mono/issues/6666
1906         public static int test_0_bad_unbox_nullable_of_enum () {
1907                 try {
1908                         var enumValue = FooEnum.Bar;
1909                         object value = (int)enumValue;
1910                         var res = (FooEnum?)value; // Should throw
1911                 } catch (InvalidCastException) {
1912                         return 0;
1913                 }
1914                 return 1;
1915         }
1916
1917         //https://github.com/mono/mono/issues/6666
1918         public static int test_0_unbox_nullable_of_enum () {
1919                 try {
1920                         var enumValue = FooEnum.Bar;
1921                         object value = (object)enumValue;
1922                         var res = (FooEnum?)value; // Should not throw
1923                 } catch (InvalidCastException) {
1924                         return 1;
1925                 }
1926                 return 0;
1927         }
1928
1929         static void decode (out sbyte v) {
1930                 byte tmp = 134;
1931                 v = (sbyte)tmp;
1932         }
1933
1934         // gh #6414
1935         public static int test_0_alias_analysis_sign_extend () {
1936           sbyte t;
1937           decode (out t);
1938
1939           return t == -122 ? 0 : 1;
1940         }
1941
1942         public interface IFoo
1943         {
1944           int MyInt { get; }
1945         }
1946
1947         public class IFooImpl : IFoo
1948         {
1949           public int MyInt => 0;
1950         }
1951
1952         //gh 6266
1953     public static int test_0_store_to_magic_iface_array ()
1954     {
1955       ICollection<IFoo> arr1 = new IFooImpl[1] { new IFooImpl() };
1956       ICollection<IFoo> arr2 = new IFooImpl[1] { new IFooImpl() };
1957
1958       ICollection<IFoo>[] a2d = new ICollection<IFoo>[2] {
1959         arr1,
1960         arr2,
1961       };
1962
1963           return 0;
1964     }
1965
1966         static volatile bool abool;
1967
1968         public static unsafe int test_0_stind_r4_float32_stack_merge () {
1969                 Single* dataPtr = stackalloc Single[4];
1970                 abool = true;
1971                 dataPtr[0] = abool ? 1.0f : 2.0f;
1972                 return dataPtr [0] == 1.0f ? 0 : 1;
1973         }
1974
1975         class AClass1 {
1976         }
1977
1978         class BClass1 : AClass1 {
1979         }
1980
1981         class CClass1 {
1982         }
1983
1984         public static int test_0_array_of_magic_iface () {
1985                 // Need to make this an object otherwise csc removes the cast
1986                 object d = new [] { new [] { new BClass1 () } };
1987                 if (!(d is IList<AClass1> []))
1988                         return 1;
1989                 if (d is IList<CClass1> [])
1990                         return 2;
1991                 var e2 = (IList<AClass1> []) d;
1992                 return 0;
1993         }
1994
1995         class SimpleContainer {
1996                 public Simple simple1;
1997                 public Simple simple2;
1998
1999                 public static Simple constsimple;
2000
2001                 public int SetFields () {
2002                         constsimple.a = 0x1337;
2003                         simple1 = simple2 = constsimple;
2004                         return simple1.a - simple2.a;
2005                 }
2006         }
2007
2008         public static int test_0_dup_vtype () {
2009                 return new SimpleContainer ().SetFields ();
2010         }
2011
2012         public struct Vec3 {
2013                 public int X, Y, Z;
2014
2015                 [MethodImplAttribute (MethodImplOptions.NoInlining)]
2016                         public Vec3(int x, int y, int z) {
2017                         X = x;
2018                         Y = y;
2019                         Z = z;
2020                 }
2021         }
2022
2023         [MethodImplAttribute (MethodImplOptions.NoInlining)]
2024         public static int gh_11378_inner_1 (Vec3 p1, Vec3 p2) {
2025                 p1.X -= p2.X;
2026                 p1.Y -= p2.Y;
2027                 p1.Z -= p2.Z;
2028
2029                 return (int)p2.Y;
2030         }
2031
2032         [MethodImplAttribute (MethodImplOptions.NoInlining)]
2033         public static int gh_11378_inner_2 (Vec3 c, Vec3 pos) {
2034                 return gh_11378_inner_1 (pos, c);
2035         }
2036
2037         static int gh_11378_inner_3 (Vec3 c) {
2038                 var c2 = c;
2039                 return gh_11378_inner_2 (c, c2);
2040         }
2041
2042         public static int test_2_gh_11378 () {
2043                 return gh_11378_inner_3 (new Vec3(0, 2, -20));
2044         }
2045
2046         static int variable_with_constant_address;
2047
2048         public static int test_0_cfold_with_non_constant_ternary_op () {
2049                 variable_with_constant_address = 0;
2050                 var old = System.Threading.Interlocked.CompareExchange(ref variable_with_constant_address, 1, 0);
2051                 return old == 0 && variable_with_constant_address == 1 ? 0 : 1;
2052         }
2053 }
2054
2055 #if __MOBILE__
2056 }
2057 #endif