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