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                 TypedReference typedref = __makeref (s);
 641                 t.vtypes1 (s, arr, typedref);
 642                 vtypes2 (s);
 643                 vtypes3 (s);
 644                 vtypes4 ();
 645         }
 646
 647         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 648         public object vtypes1 (AStruct s, AStruct[] arr, TypedReference typedref) {
 649                 if (arr != null)
 650                         return this;
 651                 else
 652                         return null;
 653         }
 654
 655         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 656         public static void vtypes2 (AStruct s) {
 657                 s.foo (5);
 658         }
 659
 660         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 661         public static void vtypes3 (AStruct s) {
 662                 AStruct.static_foo (5);
 663         }
 664
 665         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 666         public static void vtypes4_2 (IRecStruct o) {
 667         }
 668
 669         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 670         public static void vtypes4 () {
 671                 IRecStruct s = new RecStruct ();
 672                 s.foo (s);
 673                 vtypes4_2 (s);
 674         }
 675
 676         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 677         public static void locals () {
 678                 string s = null;
 679                 var astruct = new AStruct () { i = 42 };
 680                 locals1 (null);
 681                 locals2<string> (null, 5, "ABC", ref s, ref astruct);
 682                 locals3 ();
 683                 locals6 ();
 684                 locals7<int> (22);
 685         }
 686
 687         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 688         static void locals11 (double a, ref double b) {
 689         }
 690
 691         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 692         public static void locals1 (string[] args) {
 693                 long foo = 42;
 694
 695                 double ri = 1;
 696                 locals11 (b: ref ri, a: ri);
 697
 698                 for (int j = 0; j < 10; ++j) {
 699                         foo ++;
 700                 }
 701         }
 702
 703         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 704 #if NET_4_5
 705         [StateMachine (typeof (int))]
 706 #endif
 707         public static void locals2<T> (string[] args, int arg, T t, ref string rs, ref AStruct astruct) {
 708                 long i = 42;
 709                 string s = "AB";
 710
 711                 for (int j = 0; j < 10; ++j) {
 712                         if (s != null)
 713                                 i ++;
 714                         if (t != null)
 715                                 i ++;
 716                         astruct = new AStruct ();
 717                 }
 718                 rs = "A";
 719         }
 720
 721
 722         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 723         public static void locals3 () {
 724                 string s = "B";
 725                 s.ToString ();
 726
 727                 {
 728                         long i = 42;
 729                         i ++;
 730                         locals4 ();
 731                 }
 732                 {
 733                         string i = "A";
 734                         i.ToString ();
 735                         locals5 ();
 736                 }
 737                 {
 738                         long j = 42;
 739                         j ++;
 740                 }
 741         }
 742
 743         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 744         public static void locals4 () {
 745         }
 746
 747         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 748         public static void locals5 () {
 749         }
 750
 751         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 752         public static void locals6 () {
 753                 int i = 0;
 754                 int j = 0;
 755                 for (i = 0; i < 10; ++i)
 756                         j ++;
 757                 sbyte sb = 0;
 758                 for (i = 0; i < 10; ++i)
 759                         sb ++;
 760                 locals6_1 ();
 761                 locals6_2 (j);
 762                 locals6_3 ();
 763                 locals6_4 (j);
 764                 locals6_5 ();
 765                 locals6_6 (sb);
 766         }
 767
 768         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 769         public static void locals6_1 () {
 770         }
 771
 772         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 773         public static void locals6_2 (int arg) {
 774         }
 775
 776         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 777         public static void locals6_3 () {
 778                 // Clobber all registers
 779                 int sum = 0, i, j, k, l, m;
 780                 for (i = 0; i < 100; ++i)
 781                         sum ++;
 782                 for (j = 0; j < 100; ++j)
 783                         sum ++;
 784                 for (k = 0; k < 100; ++k)
 785                         sum ++;
 786                 for (l = 0; l < 100; ++l)
 787                         sum ++;
 788                 for (m = 0; m < 100; ++m)
 789                         sum ++;
 790         }
 791
 792         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 793         public static void locals6_4 (int arg) {
 794         }
 795
 796         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 797         public static void locals6_5 () {
 798         }
 799
 800         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 801         public static void locals6_6 (int arg) {
 802         }
 803
 804         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 805         public static void locals7<T> (T arg) {
 806                 T t = arg;
 807                 T t2 = t;
 808         }
 809
 810         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 811         public static void line_numbers () {
 812                 LineNumbers.ln1 ();
 813         }
 814
 815         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 816         public static void suspend () {
 817                 long i = 5;
 818
 819                 while (true) {
 820                         i ++;
 821                 }
 822         }
 823
 824         struct TypedRefTest {
 825                 public int MaxValue;
 826         }
 827
 828         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 829         public static void type_info () {
 830                 Tests t = new Tests () { field_i = 42, field_s = "S", base_field_i = 43, base_field_s = "T", field_enum = AnEnum.B };
 831                 t.ti1 (new Tests2 () { field_j = 43 }, new GClass <int> { field = 42 }, new GClass <string> { field = "FOO" });
 832                 int val = 0;
 833                 unsafe {
 834                         AStruct s = new AStruct () { i = 42, s = "S", k = 43 };
 835                         TypedRefTest reftest = new TypedRefTest () { MaxValue = 12 };
 836                         TypedReference typedref = __makeref (reftest);
 837                         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, typedref);
 838                 }
 839         }
 840
 841         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 842         public object ti1 (Tests2 t, GClass <int> gc1, GClass <string> gc2) {
 843                 if (t == null || gc1 == null || gc2 == null)
 844                         return null;
 845                 else
 846                         return this;
 847         }
 848
 849         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 850         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, TypedReference typedref) {
 851                 return s2 [0] + s3 [0] + s4 [0, 0];
 852         }
 853
 854         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 855         public static void assembly_load () {
 856                 assembly_load_2 ();
 857         }
 858
 859         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 860         public static void assembly_load_2 () {
 861                 // This will load System.dll while holding the loader lock
 862                 new Foo ();
 863         }
 864
 865         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 866         public static void invoke () {
 867                 new Tests ().invoke1 (new Tests2 (), new AStruct () { i = 42, j = (IntPtr)43 }, new GStruct<int> { j = 42 });
 868                 new Tests ().invoke_ex ();
 869         }
 870
 871         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 872         public void invoke1 (Tests2 t, AStruct s, GStruct<int> g) {
 873                 invoke2 ();
 874         }
 875
 876         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 877         public void invoke2 () {
 878         }
 879
 880         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 881         public void invoke_ex () {
 882                 invoke_ex_inner ();
 883         }
 884
 885         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 886         public void invoke_ex_inner () {
 887                 try {
 888                         throw new Exception ();
 889                 } catch {
 890                 }
 891         }
 892
 893         int counter;
 894
 895         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 896         public void invoke_single_threaded () {
 897                 // Spawn a thread incrementing a counter
 898                 bool finished = false;
 899
 900                 new Thread (delegate () {
 901                                 while (!finished)
 902                                         counter ++;
 903                 }).Start ();
 904
 905                 Thread.Sleep (100);
 906
 907                 invoke_single_threaded_2 ();
 908
 909                 finished = true;
 910         }
 911
 912         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 913         public void invoke_single_threaded_2 () {
 914         }
 915
 916         public void invoke_return_void () {
 917         }
 918
 919         public string invoke_return_ref () {
 920                 return "ABC";
 921         }
 922
 923         public object invoke_return_null () {
 924                 return null;
 925         }
 926
 927         public int invoke_return_primitive () {
 928                 return 42;
 929         }
 930
 931         public int? invoke_return_nullable () {
 932                 return 42;
 933         }
 934
 935         public int? invoke_return_nullable_null () {
 936                 return null;
 937         }
 938
 939         public void invoke_type_load () {
 940                 new Class3 ();
 941         }
 942
 943         class Class3 {
 944         }
 945
 946         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) {
 947                 return ub + sb + ss + us + i + ui + l + (long)ul + (int)c + (b ? 1 : 0) + (int)f + (int)d;
 948         }
 949
 950         public int invoke_pass_primitive2 (bool b) {
 951                 return b ? 1 : 0;
 952         }
 953
 954         public string invoke_pass_ref (string s) {
 955                 return s;
 956         }
 957
 958         public static string invoke_static_pass_ref (string s) {
 959                 return s;
 960         }
 961
 962         public static void invoke_static_return_void () {
 963         }
 964
 965         public static void invoke_throws () {
 966                 throw new Exception ();
 967         }
 968
 969         public int invoke_iface () {
 970                 return 42;
 971         }
 972
 973         public void invoke_out (out int foo, out int[] arr) {
 974                 foo = 5;
 975                 arr = new int [10];
 976         }
 977
 978         [MethodImplAttribute (MethodImplOptions.NoInlining)]
 979         public static void exceptions () {
 980                 try {
 981                         throw new OverflowException ();
 982                 } catch (Exception) {
 983                 }
 984                 try {
 985                         throw new OverflowException ();
 986                 } catch (Exception) {
 987                 }
 988                 try {
 989                         throw new ArgumentException ();
 990                 } catch (Exception) {
 991                 }
 992                 try {
 993                         throw new OverflowException ();
 994                 } catch (Exception) {
 995                 }
 996                 // no subclasses
 997                 try {
 998                         throw new OverflowException ();
 999                 } catch (Exception) {
1000                 }
1001                 try {
1002                         throw new Exception ();
1003                 } catch (Exception) {
1004                 }
1005
1006                 object o = null;
1007                 try {
1008                         o.GetType ();
1009                 } catch (Exception) {
1010                 }
1011
1012                 try {
1013                         exceptions2 ();
1014                 } catch (Exception) {
1015                 }
1016         }
1017
1018         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1019         public static void unhandled_exception () {
1020                 ThreadPool.QueueUserWorkItem (delegate {
1021                                 throw new InvalidOperationException ();
1022                         });
1023                 Thread.Sleep (10000);
1024         }
1025
1026         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1027         public static void unhandled_exception_endinvoke_2 () {
1028         }
1029
1030         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1031         public static void unhandled_exception_endinvoke () {
1032                         Action action = new Action (() =>
1033                         {
1034                                 throw new Exception ("thrown");
1035                         });
1036                         action.BeginInvoke ((ar) => {
1037                                 try {
1038                                         action.EndInvoke (ar);
1039                                 } catch (Exception ex) {
1040                                         //Console.WriteLine (ex);
1041                                 }
1042                         }, null);
1043                 Thread.Sleep (1000);
1044                 unhandled_exception_endinvoke_2 ();
1045         }
1046
1047         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1048         public static void unhandled_exception_user () {
1049 #if NET_4_5
1050                 System.Threading.Tasks.Task.Factory.StartNew (() => {
1051                                 Throw ();
1052                         });
1053                 Thread.Sleep (10000);
1054 #endif
1055         }
1056
1057         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1058         public static void Throw () {
1059                 throw new Exception ();
1060         }
1061
1062         internal static Delegate create_filter_delegate (Delegate dlg, MethodInfo filter_method)
1063         {
1064                 if (dlg == null)
1065                         throw new ArgumentNullException ();
1066                 if (dlg.Target != null)
1067                         throw new ArgumentException ();
1068                 if (dlg.Method == null)
1069                         throw new ArgumentException ();
1070
1071                 var ret_type = dlg.Method.ReturnType;
1072                 var param_types = dlg.Method.GetParameters ().Select (x => x.ParameterType).ToArray ();
1073
1074                 var dynamic = new DynamicMethod (Guid.NewGuid ().ToString (), ret_type, param_types, typeof (object), true);
1075                 var ig = dynamic.GetILGenerator ();
1076
1077                 LocalBuilder retval = null;
1078                 if (ret_type != typeof (void))
1079                         retval = ig.DeclareLocal (ret_type);
1080
1081                 var label = ig.BeginExceptionBlock ();
1082
1083                 for (int i = 0; i < param_types.Length; i++)
1084                         ig.Emit (OpCodes.Ldarg, i);
1085                 ig.Emit (OpCodes.Call, dlg.Method);
1086
1087                 if (retval != null)
1088                         ig.Emit (OpCodes.Stloc, retval);
1089
1090                 ig.Emit (OpCodes.Leave, label);
1091
1092                 ig.BeginExceptFilterBlock ();
1093
1094                 ig.Emit (OpCodes.Call, filter_method);
1095
1096                 ig.BeginCatchBlock (null);
1097
1098                 ig.Emit (OpCodes.Pop);
1099
1100                 ig.EndExceptionBlock ();
1101
1102                 if (retval != null)
1103                         ig.Emit (OpCodes.Ldloc, retval);
1104
1105                 ig.Emit (OpCodes.Ret);
1106
1107                 return dynamic.CreateDelegate (dlg.GetType ());
1108         }
1109
1110         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1111         static void exception_filter_method () {
1112                 throw new InvalidOperationException ();
1113         }
1114
1115         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1116         static int exception_filter_filter (Exception exc) {
1117                 return 1;
1118         }
1119
1120         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1121         public static void exception_filter () {
1122                 var method = typeof (Tests).GetMethod (
1123                         "exception_filter_method", BindingFlags.NonPublic | BindingFlags.Static);
1124                 var filter_method = typeof (Tests).GetMethod (
1125                         "exception_filter_filter", BindingFlags.NonPublic | BindingFlags.Static);
1126
1127                 var dlg = Delegate.CreateDelegate (typeof (Action), method);
1128
1129                 var wrapper = (Action) create_filter_delegate (dlg, filter_method);
1130
1131                 wrapper ();
1132         }
1133
1134         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1135         public static bool return_true () {
1136                 return true;
1137         }
1138
1139         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1140         public static void exceptions2 () {
1141                 if (return_true ())
1142                         throw new Exception ();
1143                 Console.WriteLine ();
1144         }
1145
1146         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1147         public static void threads () {
1148                 Thread t = new Thread (delegate () {});
1149
1150                 t.Start ();
1151                 t.Join ();
1152         }
1153
1154         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1155         public static void domains () {
1156                 AppDomain domain = AppDomain.CreateDomain ("domain");
1157
1158                 CrossDomain o = (CrossDomain)domain.CreateInstanceAndUnwrap (
1159                                    typeof (CrossDomain).Assembly.FullName, "CrossDomain");
1160
1161                 domains_2 (o, new CrossDomain ());
1162
1163                 o.invoke_2 ();
1164
1165                 o.invoke ();
1166
1167                 o.invoke_2 ();
1168
1169                 AppDomain.Unload (domain);
1170
1171                 domains_3 ();
1172
1173                 typeof (Tests).GetMethod ("called_from_invoke").Invoke (null, null);
1174         }
1175
1176         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1177         public static void called_from_invoke () {
1178         }
1179
1180         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1181         public static void domains_2 (object o, object o2) {
1182         }
1183
1184         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1185         public static void domains_3 () {
1186         }
1187
1188         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1189         public static void invoke_in_domain () {
1190         }
1191
1192         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1193         public static void invoke_in_domain_2 () {
1194         }
1195
1196         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1197         public static void dynamic_methods () {
1198                 var m = new DynamicMethod ("dyn_method", typeof (void), new Type []  { typeof (int) }, typeof (object).Module);
1199                 var ig = m.GetILGenerator ();
1200
1201                 ig.Emit (OpCodes.Ldstr, "FOO");
1202                 ig.Emit (OpCodes.Call, typeof (Tests).GetMethod ("dyn_call"));
1203                 ig.Emit (OpCodes.Ret);
1204
1205                 var del = (Action<int>)m.CreateDelegate (typeof (Action<int>));
1206
1207                 del (0);
1208         }
1209
1210         public static void dyn_call (string s) {
1211         }
1212
1213         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1214         public static void ref_emit () {
1215                 AssemblyName assemblyName = new AssemblyName ();
1216                 assemblyName.Name = "foo";
1217
1218                 AssemblyBuilder assembly =
1219                         Thread.GetDomain ().DefineDynamicAssembly (
1220                                                                                                            assemblyName, AssemblyBuilderAccess.RunAndSave);
1221
1222                 ModuleBuilder module = assembly.DefineDynamicModule ("foo.dll");
1223
1224                 TypeBuilder tb = module.DefineType ("foo", TypeAttributes.Public, typeof (object));
1225                 MethodBuilder mb = tb.DefineMethod ("ref_emit_method", MethodAttributes.Public|MethodAttributes.Static, CallingConventions.Standard, typeof (void), new Type [] { });
1226                 ILGenerator ig = mb.GetILGenerator ();
1227                 ig.Emit (OpCodes.Ldstr, "FOO");
1228                 ig.Emit (OpCodes.Call, typeof (Tests).GetMethod ("ref_emit_call"));
1229                 ig.Emit (OpCodes.Ret);
1230
1231                 Type t = tb.CreateType ();
1232
1233                 t.GetMethod ("ref_emit_method").Invoke (null, null);
1234         }
1235
1236         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1237         public static void ref_emit_call (string s) {
1238         }
1239
1240         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1241         public static void frames_in_native () {
1242                 Thread.Sleep (500);
1243                 var evt = new ManualResetEvent (false);
1244
1245                 object mon = new object ();
1246                 ThreadPool.QueueUserWorkItem (delegate {
1247                                 frames_in_native_2 ();
1248                                 evt.Set ();
1249                         });
1250                 evt.WaitOne ();
1251         }
1252
1253         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1254         static void frames_in_native_2 () {
1255                 frames_in_native_3 ();
1256         }
1257
1258         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1259         static void frames_in_native_3 () {
1260         }
1261
1262         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1263         public static void string_call (string s) {
1264         }
1265
1266         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1267         public static void ss_regress_654694 () {
1268                 if (true) {
1269                         string h = "hi";
1270                         string_call (h);
1271                 }
1272         }
1273
1274         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1275         public static void user () {
1276                 Debugger.Break ();
1277
1278                 Debugger.Log (5, Debugger.IsLogging () ? "A" : "", "B");
1279         }
1280
1281         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1282         public static void type_load () {
1283                 type_load_2 ();
1284         }
1285
1286         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1287         static void type_load_2 () {
1288                 var c1 = new Dictionary<int, int> ();
1289                 c1.ToString ();
1290                 var c = new TypeLoadClass ();
1291                 c.ToString ();
1292                 var c2 = new TypeLoadClass2 ();
1293                 c2.ToString ();
1294         }
1295
1296         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1297         public static void regress () {
1298                 regress_2755 (DateTime.Now);
1299         }
1300
1301         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1302         public static unsafe void regress_2755 (DateTime d) {
1303                 int* buffer = stackalloc int [128];
1304
1305                 regress_2755_2 ();
1306
1307                 int sum = 0;
1308                 for (int i = 0; i < 128; ++i)
1309                         sum += buffer [i];
1310
1311                 regress_2755_3 (sum);
1312         }
1313
1314         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1315         public static void regress_2755_2 () {
1316         }
1317
1318         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1319         public static void regress_2755_3 (int sum) {
1320         }
1321
1322         static object gc_suspend_field;
1323
1324         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1325         static unsafe void set_gc_suspend_field () {
1326                 set_gc_suspend_field_2 ();
1327                 // Clear stack
1328                 int* buffer = stackalloc int [4096];
1329         }
1330
1331         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1332         static void set_gc_suspend_field_2 () {
1333                 gc_suspend_field = new object ();
1334         }
1335
1336         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1337         static void gc_suspend_1 () {
1338         }
1339
1340         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1341         public static void gc_suspend_invoke () {
1342                 gc_suspend_field = null;
1343                 GC.Collect ();
1344                 GC.WaitForPendingFinalizers ();
1345         }
1346
1347         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1348         public static void gc_suspend () {
1349                 set_gc_suspend_field ();
1350                 gc_suspend_1 ();
1351         }
1352
1353         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1354         public static void generic_method<T> () where T : class {
1355         }
1356
1357         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1358         public void evaluate_method_2 () {
1359         }
1360
1361         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1362         public void evaluate_method () {
1363                 field_i = 42;
1364                 evaluate_method_2 ();
1365         }
1366
1367         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1368         static void set_ip_1 () {
1369         }
1370
1371         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1372         static void set_ip_2 () {
1373         }
1374
1375         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1376         public static void set_ip () {
1377                 int i = 0, j;
1378
1379                 i ++;
1380                 i ++;
1381                 set_ip_1 ();
1382                 i ++;
1383                 j = 5;
1384                 set_ip_2 ();
1385         }
1386
1387         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1388         public static void step_filters () {
1389                 ClassWithCctor.cctor_filter ();
1390         }
1391
1392         class ClassWithCctor {
1393                 [MethodImplAttribute (MethodImplOptions.NoInlining)]
1394                 static ClassWithCctor () {
1395                         int i = 1;
1396                         int j = 2;
1397                 }
1398
1399                 [MethodImplAttribute (MethodImplOptions.NoInlining)]
1400                 public static void cctor_filter () {
1401                 }
1402         }
1403
1404         public override string virtual_method () {
1405                 return "V2";
1406         }
1407 }
1408
1409 class TypeLoadClass {
1410 }
1411
1412 class TypeLoadClass2 {
1413 }
1414
1415 public class CrossDomain : MarshalByRefObject
1416 {
1417         public void invoke () {
1418                 Tests.invoke_in_domain ();
1419         }
1420
1421         public void invoke_2 () {
1422                 Tests.invoke_in_domain_2 ();
1423         }
1424
1425         public int invoke_3 () {
1426                 return 42;
1427         }
1428 }
1429
1430 public class Foo
1431 {
1432         public ProcessStartInfo info;
1433 }
1434
1435 // Class used for line number info testing, don't change its layout
1436 public class LineNumbers
1437 {
1438         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1439         public static void ln1 () {
1440                 // Column 3
1441                 ln2 ();
1442                 ln3 ();
1443         }
1444
1445         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1446         public static void ln2 () {
1447         }
1448
1449         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1450         public static void ln3 () {
1451 #pragma warning disable 0219
1452                 int i = 5;
1453 #pragma warning restore 0219
1454                 #line 55 "FOO"
1455         }
1456 }