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