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