mcs/class/Mono.Debugger.Soft/Test/dtest-app.cs

   1 /*
   2  * dtest-app.cs:
   3  *
   4  *   Application program used by the debugger tests.
   5  */
   6 using System;
   7 using System.Runtime.CompilerServices;
   8 using System.Reflection;
   9 using System.Reflection.Emit;
  10 using System.Diagnostics;
  11 using System.Threading;
  12 using System.Collections.Generic;
  13 using System.Linq;
  14
  15 public class TestsBase
  16 {
  17 #pragma warning disable 0414
  18 #pragma warning disable 0169
  19         public int base_field_i;
  20         public string base_field_s;
  21         static int base_static_i = 57;
  22         static string base_static_s = "C";
  23 #pragma warning restore 0414
  24 #pragma warning restore 0169
  25 }
  26
  27 public enum AnEnum {
  28         A = 0,
  29         B= 1
  30 }
  31
  32 public sealed class Tests3 {
  33         public static void M1 () {
  34         }
  35
  36         static void M2 () {
  37         }
  38
  39         public void M3 () {
  40         }
  41
  42         void M4 () {
  43         }
  44
  45 }
  46
  47 public static class Tests4 {
  48         static Tests4 () {
  49         }
  50 }
  51
  52 public class AAttribute : Attribute {
  53         public int afield;
  54 }
  55
  56 public class BAttribute : AAttribute {
  57         public int bfield;
  58 }
  59
  60 [DebuggerDisplay ("Tests", Name="FOO", Target=typeof (int))]
  61 [DebuggerTypeProxy (typeof (Tests))]
  62 [BAttribute (afield = 1, bfield = 2)]
  63 public class Tests2 {
  64         [DebuggerBrowsableAttribute (DebuggerBrowsableState.Collapsed)]
  65         public int field_j;
  66         public static int static_field_j;
  67
  68         [DebuggerBrowsableAttribute (DebuggerBrowsableState.Collapsed)]
  69         public int AProperty {
  70                 get {
  71                         return 0;
  72                 }
  73         }
  74
  75         public void invoke () {
  76         }
  77 }
  78
  79 public struct AStruct {
  80         public int i;
  81         public string s;
  82         public byte k;
  83         public IntPtr j;
  84
  85         [MethodImplAttribute (MethodImplOptions.NoInlining)]
  86         public int foo (int val) {
  87                 return val;
  88         }
  89
  90         [MethodImplAttribute (MethodImplOptions.NoInlining)]
  91         public static int static_foo (int val) {
  92                 return val;
  93         }
  94
  95         [MethodImplAttribute (MethodImplOptions.NoInlining)]
  96         public int invoke_return_int () {
  97                 return i;
  98         }
  99
 100         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 101         public static int invoke_static () {
 102                 return 5;
 103         }
 104
 105         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 106         public IntPtr invoke_return_intptr () {
 107                 return j;
 108         }
 109 }
 110
 111 public class GClass<T> {
 112         public T field;
 113         public static T static_field;
 114
 115         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 116         public GClass () {
 117         }
 118
 119         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 120         public void bp<T2> () {
 121         }
 122 }
 123
 124 public struct GStruct<T> {
 125         public T i;
 126
 127         public int j;
 128
 129         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 130         public int invoke_return_int () {
 131                 return j;
 132         }
 133 }
 134
 135 public struct NestedStruct {
 136         NestedInner nested1, nested2;
 137 }
 138
 139 public struct NestedInner {
 140 }
 141
 142 interface ITest
 143 {
 144         void Foo ();
 145         void Bar ();
 146 }
 147
 148 interface ITest<T>
 149 {
 150         void Foo ();
 151         void Bar ();
 152 }
 153
 154 class TestIfaces : ITest
 155 {
 156         void ITest.Foo () {
 157         }
 158
 159         void ITest.Bar () {
 160         }
 161
 162         TestIfaces<int> Baz () {
 163                 return null;
 164         }
 165 }
 166
 167 class TestIfaces<T> : ITest<T>
 168 {
 169         void ITest<T>.Foo () {
 170         }
 171
 172         void ITest<T>.Bar () {
 173         }
 174 }
 175
 176 public interface ITest2
 177 {
 178         int invoke_iface ();
 179 }
 180
 181 public class Tests : TestsBase, ITest2
 182 {
 183 #pragma warning disable 0414
 184         int field_i;
 185         string field_s;
 186         AnEnum field_enum;
 187         bool field_bool1, field_bool2;
 188         char field_char;
 189         byte field_byte;
 190         sbyte field_sbyte;
 191         short field_short;
 192         ushort field_ushort;
 193         long field_long;
 194         ulong field_ulong;
 195         float field_float;
 196         double field_double;
 197         Thread field_class;
 198         IntPtr field_intptr;
 199         int? field_nullable;
 200         static int static_i = 55;
 201         static string static_s = "A";
 202         public const int literal_i = 56;
 203         public const string literal_s = "B";
 204         public object child;
 205         public AStruct field_struct;
 206         public object field_boxed_struct;
 207         public GStruct<int> generic_field_struct;
 208         public KeyValuePair<int, object> boxed_struct_field;
 209         [ThreadStatic]
 210         public static int tls_i;
 211         public static bool is_attached = Debugger.IsAttached;
 212         public NestedStruct nested_struct;
 213
 214 #pragma warning restore 0414
 215
 216         public class NestedClass {
 217         }
 218
 219         public int IntProperty {
 220                 get {
 221                         return field_i;
 222                 }
 223                 set {
 224                         field_i = value;
 225                 }
 226         }
 227
 228         public int ReadOnlyProperty {
 229                 get {
 230                         return field_i;
 231                 }
 232         }
 233
 234         public int this [int index] {
 235                 get {
 236                         return field_i;
 237                 }
 238         }
 239
 240         public static void wait_one ()
 241         {
 242                 ManualResetEvent evt = new ManualResetEvent (false);
 243                 evt.WaitOne ();
 244         }
 245
 246         public static int Main (String[] args) {
 247                 tls_i = 42;
 248
 249                 if (args.Length > 0 && args [0] == "suspend-test")
 250                         /* This contains an infinite loop, so execute it conditionally */
 251                         suspend ();
 252                 if (args.Length >0 && args [0] == "unhandled-exception") {
 253                         unhandled_exception ();
 254                         return 0;
 255                 }
 256                 if (args.Length >0 && args [0] == "unhandled-exception-endinvoke") {
 257                         unhandled_exception_endinvoke ();
 258                         return 0;
 259                 }
 260                 if (args.Length >0 && args [0] == "unhandled-exception-user") {
 261                         unhandled_exception_user ();
 262                         return 0;
 263                 }
 264                 if (args.Length >0 && args [0] == "wait-one") {
 265                         wait_one ();
 266                         return 0;
 267                 }
 268                 breakpoints ();
 269                 single_stepping ();
 270                 arguments ();
 271                 objects ();
 272                 objrefs ();
 273                 vtypes ();
 274                 locals ();
 275                 line_numbers ();
 276                 type_info ();
 277                 assembly_load ();
 278                 invoke ();
 279                 exceptions ();
 280                 exception_filter ();
 281                 threads ();
 282                 dynamic_methods ();
 283                 user ();
 284                 type_load ();
 285                 regress ();
 286                 gc_suspend ();
 287                 if (args.Length > 0 && args [0] == "domain-test")
 288                         /* This takes a lot of time, so execute it conditionally */
 289                         domains ();
 290                 if (args.Length > 0 && args [0] == "ref-emit-test")
 291                         ref_emit ();
 292                 if (args.Length > 0 && args [0] == "frames-in-native")
 293                         frames_in_native ();
 294                 if (args.Length > 0 && args [0] == "invoke-single-threaded")
 295                         new Tests ().invoke_single_threaded ();
 296                 return 3;
 297         }
 298
 299         public static void breakpoints () {
 300                 /* Call these early so it is JITted by the time a breakpoint is placed on it */
 301                 bp3 ();
 302                 bp7<int> ();
 303                 bp7<string> ();
 304
 305                 bp1 ();
 306                 bp2 ();
 307                 bp3 ();
 308                 bp4 ();
 309                 bp4 ();
 310                 bp4 ();
 311                 bp5 ();
 312                 bp6<string> (new GClass <int> ());
 313                 bp7<int> ();
 314                 bp7<string> ();
 315         }
 316
 317         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 318         public static void bp1 () {
 319         }
 320
 321         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 322         public static void bp2 () {
 323         }
 324
 325         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 326         public static void bp3 () {
 327         }
 328
 329         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 330         public static void bp4 () {
 331         }
 332
 333         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 334         public static void bp5 () {
 335         }
 336
 337         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 338         public static void bp6<T> (GClass<int> gc) {
 339                 gc.bp<int> ();
 340         }
 341
 342         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 343         public static void bp7<T> () {
 344         }
 345
 346         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 347         public static void single_stepping () {
 348                 bool b = true;
 349                 ss1 ();
 350                 ss2 ();
 351                 ss3 ();
 352                 ss3_2 ();
 353                 ss4 ();
 354                 ss5 (new int [] { 1, 2, 3 }, new Func<int, bool> (is_even));
 355                 try {
 356                         ss6 (b);
 357                 } catch {
 358                 }
 359                 ss7 ();
 360                 ss_nested ();
 361                 ss_regress_654694 ();
 362         }
 363
 364         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 365         public static void ss1 () {
 366         }
 367
 368         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 369         public static void ss2 () {
 370         }
 371
 372         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 373         public static int ss3 () {
 374                 int sum = 0;
 375
 376                 for (int i = 0; i < 10; ++i)
 377                         sum += i;
 378
 379                 return sum;
 380         }
 381
 382         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 383         public static void ss3_2 () {
 384                 ss3_2_2 ();
 385         }
 386
 387         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 388         public static void ss3_2_2 () {
 389         }
 390
 391         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 392         public static int ss4 () {
 393                 ss1 (); ss1 ();
 394                 ss2 ();
 395                 return 0;
 396         }
 397
 398         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 399         public static void ss5 (int[] arr, Func<int, bool> selector) {
 400                 // Call into linq which calls back into this assembly
 401                 arr.Count (selector);
 402         }
 403
 404         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 405         public static void ss6 (bool b) {
 406                 if (b) {
 407                         ss6_2 ();
 408                         throw new Exception ();
 409                 }
 410         }
 411
 412         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 413         public static void ss6_2 () {
 414         }
 415
 416         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 417         public static void ss7 () {
 418                 try {
 419                         ss7_2 ();
 420                         ss7_3 ();
 421                 } catch {
 422                 }
 423                 ss7_2 ();
 424         }
 425
 426         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 427         public static void ss7_2 () {
 428         }
 429
 430         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 431         public static void ss7_3 () {
 432                 throw new Exception ();
 433         }
 434
 435         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 436         public static void ss_nested () {
 437                 ss_nested_1 (ss_nested_2 ());
 438                 ss_nested_1 (ss_nested_2 ());
 439                 ss_nested_3 ();
 440         }
 441
 442         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 443         public static void ss_nested_1 (int i) {
 444         }
 445
 446         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 447         public static int ss_nested_2 () {
 448                 return 0;
 449         }
 450
 451         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 452         public static void ss_nested_3 () {
 453         }
 454
 455         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 456         public static bool is_even (int i) {
 457                 return i % 2 == 0;
 458         }
 459
 460         /*
 461                 lock (static_s) {
 462                         Console.WriteLine ("HIT!");
 463                 }
 464                 return 0;
 465         }
 466         */
 467
 468         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 469         public static void arguments () {
 470                 arg1 (SByte.MaxValue - 5, Byte.MaxValue - 5, true, Int16.MaxValue - 5, UInt16.MaxValue - 5, 'F', Int32.MaxValue - 5, UInt32.MaxValue - 5, Int64.MaxValue - 5, UInt64.MaxValue - 5, 1.2345f, 6.78910, new IntPtr (Int32.MaxValue - 5), new UIntPtr (UInt32.MaxValue - 5));
 471                 int i = 42;
 472                 arg2 ("FOO", null, "BLA", ref i, new GClass <int> { field = 42 }, new object ());
 473                 Tests t = new Tests () { field_i = 42, field_s = "S" };
 474                 t.arg3 ("BLA");
 475         }
 476
 477         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 478         public static int arg1 (sbyte sb, byte b, bool bl, short s, ushort us, char c, int i, uint ui, long l, ulong ul, float f, double d, IntPtr ip, UIntPtr uip) {
 479                 return (int)(sb + b + (bl ? 0 : 1) + s + us + (int)c + i + ui + l + (long)ul + f + d + (int)ip + (int)uip);
 480         }
 481
 482         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 483         public static string arg2 (string s, string s3, object o, ref int i, GClass <int> gc, object o2) {
 484                 return s + (s3 != null ? "" : "") + o + i + gc.field + o2;
 485         }
 486
 487         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 488         public object arg3 (string s) {
 489                 return s + s + s + s + this;
 490         }
 491
 492         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 493         public static void objects () {
 494                 Tests t = new Tests () { field_i = 42, field_bool1 = true, field_bool2 = false, field_char = 'A', field_byte = 129, field_sbyte = -33, field_short = Int16.MaxValue - 5, field_ushort = UInt16.MaxValue - 5, field_long = Int64.MaxValue - 5, field_ulong = UInt64.MaxValue - 5, field_float = 3.14f, field_double = 3.14f, field_s = "S", base_field_i = 43, base_field_s = "T", field_enum = AnEnum.B, field_class = null, field_intptr = new IntPtr (Int32.MaxValue - 5), field_nullable = null };
 495                 t.o1 (new Tests2 () { field_j = 43 }, new GClass <int> { field = 42 }, new GClass <string> { field = "FOO" });
 496                 o2 (new string [] { "BAR", "BAZ" }, new int[] { 42, 43 }, new int [,] { { 1, 2 }, { 3, 4 }}, (int[,])Array.CreateInstance (typeof (int), new int [] { 2, 2}, new int [] { 1, 3}), new int[] { 0 });
 497         }
 498
 499         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 500         public object o1 (Tests2 t, GClass <int> gc1, GClass <string> gc2) {
 501                 if (t == null || gc1 == null || gc2 == null)
 502                         return null;
 503                 else
 504                         return this;
 505         }
 506
 507         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 508         public static string o2 (string[] s2, int[] s3, int[,] s4, int[,] s5, IList<int> s6) {
 509                 return s2 [0] + s3 [0] + s4 [0, 0] + s6 [0];
 510         }
 511
 512         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 513         public static void objrefs () {
 514                 Tests t = new Tests () {};
 515                 set_child (t);
 516                 t.objrefs1 ();
 517                 t.child = null;
 518                 GC.Collect ();
 519                 objrefs2 ();
 520         }
 521
 522         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 523         public static void set_child (Tests t) {
 524                 t.child = new Tests ();
 525         }
 526
 527         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 528         public void objrefs1 () {
 529         }
 530
 531         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 532         public static void objrefs2 () {
 533         }
 534
 535         public static void vtypes () {
 536                 Tests t = new Tests () { field_struct = new AStruct () { i = 42, s = "S", k = 43 }, generic_field_struct = new GStruct<int> () { i = 42 }, field_boxed_struct = new AStruct () { i = 42 }, boxed_struct_field = new KeyValuePair<int, object> (1, (long)42 ) };
 537                 AStruct s = new AStruct { i = 44, s = "T", k = 45 };
 538                 AStruct[] arr = new AStruct[] {
 539                         new AStruct () { i = 1, s = "S1" },
 540                         new AStruct () { i = 2, s = "S2" } };
 541                 t.vtypes1 (s, arr);
 542                 vtypes2 (s);
 543                 vtypes3 (s);
 544         }
 545
 546         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 547         public object vtypes1 (AStruct s, AStruct[] arr) {
 548                 if (arr != null)
 549                         return this;
 550                 else
 551                         return null;
 552         }
 553
 554         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 555         public static void vtypes2 (AStruct s) {
 556                 s.foo (5);
 557         }
 558
 559         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 560         public static void vtypes3 (AStruct s) {
 561                 AStruct.static_foo (5);
 562         }
 563
 564         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 565         public static void locals () {
 566                 string s = null;
 567                 locals1 (null);
 568                 locals2<string> (null, 5, "ABC", ref s);
 569                 locals3 ();
 570                 locals6 ();
 571                 locals7<int> (22);
 572         }
 573
 574         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 575         static void locals11 (double a, ref double b) {
 576         }
 577
 578         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 579         public static void locals1 (string[] args) {
 580                 long foo = 42;
 581
 582                 double ri = 1;
 583                 locals11 (b: ref ri, a: ri);
 584
 585                 for (int j = 0; j < 10; ++j) {
 586                         foo ++;
 587                 }
 588         }
 589
 590         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 591 #if NET_4_5
 592         [StateMachine (typeof (int))]
 593 #endif
 594         public static void locals2<T> (string[] args, int arg, T t, ref string rs) {
 595                 long i = 42;
 596                 string s = "AB";
 597
 598                 for (int j = 0; j < 10; ++j) {
 599                         if (s != null)
 600                                 i ++;
 601                         if (t != null)
 602                                 i ++;
 603                 }
 604                 rs = "A";
 605         }
 606
 607
 608         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 609         public static void locals3 () {
 610                 string s = "B";
 611                 s.ToString ();
 612
 613                 {
 614                         long i = 42;
 615                         i ++;
 616                         locals4 ();
 617                 }
 618                 {
 619                         string i = "A";
 620                         i.ToString ();
 621                         locals5 ();
 622                 }
 623                 {
 624                         long j = 42;
 625                         j ++;
 626                 }
 627         }
 628
 629         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 630         public static void locals4 () {
 631         }
 632
 633         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 634         public static void locals5 () {
 635         }
 636
 637         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 638         public static void locals6 () {
 639                 int i = 0;
 640                 int j = 0;
 641                 for (i = 0; i < 10; ++i)
 642                         j ++;
 643                 sbyte sb = 0;
 644                 for (i = 0; i < 10; ++i)
 645                         sb ++;
 646                 locals6_1 ();
 647                 locals6_2 (j);
 648                 locals6_3 ();
 649                 locals6_4 (j);
 650                 locals6_5 ();
 651                 locals6_6 (sb);
 652         }
 653
 654         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 655         public static void locals6_1 () {
 656         }
 657
 658         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 659         public static void locals6_2 (int arg) {
 660         }
 661
 662         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 663         public static void locals6_3 () {
 664                 // Clobber all registers
 665                 int sum = 0, i, j, k, l, m;
 666                 for (i = 0; i < 100; ++i)
 667                         sum ++;
 668                 for (j = 0; j < 100; ++j)
 669                         sum ++;
 670                 for (k = 0; k < 100; ++k)
 671                         sum ++;
 672                 for (l = 0; l < 100; ++l)
 673                         sum ++;
 674                 for (m = 0; m < 100; ++m)
 675                         sum ++;
 676         }
 677
 678         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 679         public static void locals6_4 (int arg) {
 680         }
 681
 682         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 683         public static void locals6_5 () {
 684         }
 685
 686         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 687         public static void locals6_6 (int arg) {
 688         }
 689
 690         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 691         public static void locals7<T> (T arg) {
 692                 T t = arg;
 693                 T t2 = t;
 694         }
 695
 696         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 697         public static void line_numbers () {
 698                 LineNumbers.ln1 ();
 699         }
 700
 701         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 702         public static void suspend () {
 703                 long i = 5;
 704
 705                 while (true) {
 706                         i ++;
 707                 }
 708         }
 709
 710         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 711         public static void type_info () {
 712                 Tests t = new Tests () { field_i = 42, field_s = "S", base_field_i = 43, base_field_s = "T", field_enum = AnEnum.B };
 713                 t.ti1 (new Tests2 () { field_j = 43 }, new GClass <int> { field = 42 }, new GClass <string> { field = "FOO" });
 714                 int val = 0;
 715                 unsafe {
 716                         AStruct s = new AStruct () { i = 42, s = "S", k = 43 };
 717
 718                         ti2 (new string [] { "BAR", "BAZ" }, new int[] { 42, 43 }, new int [,] { { 1, 2 }, { 3, 4 }}, ref val, (int*)IntPtr.Zero, 5, s, new Tests (), new Tests2 (), new GClass <int> (), AnEnum.B);
 719                 }
 720         }
 721
 722         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 723         public object ti1 (Tests2 t, GClass <int> gc1, GClass <string> gc2) {
 724                 if (t == null || gc1 == null || gc2 == null)
 725                         return null;
 726                 else
 727                         return this;
 728         }
 729
 730         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 731         public static unsafe string ti2 (string[] s2, int[] s3, int[,] s4, ref int ri, int* ptr, int i, AStruct s, Tests t, Tests2 t2, GClass<int> g, AnEnum ae) {
 732                 return s2 [0] + s3 [0] + s4 [0, 0];
 733         }
 734
 735         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 736         public static void assembly_load () {
 737                 assembly_load_2 ();
 738         }
 739
 740         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 741         public static void assembly_load_2 () {
 742                 // This will load System.dll while holding the loader lock
 743                 new Foo ();
 744         }
 745
 746         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 747         public static void invoke () {
 748                 new Tests ().invoke1 (new Tests2 (), new AStruct () { i = 42, j = (IntPtr)43 }, new GStruct<int> { j = 42 });
 749                 new Tests ().invoke_ex ();
 750         }
 751
 752         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 753         public void invoke1 (Tests2 t, AStruct s, GStruct<int> g) {
 754                 invoke2 ();
 755         }
 756
 757         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 758         public void invoke2 () {
 759         }
 760
 761         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 762         public void invoke_ex () {
 763                 invoke_ex_inner ();
 764         }
 765
 766         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 767         public void invoke_ex_inner () {
 768                 try {
 769                         throw new Exception ();
 770                 } catch {
 771                 }
 772         }
 773
 774         int counter;
 775
 776         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 777         public void invoke_single_threaded () {
 778                 // Spawn a thread incrementing a counter
 779                 bool finished = false;
 780
 781                 new Thread (delegate () {
 782                                 while (!finished)
 783                                         counter ++;
 784                 }).Start ();
 785
 786                 Thread.Sleep (100);
 787
 788                 invoke_single_threaded_2 ();
 789
 790                 finished = true;
 791         }
 792
 793         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 794         public void invoke_single_threaded_2 () {
 795         }
 796
 797         public void invoke_return_void () {
 798         }
 799
 800         public string invoke_return_ref () {
 801                 return "ABC";
 802         }
 803
 804         public object invoke_return_null () {
 805                 return null;
 806         }
 807
 808         public int invoke_return_primitive () {
 809                 return 42;
 810         }
 811
 812         public int? invoke_return_nullable () {
 813                 return 42;
 814         }
 815
 816         public int? invoke_return_nullable_null () {
 817                 return null;
 818         }
 819
 820         public void invoke_type_load () {
 821                 new Class3 ();
 822         }
 823
 824         class Class3 {
 825         }
 826
 827         public long invoke_pass_primitive (byte ub, sbyte sb, short ss, ushort us, int i, uint ui, long l, ulong ul, char c, bool b, float f, double d) {
 828                 return ub + sb + ss + us + i + ui + l + (long)ul + (int)c + (b ? 1 : 0) + (int)f + (int)d;
 829         }
 830
 831         public int invoke_pass_primitive2 (bool b) {
 832                 return b ? 1 : 0;
 833         }
 834
 835         public string invoke_pass_ref (string s) {
 836                 return s;
 837         }
 838
 839         public static string invoke_static_pass_ref (string s) {
 840                 return s;
 841         }
 842
 843         public static void invoke_static_return_void () {
 844         }
 845
 846         public static void invoke_throws () {
 847                 throw new Exception ();
 848         }
 849
 850         public int invoke_iface () {
 851                 return 42;
 852         }
 853
 854         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 855         public static void exceptions () {
 856                 try {
 857                         throw new OverflowException ();
 858                 } catch (Exception) {
 859                 }
 860                 try {
 861                         throw new OverflowException ();
 862                 } catch (Exception) {
 863                 }
 864                 try {
 865                         throw new ArgumentException ();
 866                 } catch (Exception) {
 867                 }
 868                 try {
 869                         throw new OverflowException ();
 870                 } catch (Exception) {
 871                 }
 872
 873                 object o = null;
 874                 try {
 875                         o.GetType ();
 876                 } catch (Exception) {
 877                 }
 878
 879                 try {
 880                         exceptions2 ();
 881                 } catch (Exception) {
 882                 }
 883         }
 884
 885         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 886         public static void unhandled_exception () {
 887                 ThreadPool.QueueUserWorkItem (delegate {
 888                                 throw new InvalidOperationException ();
 889                         });
 890                 Thread.Sleep (10000);
 891         }
 892
 893         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 894         public static void unhandled_exception_endinvoke_2 () {
 895         }
 896
 897         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 898         public static void unhandled_exception_endinvoke () {
 899                         Action action = new Action (() =>
 900                         {
 901                                 throw new Exception ("thrown");
 902                         });
 903                         action.BeginInvoke ((ar) => {
 904                                 try {
 905                                         action.EndInvoke (ar);
 906                                 } catch (Exception ex) {
 907                                         //Console.WriteLine (ex);
 908                                 }
 909                         }, null);
 910                 Thread.Sleep (1000);
 911                 unhandled_exception_endinvoke_2 ();
 912         }
 913
 914         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 915         public static void unhandled_exception_user () {
 916 #if NET_4_5
 917                 System.Threading.Tasks.Task.Factory.StartNew (() => {
 918                                 Throw ();
 919                         });
 920                 Thread.Sleep (10000);
 921 #endif
 922         }
 923
 924         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 925         public static void Throw () {
 926                 throw new Exception ();
 927         }
 928
 929         internal static Delegate create_filter_delegate (Delegate dlg, MethodInfo filter_method)
 930         {
 931                 if (dlg == null)
 932                         throw new ArgumentNullException ();
 933                 if (dlg.Target != null)
 934                         throw new ArgumentException ();
 935                 if (dlg.Method == null)
 936                         throw new ArgumentException ();
 937
 938                 var ret_type = dlg.Method.ReturnType;
 939                 var param_types = dlg.Method.GetParameters ().Select (x => x.ParameterType).ToArray ();
 940
 941                 var dynamic = new DynamicMethod (Guid.NewGuid ().ToString (), ret_type, param_types, typeof (object), true);
 942                 var ig = dynamic.GetILGenerator ();
 943
 944                 LocalBuilder retval = null;
 945                 if (ret_type != typeof (void))
 946                         retval = ig.DeclareLocal (ret_type);
 947
 948                 var label = ig.BeginExceptionBlock ();
 949
 950                 for (int i = 0; i < param_types.Length; i++)
 951                         ig.Emit (OpCodes.Ldarg, i);
 952                 ig.Emit (OpCodes.Call, dlg.Method);
 953
 954                 if (retval != null)
 955                         ig.Emit (OpCodes.Stloc, retval);
 956
 957                 ig.Emit (OpCodes.Leave, label);
 958
 959                 ig.BeginExceptFilterBlock ();
 960
 961                 ig.Emit (OpCodes.Call, filter_method);
 962
 963                 ig.BeginCatchBlock (null);
 964
 965                 ig.Emit (OpCodes.Pop);
 966
 967                 ig.EndExceptionBlock ();
 968
 969                 if (retval != null)
 970                         ig.Emit (OpCodes.Ldloc, retval);
 971
 972                 ig.Emit (OpCodes.Ret);
 973
 974                 return dynamic.CreateDelegate (dlg.GetType ());
 975         }
 976
 977         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 978         static void exception_filter_method () {
 979                 throw new InvalidOperationException ();
 980         }
 981
 982         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 983         static int exception_filter_filter (Exception exc) {
 984                 return 1;
 985         }
 986
 987         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 988         public static void exception_filter () {
 989                 var method = typeof (Tests).GetMethod (
 990                         "exception_filter_method", BindingFlags.NonPublic | BindingFlags.Static);
 991                 var filter_method = typeof (Tests).GetMethod (
 992                         "exception_filter_filter", BindingFlags.NonPublic | BindingFlags.Static);
 993
 994                 var dlg = Delegate.CreateDelegate (typeof (Action), method);
 995
 996                 var wrapper = (Action) create_filter_delegate (dlg, filter_method);
 997
 998                 wrapper ();
 999         }
1000
1001         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1002         public static bool return_true () {
1003                 return true;
1004         }
1005
1006         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1007         public static void exceptions2 () {
1008                 if (return_true ())
1009                         throw new Exception ();
1010                 Console.WriteLine ();
1011         }
1012
1013         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1014         public static void threads () {
1015                 Thread t = new Thread (delegate () {});
1016
1017                 t.Start ();
1018                 t.Join ();
1019         }
1020
1021         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1022         public static void domains () {
1023                 AppDomain domain = AppDomain.CreateDomain ("domain");
1024
1025                 CrossDomain o = (CrossDomain)domain.CreateInstanceAndUnwrap (
1026                                    typeof (CrossDomain).Assembly.FullName, "CrossDomain");
1027
1028                 domains_2 (o, new CrossDomain ());
1029
1030                 o.invoke_2 ();
1031
1032                 o.invoke ();
1033
1034                 o.invoke_2 ();
1035
1036                 AppDomain.Unload (domain);
1037
1038                 domains_3 ();
1039         }
1040
1041         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1042         public static void domains_2 (object o, object o2) {
1043         }
1044
1045         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1046         public static void domains_3 () {
1047         }
1048
1049         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1050         public static void invoke_in_domain () {
1051         }
1052
1053         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1054         public static void invoke_in_domain_2 () {
1055         }
1056
1057         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1058         public static void dynamic_methods () {
1059                 var m = new DynamicMethod ("dyn_method", typeof (void), new Type []  { typeof (int) }, typeof (object).Module);
1060                 var ig = m.GetILGenerator ();
1061
1062                 ig.Emit (OpCodes.Ldstr, "FOO");
1063                 ig.Emit (OpCodes.Call, typeof (Tests).GetMethod ("dyn_call"));
1064                 ig.Emit (OpCodes.Ret);
1065
1066                 var del = (Action<int>)m.CreateDelegate (typeof (Action<int>));
1067
1068                 del (0);
1069         }
1070
1071         public static void dyn_call (string s) {
1072         }
1073
1074         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1075         public static void ref_emit () {
1076                 AssemblyName assemblyName = new AssemblyName ();
1077                 assemblyName.Name = "foo";
1078
1079                 AssemblyBuilder assembly =
1080                         Thread.GetDomain ().DefineDynamicAssembly (
1081                                                                                                            assemblyName, AssemblyBuilderAccess.RunAndSave);
1082
1083                 ModuleBuilder module = assembly.DefineDynamicModule ("foo.dll");
1084
1085                 TypeBuilder tb = module.DefineType ("foo", TypeAttributes.Public, typeof (object));
1086                 MethodBuilder mb = tb.DefineMethod ("ref_emit_method", MethodAttributes.Public|MethodAttributes.Static, CallingConventions.Standard, typeof (void), new Type [] { });
1087                 ILGenerator ig = mb.GetILGenerator ();
1088                 ig.Emit (OpCodes.Ldstr, "FOO");
1089                 ig.Emit (OpCodes.Call, typeof (Tests).GetMethod ("ref_emit_call"));
1090                 ig.Emit (OpCodes.Ret);
1091
1092                 Type t = tb.CreateType ();
1093
1094                 t.GetMethod ("ref_emit_method").Invoke (null, null);
1095         }
1096
1097         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1098         public static void ref_emit_call (string s) {
1099         }
1100
1101         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1102         public static void frames_in_native () {
1103                 Thread.Sleep (500);
1104                 var evt = new ManualResetEvent (false);
1105
1106                 object mon = new object ();
1107                 ThreadPool.QueueUserWorkItem (delegate {
1108                                 frames_in_native_2 ();
1109                                 evt.Set ();
1110                         });
1111                 evt.WaitOne ();
1112         }
1113
1114         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1115         static void frames_in_native_2 () {
1116                 frames_in_native_3 ();
1117         }
1118
1119         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1120         static void frames_in_native_3 () {
1121         }
1122
1123         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1124         public static void string_call (string s) {
1125         }
1126
1127         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1128         public static void ss_regress_654694 () {
1129                 if (true) {
1130                         string h = "hi";
1131                         string_call (h);
1132                 }
1133         }
1134
1135         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1136         public static void user () {
1137                 Debugger.Break ();
1138
1139                 Debugger.Log (5, Debugger.IsLogging () ? "A" : "", "B");
1140         }
1141
1142         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1143         public static void type_load () {
1144                 type_load_2 ();
1145         }
1146
1147         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1148         static void type_load_2 () {
1149                 var c1 = new Dictionary<int, int> ();
1150                 c1.ToString ();
1151                 var c = new TypeLoadClass ();
1152                 c.ToString ();
1153                 var c2 = new TypeLoadClass2 ();
1154                 c2.ToString ();
1155         }
1156
1157         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1158         public static void regress () {
1159                 regress_2755 (DateTime.Now);
1160         }
1161
1162         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1163         public static unsafe void regress_2755 (DateTime d) {
1164                 int* buffer = stackalloc int [128];
1165
1166                 regress_2755_2 ();
1167
1168                 int sum = 0;
1169                 for (int i = 0; i < 128; ++i)
1170                         sum += buffer [i];
1171
1172                 regress_2755_3 (sum);
1173         }
1174
1175         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1176         public static void regress_2755_2 () {
1177         }
1178
1179         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1180         public static void regress_2755_3 (int sum) {
1181         }
1182
1183         static object gc_suspend_field;
1184
1185         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1186         static unsafe void set_gc_suspend_field () {
1187                 set_gc_suspend_field_2 ();
1188                 // Clear stack
1189                 int* buffer = stackalloc int [4096];
1190         }
1191
1192         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1193         static void set_gc_suspend_field_2 () {
1194                 gc_suspend_field = new object ();
1195         }
1196
1197         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1198         static void gc_suspend_1 () {
1199         }
1200
1201         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1202         public static void gc_suspend_invoke () {
1203                 gc_suspend_field = null;
1204                 GC.Collect ();
1205                 GC.WaitForPendingFinalizers ();
1206         }
1207
1208         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1209         public static void gc_suspend () {
1210                 set_gc_suspend_field ();
1211                 gc_suspend_1 ();
1212         }
1213
1214         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1215         public static void generic_method<T> () where T : class {
1216         }
1217 }
1218
1219 class TypeLoadClass {
1220 }
1221
1222 class TypeLoadClass2 {
1223 }
1224
1225 public class CrossDomain : MarshalByRefObject
1226 {
1227         public void invoke () {
1228                 Tests.invoke_in_domain ();
1229         }
1230
1231         public void invoke_2 () {
1232                 Tests.invoke_in_domain_2 ();
1233         }
1234
1235         public int invoke_3 () {
1236                 return 42;
1237         }
1238 }
1239
1240 public class Foo
1241 {
1242         public ProcessStartInfo info;
1243 }
1244
1245 // Class used for line number info testing, don't change its layout
1246 public class LineNumbers
1247 {
1248         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1249         public static void ln1 () {
1250                 // Column 3
1251                 ln2 ();
1252                 ln3 ();
1253         }
1254
1255         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1256         public static void ln2 () {
1257         }
1258
1259         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1260         public static void ln3 () {
1261 #pragma warning disable 0219
1262                 int i = 5;
1263 #pragma warning restore 0219
1264                 #line 55 "FOO"
1265         }
1266 }