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

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