From fdaf97e3ac1eaa0d44bdb8456efb346c5ef0019e Mon Sep 17 00:00:00 2001 From: Jakob Botsch Nielsen Date: Wed, 25 Sep 2019 14:54:21 -0700 Subject: [PATCH] Various tailcall test improvements (dotnet/coreclr#26818) * Remove some illegal tailcall tests These tests pass address of local stack frame to tail. prefixed calls. * Add some more tailcall tests * Tail calls to functions with small return values * Tail calls to functions with retbuf * Tail calls to functions with multi-reg returned structs * Tail calls to functions with void returns * Tail calls to abstract methods * Tail calls to interface methods * tail. calli sequences * Tail calls to struct instance methods * Tail calls involving refs * Tail calls involving byrefs * Tail calls involving generics * Improve tailcall hijacking test * Force this test to use helper on AMD64 too * Instead of 3 tailcallers and 1 collector, just use 1 collector and 1 tailcaller. Additionally, run it for only 30 iterations of 1 second sleeps. This should allow it to run for AMD64 and ARM32 in CI too. * Clarify some reasons for some disabled tests * Disable new test on everything except x86 Windows * Add another arg to TailHelper2 to ensure helper-based tailcall on SysV * Disable hijacking test on anything except x86/x64 Windows * Update more tailcalls test and add source file * Pinvoke printf for Unix in TailcallVerifyWithPrefix test * Clean up TailcallVerifyWithPrefix test Remove commented tests and tests that do not run from this file * Clean up reasons for disabling TailcallVerifyWithPrefix * Update a reason * Remove more dead code in TailcallVerifyWithPrefix.il * Fix wrong IL in TailcallVerifyWithPrefix test * Add a comment describing more_tailcalls.cs * Clarify issue number Commit migrated from https://github.com/dotnet/coreclr/commit/2468ce3d56071290a8ac13d6970783dd56975330 --- src/coreclr/tests/issues.targets | 31 +- .../JIT/Directed/tailcall/more_tailcalls.cs | 1002 ++ .../JIT/Directed/tailcall/more_tailcalls.il | 3487 +++++++ .../tailcall/more_tailcalls.ilproj} | 2 +- .../JIT/Methodical/tailcall_v4/hijacking.il | 28 +- .../JIT/Methodical/tailcall_v4/tailcall_AV.il | 203 - .../JIT/jit64/localloc/call/call03_dynamic.il | 223 - .../jit64/localloc/call/call03_dynamic.ilproj | 16 - .../JIT/jit64/localloc/call/call03_large.il | 223 - .../jit64/localloc/call/call03_large.ilproj | 16 - .../JIT/jit64/localloc/call/call03_small.il | 224 - .../jit64/localloc/call/call03_small.ilproj | 16 - .../JIT/jit64/localloc/call/call04_dynamic.il | 242 - .../jit64/localloc/call/call04_dynamic.ilproj | 15 - .../JIT/jit64/localloc/call/call04_large.il | 242 - .../jit64/localloc/call/call04_large.ilproj | 15 - .../JIT/jit64/localloc/call/call04_small.il | 260 - .../jit64/localloc/call/call04_small.ilproj | 15 - .../JIT/jit64/localloc/call/call06_dynamic.il | 287 - .../jit64/localloc/call/call06_dynamic.ilproj | 16 - .../JIT/jit64/localloc/call/call06_large.il | 287 - .../jit64/localloc/call/call06_large.ilproj | 16 - .../JIT/jit64/localloc/call/call06_small.il | 287 - .../jit64/localloc/call/call06_small.ilproj | 16 - .../opt/Tailcall/TailcallVerifyWithPrefix.il | 8960 ++++++----------- 25 files changed, 7404 insertions(+), 8725 deletions(-) create mode 100644 src/coreclr/tests/src/JIT/Directed/tailcall/more_tailcalls.cs create mode 100644 src/coreclr/tests/src/JIT/Directed/tailcall/more_tailcalls.il rename src/coreclr/tests/src/JIT/{Methodical/tailcall_v4/tailcall_AV.ilproj => Directed/tailcall/more_tailcalls.ilproj} (83%) delete mode 100644 src/coreclr/tests/src/JIT/Methodical/tailcall_v4/tailcall_AV.il delete mode 100644 src/coreclr/tests/src/JIT/jit64/localloc/call/call03_dynamic.il delete mode 100644 src/coreclr/tests/src/JIT/jit64/localloc/call/call03_dynamic.ilproj delete mode 100644 src/coreclr/tests/src/JIT/jit64/localloc/call/call03_large.il delete mode 100644 src/coreclr/tests/src/JIT/jit64/localloc/call/call03_large.ilproj delete mode 100644 src/coreclr/tests/src/JIT/jit64/localloc/call/call03_small.il delete mode 100644 src/coreclr/tests/src/JIT/jit64/localloc/call/call03_small.ilproj delete mode 100644 src/coreclr/tests/src/JIT/jit64/localloc/call/call04_dynamic.il delete mode 100644 src/coreclr/tests/src/JIT/jit64/localloc/call/call04_dynamic.ilproj delete mode 100644 src/coreclr/tests/src/JIT/jit64/localloc/call/call04_large.il delete mode 100644 src/coreclr/tests/src/JIT/jit64/localloc/call/call04_large.ilproj delete mode 100644 src/coreclr/tests/src/JIT/jit64/localloc/call/call04_small.il delete mode 100644 src/coreclr/tests/src/JIT/jit64/localloc/call/call04_small.ilproj delete mode 100644 src/coreclr/tests/src/JIT/jit64/localloc/call/call06_dynamic.il delete mode 100644 src/coreclr/tests/src/JIT/jit64/localloc/call/call06_dynamic.ilproj delete mode 100644 src/coreclr/tests/src/JIT/jit64/localloc/call/call06_large.il delete mode 100644 src/coreclr/tests/src/JIT/jit64/localloc/call/call06_large.ilproj delete mode 100644 src/coreclr/tests/src/JIT/jit64/localloc/call/call06_small.il delete mode 100644 src/coreclr/tests/src/JIT/jit64/localloc/call/call06_small.ilproj diff --git a/src/coreclr/tests/issues.targets b/src/coreclr/tests/issues.targets index c877455a18b..1277308a0b4 100644 --- a/src/coreclr/tests/issues.targets +++ b/src/coreclr/tests/issues.targets @@ -78,6 +78,9 @@ 23124 + + Unix does not support tailcall helper + @@ -88,9 +91,6 @@ needs triage - - needs triage - needs triage @@ -194,10 +194,7 @@ times out - Uses illagal il tailcall pop ret - - - 13828 + Depends on implicit tailcalls to be performed Needs triage @@ -227,14 +224,17 @@ Needs Triage - Unix doesn't support slow tail calls #2556, arm32 doesn't support fast tail calls #13828. + arm32 does not support implicit tailcalls (#13828) - Unix doesn't support slow tail calls #2556, arm32 doesn't support fast tail calls #13828. + arm32 does not support implicit tailcalls (#13828) 26105 + + arm32 does not support tailcall helper + @@ -278,6 +278,9 @@ 23124 + + arm64 does not support tailcall helper + @@ -314,7 +317,7 @@ 3392, test is useful to have because it can be run manually when making changes to the GC that can have effects in OOM scenarios, but not appropriate to run on our current test infrastructure. - 2420. x86 JIT doesn't support implicit tail call optimization or tail. call pop ret sequence + Depends on implicit tailcalls to be performed 11469, The test causes OutOfMemory exception in crossgen mode. @@ -542,7 +545,7 @@ 15016 - Uses illagal il tailcall pop ret + Requires helper-based tailcalls 9565 @@ -891,6 +894,12 @@ + + + + x64 Windows has bugs with helper-based tailcall to VSD (#26311); rest of platforms do not support it + + diff --git a/src/coreclr/tests/src/JIT/Directed/tailcall/more_tailcalls.cs b/src/coreclr/tests/src/JIT/Directed/tailcall/more_tailcalls.cs new file mode 100644 index 00000000000..eb14de91b06 --- /dev/null +++ b/src/coreclr/tests/src/JIT/Directed/tailcall/more_tailcalls.cs @@ -0,0 +1,1002 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +// Note: This test file is the source of the more_tailcalls.il file. It requires +// InlineIL.Fody to compile. It is not used as anything but a reference of that +// IL file. + +using InlineIL; +using System; +using System.Diagnostics; +using System.Reflection; +using System.Runtime.CompilerServices; + +struct S16 +{ + public long A, B; + public override string ToString() => $"{A}, {B}"; +} +struct S32 +{ + public long A, B, C, D; + public override string ToString() => $"{A}, {B}, {C}, {D}"; +} +struct SGC +{ + public object A; + public object B; + public string C; + public string D; + public override string ToString() => $"{A}, {B}, {C}, {D}"; +} +struct SGC2 +{ + public int A; + public SGC B; + public object C; + public int D; + public override string ToString() => $"{A}, ({B}), {C}, {D}"; +} +class HeapInt +{ + public int Value; + public HeapInt(int val) => Value = val; + public override string ToString() => $"{Value}"; +} + +internal class Program +{ + private static readonly IntPtr s_calcStaticCalli; + private static readonly IntPtr s_calcStaticCalliOther; + private static readonly IntPtr s_calcStaticCalliRetbuf; + private static readonly IntPtr s_calcStaticCalliRetbufOther; + + static Program() + { + IL.Emit.Ldftn(new MethodRef(typeof(Program), nameof(CalcStaticCalli))); + IL.Pop(out IntPtr calcStaticCalli); + IL.Emit.Ldftn(new MethodRef(typeof(Program), nameof(CalcStaticCalliOther))); + IL.Pop(out IntPtr calcStaticCalliOther); + IL.Emit.Ldftn(new MethodRef(typeof(Program), nameof(CalcStaticCalliRetbuf))); + IL.Pop(out IntPtr calcStaticCalliRetbuf); + IL.Emit.Ldftn(new MethodRef(typeof(Program), nameof(CalcStaticCalliRetbufOther))); + IL.Pop(out IntPtr calcStaticCalliRetbufOther); + + s_calcStaticCalli = calcStaticCalli; + s_calcStaticCalliOther = calcStaticCalliOther; + s_calcStaticCalliRetbuf = calcStaticCalliRetbuf; + s_calcStaticCalliRetbufOther = calcStaticCalliRetbufOther; + } + + private static int Main() + { + const int numCalcIters = 1000000; + const int countUpIters = 1000000; + + int x = numCalcIters; + S32 s = default; + int expected = 0; + + while (x != 0) + { + if (x % 2 == 0) + s = default; + + Calc(ref x, ref s, ref expected); + } + + bool result = true; + void Test(Func f, T expected, string name) + { + Console.Write("{0}: ", name); + Stopwatch timer = Stopwatch.StartNew(); + T val = f(); + timer.Stop(); + if (val.Equals(expected)) + { + Console.WriteLine("OK in {1} ms", name, timer.ElapsedMilliseconds); + return; + } + + Console.WriteLine("FAIL (expected {1}, got {2})", name, expected, val); + result = false; + } + + void TestCalc(Func f, T expected, string name) + => Test(() => f(numCalcIters, 0), expected, name); + + ClassImpl c = new ClassImpl(); + c.Other = c; + + InterfaceImpl i = new InterfaceImpl(); + i.Other = i; + + GenInstance g = new GenInstance(); + IGenInterface ig = new GenInterfaceImpl(); + IGenInterface ig2 = new GenInterfaceImpl(); + + long expectedI8 = (long)(((ulong)(uint)expected << 32) | (uint)expected); + S16 expectedS16 = new S16 { A = expected, B = expected, }; + S32 expectedS32 = new S32 { A = expected, B = expected, C = expected, D = expected, }; + int ten = 10; + + TestCalc(CalcStatic, expected, "Static non-generic"); + TestCalc(CalcStaticSmall, (byte)expected, "Static non-generic small"); + TestCalc(CalcStaticRetbuf, expectedS32, "Static non-generic retbuf"); + TestCalc(CalcStaticLong, expectedI8, "Static non-generic long"); + TestCalc(CalcStaticS16, expectedS16, "Static non-generic S16"); + TestCalc((x, s) => {CalcStaticVoid(x, s); return s_result;}, expected, "Static void"); + TestCalc(new Instance().CalcInstance, expected, "Instance non-generic"); + TestCalc(new Instance().CalcInstanceRetbuf, expectedS32, "Instance non-generic retbuf"); + TestCalc(c.CalcAbstract, expected, "Abstract class non-generic"); + TestCalc(c.CalcAbstractRetbuf, expectedS32, "Abstract class non-generic retbuf"); + TestCalc(i.CalcInterface, expected, "Interface non-generic"); + TestCalc(i.CalcInterfaceRetbuf, expectedS32, "Interface non-generic retbuf"); + TestCalc(CalcStaticCalli, expected, "Static calli"); + TestCalc(CalcStaticCalliRetbuf, expectedS32, "Static calli retbuf"); + TestCalc(new Instance().CalcInstanceCalli, expected, "Instance calli"); + TestCalc(new Instance().CalcInstanceCalliRetbuf, expectedS32, "Instance calli retbuf"); + Test(() => { var v = new InstanceValueType(); v.CountUp(countUpIters); return v.Count; }, countUpIters, "Value type instance call"); + Test(() => new Instance().GC("2", 3, "4", 5, "6", "7", "8", 9, ref ten), "2 3 4 5 6 7 8 9 10", "Instance with GC"); + Test(() => CountUpHeap(countUpIters, new HeapInt(0)), countUpIters, "Count up with heap int"); + Test(() => { int[] val = new int[1]; CountUpRef(countUpIters, ref val[0]); return val[0]; }, countUpIters, "Count up with byref to heap"); + Test(() => GenName1Forward("hello"), "System.String hello", "Static generic string"); + Test(() => GenName1Forward("hello"), "System.Object hello", "Static generic object"); + Test(() => GenName1Forward(5), "System.Int32 5", "Static generic int"); + Test(() => GenName2ForwardBoth("hello", (object)"hello2"), "System.String System.Object hello hello2", "Static generic 2 string object"); + Test(() => GenName2ForwardBoth("hello", 5), "System.String System.Int32 hello 5", "Static generic 2 string int"); + Test(() => GenName2ForwardOne("hello", "hello2"), "System.String System.String hello hello2", "Static generic 1 string"); + Test(() => GenName2ForwardOne((object)"hello", "hello2"), "System.Object System.String hello hello2", "Static generic 1 object"); + Test(() => GenName2ForwardOne(5, "hello2"), "System.Int32 System.String 5 hello2", "Static generic 1 int"); + Test(() => GenName2ForwardNone("hello", "hello2"), "System.Object System.String hello hello2", "Static generic 0"); + Test(() => g.NonVirtForward("a", 5, "b", "c"), + "System.String System.Int32 System.Object System.String a 5 b c", "Instance generic 4"); + Test(() => g.VirtForward("a", 5, "b", "c"), + "System.String System.Int32 System.Object System.String a 5 b c", "Virtual instance generic 4"); + Test(() => GenInterfaceForward("a", 5, "c", "d", ig), + "System.String System.Int32 System.String System.Object a 5 c d", "Interface generic 4"); + Test(() => GenInterfaceForwardNone("a", "b", 5, "d", ig2), + "System.String System.Object System.Int32 System.Object a b 5 d", "Interface generic 0"); + + if (result) + Console.WriteLine("All tailcall-via-help succeeded"); + else + Console.WriteLine("One or more failures in tailcall-via-help test"); + + return result ? 100 : 1; + } + + public static void Calc(ref int x, ref S32 s, ref int acc) + { + if (x % 2 == 0) + acc += (int)(x * 3 + s.A * 7 + s.B * 9 + s.C * -3 + s.D * 4); + else + acc += (int)(x * 1 + s.A * 9 + s.B * 3 + s.C * -4 + s.D * 5); + + x--; + s.A = 11*x; + s.B = 14*x; + s.C = -14*x; + s.D = 3*x; + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private static unsafe int CalcStatic(int x, int acc) + { + if (x == 0) + return acc; + + S32 s = default; + Calc(ref x, ref s, ref acc); + + IL.Push(x); + IL.Push(s); + IL.Push(acc); + IL.Emit.Tail(); + IL.Emit.Call(new MethodRef(typeof(Program), nameof(CalcStaticOther))); + return IL.Return(); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private static int CalcStaticOther(int x, S32 large, int acc) + { + Calc(ref x, ref large, ref acc); + + IL.Push(x); + IL.Push(acc); + IL.Emit.Tail(); + IL.Emit.Call(new MethodRef(typeof(Program), nameof(CalcStatic))); + return IL.Return(); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private static unsafe byte CalcStaticSmall(int x, int acc) + { + if (x == 0) + return (byte)acc; + + S32 s = default; + Calc(ref x, ref s, ref acc); + + IL.Push(x); + IL.Push(s); + IL.Push(acc); + IL.Emit.Tail(); + IL.Emit.Call(new MethodRef(typeof(Program), nameof(CalcStaticSmallOther))); + return IL.Return(); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private static byte CalcStaticSmallOther(int x, S32 large, int acc) + { + Calc(ref x, ref large, ref acc); + + IL.Push(x); + IL.Push(acc); + IL.Emit.Tail(); + IL.Emit.Call(new MethodRef(typeof(Program), nameof(CalcStaticSmall))); + return IL.Return(); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private static S32 CalcStaticRetbuf(int x, int acc) + { + if (x == 0) + return new S32 { A = acc, B = acc, C = acc, D = acc, }; + + S32 s = default; + Calc(ref x, ref s, ref acc); + + IL.Push(x); + IL.Push(s); + IL.Push(acc); + IL.Emit.Tail(); + IL.Emit.Call(new MethodRef(typeof(Program), nameof(CalcStaticRetbufOther))); + return IL.Return(); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private static S32 CalcStaticRetbufOther(int x, S32 large, int acc) + { + Calc(ref x, ref large, ref acc); + + IL.Push(x); + IL.Push(acc); + IL.Emit.Tail(); + IL.Emit.Call(new MethodRef(typeof(Program), nameof(CalcStaticRetbuf))); + return IL.Return(); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private static long CalcStaticLong(int x, int acc) + { + if (x == 0) + return (long)(((ulong)(uint)acc << 32) | (uint)acc); + + S32 s = default; + Calc(ref x, ref s, ref acc); + + IL.Push(x); + IL.Push(s); + IL.Push(acc); + IL.Emit.Tail(); + IL.Emit.Call(new MethodRef(typeof(Program), nameof(CalcStaticLongOther))); + return IL.Return(); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private static long CalcStaticLongOther(int x, S32 large, int acc) + { + Calc(ref x, ref large, ref acc); + + IL.Push(x); + IL.Push(acc); + IL.Emit.Tail(); + IL.Emit.Call(new MethodRef(typeof(Program), nameof(CalcStaticLong))); + return IL.Return(); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private static S16 CalcStaticS16(int x, int acc) + { + if (x == 0) + return new S16 { A = acc, B = acc }; + + S32 s = default; + Calc(ref x, ref s, ref acc); + + IL.Push(x); + IL.Push(s); + IL.Push(acc); + IL.Emit.Tail(); + IL.Emit.Call(new MethodRef(typeof(Program), nameof(CalcStaticS16Other))); + return IL.Return(); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private static S16 CalcStaticS16Other(int x, S32 large, int acc) + { + Calc(ref x, ref large, ref acc); + + IL.Push(x); + IL.Push(acc); + IL.Emit.Tail(); + IL.Emit.Call(new MethodRef(typeof(Program), nameof(CalcStaticS16))); + return IL.Return(); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private static int CalcStaticCalli(int x, int acc) + { + if (x == 0) + return acc; + + S32 s = default; + Calc(ref x, ref s, ref acc); + + IL.Push(x); + IL.Push(s); + IL.Push(acc); + IL.Push(s_calcStaticCalliOther); + IL.Emit.Tail(); + IL.Emit.Calli(new StandAloneMethodSig(CallingConventions.Standard, typeof(int), typeof(int), typeof(S32), typeof(int))); + return IL.Return(); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private static int CalcStaticCalliOther(int x, S32 large, int acc) + { + Calc(ref x, ref large, ref acc); + + IL.Push(x); + IL.Push(acc); + IL.Push(s_calcStaticCalli); + IL.Emit.Tail(); + IL.Emit.Calli(new StandAloneMethodSig(CallingConventions.Standard, typeof(int), typeof(int), typeof(int))); + return IL.Return(); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private static S32 CalcStaticCalliRetbuf(int x, int acc) + { + if (x == 0) + return new S32 { A = acc, B = acc, C = acc, D = acc, }; + + S32 s = default; + Calc(ref x, ref s, ref acc); + + IL.Push(x); + IL.Push(s); + IL.Push(acc); + IL.Push(s_calcStaticCalliRetbufOther); + IL.Emit.Tail(); + IL.Emit.Calli(new StandAloneMethodSig(CallingConventions.Standard, typeof(S32), typeof(int), typeof(S32), typeof(int))); + return IL.Return(); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private static S32 CalcStaticCalliRetbufOther(int x, S32 large, int acc) + { + Calc(ref x, ref large, ref acc); + + IL.Push(x); + IL.Push(acc); + IL.Push(s_calcStaticCalliRetbuf); + IL.Emit.Tail(); + IL.Emit.Calli(new StandAloneMethodSig(CallingConventions.Standard, typeof(S32), typeof(int), typeof(int))); + return IL.Return(); + } + + internal static int s_result; + [MethodImpl(MethodImplOptions.NoInlining)] + private static void CalcStaticVoid(int x, int acc) + { + if (x == 0) + { + s_result = acc; + return; + } + + S32 s = default; + Calc(ref x, ref s, ref acc); + + IL.Push(x); + IL.Push(s); + IL.Push(acc); + IL.Emit.Tail(); + IL.Emit.Call(new MethodRef(typeof(Program), nameof(CalcStaticVoidOther))); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private static void CalcStaticVoidOther(int x, S32 large, int acc) + { + Calc(ref x, ref large, ref acc); + + IL.Push(x); + IL.Push(acc); + IL.Emit.Tail(); + IL.Emit.Call(new MethodRef(typeof(Program), nameof(CalcStaticVoid))); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private static int CountUpHeap(int left, HeapInt counter) + { + if (left == 0) + return counter.Value; + + IL.Push(left - 1); + IL.Push(new S32()); + IL.Push(new HeapInt(counter.Value + 1)); + IL.Emit.Tail(); + IL.Emit.Call(new MethodRef(typeof(Program), nameof(CountUpHeapOther))); + return IL.Return(); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private static int CountUpHeapOther(int left, S32 s, HeapInt counter) + { + if (left == 0) + return counter.Value; + + IL.Push(left - 1); + IL.Push(new HeapInt(counter.Value + 1)); + IL.Emit.Tail(); + IL.Emit.Call(new MethodRef(typeof(Program), nameof(CountUpHeap))); + return IL.Return(); + } + + private static void CountUpRef(int left, ref int counter) + { + if (left == 0) + return; + + counter++; + IL.Push(left - 1); + IL.Push(new S32()); + IL.Push(ref counter); + IL.Emit.Tail(); + IL.Emit.Call(new MethodRef(typeof(Program), nameof(CountUpRefOther))); + } + + private static void CountUpRefOther(int left, S32 s, ref int counter) + { + if (left == 0) + return; + + counter++; + IL.Push(left - 1); + IL.Push(ref counter); + IL.Emit.Tail(); + IL.Emit.Call(new MethodRef(typeof(Program), nameof(CountUpRef))); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private static string GenName1Forward(T x) + { + S32 s = default; + IL.Push(s); + IL.Push(x); + IL.Emit.Tail(); + IL.Emit.Call(new MethodRef(typeof(Program), nameof(GenName1)).MakeGenericMethod(typeof(T))); + return IL.Return(); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private static string GenName1(S32 s, T x) + => $"{typeof(T).FullName} {x}"; + + [MethodImpl(MethodImplOptions.NoInlining)] + private static string GenName2ForwardBoth(T1 x, T2 y) + { + S32 s = default; + IL.Push(s); + IL.Push(x); + IL.Push(y); + IL.Emit.Tail(); + IL.Emit.Call(new MethodRef(typeof(Program), nameof(GenName2)).MakeGenericMethod(typeof(T1), typeof(T2))); + return IL.Return(); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private static string GenName2ForwardOne(T x, string y) + { + S32 s = default; + IL.Push(s); + IL.Push(x); + IL.Push(y); + IL.Emit.Tail(); + IL.Emit.Call(new MethodRef(typeof(Program), nameof(GenName2)).MakeGenericMethod(typeof(T), typeof(string))); + return IL.Return(); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private static string GenName2ForwardNone(object x, string y) + { + S32 s = default; + IL.Push(s); + IL.Push(x); + IL.Push(y); + IL.Emit.Tail(); + IL.Emit.Call(new MethodRef(typeof(Program), nameof(GenName2)).MakeGenericMethod(typeof(object), typeof(string))); + return IL.Return(); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private static string GenName2(S32 s, T1 a, T2 b) + => $"{typeof(T1).FullName} {typeof(T2).FullName} {a} {b}"; + + [MethodImpl(MethodImplOptions.NoInlining)] + private static string GenInterfaceForward(T1 a, T2 b, T3 c, T4 d, IGenInterface igen) + { + IL.Push(igen); + IL.Push(new S32()); + IL.Push(a); + IL.Push(b); + IL.Push(c); + IL.Push(d); + IL.Emit.Tail(); + IL.Emit.Callvirt(new MethodRef(typeof(IGenInterface), nameof(IGenInterface.F)).MakeGenericMethod(typeof(T3), typeof(T4))); + return IL.Return(); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private static string GenInterfaceForwardNone(string a, object b, int c, object d, IGenInterface igen) + { + IL.Push(igen); + IL.Push(new S32()); + IL.Push(a); + IL.Push(b); + IL.Push(c); + IL.Push(d); + IL.Emit.Tail(); + IL.Emit.Callvirt(new MethodRef(typeof(IGenInterface), nameof(IGenInterface.F)).MakeGenericMethod(typeof(int), typeof(object))); + return IL.Return(); + } +} + +class Instance +{ + private static readonly IntPtr s_calcInstanceCalli; + private static readonly IntPtr s_calcInstanceCalliOther; + private static readonly IntPtr s_calcInstanceCalliRetbuf; + private static readonly IntPtr s_calcInstanceCalliRetbufOther; + + static Instance() + { + IL.Emit.Ldftn(new MethodRef(typeof(Instance), nameof(CalcInstanceCalli))); + IL.Pop(out IntPtr calcInstanceCalli); + IL.Emit.Ldftn(new MethodRef(typeof(Instance), nameof(CalcInstanceCalliOther))); + IL.Pop(out IntPtr calcInstanceCalliOther); + IL.Emit.Ldftn(new MethodRef(typeof(Instance), nameof(CalcInstanceCalliRetbuf))); + IL.Pop(out IntPtr calcInstanceCalliRetbuf); + IL.Emit.Ldftn(new MethodRef(typeof(Instance), nameof(CalcInstanceCalliRetbufOther))); + IL.Pop(out IntPtr calcInstanceCalliRetbufOther); + + s_calcInstanceCalli = calcInstanceCalli; + s_calcInstanceCalliOther = calcInstanceCalliOther; + s_calcInstanceCalliRetbuf = calcInstanceCalliRetbuf; + s_calcInstanceCalliRetbufOther = calcInstanceCalliRetbufOther; + } + + private int _x; + + [MethodImpl(MethodImplOptions.NoInlining)] + public int CalcInstance(int x, int acc) + { + if (x != -1234567) + _x = x; + + if (_x == 0) + return acc; + + S32 s = default; + Program.Calc(ref _x, ref s, ref acc); + + IL.Push(this); + IL.Push(-1234567); + IL.Push(s); + IL.Push(acc); + IL.Emit.Tail(); + IL.Emit.Callvirt(new MethodRef(typeof(Instance), nameof(CalcInstanceOther))); + return IL.Return(); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + public int CalcInstanceOther(int x, S32 large, int acc) + { + Program.Calc(ref _x, ref large, ref acc); + + IL.Push(this); + IL.Push(-1234567); + IL.Push(acc); + IL.Emit.Tail(); + IL.Emit.Callvirt(new MethodRef(typeof(Instance), nameof(CalcInstance))); + return IL.Return(); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + public S32 CalcInstanceRetbuf(int x, int acc) + { + if (x != -1234567) + _x = x; + + if (_x == 0) + return new S32 { A = acc, B = acc, C = acc, D = acc, }; + + S32 s = default; + Program.Calc(ref _x, ref s, ref acc); + + IL.Push(this); + IL.Push(-1234567); + IL.Push(s); + IL.Push(acc); + IL.Emit.Tail(); + IL.Emit.Callvirt(new MethodRef(typeof(Instance), nameof(CalcInstanceRetbufOther))); + return IL.Return(); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + public S32 CalcInstanceRetbufOther(int x, S32 large, int acc) + { + Program.Calc(ref _x, ref large, ref acc); + + IL.Push(this); + IL.Push(-1234567); + IL.Push(acc); + IL.Emit.Tail(); + IL.Emit.Callvirt(new MethodRef(typeof(Instance), nameof(CalcInstanceRetbuf))); + return IL.Return(); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + public int CalcInstanceCalli(int x, int acc) + { + if (x != -1234567) + _x = x; + + if (_x == 0) + return acc; + + S32 s = default; + Program.Calc(ref _x, ref s, ref acc); + + IL.Push(this); + IL.Push(-1234567); + IL.Push(s); + IL.Push(acc); + IL.Push(s_calcInstanceCalliOther); + IL.Emit.Tail(); + IL.Emit.Calli(new StandAloneMethodSig(CallingConventions.Standard | CallingConventions.HasThis, typeof(int), typeof(int), typeof(S32), typeof(int))); + return IL.Return(); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + public int CalcInstanceCalliOther(int x, S32 large, int acc) + { + Program.Calc(ref _x, ref large, ref acc); + + IL.Push(this); + IL.Push(-1234567); + IL.Push(acc); + IL.Push(s_calcInstanceCalli); + IL.Emit.Tail(); + IL.Emit.Calli(new StandAloneMethodSig(CallingConventions.Standard | CallingConventions.HasThis, typeof(int), typeof(int), typeof(int))); + return IL.Return(); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + public S32 CalcInstanceCalliRetbuf(int x, int acc) + { + if (x != -1234567) + _x = x; + + if (_x == 0) + return new S32 { A = acc, B = acc, C = acc, D = acc, }; + + S32 s = default; + Program.Calc(ref _x, ref s, ref acc); + + IL.Push(this); + IL.Push(-1234567); + IL.Push(s); + IL.Push(acc); + IL.Push(s_calcInstanceCalliRetbufOther); + IL.Emit.Tail(); + IL.Emit.Calli(new StandAloneMethodSig(CallingConventions.Standard | CallingConventions.HasThis, typeof(S32), typeof(int), typeof(S32), typeof(int))); + return IL.Return(); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + public S32 CalcInstanceCalliRetbufOther(int x, S32 large, int acc) + { + Program.Calc(ref _x, ref large, ref acc); + + IL.Push(this); + IL.Push(-1234567); + IL.Push(acc); + IL.Push(s_calcInstanceCalliRetbuf); + IL.Emit.Tail(); + IL.Emit.Calli(new StandAloneMethodSig(CallingConventions.Standard | CallingConventions.HasThis, typeof(S32), typeof(int), typeof(int))); + return IL.Return(); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + public string GC(object a, int b, object c, object d, string e, string f, object g, int h, ref int interior) + { + IL.Push(this); + + IL.Push(a); + + S32 s = new S32(); + IL.Push(s); + + SGC2 sgc = new SGC2 + { + A = b, + B = + { + A = c, + B = d, + C = e, + D = f, + }, + C = g, + D = h + }; + IL.Push(sgc); + IL.Push(ref interior); + + IL.Emit.Tail(); + IL.Emit.Call(new MethodRef(typeof(Instance), nameof(GCOther))); + return IL.Return(); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + private string GCOther(object a, S32 s, SGC2 gc, ref int interior) + => $"{a} {gc.A} {gc.B.A} {gc.B.B} {gc.B.C} {gc.B.D} {gc.C} {gc.D} {interior}"; +} + +struct InstanceValueType +{ + public int Count; + + public void CountUp(int left) + { + if (left == 0) + return; + + Count++; + + IL.Push(ref this); + IL.Push(left - 1); + IL.Push(new S32()); + IL.Emit.Tail(); + IL.Emit.Call(new MethodRef(typeof(InstanceValueType), nameof(CountUpOther))); + } + + private void CountUpOther(int left, S32 s) + { + if (left == 0) + return; + + Count++; + IL.Push(ref this); + IL.Push(left - 1); + IL.Emit.Tail(); + IL.Emit.Call(new MethodRef(typeof(InstanceValueType), nameof(CountUp))); + } +} + +abstract class BaseClass +{ + public abstract int CalcAbstract(int x, int acc); + public abstract int CalcAbstractOther(int x, S32 large, int acc); + + public abstract S32 CalcAbstractRetbuf(int x, int acc); + public abstract S32 CalcAbstractRetbufOther(int x, S32 large, int acc); +} +class ClassImpl : BaseClass +{ + private int _x; + public BaseClass Other { get; set; } + + [MethodImpl(MethodImplOptions.NoInlining)] + public override int CalcAbstract(int x, int acc) + { + if (x != -1234567) + _x = x; + + if (_x == 0) + return acc; + + S32 s = default; + Program.Calc(ref _x, ref s, ref acc); + + IL.Push(Other); + IL.Push(-1234567); + IL.Push(s); + IL.Push(acc); + IL.Emit.Tail(); + IL.Emit.Callvirt(new MethodRef(typeof(ClassImpl), nameof(CalcAbstractOther))); + return IL.Return(); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + public override int CalcAbstractOther(int x, S32 large, int acc) + { + Program.Calc(ref _x, ref large, ref acc); + + IL.Push(Other); + IL.Push(-1234567); + IL.Push(acc); + IL.Emit.Tail(); + IL.Emit.Callvirt(new MethodRef(typeof(ClassImpl), nameof(CalcAbstract))); + return IL.Return(); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + public override S32 CalcAbstractRetbuf(int x, int acc) + { + if (x != -1234567) + _x = x; + + if (_x == 0) + return new S32 { A = acc, B = acc, C = acc, D = acc, }; + + S32 s = default; + Program.Calc(ref _x, ref s, ref acc); + + IL.Push(Other); + IL.Push(-1234567); + IL.Push(s); + IL.Push(acc); + IL.Emit.Tail(); + IL.Emit.Callvirt(new MethodRef(typeof(ClassImpl), nameof(CalcAbstractRetbufOther))); + return IL.Return(); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + public override S32 CalcAbstractRetbufOther(int x, S32 large, int acc) + { + Program.Calc(ref _x, ref large, ref acc); + + IL.Push(Other); + IL.Push(-1234567); + IL.Push(acc); + IL.Emit.Tail(); + IL.Emit.Callvirt(new MethodRef(typeof(ClassImpl), nameof(CalcAbstractRetbuf))); + return IL.Return(); + } +} + +interface IInterface +{ + int CalcInterface(int x, int acc); + int CalcInterfaceOther(int x, S32 large, int acc); + + S32 CalcInterfaceRetbuf(int x, int acc); + S32 CalcInterfaceRetbufOther(int x, S32 large, int acc); +} + +class InterfaceImpl : IInterface +{ + private int _x; + public IInterface Other { get; set; } + + [MethodImpl(MethodImplOptions.NoInlining)] + public int CalcInterface(int x, int acc) + { + if (x != -1234567) + _x = x; + + if (_x == 0) + return acc; + + S32 s = default; + Program.Calc(ref _x, ref s, ref acc); + + IL.Push(Other); + IL.Push(-1234567); + IL.Push(s); + IL.Push(acc); + IL.Emit.Tail(); + IL.Emit.Callvirt(new MethodRef(typeof(IInterface), nameof(CalcInterfaceOther))); + return IL.Return(); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + public int CalcInterfaceOther(int x, S32 large, int acc) + { + Program.Calc(ref _x, ref large, ref acc); + + IL.Push(Other); + IL.Push(-1234567); + IL.Push(acc); + IL.Emit.Tail(); + IL.Emit.Callvirt(new MethodRef(typeof(IInterface), nameof(CalcInterface))); + return IL.Return(); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + public S32 CalcInterfaceRetbuf(int x, int acc) + { + if (x != -1234567) + _x = x; + + if (_x == 0) + return new S32 { A = acc, B = acc, C = acc, D = acc, }; + + S32 s = default; + Program.Calc(ref _x, ref s, ref acc); + + IL.Push(Other); + IL.Push(-1234567); + IL.Push(s); + IL.Push(acc); + IL.Emit.Tail(); + IL.Emit.Callvirt(new MethodRef(typeof(IInterface), nameof(CalcInterfaceRetbufOther))); + return IL.Return(); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + public S32 CalcInterfaceRetbufOther(int x, S32 large, int acc) + { + Program.Calc(ref _x, ref large, ref acc); + + IL.Push(Other); + IL.Push(-1234567); + IL.Push(acc); + IL.Emit.Tail(); + IL.Emit.Callvirt(new MethodRef(typeof(IInterface), nameof(CalcInterfaceRetbuf))); + return IL.Return(); + } +} + +class GenInstance +{ + [MethodImpl(MethodImplOptions.NoInlining)] + public string NonVirtForward(T1 a, T2 b, T3 c, T4 d) + { + IL.Push(this); + IL.Push(new S32()); + IL.Push(a); + IL.Push(b); + IL.Push(c); + IL.Push(d); + IL.Emit.Tail(); + IL.Emit.Callvirt(new MethodRef(typeof(GenInstance), nameof(NonVirt)).MakeGenericMethod(typeof(T3), typeof(T4))); + return IL.Return(); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + public string VirtForward(T1 a, T2 b, T3 c, T4 d) + { + IL.Push(this); + IL.Push(new S32()); + IL.Push(a); + IL.Push(b); + IL.Push(c); + IL.Push(d); + IL.Emit.Tail(); + IL.Emit.Callvirt(new MethodRef(typeof(GenInstance), nameof(Virt)).MakeGenericMethod(typeof(T3), typeof(T4))); + return IL.Return(); + } + + public string NonVirt(S32 s, T1 a, T2 b, T3 c, T4 d) + => $"{typeof(T1).FullName} {typeof(T2).FullName} {typeof(T3).FullName} {typeof(T4).FullName} {a} {b} {c} {d}"; + + public virtual string Virt(S32 s, T1 a, T2 b, T3 c, T4 d) + => $"{typeof(T1).FullName} {typeof(T2).FullName} {typeof(T3).FullName} {typeof(T4).FullName} {a} {b} {c} {d}"; +} + +interface IGenInterface +{ + public string F(S32 s, T1 a, T2 b, T3 c, T4 d); +} + +class GenInterfaceImpl : IGenInterface +{ + public string F(S32 s, T1 a, T2 b, T3 c, T4 d) + => $"{typeof(T1).FullName} {typeof(T2).FullName} {typeof(T3).FullName} {typeof(T4).FullName} {a} {b} {c} {d}"; +} diff --git a/src/coreclr/tests/src/JIT/Directed/tailcall/more_tailcalls.il b/src/coreclr/tests/src/JIT/Directed/tailcall/more_tailcalls.il new file mode 100644 index 00000000000..299eb82b59f --- /dev/null +++ b/src/coreclr/tests/src/JIT/Directed/tailcall/more_tailcalls.il @@ -0,0 +1,3487 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +// See more_tailcalls.cs for the source of this IL. + +// Metadata version: v4.0.30319 +.assembly extern System.Runtime +{ + .publickeytoken = (B0 3F 5F 7F 11 D5 0A 3A ) // .?_....: + .ver 4:2:1:0 +} +.assembly extern System.Runtime.Extensions +{ + .publickeytoken = (B0 3F 5F 7F 11 D5 0A 3A ) // .?_....: + .ver 4:2:1:0 +} +.assembly extern System.Console +{ + .publickeytoken = (B0 3F 5F 7F 11 D5 0A 3A ) // .?_....: + .ver 4:1:1:0 +} +.assembly example1 +{ + .custom instance void [System.Runtime]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 ) + .custom instance void [System.Runtime]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx + 63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 ) // ceptionThrows. + + // --- The following custom attribute is added automatically, do not uncomment ------- + // .custom instance void [System.Runtime]System.Diagnostics.DebuggableAttribute::.ctor(valuetype [System.Runtime]System.Diagnostics.DebuggableAttribute/DebuggingModes) = ( 01 00 02 00 00 00 00 00 ) + + .custom instance void [System.Runtime]System.Runtime.Versioning.TargetFrameworkAttribute::.ctor(string) = ( 01 00 18 2E 4E 45 54 43 6F 72 65 41 70 70 2C 56 // ....NETCoreApp,V + 65 72 73 69 6F 6E 3D 76 33 2E 30 01 00 54 0E 14 // ersion=v3.0..T.. + 46 72 61 6D 65 77 6F 72 6B 44 69 73 70 6C 61 79 // FrameworkDisplay + 4E 61 6D 65 00 ) // Name. + .custom instance void [System.Runtime]System.Reflection.AssemblyCompanyAttribute::.ctor(string) = ( 01 00 08 65 78 61 6D 70 6C 65 31 00 00 ) // ...example1.. + .custom instance void [System.Runtime]System.Reflection.AssemblyConfigurationAttribute::.ctor(string) = ( 01 00 07 52 65 6C 65 61 73 65 00 00 ) // ...Release.. + .custom instance void [System.Runtime]System.Reflection.AssemblyFileVersionAttribute::.ctor(string) = ( 01 00 07 31 2E 30 2E 30 2E 30 00 00 ) // ...1.0.0.0.. + .custom instance void [System.Runtime]System.Reflection.AssemblyInformationalVersionAttribute::.ctor(string) = ( 01 00 05 31 2E 30 2E 30 00 00 ) // ...1.0.0.. + .custom instance void [System.Runtime]System.Reflection.AssemblyProductAttribute::.ctor(string) = ( 01 00 08 65 78 61 6D 70 6C 65 31 00 00 ) // ...example1.. + .custom instance void [System.Runtime]System.Reflection.AssemblyTitleAttribute::.ctor(string) = ( 01 00 08 65 78 61 6D 70 6C 65 31 00 00 ) // ...example1.. + .permissionset reqmin + = {class 'System.Security.Permissions.SecurityPermissionAttribute, System.Runtime.Extensions, Version=4.2.1.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a' = {property bool 'SkipVerification' = bool(true)}} + .hash algorithm 0x00008004 + .ver 1:0:0:0 +} +.module example1.dll +// MVID: {d297947d-0d42-4f5f-a026-33cccfd04656} +.custom instance void [System.Runtime]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) +.imagebase 0x00400000 +.file alignment 0x00000200 +.stackreserve 0x00100000 +.subsystem 0x0003 // WINDOWS_CUI +.corflags 0x00000001 // ILONLY +// Image base: 0x00007F4743A10000 + + +// =============== CLASS MEMBERS DECLARATION =================== + +.class private sequential ansi sealed beforefieldinit S16 + extends [System.Runtime]System.ValueType +{ + .field public int64 A + .field public int64 B + .method public hidebysig virtual instance string + ToString() cil managed + { + // Code size 33 (0x21) + .maxstack 8 + IL_0000: ldstr "{0}, {1}" + IL_0005: ldarg.0 + IL_0006: ldfld int64 S16::A + IL_000b: box [System.Runtime]System.Int64 + IL_0010: ldarg.0 + IL_0011: ldfld int64 S16::B + IL_0016: box [System.Runtime]System.Int64 + IL_001b: call string [System.Runtime]System.String::Format(string, + object, + object) + IL_0020: ret + } // end of method S16::ToString + +} // end of class S16 + +.class private sequential ansi sealed beforefieldinit S32 + extends [System.Runtime]System.ValueType +{ + .field public int64 A + .field public int64 B + .field public int64 C + .field public int64 D + .method public hidebysig virtual instance string + ToString() cil managed + { + // Code size 73 (0x49) + .maxstack 5 + IL_0000: ldstr "{0}, {1}, {2}, {3}" + IL_0005: ldc.i4.4 + IL_0006: newarr [System.Runtime]System.Object + IL_000b: dup + IL_000c: ldc.i4.0 + IL_000d: ldarg.0 + IL_000e: ldfld int64 S32::A + IL_0013: box [System.Runtime]System.Int64 + IL_0018: stelem.ref + IL_0019: dup + IL_001a: ldc.i4.1 + IL_001b: ldarg.0 + IL_001c: ldfld int64 S32::B + IL_0021: box [System.Runtime]System.Int64 + IL_0026: stelem.ref + IL_0027: dup + IL_0028: ldc.i4.2 + IL_0029: ldarg.0 + IL_002a: ldfld int64 S32::C + IL_002f: box [System.Runtime]System.Int64 + IL_0034: stelem.ref + IL_0035: dup + IL_0036: ldc.i4.3 + IL_0037: ldarg.0 + IL_0038: ldfld int64 S32::D + IL_003d: box [System.Runtime]System.Int64 + IL_0042: stelem.ref + IL_0043: call string [System.Runtime]System.String::Format(string, + object[]) + IL_0048: ret + } // end of method S32::ToString + +} // end of class S32 + +.class private sequential ansi sealed beforefieldinit SGC + extends [System.Runtime]System.ValueType +{ + .field public object A + .field public object B + .field public string C + .field public string D + .method public hidebysig virtual instance string + ToString() cil managed + { + // Code size 53 (0x35) + .maxstack 8 + IL_0000: ldstr "{0}, {1}, {2}, {3}" + IL_0005: ldc.i4.4 + IL_0006: newarr [System.Runtime]System.Object + IL_000b: dup + IL_000c: ldc.i4.0 + IL_000d: ldarg.0 + IL_000e: ldfld object SGC::A + IL_0013: stelem.ref + IL_0014: dup + IL_0015: ldc.i4.1 + IL_0016: ldarg.0 + IL_0017: ldfld object SGC::B + IL_001c: stelem.ref + IL_001d: dup + IL_001e: ldc.i4.2 + IL_001f: ldarg.0 + IL_0020: ldfld string SGC::C + IL_0025: stelem.ref + IL_0026: dup + IL_0027: ldc.i4.3 + IL_0028: ldarg.0 + IL_0029: ldfld string SGC::D + IL_002e: stelem.ref + IL_002f: call string [System.Runtime]System.String::Format(string, + object[]) + IL_0034: ret + } // end of method SGC::ToString + +} // end of class SGC + +.class private sequential ansi sealed beforefieldinit SGC2 + extends [System.Runtime]System.ValueType +{ + .field public int32 A + .field public valuetype SGC B + .field public object C + .field public int32 D + .method public hidebysig virtual instance string + ToString() cil managed + { + // Code size 68 (0x44) + .maxstack 5 + IL_0000: ldstr "{0}, ({1}), {2}, {3}" + IL_0005: ldc.i4.4 + IL_0006: newarr [System.Runtime]System.Object + IL_000b: dup + IL_000c: ldc.i4.0 + IL_000d: ldarg.0 + IL_000e: ldfld int32 SGC2::A + IL_0013: box [System.Runtime]System.Int32 + IL_0018: stelem.ref + IL_0019: dup + IL_001a: ldc.i4.1 + IL_001b: ldarg.0 + IL_001c: ldfld valuetype SGC SGC2::B + IL_0021: box SGC + IL_0026: stelem.ref + IL_0027: dup + IL_0028: ldc.i4.2 + IL_0029: ldarg.0 + IL_002a: ldfld object SGC2::C + IL_002f: stelem.ref + IL_0030: dup + IL_0031: ldc.i4.3 + IL_0032: ldarg.0 + IL_0033: ldfld int32 SGC2::D + IL_0038: box [System.Runtime]System.Int32 + IL_003d: stelem.ref + IL_003e: call string [System.Runtime]System.String::Format(string, + object[]) + IL_0043: ret + } // end of method SGC2::ToString + +} // end of class SGC2 + +.class private auto ansi beforefieldinit HeapInt + extends [System.Runtime]System.Object +{ + .field public int32 Value + .method public hidebysig specialname rtspecialname + instance void .ctor(int32 val) cil managed + { + // Code size 14 (0xe) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: call instance void [System.Runtime]System.Object::.ctor() + IL_0006: ldarg.0 + IL_0007: ldarg.1 + IL_0008: stfld int32 HeapInt::Value + IL_000d: ret + } // end of method HeapInt::.ctor + + .method public hidebysig virtual instance string + ToString() cil managed + { + // Code size 22 (0x16) + .maxstack 8 + IL_0000: ldstr "{0}" + IL_0005: ldarg.0 + IL_0006: ldfld int32 HeapInt::Value + IL_000b: box [System.Runtime]System.Int32 + IL_0010: call string [System.Runtime]System.String::Format(string, + object) + IL_0015: ret + } // end of method HeapInt::ToString + +} // end of class HeapInt + +.class private auto ansi Program + extends [System.Runtime]System.Object +{ + .class auto ansi sealed nested private beforefieldinit '<>c__DisplayClass5_0' + extends [System.Runtime]System.Object + { + .custom instance void [System.Runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field public bool result + .field public int32 ten + .field public class GenInstance`2 g + .field public class IGenInterface`2 ig + .field public class IGenInterface`2 ig2 + .method public hidebysig specialname rtspecialname + instance void .ctor() cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: call instance void [System.Runtime]System.Object::.ctor() + IL_0006: ret + } // end of method '<>c__DisplayClass5_0'::.ctor + + .method assembly hidebysig instance void + '
g__Test|0'(class [System.Runtime]System.Func`1 f, + !!T expected, + string name) cil managed + { + // Code size 105 (0x69) + .maxstack 4 + .locals init (class [System.Runtime.Extensions]System.Diagnostics.Stopwatch V_0, + !!T V_1) + IL_0000: ldstr "{0}: " + IL_0005: ldarg.3 + IL_0006: call void [System.Console]System.Console::Write(string, + object) + IL_000b: call class [System.Runtime.Extensions]System.Diagnostics.Stopwatch [System.Runtime.Extensions]System.Diagnostics.Stopwatch::StartNew() + IL_0010: stloc.0 + IL_0011: ldarg.1 + IL_0012: callvirt instance !0 class [System.Runtime]System.Func`1::Invoke() + IL_0017: stloc.1 + IL_0018: ldloc.0 + IL_0019: callvirt instance void [System.Runtime.Extensions]System.Diagnostics.Stopwatch::Stop() + IL_001e: ldloca.s V_1 + IL_0020: ldarg.2 + IL_0021: box !!T + IL_0026: constrained. !!T + IL_002c: callvirt instance bool [System.Runtime]System.Object::Equals(object) + IL_0031: brfalse.s IL_004a + + IL_0033: ldstr "OK in {1} ms" + IL_0038: ldarg.3 + IL_0039: ldloc.0 + IL_003a: callvirt instance int64 [System.Runtime.Extensions]System.Diagnostics.Stopwatch::get_ElapsedMilliseconds() + IL_003f: box [System.Runtime]System.Int64 + IL_0044: call void [System.Console]System.Console::WriteLine(string, + object, + object) + IL_0049: ret + + IL_004a: ldstr "FAIL (expected {1}, got {2})" + IL_004f: ldarg.3 + IL_0050: ldarg.2 + IL_0051: box !!T + IL_0056: ldloc.1 + IL_0057: box !!T + IL_005c: call void [System.Console]System.Console::WriteLine(string, + object, + object, + object) + IL_0061: ldarg.0 + IL_0062: ldc.i4.0 + IL_0063: stfld bool Program/'<>c__DisplayClass5_0'::result + IL_0068: ret + } // end of method '<>c__DisplayClass5_0'::'
g__Test|0' + + .method assembly hidebysig instance void + '
g__TestCalc|1'(class [System.Runtime]System.Func`3 f, + !!T expected, + string name) cil managed + { + // Code size 34 (0x22) + .maxstack 4 + .locals init (class Program/'<>c__DisplayClass5_1`1' V_0) + IL_0000: newobj instance void class Program/'<>c__DisplayClass5_1`1'::.ctor() + IL_0005: stloc.0 + IL_0006: ldloc.0 + IL_0007: ldarg.1 + IL_0008: stfld class [System.Runtime]System.Func`3 class Program/'<>c__DisplayClass5_1`1'::f + IL_000d: ldarg.0 + IL_000e: ldloc.0 + IL_000f: ldftn instance !0 class Program/'<>c__DisplayClass5_1`1'::'
b__20'() + IL_0015: newobj instance void class [System.Runtime]System.Func`1::.ctor(object, + native int) + IL_001a: ldarg.2 + IL_001b: ldarg.3 + IL_001c: call instance void Program/'<>c__DisplayClass5_0'::'
g__Test|0'(class [System.Runtime]System.Func`1, + !!0, + string) + IL_0021: ret + } // end of method '<>c__DisplayClass5_0'::'
g__TestCalc|1' + + .method assembly hidebysig instance string + '
b__4'() cil managed + { + // Code size 51 (0x33) + .maxstack 10 + IL_0000: newobj instance void Instance::.ctor() + IL_0005: ldstr "2" + IL_000a: ldc.i4.3 + IL_000b: ldstr "4" + IL_0010: ldc.i4.5 + IL_0011: box [System.Runtime]System.Int32 + IL_0016: ldstr "6" + IL_001b: ldstr "7" + IL_0020: ldstr "8" + IL_0025: ldc.i4.s 9 + IL_0027: ldarg.0 + IL_0028: ldflda int32 Program/'<>c__DisplayClass5_0'::ten + IL_002d: call instance string Instance::GC(object, + int32, + object, + object, + string, + string, + object, + int32, + int32&) + IL_0032: ret + } // end of method '<>c__DisplayClass5_0'::'
b__4' + + .method assembly hidebysig instance string + '
b__16'() cil managed + { + // Code size 28 (0x1c) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld class GenInstance`2 Program/'<>c__DisplayClass5_0'::g + IL_0006: ldstr "a" + IL_000b: ldc.i4.5 + IL_000c: ldstr "b" + IL_0011: ldstr "c" + IL_0016: callvirt instance string class GenInstance`2::NonVirtForward(!0, + !1, + !!0, + !!1) + IL_001b: ret + } // end of method '<>c__DisplayClass5_0'::'
b__16' + + .method assembly hidebysig instance string + '
b__17'() cil managed + { + // Code size 28 (0x1c) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld class GenInstance`2 Program/'<>c__DisplayClass5_0'::g + IL_0006: ldstr "a" + IL_000b: ldc.i4.5 + IL_000c: ldstr "b" + IL_0011: ldstr "c" + IL_0016: callvirt instance string class GenInstance`2::VirtForward(!0, + !1, + !!0, + !!1) + IL_001b: ret + } // end of method '<>c__DisplayClass5_0'::'
b__17' + + .method assembly hidebysig instance string + '
b__18'() cil managed + { + // Code size 28 (0x1c) + .maxstack 8 + IL_0000: ldstr "a" + IL_0005: ldc.i4.5 + IL_0006: ldstr "c" + IL_000b: ldstr "d" + IL_0010: ldarg.0 + IL_0011: ldfld class IGenInterface`2 Program/'<>c__DisplayClass5_0'::ig + IL_0016: call string Program::GenInterfaceForward(!!0, + !!1, + !!2, + !!3, + class IGenInterface`2) + IL_001b: ret + } // end of method '<>c__DisplayClass5_0'::'
b__18' + + .method assembly hidebysig instance string + '
b__19'() cil managed + { + // Code size 28 (0x1c) + .maxstack 8 + IL_0000: ldstr "a" + IL_0005: ldstr "b" + IL_000a: ldc.i4.5 + IL_000b: ldstr "d" + IL_0010: ldarg.0 + IL_0011: ldfld class IGenInterface`2 Program/'<>c__DisplayClass5_0'::ig2 + IL_0016: call string Program::GenInterfaceForwardNone(string, + object, + int32, + object, + class IGenInterface`2) + IL_001b: ret + } // end of method '<>c__DisplayClass5_0'::'
b__19' + + } // end of class '<>c__DisplayClass5_0' + + .class auto ansi sealed nested private beforefieldinit '<>c__DisplayClass5_1`1' + extends [System.Runtime]System.Object + { + .custom instance void [System.Runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field public class [System.Runtime]System.Func`3 f + .method public hidebysig specialname rtspecialname + instance void .ctor() cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: call instance void [System.Runtime]System.Object::.ctor() + IL_0006: ret + } // end of method '<>c__DisplayClass5_1`1'::.ctor + + .method assembly hidebysig instance !T + '
b__20'() cil managed + { + // Code size 18 (0x12) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld class [System.Runtime]System.Func`3 class Program/'<>c__DisplayClass5_1`1'::f + IL_0006: ldc.i4 0xf4240 + IL_000b: ldc.i4.0 + IL_000c: callvirt instance !2 class [System.Runtime]System.Func`3::Invoke(!0, + !1) + IL_0011: ret + } // end of method '<>c__DisplayClass5_1`1'::'
b__20' + + } // end of class '<>c__DisplayClass5_1`1' + + .class auto ansi serializable sealed nested private beforefieldinit '<>c' + extends [System.Runtime]System.Object + { + .custom instance void [System.Runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field public static initonly class Program/'<>c' '<>9' + .field public static class [System.Runtime]System.Func`3 '<>9__5_2' + .field public static class [System.Runtime]System.Func`1 '<>9__5_3' + .field public static class [System.Runtime]System.Func`1 '<>9__5_5' + .field public static class [System.Runtime]System.Func`1 '<>9__5_6' + .field public static class [System.Runtime]System.Func`1 '<>9__5_7' + .field public static class [System.Runtime]System.Func`1 '<>9__5_8' + .field public static class [System.Runtime]System.Func`1 '<>9__5_9' + .field public static class [System.Runtime]System.Func`1 '<>9__5_10' + .field public static class [System.Runtime]System.Func`1 '<>9__5_11' + .field public static class [System.Runtime]System.Func`1 '<>9__5_12' + .field public static class [System.Runtime]System.Func`1 '<>9__5_13' + .field public static class [System.Runtime]System.Func`1 '<>9__5_14' + .field public static class [System.Runtime]System.Func`1 '<>9__5_15' + .method private hidebysig specialname rtspecialname static + void .cctor() cil managed + { + // Code size 11 (0xb) + .maxstack 8 + IL_0000: newobj instance void Program/'<>c'::.ctor() + IL_0005: stsfld class Program/'<>c' Program/'<>c'::'<>9' + IL_000a: ret + } // end of method '<>c'::.cctor + + .method public hidebysig specialname rtspecialname + instance void .ctor() cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: call instance void [System.Runtime]System.Object::.ctor() + IL_0006: ret + } // end of method '<>c'::.ctor + + .method assembly hidebysig instance int32 + '
b__5_2'(int32 x, + int32 s) cil managed + { + // Code size 13 (0xd) + .maxstack 8 + IL_0000: ldarg.1 + IL_0001: ldarg.2 + IL_0002: call void Program::CalcStaticVoid(int32, + int32) + IL_0007: ldsfld int32 Program::s_result + IL_000c: ret + } // end of method '<>c'::'
b__5_2' + + .method assembly hidebysig instance int32 + '
b__5_3'() cil managed + { + // Code size 27 (0x1b) + .maxstack 2 + .locals init (valuetype InstanceValueType V_0) + IL_0000: ldloca.s V_0 + IL_0002: initobj InstanceValueType + IL_0008: ldloca.s V_0 + IL_000a: ldc.i4 0xf4240 + IL_000f: call instance void InstanceValueType::CountUp(int32) + IL_0014: ldloc.0 + IL_0015: ldfld int32 InstanceValueType::Count + IL_001a: ret + } // end of method '<>c'::'
b__5_3' + + .method assembly hidebysig instance int32 + '
b__5_5'() cil managed + { + // Code size 17 (0x11) + .maxstack 8 + IL_0000: ldc.i4 0xf4240 + IL_0005: ldc.i4.0 + IL_0006: newobj instance void HeapInt::.ctor(int32) + IL_000b: call int32 Program::CountUpHeap(int32, + class HeapInt) + IL_0010: ret + } // end of method '<>c'::'
b__5_5' + + .method assembly hidebysig instance int32 + '
b__5_6'() cil managed + { + // Code size 28 (0x1c) + .maxstack 3 + .locals init (int32[] V_0) + IL_0000: ldc.i4.1 + IL_0001: newarr [System.Runtime]System.Int32 + IL_0006: stloc.0 + IL_0007: ldc.i4 0xf4240 + IL_000c: ldloc.0 + IL_000d: ldc.i4.0 + IL_000e: ldelema [System.Runtime]System.Int32 + IL_0013: call void Program::CountUpRef(int32, + int32&) + IL_0018: ldloc.0 + IL_0019: ldc.i4.0 + IL_001a: ldelem.i4 + IL_001b: ret + } // end of method '<>c'::'
b__5_6' + + .method assembly hidebysig instance string + '
b__5_7'() cil managed + { + // Code size 11 (0xb) + .maxstack 8 + IL_0000: ldstr "hello" + IL_0005: call string Program::GenName1Forward(!!0) + IL_000a: ret + } // end of method '<>c'::'
b__5_7' + + .method assembly hidebysig instance string + '
b__5_8'() cil managed + { + // Code size 11 (0xb) + .maxstack 8 + IL_0000: ldstr "hello" + IL_0005: call string Program::GenName1Forward(!!0) + IL_000a: ret + } // end of method '<>c'::'
b__5_8' + + .method assembly hidebysig instance string + '
b__5_9'() cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldc.i4.5 + IL_0001: call string Program::GenName1Forward(!!0) + IL_0006: ret + } // end of method '<>c'::'
b__5_9' + + .method assembly hidebysig instance string + '
b__5_10'() cil managed + { + // Code size 16 (0x10) + .maxstack 8 + IL_0000: ldstr "hello" + IL_0005: ldstr "hello2" + IL_000a: call string Program::GenName2ForwardBoth(!!0, + !!1) + IL_000f: ret + } // end of method '<>c'::'
b__5_10' + + .method assembly hidebysig instance string + '
b__5_11'() cil managed + { + // Code size 12 (0xc) + .maxstack 8 + IL_0000: ldstr "hello" + IL_0005: ldc.i4.5 + IL_0006: call string Program::GenName2ForwardBoth(!!0, + !!1) + IL_000b: ret + } // end of method '<>c'::'
b__5_11' + + .method assembly hidebysig instance string + '
b__5_12'() cil managed + { + // Code size 16 (0x10) + .maxstack 8 + IL_0000: ldstr "hello" + IL_0005: ldstr "hello2" + IL_000a: call string Program::GenName2ForwardOne(!!0, + string) + IL_000f: ret + } // end of method '<>c'::'
b__5_12' + + .method assembly hidebysig instance string + '
b__5_13'() cil managed + { + // Code size 16 (0x10) + .maxstack 8 + IL_0000: ldstr "hello" + IL_0005: ldstr "hello2" + IL_000a: call string Program::GenName2ForwardOne(!!0, + string) + IL_000f: ret + } // end of method '<>c'::'
b__5_13' + + .method assembly hidebysig instance string + '
b__5_14'() cil managed + { + // Code size 12 (0xc) + .maxstack 8 + IL_0000: ldc.i4.5 + IL_0001: ldstr "hello2" + IL_0006: call string Program::GenName2ForwardOne(!!0, + string) + IL_000b: ret + } // end of method '<>c'::'
b__5_14' + + .method assembly hidebysig instance string + '
b__5_15'() cil managed + { + // Code size 16 (0x10) + .maxstack 8 + IL_0000: ldstr "hello" + IL_0005: ldstr "hello2" + IL_000a: call string Program::GenName2ForwardNone(object, + string) + IL_000f: ret + } // end of method '<>c'::'
b__5_15' + + } // end of class '<>c' + + .field private static initonly native int s_calcStaticCalli + .field private static initonly native int s_calcStaticCalliOther + .field private static initonly native int s_calcStaticCalliRetbuf + .field private static initonly native int s_calcStaticCalliRetbufOther + .field static assembly int32 s_result + .method private hidebysig specialname rtspecialname static + void .cctor() cil managed + { + // Code size 53 (0x35) + .maxstack 1 + .locals init (native int V_0, + native int V_1, + native int V_2, + native int V_3) + IL_0000: ldftn int32 Program::CalcStaticCalli(int32, + int32) + IL_0006: stloc.0 + IL_0007: ldftn int32 Program::CalcStaticCalliOther(int32, + valuetype S32, + int32) + IL_000d: stloc.1 + IL_000e: ldftn valuetype S32 Program::CalcStaticCalliRetbuf(int32, + int32) + IL_0014: stloc.2 + IL_0015: ldftn valuetype S32 Program::CalcStaticCalliRetbufOther(int32, + valuetype S32, + int32) + IL_001b: stloc.3 + IL_001c: ldloc.0 + IL_001d: stsfld native int Program::s_calcStaticCalli + IL_0022: ldloc.1 + IL_0023: stsfld native int Program::s_calcStaticCalliOther + IL_0028: ldloc.2 + IL_0029: stsfld native int Program::s_calcStaticCalliRetbuf + IL_002e: ldloc.3 + IL_002f: stsfld native int Program::s_calcStaticCalliRetbufOther + IL_0034: ret + } // end of method Program::.cctor + + .method private hidebysig static int32 + Main() cil managed + { + .entrypoint + // Code size 1402 (0x57a) + .maxstack 4 + .locals init (class Program/'<>c__DisplayClass5_0' V_0, + int32 V_1, + valuetype S32 V_2, + int32 V_3, + class ClassImpl V_4, + class InterfaceImpl V_5, + int64 V_6, + valuetype S16 V_7, + valuetype S32 V_8, + valuetype S16 V_9, + valuetype S32 V_10) + IL_0000: newobj instance void Program/'<>c__DisplayClass5_0'::.ctor() + IL_0005: stloc.0 + IL_0006: ldc.i4 0xf4240 + IL_000b: stloc.1 + IL_000c: ldloca.s V_2 + IL_000e: initobj S32 + IL_0014: ldc.i4.0 + IL_0015: stloc.3 + IL_0016: br.s IL_0030 + + IL_0018: ldloc.1 + IL_0019: ldc.i4.2 + IL_001a: rem + IL_001b: brtrue.s IL_0025 + + IL_001d: ldloca.s V_2 + IL_001f: initobj S32 + IL_0025: ldloca.s V_1 + IL_0027: ldloca.s V_2 + IL_0029: ldloca.s V_3 + IL_002b: call void Program::Calc(int32&, + valuetype S32&, + int32&) + IL_0030: ldloc.1 + IL_0031: brtrue.s IL_0018 + + IL_0033: ldloc.0 + IL_0034: ldc.i4.1 + IL_0035: stfld bool Program/'<>c__DisplayClass5_0'::result + IL_003a: newobj instance void ClassImpl::.ctor() + IL_003f: stloc.s V_4 + IL_0041: ldloc.s V_4 + IL_0043: ldloc.s V_4 + IL_0045: callvirt instance void ClassImpl::set_Other(class BaseClass) + IL_004a: newobj instance void InterfaceImpl::.ctor() + IL_004f: stloc.s V_5 + IL_0051: ldloc.s V_5 + IL_0053: ldloc.s V_5 + IL_0055: callvirt instance void InterfaceImpl::set_Other(class IInterface) + IL_005a: ldloc.0 + IL_005b: newobj instance void class GenInstance`2::.ctor() + IL_0060: stfld class GenInstance`2 Program/'<>c__DisplayClass5_0'::g + IL_0065: ldloc.0 + IL_0066: newobj instance void class GenInterfaceImpl`2::.ctor() + IL_006b: stfld class IGenInterface`2 Program/'<>c__DisplayClass5_0'::ig + IL_0070: ldloc.0 + IL_0071: newobj instance void class GenInterfaceImpl`2::.ctor() + IL_0076: stfld class IGenInterface`2 Program/'<>c__DisplayClass5_0'::ig2 + IL_007b: ldloc.3 + IL_007c: conv.u8 + IL_007d: ldc.i4.s 32 + IL_007f: shl + IL_0080: ldloc.3 + IL_0081: conv.u8 + IL_0082: or + IL_0083: stloc.s V_6 + IL_0085: ldloca.s V_9 + IL_0087: initobj S16 + IL_008d: ldloca.s V_9 + IL_008f: ldloc.3 + IL_0090: conv.i8 + IL_0091: stfld int64 S16::A + IL_0096: ldloca.s V_9 + IL_0098: ldloc.3 + IL_0099: conv.i8 + IL_009a: stfld int64 S16::B + IL_009f: ldloc.s V_9 + IL_00a1: stloc.s V_7 + IL_00a3: ldloca.s V_10 + IL_00a5: initobj S32 + IL_00ab: ldloca.s V_10 + IL_00ad: ldloc.3 + IL_00ae: conv.i8 + IL_00af: stfld int64 S32::A + IL_00b4: ldloca.s V_10 + IL_00b6: ldloc.3 + IL_00b7: conv.i8 + IL_00b8: stfld int64 S32::B + IL_00bd: ldloca.s V_10 + IL_00bf: ldloc.3 + IL_00c0: conv.i8 + IL_00c1: stfld int64 S32::C + IL_00c6: ldloca.s V_10 + IL_00c8: ldloc.3 + IL_00c9: conv.i8 + IL_00ca: stfld int64 S32::D + IL_00cf: ldloc.s V_10 + IL_00d1: stloc.s V_8 + IL_00d3: ldloc.0 + IL_00d4: ldc.i4.s 10 + IL_00d6: stfld int32 Program/'<>c__DisplayClass5_0'::ten + IL_00db: ldloc.0 + IL_00dc: ldnull + IL_00dd: ldftn int32 Program::CalcStatic(int32, + int32) + IL_00e3: newobj instance void class [System.Runtime]System.Func`3::.ctor(object, + native int) + IL_00e8: ldloc.3 + IL_00e9: ldstr "Static non-generic" + IL_00ee: callvirt instance void Program/'<>c__DisplayClass5_0'::'
g__TestCalc|1'(class [System.Runtime]System.Func`3, + !!0, + string) + IL_00f3: ldloc.0 + IL_00f4: ldnull + IL_00f5: ldftn uint8 Program::CalcStaticSmall(int32, + int32) + IL_00fb: newobj instance void class [System.Runtime]System.Func`3::.ctor(object, + native int) + IL_0100: ldloc.3 + IL_0101: conv.u1 + IL_0102: ldstr "Static non-generic small" + IL_0107: callvirt instance void Program/'<>c__DisplayClass5_0'::'
g__TestCalc|1'(class [System.Runtime]System.Func`3, + !!0, + string) + IL_010c: ldloc.0 + IL_010d: ldnull + IL_010e: ldftn valuetype S32 Program::CalcStaticRetbuf(int32, + int32) + IL_0114: newobj instance void class [System.Runtime]System.Func`3::.ctor(object, + native int) + IL_0119: ldloc.s V_8 + IL_011b: ldstr "Static non-generic retbuf" + IL_0120: callvirt instance void Program/'<>c__DisplayClass5_0'::'
g__TestCalc|1'(class [System.Runtime]System.Func`3, + !!0, + string) + IL_0125: ldloc.0 + IL_0126: ldnull + IL_0127: ldftn int64 Program::CalcStaticLong(int32, + int32) + IL_012d: newobj instance void class [System.Runtime]System.Func`3::.ctor(object, + native int) + IL_0132: ldloc.s V_6 + IL_0134: ldstr "Static non-generic long" + IL_0139: callvirt instance void Program/'<>c__DisplayClass5_0'::'
g__TestCalc|1'(class [System.Runtime]System.Func`3, + !!0, + string) + IL_013e: ldloc.0 + IL_013f: ldnull + IL_0140: ldftn valuetype S16 Program::CalcStaticS16(int32, + int32) + IL_0146: newobj instance void class [System.Runtime]System.Func`3::.ctor(object, + native int) + IL_014b: ldloc.s V_7 + IL_014d: ldstr "Static non-generic S16" + IL_0152: callvirt instance void Program/'<>c__DisplayClass5_0'::'
g__TestCalc|1'(class [System.Runtime]System.Func`3, + !!0, + string) + IL_0157: ldloc.0 + IL_0158: ldsfld class [System.Runtime]System.Func`3 Program/'<>c'::'<>9__5_2' + IL_015d: dup + IL_015e: brtrue.s IL_0177 + + IL_0160: pop + IL_0161: ldsfld class Program/'<>c' Program/'<>c'::'<>9' + IL_0166: ldftn instance int32 Program/'<>c'::'
b__5_2'(int32, + int32) + IL_016c: newobj instance void class [System.Runtime]System.Func`3::.ctor(object, + native int) + IL_0171: dup + IL_0172: stsfld class [System.Runtime]System.Func`3 Program/'<>c'::'<>9__5_2' + IL_0177: ldloc.3 + IL_0178: ldstr "Static void" + IL_017d: callvirt instance void Program/'<>c__DisplayClass5_0'::'
g__TestCalc|1'(class [System.Runtime]System.Func`3, + !!0, + string) + IL_0182: ldloc.0 + IL_0183: newobj instance void Instance::.ctor() + IL_0188: ldftn instance int32 Instance::CalcInstance(int32, + int32) + IL_018e: newobj instance void class [System.Runtime]System.Func`3::.ctor(object, + native int) + IL_0193: ldloc.3 + IL_0194: ldstr "Instance non-generic" + IL_0199: callvirt instance void Program/'<>c__DisplayClass5_0'::'
g__TestCalc|1'(class [System.Runtime]System.Func`3, + !!0, + string) + IL_019e: ldloc.0 + IL_019f: newobj instance void Instance::.ctor() + IL_01a4: ldftn instance valuetype S32 Instance::CalcInstanceRetbuf(int32, + int32) + IL_01aa: newobj instance void class [System.Runtime]System.Func`3::.ctor(object, + native int) + IL_01af: ldloc.s V_8 + IL_01b1: ldstr "Instance non-generic retbuf" + IL_01b6: callvirt instance void Program/'<>c__DisplayClass5_0'::'
g__TestCalc|1'(class [System.Runtime]System.Func`3, + !!0, + string) + IL_01bb: ldloc.0 + IL_01bc: ldloc.s V_4 + IL_01be: dup + IL_01bf: ldvirtftn instance int32 BaseClass::CalcAbstract(int32, + int32) + IL_01c5: newobj instance void class [System.Runtime]System.Func`3::.ctor(object, + native int) + IL_01ca: ldloc.3 + IL_01cb: ldstr "Abstract class non-generic" + IL_01d0: callvirt instance void Program/'<>c__DisplayClass5_0'::'
g__TestCalc|1'(class [System.Runtime]System.Func`3, + !!0, + string) + IL_01d5: ldloc.0 + IL_01d6: ldloc.s V_4 + IL_01d8: dup + IL_01d9: ldvirtftn instance valuetype S32 BaseClass::CalcAbstractRetbuf(int32, + int32) + IL_01df: newobj instance void class [System.Runtime]System.Func`3::.ctor(object, + native int) + IL_01e4: ldloc.s V_8 + IL_01e6: ldstr "Abstract class non-generic retbuf" + IL_01eb: callvirt instance void Program/'<>c__DisplayClass5_0'::'
g__TestCalc|1'(class [System.Runtime]System.Func`3, + !!0, + string) + IL_01f0: ldloc.0 + IL_01f1: ldloc.s V_5 + IL_01f3: dup + IL_01f4: ldvirtftn instance int32 InterfaceImpl::CalcInterface(int32, + int32) + IL_01fa: newobj instance void class [System.Runtime]System.Func`3::.ctor(object, + native int) + IL_01ff: ldloc.3 + IL_0200: ldstr "Interface non-generic" + IL_0205: callvirt instance void Program/'<>c__DisplayClass5_0'::'
g__TestCalc|1'(class [System.Runtime]System.Func`3, + !!0, + string) + IL_020a: ldloc.0 + IL_020b: ldloc.s V_5 + IL_020d: dup + IL_020e: ldvirtftn instance valuetype S32 InterfaceImpl::CalcInterfaceRetbuf(int32, + int32) + IL_0214: newobj instance void class [System.Runtime]System.Func`3::.ctor(object, + native int) + IL_0219: ldloc.s V_8 + IL_021b: ldstr "Interface non-generic retbuf" + IL_0220: callvirt instance void Program/'<>c__DisplayClass5_0'::'
g__TestCalc|1'(class [System.Runtime]System.Func`3, + !!0, + string) + IL_0225: ldloc.0 + IL_0226: ldnull + IL_0227: ldftn int32 Program::CalcStaticCalli(int32, + int32) + IL_022d: newobj instance void class [System.Runtime]System.Func`3::.ctor(object, + native int) + IL_0232: ldloc.3 + IL_0233: ldstr "Static calli" + IL_0238: callvirt instance void Program/'<>c__DisplayClass5_0'::'
g__TestCalc|1'(class [System.Runtime]System.Func`3, + !!0, + string) + IL_023d: ldloc.0 + IL_023e: ldnull + IL_023f: ldftn valuetype S32 Program::CalcStaticCalliRetbuf(int32, + int32) + IL_0245: newobj instance void class [System.Runtime]System.Func`3::.ctor(object, + native int) + IL_024a: ldloc.s V_8 + IL_024c: ldstr "Static calli retbuf" + IL_0251: callvirt instance void Program/'<>c__DisplayClass5_0'::'
g__TestCalc|1'(class [System.Runtime]System.Func`3, + !!0, + string) + IL_0256: ldloc.0 + IL_0257: newobj instance void Instance::.ctor() + IL_025c: ldftn instance int32 Instance::CalcInstanceCalli(int32, + int32) + IL_0262: newobj instance void class [System.Runtime]System.Func`3::.ctor(object, + native int) + IL_0267: ldloc.3 + IL_0268: ldstr "Instance calli" + IL_026d: callvirt instance void Program/'<>c__DisplayClass5_0'::'
g__TestCalc|1'(class [System.Runtime]System.Func`3, + !!0, + string) + IL_0272: ldloc.0 + IL_0273: newobj instance void Instance::.ctor() + IL_0278: ldftn instance valuetype S32 Instance::CalcInstanceCalliRetbuf(int32, + int32) + IL_027e: newobj instance void class [System.Runtime]System.Func`3::.ctor(object, + native int) + IL_0283: ldloc.s V_8 + IL_0285: ldstr "Instance calli retbuf" + IL_028a: callvirt instance void Program/'<>c__DisplayClass5_0'::'
g__TestCalc|1'(class [System.Runtime]System.Func`3, + !!0, + string) + IL_028f: ldloc.0 + IL_0290: ldsfld class [System.Runtime]System.Func`1 Program/'<>c'::'<>9__5_3' + IL_0295: dup + IL_0296: brtrue.s IL_02af + + IL_0298: pop + IL_0299: ldsfld class Program/'<>c' Program/'<>c'::'<>9' + IL_029e: ldftn instance int32 Program/'<>c'::'
b__5_3'() + IL_02a4: newobj instance void class [System.Runtime]System.Func`1::.ctor(object, + native int) + IL_02a9: dup + IL_02aa: stsfld class [System.Runtime]System.Func`1 Program/'<>c'::'<>9__5_3' + IL_02af: ldc.i4 0xf4240 + IL_02b4: ldstr "Value type instance call" + IL_02b9: callvirt instance void Program/'<>c__DisplayClass5_0'::'
g__Test|0'(class [System.Runtime]System.Func`1, + !!0, + string) + IL_02be: ldloc.0 + IL_02bf: ldloc.0 + IL_02c0: ldftn instance string Program/'<>c__DisplayClass5_0'::'
b__4'() + IL_02c6: newobj instance void class [System.Runtime]System.Func`1::.ctor(object, + native int) + IL_02cb: ldstr "2 3 4 5 6 7 8 9 10" + IL_02d0: ldstr "Instance with GC" + IL_02d5: callvirt instance void Program/'<>c__DisplayClass5_0'::'
g__Test|0'(class [System.Runtime]System.Func`1, + !!0, + string) + IL_02da: ldloc.0 + IL_02db: ldsfld class [System.Runtime]System.Func`1 Program/'<>c'::'<>9__5_5' + IL_02e0: dup + IL_02e1: brtrue.s IL_02fa + + IL_02e3: pop + IL_02e4: ldsfld class Program/'<>c' Program/'<>c'::'<>9' + IL_02e9: ldftn instance int32 Program/'<>c'::'
b__5_5'() + IL_02ef: newobj instance void class [System.Runtime]System.Func`1::.ctor(object, + native int) + IL_02f4: dup + IL_02f5: stsfld class [System.Runtime]System.Func`1 Program/'<>c'::'<>9__5_5' + IL_02fa: ldc.i4 0xf4240 + IL_02ff: ldstr "Count up with heap int" + IL_0304: callvirt instance void Program/'<>c__DisplayClass5_0'::'
g__Test|0'(class [System.Runtime]System.Func`1, + !!0, + string) + IL_0309: ldloc.0 + IL_030a: ldsfld class [System.Runtime]System.Func`1 Program/'<>c'::'<>9__5_6' + IL_030f: dup + IL_0310: brtrue.s IL_0329 + + IL_0312: pop + IL_0313: ldsfld class Program/'<>c' Program/'<>c'::'<>9' + IL_0318: ldftn instance int32 Program/'<>c'::'
b__5_6'() + IL_031e: newobj instance void class [System.Runtime]System.Func`1::.ctor(object, + native int) + IL_0323: dup + IL_0324: stsfld class [System.Runtime]System.Func`1 Program/'<>c'::'<>9__5_6' + IL_0329: ldc.i4 0xf4240 + IL_032e: ldstr "Count up with byref to heap" + IL_0333: callvirt instance void Program/'<>c__DisplayClass5_0'::'
g__Test|0'(class [System.Runtime]System.Func`1, + !!0, + string) + IL_0338: ldloc.0 + IL_0339: ldsfld class [System.Runtime]System.Func`1 Program/'<>c'::'<>9__5_7' + IL_033e: dup + IL_033f: brtrue.s IL_0358 + + IL_0341: pop + IL_0342: ldsfld class Program/'<>c' Program/'<>c'::'<>9' + IL_0347: ldftn instance string Program/'<>c'::'
b__5_7'() + IL_034d: newobj instance void class [System.Runtime]System.Func`1::.ctor(object, + native int) + IL_0352: dup + IL_0353: stsfld class [System.Runtime]System.Func`1 Program/'<>c'::'<>9__5_7' + IL_0358: ldstr "System.String hello" + IL_035d: ldstr "Static generic string" + IL_0362: callvirt instance void Program/'<>c__DisplayClass5_0'::'
g__Test|0'(class [System.Runtime]System.Func`1, + !!0, + string) + IL_0367: ldloc.0 + IL_0368: ldsfld class [System.Runtime]System.Func`1 Program/'<>c'::'<>9__5_8' + IL_036d: dup + IL_036e: brtrue.s IL_0387 + + IL_0370: pop + IL_0371: ldsfld class Program/'<>c' Program/'<>c'::'<>9' + IL_0376: ldftn instance string Program/'<>c'::'
b__5_8'() + IL_037c: newobj instance void class [System.Runtime]System.Func`1::.ctor(object, + native int) + IL_0381: dup + IL_0382: stsfld class [System.Runtime]System.Func`1 Program/'<>c'::'<>9__5_8' + IL_0387: ldstr "System.Object hello" + IL_038c: ldstr "Static generic object" + IL_0391: callvirt instance void Program/'<>c__DisplayClass5_0'::'
g__Test|0'(class [System.Runtime]System.Func`1, + !!0, + string) + IL_0396: ldloc.0 + IL_0397: ldsfld class [System.Runtime]System.Func`1 Program/'<>c'::'<>9__5_9' + IL_039c: dup + IL_039d: brtrue.s IL_03b6 + + IL_039f: pop + IL_03a0: ldsfld class Program/'<>c' Program/'<>c'::'<>9' + IL_03a5: ldftn instance string Program/'<>c'::'
b__5_9'() + IL_03ab: newobj instance void class [System.Runtime]System.Func`1::.ctor(object, + native int) + IL_03b0: dup + IL_03b1: stsfld class [System.Runtime]System.Func`1 Program/'<>c'::'<>9__5_9' + IL_03b6: ldstr "System.Int32 5" + IL_03bb: ldstr "Static generic int" + IL_03c0: callvirt instance void Program/'<>c__DisplayClass5_0'::'
g__Test|0'(class [System.Runtime]System.Func`1, + !!0, + string) + IL_03c5: ldloc.0 + IL_03c6: ldsfld class [System.Runtime]System.Func`1 Program/'<>c'::'<>9__5_10' + IL_03cb: dup + IL_03cc: brtrue.s IL_03e5 + + IL_03ce: pop + IL_03cf: ldsfld class Program/'<>c' Program/'<>c'::'<>9' + IL_03d4: ldftn instance string Program/'<>c'::'
b__5_10'() + IL_03da: newobj instance void class [System.Runtime]System.Func`1::.ctor(object, + native int) + IL_03df: dup + IL_03e0: stsfld class [System.Runtime]System.Func`1 Program/'<>c'::'<>9__5_10' + IL_03e5: ldstr "System.String System.Object hello hello2" + IL_03ea: ldstr "Static generic 2 string object" + IL_03ef: callvirt instance void Program/'<>c__DisplayClass5_0'::'
g__Test|0'(class [System.Runtime]System.Func`1, + !!0, + string) + IL_03f4: ldloc.0 + IL_03f5: ldsfld class [System.Runtime]System.Func`1 Program/'<>c'::'<>9__5_11' + IL_03fa: dup + IL_03fb: brtrue.s IL_0414 + + IL_03fd: pop + IL_03fe: ldsfld class Program/'<>c' Program/'<>c'::'<>9' + IL_0403: ldftn instance string Program/'<>c'::'
b__5_11'() + IL_0409: newobj instance void class [System.Runtime]System.Func`1::.ctor(object, + native int) + IL_040e: dup + IL_040f: stsfld class [System.Runtime]System.Func`1 Program/'<>c'::'<>9__5_11' + IL_0414: ldstr "System.String System.Int32 hello 5" + IL_0419: ldstr "Static generic 2 string int" + IL_041e: callvirt instance void Program/'<>c__DisplayClass5_0'::'
g__Test|0'(class [System.Runtime]System.Func`1, + !!0, + string) + IL_0423: ldloc.0 + IL_0424: ldsfld class [System.Runtime]System.Func`1 Program/'<>c'::'<>9__5_12' + IL_0429: dup + IL_042a: brtrue.s IL_0443 + + IL_042c: pop + IL_042d: ldsfld class Program/'<>c' Program/'<>c'::'<>9' + IL_0432: ldftn instance string Program/'<>c'::'
b__5_12'() + IL_0438: newobj instance void class [System.Runtime]System.Func`1::.ctor(object, + native int) + IL_043d: dup + IL_043e: stsfld class [System.Runtime]System.Func`1 Program/'<>c'::'<>9__5_12' + IL_0443: ldstr "System.String System.String hello hello2" + IL_0448: ldstr "Static generic 1 string" + IL_044d: callvirt instance void Program/'<>c__DisplayClass5_0'::'
g__Test|0'(class [System.Runtime]System.Func`1, + !!0, + string) + IL_0452: ldloc.0 + IL_0453: ldsfld class [System.Runtime]System.Func`1 Program/'<>c'::'<>9__5_13' + IL_0458: dup + IL_0459: brtrue.s IL_0472 + + IL_045b: pop + IL_045c: ldsfld class Program/'<>c' Program/'<>c'::'<>9' + IL_0461: ldftn instance string Program/'<>c'::'
b__5_13'() + IL_0467: newobj instance void class [System.Runtime]System.Func`1::.ctor(object, + native int) + IL_046c: dup + IL_046d: stsfld class [System.Runtime]System.Func`1 Program/'<>c'::'<>9__5_13' + IL_0472: ldstr "System.Object System.String hello hello2" + IL_0477: ldstr "Static generic 1 object" + IL_047c: callvirt instance void Program/'<>c__DisplayClass5_0'::'
g__Test|0'(class [System.Runtime]System.Func`1, + !!0, + string) + IL_0481: ldloc.0 + IL_0482: ldsfld class [System.Runtime]System.Func`1 Program/'<>c'::'<>9__5_14' + IL_0487: dup + IL_0488: brtrue.s IL_04a1 + + IL_048a: pop + IL_048b: ldsfld class Program/'<>c' Program/'<>c'::'<>9' + IL_0490: ldftn instance string Program/'<>c'::'
b__5_14'() + IL_0496: newobj instance void class [System.Runtime]System.Func`1::.ctor(object, + native int) + IL_049b: dup + IL_049c: stsfld class [System.Runtime]System.Func`1 Program/'<>c'::'<>9__5_14' + IL_04a1: ldstr "System.Int32 System.String 5 hello2" + IL_04a6: ldstr "Static generic 1 int" + IL_04ab: callvirt instance void Program/'<>c__DisplayClass5_0'::'
g__Test|0'(class [System.Runtime]System.Func`1, + !!0, + string) + IL_04b0: ldloc.0 + IL_04b1: ldsfld class [System.Runtime]System.Func`1 Program/'<>c'::'<>9__5_15' + IL_04b6: dup + IL_04b7: brtrue.s IL_04d0 + + IL_04b9: pop + IL_04ba: ldsfld class Program/'<>c' Program/'<>c'::'<>9' + IL_04bf: ldftn instance string Program/'<>c'::'
b__5_15'() + IL_04c5: newobj instance void class [System.Runtime]System.Func`1::.ctor(object, + native int) + IL_04ca: dup + IL_04cb: stsfld class [System.Runtime]System.Func`1 Program/'<>c'::'<>9__5_15' + IL_04d0: ldstr "System.Object System.String hello hello2" + IL_04d5: ldstr "Static generic 0" + IL_04da: callvirt instance void Program/'<>c__DisplayClass5_0'::'
g__Test|0'(class [System.Runtime]System.Func`1, + !!0, + string) + IL_04df: ldloc.0 + IL_04e0: ldloc.0 + IL_04e1: ldftn instance string Program/'<>c__DisplayClass5_0'::'
b__16'() + IL_04e7: newobj instance void class [System.Runtime]System.Func`1::.ctor(object, + native int) + IL_04ec: ldstr "System.String System.Int32 System.Object System.St" + + "ring a 5 b c" + IL_04f1: ldstr "Instance generic 4" + IL_04f6: callvirt instance void Program/'<>c__DisplayClass5_0'::'
g__Test|0'(class [System.Runtime]System.Func`1, + !!0, + string) + IL_04fb: ldloc.0 + IL_04fc: ldloc.0 + IL_04fd: ldftn instance string Program/'<>c__DisplayClass5_0'::'
b__17'() + IL_0503: newobj instance void class [System.Runtime]System.Func`1::.ctor(object, + native int) + IL_0508: ldstr "System.String System.Int32 System.Object System.St" + + "ring a 5 b c" + IL_050d: ldstr "Virtual instance generic 4" + IL_0512: callvirt instance void Program/'<>c__DisplayClass5_0'::'
g__Test|0'(class [System.Runtime]System.Func`1, + !!0, + string) + IL_0517: ldloc.0 + IL_0518: ldloc.0 + IL_0519: ldftn instance string Program/'<>c__DisplayClass5_0'::'
b__18'() + IL_051f: newobj instance void class [System.Runtime]System.Func`1::.ctor(object, + native int) + IL_0524: ldstr "System.String System.Int32 System.String System.Ob" + + "ject a 5 c d" + IL_0529: ldstr "Interface generic 4" + IL_052e: callvirt instance void Program/'<>c__DisplayClass5_0'::'
g__Test|0'(class [System.Runtime]System.Func`1, + !!0, + string) + IL_0533: ldloc.0 + IL_0534: ldloc.0 + IL_0535: ldftn instance string Program/'<>c__DisplayClass5_0'::'
b__19'() + IL_053b: newobj instance void class [System.Runtime]System.Func`1::.ctor(object, + native int) + IL_0540: ldstr "System.String System.Object System.Int32 System.Ob" + + "ject a b 5 d" + IL_0545: ldstr "Interface generic 0" + IL_054a: callvirt instance void Program/'<>c__DisplayClass5_0'::'
g__Test|0'(class [System.Runtime]System.Func`1, + !!0, + string) + IL_054f: ldloc.0 + IL_0550: ldfld bool Program/'<>c__DisplayClass5_0'::result + IL_0555: brfalse.s IL_0563 + + IL_0557: ldstr "All tailcall-via-help succeeded" + IL_055c: call void [System.Console]System.Console::WriteLine(string) + IL_0561: br.s IL_056d + + IL_0563: ldstr "One or more failures in tailcall-via-help test" + IL_0568: call void [System.Console]System.Console::WriteLine(string) + IL_056d: ldloc.0 + IL_056e: ldfld bool Program/'<>c__DisplayClass5_0'::result + IL_0573: brtrue.s IL_0577 + + IL_0575: ldc.i4.1 + IL_0576: ret + + IL_0577: ldc.i4.s 100 + IL_0579: ret + } // end of method Program::Main + + .method public hidebysig static void Calc(int32& x, + valuetype S32& s, + int32& acc) cil managed + { + // Code size 166 (0xa6) + .maxstack 5 + IL_0000: ldarg.0 + IL_0001: ldind.i4 + IL_0002: ldc.i4.2 + IL_0003: rem + IL_0004: brtrue.s IL_003d + + IL_0006: ldarg.2 + IL_0007: ldarg.2 + IL_0008: ldind.i4 + IL_0009: ldarg.0 + IL_000a: ldind.i4 + IL_000b: ldc.i4.3 + IL_000c: mul + IL_000d: conv.i8 + IL_000e: ldarg.1 + IL_000f: ldfld int64 S32::A + IL_0014: ldc.i4.7 + IL_0015: conv.i8 + IL_0016: mul + IL_0017: add + IL_0018: ldarg.1 + IL_0019: ldfld int64 S32::B + IL_001e: ldc.i4.s 9 + IL_0020: conv.i8 + IL_0021: mul + IL_0022: add + IL_0023: ldarg.1 + IL_0024: ldfld int64 S32::C + IL_0029: ldc.i4.s -3 + IL_002b: conv.i8 + IL_002c: mul + IL_002d: add + IL_002e: ldarg.1 + IL_002f: ldfld int64 S32::D + IL_0034: ldc.i4.4 + IL_0035: conv.i8 + IL_0036: mul + IL_0037: add + IL_0038: conv.i4 + IL_0039: add + IL_003a: stind.i4 + IL_003b: br.s IL_0070 + + IL_003d: ldarg.2 + IL_003e: ldarg.2 + IL_003f: ldind.i4 + IL_0040: ldarg.0 + IL_0041: ldind.i4 + IL_0042: conv.i8 + IL_0043: ldarg.1 + IL_0044: ldfld int64 S32::A + IL_0049: ldc.i4.s 9 + IL_004b: conv.i8 + IL_004c: mul + IL_004d: add + IL_004e: ldarg.1 + IL_004f: ldfld int64 S32::B + IL_0054: ldc.i4.3 + IL_0055: conv.i8 + IL_0056: mul + IL_0057: add + IL_0058: ldarg.1 + IL_0059: ldfld int64 S32::C + IL_005e: ldc.i4.s -4 + IL_0060: conv.i8 + IL_0061: mul + IL_0062: add + IL_0063: ldarg.1 + IL_0064: ldfld int64 S32::D + IL_0069: ldc.i4.5 + IL_006a: conv.i8 + IL_006b: mul + IL_006c: add + IL_006d: conv.i4 + IL_006e: add + IL_006f: stind.i4 + IL_0070: ldarg.0 + IL_0071: ldarg.0 + IL_0072: ldind.i4 + IL_0073: ldc.i4.1 + IL_0074: sub + IL_0075: stind.i4 + IL_0076: ldarg.1 + IL_0077: ldc.i4.s 11 + IL_0079: ldarg.0 + IL_007a: ldind.i4 + IL_007b: mul + IL_007c: conv.i8 + IL_007d: stfld int64 S32::A + IL_0082: ldarg.1 + IL_0083: ldc.i4.s 14 + IL_0085: ldarg.0 + IL_0086: ldind.i4 + IL_0087: mul + IL_0088: conv.i8 + IL_0089: stfld int64 S32::B + IL_008e: ldarg.1 + IL_008f: ldc.i4.s -14 + IL_0091: ldarg.0 + IL_0092: ldind.i4 + IL_0093: mul + IL_0094: conv.i8 + IL_0095: stfld int64 S32::C + IL_009a: ldarg.1 + IL_009b: ldc.i4.3 + IL_009c: ldarg.0 + IL_009d: ldind.i4 + IL_009e: mul + IL_009f: conv.i8 + IL_00a0: stfld int64 S32::D + IL_00a5: ret + } // end of method Program::Calc + + .method private hidebysig static int32 + CalcStatic(int32 x, + int32 acc) cil managed noinlining + { + // Code size 35 (0x23) + .maxstack 3 + .locals init (valuetype S32 V_0) + IL_0000: ldarg.0 + IL_0001: brtrue.s IL_0005 + + IL_0003: ldarg.1 + IL_0004: ret + + IL_0005: ldloca.s V_0 + IL_0007: initobj S32 + IL_000d: ldarga.s x + IL_000f: ldloca.s V_0 + IL_0011: ldarga.s acc + IL_0013: call void Program::Calc(int32&, + valuetype S32&, + int32&) + IL_0018: ldarg.0 + IL_0019: ldloc.0 + IL_001a: ldarg.1 + IL_001b: tail. + IL_001d: call int32 Program::CalcStaticOther(int32, + valuetype S32, + int32) + IL_0022: ret + } // end of method Program::CalcStatic + + .method private hidebysig static int32 + CalcStaticOther(int32 x, + valuetype S32 large, + int32 acc) cil managed noinlining + { + // Code size 21 (0x15) + .maxstack 3 + IL_0000: ldarga.s x + IL_0002: ldarga.s large + IL_0004: ldarga.s acc + IL_0006: call void Program::Calc(int32&, + valuetype S32&, + int32&) + IL_000b: ldarg.0 + IL_000c: ldarg.2 + IL_000d: tail. + IL_000f: call int32 Program::CalcStatic(int32, + int32) + IL_0014: ret + } // end of method Program::CalcStaticOther + + .method private hidebysig static uint8 + CalcStaticSmall(int32 x, + int32 acc) cil managed noinlining + { + // Code size 36 (0x24) + .maxstack 3 + .locals init (valuetype S32 V_0) + IL_0000: ldarg.0 + IL_0001: brtrue.s IL_0006 + + IL_0003: ldarg.1 + IL_0004: conv.u1 + IL_0005: ret + + IL_0006: ldloca.s V_0 + IL_0008: initobj S32 + IL_000e: ldarga.s x + IL_0010: ldloca.s V_0 + IL_0012: ldarga.s acc + IL_0014: call void Program::Calc(int32&, + valuetype S32&, + int32&) + IL_0019: ldarg.0 + IL_001a: ldloc.0 + IL_001b: ldarg.1 + IL_001c: tail. + IL_001e: call uint8 Program::CalcStaticSmallOther(int32, + valuetype S32, + int32) + IL_0023: ret + } // end of method Program::CalcStaticSmall + + .method private hidebysig static uint8 + CalcStaticSmallOther(int32 x, + valuetype S32 large, + int32 acc) cil managed noinlining + { + // Code size 21 (0x15) + .maxstack 3 + IL_0000: ldarga.s x + IL_0002: ldarga.s large + IL_0004: ldarga.s acc + IL_0006: call void Program::Calc(int32&, + valuetype S32&, + int32&) + IL_000b: ldarg.0 + IL_000c: ldarg.2 + IL_000d: tail. + IL_000f: call uint8 Program::CalcStaticSmall(int32, + int32) + IL_0014: ret + } // end of method Program::CalcStaticSmallOther + + .method private hidebysig static valuetype S32 + CalcStaticRetbuf(int32 x, + int32 acc) cil managed noinlining + { + // Code size 79 (0x4f) + .maxstack 3 + .locals init (valuetype S32 V_0, + valuetype S32 V_1) + IL_0000: ldarg.0 + IL_0001: brtrue.s IL_0031 + + IL_0003: ldloca.s V_1 + IL_0005: initobj S32 + IL_000b: ldloca.s V_1 + IL_000d: ldarg.1 + IL_000e: conv.i8 + IL_000f: stfld int64 S32::A + IL_0014: ldloca.s V_1 + IL_0016: ldarg.1 + IL_0017: conv.i8 + IL_0018: stfld int64 S32::B + IL_001d: ldloca.s V_1 + IL_001f: ldarg.1 + IL_0020: conv.i8 + IL_0021: stfld int64 S32::C + IL_0026: ldloca.s V_1 + IL_0028: ldarg.1 + IL_0029: conv.i8 + IL_002a: stfld int64 S32::D + IL_002f: ldloc.1 + IL_0030: ret + + IL_0031: ldloca.s V_0 + IL_0033: initobj S32 + IL_0039: ldarga.s x + IL_003b: ldloca.s V_0 + IL_003d: ldarga.s acc + IL_003f: call void Program::Calc(int32&, + valuetype S32&, + int32&) + IL_0044: ldarg.0 + IL_0045: ldloc.0 + IL_0046: ldarg.1 + IL_0047: tail. + IL_0049: call valuetype S32 Program::CalcStaticRetbufOther(int32, + valuetype S32, + int32) + IL_004e: ret + } // end of method Program::CalcStaticRetbuf + + .method private hidebysig static valuetype S32 + CalcStaticRetbufOther(int32 x, + valuetype S32 large, + int32 acc) cil managed noinlining + { + // Code size 21 (0x15) + .maxstack 3 + IL_0000: ldarga.s x + IL_0002: ldarga.s large + IL_0004: ldarga.s acc + IL_0006: call void Program::Calc(int32&, + valuetype S32&, + int32&) + IL_000b: ldarg.0 + IL_000c: ldarg.2 + IL_000d: tail. + IL_000f: call valuetype S32 Program::CalcStaticRetbuf(int32, + int32) + IL_0014: ret + } // end of method Program::CalcStaticRetbufOther + + .method private hidebysig static int64 + CalcStaticLong(int32 x, + int32 acc) cil managed noinlining + { + // Code size 42 (0x2a) + .maxstack 3 + .locals init (valuetype S32 V_0) + IL_0000: ldarg.0 + IL_0001: brtrue.s IL_000c + + IL_0003: ldarg.1 + IL_0004: conv.u8 + IL_0005: ldc.i4.s 32 + IL_0007: shl + IL_0008: ldarg.1 + IL_0009: conv.u8 + IL_000a: or + IL_000b: ret + + IL_000c: ldloca.s V_0 + IL_000e: initobj S32 + IL_0014: ldarga.s x + IL_0016: ldloca.s V_0 + IL_0018: ldarga.s acc + IL_001a: call void Program::Calc(int32&, + valuetype S32&, + int32&) + IL_001f: ldarg.0 + IL_0020: ldloc.0 + IL_0021: ldarg.1 + IL_0022: tail. + IL_0024: call int64 Program::CalcStaticLongOther(int32, + valuetype S32, + int32) + IL_0029: ret + } // end of method Program::CalcStaticLong + + .method private hidebysig static int64 + CalcStaticLongOther(int32 x, + valuetype S32 large, + int32 acc) cil managed noinlining + { + // Code size 21 (0x15) + .maxstack 3 + IL_0000: ldarga.s x + IL_0002: ldarga.s large + IL_0004: ldarga.s acc + IL_0006: call void Program::Calc(int32&, + valuetype S32&, + int32&) + IL_000b: ldarg.0 + IL_000c: ldarg.2 + IL_000d: tail. + IL_000f: call int64 Program::CalcStaticLong(int32, + int32) + IL_0014: ret + } // end of method Program::CalcStaticLongOther + + .method private hidebysig static valuetype S16 + CalcStaticS16(int32 x, + int32 acc) cil managed noinlining + { + // Code size 61 (0x3d) + .maxstack 3 + .locals init (valuetype S32 V_0, + valuetype S16 V_1) + IL_0000: ldarg.0 + IL_0001: brtrue.s IL_001f + + IL_0003: ldloca.s V_1 + IL_0005: initobj S16 + IL_000b: ldloca.s V_1 + IL_000d: ldarg.1 + IL_000e: conv.i8 + IL_000f: stfld int64 S16::A + IL_0014: ldloca.s V_1 + IL_0016: ldarg.1 + IL_0017: conv.i8 + IL_0018: stfld int64 S16::B + IL_001d: ldloc.1 + IL_001e: ret + + IL_001f: ldloca.s V_0 + IL_0021: initobj S32 + IL_0027: ldarga.s x + IL_0029: ldloca.s V_0 + IL_002b: ldarga.s acc + IL_002d: call void Program::Calc(int32&, + valuetype S32&, + int32&) + IL_0032: ldarg.0 + IL_0033: ldloc.0 + IL_0034: ldarg.1 + IL_0035: tail. + IL_0037: call valuetype S16 Program::CalcStaticS16Other(int32, + valuetype S32, + int32) + IL_003c: ret + } // end of method Program::CalcStaticS16 + + .method private hidebysig static valuetype S16 + CalcStaticS16Other(int32 x, + valuetype S32 large, + int32 acc) cil managed noinlining + { + // Code size 21 (0x15) + .maxstack 3 + IL_0000: ldarga.s x + IL_0002: ldarga.s large + IL_0004: ldarga.s acc + IL_0006: call void Program::Calc(int32&, + valuetype S32&, + int32&) + IL_000b: ldarg.0 + IL_000c: ldarg.2 + IL_000d: tail. + IL_000f: call valuetype S16 Program::CalcStaticS16(int32, + int32) + IL_0014: ret + } // end of method Program::CalcStaticS16Other + + .method private hidebysig static int32 + CalcStaticCalli(int32 x, + int32 acc) cil managed noinlining + { + // Code size 40 (0x28) + .maxstack 4 + .locals init (valuetype S32 V_0) + IL_0000: ldarg.0 + IL_0001: brtrue.s IL_0005 + + IL_0003: ldarg.1 + IL_0004: ret + + IL_0005: ldloca.s V_0 + IL_0007: initobj S32 + IL_000d: ldarga.s x + IL_000f: ldloca.s V_0 + IL_0011: ldarga.s acc + IL_0013: call void Program::Calc(int32&, + valuetype S32&, + int32&) + IL_0018: ldarg.0 + IL_0019: ldloc.0 + IL_001a: ldarg.1 + IL_001b: ldsfld native int Program::s_calcStaticCalliOther + IL_0020: tail. + IL_0022: calli int32(int32,valuetype S32,int32) + IL_0027: ret + } // end of method Program::CalcStaticCalli + + .method private hidebysig static int32 + CalcStaticCalliOther(int32 x, + valuetype S32 large, + int32 acc) cil managed noinlining + { + // Code size 26 (0x1a) + .maxstack 3 + IL_0000: ldarga.s x + IL_0002: ldarga.s large + IL_0004: ldarga.s acc + IL_0006: call void Program::Calc(int32&, + valuetype S32&, + int32&) + IL_000b: ldarg.0 + IL_000c: ldarg.2 + IL_000d: ldsfld native int Program::s_calcStaticCalli + IL_0012: tail. + IL_0014: calli int32(int32,int32) + IL_0019: ret + } // end of method Program::CalcStaticCalliOther + + .method private hidebysig static valuetype S32 + CalcStaticCalliRetbuf(int32 x, + int32 acc) cil managed noinlining + { + // Code size 84 (0x54) + .maxstack 4 + .locals init (valuetype S32 V_0, + valuetype S32 V_1) + IL_0000: ldarg.0 + IL_0001: brtrue.s IL_0031 + + IL_0003: ldloca.s V_1 + IL_0005: initobj S32 + IL_000b: ldloca.s V_1 + IL_000d: ldarg.1 + IL_000e: conv.i8 + IL_000f: stfld int64 S32::A + IL_0014: ldloca.s V_1 + IL_0016: ldarg.1 + IL_0017: conv.i8 + IL_0018: stfld int64 S32::B + IL_001d: ldloca.s V_1 + IL_001f: ldarg.1 + IL_0020: conv.i8 + IL_0021: stfld int64 S32::C + IL_0026: ldloca.s V_1 + IL_0028: ldarg.1 + IL_0029: conv.i8 + IL_002a: stfld int64 S32::D + IL_002f: ldloc.1 + IL_0030: ret + + IL_0031: ldloca.s V_0 + IL_0033: initobj S32 + IL_0039: ldarga.s x + IL_003b: ldloca.s V_0 + IL_003d: ldarga.s acc + IL_003f: call void Program::Calc(int32&, + valuetype S32&, + int32&) + IL_0044: ldarg.0 + IL_0045: ldloc.0 + IL_0046: ldarg.1 + IL_0047: ldsfld native int Program::s_calcStaticCalliRetbufOther + IL_004c: tail. + IL_004e: calli valuetype S32(int32,valuetype S32,int32) + IL_0053: ret + } // end of method Program::CalcStaticCalliRetbuf + + .method private hidebysig static valuetype S32 + CalcStaticCalliRetbufOther(int32 x, + valuetype S32 large, + int32 acc) cil managed noinlining + { + // Code size 26 (0x1a) + .maxstack 3 + IL_0000: ldarga.s x + IL_0002: ldarga.s large + IL_0004: ldarga.s acc + IL_0006: call void Program::Calc(int32&, + valuetype S32&, + int32&) + IL_000b: ldarg.0 + IL_000c: ldarg.2 + IL_000d: ldsfld native int Program::s_calcStaticCalliRetbuf + IL_0012: tail. + IL_0014: calli valuetype S32(int32,int32) + IL_0019: ret + } // end of method Program::CalcStaticCalliRetbufOther + + .method private hidebysig static void CalcStaticVoid(int32 x, + int32 acc) cil managed noinlining + { + // Code size 40 (0x28) + .maxstack 3 + .locals init (valuetype S32 V_0) + IL_0000: ldarg.0 + IL_0001: brtrue.s IL_000a + + IL_0003: ldarg.1 + IL_0004: stsfld int32 Program::s_result + IL_0009: ret + + IL_000a: ldloca.s V_0 + IL_000c: initobj S32 + IL_0012: ldarga.s x + IL_0014: ldloca.s V_0 + IL_0016: ldarga.s acc + IL_0018: call void Program::Calc(int32&, + valuetype S32&, + int32&) + IL_001d: ldarg.0 + IL_001e: ldloc.0 + IL_001f: ldarg.1 + IL_0020: tail. + IL_0022: call void Program::CalcStaticVoidOther(int32, + valuetype S32, + int32) + IL_0027: ret + } // end of method Program::CalcStaticVoid + + .method private hidebysig static void CalcStaticVoidOther(int32 x, + valuetype S32 large, + int32 acc) cil managed noinlining + { + // Code size 21 (0x15) + .maxstack 8 + IL_0000: ldarga.s x + IL_0002: ldarga.s large + IL_0004: ldarga.s acc + IL_0006: call void Program::Calc(int32&, + valuetype S32&, + int32&) + IL_000b: ldarg.0 + IL_000c: ldarg.2 + IL_000d: tail. + IL_000f: call void Program::CalcStaticVoid(int32, + int32) + IL_0014: ret + } // end of method Program::CalcStaticVoidOther + + .method private hidebysig static int32 + CountUpHeap(int32 left, + class HeapInt counter) cil managed noinlining + { + // Code size 43 (0x2b) + .maxstack 4 + .locals init (valuetype S32 V_0) + IL_0000: ldarg.0 + IL_0001: brtrue.s IL_000a + + IL_0003: ldarg.1 + IL_0004: ldfld int32 HeapInt::Value + IL_0009: ret + + IL_000a: ldarg.0 + IL_000b: ldc.i4.1 + IL_000c: sub + IL_000d: ldloca.s V_0 + IL_000f: initobj S32 + IL_0015: ldloc.0 + IL_0016: ldarg.1 + IL_0017: ldfld int32 HeapInt::Value + IL_001c: ldc.i4.1 + IL_001d: add + IL_001e: newobj instance void HeapInt::.ctor(int32) + IL_0023: tail. + IL_0025: call int32 Program::CountUpHeapOther(int32, + valuetype S32, + class HeapInt) + IL_002a: ret + } // end of method Program::CountUpHeap + + .method private hidebysig static int32 + CountUpHeapOther(int32 left, + valuetype S32 s, + class HeapInt counter) cil managed noinlining + { + // Code size 34 (0x22) + .maxstack 3 + IL_0000: ldarg.0 + IL_0001: brtrue.s IL_000a + + IL_0003: ldarg.2 + IL_0004: ldfld int32 HeapInt::Value + IL_0009: ret + + IL_000a: ldarg.0 + IL_000b: ldc.i4.1 + IL_000c: sub + IL_000d: ldarg.2 + IL_000e: ldfld int32 HeapInt::Value + IL_0013: ldc.i4.1 + IL_0014: add + IL_0015: newobj instance void HeapInt::.ctor(int32) + IL_001a: tail. + IL_001c: call int32 Program::CountUpHeap(int32, + class HeapInt) + IL_0021: ret + } // end of method Program::CountUpHeapOther + + .method private hidebysig static void CountUpRef(int32 left, + int32& counter) cil managed + { + // Code size 31 (0x1f) + .maxstack 3 + .locals init (valuetype S32 V_0) + IL_0000: ldarg.0 + IL_0001: brtrue.s IL_0004 + + IL_0003: ret + + IL_0004: ldarg.1 + IL_0005: ldarg.1 + IL_0006: ldind.i4 + IL_0007: ldc.i4.1 + IL_0008: add + IL_0009: stind.i4 + IL_000a: ldarg.0 + IL_000b: ldc.i4.1 + IL_000c: sub + IL_000d: ldloca.s V_0 + IL_000f: initobj S32 + IL_0015: ldloc.0 + IL_0016: ldarg.1 + IL_0017: tail. + IL_0019: call void Program::CountUpRefOther(int32, + valuetype S32, + int32&) + IL_001e: ret + } // end of method Program::CountUpRef + + .method private hidebysig static void CountUpRefOther(int32 left, + valuetype S32 s, + int32& counter) cil managed + { + // Code size 22 (0x16) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: brtrue.s IL_0004 + + IL_0003: ret + + IL_0004: ldarg.2 + IL_0005: ldarg.2 + IL_0006: ldind.i4 + IL_0007: ldc.i4.1 + IL_0008: add + IL_0009: stind.i4 + IL_000a: ldarg.0 + IL_000b: ldc.i4.1 + IL_000c: sub + IL_000d: ldarg.2 + IL_000e: tail. + IL_0010: call void Program::CountUpRef(int32, + int32&) + IL_0015: ret + } // end of method Program::CountUpRefOther + + .method private hidebysig static string + GenName1Forward(!!T x) cil managed noinlining + { + // Code size 18 (0x12) + .maxstack 2 + .locals init (valuetype S32 V_0) + IL_0000: ldloca.s V_0 + IL_0002: initobj S32 + IL_0008: ldloc.0 + IL_0009: ldarg.0 + IL_000a: tail. + IL_000c: call string Program::GenName1(valuetype S32, + !!0) + IL_0011: ret + } // end of method Program::GenName1Forward + + .method private hidebysig static string + GenName1(valuetype S32 s, + !!T x) cil managed noinlining + { + // Code size 32 (0x20) + .maxstack 8 + IL_0000: ldstr "{0} {1}" + IL_0005: ldtoken !!T + IL_000a: call class [System.Runtime]System.Type [System.Runtime]System.Type::GetTypeFromHandle(valuetype [System.Runtime]System.RuntimeTypeHandle) + IL_000f: callvirt instance string [System.Runtime]System.Type::get_FullName() + IL_0014: ldarg.1 + IL_0015: box !!T + IL_001a: call string [System.Runtime]System.String::Format(string, + object, + object) + IL_001f: ret + } // end of method Program::GenName1 + + .method private hidebysig static string + GenName2ForwardBoth(!!T1 x, + !!T2 y) cil managed noinlining + { + // Code size 19 (0x13) + .maxstack 3 + .locals init (valuetype S32 V_0) + IL_0000: ldloca.s V_0 + IL_0002: initobj S32 + IL_0008: ldloc.0 + IL_0009: ldarg.0 + IL_000a: ldarg.1 + IL_000b: tail. + IL_000d: call string Program::GenName2(valuetype S32, + !!0, + !!1) + IL_0012: ret + } // end of method Program::GenName2ForwardBoth + + .method private hidebysig static string + GenName2ForwardOne(!!T x, + string y) cil managed noinlining + { + // Code size 19 (0x13) + .maxstack 3 + .locals init (valuetype S32 V_0) + IL_0000: ldloca.s V_0 + IL_0002: initobj S32 + IL_0008: ldloc.0 + IL_0009: ldarg.0 + IL_000a: ldarg.1 + IL_000b: tail. + IL_000d: call string Program::GenName2(valuetype S32, + !!0, + !!1) + IL_0012: ret + } // end of method Program::GenName2ForwardOne + + .method private hidebysig static string + GenName2ForwardNone(object x, + string y) cil managed noinlining + { + // Code size 19 (0x13) + .maxstack 3 + .locals init (valuetype S32 V_0) + IL_0000: ldloca.s V_0 + IL_0002: initobj S32 + IL_0008: ldloc.0 + IL_0009: ldarg.0 + IL_000a: ldarg.1 + IL_000b: tail. + IL_000d: call string Program::GenName2(valuetype S32, + !!0, + !!1) + IL_0012: ret + } // end of method Program::GenName2ForwardNone + + .method private hidebysig static string + GenName2(valuetype S32 s, + !!T1 a, + !!T2 b) cil managed noinlining + { + // Code size 71 (0x47) + .maxstack 5 + IL_0000: ldstr "{0} {1} {2} {3}" + IL_0005: ldc.i4.4 + IL_0006: newarr [System.Runtime]System.Object + IL_000b: dup + IL_000c: ldc.i4.0 + IL_000d: ldtoken !!T1 + IL_0012: call class [System.Runtime]System.Type [System.Runtime]System.Type::GetTypeFromHandle(valuetype [System.Runtime]System.RuntimeTypeHandle) + IL_0017: callvirt instance string [System.Runtime]System.Type::get_FullName() + IL_001c: stelem.ref + IL_001d: dup + IL_001e: ldc.i4.1 + IL_001f: ldtoken !!T2 + IL_0024: call class [System.Runtime]System.Type [System.Runtime]System.Type::GetTypeFromHandle(valuetype [System.Runtime]System.RuntimeTypeHandle) + IL_0029: callvirt instance string [System.Runtime]System.Type::get_FullName() + IL_002e: stelem.ref + IL_002f: dup + IL_0030: ldc.i4.2 + IL_0031: ldarg.1 + IL_0032: box !!T1 + IL_0037: stelem.ref + IL_0038: dup + IL_0039: ldc.i4.3 + IL_003a: ldarg.2 + IL_003b: box !!T2 + IL_0040: stelem.ref + IL_0041: call string [System.Runtime]System.String::Format(string, + object[]) + IL_0046: ret + } // end of method Program::GenName2 + + .method private hidebysig static string + GenInterfaceForward(!!T1 a, + !!T2 b, + !!T3 c, + !!T4 d, + class IGenInterface`2 igen) cil managed noinlining + { + // Code size 23 (0x17) + .maxstack 6 + .locals init (valuetype S32 V_0) + IL_0000: ldarg.s igen + IL_0002: ldloca.s V_0 + IL_0004: initobj S32 + IL_000a: ldloc.0 + IL_000b: ldarg.0 + IL_000c: ldarg.1 + IL_000d: ldarg.2 + IL_000e: ldarg.3 + IL_000f: tail. + IL_0011: callvirt instance string class IGenInterface`2::F(valuetype S32, + !0, + !1, + !!0, + !!1) + IL_0016: ret + } // end of method Program::GenInterfaceForward + + .method private hidebysig static string + GenInterfaceForwardNone(string a, + object b, + int32 c, + object d, + class IGenInterface`2 igen) cil managed noinlining + { + // Code size 23 (0x17) + .maxstack 6 + .locals init (valuetype S32 V_0) + IL_0000: ldarg.s igen + IL_0002: ldloca.s V_0 + IL_0004: initobj S32 + IL_000a: ldloc.0 + IL_000b: ldarg.0 + IL_000c: ldarg.1 + IL_000d: ldarg.2 + IL_000e: ldarg.3 + IL_000f: tail. + IL_0011: callvirt instance string class IGenInterface`2::F(valuetype S32, + !0, + !1, + !!0, + !!1) + IL_0016: ret + } // end of method Program::GenInterfaceForwardNone + + .method public hidebysig specialname rtspecialname + instance void .ctor() cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: call instance void [System.Runtime]System.Object::.ctor() + IL_0006: ret + } // end of method Program::.ctor + +} // end of class Program + +.class private auto ansi Instance + extends [System.Runtime]System.Object +{ + .field private static initonly native int s_calcInstanceCalli + .field private static initonly native int s_calcInstanceCalliOther + .field private static initonly native int s_calcInstanceCalliRetbuf + .field private static initonly native int s_calcInstanceCalliRetbufOther + .field private int32 _x + .method private hidebysig specialname rtspecialname static + void .cctor() cil managed + { + // Code size 53 (0x35) + .maxstack 1 + .locals init (native int V_0, + native int V_1, + native int V_2, + native int V_3) + IL_0000: ldftn instance int32 Instance::CalcInstanceCalli(int32, + int32) + IL_0006: stloc.0 + IL_0007: ldftn instance int32 Instance::CalcInstanceCalliOther(int32, + valuetype S32, + int32) + IL_000d: stloc.1 + IL_000e: ldftn instance valuetype S32 Instance::CalcInstanceCalliRetbuf(int32, + int32) + IL_0014: stloc.2 + IL_0015: ldftn instance valuetype S32 Instance::CalcInstanceCalliRetbufOther(int32, + valuetype S32, + int32) + IL_001b: stloc.3 + IL_001c: ldloc.0 + IL_001d: stsfld native int Instance::s_calcInstanceCalli + IL_0022: ldloc.1 + IL_0023: stsfld native int Instance::s_calcInstanceCalliOther + IL_0028: ldloc.2 + IL_0029: stsfld native int Instance::s_calcInstanceCalliRetbuf + IL_002e: ldloc.3 + IL_002f: stsfld native int Instance::s_calcInstanceCalliRetbufOther + IL_0034: ret + } // end of method Instance::.cctor + + .method public hidebysig instance int32 + CalcInstance(int32 x, + int32 acc) cil managed noinlining + { + // Code size 64 (0x40) + .maxstack 4 + .locals init (valuetype S32 V_0) + IL_0000: ldarg.1 + IL_0001: ldc.i4 0xffed2979 + IL_0006: beq.s IL_000f + + IL_0008: ldarg.0 + IL_0009: ldarg.1 + IL_000a: stfld int32 Instance::_x + IL_000f: ldarg.0 + IL_0010: ldfld int32 Instance::_x + IL_0015: brtrue.s IL_0019 + + IL_0017: ldarg.2 + IL_0018: ret + + IL_0019: ldloca.s V_0 + IL_001b: initobj S32 + IL_0021: ldarg.0 + IL_0022: ldflda int32 Instance::_x + IL_0027: ldloca.s V_0 + IL_0029: ldarga.s acc + IL_002b: call void Program::Calc(int32&, + valuetype S32&, + int32&) + IL_0030: ldarg.0 + IL_0031: ldc.i4 0xffed2979 + IL_0036: ldloc.0 + IL_0037: ldarg.2 + IL_0038: tail. + IL_003a: callvirt instance int32 Instance::CalcInstanceOther(int32, + valuetype S32, + int32) + IL_003f: ret + } // end of method Instance::CalcInstance + + .method public hidebysig instance int32 + CalcInstanceOther(int32 x, + valuetype S32 large, + int32 acc) cil managed noinlining + { + // Code size 30 (0x1e) + .maxstack 3 + IL_0000: ldarg.0 + IL_0001: ldflda int32 Instance::_x + IL_0006: ldarga.s large + IL_0008: ldarga.s acc + IL_000a: call void Program::Calc(int32&, + valuetype S32&, + int32&) + IL_000f: ldarg.0 + IL_0010: ldc.i4 0xffed2979 + IL_0015: ldarg.3 + IL_0016: tail. + IL_0018: callvirt instance int32 Instance::CalcInstance(int32, + int32) + IL_001d: ret + } // end of method Instance::CalcInstanceOther + + .method public hidebysig instance valuetype S32 + CalcInstanceRetbuf(int32 x, + int32 acc) cil managed noinlining + { + // Code size 108 (0x6c) + .maxstack 4 + .locals init (valuetype S32 V_0, + valuetype S32 V_1) + IL_0000: ldarg.1 + IL_0001: ldc.i4 0xffed2979 + IL_0006: beq.s IL_000f + + IL_0008: ldarg.0 + IL_0009: ldarg.1 + IL_000a: stfld int32 Instance::_x + IL_000f: ldarg.0 + IL_0010: ldfld int32 Instance::_x + IL_0015: brtrue.s IL_0045 + + IL_0017: ldloca.s V_1 + IL_0019: initobj S32 + IL_001f: ldloca.s V_1 + IL_0021: ldarg.2 + IL_0022: conv.i8 + IL_0023: stfld int64 S32::A + IL_0028: ldloca.s V_1 + IL_002a: ldarg.2 + IL_002b: conv.i8 + IL_002c: stfld int64 S32::B + IL_0031: ldloca.s V_1 + IL_0033: ldarg.2 + IL_0034: conv.i8 + IL_0035: stfld int64 S32::C + IL_003a: ldloca.s V_1 + IL_003c: ldarg.2 + IL_003d: conv.i8 + IL_003e: stfld int64 S32::D + IL_0043: ldloc.1 + IL_0044: ret + + IL_0045: ldloca.s V_0 + IL_0047: initobj S32 + IL_004d: ldarg.0 + IL_004e: ldflda int32 Instance::_x + IL_0053: ldloca.s V_0 + IL_0055: ldarga.s acc + IL_0057: call void Program::Calc(int32&, + valuetype S32&, + int32&) + IL_005c: ldarg.0 + IL_005d: ldc.i4 0xffed2979 + IL_0062: ldloc.0 + IL_0063: ldarg.2 + IL_0064: tail. + IL_0066: callvirt instance valuetype S32 Instance::CalcInstanceRetbufOther(int32, + valuetype S32, + int32) + IL_006b: ret + } // end of method Instance::CalcInstanceRetbuf + + .method public hidebysig instance valuetype S32 + CalcInstanceRetbufOther(int32 x, + valuetype S32 large, + int32 acc) cil managed noinlining + { + // Code size 30 (0x1e) + .maxstack 3 + IL_0000: ldarg.0 + IL_0001: ldflda int32 Instance::_x + IL_0006: ldarga.s large + IL_0008: ldarga.s acc + IL_000a: call void Program::Calc(int32&, + valuetype S32&, + int32&) + IL_000f: ldarg.0 + IL_0010: ldc.i4 0xffed2979 + IL_0015: ldarg.3 + IL_0016: tail. + IL_0018: callvirt instance valuetype S32 Instance::CalcInstanceRetbuf(int32, + int32) + IL_001d: ret + } // end of method Instance::CalcInstanceRetbufOther + + .method public hidebysig instance int32 + CalcInstanceCalli(int32 x, + int32 acc) cil managed noinlining + { + // Code size 69 (0x45) + .maxstack 5 + .locals init (valuetype S32 V_0) + IL_0000: ldarg.1 + IL_0001: ldc.i4 0xffed2979 + IL_0006: beq.s IL_000f + + IL_0008: ldarg.0 + IL_0009: ldarg.1 + IL_000a: stfld int32 Instance::_x + IL_000f: ldarg.0 + IL_0010: ldfld int32 Instance::_x + IL_0015: brtrue.s IL_0019 + + IL_0017: ldarg.2 + IL_0018: ret + + IL_0019: ldloca.s V_0 + IL_001b: initobj S32 + IL_0021: ldarg.0 + IL_0022: ldflda int32 Instance::_x + IL_0027: ldloca.s V_0 + IL_0029: ldarga.s acc + IL_002b: call void Program::Calc(int32&, + valuetype S32&, + int32&) + IL_0030: ldarg.0 + IL_0031: ldc.i4 0xffed2979 + IL_0036: ldloc.0 + IL_0037: ldarg.2 + IL_0038: ldsfld native int Instance::s_calcInstanceCalliOther + IL_003d: tail. + IL_003f: calli instance int32(int32,valuetype S32,int32) + IL_0044: ret + } // end of method Instance::CalcInstanceCalli + + .method public hidebysig instance int32 + CalcInstanceCalliOther(int32 x, + valuetype S32 large, + int32 acc) cil managed noinlining + { + // Code size 35 (0x23) + .maxstack 4 + IL_0000: ldarg.0 + IL_0001: ldflda int32 Instance::_x + IL_0006: ldarga.s large + IL_0008: ldarga.s acc + IL_000a: call void Program::Calc(int32&, + valuetype S32&, + int32&) + IL_000f: ldarg.0 + IL_0010: ldc.i4 0xffed2979 + IL_0015: ldarg.3 + IL_0016: ldsfld native int Instance::s_calcInstanceCalli + IL_001b: tail. + IL_001d: calli instance int32(int32,int32) + IL_0022: ret + } // end of method Instance::CalcInstanceCalliOther + + .method public hidebysig instance valuetype S32 + CalcInstanceCalliRetbuf(int32 x, + int32 acc) cil managed noinlining + { + // Code size 113 (0x71) + .maxstack 5 + .locals init (valuetype S32 V_0, + valuetype S32 V_1) + IL_0000: ldarg.1 + IL_0001: ldc.i4 0xffed2979 + IL_0006: beq.s IL_000f + + IL_0008: ldarg.0 + IL_0009: ldarg.1 + IL_000a: stfld int32 Instance::_x + IL_000f: ldarg.0 + IL_0010: ldfld int32 Instance::_x + IL_0015: brtrue.s IL_0045 + + IL_0017: ldloca.s V_1 + IL_0019: initobj S32 + IL_001f: ldloca.s V_1 + IL_0021: ldarg.2 + IL_0022: conv.i8 + IL_0023: stfld int64 S32::A + IL_0028: ldloca.s V_1 + IL_002a: ldarg.2 + IL_002b: conv.i8 + IL_002c: stfld int64 S32::B + IL_0031: ldloca.s V_1 + IL_0033: ldarg.2 + IL_0034: conv.i8 + IL_0035: stfld int64 S32::C + IL_003a: ldloca.s V_1 + IL_003c: ldarg.2 + IL_003d: conv.i8 + IL_003e: stfld int64 S32::D + IL_0043: ldloc.1 + IL_0044: ret + + IL_0045: ldloca.s V_0 + IL_0047: initobj S32 + IL_004d: ldarg.0 + IL_004e: ldflda int32 Instance::_x + IL_0053: ldloca.s V_0 + IL_0055: ldarga.s acc + IL_0057: call void Program::Calc(int32&, + valuetype S32&, + int32&) + IL_005c: ldarg.0 + IL_005d: ldc.i4 0xffed2979 + IL_0062: ldloc.0 + IL_0063: ldarg.2 + IL_0064: ldsfld native int Instance::s_calcInstanceCalliRetbufOther + IL_0069: tail. + IL_006b: calli instance valuetype S32(int32,valuetype S32,int32) + IL_0070: ret + } // end of method Instance::CalcInstanceCalliRetbuf + + .method public hidebysig instance valuetype S32 + CalcInstanceCalliRetbufOther(int32 x, + valuetype S32 large, + int32 acc) cil managed noinlining + { + // Code size 35 (0x23) + .maxstack 4 + IL_0000: ldarg.0 + IL_0001: ldflda int32 Instance::_x + IL_0006: ldarga.s large + IL_0008: ldarga.s acc + IL_000a: call void Program::Calc(int32&, + valuetype S32&, + int32&) + IL_000f: ldarg.0 + IL_0010: ldc.i4 0xffed2979 + IL_0015: ldarg.3 + IL_0016: ldsfld native int Instance::s_calcInstanceCalliRetbuf + IL_001b: tail. + IL_001d: calli instance valuetype S32(int32,int32) + IL_0022: ret + } // end of method Instance::CalcInstanceCalliRetbufOther + + .method public hidebysig instance string + GC(object a, + int32 b, + object c, + object d, + string e, + string f, + object g, + int32 h, + int32& interior) cil managed noinlining + { + // Code size 111 (0x6f) + .maxstack 5 + .locals init (valuetype S32 V_0, + valuetype SGC2 V_1) + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: ldloca.s V_0 + IL_0004: initobj S32 + IL_000a: ldloc.0 + IL_000b: ldloca.s V_1 + IL_000d: initobj SGC2 + IL_0013: ldloca.s V_1 + IL_0015: ldarg.2 + IL_0016: stfld int32 SGC2::A + IL_001b: ldloca.s V_1 + IL_001d: ldflda valuetype SGC SGC2::B + IL_0022: ldarg.3 + IL_0023: stfld object SGC::A + IL_0028: ldloca.s V_1 + IL_002a: ldflda valuetype SGC SGC2::B + IL_002f: ldarg.s d + IL_0031: stfld object SGC::B + IL_0036: ldloca.s V_1 + IL_0038: ldflda valuetype SGC SGC2::B + IL_003d: ldarg.s e + IL_003f: stfld string SGC::C + IL_0044: ldloca.s V_1 + IL_0046: ldflda valuetype SGC SGC2::B + IL_004b: ldarg.s f + IL_004d: stfld string SGC::D + IL_0052: ldloca.s V_1 + IL_0054: ldarg.s g + IL_0056: stfld object SGC2::C + IL_005b: ldloca.s V_1 + IL_005d: ldarg.s h + IL_005f: stfld int32 SGC2::D + IL_0064: ldloc.1 + IL_0065: ldarg.s interior + IL_0067: tail. + IL_0069: call instance string Instance::GCOther(object, + valuetype S32, + valuetype SGC2, + int32&) + IL_006e: ret + } // end of method Instance::GC + + .method private hidebysig instance string + GCOther(object a, + valuetype S32 s, + valuetype SGC2 gc, + int32& interior) cil managed noinlining + { + // Code size 126 (0x7e) + .maxstack 5 + IL_0000: ldstr "{0} {1} {2} {3} {4} {5} {6} {7} {8}" + IL_0005: ldc.i4.s 9 + IL_0007: newarr [System.Runtime]System.Object + IL_000c: dup + IL_000d: ldc.i4.0 + IL_000e: ldarg.1 + IL_000f: stelem.ref + IL_0010: dup + IL_0011: ldc.i4.1 + IL_0012: ldarg.3 + IL_0013: ldfld int32 SGC2::A + IL_0018: box [System.Runtime]System.Int32 + IL_001d: stelem.ref + IL_001e: dup + IL_001f: ldc.i4.2 + IL_0020: ldarg.3 + IL_0021: ldfld valuetype SGC SGC2::B + IL_0026: ldfld object SGC::A + IL_002b: stelem.ref + IL_002c: dup + IL_002d: ldc.i4.3 + IL_002e: ldarg.3 + IL_002f: ldfld valuetype SGC SGC2::B + IL_0034: ldfld object SGC::B + IL_0039: stelem.ref + IL_003a: dup + IL_003b: ldc.i4.4 + IL_003c: ldarg.3 + IL_003d: ldfld valuetype SGC SGC2::B + IL_0042: ldfld string SGC::C + IL_0047: stelem.ref + IL_0048: dup + IL_0049: ldc.i4.5 + IL_004a: ldarg.3 + IL_004b: ldfld valuetype SGC SGC2::B + IL_0050: ldfld string SGC::D + IL_0055: stelem.ref + IL_0056: dup + IL_0057: ldc.i4.6 + IL_0058: ldarg.3 + IL_0059: ldfld object SGC2::C + IL_005e: stelem.ref + IL_005f: dup + IL_0060: ldc.i4.7 + IL_0061: ldarg.3 + IL_0062: ldfld int32 SGC2::D + IL_0067: box [System.Runtime]System.Int32 + IL_006c: stelem.ref + IL_006d: dup + IL_006e: ldc.i4.8 + IL_006f: ldarg.s interior + IL_0071: ldind.i4 + IL_0072: box [System.Runtime]System.Int32 + IL_0077: stelem.ref + IL_0078: call string [System.Runtime]System.String::Format(string, + object[]) + IL_007d: ret + } // end of method Instance::GCOther + + .method public hidebysig specialname rtspecialname + instance void .ctor() cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: call instance void [System.Runtime]System.Object::.ctor() + IL_0006: ret + } // end of method Instance::.ctor + +} // end of class Instance + +.class private sequential ansi sealed beforefieldinit InstanceValueType + extends [System.Runtime]System.ValueType +{ + .field public int32 Count + .method public hidebysig instance void + CountUp(int32 left) cil managed + { + // Code size 39 (0x27) + .maxstack 3 + .locals init (valuetype S32 V_0) + IL_0000: ldarg.1 + IL_0001: brtrue.s IL_0004 + + IL_0003: ret + + IL_0004: ldarg.0 + IL_0005: ldarg.0 + IL_0006: ldfld int32 InstanceValueType::Count + IL_000b: ldc.i4.1 + IL_000c: add + IL_000d: stfld int32 InstanceValueType::Count + IL_0012: ldarg.0 + IL_0013: ldarg.1 + IL_0014: ldc.i4.1 + IL_0015: sub + IL_0016: ldloca.s V_0 + IL_0018: initobj S32 + IL_001e: ldloc.0 + IL_001f: tail. + IL_0021: call instance void InstanceValueType::CountUpOther(int32, + valuetype S32) + IL_0026: ret + } // end of method InstanceValueType::CountUp + + .method private hidebysig instance void + CountUpOther(int32 left, + valuetype S32 s) cil managed + { + // Code size 30 (0x1e) + .maxstack 3 + IL_0000: ldarg.1 + IL_0001: brtrue.s IL_0004 + + IL_0003: ret + + IL_0004: ldarg.0 + IL_0005: ldarg.0 + IL_0006: ldfld int32 InstanceValueType::Count + IL_000b: ldc.i4.1 + IL_000c: add + IL_000d: stfld int32 InstanceValueType::Count + IL_0012: ldarg.0 + IL_0013: ldarg.1 + IL_0014: ldc.i4.1 + IL_0015: sub + IL_0016: tail. + IL_0018: call instance void InstanceValueType::CountUp(int32) + IL_001d: ret + } // end of method InstanceValueType::CountUpOther + +} // end of class InstanceValueType + +.class private abstract auto ansi beforefieldinit BaseClass + extends [System.Runtime]System.Object +{ + .method public hidebysig newslot abstract virtual + instance int32 CalcAbstract(int32 x, + int32 acc) cil managed + { + } // end of method BaseClass::CalcAbstract + + .method public hidebysig newslot abstract virtual + instance int32 CalcAbstractOther(int32 x, + valuetype S32 large, + int32 acc) cil managed + { + } // end of method BaseClass::CalcAbstractOther + + .method public hidebysig newslot abstract virtual + instance valuetype S32 CalcAbstractRetbuf(int32 x, + int32 acc) cil managed + { + } // end of method BaseClass::CalcAbstractRetbuf + + .method public hidebysig newslot abstract virtual + instance valuetype S32 CalcAbstractRetbufOther(int32 x, + valuetype S32 large, + int32 acc) cil managed + { + } // end of method BaseClass::CalcAbstractRetbufOther + + .method family hidebysig specialname rtspecialname + instance void .ctor() cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: call instance void [System.Runtime]System.Object::.ctor() + IL_0006: ret + } // end of method BaseClass::.ctor + +} // end of class BaseClass + +.class private auto ansi beforefieldinit ClassImpl + extends BaseClass +{ + .field private int32 _x + .field private class BaseClass 'k__BackingField' + .custom instance void [System.Runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .method public hidebysig specialname instance class BaseClass + get_Other() cil managed + { + .custom instance void [System.Runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld class BaseClass ClassImpl::'k__BackingField' + IL_0006: ret + } // end of method ClassImpl::get_Other + + .method public hidebysig specialname instance void + set_Other(class BaseClass 'value') cil managed + { + .custom instance void [System.Runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld class BaseClass ClassImpl::'k__BackingField' + IL_0007: ret + } // end of method ClassImpl::set_Other + + .method public hidebysig virtual instance int32 + CalcAbstract(int32 x, + int32 acc) cil managed noinlining + { + // Code size 69 (0x45) + .maxstack 4 + .locals init (valuetype S32 V_0) + IL_0000: ldarg.1 + IL_0001: ldc.i4 0xffed2979 + IL_0006: beq.s IL_000f + + IL_0008: ldarg.0 + IL_0009: ldarg.1 + IL_000a: stfld int32 ClassImpl::_x + IL_000f: ldarg.0 + IL_0010: ldfld int32 ClassImpl::_x + IL_0015: brtrue.s IL_0019 + + IL_0017: ldarg.2 + IL_0018: ret + + IL_0019: ldloca.s V_0 + IL_001b: initobj S32 + IL_0021: ldarg.0 + IL_0022: ldflda int32 ClassImpl::_x + IL_0027: ldloca.s V_0 + IL_0029: ldarga.s acc + IL_002b: call void Program::Calc(int32&, + valuetype S32&, + int32&) + IL_0030: ldarg.0 + IL_0031: call instance class BaseClass ClassImpl::get_Other() + IL_0036: ldc.i4 0xffed2979 + IL_003b: ldloc.0 + IL_003c: ldarg.2 + IL_003d: tail. + IL_003f: callvirt instance int32 ClassImpl::CalcAbstractOther(int32, + valuetype S32, + int32) + IL_0044: ret + } // end of method ClassImpl::CalcAbstract + + .method public hidebysig virtual instance int32 + CalcAbstractOther(int32 x, + valuetype S32 large, + int32 acc) cil managed noinlining + { + // Code size 35 (0x23) + .maxstack 3 + IL_0000: ldarg.0 + IL_0001: ldflda int32 ClassImpl::_x + IL_0006: ldarga.s large + IL_0008: ldarga.s acc + IL_000a: call void Program::Calc(int32&, + valuetype S32&, + int32&) + IL_000f: ldarg.0 + IL_0010: call instance class BaseClass ClassImpl::get_Other() + IL_0015: ldc.i4 0xffed2979 + IL_001a: ldarg.3 + IL_001b: tail. + IL_001d: callvirt instance int32 ClassImpl::CalcAbstract(int32, + int32) + IL_0022: ret + } // end of method ClassImpl::CalcAbstractOther + + .method public hidebysig virtual instance valuetype S32 + CalcAbstractRetbuf(int32 x, + int32 acc) cil managed noinlining + { + // Code size 113 (0x71) + .maxstack 4 + .locals init (valuetype S32 V_0, + valuetype S32 V_1) + IL_0000: ldarg.1 + IL_0001: ldc.i4 0xffed2979 + IL_0006: beq.s IL_000f + + IL_0008: ldarg.0 + IL_0009: ldarg.1 + IL_000a: stfld int32 ClassImpl::_x + IL_000f: ldarg.0 + IL_0010: ldfld int32 ClassImpl::_x + IL_0015: brtrue.s IL_0045 + + IL_0017: ldloca.s V_1 + IL_0019: initobj S32 + IL_001f: ldloca.s V_1 + IL_0021: ldarg.2 + IL_0022: conv.i8 + IL_0023: stfld int64 S32::A + IL_0028: ldloca.s V_1 + IL_002a: ldarg.2 + IL_002b: conv.i8 + IL_002c: stfld int64 S32::B + IL_0031: ldloca.s V_1 + IL_0033: ldarg.2 + IL_0034: conv.i8 + IL_0035: stfld int64 S32::C + IL_003a: ldloca.s V_1 + IL_003c: ldarg.2 + IL_003d: conv.i8 + IL_003e: stfld int64 S32::D + IL_0043: ldloc.1 + IL_0044: ret + + IL_0045: ldloca.s V_0 + IL_0047: initobj S32 + IL_004d: ldarg.0 + IL_004e: ldflda int32 ClassImpl::_x + IL_0053: ldloca.s V_0 + IL_0055: ldarga.s acc + IL_0057: call void Program::Calc(int32&, + valuetype S32&, + int32&) + IL_005c: ldarg.0 + IL_005d: call instance class BaseClass ClassImpl::get_Other() + IL_0062: ldc.i4 0xffed2979 + IL_0067: ldloc.0 + IL_0068: ldarg.2 + IL_0069: tail. + IL_006b: callvirt instance valuetype S32 ClassImpl::CalcAbstractRetbufOther(int32, + valuetype S32, + int32) + IL_0070: ret + } // end of method ClassImpl::CalcAbstractRetbuf + + .method public hidebysig virtual instance valuetype S32 + CalcAbstractRetbufOther(int32 x, + valuetype S32 large, + int32 acc) cil managed noinlining + { + // Code size 35 (0x23) + .maxstack 3 + IL_0000: ldarg.0 + IL_0001: ldflda int32 ClassImpl::_x + IL_0006: ldarga.s large + IL_0008: ldarga.s acc + IL_000a: call void Program::Calc(int32&, + valuetype S32&, + int32&) + IL_000f: ldarg.0 + IL_0010: call instance class BaseClass ClassImpl::get_Other() + IL_0015: ldc.i4 0xffed2979 + IL_001a: ldarg.3 + IL_001b: tail. + IL_001d: callvirt instance valuetype S32 ClassImpl::CalcAbstractRetbuf(int32, + int32) + IL_0022: ret + } // end of method ClassImpl::CalcAbstractRetbufOther + + .method public hidebysig specialname rtspecialname + instance void .ctor() cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: call instance void BaseClass::.ctor() + IL_0006: ret + } // end of method ClassImpl::.ctor + + .property instance class BaseClass Other() + { + .get instance class BaseClass ClassImpl::get_Other() + .set instance void ClassImpl::set_Other(class BaseClass) + } // end of property ClassImpl::Other +} // end of class ClassImpl + +.class interface private abstract auto ansi IInterface +{ + .method public hidebysig newslot abstract virtual + instance int32 CalcInterface(int32 x, + int32 acc) cil managed + { + } // end of method IInterface::CalcInterface + + .method public hidebysig newslot abstract virtual + instance int32 CalcInterfaceOther(int32 x, + valuetype S32 large, + int32 acc) cil managed + { + } // end of method IInterface::CalcInterfaceOther + + .method public hidebysig newslot abstract virtual + instance valuetype S32 CalcInterfaceRetbuf(int32 x, + int32 acc) cil managed + { + } // end of method IInterface::CalcInterfaceRetbuf + + .method public hidebysig newslot abstract virtual + instance valuetype S32 CalcInterfaceRetbufOther(int32 x, + valuetype S32 large, + int32 acc) cil managed + { + } // end of method IInterface::CalcInterfaceRetbufOther + +} // end of class IInterface + +.class private auto ansi beforefieldinit InterfaceImpl + extends [System.Runtime]System.Object + implements IInterface +{ + .field private int32 _x + .field private class IInterface 'k__BackingField' + .custom instance void [System.Runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .method public hidebysig specialname instance class IInterface + get_Other() cil managed + { + .custom instance void [System.Runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld class IInterface InterfaceImpl::'k__BackingField' + IL_0006: ret + } // end of method InterfaceImpl::get_Other + + .method public hidebysig specialname instance void + set_Other(class IInterface 'value') cil managed + { + .custom instance void [System.Runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld class IInterface InterfaceImpl::'k__BackingField' + IL_0007: ret + } // end of method InterfaceImpl::set_Other + + .method public hidebysig newslot virtual final + instance int32 CalcInterface(int32 x, + int32 acc) cil managed noinlining + { + // Code size 69 (0x45) + .maxstack 4 + .locals init (valuetype S32 V_0) + IL_0000: ldarg.1 + IL_0001: ldc.i4 0xffed2979 + IL_0006: beq.s IL_000f + + IL_0008: ldarg.0 + IL_0009: ldarg.1 + IL_000a: stfld int32 InterfaceImpl::_x + IL_000f: ldarg.0 + IL_0010: ldfld int32 InterfaceImpl::_x + IL_0015: brtrue.s IL_0019 + + IL_0017: ldarg.2 + IL_0018: ret + + IL_0019: ldloca.s V_0 + IL_001b: initobj S32 + IL_0021: ldarg.0 + IL_0022: ldflda int32 InterfaceImpl::_x + IL_0027: ldloca.s V_0 + IL_0029: ldarga.s acc + IL_002b: call void Program::Calc(int32&, + valuetype S32&, + int32&) + IL_0030: ldarg.0 + IL_0031: call instance class IInterface InterfaceImpl::get_Other() + IL_0036: ldc.i4 0xffed2979 + IL_003b: ldloc.0 + IL_003c: ldarg.2 + IL_003d: tail. + IL_003f: callvirt instance int32 IInterface::CalcInterfaceOther(int32, + valuetype S32, + int32) + IL_0044: ret + } // end of method InterfaceImpl::CalcInterface + + .method public hidebysig newslot virtual final + instance int32 CalcInterfaceOther(int32 x, + valuetype S32 large, + int32 acc) cil managed noinlining + { + // Code size 35 (0x23) + .maxstack 3 + IL_0000: ldarg.0 + IL_0001: ldflda int32 InterfaceImpl::_x + IL_0006: ldarga.s large + IL_0008: ldarga.s acc + IL_000a: call void Program::Calc(int32&, + valuetype S32&, + int32&) + IL_000f: ldarg.0 + IL_0010: call instance class IInterface InterfaceImpl::get_Other() + IL_0015: ldc.i4 0xffed2979 + IL_001a: ldarg.3 + IL_001b: tail. + IL_001d: callvirt instance int32 IInterface::CalcInterface(int32, + int32) + IL_0022: ret + } // end of method InterfaceImpl::CalcInterfaceOther + + .method public hidebysig newslot virtual final + instance valuetype S32 CalcInterfaceRetbuf(int32 x, + int32 acc) cil managed noinlining + { + // Code size 113 (0x71) + .maxstack 4 + .locals init (valuetype S32 V_0, + valuetype S32 V_1) + IL_0000: ldarg.1 + IL_0001: ldc.i4 0xffed2979 + IL_0006: beq.s IL_000f + + IL_0008: ldarg.0 + IL_0009: ldarg.1 + IL_000a: stfld int32 InterfaceImpl::_x + IL_000f: ldarg.0 + IL_0010: ldfld int32 InterfaceImpl::_x + IL_0015: brtrue.s IL_0045 + + IL_0017: ldloca.s V_1 + IL_0019: initobj S32 + IL_001f: ldloca.s V_1 + IL_0021: ldarg.2 + IL_0022: conv.i8 + IL_0023: stfld int64 S32::A + IL_0028: ldloca.s V_1 + IL_002a: ldarg.2 + IL_002b: conv.i8 + IL_002c: stfld int64 S32::B + IL_0031: ldloca.s V_1 + IL_0033: ldarg.2 + IL_0034: conv.i8 + IL_0035: stfld int64 S32::C + IL_003a: ldloca.s V_1 + IL_003c: ldarg.2 + IL_003d: conv.i8 + IL_003e: stfld int64 S32::D + IL_0043: ldloc.1 + IL_0044: ret + + IL_0045: ldloca.s V_0 + IL_0047: initobj S32 + IL_004d: ldarg.0 + IL_004e: ldflda int32 InterfaceImpl::_x + IL_0053: ldloca.s V_0 + IL_0055: ldarga.s acc + IL_0057: call void Program::Calc(int32&, + valuetype S32&, + int32&) + IL_005c: ldarg.0 + IL_005d: call instance class IInterface InterfaceImpl::get_Other() + IL_0062: ldc.i4 0xffed2979 + IL_0067: ldloc.0 + IL_0068: ldarg.2 + IL_0069: tail. + IL_006b: callvirt instance valuetype S32 IInterface::CalcInterfaceRetbufOther(int32, + valuetype S32, + int32) + IL_0070: ret + } // end of method InterfaceImpl::CalcInterfaceRetbuf + + .method public hidebysig newslot virtual final + instance valuetype S32 CalcInterfaceRetbufOther(int32 x, + valuetype S32 large, + int32 acc) cil managed noinlining + { + // Code size 35 (0x23) + .maxstack 3 + IL_0000: ldarg.0 + IL_0001: ldflda int32 InterfaceImpl::_x + IL_0006: ldarga.s large + IL_0008: ldarga.s acc + IL_000a: call void Program::Calc(int32&, + valuetype S32&, + int32&) + IL_000f: ldarg.0 + IL_0010: call instance class IInterface InterfaceImpl::get_Other() + IL_0015: ldc.i4 0xffed2979 + IL_001a: ldarg.3 + IL_001b: tail. + IL_001d: callvirt instance valuetype S32 IInterface::CalcInterfaceRetbuf(int32, + int32) + IL_0022: ret + } // end of method InterfaceImpl::CalcInterfaceRetbufOther + + .method public hidebysig specialname rtspecialname + instance void .ctor() cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: call instance void [System.Runtime]System.Object::.ctor() + IL_0006: ret + } // end of method InterfaceImpl::.ctor + + .property instance class IInterface Other() + { + .get instance class IInterface InterfaceImpl::get_Other() + .set instance void InterfaceImpl::set_Other(class IInterface) + } // end of property InterfaceImpl::Other +} // end of class InterfaceImpl + +.class private auto ansi beforefieldinit GenInstance`2 + extends [System.Runtime]System.Object +{ + .method public hidebysig instance string + NonVirtForward(!T1 a, + !T2 b, + !!T3 c, + !!T4 d) cil managed noinlining + { + // Code size 23 (0x17) + .maxstack 6 + .locals init (valuetype S32 V_0) + IL_0000: ldarg.0 + IL_0001: ldloca.s V_0 + IL_0003: initobj S32 + IL_0009: ldloc.0 + IL_000a: ldarg.1 + IL_000b: ldarg.2 + IL_000c: ldarg.3 + IL_000d: ldarg.s d + IL_000f: tail. + IL_0011: callvirt instance string class GenInstance`2::NonVirt(valuetype S32, + !0, + !1, + !!0, + !!1) + IL_0016: ret + } // end of method GenInstance`2::NonVirtForward + + .method public hidebysig instance string + VirtForward(!T1 a, + !T2 b, + !!T3 c, + !!T4 d) cil managed noinlining + { + // Code size 23 (0x17) + .maxstack 6 + .locals init (valuetype S32 V_0) + IL_0000: ldarg.0 + IL_0001: ldloca.s V_0 + IL_0003: initobj S32 + IL_0009: ldloc.0 + IL_000a: ldarg.1 + IL_000b: ldarg.2 + IL_000c: ldarg.3 + IL_000d: ldarg.s d + IL_000f: tail. + IL_0011: callvirt instance string class GenInstance`2::Virt(valuetype S32, + !0, + !1, + !!0, + !!1) + IL_0016: ret + } // end of method GenInstance`2::VirtForward + + .method public hidebysig instance string + NonVirt(valuetype S32 s, + !T1 a, + !T2 b, + !!T3 c, + !!T4 d) cil managed + { + // Code size 127 (0x7f) + .maxstack 5 + IL_0000: ldstr "{0} {1} {2} {3} {4} {5} {6} {7}" + IL_0005: ldc.i4.8 + IL_0006: newarr [System.Runtime]System.Object + IL_000b: dup + IL_000c: ldc.i4.0 + IL_000d: ldtoken !T1 + IL_0012: call class [System.Runtime]System.Type [System.Runtime]System.Type::GetTypeFromHandle(valuetype [System.Runtime]System.RuntimeTypeHandle) + IL_0017: callvirt instance string [System.Runtime]System.Type::get_FullName() + IL_001c: stelem.ref + IL_001d: dup + IL_001e: ldc.i4.1 + IL_001f: ldtoken !T2 + IL_0024: call class [System.Runtime]System.Type [System.Runtime]System.Type::GetTypeFromHandle(valuetype [System.Runtime]System.RuntimeTypeHandle) + IL_0029: callvirt instance string [System.Runtime]System.Type::get_FullName() + IL_002e: stelem.ref + IL_002f: dup + IL_0030: ldc.i4.2 + IL_0031: ldtoken !!T3 + IL_0036: call class [System.Runtime]System.Type [System.Runtime]System.Type::GetTypeFromHandle(valuetype [System.Runtime]System.RuntimeTypeHandle) + IL_003b: callvirt instance string [System.Runtime]System.Type::get_FullName() + IL_0040: stelem.ref + IL_0041: dup + IL_0042: ldc.i4.3 + IL_0043: ldtoken !!T4 + IL_0048: call class [System.Runtime]System.Type [System.Runtime]System.Type::GetTypeFromHandle(valuetype [System.Runtime]System.RuntimeTypeHandle) + IL_004d: callvirt instance string [System.Runtime]System.Type::get_FullName() + IL_0052: stelem.ref + IL_0053: dup + IL_0054: ldc.i4.4 + IL_0055: ldarg.2 + IL_0056: box !T1 + IL_005b: stelem.ref + IL_005c: dup + IL_005d: ldc.i4.5 + IL_005e: ldarg.3 + IL_005f: box !T2 + IL_0064: stelem.ref + IL_0065: dup + IL_0066: ldc.i4.6 + IL_0067: ldarg.s c + IL_0069: box !!T3 + IL_006e: stelem.ref + IL_006f: dup + IL_0070: ldc.i4.7 + IL_0071: ldarg.s d + IL_0073: box !!T4 + IL_0078: stelem.ref + IL_0079: call string [System.Runtime]System.String::Format(string, + object[]) + IL_007e: ret + } // end of method GenInstance`2::NonVirt + + .method public hidebysig newslot virtual + instance string Virt(valuetype S32 s, + !T1 a, + !T2 b, + !!T3 c, + !!T4 d) cil managed + { + // Code size 127 (0x7f) + .maxstack 5 + IL_0000: ldstr "{0} {1} {2} {3} {4} {5} {6} {7}" + IL_0005: ldc.i4.8 + IL_0006: newarr [System.Runtime]System.Object + IL_000b: dup + IL_000c: ldc.i4.0 + IL_000d: ldtoken !T1 + IL_0012: call class [System.Runtime]System.Type [System.Runtime]System.Type::GetTypeFromHandle(valuetype [System.Runtime]System.RuntimeTypeHandle) + IL_0017: callvirt instance string [System.Runtime]System.Type::get_FullName() + IL_001c: stelem.ref + IL_001d: dup + IL_001e: ldc.i4.1 + IL_001f: ldtoken !T2 + IL_0024: call class [System.Runtime]System.Type [System.Runtime]System.Type::GetTypeFromHandle(valuetype [System.Runtime]System.RuntimeTypeHandle) + IL_0029: callvirt instance string [System.Runtime]System.Type::get_FullName() + IL_002e: stelem.ref + IL_002f: dup + IL_0030: ldc.i4.2 + IL_0031: ldtoken !!T3 + IL_0036: call class [System.Runtime]System.Type [System.Runtime]System.Type::GetTypeFromHandle(valuetype [System.Runtime]System.RuntimeTypeHandle) + IL_003b: callvirt instance string [System.Runtime]System.Type::get_FullName() + IL_0040: stelem.ref + IL_0041: dup + IL_0042: ldc.i4.3 + IL_0043: ldtoken !!T4 + IL_0048: call class [System.Runtime]System.Type [System.Runtime]System.Type::GetTypeFromHandle(valuetype [System.Runtime]System.RuntimeTypeHandle) + IL_004d: callvirt instance string [System.Runtime]System.Type::get_FullName() + IL_0052: stelem.ref + IL_0053: dup + IL_0054: ldc.i4.4 + IL_0055: ldarg.2 + IL_0056: box !T1 + IL_005b: stelem.ref + IL_005c: dup + IL_005d: ldc.i4.5 + IL_005e: ldarg.3 + IL_005f: box !T2 + IL_0064: stelem.ref + IL_0065: dup + IL_0066: ldc.i4.6 + IL_0067: ldarg.s c + IL_0069: box !!T3 + IL_006e: stelem.ref + IL_006f: dup + IL_0070: ldc.i4.7 + IL_0071: ldarg.s d + IL_0073: box !!T4 + IL_0078: stelem.ref + IL_0079: call string [System.Runtime]System.String::Format(string, + object[]) + IL_007e: ret + } // end of method GenInstance`2::Virt + + .method public hidebysig specialname rtspecialname + instance void .ctor() cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: call instance void [System.Runtime]System.Object::.ctor() + IL_0006: ret + } // end of method GenInstance`2::.ctor + +} // end of class GenInstance`2 + +.class interface private abstract auto ansi IGenInterface`2 +{ + .method public hidebysig newslot abstract virtual + instance string F(valuetype S32 s, + !T1 a, + !T2 b, + !!T3 c, + !!T4 d) cil managed + { + } // end of method IGenInterface`2::F + +} // end of class IGenInterface`2 + +.class private auto ansi beforefieldinit GenInterfaceImpl`2 + extends [System.Runtime]System.Object + implements class IGenInterface`2 +{ + .method public hidebysig newslot virtual final + instance string F(valuetype S32 s, + !T1 a, + !T2 b, + !!T3 c, + !!T4 d) cil managed + { + // Code size 127 (0x7f) + .maxstack 5 + IL_0000: ldstr "{0} {1} {2} {3} {4} {5} {6} {7}" + IL_0005: ldc.i4.8 + IL_0006: newarr [System.Runtime]System.Object + IL_000b: dup + IL_000c: ldc.i4.0 + IL_000d: ldtoken !T1 + IL_0012: call class [System.Runtime]System.Type [System.Runtime]System.Type::GetTypeFromHandle(valuetype [System.Runtime]System.RuntimeTypeHandle) + IL_0017: callvirt instance string [System.Runtime]System.Type::get_FullName() + IL_001c: stelem.ref + IL_001d: dup + IL_001e: ldc.i4.1 + IL_001f: ldtoken !T2 + IL_0024: call class [System.Runtime]System.Type [System.Runtime]System.Type::GetTypeFromHandle(valuetype [System.Runtime]System.RuntimeTypeHandle) + IL_0029: callvirt instance string [System.Runtime]System.Type::get_FullName() + IL_002e: stelem.ref + IL_002f: dup + IL_0030: ldc.i4.2 + IL_0031: ldtoken !!T3 + IL_0036: call class [System.Runtime]System.Type [System.Runtime]System.Type::GetTypeFromHandle(valuetype [System.Runtime]System.RuntimeTypeHandle) + IL_003b: callvirt instance string [System.Runtime]System.Type::get_FullName() + IL_0040: stelem.ref + IL_0041: dup + IL_0042: ldc.i4.3 + IL_0043: ldtoken !!T4 + IL_0048: call class [System.Runtime]System.Type [System.Runtime]System.Type::GetTypeFromHandle(valuetype [System.Runtime]System.RuntimeTypeHandle) + IL_004d: callvirt instance string [System.Runtime]System.Type::get_FullName() + IL_0052: stelem.ref + IL_0053: dup + IL_0054: ldc.i4.4 + IL_0055: ldarg.2 + IL_0056: box !T1 + IL_005b: stelem.ref + IL_005c: dup + IL_005d: ldc.i4.5 + IL_005e: ldarg.3 + IL_005f: box !T2 + IL_0064: stelem.ref + IL_0065: dup + IL_0066: ldc.i4.6 + IL_0067: ldarg.s c + IL_0069: box !!T3 + IL_006e: stelem.ref + IL_006f: dup + IL_0070: ldc.i4.7 + IL_0071: ldarg.s d + IL_0073: box !!T4 + IL_0078: stelem.ref + IL_0079: call string [System.Runtime]System.String::Format(string, + object[]) + IL_007e: ret + } // end of method GenInterfaceImpl`2::F + + .method public hidebysig specialname rtspecialname + instance void .ctor() cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: call instance void [System.Runtime]System.Object::.ctor() + IL_0006: ret + } // end of method GenInterfaceImpl`2::.ctor + +} // end of class GenInterfaceImpl`2 + +// ============================================================= + +// *********** DISASSEMBLY COMPLETE *********************** diff --git a/src/coreclr/tests/src/JIT/Methodical/tailcall_v4/tailcall_AV.ilproj b/src/coreclr/tests/src/JIT/Directed/tailcall/more_tailcalls.ilproj similarity index 83% rename from src/coreclr/tests/src/JIT/Methodical/tailcall_v4/tailcall_AV.ilproj rename to src/coreclr/tests/src/JIT/Directed/tailcall/more_tailcalls.ilproj index 4c085103484..bcaa593ba81 100644 --- a/src/coreclr/tests/src/JIT/Methodical/tailcall_v4/tailcall_AV.ilproj +++ b/src/coreclr/tests/src/JIT/Directed/tailcall/more_tailcalls.ilproj @@ -7,6 +7,6 @@ True - + diff --git a/src/coreclr/tests/src/JIT/Methodical/tailcall_v4/hijacking.il b/src/coreclr/tests/src/JIT/Methodical/tailcall_v4/hijacking.il index c5d228ad6ad..ecc42d7b387 100644 --- a/src/coreclr/tests/src/JIT/Methodical/tailcall_v4/hijacking.il +++ b/src/coreclr/tests/src/JIT/Methodical/tailcall_v4/hijacking.il @@ -52,6 +52,7 @@ { .field public valuetype ForceHelper* me .field public int64 counter + .field public int64 extraField } // end of class ForceHelper .class private auto ansi beforefieldinit Repro @@ -121,12 +122,13 @@ IL_006e: stfld valuetype ForceHelper* ForceHelper::me IL_0073: ldarg.0 IL_0074: ldarg.1 - IL_0075: tail. call instance void Repro::TailHelper2(valuetype ForceHelper) - IL_007a: ret + IL_0075: ldarg.1 + IL_0076: tail. call instance void Repro::TailHelper2(valuetype ForceHelper, valuetype ForceHelper) + IL_007b: ret } // end of method Repro::TailHelper1 .method private hidebysig instance void - TailHelper2(valuetype ForceHelper h) cil managed + TailHelper2(valuetype ForceHelper h, valuetype ForceHelper h2) cil managed { // Code size 123 (0x7b) .maxstack 3 @@ -244,7 +246,7 @@ int32 V_9) IL_0000: newobj instance void Repro::.ctor() IL_0005: stloc.0 - IL_0006: ldc.i4.4 + IL_0006: ldc.i4.2 IL_0007: newarr [System.Threading.Thread]System.Threading.Thread IL_000c: stloc.s V_5 IL_000e: ldloc.s V_5 @@ -263,22 +265,6 @@ native int) IL_0032: newobj instance void [System.Threading.Thread]System.Threading.Thread::.ctor(class [System.Threading.Thread]System.Threading.ThreadStart) IL_0037: stelem.ref - IL_0038: ldloc.s V_5 - IL_003a: ldc.i4.2 - IL_003b: ldloc.0 - IL_003c: ldftn instance void Repro::TailCallThread() - IL_0042: newobj instance void [System.Threading.Thread]System.Threading.ThreadStart::.ctor(object, - native int) - IL_0047: newobj instance void [System.Threading.Thread]System.Threading.Thread::.ctor(class [System.Threading.Thread]System.Threading.ThreadStart) - IL_004c: stelem.ref - IL_004d: ldloc.s V_5 - IL_004f: ldc.i4.3 - IL_0050: ldloc.0 - IL_0051: ldftn instance void Repro::TailCallThread() - IL_0057: newobj instance void [System.Threading.Thread]System.Threading.ThreadStart::.ctor(object, - native int) - IL_005c: newobj instance void [System.Threading.Thread]System.Threading.Thread::.ctor(class [System.Threading.Thread]System.Threading.ThreadStart) - IL_0061: stelem.ref IL_0062: ldloc.s V_5 IL_0064: stloc.1 IL_0065: ldloc.1 @@ -319,7 +305,7 @@ IL_00a1: add IL_00a2: stloc.3 IL_00a3: ldloc.3 - IL_00a4: ldc.i4.s 60 + IL_00a4: ldc.i4.s 30 IL_00a6: blt.s IL_008b IL_00a8: ldloc.0 diff --git a/src/coreclr/tests/src/JIT/Methodical/tailcall_v4/tailcall_AV.il b/src/coreclr/tests/src/JIT/Methodical/tailcall_v4/tailcall_AV.il deleted file mode 100644 index 090d681f78c..00000000000 --- a/src/coreclr/tests/src/JIT/Methodical/tailcall_v4/tailcall_AV.il +++ /dev/null @@ -1,203 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. -// See the LICENSE file in the project root for more information. - -.assembly extern System.Console -{ - .publickeytoken = (B0 3F 5F 7F 11 D5 0A 3A ) - .ver 4:0:0:0 -} - -// Metadata version: v4.0.AMD64chk -.assembly extern mscorlib -{ - .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. - .ver 4:0:0:0 -} -.assembly o -{ - .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 ) - .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx - 63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 ) // ceptionThrows. - .hash algorithm 0x00008004 - .ver 0:0:0:0 -} -.module o.exe -// MVID: {E5624CCE-2F8F-498D-8C7E-6479B0B6CEC7} -.imagebase 0x00400000 -.file alignment 0x00000200 -.stackreserve 0x00100000 -.subsystem 0x0003 // WINDOWS_CUI -.corflags 0x00000001 // ILONLY -// Image base: 0x0000000000970000 - - -// =============== CLASS MEMBERS DECLARATION =================== - -.class private auto ansi beforefieldinit TCS.TailCallStructs - extends [mscorlib]System.Object -{ - .method public hidebysig static void Head_0() cil managed noinlining - { - // Code size 33 (0x21) - .maxstack 2 - .locals init (int32 V_0, - valuetype CSCreate.MB1 V_1) - IL_0000: ldc.i4.0 - IL_0001: stloc.0 - IL_0002: ldloca.s V_1 - IL_0004: initobj CSCreate.MB1 - IL_000a: ldloca.s V_1 - IL_000c: ldc.i4.1 - IL_000d: stfld uint8 CSCreate.MB1::b0 - IL_0012: ldloc.1 - IL_0013: ldloca.s V_0 - IL_0015: call void TCS.TailCallStructs::Caller_0(valuetype CSCreate.MB1, - int32&) - IL_001a: ldloc.0 - IL_001b: call void [System.Console]System.Console::WriteLine(int32) - IL_0020: ret - } // end of method TailCallStructs::Head_0 - - .method public hidebysig static void Caller_0(valuetype CSCreate.MB1 mbs0, - int32& result) cil managed noinlining - { - // Code size 18 (0x12) - .maxstack 2 - .locals init (typedref V_0) - IL_0000: ldarga.s mbs0 - IL_0002: mkrefany CSCreate.MB1 - IL_0007: stloc.0 - IL_0008: ldarg.1 - IL_0009: ldloc.0 - IL_000a: tail. - IL_000c: call void TCS.TailCallStructs::Callee_0(int32&, - typedref) - IL_0011: ret - } // end of method TailCallStructs::Caller_0 - - .method public hidebysig static void Callee_0(int32& result, - typedref tr0) cil managed noinlining - { - // Code size 37 (0x25) - .maxstack 3 - .locals init (valuetype CSCreate.MB1 V_0) - IL_0000: ldarg.1 - IL_0001: refanyval CSCreate.MB1 - IL_0006: ldobj CSCreate.MB1 - IL_000b: stloc.0 - IL_000c: ldloca.s V_0 - IL_000e: ldfld uint8 CSCreate.MB1::b0 - IL_0013: call void [System.Console]System.Console::WriteLine(int32) - IL_0018: ldarg.0 - IL_0019: dup - IL_001a: ldind.i4 - IL_001b: ldloca.s V_0 - IL_001d: ldfld uint8 CSCreate.MB1::b0 - IL_0022: add - IL_0023: stind.i4 - IL_0024: ret - } // end of method TailCallStructs::Callee_0 - - .method public hidebysig static int32 Main() cil managed - { - .entrypoint - // Code size 26 (0x1a) - .maxstack 8 - IL_0000: call void TCS.TailCallStructs::Head_0() -ldc.i4 100 - IL_0019: ret - } // end of method TailCallStructs::Main - - .method public hidebysig specialname rtspecialname - instance void .ctor() cil managed - { - // Code size 7 (0x7) - .maxstack 8 - IL_0000: ldarg.0 - IL_0001: call instance void [mscorlib]System.Object::.ctor() - IL_0006: ret - } // end of method TailCallStructs::.ctor - -} // end of class TCS.TailCallStructs - -.class private sequential ansi sealed beforefieldinit CSCreate.MB1 - extends [mscorlib]System.ValueType -{ - .field public uint8 b0 -} // end of class CSCreate.MB1 - -.class private sequential ansi sealed beforefieldinit CSCreate.MB2 - extends [mscorlib]System.ValueType -{ - .field public uint8 b0 - .field public uint8 b1 -} // end of class CSCreate.MB2 - -.class private sequential ansi sealed beforefieldinit CSCreate.MB3 - extends [mscorlib]System.ValueType -{ - .field public uint8 b0 - .field public uint8 b1 - .field public uint8 b2 -} // end of class CSCreate.MB3 - -.class private sequential ansi sealed beforefieldinit CSCreate.MB4 - extends [mscorlib]System.ValueType -{ - .field public uint8 b0 - .field public uint8 b1 - .field public uint8 b2 - .field public uint8 b3 -} // end of class CSCreate.MB4 - -.class private sequential ansi sealed beforefieldinit CSCreate.MB5 - extends [mscorlib]System.ValueType -{ - .field public uint8 b0 - .field public uint8 b1 - .field public uint8 b2 - .field public uint8 b3 - .field public uint8 b4 -} // end of class CSCreate.MB5 - -.class private sequential ansi sealed beforefieldinit CSCreate.MB6 - extends [mscorlib]System.ValueType -{ - .field public uint8 b0 - .field public uint8 b1 - .field public uint8 b2 - .field public uint8 b3 - .field public uint8 b4 - .field public uint8 b5 -} // end of class CSCreate.MB6 - -.class private sequential ansi sealed beforefieldinit CSCreate.MB7 - extends [mscorlib]System.ValueType -{ - .field public uint8 b0 - .field public uint8 b1 - .field public uint8 b2 - .field public uint8 b3 - .field public uint8 b4 - .field public uint8 b5 - .field public uint8 b6 -} // end of class CSCreate.MB7 - -.class private sequential ansi sealed beforefieldinit CSCreate.MB8 - extends [mscorlib]System.ValueType -{ - .field public uint8 b0 - .field public uint8 b1 - .field public uint8 b2 - .field public uint8 b3 - .field public uint8 b4 - .field public uint8 b5 - .field public uint8 b6 - .field public uint8 b7 -} // end of class CSCreate.MB8 - - -// ============================================================= - -// *********** DISASSEMBLY COMPLETE *********************** diff --git a/src/coreclr/tests/src/JIT/jit64/localloc/call/call03_dynamic.il b/src/coreclr/tests/src/JIT/jit64/localloc/call/call03_dynamic.il deleted file mode 100644 index 80999370d7c..00000000000 --- a/src/coreclr/tests/src/JIT/jit64/localloc/call/call03_dynamic.il +++ /dev/null @@ -1,223 +0,0 @@ -// Tail call version of call01 test. - -.assembly extern System.Console -{ - .publickeytoken = (B0 3F 5F 7F 11 D5 0A 3A ) - .ver 4:0:0:0 -} -.assembly extern mscorlib{} -.assembly extern common {} -.assembly call01_SMALL {} -.class private auto ansi beforefieldinit LocallocTest - extends [mscorlib]System.Object -{ - .field private static int32 locallocSize - .method public hidebysig static int32 Main() cil managed - { - .entrypoint - .maxstack 10 - .locals (unsigned int64 local1, - unsigned int64 local2, - int32* intArray1, - int32* intArray2) - IL_0000: ldc.i8 0xfedcba9876543210 - IL_0009: stloc.0 - IL_000a: ldloc.0 - IL_000b: ldc.i4.1 - IL_000c: conv.i8 - IL_000d: add - IL_000e: stloc.1 - - IL_000f: ldc.i4.4 - IL_0010: ldsfld int32 [common]LocallocTesting.Global::stackAllocSize - IL_0011: mul - IL_0012: localloc - IL_0014: stloc.2 - IL_0015: ldc.i4.4 - IL_0016: ldsfld int32 [common]LocallocTesting.Global::stackAllocSize - IL_0017: mul - IL_0018: localloc - IL_001a: stloc.3 - - IL_001b: ldsfld int32 [common]LocallocTesting.Global::stackAllocSize - IL_001c: stsfld int32 LocallocTest::locallocSize - - IL_0021: ldloc.2 - IL_0022: ldsfld int32 LocallocTest::locallocSize - IL_0027: ldc.i4 1000 - IL_002c: call void [common]LocallocTesting.Global::initializeStack(int32*, - int32, - int32) - IL_0031: ldloc.3 - IL_0032: ldsfld int32 LocallocTest::locallocSize - IL_0037: ldc.i4 2000 - IL_003c: call void [common]LocallocTesting.Global::initializeStack(int32*, - int32, - int32) - - ldstr "local1" - ldloc.0 - ldc.i8 0xfedcba9876543210 - call bool [common]LocallocTesting.Global::verifyLocal(string, - unsigned int64, - unsigned int64) - brtrue.s L_Verify1 - - ldc.i4.1 - br.s L_End - L_Verify1: - ldstr "local2" - ldloc.1 - ldc.i8 0xfedcba9876543211 - call bool [common]LocallocTesting.Global::verifyLocal(string, - unsigned int64, - unsigned int64) - brtrue.s IL_0041 - - ldc.i4.1 - br.s L_End - - IL_0041: ldc.i4.1 - IL_0042: ldc.i4.2 - IL_0043: ldc.i4.3 - IL_0044: ldc.i4.4 - IL_0045: ldc.i4.5 - IL_0046: ldc.i4.6 - IL_0047: ldc.i4.7 - IL_0048: ldc.i4.8 - IL_0049: ldloc.2 - IL_004a: ldloc.3 - IL_004b: tail. call int32 LocallocTest::func1(int32, - int32, - int32, - int32, - int32, - int32, - int32, - int32, - int32*, - int32*) - L_End: ret - } - - .method private hidebysig static int32 func1(int32 i1, - int32 i2, - int32 i3, - int32 i4, - int32 i5, - int32 i6, - int32 i7, - int32 i8, - int32* ar1, - int32* ar2) cil managed - { - .locals (int32* intArray1, - int32* intArray2, - int32 RetValue) - IL_0000: ldc.i4.4 - IL_0001: ldsfld int32 [common]LocallocTesting.Global::stackAllocSize - IL_0002: mul - IL_0003: localloc - IL_0005: stloc.0 - IL_0006: ldc.i4.4 - IL_0007: ldsfld int32 [common]LocallocTesting.Global::stackAllocSize - IL_0008: mul - IL_0009: localloc - IL_000b: stloc.1 - IL_000c: ldloc.0 - IL_000d: ldsfld int32 LocallocTest::locallocSize - IL_0012: ldc.i4 0xbb8 - IL_0017: call void [common]LocallocTesting.Global::initializeStack(int32*, - int32, - int32) - IL_001c: ldloc.1 - IL_001d: ldsfld int32 LocallocTest::locallocSize - IL_0022: ldc.i4 0xfa0 - IL_0027: call void [common]LocallocTesting.Global::initializeStack(int32*, - int32, - int32) - IL_002c: ldstr "ar1" - IL_0031: ldarg.s ar1 - IL_0033: ldsfld int32 LocallocTest::locallocSize - IL_0038: ldc.i4 0x3e8 - IL_003d: call bool [common]LocallocTesting.Global::verifyStack(string, - int32*, - int32, - int32) - IL_0042: brtrue.s L_Verify1 - - IL_0044: ldc.i4.1 - IL_0045: stloc.2 - IL_0046: br.s IL_009e - - L_Verify1: ldstr "ar2" - IL_004d: ldarg.s ar2 - IL_004f: ldsfld int32 LocallocTest::locallocSize - IL_0054: ldc.i4 0x7d0 - IL_0059: call bool [common]LocallocTesting.Global::verifyStack(string, - int32*, - int32, - int32) - IL_005e: brtrue.s L_Verify2 - - IL_0060: ldc.i4.1 - IL_0061: stloc.2 - IL_0062: br.s IL_009e - - L_Verify2: ldstr "intArray1" - IL_0069: ldloc.0 - IL_006a: ldsfld int32 LocallocTest::locallocSize - IL_006f: ldc.i4 0xbb8 - IL_0074: call bool [common]LocallocTesting.Global::verifyStack(string, - int32*, - int32, - int32) - IL_0079: brtrue.s L_Verify3 - - IL_007b: ldc.i4.1 - IL_007c: stloc.2 - IL_007d: br.s IL_009e - - L_Verify3: ldstr "intArray2" - IL_0084: ldloc.1 - IL_0085: ldsfld int32 LocallocTest::locallocSize - IL_008a: ldc.i4 0xfa0 - IL_008f: call bool [common]LocallocTesting.Global::verifyStack(string, - int32*, - int32, - int32) - IL_0094: brtrue.s L_Passed - - IL_0096: ldc.i4.1 - IL_0097: stloc.2 - IL_0098: br.s IL_009e - - L_Passed: ldstr "Passed\n" - call void [System.Console]System.Console::WriteLine(string) - ldc.i4.s 100 - IL_009b: stloc.2 - IL_009c: br.s IL_009e - - IL_009e: ldloc.2 - IL_009f: ret - } - - .method private hidebysig specialname rtspecialname static - void .cctor() cil managed - { - .maxstack 8 - IL_0000: ldc.i4.0 - IL_0001: stsfld int32 LocallocTest::locallocSize - IL_0006: ret - } - - .method public hidebysig specialname rtspecialname - instance void .ctor() cil managed - { - .maxstack 8 - IL_0000: ldarg.0 - IL_0001: call instance void [mscorlib]System.Object::.ctor() - IL_0006: ret - } - -} diff --git a/src/coreclr/tests/src/JIT/jit64/localloc/call/call03_dynamic.ilproj b/src/coreclr/tests/src/JIT/jit64/localloc/call/call03_dynamic.ilproj deleted file mode 100644 index ac2fc7a72a6..00000000000 --- a/src/coreclr/tests/src/JIT/jit64/localloc/call/call03_dynamic.ilproj +++ /dev/null @@ -1,16 +0,0 @@ - - - Exe - 1 - - - PdbOnly - True - - - - - - - - diff --git a/src/coreclr/tests/src/JIT/jit64/localloc/call/call03_large.il b/src/coreclr/tests/src/JIT/jit64/localloc/call/call03_large.il deleted file mode 100644 index 79dfbe48d03..00000000000 --- a/src/coreclr/tests/src/JIT/jit64/localloc/call/call03_large.il +++ /dev/null @@ -1,223 +0,0 @@ -// Tail call version of call01 test. - -.assembly extern System.Console -{ - .publickeytoken = (B0 3F 5F 7F 11 D5 0A 3A ) - .ver 4:0:0:0 -} -.assembly extern mscorlib{} -.assembly extern common {} -.assembly call01_SMALL {} -.class private auto ansi beforefieldinit LocallocTest - extends [mscorlib]System.Object -{ - .field private static int32 locallocSize - .method public hidebysig static int32 Main() cil managed - { - .entrypoint - .maxstack 10 - .locals (unsigned int64 local1, - unsigned int64 local2, - int32* intArray1, - int32* intArray2) - IL_0000: ldc.i8 0xfedcba9876543210 - IL_0009: stloc.0 - IL_000a: ldloc.0 - IL_000b: ldc.i4.1 - IL_000c: conv.i8 - IL_000d: add - IL_000e: stloc.1 - - IL_000f: ldc.i4.4 - IL_0010: ldc.i4 0x1000 - IL_0011: mul - IL_0012: localloc - IL_0014: stloc.2 - IL_0015: ldc.i4.4 - IL_0016: ldc.i4 0x1000 - IL_0017: mul - IL_0018: localloc - IL_001a: stloc.3 - - IL_001b: ldc.i4 0x1000 - IL_001c: stsfld int32 LocallocTest::locallocSize - - IL_0021: ldloc.2 - IL_0022: ldsfld int32 LocallocTest::locallocSize - IL_0027: ldc.i4 1000 - IL_002c: call void [common]LocallocTesting.Global::initializeStack(int32*, - int32, - int32) - IL_0031: ldloc.3 - IL_0032: ldsfld int32 LocallocTest::locallocSize - IL_0037: ldc.i4 2000 - IL_003c: call void [common]LocallocTesting.Global::initializeStack(int32*, - int32, - int32) - - ldstr "local1" - ldloc.0 - ldc.i8 0xfedcba9876543210 - call bool [common]LocallocTesting.Global::verifyLocal(string, - unsigned int64, - unsigned int64) - brtrue.s L_Verify1 - - ldc.i4.1 - br.s L_End - L_Verify1: - ldstr "local2" - ldloc.1 - ldc.i8 0xfedcba9876543211 - call bool [common]LocallocTesting.Global::verifyLocal(string, - unsigned int64, - unsigned int64) - brtrue.s IL_0041 - - ldc.i4.1 - br.s L_End - - IL_0041: ldc.i4.1 - IL_0042: ldc.i4.2 - IL_0043: ldc.i4.3 - IL_0044: ldc.i4.4 - IL_0045: ldc.i4.5 - IL_0046: ldc.i4.6 - IL_0047: ldc.i4.7 - IL_0048: ldc.i4.8 - IL_0049: ldloc.2 - IL_004a: ldloc.3 - IL_004b: tail. call int32 LocallocTest::func1(int32, - int32, - int32, - int32, - int32, - int32, - int32, - int32, - int32*, - int32*) - L_End: ret - } - - .method private hidebysig static int32 func1(int32 i1, - int32 i2, - int32 i3, - int32 i4, - int32 i5, - int32 i6, - int32 i7, - int32 i8, - int32* ar1, - int32* ar2) cil managed - { - .locals (int32* intArray1, - int32* intArray2, - int32 RetValue) - IL_0000: ldc.i4.4 - IL_0001: ldc.i4 0x1000 - IL_0002: mul - IL_0003: localloc - IL_0005: stloc.0 - IL_0006: ldc.i4.4 - IL_0007: ldc.i4 0x1000 - IL_0008: mul - IL_0009: localloc - IL_000b: stloc.1 - IL_000c: ldloc.0 - IL_000d: ldsfld int32 LocallocTest::locallocSize - IL_0012: ldc.i4 0xbb8 - IL_0017: call void [common]LocallocTesting.Global::initializeStack(int32*, - int32, - int32) - IL_001c: ldloc.1 - IL_001d: ldsfld int32 LocallocTest::locallocSize - IL_0022: ldc.i4 0xfa0 - IL_0027: call void [common]LocallocTesting.Global::initializeStack(int32*, - int32, - int32) - IL_002c: ldstr "ar1" - IL_0031: ldarg.s ar1 - IL_0033: ldsfld int32 LocallocTest::locallocSize - IL_0038: ldc.i4 0x3e8 - IL_003d: call bool [common]LocallocTesting.Global::verifyStack(string, - int32*, - int32, - int32) - IL_0042: brtrue.s L_Verify1 - - IL_0044: ldc.i4.1 - IL_0045: stloc.2 - IL_0046: br.s IL_009e - - L_Verify1: ldstr "ar2" - IL_004d: ldarg.s ar2 - IL_004f: ldsfld int32 LocallocTest::locallocSize - IL_0054: ldc.i4 0x7d0 - IL_0059: call bool [common]LocallocTesting.Global::verifyStack(string, - int32*, - int32, - int32) - IL_005e: brtrue.s L_Verify2 - - IL_0060: ldc.i4.1 - IL_0061: stloc.2 - IL_0062: br.s IL_009e - - L_Verify2: ldstr "intArray1" - IL_0069: ldloc.0 - IL_006a: ldsfld int32 LocallocTest::locallocSize - IL_006f: ldc.i4 0xbb8 - IL_0074: call bool [common]LocallocTesting.Global::verifyStack(string, - int32*, - int32, - int32) - IL_0079: brtrue.s L_Verify3 - - IL_007b: ldc.i4.1 - IL_007c: stloc.2 - IL_007d: br.s IL_009e - - L_Verify3: ldstr "intArray2" - IL_0084: ldloc.1 - IL_0085: ldsfld int32 LocallocTest::locallocSize - IL_008a: ldc.i4 0xfa0 - IL_008f: call bool [common]LocallocTesting.Global::verifyStack(string, - int32*, - int32, - int32) - IL_0094: brtrue.s L_Passed - - IL_0096: ldc.i4.1 - IL_0097: stloc.2 - IL_0098: br.s IL_009e - - L_Passed: ldstr "Passed\n" - call void [System.Console]System.Console::WriteLine(string) - ldc.i4.s 100 - IL_009b: stloc.2 - IL_009c: br.s IL_009e - - IL_009e: ldloc.2 - IL_009f: ret - } - - .method private hidebysig specialname rtspecialname static - void .cctor() cil managed - { - .maxstack 8 - IL_0000: ldc.i4.0 - IL_0001: stsfld int32 LocallocTest::locallocSize - IL_0006: ret - } - - .method public hidebysig specialname rtspecialname - instance void .ctor() cil managed - { - .maxstack 8 - IL_0000: ldarg.0 - IL_0001: call instance void [mscorlib]System.Object::.ctor() - IL_0006: ret - } - -} diff --git a/src/coreclr/tests/src/JIT/jit64/localloc/call/call03_large.ilproj b/src/coreclr/tests/src/JIT/jit64/localloc/call/call03_large.ilproj deleted file mode 100644 index 16ec69eb77e..00000000000 --- a/src/coreclr/tests/src/JIT/jit64/localloc/call/call03_large.ilproj +++ /dev/null @@ -1,16 +0,0 @@ - - - Exe - 1 - - - PdbOnly - True - - - - - - - - diff --git a/src/coreclr/tests/src/JIT/jit64/localloc/call/call03_small.il b/src/coreclr/tests/src/JIT/jit64/localloc/call/call03_small.il deleted file mode 100644 index e419804a74b..00000000000 --- a/src/coreclr/tests/src/JIT/jit64/localloc/call/call03_small.il +++ /dev/null @@ -1,224 +0,0 @@ -// Tail call version of call01 test. - - -.assembly extern System.Console -{ - .publickeytoken = (B0 3F 5F 7F 11 D5 0A 3A ) - .ver 4:0:0:0 -} -.assembly extern mscorlib{} -.assembly extern common {} -.assembly call01_SMALL {} -.class private auto ansi beforefieldinit LocallocTest - extends [mscorlib]System.Object -{ - .field private static int32 locallocSize - .method public hidebysig static int32 Main() cil managed - { - .entrypoint - .maxstack 10 - .locals (unsigned int64 local1, - unsigned int64 local2, - int32* intArray1, - int32* intArray2) - IL_0000: ldc.i8 0xfedcba9876543210 - IL_0009: stloc.0 - IL_000a: ldloc.0 - IL_000b: ldc.i4.1 - IL_000c: conv.i8 - IL_000d: add - IL_000e: stloc.1 - - IL_000f: ldc.i4.4 - IL_0010: ldc.i4.1 - IL_0011: mul - IL_0012: localloc - IL_0014: stloc.2 - IL_0015: ldc.i4.4 - IL_0016: ldc.i4.1 - IL_0017: mul - IL_0018: localloc - IL_001a: stloc.3 - - IL_001b: ldc.i4.1 - IL_001c: stsfld int32 LocallocTest::locallocSize - - IL_0021: ldloc.2 - IL_0022: ldsfld int32 LocallocTest::locallocSize - IL_0027: ldc.i4 1000 - IL_002c: call void [common]LocallocTesting.Global::initializeStack(int32*, - int32, - int32) - IL_0031: ldloc.3 - IL_0032: ldsfld int32 LocallocTest::locallocSize - IL_0037: ldc.i4 2000 - IL_003c: call void [common]LocallocTesting.Global::initializeStack(int32*, - int32, - int32) - - ldstr "local1" - ldloc.0 - ldc.i8 0xfedcba9876543210 - call bool [common]LocallocTesting.Global::verifyLocal(string, - unsigned int64, - unsigned int64) - brtrue.s L_Verify1 - - ldc.i4.1 - br.s L_End - L_Verify1: - ldstr "local2" - ldloc.1 - ldc.i8 0xfedcba9876543211 - call bool [common]LocallocTesting.Global::verifyLocal(string, - unsigned int64, - unsigned int64) - brtrue.s IL_0041 - - ldc.i4.1 - br.s L_End - - IL_0041: ldc.i4.1 - IL_0042: ldc.i4.2 - IL_0043: ldc.i4.3 - IL_0044: ldc.i4.4 - IL_0045: ldc.i4.5 - IL_0046: ldc.i4.6 - IL_0047: ldc.i4.7 - IL_0048: ldc.i4.8 - IL_0049: ldloc.2 - IL_004a: ldloc.3 - IL_004b: tail. call int32 LocallocTest::func1(int32, - int32, - int32, - int32, - int32, - int32, - int32, - int32, - int32*, - int32*) - L_End: ret - } - - .method private hidebysig static int32 func1(int32 i1, - int32 i2, - int32 i3, - int32 i4, - int32 i5, - int32 i6, - int32 i7, - int32 i8, - int32* ar1, - int32* ar2) cil managed - { - .locals (int32* intArray1, - int32* intArray2, - int32 RetValue) - IL_0000: ldc.i4.4 - IL_0001: ldc.i4.1 - IL_0002: mul - IL_0003: localloc - IL_0005: stloc.0 - IL_0006: ldc.i4.4 - IL_0007: ldc.i4.1 - IL_0008: mul - IL_0009: localloc - IL_000b: stloc.1 - IL_000c: ldloc.0 - IL_000d: ldsfld int32 LocallocTest::locallocSize - IL_0012: ldc.i4 0xbb8 - IL_0017: call void [common]LocallocTesting.Global::initializeStack(int32*, - int32, - int32) - IL_001c: ldloc.1 - IL_001d: ldsfld int32 LocallocTest::locallocSize - IL_0022: ldc.i4 0xfa0 - IL_0027: call void [common]LocallocTesting.Global::initializeStack(int32*, - int32, - int32) - IL_002c: ldstr "ar1" - IL_0031: ldarg.s ar1 - IL_0033: ldsfld int32 LocallocTest::locallocSize - IL_0038: ldc.i4 0x3e8 - IL_003d: call bool [common]LocallocTesting.Global::verifyStack(string, - int32*, - int32, - int32) - IL_0042: brtrue.s L_Verify1 - - IL_0044: ldc.i4.1 - IL_0045: stloc.2 - IL_0046: br.s IL_009e - - L_Verify1: ldstr "ar2" - IL_004d: ldarg.s ar2 - IL_004f: ldsfld int32 LocallocTest::locallocSize - IL_0054: ldc.i4 0x7d0 - IL_0059: call bool [common]LocallocTesting.Global::verifyStack(string, - int32*, - int32, - int32) - IL_005e: brtrue.s L_Verify2 - - IL_0060: ldc.i4.1 - IL_0061: stloc.2 - IL_0062: br.s IL_009e - - L_Verify2: ldstr "intArray1" - IL_0069: ldloc.0 - IL_006a: ldsfld int32 LocallocTest::locallocSize - IL_006f: ldc.i4 0xbb8 - IL_0074: call bool [common]LocallocTesting.Global::verifyStack(string, - int32*, - int32, - int32) - IL_0079: brtrue.s L_Verify3 - - IL_007b: ldc.i4.1 - IL_007c: stloc.2 - IL_007d: br.s IL_009e - - L_Verify3: ldstr "intArray2" - IL_0084: ldloc.1 - IL_0085: ldsfld int32 LocallocTest::locallocSize - IL_008a: ldc.i4 0xfa0 - IL_008f: call bool [common]LocallocTesting.Global::verifyStack(string, - int32*, - int32, - int32) - IL_0094: brtrue.s L_Passed - - IL_0096: ldc.i4.1 - IL_0097: stloc.2 - IL_0098: br.s IL_009e - - L_Passed: ldstr "Passed\n" - call void [System.Console]System.Console::WriteLine(string) - ldc.i4.s 100 - IL_009b: stloc.2 - IL_009c: br.s IL_009e - - IL_009e: ldloc.2 - IL_009f: ret - } - - .method private hidebysig specialname rtspecialname static - void .cctor() cil managed - { - .maxstack 8 - IL_0000: ldc.i4.0 - IL_0001: stsfld int32 LocallocTest::locallocSize - IL_0006: ret - } - - .method public hidebysig specialname rtspecialname - instance void .ctor() cil managed - { - .maxstack 8 - IL_0000: ldarg.0 - IL_0001: call instance void [mscorlib]System.Object::.ctor() - IL_0006: ret - } - -} diff --git a/src/coreclr/tests/src/JIT/jit64/localloc/call/call03_small.ilproj b/src/coreclr/tests/src/JIT/jit64/localloc/call/call03_small.ilproj deleted file mode 100644 index f24c34e93a8..00000000000 --- a/src/coreclr/tests/src/JIT/jit64/localloc/call/call03_small.ilproj +++ /dev/null @@ -1,16 +0,0 @@ - - - Exe - 1 - - - PdbOnly - True - - - - - - - - diff --git a/src/coreclr/tests/src/JIT/jit64/localloc/call/call04_dynamic.il b/src/coreclr/tests/src/JIT/jit64/localloc/call/call04_dynamic.il deleted file mode 100644 index 266b49e93d3..00000000000 --- a/src/coreclr/tests/src/JIT/jit64/localloc/call/call04_dynamic.il +++ /dev/null @@ -1,242 +0,0 @@ -// tail call version of call02. - - -.assembly extern System.Console -{ - .publickeytoken = (B0 3F 5F 7F 11 D5 0A 3A ) - .ver 4:0:0:0 -} -.assembly extern mscorlib{} -.assembly extern common {} - -.assembly call02 {} - -.class private auto ansi beforefieldinit LocallocTest - extends [mscorlib]System.Object -{ - .field private static int32 locallocSize - .method public hidebysig static int32 Main() cil managed - { - .entrypoint - .maxstack 11 - .locals (unsigned int64 local1, - unsigned int64 local2, - int32* intArray1, - int32* intArray2, - class [common]LocallocTesting.TestClass obj) - IL_0000: ldc.i8 0xfedcba9876543210 - IL_0009: stloc.0 - IL_000a: ldloc.0 - IL_000b: ldc.i4.1 - IL_000c: conv.i8 - IL_000d: add - IL_000e: stloc.1 - - IL_000f: ldc.i4.4 - IL_0010: ldsfld int32 [common]LocallocTesting.Global::stackAllocSize - IL_0011: mul - IL_0012: localloc - IL_0014: stloc.2 - IL_0015: ldc.i4.4 - IL_0016: ldsfld int32 [common]LocallocTesting.Global::stackAllocSize - IL_0017: mul - IL_0018: localloc - IL_001a: stloc.3 - - IL_001b: ldsfld int32 [common]LocallocTesting.Global::stackAllocSize - IL_001c: stsfld int32 LocallocTest::locallocSize - - IL_0021: ldloc.2 - IL_0022: ldsfld int32 LocallocTest::locallocSize - IL_0027: ldc.i4 1000 - IL_002c: call void [common]LocallocTesting.Global::initializeStack(int32*, - int32, - int32) - IL_0031: ldloc.3 - IL_0032: ldsfld int32 LocallocTest::locallocSize - IL_0037: ldc.i4 2000 - IL_003c: call void [common]LocallocTesting.Global::initializeStack(int32*, - int32, - int32) - - IL_0041: ldc.i4 9999 - IL_0046: conv.i8 - IL_0047: newobj instance void [common]LocallocTesting.TestClass::.ctor(int64) - IL_004c: stloc.s obj - - IL_004e: ldc.i4.1 - IL_004f: ldc.i4.2 - IL_0050: ldc.i4.3 - IL_0051: ldc.i4.4 - IL_0052: ldc.i4.5 - IL_0053: ldc.i4.6 - IL_0054: ldc.i4.7 - IL_0055: ldc.i4.8 - IL_0056: ldloc.2 - IL_0057: ldloc.s obj - IL_0059: ldloc.3 - IL_005a: tail. call int32 LocallocTest::func1(int32, - int32, - int32, - int32, - int32, - int32, - int32, - int32, - int32*, - class [common]LocallocTesting.TestClass, - int32*) - - IL_0065: ret - } - - .method private hidebysig static int32 - func1(int32 i1, - int32 i2, - int32 i3, - int32 i4, - int32 i5, - int32 i6, - int32 i7, - int32 i8, - int32* ar1, - class [common]LocallocTesting.TestClass obj, - int32* ar2) cil managed - { - .maxstack 4 - .locals (int32* intArray1, - int32* intArray2, - int32 retValue) - - ldc.i4.4 - IL_0078: ldsfld int32 [common]LocallocTesting.Global::stackAllocSize - IL_0079: mul - IL_007a: localloc - IL_007c: stloc.s intArray1 - IL_007e: ldc.i4.4 - IL_007f: ldsfld int32 [common]LocallocTesting.Global::stackAllocSize - IL_0080: mul - IL_0081: localloc - IL_0083: stloc.s intArray2 - - IL_0085: ldloc.s intArray1 - IL_0087: ldsfld int32 LocallocTest::locallocSize - IL_008c: ldc.i4 3000 - IL_0091: call void [common]LocallocTesting.Global::initializeStack(int32*, - int32, - int32) - IL_0096: ldloc.s intArray2 - IL_0098: ldsfld int32 LocallocTest::locallocSize - IL_009d: ldc.i4 4000 - IL_00a2: call void [common]LocallocTesting.Global::initializeStack(int32*, - int32, - int32) - IL_0036: ldarg.s obj - IL_0037: callvirt instance bool [common]LocallocTesting.TestClass::ForceGC() - IL_003c: brtrue.s L_Forced - IL_003d: ldstr "Failed to force GC!" - IL_0042: call void [System.Console]System.Console::WriteLine(string) - IL_004e: ldc.i4.1 - IL_004f: stloc.s retValue - IL_0051: br L_END - - L_Forced: ldarg.s obj - IL_00a9: ldfld int64 [common]LocallocTesting.TestClass::id - IL_00ae: ldc.i4 0x270f - IL_00b3: conv.i8 - IL_00b4: beq.s L_Verify1 - - IL_00b6: ldstr "obj.id is corrupted." - IL_00bb: call void [System.Console]System.Console::WriteLine(string) - IL_00c0: ldc.i4.1 - IL_00c1: stloc.s retValue - IL_00c3: br L_END - - L_Verify1: ldstr "ar1" - IL_00cd: ldarg.s ar1 - IL_00cf: ldsfld int32 LocallocTest::locallocSize - IL_00d4: ldc.i4 1000 - IL_00d9: call bool [common]LocallocTesting.Global::verifyStack(string, - int32*, - int32, - int32) - IL_00de: brtrue.s L_Verify2 - - IL_00e0: ldc.i4.1 - IL_00e1: stloc.s retValue - IL_00e3: br.s L_END - - L_Verify2: ldstr "ar2" - IL_00ea: ldarg.s ar2 - IL_00ec: ldsfld int32 LocallocTest::locallocSize - IL_00f1: ldc.i4 2000 - IL_00f6: call bool [common]LocallocTesting.Global::verifyStack(string, - int32*, - int32, - int32) - IL_00fb: brtrue.s L_Verify3 - - IL_00fd: ldc.i4.1 - IL_00fe: stloc.s retValue - IL_0100: br.s L_END - - L_Verify3: ldstr "intArray1" - IL_0107: ldloc.s intArray1 - IL_0109: ldsfld int32 LocallocTest::locallocSize - IL_010e: ldc.i4 3000 - IL_0113: call bool [common]LocallocTesting.Global::verifyStack(string, - int32*, - int32, - int32) - IL_0118: brtrue.s L_Verify4 - - IL_011a: ldc.i4.1 - IL_011b: stloc.s retValue - IL_011d: br.s L_END - - L_Verify4: ldstr "intArray2" - IL_0124: ldloc.s intArray2 - IL_0126: ldsfld int32 LocallocTest::locallocSize - IL_012b: ldc.i4 4000 - IL_0130: call bool [common]LocallocTesting.Global::verifyStack(string, - int32*, - int32, - int32) - IL_0135: brtrue.s L_Passed - - IL_0137: ldc.i4.1 - IL_0138: stloc.s retValue - IL_013a: br.s L_END - - L_Passed: ldstr "Passed" - IL_0141: call void [System.Console]System.Console::WriteLine(string) - IL_0146: ldc.i4.s 100 - IL_0148: stloc.s retValue - IL_014a: br.s L_END - - L_END: ldloc.s retValue - IL_014e: ret - } - - .method private hidebysig specialname rtspecialname static - void .cctor() cil managed - { - .maxstack 8 - IL_0000: ldc.i4.0 - IL_0001: stsfld int32 LocallocTest::locallocSize - IL_0006: ret - } - - .method public hidebysig specialname rtspecialname - instance void .ctor() cil managed - { - .maxstack 8 - IL_0000: ldarg.0 - IL_0001: call instance void [mscorlib]System.Object::.ctor() - IL_0006: ret - } - -} - - - diff --git a/src/coreclr/tests/src/JIT/jit64/localloc/call/call04_dynamic.ilproj b/src/coreclr/tests/src/JIT/jit64/localloc/call/call04_dynamic.ilproj deleted file mode 100644 index 8bf82856c0f..00000000000 --- a/src/coreclr/tests/src/JIT/jit64/localloc/call/call04_dynamic.ilproj +++ /dev/null @@ -1,15 +0,0 @@ - - - Exe - - - PdbOnly - True - - - - - - - - diff --git a/src/coreclr/tests/src/JIT/jit64/localloc/call/call04_large.il b/src/coreclr/tests/src/JIT/jit64/localloc/call/call04_large.il deleted file mode 100644 index da3541d8203..00000000000 --- a/src/coreclr/tests/src/JIT/jit64/localloc/call/call04_large.il +++ /dev/null @@ -1,242 +0,0 @@ -// tail call version of call02. - - -.assembly extern System.Console -{ - .publickeytoken = (B0 3F 5F 7F 11 D5 0A 3A ) - .ver 4:0:0:0 -} -.assembly extern mscorlib{} -.assembly extern common {} - -.assembly call02 {} - -.class private auto ansi beforefieldinit LocallocTest - extends [mscorlib]System.Object -{ - .field private static int32 locallocSize - .method public hidebysig static int32 Main() cil managed - { - .entrypoint - .maxstack 11 - .locals (unsigned int64 local1, - unsigned int64 local2, - int32* intArray1, - int32* intArray2, - class [common]LocallocTesting.TestClass obj) - IL_0000: ldc.i8 0xfedcba9876543210 - IL_0009: stloc.0 - IL_000a: ldloc.0 - IL_000b: ldc.i4.1 - IL_000c: conv.i8 - IL_000d: add - IL_000e: stloc.1 - - IL_000f: ldc.i4.4 - IL_0010: ldc.i4 0x1000 - IL_0011: mul - IL_0012: localloc - IL_0014: stloc.2 - IL_0015: ldc.i4.4 - IL_0016: ldc.i4 0x1000 - IL_0017: mul - IL_0018: localloc - IL_001a: stloc.3 - - IL_001b: ldc.i4 0x1000 - IL_001c: stsfld int32 LocallocTest::locallocSize - - IL_0021: ldloc.2 - IL_0022: ldsfld int32 LocallocTest::locallocSize - IL_0027: ldc.i4 1000 - IL_002c: call void [common]LocallocTesting.Global::initializeStack(int32*, - int32, - int32) - IL_0031: ldloc.3 - IL_0032: ldsfld int32 LocallocTest::locallocSize - IL_0037: ldc.i4 2000 - IL_003c: call void [common]LocallocTesting.Global::initializeStack(int32*, - int32, - int32) - - IL_0041: ldc.i4 9999 - IL_0046: conv.i8 - IL_0047: newobj instance void [common]LocallocTesting.TestClass::.ctor(int64) - IL_004c: stloc.s obj - - IL_004e: ldc.i4.1 - IL_004f: ldc.i4.2 - IL_0050: ldc.i4.3 - IL_0051: ldc.i4.4 - IL_0052: ldc.i4.5 - IL_0053: ldc.i4.6 - IL_0054: ldc.i4.7 - IL_0055: ldc.i4.8 - IL_0056: ldloc.2 - IL_0057: ldloc.s obj - IL_0059: ldloc.3 - IL_005a: tail. call int32 LocallocTest::func1(int32, - int32, - int32, - int32, - int32, - int32, - int32, - int32, - int32*, - class [common]LocallocTesting.TestClass, - int32*) - - IL_0065: ret - } - - .method private hidebysig static int32 - func1(int32 i1, - int32 i2, - int32 i3, - int32 i4, - int32 i5, - int32 i6, - int32 i7, - int32 i8, - int32* ar1, - class [common]LocallocTesting.TestClass obj, - int32* ar2) cil managed - { - .maxstack 4 - .locals (int32* intArray1, - int32* intArray2, - int32 retValue) - - ldc.i4.4 - IL_0078: ldc.i4 0x1000 - IL_0079: mul - IL_007a: localloc - IL_007c: stloc.s intArray1 - IL_007e: ldc.i4.4 - IL_007f: ldc.i4 0x1000 - IL_0080: mul - IL_0081: localloc - IL_0083: stloc.s intArray2 - - IL_0085: ldloc.s intArray1 - IL_0087: ldsfld int32 LocallocTest::locallocSize - IL_008c: ldc.i4 3000 - IL_0091: call void [common]LocallocTesting.Global::initializeStack(int32*, - int32, - int32) - IL_0096: ldloc.s intArray2 - IL_0098: ldsfld int32 LocallocTest::locallocSize - IL_009d: ldc.i4 4000 - IL_00a2: call void [common]LocallocTesting.Global::initializeStack(int32*, - int32, - int32) - IL_0036: ldarg.s obj - IL_0037: callvirt instance bool [common]LocallocTesting.TestClass::ForceGC() - IL_003c: brtrue.s L_Forced - IL_003d: ldstr "Failed to force GC!" - IL_0042: call void [System.Console]System.Console::WriteLine(string) - IL_004e: ldc.i4.1 - IL_004f: stloc.s retValue - IL_0051: br L_END - - L_Forced: ldarg.s obj - IL_00a9: ldfld int64 [common]LocallocTesting.TestClass::id - IL_00ae: ldc.i4 0x270f - IL_00b3: conv.i8 - IL_00b4: beq.s L_Verify1 - - IL_00b6: ldstr "obj.id is corrupted." - IL_00bb: call void [System.Console]System.Console::WriteLine(string) - IL_00c0: ldc.i4.1 - IL_00c1: stloc.s retValue - IL_00c3: br L_END - - L_Verify1: ldstr "ar1" - IL_00cd: ldarg.s ar1 - IL_00cf: ldsfld int32 LocallocTest::locallocSize - IL_00d4: ldc.i4 1000 - IL_00d9: call bool [common]LocallocTesting.Global::verifyStack(string, - int32*, - int32, - int32) - IL_00de: brtrue.s L_Verify2 - - IL_00e0: ldc.i4.1 - IL_00e1: stloc.s retValue - IL_00e3: br.s L_END - - L_Verify2: ldstr "ar2" - IL_00ea: ldarg.s ar2 - IL_00ec: ldsfld int32 LocallocTest::locallocSize - IL_00f1: ldc.i4 2000 - IL_00f6: call bool [common]LocallocTesting.Global::verifyStack(string, - int32*, - int32, - int32) - IL_00fb: brtrue.s L_Verify3 - - IL_00fd: ldc.i4.1 - IL_00fe: stloc.s retValue - IL_0100: br.s L_END - - L_Verify3: ldstr "intArray1" - IL_0107: ldloc.s intArray1 - IL_0109: ldsfld int32 LocallocTest::locallocSize - IL_010e: ldc.i4 3000 - IL_0113: call bool [common]LocallocTesting.Global::verifyStack(string, - int32*, - int32, - int32) - IL_0118: brtrue.s L_Verify4 - - IL_011a: ldc.i4.1 - IL_011b: stloc.s retValue - IL_011d: br.s L_END - - L_Verify4: ldstr "intArray2" - IL_0124: ldloc.s intArray2 - IL_0126: ldsfld int32 LocallocTest::locallocSize - IL_012b: ldc.i4 4000 - IL_0130: call bool [common]LocallocTesting.Global::verifyStack(string, - int32*, - int32, - int32) - IL_0135: brtrue.s L_Passed - - IL_0137: ldc.i4.1 - IL_0138: stloc.s retValue - IL_013a: br.s L_END - - L_Passed: ldstr "Passed" - IL_0141: call void [System.Console]System.Console::WriteLine(string) - IL_0146: ldc.i4.s 100 - IL_0148: stloc.s retValue - IL_014a: br.s L_END - - L_END: ldloc.s retValue - IL_014e: ret - } - - .method private hidebysig specialname rtspecialname static - void .cctor() cil managed - { - .maxstack 8 - IL_0000: ldc.i4.0 - IL_0001: stsfld int32 LocallocTest::locallocSize - IL_0006: ret - } - - .method public hidebysig specialname rtspecialname - instance void .ctor() cil managed - { - .maxstack 8 - IL_0000: ldarg.0 - IL_0001: call instance void [mscorlib]System.Object::.ctor() - IL_0006: ret - } - -} - - - diff --git a/src/coreclr/tests/src/JIT/jit64/localloc/call/call04_large.ilproj b/src/coreclr/tests/src/JIT/jit64/localloc/call/call04_large.ilproj deleted file mode 100644 index e5c380baa93..00000000000 --- a/src/coreclr/tests/src/JIT/jit64/localloc/call/call04_large.ilproj +++ /dev/null @@ -1,15 +0,0 @@ - - - Exe - - - PdbOnly - True - - - - - - - - diff --git a/src/coreclr/tests/src/JIT/jit64/localloc/call/call04_small.il b/src/coreclr/tests/src/JIT/jit64/localloc/call/call04_small.il deleted file mode 100644 index e13764d7baa..00000000000 --- a/src/coreclr/tests/src/JIT/jit64/localloc/call/call04_small.il +++ /dev/null @@ -1,260 +0,0 @@ -// tail call version of call02. - - -.assembly extern System.Console -{ - .publickeytoken = (B0 3F 5F 7F 11 D5 0A 3A ) - .ver 4:0:0:0 -} -.assembly extern mscorlib{} -.assembly extern common {} - -.assembly call02 {} - -.class private auto ansi beforefieldinit LocallocTest - extends [mscorlib]System.Object -{ - .field private static int32 locallocSize - .method public hidebysig static int32 Main() cil managed - { - .entrypoint - // Code size 102 (0x66) - .maxstack 11 - .locals (unsigned int64 local1, - unsigned int64 local2, - int32* intArray1, - int32* intArray2, - class [common]LocallocTesting.TestClass obj) -// Initialize local variable - IL_0000: ldc.i8 0xfedcba9876543210 - IL_0009: stloc.0 - IL_000a: ldloc.0 - IL_000b: ldc.i4.1 - IL_000c: conv.i8 - IL_000d: add - IL_000e: stloc.1 - -// localloc for intArrayXX - IL_000f: ldc.i4.4 - IL_0010: ldc.i4.1 - IL_0011: mul - IL_0012: localloc - IL_0014: stloc.2 - IL_0015: ldc.i4.4 - IL_0016: ldc.i4.1 - IL_0017: mul - IL_0018: localloc - IL_001a: stloc.3 - -// Set size localloc - IL_001b: ldc.i4.1 - IL_001c: stsfld int32 LocallocTest::locallocSize - -// Initialize intArrayXX - IL_0021: ldloc.2 - IL_0022: ldsfld int32 LocallocTest::locallocSize - IL_0027: ldc.i4 1000 - IL_002c: call void [common]LocallocTesting.Global::initializeStack(int32*, - int32, - int32) - IL_0031: ldloc.3 - IL_0032: ldsfld int32 LocallocTest::locallocSize - IL_0037: ldc.i4 2000 - IL_003c: call void [common]LocallocTesting.Global::initializeStack(int32*, - int32, - int32) - -// allocate 'obj' which is one of param - IL_0041: ldc.i4 9999 - IL_0046: conv.i8 - IL_0047: newobj instance void [common]LocallocTesting.TestClass::.ctor(int64) - IL_004c: stloc.s obj - -// Invoke func1 - IL_004e: ldc.i4.1 - IL_004f: ldc.i4.2 - IL_0050: ldc.i4.3 - IL_0051: ldc.i4.4 - IL_0052: ldc.i4.5 - IL_0053: ldc.i4.6 - IL_0054: ldc.i4.7 - IL_0055: ldc.i4.8 - IL_0056: ldloc.2 - IL_0057: ldloc.s obj - IL_0059: ldloc.3 - IL_005a: tail. call int32 LocallocTest::func1(int32, - int32, - int32, - int32, - int32, - int32, - int32, - int32, - int32*, - class [common]LocallocTesting.TestClass, - int32*) - - IL_0065: ret - } // end of method LocallocTest::Main - - .method private hidebysig static int32 - func1(int32 i1, - int32 i2, - int32 i3, - int32 i4, - int32 i5, - int32 i6, - int32 i7, - int32 i8, - int32* ar1, - class [common]LocallocTesting.TestClass obj, - int32* ar2) cil managed - { - // Code size 335 (0x14f) - .maxstack 4 - .locals (int32* intArray1, - int32* intArray2, - int32 retValue) - -// allocate intArrayXX - ldc.i4.4 - IL_0078: ldc.i4.1 - IL_0079: mul - IL_007a: localloc - IL_007c: stloc.s intArray1 - IL_007e: ldc.i4.4 - IL_007f: ldc.i4.1 - IL_0080: mul - IL_0081: localloc - IL_0083: stloc.s intArray2 - -// Initialize intArrayXX - IL_0085: ldloc.s intArray1 - IL_0087: ldsfld int32 LocallocTest::locallocSize - IL_008c: ldc.i4 3000 - IL_0091: call void [common]LocallocTesting.Global::initializeStack(int32*, - int32, - int32) - IL_0096: ldloc.s intArray2 - IL_0098: ldsfld int32 LocallocTest::locallocSize - IL_009d: ldc.i4 4000 - IL_00a2: call void [common]LocallocTesting.Global::initializeStack(int32*, - int32, - int32) -// Force GC - IL_0036: ldarg.s obj - IL_0037: callvirt instance bool [common]LocallocTesting.TestClass::ForceGC() - IL_003c: brtrue.s L_Forced - IL_003d: ldstr "Failed to force GC!" - IL_0042: call void [System.Console]System.Console::WriteLine(string) - IL_004e: ldc.i4.1 - IL_004f: stloc.s retValue - IL_0051: br L_END - -// Check if obj is corrupted - L_Forced: ldarg.s obj - IL_00a9: ldfld int64 [common]LocallocTesting.TestClass::id - IL_00ae: ldc.i4 0x270f - IL_00b3: conv.i8 - IL_00b4: beq.s L_Verify1 - - IL_00b6: ldstr "obj.id is corrupted." - IL_00bb: call void [System.Console]System.Console::WriteLine(string) - IL_00c0: ldc.i4.1 - IL_00c1: stloc.s retValue - IL_00c3: br L_END - -// Verify arrays. - L_Verify1: ldstr "ar1" - IL_00cd: ldarg.s ar1 - IL_00cf: ldsfld int32 LocallocTest::locallocSize - IL_00d4: ldc.i4 1000 - IL_00d9: call bool [common]LocallocTesting.Global::verifyStack(string, - int32*, - int32, - int32) - IL_00de: brtrue.s L_Verify2 - - IL_00e0: ldc.i4.1 - IL_00e1: stloc.s retValue - IL_00e3: br.s L_END - - L_Verify2: ldstr "ar2" - IL_00ea: ldarg.s ar2 - IL_00ec: ldsfld int32 LocallocTest::locallocSize - IL_00f1: ldc.i4 2000 - IL_00f6: call bool [common]LocallocTesting.Global::verifyStack(string, - int32*, - int32, - int32) - IL_00fb: brtrue.s L_Verify3 - - IL_00fd: ldc.i4.1 - IL_00fe: stloc.s retValue - IL_0100: br.s L_END - - L_Verify3: ldstr "intArray1" - IL_0107: ldloc.s intArray1 - IL_0109: ldsfld int32 LocallocTest::locallocSize - IL_010e: ldc.i4 3000 - IL_0113: call bool [common]LocallocTesting.Global::verifyStack(string, - int32*, - int32, - int32) - IL_0118: brtrue.s L_Verify4 - - IL_011a: ldc.i4.1 - IL_011b: stloc.s retValue - IL_011d: br.s L_END - - L_Verify4: ldstr "intArray2" - IL_0124: ldloc.s intArray2 - IL_0126: ldsfld int32 LocallocTest::locallocSize - IL_012b: ldc.i4 4000 - IL_0130: call bool [common]LocallocTesting.Global::verifyStack(string, - int32*, - int32, - int32) - IL_0135: brtrue.s L_Passed - - IL_0137: ldc.i4.1 - IL_0138: stloc.s retValue - IL_013a: br.s L_END - - L_Passed: ldstr "Passed" - IL_0141: call void [System.Console]System.Console::WriteLine(string) - IL_0146: ldc.i4.s 100 - IL_0148: stloc.s retValue - IL_014a: br.s L_END - - L_END: ldloc.s retValue - IL_014e: ret - } // end of method LocallocTest::func1 - - .method private hidebysig specialname rtspecialname static - void .cctor() cil managed - { - // Code size 7 (0x7) - .maxstack 8 - IL_0000: ldc.i4.0 - IL_0001: stsfld int32 LocallocTest::locallocSize - IL_0006: ret - } // end of method LocallocTest::.cctor - - .method public hidebysig specialname rtspecialname - instance void .ctor() cil managed - { - // Code size 7 (0x7) - .maxstack 8 - IL_0000: ldarg.0 - IL_0001: call instance void [mscorlib]System.Object::.ctor() - IL_0006: ret - } // end of method LocallocTest::.ctor - -} // end of class LocallocTest - - -// ============================================================= - -//*********** DISASSEMBLY COMPLETE *********************** -// WARNING: Created Win32 resource file call04_small.res diff --git a/src/coreclr/tests/src/JIT/jit64/localloc/call/call04_small.ilproj b/src/coreclr/tests/src/JIT/jit64/localloc/call/call04_small.ilproj deleted file mode 100644 index 10f4211abad..00000000000 --- a/src/coreclr/tests/src/JIT/jit64/localloc/call/call04_small.ilproj +++ /dev/null @@ -1,15 +0,0 @@ - - - Exe - - - PdbOnly - True - - - - - - - - diff --git a/src/coreclr/tests/src/JIT/jit64/localloc/call/call06_dynamic.il b/src/coreclr/tests/src/JIT/jit64/localloc/call/call06_dynamic.il deleted file mode 100644 index be5a6f75f7a..00000000000 --- a/src/coreclr/tests/src/JIT/jit64/localloc/call/call06_dynamic.il +++ /dev/null @@ -1,287 +0,0 @@ -// Test localloc with tail call followed by jump - -.assembly extern System.Console -{ - .publickeytoken = (B0 3F 5F 7F 11 D5 0A 3A ) - .ver 4:0:0:0 -} -.assembly extern mscorlib{} -.assembly extern common{} -.assembly call06{} - -.class private auto ansi beforefieldinit LocallocTest - extends [mscorlib]System.Object -{ - .field private static int32 locallocSize - .method public hidebysig static int32 Main() cil managed - { - .entrypoint - .maxstack 11 - .locals (int32* intArray1, - int32* intArray2, - class LocallocTest V_2) - IL_0000: ldc.i4.4 - IL_0001: ldsfld int32 [common]LocallocTesting.Global::stackAllocSize - IL_0002: mul - IL_0003: localloc - IL_0005: stloc.0 - IL_0006: ldc.i4.4 - IL_0007: ldsfld int32 [common]LocallocTesting.Global::stackAllocSize - IL_0008: mul - IL_0009: localloc - IL_000b: stloc.1 - IL_000c: ldsfld int32 [common]LocallocTesting.Global::stackAllocSize - IL_000d: stsfld int32 LocallocTest::locallocSize - IL_0012: ldloc.0 - IL_0013: ldsfld int32 LocallocTest::locallocSize - IL_0018: ldc.i4 1000 - IL_001d: call void [common]LocallocTesting.Global::initializeStack(int32*, - int32, - int32) - IL_0022: ldloc.1 - IL_0023: ldsfld int32 LocallocTest::locallocSize - IL_0028: ldc.i4 2000 - IL_002d: call void [common]LocallocTesting.Global::initializeStack(int32*, - int32, - int32) - IL_0032: newobj instance void LocallocTest::.ctor() - IL_0037: stloc.2 - IL_0038: ldloc.2 - IL_0039: ldc.i4.1 - IL_003a: ldc.i4.2 - IL_003b: ldc.i4.3 - IL_003c: ldc.i4.4 - IL_003d: ldc.i4.5 - IL_003e: ldc.i4.6 - IL_003f: ldc.i4.7 - IL_0040: ldc.i4.8 - IL_0041: ldloc.0 - IL_0042: ldloc.1 - IL_0043: tail. callvirt instance int32 LocallocTest::func0(int32, - int32, - int32, - int32, - int32, - int32, - int32, - int32, - int32*, - int32*) - IL_004c: ret - } - - .method private hidebysig instance int32 - func0(int32 i1, - int32 i2, - int32 i3, - int32 i4, - int32 i5, - int32 i6, - int32 i7, - int32 i8, - int32* ar1, - int32* ar2) cil managed - { - .maxstack 11 - .locals (int32 retValue) - IL_0000: ldstr "ar1" - IL_0005: ldarg.s ar1 - IL_0007: ldsfld int32 LocallocTest::locallocSize - IL_000c: ldc.i4 1000 - IL_0011: call bool [common]LocallocTesting.Global::verifyStack(string, - int32*, - int32, - int32) - IL_0016: brtrue.s IL_001c - - IL_0018: ldc.i4.1 - IL_0019: stloc.0 - IL_001a: br.s L_END - - IL_001c: ldstr "ar2" - IL_0021: ldarg.s ar2 - IL_0023: ldsfld int32 LocallocTest::locallocSize - IL_0028: ldc.i4 2000 - IL_002d: call bool [common]LocallocTesting.Global::verifyStack(string, - int32*, - int32, - int32) - IL_0032: brtrue.s L_JMP - - IL_0034: ldc.i4.1 - IL_0035: stloc.0 - IL_0036: br.s L_END - - L_JMP: jmp instance int32 LocallocTest::func1(int32, - int32, - int32, - int32, - int32, - int32, - int32, - int32, - int32*, - int32*) - IL_004a: stloc.0 - - L_END: ldc.i4.1 - IL_004e: ret - } - - .method private hidebysig instance int32 - func1(int32 i1, - int32 i2, - int32 i3, - int32 i4, - int32 i5, - int32 i6, - int32 i7, - int32 i8, - int32* ar1, - int32* ar2) cil managed - { - .maxstack 4 - .locals (unsigned int64 local1, - unsigned int64 local2, - int32* intArray1, - int32* intArray2, - int32 retValue) - IL_0000: ldc.i8 0xfedcba9876543210 - IL_0009: stloc.0 - IL_000a: ldloc.0 - IL_000b: ldc.i4.1 - IL_000c: conv.i8 - IL_000d: add - IL_000e: stloc.1 - IL_000f: ldc.i4.4 - IL_0010: ldsfld int32 [common]LocallocTesting.Global::stackAllocSize - IL_0011: mul - IL_0012: localloc - IL_0014: stloc.2 - IL_0015: ldc.i4.4 - IL_0016: ldsfld int32 [common]LocallocTesting.Global::stackAllocSize - IL_0017: mul - IL_0018: localloc - IL_001a: stloc.3 - IL_001b: ldloc.2 - IL_001c: ldsfld int32 LocallocTest::locallocSize - IL_0021: ldc.i4 3000 - IL_0026: call void [common]LocallocTesting.Global::initializeStack(int32*, - int32, - int32) - IL_002b: ldloc.3 - IL_002c: ldsfld int32 LocallocTest::locallocSize - IL_0031: ldc.i4 4000 - IL_0036: call void [common]LocallocTesting.Global::initializeStack(int32*, - int32, - int32) - IL_003b: ldstr "local1" - IL_0040: ldloc.0 - IL_0041: ldc.i8 0xfedcba9876543210 - IL_004a: call bool [common]LocallocTesting.Global::verifyLocal(string, - unsigned int64, - unsigned int64) - IL_004f: brtrue.s IL_0059 - - IL_0051: ldc.i4.1 - IL_0052: stloc.s retValue - IL_0054: br L_END - - IL_0059: ldstr "local2" - IL_005e: ldloc.1 - IL_005f: ldc.i8 0xfedcba9876543211 - IL_0068: call bool [common]LocallocTesting.Global::verifyLocal(string, - unsigned int64, - unsigned int64) - IL_006d: brtrue.s IL_0077 - IL_006f: ldc.i4.1 - IL_0070: stloc.s retValue - IL_0072: br L_END - - IL_0077: ldstr "ar1" - IL_007c: ldarg.s ar1 - IL_007e: ldsfld int32 LocallocTest::locallocSize - IL_0083: ldc.i4 1000 - IL_0088: call bool [common]LocallocTesting.Global::verifyStack(string, - int32*, - int32, - int32) - IL_008d: brtrue.s IL_0094 - - IL_008f: ldc.i4.1 - IL_0090: stloc.s retValue - IL_0092: br.s L_END - - IL_0094: ldstr "ar2" - IL_0099: ldarg.s ar2 - IL_009b: ldsfld int32 LocallocTest::locallocSize - IL_00a0: ldc.i4 2000 - IL_00a5: call bool [common]LocallocTesting.Global::verifyStack(string, - int32*, - int32, - int32) - IL_00aa: brtrue.s IL_00b1 - - IL_00ac: ldc.i4.1 - IL_00ad: stloc.s retValue - IL_00af: br.s L_END - - IL_00b1: ldstr "intArray1" - IL_00b6: ldloc.2 - IL_00b7: ldsfld int32 LocallocTest::locallocSize - IL_00bc: ldc.i4 3000 - IL_00c1: call bool [common]LocallocTesting.Global::verifyStack(string, - int32*, - int32, - int32) - IL_00c6: brtrue.s IL_00cd - - IL_00c8: ldc.i4.1 - IL_00c9: stloc.s retValue - IL_00cb: br.s L_END - - IL_00cd: ldstr "intArray2" - IL_00d2: ldloc.3 - IL_00d3: ldsfld int32 LocallocTest::locallocSize - IL_00d8: ldc.i4 4000 - IL_00dd: call bool [common]LocallocTesting.Global::verifyStack(string, - int32*, - int32, - int32) - IL_00e2: brtrue.s L_Passed - - IL_00e4: ldc.i4.1 - IL_00e5: stloc.s retValue - IL_00e7: br.s L_END - - L_Passed: ldstr "Passed\n" - IL_00ee: call void [System.Console]System.Console::WriteLine(string) - IL_00f3: ldc.i4.s 100 - IL_00f5: stloc.s retValue - - L_END: ldloc.s retValue - IL_00fb: ret - } - - .method private hidebysig specialname rtspecialname static - void .cctor() cil managed - { - .maxstack 8 - IL_0000: ldc.i4.0 - IL_0001: stsfld int32 LocallocTest::locallocSize - IL_0006: ret - } - - .method public hidebysig specialname rtspecialname - instance void .ctor() cil managed - { - .maxstack 8 - IL_0000: ldarg.0 - IL_0001: call instance void [mscorlib]System.Object::.ctor() - IL_0006: ret - } - -} - - - diff --git a/src/coreclr/tests/src/JIT/jit64/localloc/call/call06_dynamic.ilproj b/src/coreclr/tests/src/JIT/jit64/localloc/call/call06_dynamic.ilproj deleted file mode 100644 index 1f753c348e7..00000000000 --- a/src/coreclr/tests/src/JIT/jit64/localloc/call/call06_dynamic.ilproj +++ /dev/null @@ -1,16 +0,0 @@ - - - Exe - 1 - - - PdbOnly - True - - - - - - - - diff --git a/src/coreclr/tests/src/JIT/jit64/localloc/call/call06_large.il b/src/coreclr/tests/src/JIT/jit64/localloc/call/call06_large.il deleted file mode 100644 index c454286f219..00000000000 --- a/src/coreclr/tests/src/JIT/jit64/localloc/call/call06_large.il +++ /dev/null @@ -1,287 +0,0 @@ -// Test localloc with tail call followed by jump - -.assembly extern System.Console -{ - .publickeytoken = (B0 3F 5F 7F 11 D5 0A 3A ) - .ver 4:0:0:0 -} -.assembly extern mscorlib{} -.assembly extern common{} -.assembly call06{} - -.class private auto ansi beforefieldinit LocallocTest - extends [mscorlib]System.Object -{ - .field private static int32 locallocSize - .method public hidebysig static int32 Main() cil managed - { - .entrypoint - .maxstack 11 - .locals (int32* intArray1, - int32* intArray2, - class LocallocTest V_2) - IL_0000: ldc.i4.4 - IL_0001: ldc.i4 0x1000 - IL_0002: mul - IL_0003: localloc - IL_0005: stloc.0 - IL_0006: ldc.i4.4 - IL_0007: ldc.i4 0x1000 - IL_0008: mul - IL_0009: localloc - IL_000b: stloc.1 - IL_000c: ldc.i4 0x1000 - IL_000d: stsfld int32 LocallocTest::locallocSize - IL_0012: ldloc.0 - IL_0013: ldsfld int32 LocallocTest::locallocSize - IL_0018: ldc.i4 1000 - IL_001d: call void [common]LocallocTesting.Global::initializeStack(int32*, - int32, - int32) - IL_0022: ldloc.1 - IL_0023: ldsfld int32 LocallocTest::locallocSize - IL_0028: ldc.i4 2000 - IL_002d: call void [common]LocallocTesting.Global::initializeStack(int32*, - int32, - int32) - IL_0032: newobj instance void LocallocTest::.ctor() - IL_0037: stloc.2 - IL_0038: ldloc.2 - IL_0039: ldc.i4.1 - IL_003a: ldc.i4.2 - IL_003b: ldc.i4.3 - IL_003c: ldc.i4.4 - IL_003d: ldc.i4.5 - IL_003e: ldc.i4.6 - IL_003f: ldc.i4.7 - IL_0040: ldc.i4.8 - IL_0041: ldloc.0 - IL_0042: ldloc.1 - IL_0043: tail. callvirt instance int32 LocallocTest::func0(int32, - int32, - int32, - int32, - int32, - int32, - int32, - int32, - int32*, - int32*) - IL_004c: ret - } - - .method private hidebysig instance int32 - func0(int32 i1, - int32 i2, - int32 i3, - int32 i4, - int32 i5, - int32 i6, - int32 i7, - int32 i8, - int32* ar1, - int32* ar2) cil managed - { - .maxstack 11 - .locals (int32 retValue) - IL_0000: ldstr "ar1" - IL_0005: ldarg.s ar1 - IL_0007: ldsfld int32 LocallocTest::locallocSize - IL_000c: ldc.i4 1000 - IL_0011: call bool [common]LocallocTesting.Global::verifyStack(string, - int32*, - int32, - int32) - IL_0016: brtrue.s IL_001c - - IL_0018: ldc.i4.1 - IL_0019: stloc.0 - IL_001a: br.s L_END - - IL_001c: ldstr "ar2" - IL_0021: ldarg.s ar2 - IL_0023: ldsfld int32 LocallocTest::locallocSize - IL_0028: ldc.i4 2000 - IL_002d: call bool [common]LocallocTesting.Global::verifyStack(string, - int32*, - int32, - int32) - IL_0032: brtrue.s L_JMP - - IL_0034: ldc.i4.1 - IL_0035: stloc.0 - IL_0036: br.s L_END - - L_JMP: jmp instance int32 LocallocTest::func1(int32, - int32, - int32, - int32, - int32, - int32, - int32, - int32, - int32*, - int32*) - IL_004a: stloc.0 - - L_END: ldc.i4.1 - IL_004e: ret - } - - .method private hidebysig instance int32 - func1(int32 i1, - int32 i2, - int32 i3, - int32 i4, - int32 i5, - int32 i6, - int32 i7, - int32 i8, - int32* ar1, - int32* ar2) cil managed - { - .maxstack 4 - .locals (unsigned int64 local1, - unsigned int64 local2, - int32* intArray1, - int32* intArray2, - int32 retValue) - IL_0000: ldc.i8 0xfedcba9876543210 - IL_0009: stloc.0 - IL_000a: ldloc.0 - IL_000b: ldc.i4.1 - IL_000c: conv.i8 - IL_000d: add - IL_000e: stloc.1 - IL_000f: ldc.i4.4 - IL_0010: ldc.i4 0x1000 - IL_0011: mul - IL_0012: localloc - IL_0014: stloc.2 - IL_0015: ldc.i4.4 - IL_0016: ldc.i4 0x1000 - IL_0017: mul - IL_0018: localloc - IL_001a: stloc.3 - IL_001b: ldloc.2 - IL_001c: ldsfld int32 LocallocTest::locallocSize - IL_0021: ldc.i4 3000 - IL_0026: call void [common]LocallocTesting.Global::initializeStack(int32*, - int32, - int32) - IL_002b: ldloc.3 - IL_002c: ldsfld int32 LocallocTest::locallocSize - IL_0031: ldc.i4 4000 - IL_0036: call void [common]LocallocTesting.Global::initializeStack(int32*, - int32, - int32) - IL_003b: ldstr "local1" - IL_0040: ldloc.0 - IL_0041: ldc.i8 0xfedcba9876543210 - IL_004a: call bool [common]LocallocTesting.Global::verifyLocal(string, - unsigned int64, - unsigned int64) - IL_004f: brtrue.s IL_0059 - - IL_0051: ldc.i4.1 - IL_0052: stloc.s retValue - IL_0054: br L_END - - IL_0059: ldstr "local2" - IL_005e: ldloc.1 - IL_005f: ldc.i8 0xfedcba9876543211 - IL_0068: call bool [common]LocallocTesting.Global::verifyLocal(string, - unsigned int64, - unsigned int64) - IL_006d: brtrue.s IL_0077 - IL_006f: ldc.i4.1 - IL_0070: stloc.s retValue - IL_0072: br L_END - - IL_0077: ldstr "ar1" - IL_007c: ldarg.s ar1 - IL_007e: ldsfld int32 LocallocTest::locallocSize - IL_0083: ldc.i4 1000 - IL_0088: call bool [common]LocallocTesting.Global::verifyStack(string, - int32*, - int32, - int32) - IL_008d: brtrue.s IL_0094 - - IL_008f: ldc.i4.1 - IL_0090: stloc.s retValue - IL_0092: br.s L_END - - IL_0094: ldstr "ar2" - IL_0099: ldarg.s ar2 - IL_009b: ldsfld int32 LocallocTest::locallocSize - IL_00a0: ldc.i4 2000 - IL_00a5: call bool [common]LocallocTesting.Global::verifyStack(string, - int32*, - int32, - int32) - IL_00aa: brtrue.s IL_00b1 - - IL_00ac: ldc.i4.1 - IL_00ad: stloc.s retValue - IL_00af: br.s L_END - - IL_00b1: ldstr "intArray1" - IL_00b6: ldloc.2 - IL_00b7: ldsfld int32 LocallocTest::locallocSize - IL_00bc: ldc.i4 3000 - IL_00c1: call bool [common]LocallocTesting.Global::verifyStack(string, - int32*, - int32, - int32) - IL_00c6: brtrue.s IL_00cd - - IL_00c8: ldc.i4.1 - IL_00c9: stloc.s retValue - IL_00cb: br.s L_END - - IL_00cd: ldstr "intArray2" - IL_00d2: ldloc.3 - IL_00d3: ldsfld int32 LocallocTest::locallocSize - IL_00d8: ldc.i4 4000 - IL_00dd: call bool [common]LocallocTesting.Global::verifyStack(string, - int32*, - int32, - int32) - IL_00e2: brtrue.s L_Passed - - IL_00e4: ldc.i4.1 - IL_00e5: stloc.s retValue - IL_00e7: br.s L_END - - L_Passed: ldstr "Passed\n" - IL_00ee: call void [System.Console]System.Console::WriteLine(string) - IL_00f3: ldc.i4.s 100 - IL_00f5: stloc.s retValue - - L_END: ldloc.s retValue - IL_00fb: ret - } - - .method private hidebysig specialname rtspecialname static - void .cctor() cil managed - { - .maxstack 8 - IL_0000: ldc.i4.0 - IL_0001: stsfld int32 LocallocTest::locallocSize - IL_0006: ret - } - - .method public hidebysig specialname rtspecialname - instance void .ctor() cil managed - { - .maxstack 8 - IL_0000: ldarg.0 - IL_0001: call instance void [mscorlib]System.Object::.ctor() - IL_0006: ret - } - -} - - - diff --git a/src/coreclr/tests/src/JIT/jit64/localloc/call/call06_large.ilproj b/src/coreclr/tests/src/JIT/jit64/localloc/call/call06_large.ilproj deleted file mode 100644 index 665240fc4a1..00000000000 --- a/src/coreclr/tests/src/JIT/jit64/localloc/call/call06_large.ilproj +++ /dev/null @@ -1,16 +0,0 @@ - - - Exe - 1 - - - PdbOnly - True - - - - - - - - diff --git a/src/coreclr/tests/src/JIT/jit64/localloc/call/call06_small.il b/src/coreclr/tests/src/JIT/jit64/localloc/call/call06_small.il deleted file mode 100644 index 3acf909b7b8..00000000000 --- a/src/coreclr/tests/src/JIT/jit64/localloc/call/call06_small.il +++ /dev/null @@ -1,287 +0,0 @@ -// Test localloc with tail call followed by jump - -.assembly extern System.Console -{ - .publickeytoken = (B0 3F 5F 7F 11 D5 0A 3A ) - .ver 4:0:0:0 -} -.assembly extern mscorlib{} -.assembly extern common{} -.assembly call06{} - -.class private auto ansi beforefieldinit LocallocTest - extends [mscorlib]System.Object -{ - .field private static int32 locallocSize - .method public hidebysig static int32 Main() cil managed - { - .entrypoint - .maxstack 11 - .locals (int32* intArray1, - int32* intArray2, - class LocallocTest V_2) - IL_0000: ldc.i4.4 - IL_0001: ldc.i4.1 - IL_0002: mul - IL_0003: localloc - IL_0005: stloc.0 - IL_0006: ldc.i4.4 - IL_0007: ldc.i4.1 - IL_0008: mul - IL_0009: localloc - IL_000b: stloc.1 - IL_000c: ldc.i4.1 - IL_000d: stsfld int32 LocallocTest::locallocSize - IL_0012: ldloc.0 - IL_0013: ldsfld int32 LocallocTest::locallocSize - IL_0018: ldc.i4 1000 - IL_001d: call void [common]LocallocTesting.Global::initializeStack(int32*, - int32, - int32) - IL_0022: ldloc.1 - IL_0023: ldsfld int32 LocallocTest::locallocSize - IL_0028: ldc.i4 2000 - IL_002d: call void [common]LocallocTesting.Global::initializeStack(int32*, - int32, - int32) - IL_0032: newobj instance void LocallocTest::.ctor() - IL_0037: stloc.2 - IL_0038: ldloc.2 - IL_0039: ldc.i4.1 - IL_003a: ldc.i4.2 - IL_003b: ldc.i4.3 - IL_003c: ldc.i4.4 - IL_003d: ldc.i4.5 - IL_003e: ldc.i4.6 - IL_003f: ldc.i4.7 - IL_0040: ldc.i4.8 - IL_0041: ldloc.0 - IL_0042: ldloc.1 - IL_0043: tail. callvirt instance int32 LocallocTest::func0(int32, - int32, - int32, - int32, - int32, - int32, - int32, - int32, - int32*, - int32*) - IL_004c: ret - } - - .method private hidebysig instance int32 - func0(int32 i1, - int32 i2, - int32 i3, - int32 i4, - int32 i5, - int32 i6, - int32 i7, - int32 i8, - int32* ar1, - int32* ar2) cil managed - { - .maxstack 11 - .locals (int32 retValue) - IL_0000: ldstr "ar1" - IL_0005: ldarg.s ar1 - IL_0007: ldsfld int32 LocallocTest::locallocSize - IL_000c: ldc.i4 1000 - IL_0011: call bool [common]LocallocTesting.Global::verifyStack(string, - int32*, - int32, - int32) - IL_0016: brtrue.s IL_001c - - IL_0018: ldc.i4.1 - IL_0019: stloc.0 - IL_001a: br.s L_END - - IL_001c: ldstr "ar2" - IL_0021: ldarg.s ar2 - IL_0023: ldsfld int32 LocallocTest::locallocSize - IL_0028: ldc.i4 2000 - IL_002d: call bool [common]LocallocTesting.Global::verifyStack(string, - int32*, - int32, - int32) - IL_0032: brtrue.s L_JMP - - IL_0034: ldc.i4.1 - IL_0035: stloc.0 - IL_0036: br.s L_END - - L_JMP: jmp instance int32 LocallocTest::func1(int32, - int32, - int32, - int32, - int32, - int32, - int32, - int32, - int32*, - int32*) - IL_004a: stloc.0 - - L_END: ldc.i4.1 - IL_004e: ret - } - - .method private hidebysig instance int32 - func1(int32 i1, - int32 i2, - int32 i3, - int32 i4, - int32 i5, - int32 i6, - int32 i7, - int32 i8, - int32* ar1, - int32* ar2) cil managed - { - .maxstack 4 - .locals (unsigned int64 local1, - unsigned int64 local2, - int32* intArray1, - int32* intArray2, - int32 retValue) - IL_0000: ldc.i8 0xfedcba9876543210 - IL_0009: stloc.0 - IL_000a: ldloc.0 - IL_000b: ldc.i4.1 - IL_000c: conv.i8 - IL_000d: add - IL_000e: stloc.1 - IL_000f: ldc.i4.4 - IL_0010: ldc.i4.1 - IL_0011: mul - IL_0012: localloc - IL_0014: stloc.2 - IL_0015: ldc.i4.4 - IL_0016: ldc.i4.1 - IL_0017: mul - IL_0018: localloc - IL_001a: stloc.3 - IL_001b: ldloc.2 - IL_001c: ldsfld int32 LocallocTest::locallocSize - IL_0021: ldc.i4 3000 - IL_0026: call void [common]LocallocTesting.Global::initializeStack(int32*, - int32, - int32) - IL_002b: ldloc.3 - IL_002c: ldsfld int32 LocallocTest::locallocSize - IL_0031: ldc.i4 4000 - IL_0036: call void [common]LocallocTesting.Global::initializeStack(int32*, - int32, - int32) - IL_003b: ldstr "local1" - IL_0040: ldloc.0 - IL_0041: ldc.i8 0xfedcba9876543210 - IL_004a: call bool [common]LocallocTesting.Global::verifyLocal(string, - unsigned int64, - unsigned int64) - IL_004f: brtrue.s IL_0059 - - IL_0051: ldc.i4.1 - IL_0052: stloc.s retValue - IL_0054: br L_END - - IL_0059: ldstr "local2" - IL_005e: ldloc.1 - IL_005f: ldc.i8 0xfedcba9876543211 - IL_0068: call bool [common]LocallocTesting.Global::verifyLocal(string, - unsigned int64, - unsigned int64) - IL_006d: brtrue.s IL_0077 - IL_006f: ldc.i4.1 - IL_0070: stloc.s retValue - IL_0072: br L_END - - IL_0077: ldstr "ar1" - IL_007c: ldarg.s ar1 - IL_007e: ldsfld int32 LocallocTest::locallocSize - IL_0083: ldc.i4 1000 - IL_0088: call bool [common]LocallocTesting.Global::verifyStack(string, - int32*, - int32, - int32) - IL_008d: brtrue.s IL_0094 - - IL_008f: ldc.i4.1 - IL_0090: stloc.s retValue - IL_0092: br.s L_END - - IL_0094: ldstr "ar2" - IL_0099: ldarg.s ar2 - IL_009b: ldsfld int32 LocallocTest::locallocSize - IL_00a0: ldc.i4 2000 - IL_00a5: call bool [common]LocallocTesting.Global::verifyStack(string, - int32*, - int32, - int32) - IL_00aa: brtrue.s IL_00b1 - - IL_00ac: ldc.i4.1 - IL_00ad: stloc.s retValue - IL_00af: br.s L_END - - IL_00b1: ldstr "intArray1" - IL_00b6: ldloc.2 - IL_00b7: ldsfld int32 LocallocTest::locallocSize - IL_00bc: ldc.i4 3000 - IL_00c1: call bool [common]LocallocTesting.Global::verifyStack(string, - int32*, - int32, - int32) - IL_00c6: brtrue.s IL_00cd - - IL_00c8: ldc.i4.1 - IL_00c9: stloc.s retValue - IL_00cb: br.s L_END - - IL_00cd: ldstr "intArray2" - IL_00d2: ldloc.3 - IL_00d3: ldsfld int32 LocallocTest::locallocSize - IL_00d8: ldc.i4 4000 - IL_00dd: call bool [common]LocallocTesting.Global::verifyStack(string, - int32*, - int32, - int32) - IL_00e2: brtrue.s L_Passed - - IL_00e4: ldc.i4.1 - IL_00e5: stloc.s retValue - IL_00e7: br.s L_END - - L_Passed: ldstr "Passed\n" - IL_00ee: call void [System.Console]System.Console::WriteLine(string) - IL_00f3: ldc.i4.s 100 - IL_00f5: stloc.s retValue - - L_END: ldloc.s retValue - IL_00fb: ret - } - - .method private hidebysig specialname rtspecialname static - void .cctor() cil managed - { - .maxstack 8 - IL_0000: ldc.i4.0 - IL_0001: stsfld int32 LocallocTest::locallocSize - IL_0006: ret - } - - .method public hidebysig specialname rtspecialname - instance void .ctor() cil managed - { - .maxstack 8 - IL_0000: ldarg.0 - IL_0001: call instance void [mscorlib]System.Object::.ctor() - IL_0006: ret - } - -} - - - diff --git a/src/coreclr/tests/src/JIT/jit64/localloc/call/call06_small.ilproj b/src/coreclr/tests/src/JIT/jit64/localloc/call/call06_small.ilproj deleted file mode 100644 index 41c64100e45..00000000000 --- a/src/coreclr/tests/src/JIT/jit64/localloc/call/call06_small.ilproj +++ /dev/null @@ -1,16 +0,0 @@ - - - Exe - 1 - - - PdbOnly - True - - - - - - - - diff --git a/src/coreclr/tests/src/JIT/opt/Tailcall/TailcallVerifyWithPrefix.il b/src/coreclr/tests/src/JIT/opt/Tailcall/TailcallVerifyWithPrefix.il index 565451803b9..07b7670b15a 100644 --- a/src/coreclr/tests/src/JIT/opt/Tailcall/TailcallVerifyWithPrefix.il +++ b/src/coreclr/tests/src/JIT/opt/Tailcall/TailcallVerifyWithPrefix.il @@ -6,6 +6,7 @@ // Metadata version: v2.0.50727 .module extern kernel32 +.module extern libc .assembly extern mscorlib { } .assembly extern System.Console @@ -13,6 +14,16 @@ .publickeytoken = (B0 3F 5F 7F 11 D5 0A 3A ) .ver 4:0:0:0 } +.assembly extern System.Runtime +{ + .publickeytoken = (B0 3F 5F 7F 11 D5 0A 3A ) + .ver 4:2:1:0 +} +.assembly extern System.Runtime.Extensions +{ + .publickeytoken = (B0 3F 5F 7F 11 D5 0A 3A ) + .ver 4:2:1:0 +} .assembly extern System.Threading.Thread { .publickeytoken = (B0 3F 5F 7F 11 D5 0A 3A ) @@ -174,118 +185,6 @@ IL_001a: ret } // end of method Condition18::Callee1 - .method public hidebysig static int32 Test2() cil managed nooptimization - { - // Code size 154 (0x9a) - .maxstack 3 - .locals init ([0] class [mscorlib]System.Exception e) - IL_0000: ldstr "Executing Condition18.Test2 - Caller(imperative se" - + "curity): Arguments: None - ReturnType: 3 byte struct; Callee: Arguments" - + ": None - ReturnType: 3 byte struct" - IL_0005: call void [System.Console]System.Console::WriteLine(string) - IL_000a: ldc.i4.s 100 - IL_000c: stsfld int32 TailcallVerify.Condition18::Result - .try - { - IL_0011: call valuetype TailcallVerify.ValueType3Bytes TailcallVerify.Condition18::Caller2() - IL_0016: pop - IL_0017: leave.s IL_0070 - - } // end .try - catch [mscorlib]System.Exception - { - IL_0019: stloc.0 - IL_001a: ldloc.0 - IL_001b: isinst [mscorlib]System.DivideByZeroException - IL_0020: brtrue.s IL_002b - - IL_0022: ldc.i4.s 101 - IL_0024: stsfld int32 TailcallVerify.Condition18::Result - IL_0029: rethrow - IL_002b: ldloc.0 - IL_002c: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_0031: ldstr "Caller" - IL_0036: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_003b: ldc.i4.m1 - IL_003c: bne.un.s IL_006e - - IL_003e: ldstr "FAILED: Found the word 'Caller' in the stacktrace." - IL_0043: call void [System.Console]System.Console::WriteLine(string) - IL_0048: ldstr "------------------------------------------------" - IL_004d: call void [System.Console]System.Console::WriteLine(string) - IL_0052: call void [System.Console]System.Console::WriteLine() - IL_0057: ldloc.0 - IL_0058: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_005d: call void [System.Console]System.Console::WriteLine(string) - IL_0062: call void [System.Console]System.Console::WriteLine() - IL_0067: ldc.i4.s 101 - IL_0069: stsfld int32 TailcallVerify.Condition18::Result - IL_006e: leave.s IL_0070 - - } // end handler - IL_0070: ldstr "Execution finished - Test " - IL_0075: ldsfld int32 TailcallVerify.Condition18::Result - IL_007a: ldc.i4.s 100 - IL_007c: beq.s IL_0085 - - IL_007e: ldstr "FAILED" - IL_0083: br.s IL_008a - - IL_0085: ldstr "PASSED" - IL_008a: call string [mscorlib]System.String::Concat(string, - string) - IL_008f: call void [System.Console]System.Console::WriteLine(string) - IL_0094: ldsfld int32 TailcallVerify.Condition18::Result - IL_0099: ret - } // end of method Condition18::Test2 - - .method private hidebysig static valuetype TailcallVerify.ValueType3Bytes - Caller2() cil managed - { - // Code size 65 (0x41) - .maxstack 2 - .locals init ([0] class [mscorlib]System.Security.Permissions.FileIOPermission io) - IL_0000: ldc.i4.1 - IL_0001: newobj instance void [mscorlib]System.Security.Permissions.FileIOPermission::.ctor(valuetype [mscorlib]System.Security.Permissions.PermissionState) - IL_0006: stloc.0 - IL_0007: ldloc.0 - IL_0008: callvirt instance void [mscorlib]System.Security.CodeAccessPermission::Demand() - IL_000d: ldc.i4.0 - IL_000e: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) - IL_0013: callvirt instance class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Diagnostics.StackFrame::GetMethod() - IL_0018: callvirt instance string [mscorlib]System.Reflection.MemberInfo::get_Name() - IL_001d: ldstr "Caller" - IL_0022: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_0027: ldc.i4.m1 - IL_0028: bne.un.s IL_003b - - IL_002a: ldstr "Failed, Method was inlined..." - IL_002f: call void [System.Console]System.Console::WriteLine(string) - IL_0034: ldc.i4.s 101 - IL_0036: stsfld int32 TailcallVerify.Condition18::Result - IL_003b: tail. call valuetype TailcallVerify.ValueType3Bytes TailcallVerify.Condition18::Callee2() - IL_0040: ret - } // end of method Condition18::Caller2 - - .method private hidebysig static valuetype TailcallVerify.ValueType3Bytes - Callee2() cil managed noinlining - { - // Code size 27 (0x1b) - .maxstack 3 - .locals init ([0] valuetype TailcallVerify.ValueType3Bytes v) - IL_0000: ldloca.s v - IL_0002: initobj TailcallVerify.ValueType3Bytes - IL_0008: ldloca.s v - IL_000a: ldc.i4.1 - IL_000b: volatile. - IL_000d: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition18::zero - IL_0012: div - IL_0013: conv.i2 - IL_0014: stfld int16 TailcallVerify.ValueType3Bytes::i2 - IL_0019: ldloc.0 - IL_001a: ret - } // end of method Condition18::Callee2 - .method public hidebysig static int32 Test3() cil managed nooptimization { // Code size 154 (0x9a) @@ -1414,30 +1313,6 @@ IL_009f: ret } // end of method Condition11::Test2 - .method private hidebysig instance void - Caller2() cil managed - { - // Code size 54 (0x36) - .maxstack 8 - IL_0000: ldc.i4.0 - IL_0001: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) - IL_0006: callvirt instance class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Diagnostics.StackFrame::GetMethod() - IL_000b: callvirt instance string [mscorlib]System.Reflection.MemberInfo::get_Name() - IL_0010: ldstr "Caller" - IL_0015: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_001a: ldc.i4.m1 - IL_001b: bne.un.s IL_002e - - IL_001d: ldstr "Failed, Method was inlined..." - IL_0022: call void [System.Console]System.Console::WriteLine(string) - IL_0027: ldc.i4.s 101 - IL_0029: stsfld int32 TailcallVerify.Condition11::Result - IL_002e: ldarg.0 - IL_002f: tail. callvirt instance int32 TailcallVerify.Condition11::Callee2() - IL_0034: pop - IL_0035: ret - } // end of method Condition11::Caller2 - .method family hidebysig newslot virtual instance int32 Callee2() cil managed noinlining { @@ -1617,12 +1492,6 @@ IL_00d3: ldloc.s '<>g__initLocal0' IL_00d5: ldstr "Condition7.Test4" IL_00da: callvirt instance void class [mscorlib]System.Collections.Generic.List`1::Add(!0) - IL_00df: ldloc.s '<>g__initLocal0' - IL_00e1: ldstr "Condition8.Test2" - IL_00e6: callvirt instance void class [mscorlib]System.Collections.Generic.List`1::Add(!0) - IL_00eb: ldloc.s '<>g__initLocal0' - IL_00ed: ldstr "Condition8.Test3" - IL_00f2: callvirt instance void class [mscorlib]System.Collections.Generic.List`1::Add(!0) IL_00f7: ldloc.s '<>g__initLocal0' IL_00f9: ldstr "Condition9.Test1" IL_00fe: callvirt instance void class [mscorlib]System.Collections.Generic.List`1::Add(!0) @@ -1632,21 +1501,9 @@ IL_010f: ldloc.s '<>g__initLocal0' IL_0111: ldstr "Condition13.Test1" IL_0116: callvirt instance void class [mscorlib]System.Collections.Generic.List`1::Add(!0) - IL_011b: ldloc.s '<>g__initLocal0' - IL_011d: ldstr "Condition21.Test1" - IL_0122: callvirt instance void class [mscorlib]System.Collections.Generic.List`1::Add(!0) - IL_0127: ldloc.s '<>g__initLocal0' - IL_0129: ldstr "Condition21.Test2" - IL_012e: callvirt instance void class [mscorlib]System.Collections.Generic.List`1::Add(!0) IL_0133: ldloc.s '<>g__initLocal0' IL_0135: ldstr "Condition21.Test3" IL_013a: callvirt instance void class [mscorlib]System.Collections.Generic.List`1::Add(!0) - IL_013f: ldloc.s '<>g__initLocal0' - IL_0141: ldstr "Condition21.Test4" - IL_0146: callvirt instance void class [mscorlib]System.Collections.Generic.List`1::Add(!0) - IL_014b: ldloc.s '<>g__initLocal0' - IL_014d: ldstr "Condition21.Test5" - IL_0152: callvirt instance void class [mscorlib]System.Collections.Generic.List`1::Add(!0) IL_0157: ldloc.s '<>g__initLocal0' IL_0159: ldstr "Condition21.Test6" IL_015e: callvirt instance void class [mscorlib]System.Collections.Generic.List`1::Add(!0) @@ -1946,96 +1803,12 @@ IL_0028: ldstr "/\?" IL_002d: call bool [mscorlib]System.String::op_Equality(string, string) - IL_0032: brfalse.s IL_003c + IL_0032: brfalse.s IL_00fc IL_0034: call void TailcallVerify.Program::Usage() IL_0039: ldc.i4.s 100 IL_003b: ret - IL_003c: ldloc.1 - IL_003d: ldstr "Condition1.Test1" - IL_0042: call bool [mscorlib]System.String::op_Equality(string, - string) - IL_0047: brtrue.s IL_0052 - - IL_0049: ldloc.1 - IL_004a: ldloc.0 - IL_004b: call bool [mscorlib]System.String::op_Equality(string, - string) - IL_0050: brfalse.s IL_005c - - IL_0052: call int32 TailcallVerify.Condition1::Test1() - IL_0057: call void TailcallVerify.Program::set_Result(int32) - IL_005c: ldloc.1 - IL_005d: ldstr "Condition1.Test2" - IL_0062: call bool [mscorlib]System.String::op_Equality(string, - string) - IL_0067: brtrue.s IL_0072 - - IL_0069: ldloc.1 - IL_006a: ldloc.0 - IL_006b: call bool [mscorlib]System.String::op_Equality(string, - string) - IL_0070: brfalse.s IL_007c - - IL_0072: call int32 TailcallVerify.Condition1::Test2() - IL_0077: call void TailcallVerify.Program::set_Result(int32) - IL_007c: ldloc.1 - IL_007d: ldstr "Condition1.Test3" - IL_0082: call bool [mscorlib]System.String::op_Equality(string, - string) - IL_0087: brtrue.s IL_0092 - - IL_0089: ldloc.1 - IL_008a: ldloc.0 - IL_008b: call bool [mscorlib]System.String::op_Equality(string, - string) - IL_0090: brfalse.s IL_009c - - IL_0092: call int32 TailcallVerify.Condition1::Test3() - IL_0097: call void TailcallVerify.Program::set_Result(int32) - IL_009c: ldloc.1 - IL_009d: ldstr "Condition1.Test4" - IL_00a2: call bool [mscorlib]System.String::op_Equality(string, - string) - IL_00a7: brtrue.s IL_00b2 - - IL_00a9: ldloc.1 - IL_00aa: ldloc.0 - IL_00ab: call bool [mscorlib]System.String::op_Equality(string, - string) - IL_00b0: brfalse.s IL_00bc - - IL_00b2: call int32 TailcallVerify.Condition1::Test4() - IL_00b7: call void TailcallVerify.Program::set_Result(int32) - IL_00bc: ldloc.1 - IL_00bd: ldstr "Condition2.Test1" - IL_00c2: call bool [mscorlib]System.String::op_Equality(string, - string) - IL_00c7: brtrue.s IL_00d2 - - IL_00c9: ldloc.1 - IL_00ca: ldloc.0 - IL_00cb: call bool [mscorlib]System.String::op_Equality(string, - string) - IL_00d0: brfalse.s IL_00dc - - IL_00d2: call int32 TailcallVerify.Condition2::Test1() - IL_00d7: call void TailcallVerify.Program::set_Result(int32) - IL_00dc: ldloc.1 - IL_00dd: ldstr "Condition2.Test2" - IL_00e2: call bool [mscorlib]System.String::op_Equality(string, - string) - IL_00e7: brtrue.s IL_00f2 - - IL_00e9: ldloc.1 - IL_00ea: ldloc.0 - IL_00eb: call bool [mscorlib]System.String::op_Equality(string, - string) - IL_00f0: brfalse.s IL_00fc - - IL_00f2: call int32 TailcallVerify.Condition2::Test2() - IL_00f7: call void TailcallVerify.Program::set_Result(int32) IL_00fc: ldloc.1 IL_00fd: ldstr "Condition3.Test1" IL_0102: call bool [mscorlib]System.String::op_Equality(string, @@ -2340,52 +2113,10 @@ IL_03aa: ldloc.0 IL_03ab: call bool [mscorlib]System.String::op_Equality(string, string) - IL_03b0: brfalse.s IL_03bc + IL_03b0: brfalse.s IL_041c IL_03b2: call int32 TailcallVerify.Condition7::Test4() IL_03b7: call void TailcallVerify.Program::set_Result(int32) - IL_03bc: ldloc.1 - IL_03bd: ldstr "Condition8.Test1" - IL_03c2: call bool [mscorlib]System.String::op_Equality(string, - string) - IL_03c7: brtrue.s IL_03d2 - - IL_03c9: ldloc.1 - IL_03ca: ldloc.0 - IL_03cb: call bool [mscorlib]System.String::op_Equality(string, - string) - IL_03d0: brfalse.s IL_03dc - - IL_03d2: call int32 TailcallVerify.Condition8::Test1() - IL_03d7: call void TailcallVerify.Program::set_Result(int32) - IL_03dc: ldloc.1 - IL_03dd: ldstr "Condition8.Test2" - IL_03e2: call bool [mscorlib]System.String::op_Equality(string, - string) - IL_03e7: brtrue.s IL_03f2 - - IL_03e9: ldloc.1 - IL_03ea: ldloc.0 - IL_03eb: call bool [mscorlib]System.String::op_Equality(string, - string) - IL_03f0: brfalse.s IL_03fc - - IL_03f2: call int32 TailcallVerify.Condition8::Test2() - IL_03f7: call void TailcallVerify.Program::set_Result(int32) - IL_03fc: ldloc.1 - IL_03fd: ldstr "Condition8.Test3" - IL_0402: call bool [mscorlib]System.String::op_Equality(string, - string) - IL_0407: brtrue.s IL_0412 - - IL_0409: ldloc.1 - IL_040a: ldloc.0 - IL_040b: call bool [mscorlib]System.String::op_Equality(string, - string) - IL_0410: brfalse.s IL_041c - - IL_0412: call int32 TailcallVerify.Condition8::Test3() - IL_0417: call void TailcallVerify.Program::set_Result(int32) IL_041c: ldloc.1 IL_041d: ldstr "Condition9.Test1" IL_0422: call bool [mscorlib]System.String::op_Equality(string, @@ -2550,24 +2281,10 @@ IL_058a: ldloc.0 IL_058b: call bool [mscorlib]System.String::op_Equality(string, string) - IL_0590: brfalse.s IL_059c + IL_0590: brfalse.s IL_05bc IL_0592: call int32 TailcallVerify.Condition18::Test1() IL_0597: call void TailcallVerify.Program::set_Result(int32) - IL_059c: ldloc.1 - IL_059d: ldstr "Condition18.Test2" - IL_05a2: call bool [mscorlib]System.String::op_Equality(string, - string) - IL_05a7: brtrue.s IL_05b2 - - IL_05a9: ldloc.1 - IL_05aa: ldloc.0 - IL_05ab: call bool [mscorlib]System.String::op_Equality(string, - string) - IL_05b0: brfalse.s IL_05bc - - IL_05b2: call int32 TailcallVerify.Condition18::Test2() - IL_05b7: call void TailcallVerify.Program::set_Result(int32) IL_05bc: ldloc.1 IL_05bd: ldstr "Condition19.Test1" IL_05c2: call bool [mscorlib]System.String::op_Equality(string, @@ -2606,38 +2323,10 @@ IL_060a: ldloc.0 IL_060b: call bool [mscorlib]System.String::op_Equality(string, string) - IL_0610: brfalse.s IL_061c + IL_0610: brfalse.s IL_065c IL_0612: call int32 TailcallVerify.Condition20::Test1() IL_0617: call void TailcallVerify.Program::set_Result(int32) - IL_061c: ldloc.1 - IL_061d: ldstr "Condition21.Test1" - IL_0622: call bool [mscorlib]System.String::op_Equality(string, - string) - IL_0627: brtrue.s IL_0632 - - IL_0629: ldloc.1 - IL_062a: ldloc.0 - IL_062b: call bool [mscorlib]System.String::op_Equality(string, - string) - IL_0630: brfalse.s IL_063c - - IL_0632: call int32 TailcallVerify.Condition21::Test1() - IL_0637: call void TailcallVerify.Program::set_Result(int32) - IL_063c: ldloc.1 - IL_063d: ldstr "Condition21.Test2" - IL_0642: call bool [mscorlib]System.String::op_Equality(string, - string) - IL_0647: brtrue.s IL_0652 - - IL_0649: ldloc.1 - IL_064a: ldloc.0 - IL_064b: call bool [mscorlib]System.String::op_Equality(string, - string) - IL_0650: brfalse.s IL_065c - - IL_0652: call int32 TailcallVerify.Condition21::Test2() - IL_0657: call void TailcallVerify.Program::set_Result(int32) IL_065c: ldloc.1 IL_065d: ldstr "Condition21.Test3" IL_0662: call bool [mscorlib]System.String::op_Equality(string, @@ -2648,38 +2337,10 @@ IL_066a: ldloc.0 IL_066b: call bool [mscorlib]System.String::op_Equality(string, string) - IL_0670: brfalse.s IL_067c + IL_0670: brfalse.s IL_06bc IL_0672: call int32 TailcallVerify.Condition21::Test3() IL_0677: call void TailcallVerify.Program::set_Result(int32) - IL_067c: ldloc.1 - IL_067d: ldstr "Condition21.Test4" - IL_0682: call bool [mscorlib]System.String::op_Equality(string, - string) - IL_0687: brtrue.s IL_0692 - - IL_0689: ldloc.1 - IL_068a: ldloc.0 - IL_068b: call bool [mscorlib]System.String::op_Equality(string, - string) - IL_0690: brfalse.s IL_069c - - IL_0692: call int32 TailcallVerify.Condition21::Test4() - IL_0697: call void TailcallVerify.Program::set_Result(int32) - IL_069c: ldloc.1 - IL_069d: ldstr "Condition21.Test5" - IL_06a2: call bool [mscorlib]System.String::op_Equality(string, - string) - IL_06a7: brtrue.s IL_06b2 - - IL_06a9: ldloc.1 - IL_06aa: ldloc.0 - IL_06ab: call bool [mscorlib]System.String::op_Equality(string, - string) - IL_06b0: brfalse.s IL_06bc - - IL_06b2: call int32 TailcallVerify.Condition21::Test5() - IL_06b7: call void TailcallVerify.Program::set_Result(int32) IL_06bc: ldloc.1 IL_06bd: ldstr "Condition21.Test6" IL_06c2: call bool [mscorlib]System.String::op_Equality(string, @@ -2704,52 +2365,10 @@ IL_06ea: ldloc.0 IL_06eb: call bool [mscorlib]System.String::op_Equality(string, string) - IL_06f0: brfalse.s IL_06fc + IL_06f0: brfalse.s IL_075c IL_06f2: call int32 TailcallVerify.Condition21::Test7() IL_06f7: call void TailcallVerify.Program::set_Result(int32) - IL_06fc: ldloc.1 - IL_06fd: ldstr "Condition22.Test1" - IL_0702: call bool [mscorlib]System.String::op_Equality(string, - string) - IL_0707: brtrue.s IL_0712 - - IL_0709: ldloc.1 - IL_070a: ldloc.0 - IL_070b: call bool [mscorlib]System.String::op_Equality(string, - string) - IL_0710: brfalse.s IL_071c - - IL_0712: call int32 TailcallVerify.Condition22::Test1() - IL_0717: call void TailcallVerify.Program::set_Result(int32) - IL_071c: ldloc.1 - IL_071d: ldstr "Condition22.Test2" - IL_0722: call bool [mscorlib]System.String::op_Equality(string, - string) - IL_0727: brtrue.s IL_0732 - - IL_0729: ldloc.1 - IL_072a: ldloc.0 - IL_072b: call bool [mscorlib]System.String::op_Equality(string, - string) - IL_0730: brfalse.s IL_073c - - IL_0732: call int32 TailcallVerify.Condition22::Test2() - IL_0737: call void TailcallVerify.Program::set_Result(int32) - IL_073c: ldloc.1 - IL_073d: ldstr "Condition22.Test3" - IL_0742: call bool [mscorlib]System.String::op_Equality(string, - string) - IL_0747: brtrue.s IL_0752 - - IL_0749: ldloc.1 - IL_074a: ldloc.0 - IL_074b: call bool [mscorlib]System.String::op_Equality(string, - string) - IL_0750: brfalse.s IL_075c - - IL_0752: call int32 TailcallVerify.Condition22::Test3() - IL_0757: call void TailcallVerify.Program::set_Result(int32) IL_075c: ldloc.1 IL_075d: ldstr "Condition22.Test4" IL_0762: call bool [mscorlib]System.String::op_Equality(string, @@ -2791,22 +2410,6 @@ .entrypoint .maxstack 1 - // Disable tests intending to test tail.call,pop,ret sequence. - //ldstr "Condition1.Test1" - //call int32 TailcallVerify.Program::Run(string) - //pop - //ldstr "Condition1.Test2" - //call int32 TailcallVerify.Program::Run(string) - //pop - //ldstr "Condition1.Test3" - //call int32 TailcallVerify.Program::Run(string) - //pop - //ldstr "Condition2.Test1" - //call int32 TailcallVerify.Program::Run(string) - //pop - //ldstr "Condition2.Test2" - //call int32 TailcallVerify.Program::Run(string) - //pop ldstr "Condition3.Test1" call int32 TailcallVerify.Program::Run(string) pop @@ -2873,20 +2476,6 @@ ldstr "Condition7.Test4" call int32 TailcallVerify.Program::Run(string) pop - - // Condition8 tests use varargs calling conventions. - // The lines below should be uncommented when/if CoreCLR starts - // supporting varargs. - //ldstr "Condition8.Test1" - //call int32 TailcallVerify.Program::Run(string) - //pop - //ldstr "Condition8.Test2" - //call int32 TailcallVerify.Program::Run(string) - //pop - //ldstr "Condition8.Test3" - //call int32 TailcallVerify.Program::Run(string) - //pop - ldstr "Condition9.Test1" call int32 TailcallVerify.Program::Run(string) pop @@ -2923,9 +2512,6 @@ ldstr "Condition17.Test1" call int32 TailcallVerify.Program::Run(string) pop - ldstr "Condition17.Test4" - call int32 TailcallVerify.Program::Run(string) - pop ldstr "Condition18.Test1" call int32 TailcallVerify.Program::Run(string) pop @@ -2941,13 +2527,6 @@ ldstr "Condition20.Test1" call int32 TailcallVerify.Program::Run(string) pop - // Disable tests intending to test tail.call,pop,ret sequence. - //ldstr "Condition21.Test1" - //call int32 TailcallVerify.Program::Run(string) - //pop - //ldstr "Condition21.Test2" - //call int32 TailcallVerify.Program::Run(string) - //pop ldstr "Condition21.Test3" call int32 TailcallVerify.Program::Run(string) pop @@ -2957,10 +2536,6 @@ ldstr "Condition21.Test7" call int32 TailcallVerify.Program::Run(string) pop - // Disable tests intending to test tail.call,pop,ret sequence. - //ldstr "Condition22.Test2" - //call int32 TailcallVerify.Program::Run(string) - //pop ldstr "Condition22.Test4" call int32 TailcallVerify.Program::Run(string) ret @@ -3020,188 +2595,187 @@ } // end of property Program::Result } // end of class TailcallVerify.Program -.class private auto ansi beforefieldinit TailcallVerify.Condition8 +.class private auto ansi beforefieldinit TailcallVerify.Condition21 extends [mscorlib]System.Object { .field private static int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) zero .field private static int32 Result - .method public hidebysig static int32 Test1() cil managed nooptimization + .field private static class [mscorlib]System.Collections.Generic.List`1 evenList + .field private static class [mscorlib]System.Collections.Generic.List`1 oddList + .field assembly class [mscorlib]System.Collections.Generic.List`1 threadList + .field private static int32 counterE4 + .field private static int32 counterO4 + .field private int32 counterE5 + .field private int32 counterO5 + + .method public hidebysig static int32 Test3() cil managed nooptimization { - // Code size 153 (0x99) + // Code size 394 (0x18a) .maxstack 3 - .locals init ([0] class [mscorlib]System.Exception e) - IL_0000: ldstr "Executing Condition8.Test1 - Caller: Arguments: No" - + "ne - ReturnType: void; Callee: Arguments: varargs - ReturnType: void" + .locals init ([0] class [System.Threading.Thread]System.Threading.Thread t1, + [1] class [mscorlib]System.Exception e, + [2] int64 l, + [3] int64 V_3, + [4] valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator CS$5$0000, + [5] valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator CS$5$0001) + IL_0000: ldstr "Executing Condition21.Test3 - Caller: Arguments: N" + + "one - ReturnType: void; CalleeIsOdd3: Arguments: int, int, int, int, 3 " + + "byte struct - ReturnType: 3 byte struct; CalleeIsEven3: Arguments: int," + + " int, int, int, 3 byte struct - ReturnType: 3 byte struct;" IL_0005: call void [System.Console]System.Console::WriteLine(string) IL_000a: ldc.i4.s 100 - IL_000c: stsfld int32 TailcallVerify.Condition8::Result + IL_000c: stsfld int32 TailcallVerify.Condition21::Result + IL_0011: ldsfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::evenList + IL_0016: callvirt instance void class [mscorlib]System.Collections.Generic.List`1::Clear() + IL_001b: ldsfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::oddList + IL_0020: callvirt instance void class [mscorlib]System.Collections.Generic.List`1::Clear() .try { - IL_0011: call void TailcallVerify.Condition8::Caller1() - IL_0016: leave.s IL_006f + IL_0025: ldnull + IL_0026: ldftn void TailcallVerify.Condition21::Caller3() + IL_002c: newobj instance void [System.Threading.Thread]System.Threading.ThreadStart::.ctor(object, + native int) + IL_0031: newobj instance void [System.Threading.Thread]System.Threading.Thread::.ctor(class [System.Threading.Thread]System.Threading.ThreadStart) + IL_0036: stloc.0 + IL_0037: ldloc.0 + IL_0038: callvirt instance void [System.Threading.Thread]System.Threading.Thread::Start() + IL_003d: ldloc.0 + IL_003e: callvirt instance void [System.Threading.Thread]System.Threading.Thread::Join() + IL_0043: leave.s IL_009c } // end .try catch [mscorlib]System.Exception { - IL_0018: stloc.0 - IL_0019: ldloc.0 - IL_001a: isinst [mscorlib]System.DivideByZeroException - IL_001f: brtrue.s IL_002a + IL_0045: stloc.1 + IL_0046: ldloc.1 + IL_0047: isinst [mscorlib]System.DivideByZeroException + IL_004c: brtrue.s IL_0057 - IL_0021: ldc.i4.s 101 - IL_0023: stsfld int32 TailcallVerify.Condition8::Result - IL_0028: rethrow - IL_002a: ldloc.0 - IL_002b: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_0030: ldstr "Caller" - IL_0035: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_003a: ldc.i4.m1 - IL_003b: beq.s IL_006d + IL_004e: ldc.i4.s 101 + IL_0050: stsfld int32 TailcallVerify.Condition21::Result + IL_0055: rethrow + IL_0057: ldloc.1 + IL_0058: callvirt instance string [mscorlib]System.Exception::get_StackTrace() + IL_005d: ldstr "Caller" + IL_0062: callvirt instance int32 [mscorlib]System.String::IndexOf(string) + IL_0067: ldc.i4.m1 + IL_0068: beq.s IL_009a - IL_003d: ldstr "FAILED: Found the word 'Caller' in the stacktrace." - IL_0042: call void [System.Console]System.Console::WriteLine(string) - IL_0047: ldstr "------------------------------------------------" - IL_004c: call void [System.Console]System.Console::WriteLine(string) - IL_0051: call void [System.Console]System.Console::WriteLine() - IL_0056: ldloc.0 - IL_0057: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_005c: call void [System.Console]System.Console::WriteLine(string) - IL_0061: call void [System.Console]System.Console::WriteLine() - IL_0066: ldc.i4.s 101 - IL_0068: stsfld int32 TailcallVerify.Condition8::Result - IL_006d: leave.s IL_006f + IL_006a: ldstr "FAILED: Found the word 'Caller' in the stacktrace." + IL_006f: call void [System.Console]System.Console::WriteLine(string) + IL_0074: ldstr "------------------------------------------------" + IL_0079: call void [System.Console]System.Console::WriteLine(string) + IL_007e: call void [System.Console]System.Console::WriteLine() + IL_0083: ldloc.1 + IL_0084: callvirt instance string [mscorlib]System.Exception::get_StackTrace() + IL_0089: call void [System.Console]System.Console::WriteLine(string) + IL_008e: call void [System.Console]System.Console::WriteLine() + IL_0093: ldc.i4.s 101 + IL_0095: stsfld int32 TailcallVerify.Condition21::Result + IL_009a: leave.s IL_009c } // end handler - IL_006f: ldstr "Execution finished - Test " - IL_0074: ldsfld int32 TailcallVerify.Condition8::Result - IL_0079: ldc.i4.s 100 - IL_007b: beq.s IL_0084 + IL_009c: ldsfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::evenList + IL_00a1: call class [mscorlib]System.Collections.Generic.IEnumerable`1 [System.Linq]System.Linq.Enumerable::Distinct(class [mscorlib]System.Collections.Generic.IEnumerable`1) + IL_00a6: call int32 [System.Linq]System.Linq.Enumerable::Count(class [mscorlib]System.Collections.Generic.IEnumerable`1) + IL_00ab: ldc.i4.1 + IL_00ac: beq.s IL_00fe - IL_007d: ldstr "FAILED" - IL_0082: br.s IL_0089 + IL_00ae: ldstr "FAILED: The local on the stack for CalleeIsEven3 s" + + "hifted. (should have always the same address)" + IL_00b3: call void [System.Console]System.Console::WriteLine(string) + IL_00b8: ldsfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::evenList + IL_00bd: callvirt instance valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator class [mscorlib]System.Collections.Generic.List`1::GetEnumerator() + IL_00c2: stloc.s CS$5$0000 + .try + { + IL_00c4: br.s IL_00de - IL_0084: ldstr "PASSED" - IL_0089: call string [mscorlib]System.String::Concat(string, - string) - IL_008e: call void [System.Console]System.Console::WriteLine(string) - IL_0093: ldsfld int32 TailcallVerify.Condition8::Result - IL_0098: ret - } // end of method Condition8::Test1 + IL_00c6: ldloca.s CS$5$0000 + IL_00c8: call instance !0 valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator::get_Current() + IL_00cd: stloc.2 + IL_00ce: ldstr "0x{0:x8}" + IL_00d3: ldloc.2 + IL_00d4: box [mscorlib]System.Int64 + IL_00d9: call void [System.Console]System.Console::WriteLine(string, + object) + IL_00de: ldloca.s CS$5$0000 + IL_00e0: call instance bool valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator::MoveNext() + IL_00e5: brtrue.s IL_00c6 - .method private hidebysig static void Caller1() cil managed - { - // Code size 55 (0x37) - .maxstack 8 - IL_0000: ldc.i4.0 - IL_0001: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) - IL_0006: callvirt instance class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Diagnostics.StackFrame::GetMethod() - IL_000b: callvirt instance string [mscorlib]System.Reflection.MemberInfo::get_Name() - IL_0010: ldstr "Caller" - IL_0015: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_001a: ldc.i4.m1 - IL_001b: bne.un.s IL_002e + IL_00e7: leave.s IL_00f7 - IL_001d: ldstr "Failed, Method was inlined..." - IL_0022: call void [System.Console]System.Console::WriteLine(string) - IL_0027: ldc.i4.s 101 - IL_0029: stsfld int32 TailcallVerify.Condition8::Result - IL_002e: ldc.i4.0 - IL_002f: ldc.i4.1 - IL_0030: ldc.i4.2 - IL_0031: tail. call vararg void TailcallVerify.Condition8::Callee1(..., - int32, - int32, - int32) - IL_0036: ret - } // end of method Condition8::Caller1 - - .method private hidebysig static vararg void - Callee1() cil managed noinlining - { - // Code size 11 (0xb) - .maxstack 8 - IL_0000: ldc.i4.1 - IL_0001: volatile. - IL_0003: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition8::zero - IL_0008: div - IL_0009: pop - IL_000a: ret - } // end of method Condition8::Callee1 + } // end .try + finally + { + IL_00e9: ldloca.s CS$5$0000 + IL_00eb: constrained. valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator + IL_00f1: callvirt instance void [mscorlib]System.IDisposable::Dispose() + IL_00f6: endfinally + } // end handler + IL_00f7: ldc.i4.s 101 + IL_00f9: stsfld int32 TailcallVerify.Condition21::Result + IL_00fe: ldsfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::oddList + IL_0103: call class [mscorlib]System.Collections.Generic.IEnumerable`1 [System.Linq]System.Linq.Enumerable::Distinct(class [mscorlib]System.Collections.Generic.IEnumerable`1) + IL_0108: call int32 [System.Linq]System.Linq.Enumerable::Count(class [mscorlib]System.Collections.Generic.IEnumerable`1) + IL_010d: ldc.i4.1 + IL_010e: beq.s IL_0160 - .method public hidebysig static int32 Test2() cil managed nooptimization - { - // Code size 156 (0x9c) - .maxstack 3 - .locals init ([0] class [mscorlib]System.Exception e) - IL_0000: ldstr "Executing Condition8.Test2 - Caller: Arguments: va" - + "rargs - ReturnType: void; Callee: Arguments: None - ReturnType: void" - IL_0005: call void [System.Console]System.Console::WriteLine(string) - IL_000a: ldc.i4.s 100 - IL_000c: stsfld int32 TailcallVerify.Condition8::Result + IL_0110: ldstr "FAILED: The local on the stack for CalleeIsOdd3 sh" + + "ifted. (should have always the same address)" + IL_0115: call void [System.Console]System.Console::WriteLine(string) + IL_011a: ldsfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::oddList + IL_011f: callvirt instance valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator class [mscorlib]System.Collections.Generic.List`1::GetEnumerator() + IL_0124: stloc.s CS$5$0001 .try { - IL_0011: ldc.i4.0 - IL_0012: ldc.i4.1 - IL_0013: ldc.i4.2 - IL_0014: call vararg void TailcallVerify.Condition8::Caller2(..., - int32, - int32, - int32) - IL_0019: leave.s IL_0072 + IL_0126: br.s IL_0140 + + IL_0128: ldloca.s CS$5$0001 + IL_012a: call instance !0 valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator::get_Current() + IL_012f: stloc.3 + IL_0130: ldstr "0x{0:x8}" + IL_0135: ldloc.3 + IL_0136: box [mscorlib]System.Int64 + IL_013b: call void [System.Console]System.Console::WriteLine(string, + object) + IL_0140: ldloca.s CS$5$0001 + IL_0142: call instance bool valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator::MoveNext() + IL_0147: brtrue.s IL_0128 + + IL_0149: leave.s IL_0159 } // end .try - catch [mscorlib]System.Exception + finally { - IL_001b: stloc.0 - IL_001c: ldloc.0 - IL_001d: isinst [mscorlib]System.DivideByZeroException - IL_0022: brtrue.s IL_002d - - IL_0024: ldc.i4.s 101 - IL_0026: stsfld int32 TailcallVerify.Condition8::Result - IL_002b: rethrow - IL_002d: ldloc.0 - IL_002e: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_0033: ldstr "Caller" - IL_0038: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_003d: ldc.i4.m1 - IL_003e: beq.s IL_0070 - - IL_0040: ldstr "FAILED: Found the word 'Caller' in the stacktrace." - IL_0045: call void [System.Console]System.Console::WriteLine(string) - IL_004a: ldstr "------------------------------------------------" - IL_004f: call void [System.Console]System.Console::WriteLine(string) - IL_0054: call void [System.Console]System.Console::WriteLine() - IL_0059: ldloc.0 - IL_005a: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_005f: call void [System.Console]System.Console::WriteLine(string) - IL_0064: call void [System.Console]System.Console::WriteLine() - IL_0069: ldc.i4.s 101 - IL_006b: stsfld int32 TailcallVerify.Condition8::Result - IL_0070: leave.s IL_0072 - + IL_014b: ldloca.s CS$5$0001 + IL_014d: constrained. valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator + IL_0153: callvirt instance void [mscorlib]System.IDisposable::Dispose() + IL_0158: endfinally } // end handler - IL_0072: ldstr "Execution finished - Test " - IL_0077: ldsfld int32 TailcallVerify.Condition8::Result - IL_007c: ldc.i4.s 100 - IL_007e: beq.s IL_0087 + IL_0159: ldc.i4.s 101 + IL_015b: stsfld int32 TailcallVerify.Condition21::Result + IL_0160: ldstr "Execution finished - Test " + IL_0165: ldsfld int32 TailcallVerify.Condition21::Result + IL_016a: ldc.i4.s 100 + IL_016c: beq.s IL_0175 - IL_0080: ldstr "FAILED" - IL_0085: br.s IL_008c + IL_016e: ldstr "FAILED" + IL_0173: br.s IL_017a - IL_0087: ldstr "PASSED" - IL_008c: call string [mscorlib]System.String::Concat(string, + IL_0175: ldstr "PASSED" + IL_017a: call string [mscorlib]System.String::Concat(string, string) - IL_0091: call void [System.Console]System.Console::WriteLine(string) - IL_0096: ldsfld int32 TailcallVerify.Condition8::Result - IL_009b: ret - } // end of method Condition8::Test2 + IL_017f: call void [System.Console]System.Console::WriteLine(string) + IL_0184: ldsfld int32 TailcallVerify.Condition21::Result + IL_0189: ret + } // end of method Condition21::Test3 - .method private hidebysig static vararg void - Caller2() cil managed + .method private hidebysig static void Caller3() cil managed { - // Code size 52 (0x34) - .maxstack 8 + // Code size 73 (0x49) + .maxstack 6 + .locals init ([0] valuetype TailcallVerify.ValueType3Bytes CS$0$0000) IL_0000: ldc.i4.0 IL_0001: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) IL_0006: callvirt instance class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Diagnostics.StackFrame::GetMethod() @@ -3211,384 +2785,73 @@ IL_001a: ldc.i4.m1 IL_001b: bne.un.s IL_002e - IL_001d: ldstr "Failed, Method was inlined..." + IL_001d: ldstr "FAILED: Caller3 was inlined..." IL_0022: call void [System.Console]System.Console::WriteLine(string) IL_0027: ldc.i4.s 101 - IL_0029: stsfld int32 TailcallVerify.Condition8::Result - IL_002e: tail. call void TailcallVerify.Condition8::Callee2() - IL_0033: ret - } // end of method Condition8::Caller2 - - .method private hidebysig static void Callee2() cil managed noinlining - { - // Code size 11 (0xb) - .maxstack 8 - IL_0000: ldc.i4.1 - IL_0001: volatile. - IL_0003: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition8::zero - IL_0008: div - IL_0009: pop - IL_000a: ret - } // end of method Condition8::Callee2 - - .method public hidebysig static int32 Test3() cil managed nooptimization - { - // Code size 156 (0x9c) - .maxstack 3 - .locals init ([0] class [mscorlib]System.Exception e) - IL_0000: ldstr "Executing Condition8.Test3 - Caller: Arguments: va" - + "rarg - ReturnType: void; Callee: Arguments: vararg - ReturnType: void" - IL_0005: call void [System.Console]System.Console::WriteLine(string) - IL_000a: ldc.i4.s 100 - IL_000c: stsfld int32 TailcallVerify.Condition8::Result + IL_0029: stsfld int32 TailcallVerify.Condition21::Result .try { - IL_0011: ldc.i4.0 - IL_0012: ldc.i4.1 - IL_0013: ldc.i4.2 - IL_0014: call vararg void TailcallVerify.Condition8::Caller3(..., - int32, - int32, - int32) - IL_0019: leave.s IL_0072 + IL_002e: ldc.i4.s 20 + IL_0030: ldc.i4.1 + IL_0031: ldc.i4.2 + IL_0032: ldc.i4.3 + IL_0033: ldc.i4.4 + IL_0034: ldloca.s CS$0$0000 + IL_0036: initobj TailcallVerify.ValueType3Bytes + IL_003c: ldloc.0 + IL_003d: call valuetype TailcallVerify.ValueType3Bytes TailcallVerify.Condition21::CallerIsOdd3(int32, + int32, + int32, + int32, + int32, + valuetype TailcallVerify.ValueType3Bytes) + IL_0042: pop + IL_0043: leave.s IL_0048 } // end .try - catch [mscorlib]System.Exception + catch [mscorlib]System.DivideByZeroException { - IL_001b: stloc.0 - IL_001c: ldloc.0 - IL_001d: isinst [mscorlib]System.DivideByZeroException - IL_0022: brtrue.s IL_002d - - IL_0024: ldc.i4.s 101 - IL_0026: stsfld int32 TailcallVerify.Condition8::Result - IL_002b: rethrow - IL_002d: ldloc.0 - IL_002e: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_0033: ldstr "Caller" - IL_0038: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_003d: ldc.i4.m1 - IL_003e: beq.s IL_0070 - - IL_0040: ldstr "FAILED: Found the word 'Caller' in the stacktrace." - IL_0045: call void [System.Console]System.Console::WriteLine(string) - IL_004a: ldstr "------------------------------------------------" - IL_004f: call void [System.Console]System.Console::WriteLine(string) - IL_0054: call void [System.Console]System.Console::WriteLine() - IL_0059: ldloc.0 - IL_005a: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_005f: call void [System.Console]System.Console::WriteLine(string) - IL_0064: call void [System.Console]System.Console::WriteLine() - IL_0069: ldc.i4.s 101 - IL_006b: stsfld int32 TailcallVerify.Condition8::Result - IL_0070: leave.s IL_0072 + IL_0045: pop + IL_0046: leave.s IL_0048 } // end handler - IL_0072: ldstr "Execution finished - Test " - IL_0077: ldsfld int32 TailcallVerify.Condition8::Result - IL_007c: ldc.i4.s 100 - IL_007e: beq.s IL_0087 - - IL_0080: ldstr "FAILED" - IL_0085: br.s IL_008c - - IL_0087: ldstr "PASSED" - IL_008c: call string [mscorlib]System.String::Concat(string, - string) - IL_0091: call void [System.Console]System.Console::WriteLine(string) - IL_0096: ldsfld int32 TailcallVerify.Condition8::Result - IL_009b: ret - } // end of method Condition8::Test3 + IL_0048: ret + } // end of method Condition21::Caller3 - .method private hidebysig static vararg void - Caller3() cil managed + .method private hidebysig static valuetype TailcallVerify.ValueType3Bytes + CallerIsOdd3(int32 i, + int32 i2, + int32 i3, + int32 i4, + int32 i5, + valuetype TailcallVerify.ValueType3Bytes v3) cil managed { - // Code size 55 (0x37) + // Code size 14 (0xe) .maxstack 8 - IL_0000: ldc.i4.0 - IL_0001: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) - IL_0006: callvirt instance class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Diagnostics.StackFrame::GetMethod() - IL_000b: callvirt instance string [mscorlib]System.Reflection.MemberInfo::get_Name() - IL_0010: ldstr "Caller" - IL_0015: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_001a: ldc.i4.m1 - IL_001b: bne.un.s IL_002e - - IL_001d: ldstr "Failed, Method was inlined..." - IL_0022: call void [System.Console]System.Console::WriteLine(string) - IL_0027: ldc.i4.s 101 - IL_0029: stsfld int32 TailcallVerify.Condition8::Result - IL_002e: ldc.i4.0 - IL_002f: ldc.i4.1 - IL_0030: ldc.i4.2 - IL_0031: tail. call vararg void TailcallVerify.Condition8::Callee3(..., - int32, - int32, - int32) - IL_0036: ret - } // end of method Condition8::Caller3 - - .method private hidebysig static vararg void - Callee3() cil managed noinlining - { - // Code size 11 (0xb) - .maxstack 8 - IL_0000: ldc.i4.1 - IL_0001: volatile. - IL_0003: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition8::zero - IL_0008: div - IL_0009: pop - IL_000a: ret - } // end of method Condition8::Callee3 - - .method public hidebysig specialname rtspecialname - instance void .ctor() cil managed - { - // Code size 7 (0x7) - .maxstack 8 - IL_0000: ldarg.0 - IL_0001: call instance void [mscorlib]System.Object::.ctor() - IL_0006: ret - } // end of method Condition8::.ctor - - .method private hidebysig specialname rtspecialname static - void .cctor() cil managed - { - // Code size 16 (0x10) - .maxstack 8 - IL_0000: ldc.i4.0 - IL_0001: volatile. - IL_0003: stsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition8::zero - IL_0008: ldc.i4.s 100 - IL_000a: stsfld int32 TailcallVerify.Condition8::Result - IL_000f: ret - } // end of method Condition8::.cctor - -} // end of class TailcallVerify.Condition8 - -.class private auto ansi beforefieldinit TailcallVerify.Condition21 - extends [mscorlib]System.Object -{ - .field private static int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) zero - .field private static int32 Result - .field private static class [mscorlib]System.Collections.Generic.List`1 evenList - .field private static class [mscorlib]System.Collections.Generic.List`1 oddList - .field assembly class [mscorlib]System.Collections.Generic.List`1 threadList - .field private static int32 counterE4 - .field private static int32 counterO4 - .field private int32 counterE5 - .field private int32 counterO5 - .method public hidebysig static int32 Test1() cil managed nooptimization - { - // Code size 368 (0x170) - .maxstack 3 - .locals init ([0] class [mscorlib]System.Exception e, - [1] int64 l, - [2] int64 V_2, - [3] valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator CS$5$0000, - [4] valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator CS$5$0001) - IL_0000: ldstr "Executing Condition21.Test1 - Caller: Arguments: N" - + "one - ReturnType: void; CalleeIsOdd1: Arguments: int, int, int, int, 3 " - + "byte struct - ReturnType: 3 byte struct; CalleeIsEven1: Arguments: int," - + " int, int, int, 3 byte struct - ReturnType: 3 byte struct;" - IL_0005: call void [System.Console]System.Console::WriteLine(string) - IL_000a: ldc.i4.s 100 - IL_000c: stsfld int32 TailcallVerify.Condition21::Result - IL_0011: ldsfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::evenList - IL_0016: callvirt instance void class [mscorlib]System.Collections.Generic.List`1::Clear() - IL_001b: ldsfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::oddList - IL_0020: callvirt instance void class [mscorlib]System.Collections.Generic.List`1::Clear() - .try - { - IL_0025: call void TailcallVerify.Condition21::Caller1() - IL_002a: leave.s IL_0083 - - } // end .try - catch [mscorlib]System.Exception - { - IL_002c: stloc.0 - IL_002d: ldloc.0 - IL_002e: isinst [mscorlib]System.DivideByZeroException - IL_0033: brtrue.s IL_003e - - IL_0035: ldc.i4.s 101 - IL_0037: stsfld int32 TailcallVerify.Condition21::Result - IL_003c: rethrow - IL_003e: ldloc.0 - IL_003f: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_0044: ldstr "Caller" - IL_0049: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_004e: ldc.i4.m1 - IL_004f: beq.s IL_0081 - - IL_0051: ldstr "FAILED: Found the word 'Caller' in the stacktrace." - IL_0056: call void [System.Console]System.Console::WriteLine(string) - IL_005b: ldstr "------------------------------------------------" - IL_0060: call void [System.Console]System.Console::WriteLine(string) - IL_0065: call void [System.Console]System.Console::WriteLine() - IL_006a: ldloc.0 - IL_006b: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_0070: call void [System.Console]System.Console::WriteLine(string) - IL_0075: call void [System.Console]System.Console::WriteLine() - IL_007a: ldc.i4.s 101 - IL_007c: stsfld int32 TailcallVerify.Condition21::Result - IL_0081: leave.s IL_0083 - - } // end handler - IL_0083: ldsfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::evenList - IL_0088: call class [mscorlib]System.Collections.Generic.IEnumerable`1 [System.Linq]System.Linq.Enumerable::Distinct(class [mscorlib]System.Collections.Generic.IEnumerable`1) - IL_008d: call int32 [System.Linq]System.Linq.Enumerable::Count(class [mscorlib]System.Collections.Generic.IEnumerable`1) - IL_0092: ldc.i4.1 - IL_0093: beq.s IL_00e4 - - IL_0095: ldstr "FAILED: The local on the stack for CalleeIsEven3 s" - + "hifted. (should have always the same address)" - IL_009a: call void [System.Console]System.Console::WriteLine(string) - IL_009f: ldsfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::evenList - IL_00a4: callvirt instance valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator class [mscorlib]System.Collections.Generic.List`1::GetEnumerator() - IL_00a9: stloc.3 - .try - { - IL_00aa: br.s IL_00c4 - - IL_00ac: ldloca.s CS$5$0000 - IL_00ae: call instance !0 valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator::get_Current() - IL_00b3: stloc.1 - IL_00b4: ldstr "0x{0:x8}" - IL_00b9: ldloc.1 - IL_00ba: box [mscorlib]System.Int64 - IL_00bf: call void [System.Console]System.Console::WriteLine(string, - object) - IL_00c4: ldloca.s CS$5$0000 - IL_00c6: call instance bool valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator::MoveNext() - IL_00cb: brtrue.s IL_00ac - - IL_00cd: leave.s IL_00dd - - } // end .try - finally - { - IL_00cf: ldloca.s CS$5$0000 - IL_00d1: constrained. valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator - IL_00d7: callvirt instance void [mscorlib]System.IDisposable::Dispose() - IL_00dc: endfinally - } // end handler - IL_00dd: ldc.i4.s 101 - IL_00df: stsfld int32 TailcallVerify.Condition21::Result - IL_00e4: ldsfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::oddList - IL_00e9: call class [mscorlib]System.Collections.Generic.IEnumerable`1 [System.Linq]System.Linq.Enumerable::Distinct(class [mscorlib]System.Collections.Generic.IEnumerable`1) - IL_00ee: call int32 [System.Linq]System.Linq.Enumerable::Count(class [mscorlib]System.Collections.Generic.IEnumerable`1) - IL_00f3: ldc.i4.1 - IL_00f4: beq.s IL_0146 - - IL_00f6: ldstr "FAILED: The local on the stack for CalleeIsOdd3 sh" - + "ifted. (should have always the same address)" - IL_00fb: call void [System.Console]System.Console::WriteLine(string) - IL_0100: ldsfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::oddList - IL_0105: callvirt instance valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator class [mscorlib]System.Collections.Generic.List`1::GetEnumerator() - IL_010a: stloc.s CS$5$0001 - .try - { - IL_010c: br.s IL_0126 - - IL_010e: ldloca.s CS$5$0001 - IL_0110: call instance !0 valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator::get_Current() - IL_0115: stloc.2 - IL_0116: ldstr "0x{0:x8}" - IL_011b: ldloc.2 - IL_011c: box [mscorlib]System.Int64 - IL_0121: call void [System.Console]System.Console::WriteLine(string, - object) - IL_0126: ldloca.s CS$5$0001 - IL_0128: call instance bool valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator::MoveNext() - IL_012d: brtrue.s IL_010e - - IL_012f: leave.s IL_013f - - } // end .try - finally - { - IL_0131: ldloca.s CS$5$0001 - IL_0133: constrained. valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator - IL_0139: callvirt instance void [mscorlib]System.IDisposable::Dispose() - IL_013e: endfinally - } // end handler - IL_013f: ldc.i4.s 101 - IL_0141: stsfld int32 TailcallVerify.Condition21::Result - IL_0146: ldstr "Execution finished - Test " - IL_014b: ldsfld int32 TailcallVerify.Condition21::Result - IL_0150: ldc.i4.s 100 - IL_0152: beq.s IL_015b - - IL_0154: ldstr "FAILED" - IL_0159: br.s IL_0160 - - IL_015b: ldstr "PASSED" - IL_0160: call string [mscorlib]System.String::Concat(string, - string) - IL_0165: call void [System.Console]System.Console::WriteLine(string) - IL_016a: ldsfld int32 TailcallVerify.Condition21::Result - IL_016f: ret - } // end of method Condition21::Test1 - - .method private hidebysig static void Caller1() cil managed - { - // Code size 96 (0x60) - .maxstack 6 - .locals init ([0] valuetype TailcallVerify.ValueType3Bytes v, - [1] valuetype TailcallVerify.ValueType3Bytes '<>g__initLocal0', - [2] valuetype TailcallVerify.ValueType3Bytes CS$0$0000) - IL_0000: ldc.i4.0 - IL_0001: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) - IL_0006: callvirt instance class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Diagnostics.StackFrame::GetMethod() - IL_000b: callvirt instance string [mscorlib]System.Reflection.MemberInfo::get_Name() - IL_0010: ldstr "Caller" - IL_0015: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_001a: ldc.i4.m1 - IL_001b: bne.un.s IL_002e - - IL_001d: ldstr "FAILED: Caller3 was inlined..." - IL_0022: call void [System.Console]System.Console::WriteLine(string) - IL_0027: ldc.i4.s 101 - IL_0029: stsfld int32 TailcallVerify.Condition21::Result - IL_002e: ldloca.s CS$0$0000 - IL_0030: initobj TailcallVerify.ValueType3Bytes - IL_0036: ldloc.2 - IL_0037: stloc.1 - IL_0038: ldloca.s '<>g__initLocal0' - IL_003a: ldc.i4 0xff - IL_003f: stfld uint8 TailcallVerify.ValueType3Bytes::i1 - IL_0044: ldloca.s '<>g__initLocal0' - IL_0046: ldc.i4 0xffff8000 - IL_004b: stfld int16 TailcallVerify.ValueType3Bytes::i2 - IL_0050: ldloc.1 - IL_0051: stloc.0 - IL_0052: ldc.i4.s 20 - IL_0054: ldc.i4.1 - IL_0055: ldc.i4.2 - IL_0056: ldc.i4.3 - IL_0057: ldc.i4.4 - IL_0058: ldloc.0 -// tail. // tail.call, pop, ret sequence is never valid for .NET Core (but is accepted by .NET x64) - IL_0059: call valuetype TailcallVerify.ValueType3Bytes TailcallVerify.Condition21::CalleeIsOdd1(int32, - int32, - int32, - int32, - int32, - valuetype TailcallVerify.ValueType3Bytes) - IL_005e: pop - IL_005f: ret - } // end of method Condition21::Caller1 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: ldarg.2 + IL_0003: ldarg.3 + IL_0004: ldarg.s i5 + IL_0006: ldarg.s v3 + IL_0008: tail. call valuetype TailcallVerify.ValueType3Bytes TailcallVerify.Condition21::CalleeIsOdd3(int32, + int32, + int32, + int32, + int32, + valuetype TailcallVerify.ValueType3Bytes) + IL_000d: ret + } // end of method Condition21::CallerIsOdd3 .method private hidebysig static valuetype TailcallVerify.ValueType3Bytes - CalleeIsOdd1(int32 i, + CalleeIsOdd3(int32 i, int32 i2, int32 i3, int32 i4, int32 i5, valuetype TailcallVerify.ValueType3Bytes v3) cil managed { - // Code size 171 (0xab) + // Code size 109 (0x6d) .maxstack 6 .locals init ([0] int32 data, [1] int32* pData, @@ -3604,87 +2867,57 @@ IL_0011: ldloca.s p IL_0013: call instance int64 [mscorlib]System.IntPtr::ToInt64() IL_0018: callvirt instance void class [mscorlib]System.Collections.Generic.List`1::Add(!0) - IL_001d: ldarg.1 - IL_001e: ldc.i4.1 - IL_001f: bne.un.s IL_004a - - IL_0021: ldarg.2 - IL_0022: ldc.i4.2 - IL_0023: bne.un.s IL_004a - - IL_0025: ldarg.3 - IL_0026: ldc.i4.3 - IL_0027: bne.un.s IL_004a + IL_001d: ldc.i4.0 + IL_001e: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) + IL_0023: callvirt instance class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Diagnostics.StackFrame::GetMethod() + IL_0028: callvirt instance string [mscorlib]System.Reflection.MemberInfo::get_Name() + IL_002d: ldstr "Callee" + IL_0032: callvirt instance int32 [mscorlib]System.String::IndexOf(string) + IL_0037: ldc.i4.m1 + IL_0038: bne.un.s IL_004b - IL_0029: ldarg.s i5 - IL_002b: ldc.i4.4 - IL_002c: bne.un.s IL_004a + IL_003a: ldstr "FAILED: CalleeIsOdd3 was inlined..." + IL_003f: call void [System.Console]System.Console::WriteLine(string) + IL_0044: ldc.i4.s 101 + IL_0046: stsfld int32 TailcallVerify.Condition21::Result + IL_004b: ldarg.0 + IL_004c: brtrue.s IL_005d - IL_002e: ldarga.s v3 - IL_0030: ldfld uint8 TailcallVerify.ValueType3Bytes::i1 - IL_0035: ldc.i4 0xff - IL_003a: bne.un.s IL_004a - - IL_003c: ldarga.s v3 - IL_003e: ldfld int16 TailcallVerify.ValueType3Bytes::i2 - IL_0043: ldc.i4 0xffff8000 - IL_0048: beq.s IL_005b - - IL_004a: ldstr "FAILED: Passed in arguments are wrong..." - IL_004f: call void [System.Console]System.Console::WriteLine(string) - IL_0054: ldc.i4.s 101 - IL_0056: stsfld int32 TailcallVerify.Condition21::Result - IL_005b: ldc.i4.0 - IL_005c: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) - IL_0061: callvirt instance class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Diagnostics.StackFrame::GetMethod() - IL_0066: callvirt instance string [mscorlib]System.Reflection.MemberInfo::get_Name() - IL_006b: ldstr "Callee" - IL_0070: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_0075: ldc.i4.m1 - IL_0076: bne.un.s IL_0089 - - IL_0078: ldstr "FAILED: CalleeIsOdd3 was inlined..." - IL_007d: call void [System.Console]System.Console::WriteLine(string) - IL_0082: ldc.i4.s 101 - IL_0084: stsfld int32 TailcallVerify.Condition21::Result - IL_0089: ldarg.0 - IL_008a: brtrue.s IL_009b - - IL_008c: ldc.i4.1 - IL_008d: ldarg.0 - IL_008e: div - IL_008f: starg.s i - IL_0091: ldloca.s CS$0$0000 - IL_0093: initobj TailcallVerify.ValueType3Bytes - IL_0099: ldloc.3 - IL_009a: ret + IL_004e: ldc.i4.1 + IL_004f: ldarg.0 + IL_0050: div + IL_0051: starg.s i + IL_0053: ldloca.s CS$0$0000 + IL_0055: initobj TailcallVerify.ValueType3Bytes + IL_005b: ldloc.3 + IL_005c: ret - IL_009b: ldarg.0 - IL_009c: ldc.i4.1 - IL_009d: sub - IL_009e: ldarg.1 - IL_009f: ldarg.2 - IL_00a0: ldarg.3 - IL_00a1: ldarg.s i5 - IL_00a3: ldarg.s v3 - IL_00a5: tail. call valuetype TailcallVerify.ValueType3Bytes TailcallVerify.Condition21::CalleeIsEven1(int32, + IL_005d: ldarg.0 + IL_005e: ldc.i4.1 + IL_005f: sub + IL_0060: ldarg.1 + IL_0061: ldarg.2 + IL_0062: ldarg.3 + IL_0063: ldarg.s i5 + IL_0065: ldarg.s v3 + IL_0067: tail. call valuetype TailcallVerify.ValueType3Bytes TailcallVerify.Condition21::CalleeIsEven3(int32, int32, int32, int32, int32, valuetype TailcallVerify.ValueType3Bytes) - IL_00aa: ret - } // end of method Condition21::CalleeIsOdd1 + IL_006c: ret + } // end of method Condition21::CalleeIsOdd3 .method private hidebysig static valuetype TailcallVerify.ValueType3Bytes - CalleeIsEven1(int32 i, + CalleeIsEven3(int32 i, int32 i2, int32 i3, int32 i4, int32 i5, valuetype TailcallVerify.ValueType3Bytes v3) cil managed { - // Code size 171 (0xab) + // Code size 109 (0x6d) .maxstack 6 .locals init ([0] int32 data, [1] int32* pData, @@ -3700,236 +2933,115 @@ IL_0011: ldloca.s p IL_0013: call instance int64 [mscorlib]System.IntPtr::ToInt64() IL_0018: callvirt instance void class [mscorlib]System.Collections.Generic.List`1::Add(!0) - IL_001d: ldarg.1 - IL_001e: ldc.i4.1 - IL_001f: bne.un.s IL_004a - - IL_0021: ldarg.2 - IL_0022: ldc.i4.2 - IL_0023: bne.un.s IL_004a - - IL_0025: ldarg.3 - IL_0026: ldc.i4.3 - IL_0027: bne.un.s IL_004a + IL_001d: ldc.i4.0 + IL_001e: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) + IL_0023: callvirt instance class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Diagnostics.StackFrame::GetMethod() + IL_0028: callvirt instance string [mscorlib]System.Reflection.MemberInfo::get_Name() + IL_002d: ldstr "Callee" + IL_0032: callvirt instance int32 [mscorlib]System.String::IndexOf(string) + IL_0037: ldc.i4.m1 + IL_0038: bne.un.s IL_004b - IL_0029: ldarg.s i5 - IL_002b: ldc.i4.4 - IL_002c: bne.un.s IL_004a + IL_003a: ldstr "FAILED: CalleeIsEven3 was inlined..." + IL_003f: call void [System.Console]System.Console::WriteLine(string) + IL_0044: ldc.i4.s 101 + IL_0046: stsfld int32 TailcallVerify.Condition21::Result + IL_004b: ldarg.0 + IL_004c: brtrue.s IL_005d - IL_002e: ldarga.s v3 - IL_0030: ldfld uint8 TailcallVerify.ValueType3Bytes::i1 - IL_0035: ldc.i4 0xff - IL_003a: bne.un.s IL_004a - - IL_003c: ldarga.s v3 - IL_003e: ldfld int16 TailcallVerify.ValueType3Bytes::i2 - IL_0043: ldc.i4 0xffff8000 - IL_0048: beq.s IL_005b - - IL_004a: ldstr "FAILED: Passed in arguments are wrong..." - IL_004f: call void [System.Console]System.Console::WriteLine(string) - IL_0054: ldc.i4.s 101 - IL_0056: stsfld int32 TailcallVerify.Condition21::Result - IL_005b: ldc.i4.0 - IL_005c: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) - IL_0061: callvirt instance class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Diagnostics.StackFrame::GetMethod() - IL_0066: callvirt instance string [mscorlib]System.Reflection.MemberInfo::get_Name() - IL_006b: ldstr "Callee" - IL_0070: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_0075: ldc.i4.m1 - IL_0076: bne.un.s IL_0089 - - IL_0078: ldstr "FAILED: CalleeIsEven3 was inlined..." - IL_007d: call void [System.Console]System.Console::WriteLine(string) - IL_0082: ldc.i4.s 101 - IL_0084: stsfld int32 TailcallVerify.Condition21::Result - IL_0089: ldarg.0 - IL_008a: brtrue.s IL_009b - - IL_008c: ldc.i4.1 - IL_008d: ldarg.0 - IL_008e: div - IL_008f: starg.s i - IL_0091: ldloca.s CS$0$0000 - IL_0093: initobj TailcallVerify.ValueType3Bytes - IL_0099: ldloc.3 - IL_009a: ret + IL_004e: ldc.i4.1 + IL_004f: ldarg.0 + IL_0050: div + IL_0051: starg.s i + IL_0053: ldloca.s CS$0$0000 + IL_0055: initobj TailcallVerify.ValueType3Bytes + IL_005b: ldloc.3 + IL_005c: ret - IL_009b: ldarg.0 - IL_009c: ldc.i4.1 - IL_009d: sub - IL_009e: ldarg.1 - IL_009f: ldarg.2 - IL_00a0: ldarg.3 - IL_00a1: ldarg.s i5 - IL_00a3: ldarg.s v3 - IL_00a5: tail. call valuetype TailcallVerify.ValueType3Bytes TailcallVerify.Condition21::CalleeIsOdd1(int32, + IL_005d: ldarg.0 + IL_005e: ldc.i4.1 + IL_005f: sub + IL_0060: ldarg.1 + IL_0061: ldarg.2 + IL_0062: ldarg.3 + IL_0063: ldarg.s i5 + IL_0065: ldarg.s v3 + IL_0067: tail. call valuetype TailcallVerify.ValueType3Bytes TailcallVerify.Condition21::CalleeIsOdd3(int32, int32, int32, int32, int32, valuetype TailcallVerify.ValueType3Bytes) - IL_00aa: ret - } // end of method Condition21::CalleeIsEven1 + IL_006c: ret + } // end of method Condition21::CalleeIsEven3 - .method public hidebysig static int32 Test2() cil managed nooptimization + .method public hidebysig static int32 Test6() cil managed nooptimization { - // Code size 368 (0x170) + // Code size 153 (0x99) .maxstack 3 - .locals init ([0] class [mscorlib]System.Exception e, - [1] int64 l, - [2] int64 V_2, - [3] valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator CS$5$0000, - [4] valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator CS$5$0001) - IL_0000: ldstr "Executing Condition21.Test2 - Caller: Arguments: N" - + "one - ReturnType: void; CalleeIsOdd3: Arguments: int, int, int, int, 3 " - + "byte struct - ReturnType: 3 byte struct; CalleeIsEven3: Arguments: int," - + " int, int, int, 3 byte struct - ReturnType: 3 byte struct;" + .locals init ([0] class [mscorlib]System.Exception e) + IL_0000: ldstr "Executing Condition21.Test6 - Caller: Arguments: " + + "None - ReturnType: void; Callee: Arguments: None - ReturnType: void" IL_0005: call void [System.Console]System.Console::WriteLine(string) IL_000a: ldc.i4.s 100 IL_000c: stsfld int32 TailcallVerify.Condition21::Result - IL_0011: ldsfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::evenList - IL_0016: callvirt instance void class [mscorlib]System.Collections.Generic.List`1::Clear() - IL_001b: ldsfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::oddList - IL_0020: callvirt instance void class [mscorlib]System.Collections.Generic.List`1::Clear() .try { - IL_0025: call void TailcallVerify.Condition21::Caller2() - IL_002a: leave.s IL_0083 + IL_0011: call void TailcallVerify.Condition21::Caller6() + IL_0016: leave.s IL_006f } // end .try catch [mscorlib]System.Exception { - IL_002c: stloc.0 - IL_002d: ldloc.0 - IL_002e: isinst [mscorlib]System.DivideByZeroException - IL_0033: brtrue.s IL_003e - - IL_0035: ldc.i4.s 101 - IL_0037: stsfld int32 TailcallVerify.Condition21::Result - IL_003c: rethrow - IL_003e: ldloc.0 - IL_003f: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_0044: ldstr "Caller" - IL_0049: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_004e: ldc.i4.m1 - IL_004f: beq.s IL_0081 - - IL_0051: ldstr "FAILED: Found the word 'Caller' in the stacktrace." - IL_0056: call void [System.Console]System.Console::WriteLine(string) - IL_005b: ldstr "------------------------------------------------" - IL_0060: call void [System.Console]System.Console::WriteLine(string) - IL_0065: call void [System.Console]System.Console::WriteLine() - IL_006a: ldloc.0 - IL_006b: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_0070: call void [System.Console]System.Console::WriteLine(string) - IL_0075: call void [System.Console]System.Console::WriteLine() - IL_007a: ldc.i4.s 101 - IL_007c: stsfld int32 TailcallVerify.Condition21::Result - IL_0081: leave.s IL_0083 + IL_0018: stloc.0 + IL_0019: ldloc.0 + IL_001a: isinst [mscorlib]System.DivideByZeroException + IL_001f: brtrue.s IL_002a - } // end handler - IL_0083: ldsfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::evenList - IL_0088: call class [mscorlib]System.Collections.Generic.IEnumerable`1 [System.Linq]System.Linq.Enumerable::Distinct(class [mscorlib]System.Collections.Generic.IEnumerable`1) - IL_008d: call int32 [System.Linq]System.Linq.Enumerable::Count(class [mscorlib]System.Collections.Generic.IEnumerable`1) - IL_0092: ldc.i4.2 - IL_0093: beq.s IL_00e4 - - IL_0095: ldstr "FAILED: The local on the stack for CalleeIsEven3 s" - + "hifted. (should have always the same address except for the first one.)" - IL_009a: call void [System.Console]System.Console::WriteLine(string) - IL_009f: ldsfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::evenList - IL_00a4: callvirt instance valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator class [mscorlib]System.Collections.Generic.List`1::GetEnumerator() - IL_00a9: stloc.3 - .try - { - IL_00aa: br.s IL_00c4 - - IL_00ac: ldloca.s CS$5$0000 - IL_00ae: call instance !0 valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator::get_Current() - IL_00b3: stloc.1 - IL_00b4: ldstr "0x{0:x8}" - IL_00b9: ldloc.1 - IL_00ba: box [mscorlib]System.Int64 - IL_00bf: call void [System.Console]System.Console::WriteLine(string, - object) - IL_00c4: ldloca.s CS$5$0000 - IL_00c6: call instance bool valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator::MoveNext() - IL_00cb: brtrue.s IL_00ac + IL_0021: ldc.i4.s 101 + IL_0023: stsfld int32 TailcallVerify.Condition21::Result + IL_0028: rethrow + IL_002a: ldloc.0 + IL_002b: callvirt instance string [mscorlib]System.Exception::get_StackTrace() + IL_0030: ldstr "Caller" + IL_0035: callvirt instance int32 [mscorlib]System.String::IndexOf(string) + IL_003a: ldc.i4.m1 + IL_003b: beq.s IL_006d - IL_00cd: leave.s IL_00dd + IL_003d: ldstr "FAILED: Found the word 'Caller' in the stacktrace." + IL_0042: call void [System.Console]System.Console::WriteLine(string) + IL_0047: ldstr "------------------------------------------------" + IL_004c: call void [System.Console]System.Console::WriteLine(string) + IL_0051: call void [System.Console]System.Console::WriteLine() + IL_0056: ldloc.0 + IL_0057: callvirt instance string [mscorlib]System.Exception::get_StackTrace() + IL_005c: call void [System.Console]System.Console::WriteLine(string) + IL_0061: call void [System.Console]System.Console::WriteLine() + IL_0066: ldc.i4.s 101 + IL_0068: stsfld int32 TailcallVerify.Condition21::Result + IL_006d: leave.s IL_006f - } // end .try - finally - { - IL_00cf: ldloca.s CS$5$0000 - IL_00d1: constrained. valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator - IL_00d7: callvirt instance void [mscorlib]System.IDisposable::Dispose() - IL_00dc: endfinally } // end handler - IL_00dd: ldc.i4.s 101 - IL_00df: stsfld int32 TailcallVerify.Condition21::Result - IL_00e4: ldsfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::oddList - IL_00e9: call class [mscorlib]System.Collections.Generic.IEnumerable`1 [System.Linq]System.Linq.Enumerable::Distinct(class [mscorlib]System.Collections.Generic.IEnumerable`1) - IL_00ee: call int32 [System.Linq]System.Linq.Enumerable::Count(class [mscorlib]System.Collections.Generic.IEnumerable`1) - IL_00f3: ldc.i4.1 - IL_00f4: beq.s IL_0146 - - IL_00f6: ldstr "FAILED: The local on the stack for CalleeIsOdd3 sh" - + "ifted. (should have always the same address)" - IL_00fb: call void [System.Console]System.Console::WriteLine(string) - IL_0100: ldsfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::oddList - IL_0105: callvirt instance valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator class [mscorlib]System.Collections.Generic.List`1::GetEnumerator() - IL_010a: stloc.s CS$5$0001 - .try - { - IL_010c: br.s IL_0126 - - IL_010e: ldloca.s CS$5$0001 - IL_0110: call instance !0 valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator::get_Current() - IL_0115: stloc.2 - IL_0116: ldstr "0x{0:x8}" - IL_011b: ldloc.2 - IL_011c: box [mscorlib]System.Int64 - IL_0121: call void [System.Console]System.Console::WriteLine(string, - object) - IL_0126: ldloca.s CS$5$0001 - IL_0128: call instance bool valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator::MoveNext() - IL_012d: brtrue.s IL_010e + IL_006f: ldstr "Execution finished - Test " + IL_0074: ldsfld int32 TailcallVerify.Condition21::Result + IL_0079: ldc.i4.s 100 + IL_007b: beq.s IL_0084 - IL_012f: leave.s IL_013f + IL_007d: ldstr "FAILED" + IL_0082: br.s IL_0089 - } // end .try - finally - { - IL_0131: ldloca.s CS$5$0001 - IL_0133: constrained. valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator - IL_0139: callvirt instance void [mscorlib]System.IDisposable::Dispose() - IL_013e: endfinally - } // end handler - IL_013f: ldc.i4.s 101 - IL_0141: stsfld int32 TailcallVerify.Condition21::Result - IL_0146: ldstr "Execution finished - Test " - IL_014b: ldsfld int32 TailcallVerify.Condition21::Result - IL_0150: ldc.i4.s 100 - IL_0152: beq.s IL_015b - - IL_0154: ldstr "FAILED" - IL_0159: br.s IL_0160 - - IL_015b: ldstr "PASSED" - IL_0160: call string [mscorlib]System.String::Concat(string, + IL_0084: ldstr "PASSED" + IL_0089: call string [mscorlib]System.String::Concat(string, string) - IL_0165: call void [System.Console]System.Console::WriteLine(string) - IL_016a: ldsfld int32 TailcallVerify.Condition21::Result - IL_016f: ret - } // end of method Condition21::Test2 + IL_008e: call void [System.Console]System.Console::WriteLine(string) + IL_0093: ldsfld int32 TailcallVerify.Condition21::Result + IL_0098: ret + } // end of method Condition21::Test6 - .method private hidebysig static void Caller2() cil managed + .method private hidebysig static void Caller6() cil managed { - // Code size 66 (0x42) - .maxstack 4 - .locals init ([0] valuetype TailcallVerify.ValueType3Bytes CS$0$0000) + // Code size 52 (0x34) + .maxstack 8 IL_0000: ldc.i4.0 IL_0001: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) IL_0006: callvirt instance class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Diagnostics.StackFrame::GetMethod() @@ -3939,2547 +3051,543 @@ IL_001a: ldc.i4.m1 IL_001b: bne.un.s IL_002e - IL_001d: ldstr "FAILED: Caller3 was inlined..." + IL_001d: ldstr "Failed, Method was inlined..." IL_0022: call void [System.Console]System.Console::WriteLine(string) IL_0027: ldc.i4.s 101 IL_0029: stsfld int32 TailcallVerify.Condition21::Result - IL_002e: ldc.i4.s 20 - IL_0030: ldc.i4.1 - IL_0031: ldc.i4.2 - IL_0032: ldloca.s CS$0$0000 - IL_0034: initobj TailcallVerify.ValueType3Bytes - IL_003a: ldloc.0 -// tail. // tail.call, pop, ret sequence is never valid for .NET Core (but is accepted by .NET x64) - IL_003b: call valuetype TailcallVerify.ValueType3Bytes TailcallVerify.Condition21::CalleeIsEven2(int32, - int32, - int32, - valuetype TailcallVerify.ValueType3Bytes) - IL_0040: pop - IL_0041: ret - } // end of method Condition21::Caller2 - - .method private hidebysig static valuetype TailcallVerify.ValueType3Bytes - CalleeIsOdd2(int32 i, - int32 i2, - int32 i3, - int32 i4, - int32 i5, - valuetype TailcallVerify.ValueType3Bytes v3, - int32 i6, - int32 i7, - int32 i8, - int32 i9, - int32 i10, - int32 i11, - int32 i12) cil managed - { - // Code size 116 (0x74) - .maxstack 4 - .locals init ([0] int32 data, - [1] int32* pData, - [2] native int p, - [3] valuetype TailcallVerify.ValueType3Bytes CS$0$0000) - IL_0000: ldloca.s data - IL_0002: conv.u - IL_0003: stloc.1 - IL_0004: ldloca.s p - IL_0006: ldloc.1 - IL_0007: call instance void [mscorlib]System.IntPtr::.ctor(void*) - IL_000c: ldsfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::oddList - IL_0011: ldloca.s p - IL_0013: call instance int64 [mscorlib]System.IntPtr::ToInt64() - IL_0018: callvirt instance void class [mscorlib]System.Collections.Generic.List`1::Add(!0) - IL_001d: ldc.i4.0 - IL_001e: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) - IL_0023: callvirt instance class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Diagnostics.StackFrame::GetMethod() - IL_0028: callvirt instance string [mscorlib]System.Reflection.MemberInfo::get_Name() - IL_002d: ldstr "Callee" - IL_0032: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_0037: ldc.i4.m1 - IL_0038: bne.un.s IL_004b - - IL_003a: ldstr "FAILED: CalleeIsOdd3 was inlined..." - IL_003f: call void [System.Console]System.Console::WriteLine(string) - IL_0044: ldc.i4.s 101 - IL_0046: stsfld int32 TailcallVerify.Condition21::Result - IL_004b: ldarg.0 - IL_004c: brtrue.s IL_0067 - - IL_004e: ldstr "IsOdd" - IL_0053: call void [System.Console]System.Console::WriteLine(string) - IL_0058: ldc.i4.1 - IL_0059: ldarg.0 - IL_005a: div - IL_005b: starg.s i - IL_005d: ldloca.s CS$0$0000 - IL_005f: initobj TailcallVerify.ValueType3Bytes - IL_0065: ldloc.3 - IL_0066: ret - - IL_0067: ldarg.0 - IL_0068: ldc.i4.1 - IL_0069: sub - IL_006a: ldarg.1 - IL_006b: ldarg.2 - IL_006c: ldarg.s v3 - IL_006e: tail. call valuetype TailcallVerify.ValueType3Bytes TailcallVerify.Condition21::CalleeIsEven2(int32, - int32, - int32, - valuetype TailcallVerify.ValueType3Bytes) - IL_0073: ret - } // end of method Condition21::CalleeIsOdd2 + IL_002e: ldftn void TailcallVerify.Condition21::Callee6() + tail. calli void() + IL_0033: ret + } // end of method Condition21::Caller6 - .method private hidebysig static valuetype TailcallVerify.ValueType3Bytes - CalleeIsEven2(int32 i, - int32 i2, - int32 i3, - valuetype TailcallVerify.ValueType3Bytes v3) cil managed + .method private hidebysig static void Callee6() cil managed noinlining { - // Code size 124 (0x7c) - .maxstack 13 - .locals init ([0] int32 data, - [1] int32* pData, - [2] native int p, - [3] valuetype TailcallVerify.ValueType3Bytes CS$0$0000) - IL_0000: ldloca.s data - IL_0002: conv.u - IL_0003: stloc.1 - IL_0004: ldloca.s p - IL_0006: ldloc.1 - IL_0007: call instance void [mscorlib]System.IntPtr::.ctor(void*) - IL_000c: ldsfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::evenList - IL_0011: ldloca.s p - IL_0013: call instance int64 [mscorlib]System.IntPtr::ToInt64() - IL_0018: callvirt instance void class [mscorlib]System.Collections.Generic.List`1::Add(!0) - IL_001d: ldc.i4.0 - IL_001e: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) - IL_0023: callvirt instance class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Diagnostics.StackFrame::GetMethod() - IL_0028: callvirt instance string [mscorlib]System.Reflection.MemberInfo::get_Name() - IL_002d: ldstr "Callee" - IL_0032: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_0037: ldc.i4.m1 - IL_0038: bne.un.s IL_004b - - IL_003a: ldstr "FAILED: CalleeIsEven3 was inlined..." - IL_003f: call void [System.Console]System.Console::WriteLine(string) - IL_0044: ldc.i4.s 101 - IL_0046: stsfld int32 TailcallVerify.Condition21::Result - IL_004b: ldarg.0 - IL_004c: brtrue.s IL_0067 - - IL_004e: ldstr "IsEven" - IL_0053: call void [System.Console]System.Console::WriteLine(string) - IL_0058: ldc.i4.1 - IL_0059: ldarg.0 - IL_005a: div - IL_005b: starg.s i - IL_005d: ldloca.s CS$0$0000 - IL_005f: initobj TailcallVerify.ValueType3Bytes - IL_0065: ldloc.3 - IL_0066: ret - - IL_0067: ldarg.0 - IL_0068: ldc.i4.1 - IL_0069: sub - IL_006a: ldarg.1 - IL_006b: ldarg.2 - IL_006c: ldarg.2 - IL_006d: ldarg.1 - IL_006e: ldarg.3 - IL_006f: ldarg.2 - IL_0070: ldarg.1 - IL_0071: ldarg.0 - IL_0072: ldc.i4.3 - IL_0073: ldc.i4.4 - IL_0074: ldc.i4.5 - IL_0075: ldc.i4.6 - IL_0076: tail. call valuetype TailcallVerify.ValueType3Bytes TailcallVerify.Condition21::CalleeIsOdd2(int32, - int32, - int32, - int32, - int32, - valuetype TailcallVerify.ValueType3Bytes, - int32, - int32, - int32, - int32, - int32, - int32, - int32) - IL_007b: ret - } // end of method Condition21::CalleeIsEven2 + // Code size 11 (0xb) + .maxstack 8 + IL_0000: ldc.i4.1 + IL_0001: volatile. + IL_0003: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition21::zero + IL_0008: div + IL_0009: pop + IL_000a: ret + } // end of method Condition21::Callee6 - .method public hidebysig static int32 Test3() cil managed nooptimization + .method public hidebysig static int32 Test7() cil managed nooptimization { - // Code size 394 (0x18a) + // Code size 155 (0x9b) .maxstack 3 - .locals init ([0] class [System.Threading.Thread]System.Threading.Thread t1, - [1] class [mscorlib]System.Exception e, - [2] int64 l, - [3] int64 V_3, - [4] valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator CS$5$0000, - [5] valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator CS$5$0001) - IL_0000: ldstr "Executing Condition21.Test3 - Caller: Arguments: N" - + "one - ReturnType: void; CalleeIsOdd3: Arguments: int, int, int, int, 3 " - + "byte struct - ReturnType: 3 byte struct; CalleeIsEven3: Arguments: int," - + " int, int, int, 3 byte struct - ReturnType: 3 byte struct;" + .locals init ([0] class [mscorlib]System.Exception e) + IL_0000: ldstr "Executing Condition21.Test7 - Caller: Arguments: " + + "Int32 - ReturnType: Int32; Callee: Arguments: Int32 - ReturnType: Int32" IL_0005: call void [System.Console]System.Console::WriteLine(string) IL_000a: ldc.i4.s 100 IL_000c: stsfld int32 TailcallVerify.Condition21::Result - IL_0011: ldsfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::evenList - IL_0016: callvirt instance void class [mscorlib]System.Collections.Generic.List`1::Clear() - IL_001b: ldsfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::oddList - IL_0020: callvirt instance void class [mscorlib]System.Collections.Generic.List`1::Clear() .try { - IL_0025: ldnull - IL_0026: ldftn void TailcallVerify.Condition21::Caller3() - IL_002c: newobj instance void [System.Threading.Thread]System.Threading.ThreadStart::.ctor(object, - native int) - IL_0031: newobj instance void [System.Threading.Thread]System.Threading.Thread::.ctor(class [System.Threading.Thread]System.Threading.ThreadStart) - IL_0036: stloc.0 - IL_0037: ldloc.0 - IL_0038: callvirt instance void [System.Threading.Thread]System.Threading.Thread::Start() - IL_003d: ldloc.0 - IL_003e: callvirt instance void [System.Threading.Thread]System.Threading.Thread::Join() - IL_0043: leave.s IL_009c + IL_0011: ldc.i4.0 + IL_0012: call int32 TailcallVerify.Condition21::Caller7(int32) + IL_0017: pop + IL_0018: leave.s IL_0071 } // end .try catch [mscorlib]System.Exception { - IL_0045: stloc.1 - IL_0046: ldloc.1 - IL_0047: isinst [mscorlib]System.DivideByZeroException - IL_004c: brtrue.s IL_0057 + IL_001a: stloc.0 + IL_001b: ldloc.0 + IL_001c: isinst [mscorlib]System.DivideByZeroException + IL_0021: brtrue.s IL_002c - IL_004e: ldc.i4.s 101 - IL_0050: stsfld int32 TailcallVerify.Condition21::Result - IL_0055: rethrow - IL_0057: ldloc.1 - IL_0058: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_005d: ldstr "Caller" - IL_0062: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_0067: ldc.i4.m1 - IL_0068: beq.s IL_009a + IL_0023: ldc.i4.s 101 + IL_0025: stsfld int32 TailcallVerify.Condition21::Result + IL_002a: rethrow + IL_002c: ldloc.0 + IL_002d: callvirt instance string [mscorlib]System.Exception::get_StackTrace() + IL_0032: ldstr "Caller" + IL_0037: callvirt instance int32 [mscorlib]System.String::IndexOf(string) + IL_003c: ldc.i4.m1 + IL_003d: beq.s IL_006f - IL_006a: ldstr "FAILED: Found the word 'Caller' in the stacktrace." - IL_006f: call void [System.Console]System.Console::WriteLine(string) - IL_0074: ldstr "------------------------------------------------" - IL_0079: call void [System.Console]System.Console::WriteLine(string) - IL_007e: call void [System.Console]System.Console::WriteLine() - IL_0083: ldloc.1 - IL_0084: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_0089: call void [System.Console]System.Console::WriteLine(string) - IL_008e: call void [System.Console]System.Console::WriteLine() - IL_0093: ldc.i4.s 101 - IL_0095: stsfld int32 TailcallVerify.Condition21::Result - IL_009a: leave.s IL_009c + IL_003f: ldstr "FAILED: Found the word 'Caller' in the stacktrace." + IL_0044: call void [System.Console]System.Console::WriteLine(string) + IL_0049: ldstr "------------------------------------------------" + IL_004e: call void [System.Console]System.Console::WriteLine(string) + IL_0053: call void [System.Console]System.Console::WriteLine() + IL_0058: ldloc.0 + IL_0059: callvirt instance string [mscorlib]System.Exception::get_StackTrace() + IL_005e: call void [System.Console]System.Console::WriteLine(string) + IL_0063: call void [System.Console]System.Console::WriteLine() + IL_0068: ldc.i4.s 101 + IL_006a: stsfld int32 TailcallVerify.Condition21::Result + IL_006f: leave.s IL_0071 } // end handler - IL_009c: ldsfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::evenList - IL_00a1: call class [mscorlib]System.Collections.Generic.IEnumerable`1 [System.Linq]System.Linq.Enumerable::Distinct(class [mscorlib]System.Collections.Generic.IEnumerable`1) - IL_00a6: call int32 [System.Linq]System.Linq.Enumerable::Count(class [mscorlib]System.Collections.Generic.IEnumerable`1) - IL_00ab: ldc.i4.1 - IL_00ac: beq.s IL_00fe + IL_0071: ldstr "Execution finished - Test " + IL_0076: ldsfld int32 TailcallVerify.Condition21::Result + IL_007b: ldc.i4.s 100 + IL_007d: beq.s IL_0086 - IL_00ae: ldstr "FAILED: The local on the stack for CalleeIsEven3 s" - + "hifted. (should have always the same address)" - IL_00b3: call void [System.Console]System.Console::WriteLine(string) - IL_00b8: ldsfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::evenList - IL_00bd: callvirt instance valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator class [mscorlib]System.Collections.Generic.List`1::GetEnumerator() - IL_00c2: stloc.s CS$5$0000 - .try - { - IL_00c4: br.s IL_00de + IL_007f: ldstr "FAILED" + IL_0084: br.s IL_008b - IL_00c6: ldloca.s CS$5$0000 - IL_00c8: call instance !0 valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator::get_Current() - IL_00cd: stloc.2 - IL_00ce: ldstr "0x{0:x8}" - IL_00d3: ldloc.2 - IL_00d4: box [mscorlib]System.Int64 - IL_00d9: call void [System.Console]System.Console::WriteLine(string, - object) - IL_00de: ldloca.s CS$5$0000 - IL_00e0: call instance bool valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator::MoveNext() - IL_00e5: brtrue.s IL_00c6 + IL_0086: ldstr "PASSED" + IL_008b: call string [mscorlib]System.String::Concat(string, + string) + IL_0090: call void [System.Console]System.Console::WriteLine(string) + IL_0095: ldsfld int32 TailcallVerify.Condition21::Result + IL_009a: ret + } // end of method Condition21::Test7 - IL_00e7: leave.s IL_00f7 - - } // end .try - finally - { - IL_00e9: ldloca.s CS$5$0000 - IL_00eb: constrained. valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator - IL_00f1: callvirt instance void [mscorlib]System.IDisposable::Dispose() - IL_00f6: endfinally - } // end handler - IL_00f7: ldc.i4.s 101 - IL_00f9: stsfld int32 TailcallVerify.Condition21::Result - IL_00fe: ldsfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::oddList - IL_0103: call class [mscorlib]System.Collections.Generic.IEnumerable`1 [System.Linq]System.Linq.Enumerable::Distinct(class [mscorlib]System.Collections.Generic.IEnumerable`1) - IL_0108: call int32 [System.Linq]System.Linq.Enumerable::Count(class [mscorlib]System.Collections.Generic.IEnumerable`1) - IL_010d: ldc.i4.1 - IL_010e: beq.s IL_0160 - - IL_0110: ldstr "FAILED: The local on the stack for CalleeIsOdd3 sh" - + "ifted. (should have always the same address)" - IL_0115: call void [System.Console]System.Console::WriteLine(string) - IL_011a: ldsfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::oddList - IL_011f: callvirt instance valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator class [mscorlib]System.Collections.Generic.List`1::GetEnumerator() - IL_0124: stloc.s CS$5$0001 - .try - { - IL_0126: br.s IL_0140 - - IL_0128: ldloca.s CS$5$0001 - IL_012a: call instance !0 valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator::get_Current() - IL_012f: stloc.3 - IL_0130: ldstr "0x{0:x8}" - IL_0135: ldloc.3 - IL_0136: box [mscorlib]System.Int64 - IL_013b: call void [System.Console]System.Console::WriteLine(string, - object) - IL_0140: ldloca.s CS$5$0001 - IL_0142: call instance bool valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator::MoveNext() - IL_0147: brtrue.s IL_0128 - - IL_0149: leave.s IL_0159 - - } // end .try - finally - { - IL_014b: ldloca.s CS$5$0001 - IL_014d: constrained. valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator - IL_0153: callvirt instance void [mscorlib]System.IDisposable::Dispose() - IL_0158: endfinally - } // end handler - IL_0159: ldc.i4.s 101 - IL_015b: stsfld int32 TailcallVerify.Condition21::Result - IL_0160: ldstr "Execution finished - Test " - IL_0165: ldsfld int32 TailcallVerify.Condition21::Result - IL_016a: ldc.i4.s 100 - IL_016c: beq.s IL_0175 - - IL_016e: ldstr "FAILED" - IL_0173: br.s IL_017a - - IL_0175: ldstr "PASSED" - IL_017a: call string [mscorlib]System.String::Concat(string, - string) - IL_017f: call void [System.Console]System.Console::WriteLine(string) - IL_0184: ldsfld int32 TailcallVerify.Condition21::Result - IL_0189: ret - } // end of method Condition21::Test3 - - .method private hidebysig static void Caller3() cil managed - { - // Code size 73 (0x49) - .maxstack 6 - .locals init ([0] valuetype TailcallVerify.ValueType3Bytes CS$0$0000) - IL_0000: ldc.i4.0 - IL_0001: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) - IL_0006: callvirt instance class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Diagnostics.StackFrame::GetMethod() - IL_000b: callvirt instance string [mscorlib]System.Reflection.MemberInfo::get_Name() - IL_0010: ldstr "Caller" - IL_0015: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_001a: ldc.i4.m1 - IL_001b: bne.un.s IL_002e - - IL_001d: ldstr "FAILED: Caller3 was inlined..." - IL_0022: call void [System.Console]System.Console::WriteLine(string) - IL_0027: ldc.i4.s 101 - IL_0029: stsfld int32 TailcallVerify.Condition21::Result - .try - { - IL_002e: ldc.i4.s 20 - IL_0030: ldc.i4.1 - IL_0031: ldc.i4.2 - IL_0032: ldc.i4.3 - IL_0033: ldc.i4.4 - IL_0034: ldloca.s CS$0$0000 - IL_0036: initobj TailcallVerify.ValueType3Bytes - IL_003c: ldloc.0 - IL_003d: call valuetype TailcallVerify.ValueType3Bytes TailcallVerify.Condition21::CallerIsOdd3(int32, - int32, - int32, - int32, - int32, - valuetype TailcallVerify.ValueType3Bytes) - IL_0042: pop - IL_0043: leave.s IL_0048 - - } // end .try - catch [mscorlib]System.DivideByZeroException - { - IL_0045: pop - IL_0046: leave.s IL_0048 - - } // end handler - IL_0048: ret - } // end of method Condition21::Caller3 - - .method private hidebysig static valuetype TailcallVerify.ValueType3Bytes - CallerIsOdd3(int32 i, - int32 i2, - int32 i3, - int32 i4, - int32 i5, - valuetype TailcallVerify.ValueType3Bytes v3) cil managed - { - // Code size 14 (0xe) - .maxstack 8 - IL_0000: ldarg.0 - IL_0001: ldarg.1 - IL_0002: ldarg.2 - IL_0003: ldarg.3 - IL_0004: ldarg.s i5 - IL_0006: ldarg.s v3 - IL_0008: tail. call valuetype TailcallVerify.ValueType3Bytes TailcallVerify.Condition21::CalleeIsOdd3(int32, - int32, - int32, - int32, - int32, - valuetype TailcallVerify.ValueType3Bytes) - IL_000d: ret - } // end of method Condition21::CallerIsOdd3 - - .method private hidebysig static valuetype TailcallVerify.ValueType3Bytes - CalleeIsOdd3(int32 i, - int32 i2, - int32 i3, - int32 i4, - int32 i5, - valuetype TailcallVerify.ValueType3Bytes v3) cil managed - { - // Code size 109 (0x6d) - .maxstack 6 - .locals init ([0] int32 data, - [1] int32* pData, - [2] native int p, - [3] valuetype TailcallVerify.ValueType3Bytes CS$0$0000) - IL_0000: ldloca.s data - IL_0002: conv.u - IL_0003: stloc.1 - IL_0004: ldloca.s p - IL_0006: ldloc.1 - IL_0007: call instance void [mscorlib]System.IntPtr::.ctor(void*) - IL_000c: ldsfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::oddList - IL_0011: ldloca.s p - IL_0013: call instance int64 [mscorlib]System.IntPtr::ToInt64() - IL_0018: callvirt instance void class [mscorlib]System.Collections.Generic.List`1::Add(!0) - IL_001d: ldc.i4.0 - IL_001e: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) - IL_0023: callvirt instance class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Diagnostics.StackFrame::GetMethod() - IL_0028: callvirt instance string [mscorlib]System.Reflection.MemberInfo::get_Name() - IL_002d: ldstr "Callee" - IL_0032: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_0037: ldc.i4.m1 - IL_0038: bne.un.s IL_004b - - IL_003a: ldstr "FAILED: CalleeIsOdd3 was inlined..." - IL_003f: call void [System.Console]System.Console::WriteLine(string) - IL_0044: ldc.i4.s 101 - IL_0046: stsfld int32 TailcallVerify.Condition21::Result - IL_004b: ldarg.0 - IL_004c: brtrue.s IL_005d - - IL_004e: ldc.i4.1 - IL_004f: ldarg.0 - IL_0050: div - IL_0051: starg.s i - IL_0053: ldloca.s CS$0$0000 - IL_0055: initobj TailcallVerify.ValueType3Bytes - IL_005b: ldloc.3 - IL_005c: ret - - IL_005d: ldarg.0 - IL_005e: ldc.i4.1 - IL_005f: sub - IL_0060: ldarg.1 - IL_0061: ldarg.2 - IL_0062: ldarg.3 - IL_0063: ldarg.s i5 - IL_0065: ldarg.s v3 - IL_0067: tail. call valuetype TailcallVerify.ValueType3Bytes TailcallVerify.Condition21::CalleeIsEven3(int32, - int32, - int32, - int32, - int32, - valuetype TailcallVerify.ValueType3Bytes) - IL_006c: ret - } // end of method Condition21::CalleeIsOdd3 - - .method private hidebysig static valuetype TailcallVerify.ValueType3Bytes - CalleeIsEven3(int32 i, - int32 i2, - int32 i3, - int32 i4, - int32 i5, - valuetype TailcallVerify.ValueType3Bytes v3) cil managed - { - // Code size 109 (0x6d) - .maxstack 6 - .locals init ([0] int32 data, - [1] int32* pData, - [2] native int p, - [3] valuetype TailcallVerify.ValueType3Bytes CS$0$0000) - IL_0000: ldloca.s data - IL_0002: conv.u - IL_0003: stloc.1 - IL_0004: ldloca.s p - IL_0006: ldloc.1 - IL_0007: call instance void [mscorlib]System.IntPtr::.ctor(void*) - IL_000c: ldsfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::evenList - IL_0011: ldloca.s p - IL_0013: call instance int64 [mscorlib]System.IntPtr::ToInt64() - IL_0018: callvirt instance void class [mscorlib]System.Collections.Generic.List`1::Add(!0) - IL_001d: ldc.i4.0 - IL_001e: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) - IL_0023: callvirt instance class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Diagnostics.StackFrame::GetMethod() - IL_0028: callvirt instance string [mscorlib]System.Reflection.MemberInfo::get_Name() - IL_002d: ldstr "Callee" - IL_0032: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_0037: ldc.i4.m1 - IL_0038: bne.un.s IL_004b - - IL_003a: ldstr "FAILED: CalleeIsEven3 was inlined..." - IL_003f: call void [System.Console]System.Console::WriteLine(string) - IL_0044: ldc.i4.s 101 - IL_0046: stsfld int32 TailcallVerify.Condition21::Result - IL_004b: ldarg.0 - IL_004c: brtrue.s IL_005d - - IL_004e: ldc.i4.1 - IL_004f: ldarg.0 - IL_0050: div - IL_0051: starg.s i - IL_0053: ldloca.s CS$0$0000 - IL_0055: initobj TailcallVerify.ValueType3Bytes - IL_005b: ldloc.3 - IL_005c: ret - - IL_005d: ldarg.0 - IL_005e: ldc.i4.1 - IL_005f: sub - IL_0060: ldarg.1 - IL_0061: ldarg.2 - IL_0062: ldarg.3 - IL_0063: ldarg.s i5 - IL_0065: ldarg.s v3 - IL_0067: tail. call valuetype TailcallVerify.ValueType3Bytes TailcallVerify.Condition21::CalleeIsOdd3(int32, - int32, - int32, - int32, - int32, - valuetype TailcallVerify.ValueType3Bytes) - IL_006c: ret - } // end of method Condition21::CalleeIsEven3 - - .method public hidebysig static int32 Test4() cil managed nooptimization - { - // Code size 269 (0x10d) - .maxstack 4 - .locals init ([0] int32 i, - [1] int32 V_1) - IL_0000: ldstr "Executing Condition21.Test4 - Verifying helper fra" - + "me location on the stack." - IL_0005: call void [System.Console]System.Console::WriteLine(string) - IL_000a: ldc.i4.s 100 - IL_000c: stsfld int32 TailcallVerify.Condition21::Result - IL_0011: ldsfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::oddList - IL_0016: callvirt instance void class [mscorlib]System.Collections.Generic.List`1::Clear() - .try - { - IL_001b: call void TailcallVerify.Condition21::Caller4() - IL_0020: leave.s IL_0025 - - } // end .try - catch [mscorlib]System.Exception - { - IL_0022: pop - IL_0023: leave.s IL_0025 - - } // end handler - IL_0025: ldc.i4.0 - IL_0026: stloc.0 - IL_0027: br.s IL_006a - - IL_0029: ldsfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::oddList - IL_002e: ldloc.0 - IL_002f: callvirt instance !0 class [mscorlib]System.Collections.Generic.List`1::get_Item(int32) - IL_0034: ldsfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::oddList - IL_0039: ldloc.0 - IL_003a: ldc.i4.1 - IL_003b: add - IL_003c: callvirt instance !0 class [mscorlib]System.Collections.Generic.List`1::get_Item(int32) - IL_0041: bne.un.s IL_005f - - IL_0043: ldsfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::oddList - IL_0048: ldloc.0 - IL_0049: ldc.i4.1 - IL_004a: add - IL_004b: callvirt instance !0 class [mscorlib]System.Collections.Generic.List`1::get_Item(int32) - IL_0050: ldsfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::oddList - IL_0055: ldloc.0 - IL_0056: ldc.i4.2 - IL_0057: add - IL_0058: callvirt instance !0 class [mscorlib]System.Collections.Generic.List`1::get_Item(int32) - IL_005d: beq.s IL_0066 - - IL_005f: ldc.i4.s 101 - IL_0061: stsfld int32 TailcallVerify.Condition21::Result - IL_0066: ldloc.0 - IL_0067: ldc.i4.3 - IL_0068: add - IL_0069: stloc.0 - IL_006a: ldloc.0 - IL_006b: ldc.i4.2 - IL_006c: add - IL_006d: ldsfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::oddList - IL_0072: callvirt instance int32 class [mscorlib]System.Collections.Generic.List`1::get_Count() - IL_0077: blt.s IL_0029 - - IL_0079: ldsfld int32 TailcallVerify.Condition21::Result - IL_007e: ldc.i4.s 100 - IL_0080: beq.s IL_00e3 - - IL_0082: ldstr "The following shows a list of stack addresses of a" - + " local on the stack." - IL_0087: call void [System.Console]System.Console::WriteLine(string) - IL_008c: ldstr "You should see the same address three times before" - + " it decreases and repeats again." - IL_0091: call void [System.Console]System.Console::WriteLine(string) - IL_0096: ldstr "This happens because the call chain looks like thi" - + "s E->E->E->E->O->O->O->E->E->E->E->O->O->O" - IL_009b: call void [System.Console]System.Console::WriteLine(string) - IL_00a0: ldstr "where E is a method where tailcalls are not allowe" - + "d (it's synchronized) and O is a" - IL_00a5: call void [System.Console]System.Console::WriteLine(string) - IL_00aa: ldstr "method that gets tailcall'ed." - IL_00af: call void [System.Console]System.Console::WriteLine(string) - IL_00b4: ldc.i4.0 - IL_00b5: stloc.1 - IL_00b6: br.s IL_00d6 - - IL_00b8: ldstr "0x{0:x8}" - IL_00bd: ldsfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::oddList - IL_00c2: ldloc.1 - IL_00c3: callvirt instance !0 class [mscorlib]System.Collections.Generic.List`1::get_Item(int32) - IL_00c8: box [mscorlib]System.Int64 - IL_00cd: call void [System.Console]System.Console::WriteLine(string, - object) - IL_00d2: ldloc.1 - IL_00d3: ldc.i4.1 - IL_00d4: add - IL_00d5: stloc.1 - IL_00d6: ldloc.1 - IL_00d7: ldsfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::oddList - IL_00dc: callvirt instance int32 class [mscorlib]System.Collections.Generic.List`1::get_Count() - IL_00e1: blt.s IL_00b8 - - IL_00e3: ldstr "Execution finished - Test " - IL_00e8: ldsfld int32 TailcallVerify.Condition21::Result - IL_00ed: ldc.i4.s 100 - IL_00ef: beq.s IL_00f8 - - IL_00f1: ldstr "FAILED" - IL_00f6: br.s IL_00fd - - IL_00f8: ldstr "PASSED" - IL_00fd: call string [mscorlib]System.String::Concat(string, - string) - IL_0102: call void [System.Console]System.Console::WriteLine(string) - IL_0107: ldsfld int32 TailcallVerify.Condition21::Result - IL_010c: ret - } // end of method Condition21::Test4 - - .method private hidebysig static void Caller4() cil managed - { - // Code size 71 (0x47) - .maxstack 6 - .locals init ([0] valuetype TailcallVerify.ValueType3Bytes CS$0$0000) - IL_0000: ldc.i4.0 - IL_0001: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) - IL_0006: callvirt instance class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Diagnostics.StackFrame::GetMethod() - IL_000b: callvirt instance string [mscorlib]System.Reflection.MemberInfo::get_Name() - IL_0010: ldstr "Caller" - IL_0015: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_001a: ldc.i4.m1 - IL_001b: bne.un.s IL_002e - - IL_001d: ldstr "FAILED: Caller4 was inlined..." - IL_0022: call void [System.Console]System.Console::WriteLine(string) - IL_0027: ldc.i4.s 101 - IL_0029: stsfld int32 TailcallVerify.Condition21::Result - IL_002e: ldc.i4 0xc8 - IL_0033: ldc.i4.1 - IL_0034: ldc.i4.2 - IL_0035: ldc.i4.3 - IL_0036: ldc.i4.4 - IL_0037: ldloca.s CS$0$0000 - IL_0039: initobj TailcallVerify.ValueType3Bytes - IL_003f: ldloc.0 -// tail. // tail.call, pop, ret sequence is never valid for .NET Core (but is accepted by .NET x64) - IL_0040: call valuetype TailcallVerify.ValueType3Bytes TailcallVerify.Condition21::CalleeE4(int32, - int32, - int32, - int32, - int32, - valuetype TailcallVerify.ValueType3Bytes) - IL_0045: pop - IL_0046: ret - } // end of method Condition21::Caller4 - - .method private hidebysig static valuetype TailcallVerify.ValueType3Bytes - CalleeE4(int32 i, - int32 i2, - int32 i3, - int32 i4, - int32 i5, - valuetype TailcallVerify.ValueType3Bytes v3) cil managed synchronized noinlining - { - // Code size 128 (0x80) - .maxstack 6 - .locals init ([0] valuetype TailcallVerify.ValueType3Bytes CS$0$0000) - IL_0000: ldc.i4.0 - IL_0001: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) - IL_0006: callvirt instance class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Diagnostics.StackFrame::GetMethod() - IL_000b: callvirt instance string [mscorlib]System.Reflection.MemberInfo::get_Name() - IL_0010: ldstr "Callee" - IL_0015: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_001a: ldc.i4.m1 - IL_001b: bne.un.s IL_002e - - IL_001d: ldstr "FAILED: CalleeE4 was inlined..." - IL_0022: call void [System.Console]System.Console::WriteLine(string) - IL_0027: ldc.i4.s 101 - IL_0029: stsfld int32 TailcallVerify.Condition21::Result - IL_002e: ldarg.0 - IL_002f: brtrue.s IL_0046 - - IL_0031: ldarg.0 - IL_0032: volatile. - IL_0034: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition21::zero - IL_0039: div - IL_003a: starg.s i - IL_003c: ldloca.s CS$0$0000 - IL_003e: initobj TailcallVerify.ValueType3Bytes - IL_0044: ldloc.0 - IL_0045: ret - - IL_0046: ldsfld int32 TailcallVerify.Condition21::counterE4 - IL_004b: ldc.i4.0 - IL_004c: ble.s IL_006a - - IL_004e: ldsfld int32 TailcallVerify.Condition21::counterE4 - IL_0053: ldc.i4.1 - IL_0054: sub - IL_0055: stsfld int32 TailcallVerify.Condition21::counterE4 - IL_005a: ldarg.0 - IL_005b: ldc.i4.1 - IL_005c: sub - IL_005d: ldarg.1 - IL_005e: ldarg.2 - IL_005f: ldarg.3 - IL_0060: ldarg.s i5 - IL_0062: ldarg.s v3 - IL_0064: tail. call valuetype TailcallVerify.ValueType3Bytes TailcallVerify.Condition21::CalleeE4(int32, - int32, - int32, - int32, - int32, - valuetype TailcallVerify.ValueType3Bytes) - IL_0069: ret - - IL_006a: ldc.i4.3 - IL_006b: stsfld int32 TailcallVerify.Condition21::counterE4 - IL_0070: ldarg.0 - IL_0071: ldc.i4.1 - IL_0072: sub - IL_0073: ldarg.1 - IL_0074: ldarg.2 - IL_0075: ldarg.3 - IL_0076: ldarg.s i5 - IL_0078: ldarg.s v3 - IL_007a: tail. call valuetype TailcallVerify.ValueType3Bytes TailcallVerify.Condition21::CalleeO4(int32, - int32, - int32, - int32, - int32, - valuetype TailcallVerify.ValueType3Bytes) - IL_007f: ret - } // end of method Condition21::CalleeE4 - - .method private hidebysig static valuetype TailcallVerify.ValueType3Bytes - CalleeO4(int32 i, - int32 i2, - int32 i3, - int32 i4, - int32 i5, - valuetype TailcallVerify.ValueType3Bytes v3) cil managed - { - // Code size 157 (0x9d) - .maxstack 6 - .locals init ([0] int32 data, - [1] int32* pData, - [2] native int p, - [3] valuetype TailcallVerify.ValueType3Bytes CS$0$0000) - IL_0000: ldloca.s data - IL_0002: conv.u - IL_0003: stloc.1 - IL_0004: ldloca.s p - IL_0006: ldloc.1 - IL_0007: call instance void [mscorlib]System.IntPtr::.ctor(void*) - IL_000c: ldsfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::oddList - IL_0011: ldloca.s p - IL_0013: call instance int64 [mscorlib]System.IntPtr::ToInt64() - IL_0018: callvirt instance void class [mscorlib]System.Collections.Generic.List`1::Add(!0) - IL_001d: ldc.i4.0 - IL_001e: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) - IL_0023: callvirt instance class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Diagnostics.StackFrame::GetMethod() - IL_0028: callvirt instance string [mscorlib]System.Reflection.MemberInfo::get_Name() - IL_002d: ldstr "Callee" - IL_0032: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_0037: ldc.i4.m1 - IL_0038: bne.un.s IL_004b - - IL_003a: ldstr "FAILED: CalleeO4 was inlined..." - IL_003f: call void [System.Console]System.Console::WriteLine(string) - IL_0044: ldc.i4.s 101 - IL_0046: stsfld int32 TailcallVerify.Condition21::Result - IL_004b: ldarg.0 - IL_004c: brtrue.s IL_0063 - - IL_004e: ldarg.0 - IL_004f: volatile. - IL_0051: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition21::zero - IL_0056: div - IL_0057: starg.s i - IL_0059: ldloca.s CS$0$0000 - IL_005b: initobj TailcallVerify.ValueType3Bytes - IL_0061: ldloc.3 - IL_0062: ret - - IL_0063: ldsfld int32 TailcallVerify.Condition21::counterO4 - IL_0068: ldc.i4.0 - IL_0069: ble.s IL_0087 - - IL_006b: ldsfld int32 TailcallVerify.Condition21::counterO4 - IL_0070: ldc.i4.1 - IL_0071: sub - IL_0072: stsfld int32 TailcallVerify.Condition21::counterO4 - IL_0077: ldarg.0 - IL_0078: ldc.i4.1 - IL_0079: sub - IL_007a: ldarg.1 - IL_007b: ldarg.2 - IL_007c: ldarg.3 - IL_007d: ldarg.s i5 - IL_007f: ldarg.s v3 - IL_0081: tail. call valuetype TailcallVerify.ValueType3Bytes TailcallVerify.Condition21::CalleeO4(int32, - int32, - int32, - int32, - int32, - valuetype TailcallVerify.ValueType3Bytes) - IL_0086: ret - - IL_0087: ldc.i4.2 - IL_0088: stsfld int32 TailcallVerify.Condition21::counterO4 - IL_008d: ldarg.0 - IL_008e: ldc.i4.1 - IL_008f: sub - IL_0090: ldarg.1 - IL_0091: ldarg.2 - IL_0092: ldarg.3 - IL_0093: ldarg.s i5 - IL_0095: ldarg.s v3 - IL_0097: tail. call valuetype TailcallVerify.ValueType3Bytes TailcallVerify.Condition21::CalleeE4(int32, - int32, - int32, - int32, - int32, - valuetype TailcallVerify.ValueType3Bytes) - IL_009c: ret - } // end of method Condition21::CalleeO4 - - .method public hidebysig static int32 Test5() cil managed nooptimization - { - // Code size 387 (0x183) - .maxstack 3 - .locals init ([0] class TailcallVerify.Condition21 con1, - [1] class TailcallVerify.Condition21 con2, - [2] class [System.Threading.Thread]System.Threading.Thread t1, - [3] class [System.Threading.Thread]System.Threading.Thread t2, - [4] class [mscorlib]System.Exception ex, - [5] int32 i, - [6] int32 V_6) - IL_0000: ldstr "Executing Condition21.Test5 - Verifying helper fra" - + "me location on the stack while using multiple threads." - IL_0005: call void [System.Console]System.Console::WriteLine(string) - IL_000a: ldc.i4.s 100 - IL_000c: stsfld int32 TailcallVerify.Condition21::Result - IL_0011: newobj instance void TailcallVerify.Condition21::.ctor() - IL_0016: stloc.0 - IL_0017: newobj instance void TailcallVerify.Condition21::.ctor() - IL_001c: stloc.1 - IL_001d: ldloc.0 - IL_001e: ldftn instance void TailcallVerify.Condition21::Caller5() - IL_0024: newobj instance void [System.Threading.Thread]System.Threading.ThreadStart::.ctor(object, - native int) - IL_0029: newobj instance void [System.Threading.Thread]System.Threading.Thread::.ctor(class [System.Threading.Thread]System.Threading.ThreadStart) - IL_002e: stloc.2 - IL_002f: ldloc.1 - IL_0030: ldftn instance void TailcallVerify.Condition21::Caller5() - IL_0036: newobj instance void [System.Threading.Thread]System.Threading.ThreadStart::.ctor(object, - native int) - IL_003b: newobj instance void [System.Threading.Thread]System.Threading.Thread::.ctor(class [System.Threading.Thread]System.Threading.ThreadStart) - IL_0040: stloc.3 - .try - { - IL_0041: ldloc.2 - IL_0042: callvirt instance void [System.Threading.Thread]System.Threading.Thread::Start() - IL_0047: ldloc.3 - IL_0048: callvirt instance void [System.Threading.Thread]System.Threading.Thread::Start() - IL_004d: ldloc.2 - IL_004e: callvirt instance void [System.Threading.Thread]System.Threading.Thread::Join() - IL_0053: ldloc.3 - IL_0054: callvirt instance void [System.Threading.Thread]System.Threading.Thread::Join() - IL_0059: leave.s IL_007c - - } // end .try - catch [mscorlib]System.Exception - { - IL_005b: stloc.s ex - IL_005d: ldstr "FAILED: This exception was NOT expected: " - IL_0062: ldloc.s ex - IL_0064: callvirt instance string [mscorlib]System.Exception::get_Message() - IL_0069: call string [mscorlib]System.String::Concat(string, - string) - IL_006e: call void [System.Console]System.Console::WriteLine(string) - IL_0073: ldc.i4.s 101 - IL_0075: stsfld int32 TailcallVerify.Condition21::Result - IL_007a: leave.s IL_007c - - } // end handler - IL_007c: ldloc.0 - IL_007d: callvirt instance void TailcallVerify.Condition21::VerifyThreadList() - IL_0082: ldsfld int32 TailcallVerify.Condition21::Result - IL_0087: ldc.i4.s 100 - IL_0089: bne.un.s IL_0091 - - IL_008b: ldloc.1 - IL_008c: callvirt instance void TailcallVerify.Condition21::VerifyThreadList() - IL_0091: ldsfld int32 TailcallVerify.Condition21::Result - IL_0096: ldc.i4.s 100 - IL_0098: beq IL_0159 - - IL_009d: ldstr "The following shows a list of stack addresses of a" - + " local on the stack." - IL_00a2: call void [System.Console]System.Console::WriteLine(string) - IL_00a7: ldstr "You should see the same address three times before" - + " it decreases and repeats again." - IL_00ac: call void [System.Console]System.Console::WriteLine(string) - IL_00b1: ldstr "This happens because the call chain looks like thi" - + "s E->E->E->E->O->O->O->E->E->E->E->O->O->O" - IL_00b6: call void [System.Console]System.Console::WriteLine(string) - IL_00bb: ldstr "where E is a method where tailcalls are not allowe" - + "d (it's synchronized) and O is a" - IL_00c0: call void [System.Console]System.Console::WriteLine(string) - IL_00c5: ldstr "method that gets tailcall'ed." - IL_00ca: call void [System.Console]System.Console::WriteLine(string) - IL_00cf: call void [System.Console]System.Console::WriteLine() - IL_00d4: ldstr "------ Stack addresses for thread 1. ---------" - IL_00d9: call void [System.Console]System.Console::WriteLine(string) - IL_00de: ldc.i4.0 - IL_00df: stloc.s i - IL_00e1: br.s IL_0105 - - IL_00e3: ldstr "0x{0:x8}" - IL_00e8: ldloc.0 - IL_00e9: ldfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::threadList - IL_00ee: ldloc.s i - IL_00f0: callvirt instance !0 class [mscorlib]System.Collections.Generic.List`1::get_Item(int32) - IL_00f5: box [mscorlib]System.Int64 - IL_00fa: call void [System.Console]System.Console::WriteLine(string, - object) - IL_00ff: ldloc.s i - IL_0101: ldc.i4.1 - IL_0102: add - IL_0103: stloc.s i - IL_0105: ldloc.s i - IL_0107: ldloc.0 - IL_0108: ldfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::threadList - IL_010d: callvirt instance int32 class [mscorlib]System.Collections.Generic.List`1::get_Count() - IL_0112: blt.s IL_00e3 - - IL_0114: call void [System.Console]System.Console::WriteLine() - IL_0119: ldstr "------ Stack addresses for thread 2. ---------" - IL_011e: call void [System.Console]System.Console::WriteLine(string) - IL_0123: ldc.i4.0 - IL_0124: stloc.s V_6 - IL_0126: br.s IL_014a - - IL_0128: ldstr "0x{0:x8}" - IL_012d: ldloc.1 - IL_012e: ldfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::threadList - IL_0133: ldloc.s V_6 - IL_0135: callvirt instance !0 class [mscorlib]System.Collections.Generic.List`1::get_Item(int32) - IL_013a: box [mscorlib]System.Int64 - IL_013f: call void [System.Console]System.Console::WriteLine(string, - object) - IL_0144: ldloc.s V_6 - IL_0146: ldc.i4.1 - IL_0147: add - IL_0148: stloc.s V_6 - IL_014a: ldloc.s V_6 - IL_014c: ldloc.1 - IL_014d: ldfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::threadList - IL_0152: callvirt instance int32 class [mscorlib]System.Collections.Generic.List`1::get_Count() - IL_0157: blt.s IL_0128 - - IL_0159: ldstr "Execution finished - Test " - IL_015e: ldsfld int32 TailcallVerify.Condition21::Result - IL_0163: ldc.i4.s 100 - IL_0165: beq.s IL_016e - - IL_0167: ldstr "FAILED" - IL_016c: br.s IL_0173 - - IL_016e: ldstr "PASSED" - IL_0173: call string [mscorlib]System.String::Concat(string, - string) - IL_0178: call void [System.Console]System.Console::WriteLine(string) - IL_017d: ldsfld int32 TailcallVerify.Condition21::Result - IL_0182: ret - } // end of method Condition21::Test5 - - .method assembly hidebysig instance void - VerifyThreadList() cil managed - { - // Code size 90 (0x5a) - .maxstack 4 - .locals init ([0] int32 i) - IL_0000: ldc.i4.0 - IL_0001: stloc.0 - IL_0002: br.s IL_0049 - - IL_0004: ldarg.0 - IL_0005: ldfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::threadList - IL_000a: ldloc.0 - IL_000b: callvirt instance !0 class [mscorlib]System.Collections.Generic.List`1::get_Item(int32) - IL_0010: ldarg.0 - IL_0011: ldfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::threadList - IL_0016: ldloc.0 - IL_0017: ldc.i4.1 - IL_0018: add - IL_0019: callvirt instance !0 class [mscorlib]System.Collections.Generic.List`1::get_Item(int32) - IL_001e: bne.un.s IL_003e - - IL_0020: ldarg.0 - IL_0021: ldfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::threadList - IL_0026: ldloc.0 - IL_0027: ldc.i4.1 - IL_0028: add - IL_0029: callvirt instance !0 class [mscorlib]System.Collections.Generic.List`1::get_Item(int32) - IL_002e: ldarg.0 - IL_002f: ldfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::threadList - IL_0034: ldloc.0 - IL_0035: ldc.i4.2 - IL_0036: add - IL_0037: callvirt instance !0 class [mscorlib]System.Collections.Generic.List`1::get_Item(int32) - IL_003c: beq.s IL_0045 - - IL_003e: ldc.i4.s 101 - IL_0040: stsfld int32 TailcallVerify.Condition21::Result - IL_0045: ldloc.0 - IL_0046: ldc.i4.3 - IL_0047: add - IL_0048: stloc.0 - IL_0049: ldloc.0 - IL_004a: ldc.i4.2 - IL_004b: add - IL_004c: ldarg.0 - IL_004d: ldfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::threadList - IL_0052: callvirt instance int32 class [mscorlib]System.Collections.Generic.List`1::get_Count() - IL_0057: blt.s IL_0004 - - IL_0059: ret - } // end of method Condition21::VerifyThreadList - - .method private hidebysig instance void - Caller5() cil managed - { - // Code size 74 (0x4a) - .maxstack 7 - .locals init ([0] valuetype TailcallVerify.ValueType3Bytes CS$0$0000) - IL_0000: ldc.i4.0 - IL_0001: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) - IL_0006: callvirt instance class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Diagnostics.StackFrame::GetMethod() - IL_000b: callvirt instance string [mscorlib]System.Reflection.MemberInfo::get_Name() - IL_0010: ldstr "Caller" - IL_0015: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_001a: ldc.i4.m1 - IL_001b: bne.un.s IL_002e - - IL_001d: ldstr "FAILED: Caller5 was inlined..." - IL_0022: call void [System.Console]System.Console::WriteLine(string) - IL_0027: ldc.i4.s 101 - IL_0029: stsfld int32 TailcallVerify.Condition21::Result - .try - { - IL_002e: ldarg.0 - IL_002f: ldc.i4.s 50 - IL_0031: ldc.i4.1 - IL_0032: ldc.i4.2 - IL_0033: ldc.i4.3 - IL_0034: ldc.i4.4 - IL_0035: ldloca.s CS$0$0000 - IL_0037: initobj TailcallVerify.ValueType3Bytes - IL_003d: ldloc.0 - IL_003e: call instance valuetype TailcallVerify.ValueType3Bytes TailcallVerify.Condition21::CallerE5(int32, - int32, - int32, - int32, - int32, - valuetype TailcallVerify.ValueType3Bytes) - IL_0043: pop - IL_0044: leave.s IL_0049 - - } // end .try - catch [mscorlib]System.DivideByZeroException - { - IL_0046: pop - IL_0047: leave.s IL_0049 - - } // end handler - IL_0049: ret - } // end of method Condition21::Caller5 - - .method private hidebysig instance valuetype TailcallVerify.ValueType3Bytes - CallerE5(int32 i, - int32 i2, - int32 i3, - int32 i4, - int32 i5, - valuetype TailcallVerify.ValueType3Bytes v3) cil managed noinlining - { - // Code size 16 (0x10) - .maxstack 8 - IL_0000: ldarg.0 - IL_0001: ldarg.1 - IL_0002: ldarg.2 - IL_0003: ldarg.3 - IL_0004: ldarg.s i4 - IL_0006: ldarg.s i5 - IL_0008: ldarg.s v3 - IL_000a: tail. call instance valuetype TailcallVerify.ValueType3Bytes TailcallVerify.Condition21::CalleeE5(int32, - int32, - int32, - int32, - int32, - valuetype TailcallVerify.ValueType3Bytes) - IL_000f: ret - } // end of method Condition21::CallerE5 - - .method private hidebysig instance valuetype TailcallVerify.ValueType3Bytes - CalleeE5(int32 i, - int32 i2, - int32 i3, - int32 i4, - int32 i5, - valuetype TailcallVerify.ValueType3Bytes v3) cil managed synchronized - { - // Code size 147 (0x93) - .maxstack 7 - .locals init ([0] int32 data, - [1] int32* pData, - [2] valuetype TailcallVerify.ValueType3Bytes CS$0$0000) - IL_0000: ldloca.s data - IL_0002: conv.u - IL_0003: stloc.1 - IL_0004: ldloc.1 - IL_0005: newobj instance void [mscorlib]System.IntPtr::.ctor(void*) - IL_000a: pop - IL_000b: ldc.i4.0 - IL_000c: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) - IL_0011: callvirt instance class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Diagnostics.StackFrame::GetMethod() - IL_0016: callvirt instance string [mscorlib]System.Reflection.MemberInfo::get_Name() - IL_001b: ldstr "Callee" - IL_0020: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_0025: ldc.i4.m1 - IL_0026: bne.un.s IL_0039 - - IL_0028: ldstr "FAILED: CalleeE5 was inlined..." - IL_002d: call void [System.Console]System.Console::WriteLine(string) - IL_0032: ldc.i4.s 101 - IL_0034: stsfld int32 TailcallVerify.Condition21::Result - IL_0039: ldarg.1 - IL_003a: brtrue.s IL_0051 - - IL_003c: ldarg.1 - IL_003d: volatile. - IL_003f: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition21::zero - IL_0044: div - IL_0045: starg.s i - IL_0047: ldloca.s CS$0$0000 - IL_0049: initobj TailcallVerify.ValueType3Bytes - IL_004f: ldloc.2 - IL_0050: ret - - IL_0051: ldarg.0 - IL_0052: ldfld int32 TailcallVerify.Condition21::counterE5 - IL_0057: ldc.i4.0 - IL_0058: ble.s IL_007a - - IL_005a: ldarg.0 - IL_005b: dup - IL_005c: ldfld int32 TailcallVerify.Condition21::counterE5 - IL_0061: ldc.i4.1 - IL_0062: sub - IL_0063: stfld int32 TailcallVerify.Condition21::counterE5 - IL_0068: ldarg.0 - IL_0069: ldarg.1 - IL_006a: ldc.i4.1 - IL_006b: sub - IL_006c: ldarg.2 - IL_006d: ldarg.3 - IL_006e: ldarg.s i4 - IL_0070: ldarg.s i5 - IL_0072: ldarg.s v3 - IL_0074: tail. call instance valuetype TailcallVerify.ValueType3Bytes TailcallVerify.Condition21::CalleeE5(int32, - int32, - int32, - int32, - int32, - valuetype TailcallVerify.ValueType3Bytes) - IL_0079: ret - - IL_007a: ldarg.0 - IL_007b: ldc.i4.3 - IL_007c: stfld int32 TailcallVerify.Condition21::counterE5 - IL_0081: ldarg.0 - IL_0082: ldarg.1 - IL_0083: ldc.i4.1 - IL_0084: sub - IL_0085: ldarg.2 - IL_0086: ldarg.3 - IL_0087: ldarg.s i4 - IL_0089: ldarg.s i5 - IL_008b: ldarg.s v3 - IL_008d: tail. call instance valuetype TailcallVerify.ValueType3Bytes TailcallVerify.Condition21::CalleeO5(int32, - int32, - int32, - int32, - int32, - valuetype TailcallVerify.ValueType3Bytes) - IL_0092: ret - } // end of method Condition21::CalleeE5 - - .method private hidebysig instance valuetype TailcallVerify.ValueType3Bytes - CalleeO5(int32 i, - int32 i2, - int32 i3, - int32 i4, - int32 i5, - valuetype TailcallVerify.ValueType3Bytes v3) cil managed - { - // Code size 166 (0xa6) - .maxstack 7 - .locals init ([0] int32 data, - [1] int32* pData, - [2] native int p, - [3] valuetype TailcallVerify.ValueType3Bytes CS$0$0000) - IL_0000: ldloca.s data - IL_0002: conv.u - IL_0003: stloc.1 - IL_0004: ldloca.s p - IL_0006: ldloc.1 - IL_0007: call instance void [mscorlib]System.IntPtr::.ctor(void*) - IL_000c: ldarg.0 - IL_000d: ldfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::threadList - IL_0012: ldloca.s p - IL_0014: call instance int64 [mscorlib]System.IntPtr::ToInt64() - IL_0019: callvirt instance void class [mscorlib]System.Collections.Generic.List`1::Add(!0) - IL_001e: ldc.i4.0 - IL_001f: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) - IL_0024: callvirt instance class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Diagnostics.StackFrame::GetMethod() - IL_0029: callvirt instance string [mscorlib]System.Reflection.MemberInfo::get_Name() - IL_002e: ldstr "Callee" - IL_0033: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_0038: ldc.i4.m1 - IL_0039: bne.un.s IL_004c - - IL_003b: ldstr "FAILED: CalleeO5 was inlined..." - IL_0040: call void [System.Console]System.Console::WriteLine(string) - IL_0045: ldc.i4.s 101 - IL_0047: stsfld int32 TailcallVerify.Condition21::Result - IL_004c: ldarg.1 - IL_004d: brtrue.s IL_0064 - - IL_004f: ldarg.1 - IL_0050: volatile. - IL_0052: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition21::zero - IL_0057: div - IL_0058: starg.s i - IL_005a: ldloca.s CS$0$0000 - IL_005c: initobj TailcallVerify.ValueType3Bytes - IL_0062: ldloc.3 - IL_0063: ret - - IL_0064: ldarg.0 - IL_0065: ldfld int32 TailcallVerify.Condition21::counterO5 - IL_006a: ldc.i4.0 - IL_006b: ble.s IL_008d - - IL_006d: ldarg.0 - IL_006e: dup - IL_006f: ldfld int32 TailcallVerify.Condition21::counterO5 - IL_0074: ldc.i4.1 - IL_0075: sub - IL_0076: stfld int32 TailcallVerify.Condition21::counterO5 - IL_007b: ldarg.0 - IL_007c: ldarg.1 - IL_007d: ldc.i4.1 - IL_007e: sub - IL_007f: ldarg.2 - IL_0080: ldarg.3 - IL_0081: ldarg.s i4 - IL_0083: ldarg.s i5 - IL_0085: ldarg.s v3 - IL_0087: tail. call instance valuetype TailcallVerify.ValueType3Bytes TailcallVerify.Condition21::CalleeO5(int32, - int32, - int32, - int32, - int32, - valuetype TailcallVerify.ValueType3Bytes) - IL_008c: ret - - IL_008d: ldarg.0 - IL_008e: ldc.i4.2 - IL_008f: stfld int32 TailcallVerify.Condition21::counterO5 - IL_0094: ldarg.0 - IL_0095: ldarg.1 - IL_0096: ldc.i4.1 - IL_0097: sub - IL_0098: ldarg.2 - IL_0099: ldarg.3 - IL_009a: ldarg.s i4 - IL_009c: ldarg.s i5 - IL_009e: ldarg.s v3 - IL_00a0: tail. call instance valuetype TailcallVerify.ValueType3Bytes TailcallVerify.Condition21::CalleeE5(int32, - int32, - int32, - int32, - int32, - valuetype TailcallVerify.ValueType3Bytes) - IL_00a5: ret - } // end of method Condition21::CalleeO5 - - .method public hidebysig static int32 Test6() cil managed nooptimization - { - // Code size 153 (0x99) - .maxstack 3 - .locals init ([0] class [mscorlib]System.Exception e) - IL_0000: ldstr "Executing Condition21.Test6 - Caller: Arguments: " - + "None - ReturnType: void; Callee: Arguments: None - ReturnType: void" - IL_0005: call void [System.Console]System.Console::WriteLine(string) - IL_000a: ldc.i4.s 100 - IL_000c: stsfld int32 TailcallVerify.Condition21::Result - .try - { - IL_0011: call void TailcallVerify.Condition21::Caller6() - IL_0016: leave.s IL_006f - - } // end .try - catch [mscorlib]System.Exception - { - IL_0018: stloc.0 - IL_0019: ldloc.0 - IL_001a: isinst [mscorlib]System.DivideByZeroException - IL_001f: brtrue.s IL_002a - - IL_0021: ldc.i4.s 101 - IL_0023: stsfld int32 TailcallVerify.Condition21::Result - IL_0028: rethrow - IL_002a: ldloc.0 - IL_002b: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_0030: ldstr "Caller" - IL_0035: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_003a: ldc.i4.m1 - IL_003b: beq.s IL_006d - - IL_003d: ldstr "FAILED: Found the word 'Caller' in the stacktrace." - IL_0042: call void [System.Console]System.Console::WriteLine(string) - IL_0047: ldstr "------------------------------------------------" - IL_004c: call void [System.Console]System.Console::WriteLine(string) - IL_0051: call void [System.Console]System.Console::WriteLine() - IL_0056: ldloc.0 - IL_0057: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_005c: call void [System.Console]System.Console::WriteLine(string) - IL_0061: call void [System.Console]System.Console::WriteLine() - IL_0066: ldc.i4.s 101 - IL_0068: stsfld int32 TailcallVerify.Condition21::Result - IL_006d: leave.s IL_006f - - } // end handler - IL_006f: ldstr "Execution finished - Test " - IL_0074: ldsfld int32 TailcallVerify.Condition21::Result - IL_0079: ldc.i4.s 100 - IL_007b: beq.s IL_0084 - - IL_007d: ldstr "FAILED" - IL_0082: br.s IL_0089 - - IL_0084: ldstr "PASSED" - IL_0089: call string [mscorlib]System.String::Concat(string, - string) - IL_008e: call void [System.Console]System.Console::WriteLine(string) - IL_0093: ldsfld int32 TailcallVerify.Condition21::Result - IL_0098: ret - } // end of method Condition21::Test6 - - .method private hidebysig static void Caller6() cil managed - { - // Code size 52 (0x34) - .maxstack 8 - IL_0000: ldc.i4.0 - IL_0001: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) - IL_0006: callvirt instance class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Diagnostics.StackFrame::GetMethod() - IL_000b: callvirt instance string [mscorlib]System.Reflection.MemberInfo::get_Name() - IL_0010: ldstr "Caller" - IL_0015: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_001a: ldc.i4.m1 - IL_001b: bne.un.s IL_002e - - IL_001d: ldstr "Failed, Method was inlined..." - IL_0022: call void [System.Console]System.Console::WriteLine(string) - IL_0027: ldc.i4.s 101 - IL_0029: stsfld int32 TailcallVerify.Condition21::Result - IL_002e: ldftn void TailcallVerify.Condition21::Callee6() - tail. calli void() - IL_0033: ret - } // end of method Condition21::Caller6 - - .method private hidebysig static void Callee6() cil managed noinlining - { - // Code size 11 (0xb) - .maxstack 8 - IL_0000: ldc.i4.1 - IL_0001: volatile. - IL_0003: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition21::zero - IL_0008: div - IL_0009: pop - IL_000a: ret - } // end of method Condition21::Callee6 - - .method public hidebysig static int32 Test7() cil managed nooptimization - { - // Code size 155 (0x9b) - .maxstack 3 - .locals init ([0] class [mscorlib]System.Exception e) - IL_0000: ldstr "Executing Condition21.Test7 - Caller: Arguments: " - + "Int32 - ReturnType: Int32; Callee: Arguments: Int32 - ReturnType: Int32" - IL_0005: call void [System.Console]System.Console::WriteLine(string) - IL_000a: ldc.i4.s 100 - IL_000c: stsfld int32 TailcallVerify.Condition21::Result - .try - { - IL_0011: ldc.i4.0 - IL_0012: call int32 TailcallVerify.Condition21::Caller7(int32) - IL_0017: pop - IL_0018: leave.s IL_0071 - - } // end .try - catch [mscorlib]System.Exception - { - IL_001a: stloc.0 - IL_001b: ldloc.0 - IL_001c: isinst [mscorlib]System.DivideByZeroException - IL_0021: brtrue.s IL_002c - - IL_0023: ldc.i4.s 101 - IL_0025: stsfld int32 TailcallVerify.Condition21::Result - IL_002a: rethrow - IL_002c: ldloc.0 - IL_002d: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_0032: ldstr "Caller" - IL_0037: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_003c: ldc.i4.m1 - IL_003d: beq.s IL_006f - - IL_003f: ldstr "FAILED: Found the word 'Caller' in the stacktrace." - IL_0044: call void [System.Console]System.Console::WriteLine(string) - IL_0049: ldstr "------------------------------------------------" - IL_004e: call void [System.Console]System.Console::WriteLine(string) - IL_0053: call void [System.Console]System.Console::WriteLine() - IL_0058: ldloc.0 - IL_0059: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_005e: call void [System.Console]System.Console::WriteLine(string) - IL_0063: call void [System.Console]System.Console::WriteLine() - IL_0068: ldc.i4.s 101 - IL_006a: stsfld int32 TailcallVerify.Condition21::Result - IL_006f: leave.s IL_0071 - - } // end handler - IL_0071: ldstr "Execution finished - Test " - IL_0076: ldsfld int32 TailcallVerify.Condition21::Result - IL_007b: ldc.i4.s 100 - IL_007d: beq.s IL_0086 - - IL_007f: ldstr "FAILED" - IL_0084: br.s IL_008b - - IL_0086: ldstr "PASSED" - IL_008b: call string [mscorlib]System.String::Concat(string, - string) - IL_0090: call void [System.Console]System.Console::WriteLine(string) - IL_0095: ldsfld int32 TailcallVerify.Condition21::Result - IL_009a: ret - } // end of method Condition21::Test7 - - .method private hidebysig static int32 - Caller7(int32 i1) cil managed - { - // Code size 53 (0x35) - .maxstack 8 - IL_0000: ldc.i4.0 - IL_0001: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) - IL_0006: callvirt instance class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Diagnostics.StackFrame::GetMethod() - IL_000b: callvirt instance string [mscorlib]System.Reflection.MemberInfo::get_Name() - IL_0010: ldstr "Caller" - IL_0015: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_001a: ldc.i4.m1 - IL_001b: bne.un.s IL_002e - - IL_001d: ldstr "Failed, Method was inlined..." - IL_0022: call void [System.Console]System.Console::WriteLine(string) - IL_0027: ldc.i4.s 101 - IL_0029: stsfld int32 TailcallVerify.Condition21::Result - IL_002e: ldarg.0 - IL_002f: ldftn int32 TailcallVerify.Condition21::Callee7(int32) - tail. calli int32(int32) - IL_0034: ret - } // end of method Condition21::Caller7 - - .method private hidebysig static int32 - Callee7(int32 i1) cil managed noinlining - { - // Code size 12 (0xc) - .maxstack 8 - IL_0000: ldc.i4.1 - IL_0001: volatile. - IL_0003: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition21::zero - IL_0008: div - IL_0009: pop - IL_000a: ldarg.0 - IL_000b: ret - } // end of method Condition21::Callee7 - - .method public hidebysig specialname rtspecialname - instance void .ctor() cil managed - { - // Code size 32 (0x20) - .maxstack 8 - IL_0000: ldarg.0 - IL_0001: newobj instance void class [mscorlib]System.Collections.Generic.List`1::.ctor() - IL_0006: stfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::threadList - IL_000b: ldarg.0 - IL_000c: ldc.i4.3 - IL_000d: stfld int32 TailcallVerify.Condition21::counterE5 - IL_0012: ldarg.0 - IL_0013: ldc.i4.2 - IL_0014: stfld int32 TailcallVerify.Condition21::counterO5 - IL_0019: ldarg.0 - IL_001a: call instance void [mscorlib]System.Object::.ctor() - IL_001f: ret - } // end of method Condition21::.ctor - - .method private hidebysig specialname rtspecialname static - void .cctor() cil managed - { - // Code size 48 (0x30) - .maxstack 8 - IL_0000: ldc.i4.0 - IL_0001: volatile. - IL_0003: stsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition21::zero - IL_0008: ldc.i4.s 100 - IL_000a: stsfld int32 TailcallVerify.Condition21::Result - IL_000f: newobj instance void class [mscorlib]System.Collections.Generic.List`1::.ctor() - IL_0014: stsfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::evenList - IL_0019: newobj instance void class [mscorlib]System.Collections.Generic.List`1::.ctor() - IL_001e: stsfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::oddList - IL_0023: ldc.i4.3 - IL_0024: stsfld int32 TailcallVerify.Condition21::counterE4 - IL_0029: ldc.i4.2 - IL_002a: stsfld int32 TailcallVerify.Condition21::counterO4 - IL_002f: ret - } // end of method Condition21::.cctor - -} // end of class TailcallVerify.Condition21 - -.class private auto ansi beforefieldinit TailcallVerify.Condition10 - extends [mscorlib]System.Object -{ - .class auto ansi nested private beforefieldinit Foo1`2 - extends [mscorlib]System.Object - { - .field private int32 zero - .method public hidebysig instance void - Test1() cil managed nooptimization - { - // Code size 91 (0x5b) - .maxstack 2 - .locals init ([0] class [mscorlib]System.Exception e) - .try - { - IL_0000: ldarg.0 - IL_0001: call instance void class TailcallVerify.Condition10/Foo1`2::Caller1() - IL_0006: leave.s IL_005a - - } // end .try - catch [mscorlib]System.Exception - { - IL_0008: stloc.0 - IL_0009: ldloc.0 - IL_000a: isinst [mscorlib]System.DivideByZeroException - IL_000f: brtrue.s IL_001a - - IL_0011: ldc.i4.s 101 - IL_0013: stsfld int32 TailcallVerify.Condition10::Result - IL_0018: rethrow - IL_001a: ldloc.0 - IL_001b: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_0020: ldstr "Caller" - IL_0025: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_002a: ldc.i4.m1 - IL_002b: beq.s IL_0058 - - IL_002d: ldstr "FAILED: Found the word 'Caller' in the stacktrace." - IL_0032: call void [System.Console]System.Console::WriteLine(string) - IL_0037: ldstr "------------------------------------------------" - IL_003c: call void [System.Console]System.Console::WriteLine(string) - IL_0041: call void [System.Console]System.Console::WriteLine() - IL_0046: ldloc.0 - IL_0047: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_004c: call void [System.Console]System.Console::WriteLine(string) - IL_0051: call void [System.Console]System.Console::WriteLine() - IL_0056: rethrow - IL_0058: leave.s IL_005a - - } // end handler - IL_005a: ret - } // end of method Foo1`2::Test1 - - .method public hidebysig instance void - Test1Recursive() cil managed nooptimization - { - // Code size 91 (0x5b) - .maxstack 2 - .locals init ([0] class [mscorlib]System.Exception e) - .try - { - IL_0000: ldarg.0 - IL_0001: call instance void class TailcallVerify.Condition10/Foo1`2::Caller1Recursive() - IL_0006: leave.s IL_005a - - } // end .try - catch [mscorlib]System.Exception - { - IL_0008: stloc.0 - IL_0009: ldloc.0 - IL_000a: isinst [mscorlib]System.DivideByZeroException - IL_000f: brtrue.s IL_001a - - IL_0011: ldc.i4.s 101 - IL_0013: stsfld int32 TailcallVerify.Condition10::Result - IL_0018: rethrow - IL_001a: ldloc.0 - IL_001b: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_0020: ldstr "Caller" - IL_0025: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_002a: ldc.i4.m1 - IL_002b: beq.s IL_0058 - - IL_002d: ldstr "FAILED: Found the word 'Caller' in the stacktrace." - IL_0032: call void [System.Console]System.Console::WriteLine(string) - IL_0037: ldstr "------------------------------------------------" - IL_003c: call void [System.Console]System.Console::WriteLine(string) - IL_0041: call void [System.Console]System.Console::WriteLine() - IL_0046: ldloc.0 - IL_0047: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_004c: call void [System.Console]System.Console::WriteLine(string) - IL_0051: call void [System.Console]System.Console::WriteLine() - IL_0056: rethrow - IL_0058: leave.s IL_005a - - } // end handler - IL_005a: ret - } // end of method Foo1`2::Test1Recursive - - .method public hidebysig instance void - Caller1() cil managed - { - // This method depends on JIT compiler doing automatic tail call, which isn't supported by Ready-to-Run. - .custom instance void System.Runtime.BypassReadyToRunAttribute::.ctor() = ( 01 00 00 00 ) - - // Code size 53 (0x35) - .maxstack 8 - IL_0000: ldc.i4.0 - IL_0001: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) - IL_0006: callvirt instance class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Diagnostics.StackFrame::GetMethod() - IL_000b: callvirt instance string [mscorlib]System.Reflection.MemberInfo::get_Name() - IL_0010: ldstr "Caller" - IL_0015: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_001a: ldc.i4.m1 - IL_001b: bne.un.s IL_002e - - IL_001d: ldstr "Failed, Method was inlined..." - IL_0022: call void [System.Console]System.Console::WriteLine(string) - IL_0027: ldc.i4.s 101 - IL_0029: stsfld int32 TailcallVerify.Condition10::Result - IL_002e: ldarg.0 - IL_002f: call instance void class TailcallVerify.Condition10/Foo1`2::Callee1() - IL_0034: ret - } // end of method Foo1`2::Caller1 - - .method public hidebysig instance void - Caller1Recursive() cil managed - { - // This method depends on JIT compiler doing automatic tail call, which isn't supported by Ready-to-Run. - .custom instance void System.Runtime.BypassReadyToRunAttribute::.ctor() = ( 01 00 00 00 ) - - // Code size 55 (0x37) - .maxstack 8 - IL_0000: ldc.i4.0 - IL_0001: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) - IL_0006: callvirt instance class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Diagnostics.StackFrame::GetMethod() - IL_000b: callvirt instance string [mscorlib]System.Reflection.MemberInfo::get_Name() - IL_0010: ldstr "Caller" - IL_0015: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_001a: ldc.i4.m1 - IL_001b: bne.un.s IL_002e - - IL_001d: ldstr "Failed, Method was inlined..." - IL_0022: call void [System.Console]System.Console::WriteLine(string) - IL_0027: ldc.i4.s 101 - IL_0029: stsfld int32 TailcallVerify.Condition10::Result - IL_002e: ldarg.0 - IL_002f: ldc.i4.s 20 - IL_0031: call instance void class TailcallVerify.Condition10/Foo1`2::Callee1Recursive(int32) - IL_0036: ret - } // end of method Foo1`2::Caller1Recursive - - .method private hidebysig instance void - Callee1() cil managed noinlining - { - // Code size 10 (0xa) - .maxstack 8 - IL_0000: ldc.i4.1 - IL_0001: ldarg.0 - IL_0002: ldfld int32 class TailcallVerify.Condition10/Foo1`2::zero - IL_0007: div - IL_0008: pop - IL_0009: ret - } // end of method Foo1`2::Callee1 - - .method private hidebysig instance void - Callee1Recursive(int32 i) cil managed - { - // This method depends on JIT compiler doing automatic tail call, which isn't supported by Ready-to-Run. - .custom instance void System.Runtime.BypassReadyToRunAttribute::.ctor() = ( 01 00 00 00 ) - - // Code size 93 (0x5d) - .maxstack 3 - .locals init ([0] string stackTrace, - [1] int32 count, - [2] int32 idx) - IL_0000: newobj instance void [mscorlib]System.Diagnostics.StackTrace::.ctor() - IL_0005: callvirt instance string [mscorlib]System.Object::ToString() - IL_000a: stloc.0 - IL_000b: ldc.i4.0 - IL_000c: stloc.1 - IL_000d: ldc.i4.0 - IL_000e: stloc.2 - IL_000f: br.s IL_0019 - - IL_0011: ldloc.2 - IL_0012: ldc.i4.1 - IL_0013: add - IL_0014: stloc.2 - IL_0015: ldloc.1 - IL_0016: ldc.i4.1 - IL_0017: add - IL_0018: stloc.1 - IL_0019: ldloc.0 - IL_001a: ldstr "Callee" - IL_001f: ldloc.2 - IL_0020: callvirt instance int32 [mscorlib]System.String::IndexOf(string, - int32) - IL_0025: dup - IL_0026: stloc.2 - IL_0027: ldc.i4.m1 - IL_0028: bne.un.s IL_0011 - - IL_002a: ldloc.1 - IL_002b: ldc.i4.1 - IL_002c: beq.s IL_0045 - - IL_002e: ldstr "FAILED: Callee1Recursive was not tailcall'ed..." - IL_0033: call void [System.Console]System.Console::WriteLine(string) - IL_0038: ldloc.0 - IL_0039: call void [System.Console]System.Console::WriteLine(string) - IL_003e: ldc.i4.s 101 - IL_0040: stsfld int32 TailcallVerify.Condition10::Result - IL_0045: ldarg.1 - IL_0046: brtrue.s IL_0053 - - IL_0048: ldarg.1 - IL_0049: ldarg.0 - IL_004a: ldfld int32 class TailcallVerify.Condition10/Foo1`2::zero - IL_004f: div - IL_0050: starg.s i - IL_0052: ret - - IL_0053: ldarg.0 - IL_0054: ldarg.1 - IL_0055: ldc.i4.1 - IL_0056: sub - IL_0057: call instance void class TailcallVerify.Condition10/Foo1`2::Callee1Recursive(int32) - IL_005c: ret - } // end of method Foo1`2::Callee1Recursive - - .method public hidebysig specialname rtspecialname - instance void .ctor() cil managed - { - // Code size 7 (0x7) - .maxstack 8 - IL_0000: ldarg.0 - IL_0001: call instance void [mscorlib]System.Object::.ctor() - IL_0006: ret - } // end of method Foo1`2::.ctor - - } // end of class Foo1`2 - - .class auto ansi nested private beforefieldinit Foo2`2 - extends [mscorlib]System.Object - { - .field private int32 zero - .method public hidebysig instance void - Test1() cil managed nooptimization - { - // Code size 109 (0x6d) - .maxstack 3 - .locals init ([0] !V arg1, - [1] !K arg2, - [2] class [mscorlib]System.Exception e) - .try - { - IL_0000: ldloca.s arg1 - IL_0002: initobj !V - IL_0008: ldloca.s arg2 - IL_000a: initobj !K - IL_0010: ldarg.0 - IL_0011: ldloc.0 - IL_0012: ldloc.1 - IL_0013: call instance void class TailcallVerify.Condition10/Foo2`2::Caller1(!0, - !1) - IL_0018: leave.s IL_006c - - } // end .try - catch [mscorlib]System.Exception - { - IL_001a: stloc.2 - IL_001b: ldloc.2 - IL_001c: isinst [mscorlib]System.DivideByZeroException - IL_0021: brtrue.s IL_002c - - IL_0023: ldc.i4.s 101 - IL_0025: stsfld int32 TailcallVerify.Condition10::Result - IL_002a: rethrow - IL_002c: ldloc.2 - IL_002d: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_0032: ldstr "Caller" - IL_0037: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_003c: ldc.i4.m1 - IL_003d: beq.s IL_006a - - IL_003f: ldstr "FAILED: Found the word 'Caller' in the stacktrace." - IL_0044: call void [System.Console]System.Console::WriteLine(string) - IL_0049: ldstr "------------------------------------------------" - IL_004e: call void [System.Console]System.Console::WriteLine(string) - IL_0053: call void [System.Console]System.Console::WriteLine() - IL_0058: ldloc.2 - IL_0059: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_005e: call void [System.Console]System.Console::WriteLine(string) - IL_0063: call void [System.Console]System.Console::WriteLine() - IL_0068: rethrow - IL_006a: leave.s IL_006c - - } // end handler - IL_006c: ret - } // end of method Foo2`2::Test1 - - .method public hidebysig instance void - Caller1(!V arg1, - !K arg2) cil managed - { - // This method depends on JIT compiler doing automatic tail call, which isn't supported by Ready-to-Run. - .custom instance void System.Runtime.BypassReadyToRunAttribute::.ctor() = ( 01 00 00 00 ) - - // Code size 54 (0x36) - .maxstack 8 - IL_0000: ldc.i4.0 - IL_0001: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) - IL_0006: callvirt instance class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Diagnostics.StackFrame::GetMethod() - IL_000b: callvirt instance string [mscorlib]System.Reflection.MemberInfo::get_Name() - IL_0010: ldstr "Caller" - IL_0015: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_001a: ldc.i4.m1 - IL_001b: bne.un.s IL_002e - - IL_001d: ldstr "Failed, Method was inlined..." - IL_0022: call void [System.Console]System.Console::WriteLine(string) - IL_0027: ldc.i4.s 101 - IL_0029: stsfld int32 TailcallVerify.Condition10::Result - IL_002e: ldarg.0 - IL_002f: ldarg.1 - IL_0030: call instance void class TailcallVerify.Condition10/Foo2`2::Callee1(!0) - IL_0035: ret - } // end of method Foo2`2::Caller1 - - .method private hidebysig instance void - Callee1(!V arg1) cil managed noinlining - { - // Code size 10 (0xa) - .maxstack 8 - IL_0000: ldc.i4.1 - IL_0001: ldarg.0 - IL_0002: ldfld int32 class TailcallVerify.Condition10/Foo2`2::zero - IL_0007: div - IL_0008: pop - IL_0009: ret - } // end of method Foo2`2::Callee1 - - .method public hidebysig specialname rtspecialname - instance void .ctor() cil managed - { - // Code size 7 (0x7) - .maxstack 8 - IL_0000: ldarg.0 - IL_0001: call instance void [mscorlib]System.Object::.ctor() - IL_0006: ret - } // end of method Foo2`2::.ctor - - } // end of class Foo2`2 - - .field private static int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) zero - .field private static int32 Result - .method public hidebysig static int32 Test1() cil managed nooptimization - { - // Code size 153 (0x99) - .maxstack 3 - .locals init ([0] class [mscorlib]System.Exception e) - IL_0000: ldstr "Executing Condition10.Test1 - Caller: Argu" - + "ments: None - ReturnType: void; Callee: Arguments: None - ReturnType: v" - + "oid" - IL_0005: call void [System.Console]System.Console::WriteLine(string) - IL_000a: ldc.i4.s 100 - IL_000c: stsfld int32 TailcallVerify.Condition10::Result - .try - { - IL_0011: call void TailcallVerify.Condition10::Caller1() - IL_0016: leave.s IL_006f - - } // end .try - catch [mscorlib]System.Exception - { - IL_0018: stloc.0 - IL_0019: ldloc.0 - IL_001a: isinst [mscorlib]System.DivideByZeroException - IL_001f: brtrue.s IL_002a - - IL_0021: ldc.i4.s 101 - IL_0023: stsfld int32 TailcallVerify.Condition10::Result - IL_0028: rethrow - IL_002a: ldloc.0 - IL_002b: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_0030: ldstr "Caller" - IL_0035: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_003a: ldc.i4.m1 - IL_003b: beq.s IL_006d - - IL_003d: ldstr "FAILED: Found the word 'Caller' in the stacktrace." - IL_0042: call void [System.Console]System.Console::WriteLine(string) - IL_0047: ldstr "------------------------------------------------" - IL_004c: call void [System.Console]System.Console::WriteLine(string) - IL_0051: call void [System.Console]System.Console::WriteLine() - IL_0056: ldloc.0 - IL_0057: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_005c: call void [System.Console]System.Console::WriteLine(string) - IL_0061: call void [System.Console]System.Console::WriteLine() - IL_0066: ldc.i4.s 101 - IL_0068: stsfld int32 TailcallVerify.Condition10::Result - IL_006d: leave.s IL_006f - - } // end handler - IL_006f: ldstr "Execution finished - Test " - IL_0074: ldsfld int32 TailcallVerify.Condition10::Result - IL_0079: ldc.i4.s 100 - IL_007b: beq.s IL_0084 - - IL_007d: ldstr "FAILED" - IL_0082: br.s IL_0089 - - IL_0084: ldstr "PASSED" - IL_0089: call string [mscorlib]System.String::Concat(string, - string) - IL_008e: call void [System.Console]System.Console::WriteLine(string) - IL_0093: ldsfld int32 TailcallVerify.Condition10::Result - IL_0098: ret - } // end of method Condition10::Test1 - - .method private hidebysig static void Caller1() cil managed - { - // Code size 52 (0x34) - .maxstack 8 - IL_0000: ldc.i4.0 - IL_0001: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) - IL_0006: callvirt instance class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Diagnostics.StackFrame::GetMethod() - IL_000b: callvirt instance string [mscorlib]System.Reflection.MemberInfo::get_Name() - IL_0010: ldstr "Caller" - IL_0015: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_001a: ldc.i4.m1 - IL_001b: bne.un.s IL_002e - - IL_001d: ldstr "Failed, Method was inlined..." - IL_0022: call void [System.Console]System.Console::WriteLine(string) - IL_0027: ldc.i4.s 101 - IL_0029: stsfld int32 TailcallVerify.Condition10::Result - IL_002e: tail. call void TailcallVerify.Condition10::Callee1() - IL_0033: ret - } // end of method Condition10::Caller1 - - .method private hidebysig static void Callee1() cil managed noinlining - { - // Code size 11 (0xb) - .maxstack 8 - IL_0000: ldc.i4.1 - IL_0001: volatile. - IL_0003: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition10::zero - IL_0008: div - IL_0009: pop - IL_000a: ret - } // end of method Condition10::Callee1 - - .method public hidebysig static int32 Test2() cil managed nooptimization - { - // Code size 153 (0x99) - .maxstack 3 - .locals init ([0] class [mscorlib]System.Exception e) - IL_0000: ldstr "Executing Condition10.Test2 - Caller: Arguments: N" - + "one - ReturnType: void; Callee: Arguments: None - ReturnType: v" - + "oid" - IL_0005: call void [System.Console]System.Console::WriteLine(string) - IL_000a: ldc.i4.s 100 - IL_000c: stsfld int32 TailcallVerify.Condition10::Result - .try - { - IL_0011: call void TailcallVerify.Condition10::Caller2() - IL_0016: leave.s IL_006f - - } // end .try - catch [mscorlib]System.Exception - { - IL_0018: stloc.0 - IL_0019: ldloc.0 - IL_001a: isinst [mscorlib]System.DivideByZeroException - IL_001f: brtrue.s IL_002a - - IL_0021: ldc.i4.s 101 - IL_0023: stsfld int32 TailcallVerify.Condition10::Result - IL_0028: rethrow - IL_002a: ldloc.0 - IL_002b: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_0030: ldstr "Caller" - IL_0035: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_003a: ldc.i4.m1 - IL_003b: beq.s IL_006d - - IL_003d: ldstr "FAILED: Found the word 'Caller' in the stacktrace." - IL_0042: call void [System.Console]System.Console::WriteLine(string) - IL_0047: ldstr "------------------------------------------------" - IL_004c: call void [System.Console]System.Console::WriteLine(string) - IL_0051: call void [System.Console]System.Console::WriteLine() - IL_0056: ldloc.0 - IL_0057: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_005c: call void [System.Console]System.Console::WriteLine(string) - IL_0061: call void [System.Console]System.Console::WriteLine() - IL_0066: ldc.i4.s 101 - IL_0068: stsfld int32 TailcallVerify.Condition10::Result - IL_006d: leave.s IL_006f - - } // end handler - IL_006f: ldstr "Execution finished - Test " - IL_0074: ldsfld int32 TailcallVerify.Condition10::Result - IL_0079: ldc.i4.s 100 - IL_007b: beq.s IL_0084 - - IL_007d: ldstr "FAILED" - IL_0082: br.s IL_0089 - - IL_0084: ldstr "PASSED" - IL_0089: call string [mscorlib]System.String::Concat(string, - string) - IL_008e: call void [System.Console]System.Console::WriteLine(string) - IL_0093: ldsfld int32 TailcallVerify.Condition10::Result - IL_0098: ret - } // end of method Condition10::Test2 - - .method private hidebysig static void Caller2() cil managed - { - // This method depends on JIT compiler doing automatic tail call, which isn't supported by Ready-to-Run. - .custom instance void System.Runtime.BypassReadyToRunAttribute::.ctor() = ( 01 00 00 00 ) - - // Code size 52 (0x34) - .maxstack 8 - IL_0000: ldc.i4.0 - IL_0001: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) - IL_0006: callvirt instance class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Diagnostics.StackFrame::GetMethod() - IL_000b: callvirt instance string [mscorlib]System.Reflection.MemberInfo::get_Name() - IL_0010: ldstr "Caller" - IL_0015: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_001a: ldc.i4.m1 - IL_001b: bne.un.s IL_002e + .method private hidebysig static int32 + Caller7(int32 i1) cil managed + { + // Code size 53 (0x35) + .maxstack 8 + IL_0000: ldc.i4.0 + IL_0001: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) + IL_0006: callvirt instance class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Diagnostics.StackFrame::GetMethod() + IL_000b: callvirt instance string [mscorlib]System.Reflection.MemberInfo::get_Name() + IL_0010: ldstr "Caller" + IL_0015: callvirt instance int32 [mscorlib]System.String::IndexOf(string) + IL_001a: ldc.i4.m1 + IL_001b: bne.un.s IL_002e IL_001d: ldstr "Failed, Method was inlined..." IL_0022: call void [System.Console]System.Console::WriteLine(string) IL_0027: ldc.i4.s 101 - IL_0029: stsfld int32 TailcallVerify.Condition10::Result - IL_002e: call void TailcallVerify.Condition10::Callee2() - IL_0033: ret - } // end of method Condition10::Caller2 + IL_0029: stsfld int32 TailcallVerify.Condition21::Result + IL_002e: ldarg.0 + IL_002f: ldftn int32 TailcallVerify.Condition21::Callee7(int32) + tail. calli int32(int32) + IL_0034: ret + } // end of method Condition21::Caller7 - .method private hidebysig static void Callee2() cil managed noinlining + .method private hidebysig static int32 + Callee7(int32 i1) cil managed noinlining { - // Code size 11 (0xb) + // Code size 12 (0xc) .maxstack 8 IL_0000: ldc.i4.1 IL_0001: volatile. - IL_0003: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition10::zero + IL_0003: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition21::zero IL_0008: div IL_0009: pop - IL_000a: ret - } // end of method Condition10::Callee2 + IL_000a: ldarg.0 + IL_000b: ret + } // end of method Condition21::Callee7 - .method public hidebysig static int32 Test3() cil managed nooptimization + .method public hidebysig specialname rtspecialname + instance void .ctor() cil managed { - // Code size 170 (0xaa) - .maxstack 3 - .locals init ([0] class TailcallVerify.Condition10/Foo1`2 foo1, - [1] class TailcallVerify.Condition10/Foo1`2 foo2, - [2] class TailcallVerify.Condition10/Foo1`2 foo3, - [3] class TailcallVerify.Condition10/Foo1`2 foo4, - [4] class [mscorlib]System.Exception e) - IL_0000: ldstr "Executing Condition10.Test3 - class Foo1: Caller: Arguments: None - ReturnType: void; Callee: Arguments: Non" - + "e - ReturnType: void" - IL_0005: call void [System.Console]System.Console::WriteLine(string) - IL_000a: ldstr " class Foo1: Caller: Arguments: None - ReturnType: void; Callee: Arguments: Non" - + "e - ReturnType: void" - IL_000f: call void [System.Console]System.Console::WriteLine(string) - IL_0014: ldstr " class Foo1: Caller: Arguments: None - ReturnType: void; Callee: Arguments: N" - + "one - ReturnType: void" - IL_0019: call void [System.Console]System.Console::WriteLine(string) - IL_001e: ldstr " class Foo1: Caller: Arguments: None - ReturnType: void; Callee: Ar" - + "guments: None - ReturnType: void" - IL_0023: call void [System.Console]System.Console::WriteLine(string) - IL_0028: ldc.i4.s 100 - IL_002a: stsfld int32 TailcallVerify.Condition10::Result - .try - { - IL_002f: newobj instance void class TailcallVerify.Condition10/Foo1`2::.ctor() - IL_0034: stloc.0 - IL_0035: newobj instance void class TailcallVerify.Condition10/Foo1`2::.ctor() - IL_003a: stloc.1 - IL_003b: newobj instance void class TailcallVerify.Condition10/Foo1`2::.ctor() - IL_0040: stloc.2 - IL_0041: newobj instance void class TailcallVerify.Condition10/Foo1`2::.ctor() - IL_0046: stloc.3 - IL_0047: ldloc.0 - IL_0048: callvirt instance void class TailcallVerify.Condition10/Foo1`2::Test1() - IL_004d: ldloc.1 - IL_004e: callvirt instance void class TailcallVerify.Condition10/Foo1`2::Test1() - IL_0053: ldloc.2 - IL_0054: callvirt instance void class TailcallVerify.Condition10/Foo1`2::Test1() - IL_0059: ldloc.3 - IL_005a: callvirt instance void class TailcallVerify.Condition10/Foo1`2::Test1() - IL_005f: leave.s IL_0080 + // Code size 32 (0x20) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: newobj instance void class [mscorlib]System.Collections.Generic.List`1::.ctor() + IL_0006: stfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::threadList + IL_000b: ldarg.0 + IL_000c: ldc.i4.3 + IL_000d: stfld int32 TailcallVerify.Condition21::counterE5 + IL_0012: ldarg.0 + IL_0013: ldc.i4.2 + IL_0014: stfld int32 TailcallVerify.Condition21::counterO5 + IL_0019: ldarg.0 + IL_001a: call instance void [mscorlib]System.Object::.ctor() + IL_001f: ret + } // end of method Condition21::.ctor - } // end .try - catch [mscorlib]System.Exception + .method private hidebysig specialname rtspecialname static + void .cctor() cil managed + { + // Code size 48 (0x30) + .maxstack 8 + IL_0000: ldc.i4.0 + IL_0001: volatile. + IL_0003: stsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition21::zero + IL_0008: ldc.i4.s 100 + IL_000a: stsfld int32 TailcallVerify.Condition21::Result + IL_000f: newobj instance void class [mscorlib]System.Collections.Generic.List`1::.ctor() + IL_0014: stsfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::evenList + IL_0019: newobj instance void class [mscorlib]System.Collections.Generic.List`1::.ctor() + IL_001e: stsfld class [mscorlib]System.Collections.Generic.List`1 TailcallVerify.Condition21::oddList + IL_0023: ldc.i4.3 + IL_0024: stsfld int32 TailcallVerify.Condition21::counterE4 + IL_0029: ldc.i4.2 + IL_002a: stsfld int32 TailcallVerify.Condition21::counterO4 + IL_002f: ret + } // end of method Condition21::.cctor + +} // end of class TailcallVerify.Condition21 + +.class private auto ansi beforefieldinit TailcallVerify.Condition10 + extends [mscorlib]System.Object +{ + .class auto ansi nested private beforefieldinit Foo1`2 + extends [mscorlib]System.Object + { + .field private int32 zero + .method public hidebysig instance void + Test1() cil managed nooptimization { - IL_0061: stloc.s e - IL_0063: ldloc.s e - IL_0065: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_006a: ldstr "Caller" - IL_006f: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_0074: ldc.i4.m1 - IL_0075: beq.s IL_007e + // Code size 91 (0x5b) + .maxstack 2 + .locals init ([0] class [mscorlib]System.Exception e) + .try + { + IL_0000: ldarg.0 + IL_0001: call instance void class TailcallVerify.Condition10/Foo1`2::Caller1() + IL_0006: leave.s IL_005a - IL_0077: ldc.i4.s 101 - IL_0079: stsfld int32 TailcallVerify.Condition10::Result - IL_007e: leave.s IL_0080 + } // end .try + catch [mscorlib]System.Exception + { + IL_0008: stloc.0 + IL_0009: ldloc.0 + IL_000a: isinst [mscorlib]System.DivideByZeroException + IL_000f: brtrue.s IL_001a - } // end handler - IL_0080: ldstr "Execution finished - Test " - IL_0085: ldsfld int32 TailcallVerify.Condition10::Result - IL_008a: ldc.i4.s 100 - IL_008c: beq.s IL_0095 + IL_0011: ldc.i4.s 101 + IL_0013: stsfld int32 TailcallVerify.Condition10::Result + IL_0018: rethrow + IL_001a: ldloc.0 + IL_001b: callvirt instance string [mscorlib]System.Exception::get_StackTrace() + IL_0020: ldstr "Caller" + IL_0025: callvirt instance int32 [mscorlib]System.String::IndexOf(string) + IL_002a: ldc.i4.m1 + IL_002b: beq.s IL_0058 - IL_008e: ldstr "FAILED" - IL_0093: br.s IL_009a + IL_002d: ldstr "FAILED: Found the word 'Caller' in the stacktrace." + IL_0032: call void [System.Console]System.Console::WriteLine(string) + IL_0037: ldstr "------------------------------------------------" + IL_003c: call void [System.Console]System.Console::WriteLine(string) + IL_0041: call void [System.Console]System.Console::WriteLine() + IL_0046: ldloc.0 + IL_0047: callvirt instance string [mscorlib]System.Exception::get_StackTrace() + IL_004c: call void [System.Console]System.Console::WriteLine(string) + IL_0051: call void [System.Console]System.Console::WriteLine() + IL_0056: rethrow + IL_0058: leave.s IL_005a - IL_0095: ldstr "PASSED" - IL_009a: call string [mscorlib]System.String::Concat(string, - string) - IL_009f: call void [System.Console]System.Console::WriteLine(string) - IL_00a4: ldsfld int32 TailcallVerify.Condition10::Result - IL_00a9: ret - } // end of method Condition10::Test3 + } // end handler + IL_005a: ret + } // end of method Foo1`2::Test1 - .method public hidebysig static int32 Test4() cil managed nooptimization - { - // Code size 161 (0xa1) - .maxstack 3 - .locals init ([0] class TailcallVerify.Condition10/Foo2`2 foo1, - [1] class TailcallVerify.Condition10/Foo2`2 foo2, - [2] class TailcallVerify.Condition10/Foo2`2 foo3, - [3] class TailcallVerify.Condition10/Foo2`2 foo4, - [4] class [mscorlib]System.Exception e) - IL_0000: ldstr "Executing Condition10.Test4 - class Foo2: Caller: Arguments: string, int - ReturnType: void; Callee: Argumen" - + "ts: string - ReturnType: void" - IL_0005: call void [System.Console]System.Console::WriteLine(string) - IL_000a: ldstr " class Foo2: Caller: Arguments: string, int - ReturnType: void; Callee: Argumen" - + "ts: string - ReturnType: void" - IL_000f: call void [System.Console]System.Console::WriteLine(string) - IL_0014: ldstr " class Foo2: Caller: Arguments: string, short - ReturnType: void; Callee: Arg" - + "uments: string - ReturnType: void" - IL_0019: call void [System.Console]System.Console::WriteLine(string) - IL_001e: ldstr " class Foo2: Caller: Arguments: string, ValueType3Bytes - ReturnTyp" - + "e: void; Callee: Arguments: string - ReturnType: void" - IL_0023: call void [System.Console]System.Console::WriteLine(string) - IL_0028: ldc.i4.s 100 - IL_002a: stsfld int32 TailcallVerify.Condition10::Result - .try + .method public hidebysig instance void + Test1Recursive() cil managed nooptimization { - IL_002f: newobj instance void class TailcallVerify.Condition10/Foo2`2::.ctor() - IL_0034: stloc.0 - IL_0035: newobj instance void class TailcallVerify.Condition10/Foo2`2::.ctor() - IL_003a: stloc.1 - IL_003b: newobj instance void class TailcallVerify.Condition10/Foo2`2::.ctor() - IL_0040: stloc.2 - IL_0041: newobj instance void class TailcallVerify.Condition10/Foo2`2::.ctor() - IL_0046: stloc.3 - IL_0047: ldloc.0 - IL_0048: callvirt instance void class TailcallVerify.Condition10/Foo2`2::Test1() - IL_004d: ldloc.1 - IL_004e: callvirt instance void class TailcallVerify.Condition10/Foo2`2::Test1() - IL_0053: ldloc.2 - IL_0054: callvirt instance void class TailcallVerify.Condition10/Foo2`2::Test1() - IL_0059: ldloc.3 - IL_005a: callvirt instance void class TailcallVerify.Condition10/Foo2`2::Test1() - IL_005f: leave.s IL_0077 + // Code size 91 (0x5b) + .maxstack 2 + .locals init ([0] class [mscorlib]System.Exception e) + .try + { + IL_0000: ldarg.0 + IL_0001: call instance void class TailcallVerify.Condition10/Foo1`2::Caller1Recursive() + IL_0006: leave.s IL_005a + + } // end .try + catch [mscorlib]System.Exception + { + IL_0008: stloc.0 + IL_0009: ldloc.0 + IL_000a: isinst [mscorlib]System.DivideByZeroException + IL_000f: brtrue.s IL_001a + + IL_0011: ldc.i4.s 101 + IL_0013: stsfld int32 TailcallVerify.Condition10::Result + IL_0018: rethrow + IL_001a: ldloc.0 + IL_001b: callvirt instance string [mscorlib]System.Exception::get_StackTrace() + IL_0020: ldstr "Caller" + IL_0025: callvirt instance int32 [mscorlib]System.String::IndexOf(string) + IL_002a: ldc.i4.m1 + IL_002b: beq.s IL_0058 - } // end .try - catch [mscorlib]System.Exception + IL_002d: ldstr "FAILED: Found the word 'Caller' in the stacktrace." + IL_0032: call void [System.Console]System.Console::WriteLine(string) + IL_0037: ldstr "------------------------------------------------" + IL_003c: call void [System.Console]System.Console::WriteLine(string) + IL_0041: call void [System.Console]System.Console::WriteLine() + IL_0046: ldloc.0 + IL_0047: callvirt instance string [mscorlib]System.Exception::get_StackTrace() + IL_004c: call void [System.Console]System.Console::WriteLine(string) + IL_0051: call void [System.Console]System.Console::WriteLine() + IL_0056: rethrow + IL_0058: leave.s IL_005a + + } // end handler + IL_005a: ret + } // end of method Foo1`2::Test1Recursive + + .method public hidebysig instance void + Caller1() cil managed { - IL_0061: stloc.s e - IL_0063: ldc.i4.s 101 - IL_0065: stsfld int32 TailcallVerify.Condition10::Result - IL_006a: ldloc.s e - IL_006c: isinst [mscorlib]System.DivideByZeroException - IL_0071: brtrue.s IL_0075 + // This method depends on JIT compiler doing automatic tail call, which isn't supported by Ready-to-Run. + .custom instance void System.Runtime.BypassReadyToRunAttribute::.ctor() = ( 01 00 00 00 ) - IL_0073: rethrow - IL_0075: leave.s IL_0077 + // Code size 53 (0x35) + .maxstack 8 + IL_0000: ldc.i4.0 + IL_0001: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) + IL_0006: callvirt instance class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Diagnostics.StackFrame::GetMethod() + IL_000b: callvirt instance string [mscorlib]System.Reflection.MemberInfo::get_Name() + IL_0010: ldstr "Caller" + IL_0015: callvirt instance int32 [mscorlib]System.String::IndexOf(string) + IL_001a: ldc.i4.m1 + IL_001b: bne.un.s IL_002e - } // end handler - IL_0077: ldstr "Execution finished - Test " - IL_007c: ldsfld int32 TailcallVerify.Condition10::Result - IL_0081: ldc.i4.s 100 - IL_0083: beq.s IL_008c + IL_001d: ldstr "Failed, Method was inlined..." + IL_0022: call void [System.Console]System.Console::WriteLine(string) + IL_0027: ldc.i4.s 101 + IL_0029: stsfld int32 TailcallVerify.Condition10::Result + IL_002e: ldarg.0 + IL_002f: call instance void class TailcallVerify.Condition10/Foo1`2::Callee1() + IL_0034: ret + } // end of method Foo1`2::Caller1 - IL_0085: ldstr "FAILED" - IL_008a: br.s IL_0091 + .method public hidebysig instance void + Caller1Recursive() cil managed + { + // This method depends on JIT compiler doing automatic tail call, which isn't supported by Ready-to-Run. + .custom instance void System.Runtime.BypassReadyToRunAttribute::.ctor() = ( 01 00 00 00 ) - IL_008c: ldstr "PASSED" - IL_0091: call string [mscorlib]System.String::Concat(string, - string) - IL_0096: call void [System.Console]System.Console::WriteLine(string) - IL_009b: ldsfld int32 TailcallVerify.Condition10::Result - IL_00a0: ret - } // end of method Condition10::Test4 + // Code size 55 (0x37) + .maxstack 8 + IL_0000: ldc.i4.0 + IL_0001: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) + IL_0006: callvirt instance class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Diagnostics.StackFrame::GetMethod() + IL_000b: callvirt instance string [mscorlib]System.Reflection.MemberInfo::get_Name() + IL_0010: ldstr "Caller" + IL_0015: callvirt instance int32 [mscorlib]System.String::IndexOf(string) + IL_001a: ldc.i4.m1 + IL_001b: bne.un.s IL_002e - .method public hidebysig static int32 Test5() cil managed nooptimization - { - // Code size 200 (0xc8) - .maxstack 3 - .locals init ([0] class TailcallVerify.Condition10/Foo1`2 foo1, - [1] class TailcallVerify.Condition10/Foo1`2 foo2, - [2] class TailcallVerify.Condition10/Foo1`2 foo3, - [3] class TailcallVerify.Condition10/Foo1`2 foo4, - [4] class [mscorlib]System.Exception e) - IL_0000: ldstr "Executing Condition10.Test5 - Caller: Arguments: N" - + "one - ReturnType: void; Callee: Arguments: None - ReturnType: v" - + "oid" - IL_0005: call void [System.Console]System.Console::WriteLine(string) - IL_000a: ldc.i4.s 100 - IL_000c: stsfld int32 TailcallVerify.Condition10::Result - .try + IL_001d: ldstr "Failed, Method was inlined..." + IL_0022: call void [System.Console]System.Console::WriteLine(string) + IL_0027: ldc.i4.s 101 + IL_0029: stsfld int32 TailcallVerify.Condition10::Result + IL_002e: ldarg.0 + IL_002f: ldc.i4.s 20 + IL_0031: call instance void class TailcallVerify.Condition10/Foo1`2::Callee1Recursive(int32) + IL_0036: ret + } // end of method Foo1`2::Caller1Recursive + + .method private hidebysig instance void + Callee1() cil managed noinlining { - IL_0011: newobj instance void class TailcallVerify.Condition10/Foo1`2::.ctor() - IL_0016: stloc.0 - IL_0017: newobj instance void class TailcallVerify.Condition10/Foo1`2::.ctor() - IL_001c: stloc.1 - IL_001d: newobj instance void class TailcallVerify.Condition10/Foo1`2::.ctor() - IL_0022: stloc.2 - IL_0023: newobj instance void class TailcallVerify.Condition10/Foo1`2::.ctor() - IL_0028: stloc.3 - IL_0029: ldloc.0 - IL_002a: callvirt instance void class TailcallVerify.Condition10/Foo1`2::Test1Recursive() - IL_002f: ldloc.1 - IL_0030: callvirt instance void class TailcallVerify.Condition10/Foo1`2::Test1Recursive() - IL_0035: ldloc.2 - IL_0036: callvirt instance void class TailcallVerify.Condition10/Foo1`2::Test1Recursive() - IL_003b: ldloc.3 - IL_003c: callvirt instance void class TailcallVerify.Condition10/Foo1`2::Test1Recursive() - IL_0041: leave.s IL_009e + // Code size 10 (0xa) + .maxstack 8 + IL_0000: ldc.i4.1 + IL_0001: ldarg.0 + IL_0002: ldfld int32 class TailcallVerify.Condition10/Foo1`2::zero + IL_0007: div + IL_0008: pop + IL_0009: ret + } // end of method Foo1`2::Callee1 - } // end .try - catch [mscorlib]System.Exception + .method private hidebysig instance void + Callee1Recursive(int32 i) cil managed { - IL_0043: stloc.s e - IL_0045: ldloc.s e - IL_0047: isinst [mscorlib]System.DivideByZeroException - IL_004c: brtrue.s IL_0057 + // This method depends on JIT compiler doing automatic tail call, which isn't supported by Ready-to-Run. + .custom instance void System.Runtime.BypassReadyToRunAttribute::.ctor() = ( 01 00 00 00 ) - IL_004e: ldc.i4.s 101 - IL_0050: stsfld int32 TailcallVerify.Condition10::Result - IL_0055: rethrow - IL_0057: ldloc.s e - IL_0059: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_005e: ldstr "Caller" - IL_0063: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_0068: ldc.i4.m1 - IL_0069: beq.s IL_009c + // Code size 93 (0x5d) + .maxstack 3 + .locals init ([0] string stackTrace, + [1] int32 count, + [2] int32 idx) + IL_0000: newobj instance void [mscorlib]System.Diagnostics.StackTrace::.ctor() + IL_0005: callvirt instance string [mscorlib]System.Object::ToString() + IL_000a: stloc.0 + IL_000b: ldc.i4.0 + IL_000c: stloc.1 + IL_000d: ldc.i4.0 + IL_000e: stloc.2 + IL_000f: br.s IL_0019 - IL_006b: ldstr "FAILED: Found the word 'Caller' in the stacktrace." - IL_0070: call void [System.Console]System.Console::WriteLine(string) - IL_0075: ldstr "------------------------------------------------" - IL_007a: call void [System.Console]System.Console::WriteLine(string) - IL_007f: call void [System.Console]System.Console::WriteLine() - IL_0084: ldloc.s e - IL_0086: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_008b: call void [System.Console]System.Console::WriteLine(string) - IL_0090: call void [System.Console]System.Console::WriteLine() - IL_0095: ldc.i4.s 101 - IL_0097: stsfld int32 TailcallVerify.Condition10::Result - IL_009c: leave.s IL_009e + IL_0011: ldloc.2 + IL_0012: ldc.i4.1 + IL_0013: add + IL_0014: stloc.2 + IL_0015: ldloc.1 + IL_0016: ldc.i4.1 + IL_0017: add + IL_0018: stloc.1 + IL_0019: ldloc.0 + IL_001a: ldstr "Callee" + IL_001f: ldloc.2 + IL_0020: callvirt instance int32 [mscorlib]System.String::IndexOf(string, + int32) + IL_0025: dup + IL_0026: stloc.2 + IL_0027: ldc.i4.m1 + IL_0028: bne.un.s IL_0011 - } // end handler - IL_009e: ldstr "Execution finished - Test " - IL_00a3: ldsfld int32 TailcallVerify.Condition10::Result - IL_00a8: ldc.i4.s 100 - IL_00aa: beq.s IL_00b3 + IL_002a: ldloc.1 + IL_002b: ldc.i4.1 + IL_002c: beq.s IL_0045 - IL_00ac: ldstr "FAILED" - IL_00b1: br.s IL_00b8 + IL_002e: ldstr "FAILED: Callee1Recursive was not tailcall'ed..." + IL_0033: call void [System.Console]System.Console::WriteLine(string) + IL_0038: ldloc.0 + IL_0039: call void [System.Console]System.Console::WriteLine(string) + IL_003e: ldc.i4.s 101 + IL_0040: stsfld int32 TailcallVerify.Condition10::Result + IL_0045: ldarg.1 + IL_0046: brtrue.s IL_0053 - IL_00b3: ldstr "PASSED" - IL_00b8: call string [mscorlib]System.String::Concat(string, - string) - IL_00bd: call void [System.Console]System.Console::WriteLine(string) - IL_00c2: ldsfld int32 TailcallVerify.Condition10::Result - IL_00c7: ret - } // end of method Condition10::Test5 + IL_0048: ldarg.1 + IL_0049: ldarg.0 + IL_004a: ldfld int32 class TailcallVerify.Condition10/Foo1`2::zero + IL_004f: div + IL_0050: starg.s i + IL_0052: ret - .method public hidebysig specialname rtspecialname - instance void .ctor() cil managed - { - // Code size 7 (0x7) - .maxstack 8 - IL_0000: ldarg.0 - IL_0001: call instance void [mscorlib]System.Object::.ctor() - IL_0006: ret - } // end of method Condition10::.ctor + IL_0053: ldarg.0 + IL_0054: ldarg.1 + IL_0055: ldc.i4.1 + IL_0056: sub + IL_0057: call instance void class TailcallVerify.Condition10/Foo1`2::Callee1Recursive(int32) + IL_005c: ret + } // end of method Foo1`2::Callee1Recursive - .method private hidebysig specialname rtspecialname static - void .cctor() cil managed - { - // Code size 16 (0x10) - .maxstack 8 - IL_0000: ldc.i4.0 - IL_0001: volatile. - IL_0003: stsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition10::zero - IL_0008: ldc.i4.s 100 - IL_000a: stsfld int32 TailcallVerify.Condition10::Result - IL_000f: ret - } // end of method Condition10::.cctor + .method public hidebysig specialname rtspecialname + instance void .ctor() cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: call instance void [mscorlib]System.Object::.ctor() + IL_0006: ret + } // end of method Foo1`2::.ctor -} // end of class TailcallVerify.Condition10 + } // end of class Foo1`2 -.class private auto ansi beforefieldinit TailcallVerify.Condition7 - extends [mscorlib]System.Object -{ - .field private static int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) zero - .field private static int32 Result - .method public hidebysig static int32 Test1() cil managed nooptimization + .class auto ansi nested private beforefieldinit Foo2`2 + extends [mscorlib]System.Object { - // Code size 153 (0x99) - .maxstack 3 - .locals init ([0] class [mscorlib]System.Exception e) - IL_0000: ldstr "Executing Condition7.Test1 - Caller: Arguments: No" - + "ne - ReturnType: void; Callee: Arguments: 10 x Int32 - ReturnType: void" - IL_0005: call void [System.Console]System.Console::WriteLine(string) - IL_000a: ldc.i4.s 100 - IL_000c: stsfld int32 TailcallVerify.Condition7::Result - .try + .field private int32 zero + .method public hidebysig instance void + Test1() cil managed nooptimization { - IL_0011: call void TailcallVerify.Condition7::Caller1() - IL_0016: leave.s IL_006f + // Code size 109 (0x6d) + .maxstack 3 + .locals init ([0] !V arg1, + [1] !K arg2, + [2] class [mscorlib]System.Exception e) + .try + { + IL_0000: ldloca.s arg1 + IL_0002: initobj !V + IL_0008: ldloca.s arg2 + IL_000a: initobj !K + IL_0010: ldarg.0 + IL_0011: ldloc.0 + IL_0012: ldloc.1 + IL_0013: call instance void class TailcallVerify.Condition10/Foo2`2::Caller1(!0, + !1) + IL_0018: leave.s IL_006c - } // end .try - catch [mscorlib]System.Exception - { - IL_0018: stloc.0 - IL_0019: ldloc.0 - IL_001a: isinst [mscorlib]System.DivideByZeroException - IL_001f: brtrue.s IL_002a + } // end .try + catch [mscorlib]System.Exception + { + IL_001a: stloc.2 + IL_001b: ldloc.2 + IL_001c: isinst [mscorlib]System.DivideByZeroException + IL_0021: brtrue.s IL_002c - IL_0021: ldc.i4.s 101 - IL_0023: stsfld int32 TailcallVerify.Condition7::Result - IL_0028: rethrow - IL_002a: ldloc.0 - IL_002b: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_0030: ldstr "Caller" - IL_0035: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_003a: ldc.i4.m1 - IL_003b: beq.s IL_006d + IL_0023: ldc.i4.s 101 + IL_0025: stsfld int32 TailcallVerify.Condition10::Result + IL_002a: rethrow + IL_002c: ldloc.2 + IL_002d: callvirt instance string [mscorlib]System.Exception::get_StackTrace() + IL_0032: ldstr "Caller" + IL_0037: callvirt instance int32 [mscorlib]System.String::IndexOf(string) + IL_003c: ldc.i4.m1 + IL_003d: beq.s IL_006a - IL_003d: ldstr "FAILED: Found the word 'Caller' in the stacktrace." - IL_0042: call void [System.Console]System.Console::WriteLine(string) - IL_0047: ldstr "------------------------------------------------" - IL_004c: call void [System.Console]System.Console::WriteLine(string) - IL_0051: call void [System.Console]System.Console::WriteLine() - IL_0056: ldloc.0 - IL_0057: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_005c: call void [System.Console]System.Console::WriteLine(string) - IL_0061: call void [System.Console]System.Console::WriteLine() - IL_0066: ldc.i4.s 101 - IL_0068: stsfld int32 TailcallVerify.Condition7::Result - IL_006d: leave.s IL_006f + IL_003f: ldstr "FAILED: Found the word 'Caller' in the stacktrace." + IL_0044: call void [System.Console]System.Console::WriteLine(string) + IL_0049: ldstr "------------------------------------------------" + IL_004e: call void [System.Console]System.Console::WriteLine(string) + IL_0053: call void [System.Console]System.Console::WriteLine() + IL_0058: ldloc.2 + IL_0059: callvirt instance string [mscorlib]System.Exception::get_StackTrace() + IL_005e: call void [System.Console]System.Console::WriteLine(string) + IL_0063: call void [System.Console]System.Console::WriteLine() + IL_0068: rethrow + IL_006a: leave.s IL_006c - } // end handler - IL_006f: ldstr "Execution finished - Test " - IL_0074: ldsfld int32 TailcallVerify.Condition7::Result - IL_0079: ldc.i4.s 100 - IL_007b: beq.s IL_0084 + } // end handler + IL_006c: ret + } // end of method Foo2`2::Test1 - IL_007d: ldstr "FAILED" - IL_0082: br.s IL_0089 + .method public hidebysig instance void + Caller1(!V arg1, + !K arg2) cil managed + { + // This method depends on JIT compiler doing automatic tail call, which isn't supported by Ready-to-Run. + .custom instance void System.Runtime.BypassReadyToRunAttribute::.ctor() = ( 01 00 00 00 ) - IL_0084: ldstr "PASSED" - IL_0089: call string [mscorlib]System.String::Concat(string, - string) - IL_008e: call void [System.Console]System.Console::WriteLine(string) - IL_0093: ldsfld int32 TailcallVerify.Condition7::Result - IL_0098: ret - } // end of method Condition7::Test1 + // Code size 54 (0x36) + .maxstack 8 + IL_0000: ldc.i4.0 + IL_0001: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) + IL_0006: callvirt instance class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Diagnostics.StackFrame::GetMethod() + IL_000b: callvirt instance string [mscorlib]System.Reflection.MemberInfo::get_Name() + IL_0010: ldstr "Caller" + IL_0015: callvirt instance int32 [mscorlib]System.String::IndexOf(string) + IL_001a: ldc.i4.m1 + IL_001b: bne.un.s IL_002e - .method private hidebysig static void Caller1() cil managed - { - // Code size 63 (0x3f) - .maxstack 10 - IL_0000: ldc.i4.0 - IL_0001: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) - IL_0006: callvirt instance class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Diagnostics.StackFrame::GetMethod() - IL_000b: callvirt instance string [mscorlib]System.Reflection.MemberInfo::get_Name() - IL_0010: ldstr "Caller" - IL_0015: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_001a: ldc.i4.m1 - IL_001b: bne.un.s IL_002e + IL_001d: ldstr "Failed, Method was inlined..." + IL_0022: call void [System.Console]System.Console::WriteLine(string) + IL_0027: ldc.i4.s 101 + IL_0029: stsfld int32 TailcallVerify.Condition10::Result + IL_002e: ldarg.0 + IL_002f: ldarg.1 + IL_0030: call instance void class TailcallVerify.Condition10/Foo2`2::Callee1(!0) + IL_0035: ret + } // end of method Foo2`2::Caller1 - IL_001d: ldstr "Failed, Method was inlined..." - IL_0022: call void [System.Console]System.Console::WriteLine(string) - IL_0027: ldc.i4.s 101 - IL_0029: stsfld int32 TailcallVerify.Condition7::Result - IL_002e: ldc.i4.0 - IL_002f: ldc.i4.1 - IL_0030: ldc.i4.2 - IL_0031: ldc.i4.3 - IL_0032: ldc.i4.4 - IL_0033: ldc.i4.5 - IL_0034: ldc.i4.6 - IL_0035: ldc.i4.7 - IL_0036: ldc.i4.8 - IL_0037: ldc.i4.s 9 - IL_0039: tail. call void TailcallVerify.Condition7::Callee1(int32, - int32, - int32, - int32, - int32, - int32, - int32, - int32, - int32, - int32) - IL_003e: ret - } // end of method Condition7::Caller1 + .method private hidebysig instance void + Callee1(!V arg1) cil managed noinlining + { + // Code size 10 (0xa) + .maxstack 8 + IL_0000: ldc.i4.1 + IL_0001: ldarg.0 + IL_0002: ldfld int32 class TailcallVerify.Condition10/Foo2`2::zero + IL_0007: div + IL_0008: pop + IL_0009: ret + } // end of method Foo2`2::Callee1 - .method private hidebysig static void Callee1(int32 i1, - int32 i2, - int32 i3, - int32 i4, - int32 i5, - int32 i6, - int32 i7, - int32 i8, - int32 i9, - int32 i10) cil managed noinlining - { - // Code size 11 (0xb) - .maxstack 8 - IL_0000: ldarg.0 - IL_0001: volatile. - IL_0003: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition7::zero - IL_0008: div - IL_0009: pop - IL_000a: ret - } // end of method Condition7::Callee1 + .method public hidebysig specialname rtspecialname + instance void .ctor() cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: call instance void [mscorlib]System.Object::.ctor() + IL_0006: ret + } // end of method Foo2`2::.ctor - .method public hidebysig static int32 Test2() cil managed nooptimization + } // end of class Foo2`2 + + .field private static int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) zero + .field private static int32 Result + .method public hidebysig static int32 Test1() cil managed nooptimization { // Code size 153 (0x99) .maxstack 3 .locals init ([0] class [mscorlib]System.Exception e) - IL_0000: ldstr "Executing Condition7.Test2 - Caller: Arguments: No" - + "ne - ReturnType: void; Callee: Arguments: i32,i64,mb3,i16,u8,f64,f32,mb" - + "5 - ReturnType: void" + IL_0000: ldstr "Executing Condition10.Test1 - Caller: Argu" + + "ments: None - ReturnType: void; Callee: Arguments: None - ReturnType: v" + + "oid" IL_0005: call void [System.Console]System.Console::WriteLine(string) IL_000a: ldc.i4.s 100 - IL_000c: stsfld int32 TailcallVerify.Condition7::Result + IL_000c: stsfld int32 TailcallVerify.Condition10::Result .try { - IL_0011: call void TailcallVerify.Condition7::Caller2() + IL_0011: call void TailcallVerify.Condition10::Caller1() IL_0016: leave.s IL_006f } // end .try @@ -6491,7 +3599,7 @@ IL_001f: brtrue.s IL_002a IL_0021: ldc.i4.s 101 - IL_0023: stsfld int32 TailcallVerify.Condition7::Result + IL_0023: stsfld int32 TailcallVerify.Condition10::Result IL_0028: rethrow IL_002a: ldloc.0 IL_002b: callvirt instance string [mscorlib]System.Exception::get_StackTrace() @@ -6510,12 +3618,12 @@ IL_005c: call void [System.Console]System.Console::WriteLine(string) IL_0061: call void [System.Console]System.Console::WriteLine() IL_0066: ldc.i4.s 101 - IL_0068: stsfld int32 TailcallVerify.Condition7::Result + IL_0068: stsfld int32 TailcallVerify.Condition10::Result IL_006d: leave.s IL_006f } // end handler IL_006f: ldstr "Execution finished - Test " - IL_0074: ldsfld int32 TailcallVerify.Condition7::Result + IL_0074: ldsfld int32 TailcallVerify.Condition10::Result IL_0079: ldc.i4.s 100 IL_007b: beq.s IL_0084 @@ -6526,20 +3634,14 @@ IL_0089: call string [mscorlib]System.String::Concat(string, string) IL_008e: call void [System.Console]System.Console::WriteLine(string) - IL_0093: ldsfld int32 TailcallVerify.Condition7::Result + IL_0093: ldsfld int32 TailcallVerify.Condition10::Result IL_0098: ret - } // end of method Condition7::Test2 + } // end of method Condition10::Test1 - .method private hidebysig static void Caller2() cil managed + .method private hidebysig static void Caller1() cil managed { - // Code size 174 (0xae) + // Code size 52 (0x34) .maxstack 8 - .locals init ([0] valuetype TailcallVerify.ValueType3Bytes v3, - [1] valuetype TailcallVerify.ValueType5Bytes v5, - [2] valuetype TailcallVerify.ValueType3Bytes '<>g__initLocal0', - [3] valuetype TailcallVerify.ValueType5Bytes '<>g__initLocal1', - [4] valuetype TailcallVerify.ValueType3Bytes CS$0$0000, - [5] valuetype TailcallVerify.ValueType5Bytes CS$0$0001) IL_0000: ldc.i4.0 IL_0001: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) IL_0006: callvirt instance class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Diagnostics.StackFrame::GetMethod() @@ -6552,292 +3654,93 @@ IL_001d: ldstr "Failed, Method was inlined..." IL_0022: call void [System.Console]System.Console::WriteLine(string) IL_0027: ldc.i4.s 101 - IL_0029: stsfld int32 TailcallVerify.Condition7::Result - IL_002e: ldloca.s CS$0$0000 - IL_0030: initobj TailcallVerify.ValueType3Bytes - IL_0036: ldloc.s CS$0$0000 - IL_0038: stloc.2 - IL_0039: ldloca.s '<>g__initLocal0' - IL_003b: ldc.i4.0 - IL_003c: stfld uint8 TailcallVerify.ValueType3Bytes::i1 - IL_0041: ldloca.s '<>g__initLocal0' - IL_0043: ldc.i4 0x7fff - IL_0048: stfld int16 TailcallVerify.ValueType3Bytes::i2 - IL_004d: ldloc.2 - IL_004e: stloc.0 - IL_004f: ldloca.s CS$0$0001 - IL_0051: initobj TailcallVerify.ValueType5Bytes - IL_0057: ldloc.s CS$0$0001 - IL_0059: stloc.3 - IL_005a: ldloca.s '<>g__initLocal1' - IL_005c: ldc.i4 0xff - IL_0061: stfld uint8 TailcallVerify.ValueType5Bytes::i1 - IL_0066: ldloca.s '<>g__initLocal1' - IL_0068: ldc.i4 0xffff8000 - IL_006d: stfld int16 TailcallVerify.ValueType5Bytes::i2 - IL_0072: ldloca.s '<>g__initLocal1' - IL_0074: ldc.i4 0x7fff - IL_0079: stfld int16 TailcallVerify.ValueType5Bytes::i3 - IL_007e: ldloc.3 - IL_007f: stloc.1 - IL_0080: ldc.i4 0x80000000 - IL_0085: ldc.i8 0x7fffffffffffffff - IL_008e: ldloc.0 - IL_008f: ldc.i4 0xffff8000 - IL_0094: ldc.i4 0xff - IL_0099: ldc.r8 -1.7976931348623157e+308 - IL_00a2: ldc.r4 3.4028235e+038 - IL_00a7: ldloc.1 - IL_00a8: tail. call void TailcallVerify.Condition7::Callee2(int32, - int64, - valuetype TailcallVerify.ValueType3Bytes, - int16, - uint8, - float64, - float32, - valuetype TailcallVerify.ValueType5Bytes) - IL_00ad: ret - } // end of method Condition7::Caller2 + IL_0029: stsfld int32 TailcallVerify.Condition10::Result + IL_002e: tail. call void TailcallVerify.Condition10::Callee1() + IL_0033: ret + } // end of method Condition10::Caller1 - .method private hidebysig static void Callee2(int32 i1, - int64 i2, - valuetype TailcallVerify.ValueType3Bytes v3, - int16 i4, - uint8 b5, - float64 d6, - float32 f7, - valuetype TailcallVerify.ValueType5Bytes v8) cil managed noinlining + .method private hidebysig static void Callee1() cil managed noinlining { - // Code size 308 (0x134) - .maxstack 4 - .locals init ([0] object[] CS$0$0000) - IL_0000: ldarg.0 - IL_0001: ldc.i4 0x80000000 - IL_0006: bne.un.s IL_007f - - IL_0008: ldarg.1 - IL_0009: ldc.i8 0x7fffffffffffffff - IL_0012: bne.un.s IL_007f - - IL_0014: ldarga.s v3 - IL_0016: ldfld uint8 TailcallVerify.ValueType3Bytes::i1 - IL_001b: brtrue.s IL_007f - - IL_001d: ldarga.s v3 - IL_001f: ldfld int16 TailcallVerify.ValueType3Bytes::i2 - IL_0024: ldc.i4 0x7fff - IL_0029: bne.un.s IL_007f - - IL_002b: ldarg.3 - IL_002c: ldc.i4 0xffff8000 - IL_0031: bne.un.s IL_007f - - IL_0033: ldarg.s b5 - IL_0035: ldc.i4 0xff - IL_003a: bne.un.s IL_007f - - IL_003c: ldarg.s d6 - IL_003e: ldc.r8 -1.7976931348623157e+308 - IL_0047: bne.un.s IL_007f - - IL_0049: ldarg.s f7 - IL_004b: ldc.r4 3.4028235e+038 - IL_0050: bne.un.s IL_007f - - IL_0052: ldarga.s v8 - IL_0054: ldfld uint8 TailcallVerify.ValueType5Bytes::i1 - IL_0059: ldc.i4 0xff - IL_005e: bne.un.s IL_007f - - IL_0060: ldarga.s v8 - IL_0062: ldfld int16 TailcallVerify.ValueType5Bytes::i2 - IL_0067: ldc.i4 0xffff8000 - IL_006c: bne.un.s IL_007f - - IL_006e: ldarga.s v8 - IL_0070: ldfld int16 TailcallVerify.ValueType5Bytes::i3 - IL_0075: ldc.i4 0x7fff - IL_007a: beq IL_0129 - - IL_007f: ldc.i4.s 101 - IL_0081: stsfld int32 TailcallVerify.Condition7::Result - IL_0086: ldstr "FAILED: Passed in arguments are invalid." - IL_008b: call void [System.Console]System.Console::WriteLine(string) - IL_0090: ldstr "i1:{0} != Int32.MinValue || i2:{1} != Int64.MaxVal" - + "ue || v3.i1:{2} != byte.MinValue || v3.i2:{3} != short.MaxValue || i4:{" - + "4} != Int16.MinValue || b5:{5} != byte.MaxValue || d6:{6} != double.Min" - + "Value || f7:{7} != float.MaxValue || v8.i1:{8} != byte.MaxValue || v8.i" - + "2:{9} != short.MinValue || v8.i3:{10} != short.MaxValue" - IL_0095: ldc.i4.s 11 - IL_0097: newarr [mscorlib]System.Object - IL_009c: stloc.0 - IL_009d: ldloc.0 - IL_009e: ldc.i4.0 - IL_009f: ldarg.0 - IL_00a0: box [mscorlib]System.Int32 - IL_00a5: stelem.ref - IL_00a6: ldloc.0 - IL_00a7: ldc.i4.1 - IL_00a8: ldarg.1 - IL_00a9: box [mscorlib]System.Int64 - IL_00ae: stelem.ref - IL_00af: ldloc.0 - IL_00b0: ldc.i4.2 - IL_00b1: ldarga.s v3 - IL_00b3: ldfld uint8 TailcallVerify.ValueType3Bytes::i1 - IL_00b8: box [mscorlib]System.Byte - IL_00bd: stelem.ref - IL_00be: ldloc.0 - IL_00bf: ldc.i4.3 - IL_00c0: ldarga.s v3 - IL_00c2: ldfld int16 TailcallVerify.ValueType3Bytes::i2 - IL_00c7: box [mscorlib]System.Int16 - IL_00cc: stelem.ref - IL_00cd: ldloc.0 - IL_00ce: ldc.i4.4 - IL_00cf: ldarg.3 - IL_00d0: box [mscorlib]System.Int16 - IL_00d5: stelem.ref - IL_00d6: ldloc.0 - IL_00d7: ldc.i4.5 - IL_00d8: ldarg.s b5 - IL_00da: box [mscorlib]System.Byte - IL_00df: stelem.ref - IL_00e0: ldloc.0 - IL_00e1: ldc.i4.6 - IL_00e2: ldarg.s d6 - IL_00e4: box [mscorlib]System.Double - IL_00e9: stelem.ref - IL_00ea: ldloc.0 - IL_00eb: ldc.i4.7 - IL_00ec: ldarg.s f7 - IL_00ee: box [mscorlib]System.Single - IL_00f3: stelem.ref - IL_00f4: ldloc.0 - IL_00f5: ldc.i4.8 - IL_00f6: ldarga.s v8 - IL_00f8: ldfld uint8 TailcallVerify.ValueType5Bytes::i1 - IL_00fd: box [mscorlib]System.Byte - IL_0102: stelem.ref - IL_0103: ldloc.0 - IL_0104: ldc.i4.s 9 - IL_0106: ldarga.s v8 - IL_0108: ldfld int16 TailcallVerify.ValueType5Bytes::i2 - IL_010d: box [mscorlib]System.Int16 - IL_0112: stelem.ref - IL_0113: ldloc.0 - IL_0114: ldc.i4.s 10 - IL_0116: ldarga.s v8 - IL_0118: ldfld int16 TailcallVerify.ValueType5Bytes::i3 - IL_011d: box [mscorlib]System.Int16 - IL_0122: stelem.ref - IL_0123: ldloc.0 - IL_0124: call void [System.Console]System.Console::Write(string) - callvirt instance string [mscorlib]System.Object::ToString() - call void [System.Console]System.Console::WriteLine(string) - - IL_0129: ldc.i4.1 - IL_012a: volatile. - IL_012c: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition7::zero - IL_0131: div - IL_0132: pop - IL_0133: ret - } // end of method Condition7::Callee2 + // Code size 11 (0xb) + .maxstack 8 + IL_0000: ldc.i4.1 + IL_0001: volatile. + IL_0003: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition10::zero + IL_0008: div + IL_0009: pop + IL_000a: ret + } // end of method Condition10::Callee1 - .method public hidebysig static int32 Test3() cil managed nooptimization + .method public hidebysig static int32 Test2() cil managed nooptimization { - // Code size 193 (0xc1) - .maxstack 6 - .locals init ([0] class [mscorlib]System.Exception e, - [1] valuetype TailcallVerify.ValueType3Bytes CS$0$0000, - [2] valuetype TailcallVerify.ValueType5Bytes CS$0$0001, - [3] valuetype TailcallVerify.ValueTypeSingleInt64 CS$0$0002, - [4] valuetype TailcallVerify.ValueType3Bytes CS$0$0003, - [5] valuetype TailcallVerify.ValueType5Bytes CS$0$0004, - [6] valuetype TailcallVerify.ValueType3Bytes CS$0$0005) - IL_0000: ldstr "Executing Condition7.Test3 - Caller: Arguments: mb" - + "3,mb5,mb8,mb3,mb5,mb3 - ReturnType: void; Callee: Arguments: mb3,mb5,mb" - + "8,mb3,mb5,mb3 - ReturnType: void" - IL_0005: call void [System.Console]System.Console::WriteLine(string) - IL_000a: ldc.i4.s 100 - IL_000c: stsfld int32 TailcallVerify.Condition7::Result - .try - { - IL_0011: ldloca.s CS$0$0000 - IL_0013: initobj TailcallVerify.ValueType3Bytes - IL_0019: ldloc.1 - IL_001a: ldloca.s CS$0$0001 - IL_001c: initobj TailcallVerify.ValueType5Bytes - IL_0022: ldloc.2 - IL_0023: ldloca.s CS$0$0002 - IL_0025: initobj TailcallVerify.ValueTypeSingleInt64 - IL_002b: ldloc.3 - IL_002c: ldloca.s CS$0$0003 - IL_002e: initobj TailcallVerify.ValueType3Bytes - IL_0034: ldloc.s CS$0$0003 - IL_0036: ldloca.s CS$0$0004 - IL_0038: initobj TailcallVerify.ValueType5Bytes - IL_003e: ldloc.s CS$0$0004 - IL_0040: ldloca.s CS$0$0005 - IL_0042: initobj TailcallVerify.ValueType3Bytes - IL_0048: ldloc.s CS$0$0005 - IL_004a: call void TailcallVerify.Condition7::Caller3(valuetype TailcallVerify.ValueType3Bytes, - valuetype TailcallVerify.ValueType5Bytes, - valuetype TailcallVerify.ValueTypeSingleInt64, - valuetype TailcallVerify.ValueType3Bytes, - valuetype TailcallVerify.ValueType5Bytes, - valuetype TailcallVerify.ValueType3Bytes) - IL_004f: leave.s IL_0097 + // Code size 153 (0x99) + .maxstack 3 + .locals init ([0] class [mscorlib]System.Exception e) + IL_0000: ldstr "Executing Condition10.Test2 - Caller: Arguments: N" + + "one - ReturnType: void; Callee: Arguments: None - ReturnType: v" + + "oid" + IL_0005: call void [System.Console]System.Console::WriteLine(string) + IL_000a: ldc.i4.s 100 + IL_000c: stsfld int32 TailcallVerify.Condition10::Result + .try + { + IL_0011: call void TailcallVerify.Condition10::Caller2() + IL_0016: leave.s IL_006f } // end .try catch [mscorlib]System.Exception { - IL_0051: stloc.0 - IL_0052: ldloc.0 - IL_0053: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_0058: ldstr "Caller" - IL_005d: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_0062: ldc.i4.m1 - IL_0063: beq.s IL_0095 + IL_0018: stloc.0 + IL_0019: ldloc.0 + IL_001a: isinst [mscorlib]System.DivideByZeroException + IL_001f: brtrue.s IL_002a - IL_0065: ldstr "FAILED: Found the word 'Caller' in the stacktrace." - IL_006a: call void [System.Console]System.Console::WriteLine(string) - IL_006f: ldstr "------------------------------------------------" - IL_0074: call void [System.Console]System.Console::WriteLine(string) - IL_0079: call void [System.Console]System.Console::WriteLine() - IL_007e: ldloc.0 - IL_007f: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_0084: call void [System.Console]System.Console::WriteLine(string) - IL_0089: call void [System.Console]System.Console::WriteLine() - IL_008e: ldc.i4.s 101 - IL_0090: stsfld int32 TailcallVerify.Condition7::Result - IL_0095: leave.s IL_0097 + IL_0021: ldc.i4.s 101 + IL_0023: stsfld int32 TailcallVerify.Condition10::Result + IL_0028: rethrow + IL_002a: ldloc.0 + IL_002b: callvirt instance string [mscorlib]System.Exception::get_StackTrace() + IL_0030: ldstr "Caller" + IL_0035: callvirt instance int32 [mscorlib]System.String::IndexOf(string) + IL_003a: ldc.i4.m1 + IL_003b: beq.s IL_006d + + IL_003d: ldstr "FAILED: Found the word 'Caller' in the stacktrace." + IL_0042: call void [System.Console]System.Console::WriteLine(string) + IL_0047: ldstr "------------------------------------------------" + IL_004c: call void [System.Console]System.Console::WriteLine(string) + IL_0051: call void [System.Console]System.Console::WriteLine() + IL_0056: ldloc.0 + IL_0057: callvirt instance string [mscorlib]System.Exception::get_StackTrace() + IL_005c: call void [System.Console]System.Console::WriteLine(string) + IL_0061: call void [System.Console]System.Console::WriteLine() + IL_0066: ldc.i4.s 101 + IL_0068: stsfld int32 TailcallVerify.Condition10::Result + IL_006d: leave.s IL_006f } // end handler - IL_0097: ldstr "Execution finished - Test " - IL_009c: ldsfld int32 TailcallVerify.Condition7::Result - IL_00a1: ldc.i4.s 100 - IL_00a3: beq.s IL_00ac + IL_006f: ldstr "Execution finished - Test " + IL_0074: ldsfld int32 TailcallVerify.Condition10::Result + IL_0079: ldc.i4.s 100 + IL_007b: beq.s IL_0084 - IL_00a5: ldstr "FAILED" - IL_00aa: br.s IL_00b1 + IL_007d: ldstr "FAILED" + IL_0082: br.s IL_0089 - IL_00ac: ldstr "PASSED" - IL_00b1: call string [mscorlib]System.String::Concat(string, + IL_0084: ldstr "PASSED" + IL_0089: call string [mscorlib]System.String::Concat(string, string) - IL_00b6: call void [System.Console]System.Console::WriteLine(string) - IL_00bb: ldsfld int32 TailcallVerify.Condition7::Result - IL_00c0: ret - } // end of method Condition7::Test3 + IL_008e: call void [System.Console]System.Console::WriteLine(string) + IL_0093: ldsfld int32 TailcallVerify.Condition10::Result + IL_0098: ret + } // end of method Condition10::Test2 - .method private hidebysig static void Caller3(valuetype TailcallVerify.ValueType3Bytes v1, - valuetype TailcallVerify.ValueType5Bytes v2, - valuetype TailcallVerify.ValueTypeSingleInt64 v3, - valuetype TailcallVerify.ValueType3Bytes v4, - valuetype TailcallVerify.ValueType5Bytes v5, - valuetype TailcallVerify.ValueType3Bytes v6) cil managed + .method private hidebysig static void Caller2() cil managed { - // Code size 60 (0x3c) + // This method depends on JIT compiler doing automatic tail call, which isn't supported by Ready-to-Run. + .custom instance void System.Runtime.BypassReadyToRunAttribute::.ctor() = ( 01 00 00 00 ) + + // Code size 52 (0x34) .maxstack 8 IL_0000: ldc.i4.0 IL_0001: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) @@ -6848,198 +3751,264 @@ IL_001a: ldc.i4.m1 IL_001b: bne.un.s IL_002e - IL_001d: ldstr "Failed, Method was inlined..." - IL_0022: call void [System.Console]System.Console::WriteLine(string) - IL_0027: ldc.i4.s 101 - IL_0029: stsfld int32 TailcallVerify.Condition7::Result - IL_002e: ldarg.0 - IL_002f: ldarg.1 - IL_0030: ldarg.2 - IL_0031: ldarg.3 - IL_0032: ldarg.s v5 - IL_0034: ldarg.s v6 - IL_0036: tail. call void TailcallVerify.Condition7::Callee3(valuetype TailcallVerify.ValueType3Bytes, - valuetype TailcallVerify.ValueType5Bytes, - valuetype TailcallVerify.ValueTypeSingleInt64, - valuetype TailcallVerify.ValueType3Bytes, - valuetype TailcallVerify.ValueType5Bytes, - valuetype TailcallVerify.ValueType3Bytes) - IL_003b: ret - } // end of method Condition7::Caller3 + IL_001d: ldstr "Failed, Method was inlined..." + IL_0022: call void [System.Console]System.Console::WriteLine(string) + IL_0027: ldc.i4.s 101 + IL_0029: stsfld int32 TailcallVerify.Condition10::Result + IL_002e: call void TailcallVerify.Condition10::Callee2() + IL_0033: ret + } // end of method Condition10::Caller2 + + .method private hidebysig static void Callee2() cil managed noinlining + { + // Code size 11 (0xb) + .maxstack 8 + IL_0000: ldc.i4.1 + IL_0001: volatile. + IL_0003: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition10::zero + IL_0008: div + IL_0009: pop + IL_000a: ret + } // end of method Condition10::Callee2 + + .method public hidebysig static int32 Test3() cil managed nooptimization + { + // Code size 170 (0xaa) + .maxstack 3 + .locals init ([0] class TailcallVerify.Condition10/Foo1`2 foo1, + [1] class TailcallVerify.Condition10/Foo1`2 foo2, + [2] class TailcallVerify.Condition10/Foo1`2 foo3, + [3] class TailcallVerify.Condition10/Foo1`2 foo4, + [4] class [mscorlib]System.Exception e) + IL_0000: ldstr "Executing Condition10.Test3 - class Foo1: Caller: Arguments: None - ReturnType: void; Callee: Arguments: Non" + + "e - ReturnType: void" + IL_0005: call void [System.Console]System.Console::WriteLine(string) + IL_000a: ldstr " class Foo1: Caller: Arguments: None - ReturnType: void; Callee: Arguments: Non" + + "e - ReturnType: void" + IL_000f: call void [System.Console]System.Console::WriteLine(string) + IL_0014: ldstr " class Foo1: Caller: Arguments: None - ReturnType: void; Callee: Arguments: N" + + "one - ReturnType: void" + IL_0019: call void [System.Console]System.Console::WriteLine(string) + IL_001e: ldstr " class Foo1: Caller: Arguments: None - ReturnType: void; Callee: Ar" + + "guments: None - ReturnType: void" + IL_0023: call void [System.Console]System.Console::WriteLine(string) + IL_0028: ldc.i4.s 100 + IL_002a: stsfld int32 TailcallVerify.Condition10::Result + .try + { + IL_002f: newobj instance void class TailcallVerify.Condition10/Foo1`2::.ctor() + IL_0034: stloc.0 + IL_0035: newobj instance void class TailcallVerify.Condition10/Foo1`2::.ctor() + IL_003a: stloc.1 + IL_003b: newobj instance void class TailcallVerify.Condition10/Foo1`2::.ctor() + IL_0040: stloc.2 + IL_0041: newobj instance void class TailcallVerify.Condition10/Foo1`2::.ctor() + IL_0046: stloc.3 + IL_0047: ldloc.0 + IL_0048: callvirt instance void class TailcallVerify.Condition10/Foo1`2::Test1() + IL_004d: ldloc.1 + IL_004e: callvirt instance void class TailcallVerify.Condition10/Foo1`2::Test1() + IL_0053: ldloc.2 + IL_0054: callvirt instance void class TailcallVerify.Condition10/Foo1`2::Test1() + IL_0059: ldloc.3 + IL_005a: callvirt instance void class TailcallVerify.Condition10/Foo1`2::Test1() + IL_005f: leave.s IL_0080 + + } // end .try + catch [mscorlib]System.Exception + { + IL_0061: stloc.s e + IL_0063: ldloc.s e + IL_0065: callvirt instance string [mscorlib]System.Exception::get_StackTrace() + IL_006a: ldstr "Caller" + IL_006f: callvirt instance int32 [mscorlib]System.String::IndexOf(string) + IL_0074: ldc.i4.m1 + IL_0075: beq.s IL_007e + + IL_0077: ldc.i4.s 101 + IL_0079: stsfld int32 TailcallVerify.Condition10::Result + IL_007e: leave.s IL_0080 + + } // end handler + IL_0080: ldstr "Execution finished - Test " + IL_0085: ldsfld int32 TailcallVerify.Condition10::Result + IL_008a: ldc.i4.s 100 + IL_008c: beq.s IL_0095 + + IL_008e: ldstr "FAILED" + IL_0093: br.s IL_009a + + IL_0095: ldstr "PASSED" + IL_009a: call string [mscorlib]System.String::Concat(string, + string) + IL_009f: call void [System.Console]System.Console::WriteLine(string) + IL_00a4: ldsfld int32 TailcallVerify.Condition10::Result + IL_00a9: ret + } // end of method Condition10::Test3 + + .method public hidebysig static int32 Test4() cil managed nooptimization + { + // Code size 161 (0xa1) + .maxstack 3 + .locals init ([0] class TailcallVerify.Condition10/Foo2`2 foo1, + [1] class TailcallVerify.Condition10/Foo2`2 foo2, + [2] class TailcallVerify.Condition10/Foo2`2 foo3, + [3] class TailcallVerify.Condition10/Foo2`2 foo4, + [4] class [mscorlib]System.Exception e) + IL_0000: ldstr "Executing Condition10.Test4 - class Foo2: Caller: Arguments: string, int - ReturnType: void; Callee: Argumen" + + "ts: string - ReturnType: void" + IL_0005: call void [System.Console]System.Console::WriteLine(string) + IL_000a: ldstr " class Foo2: Caller: Arguments: string, int - ReturnType: void; Callee: Argumen" + + "ts: string - ReturnType: void" + IL_000f: call void [System.Console]System.Console::WriteLine(string) + IL_0014: ldstr " class Foo2: Caller: Arguments: string, short - ReturnType: void; Callee: Arg" + + "uments: string - ReturnType: void" + IL_0019: call void [System.Console]System.Console::WriteLine(string) + IL_001e: ldstr " class Foo2: Caller: Arguments: string, ValueType3Bytes - ReturnTyp" + + "e: void; Callee: Arguments: string - ReturnType: void" + IL_0023: call void [System.Console]System.Console::WriteLine(string) + IL_0028: ldc.i4.s 100 + IL_002a: stsfld int32 TailcallVerify.Condition10::Result + .try + { + IL_002f: newobj instance void class TailcallVerify.Condition10/Foo2`2::.ctor() + IL_0034: stloc.0 + IL_0035: newobj instance void class TailcallVerify.Condition10/Foo2`2::.ctor() + IL_003a: stloc.1 + IL_003b: newobj instance void class TailcallVerify.Condition10/Foo2`2::.ctor() + IL_0040: stloc.2 + IL_0041: newobj instance void class TailcallVerify.Condition10/Foo2`2::.ctor() + IL_0046: stloc.3 + IL_0047: ldloc.0 + IL_0048: callvirt instance void class TailcallVerify.Condition10/Foo2`2::Test1() + IL_004d: ldloc.1 + IL_004e: callvirt instance void class TailcallVerify.Condition10/Foo2`2::Test1() + IL_0053: ldloc.2 + IL_0054: callvirt instance void class TailcallVerify.Condition10/Foo2`2::Test1() + IL_0059: ldloc.3 + IL_005a: callvirt instance void class TailcallVerify.Condition10/Foo2`2::Test1() + IL_005f: leave.s IL_0077 + + } // end .try + catch [mscorlib]System.Exception + { + IL_0061: stloc.s e + IL_0063: ldc.i4.s 101 + IL_0065: stsfld int32 TailcallVerify.Condition10::Result + IL_006a: ldloc.s e + IL_006c: isinst [mscorlib]System.DivideByZeroException + IL_0071: brtrue.s IL_0075 + + IL_0073: rethrow + IL_0075: leave.s IL_0077 + + } // end handler + IL_0077: ldstr "Execution finished - Test " + IL_007c: ldsfld int32 TailcallVerify.Condition10::Result + IL_0081: ldc.i4.s 100 + IL_0083: beq.s IL_008c + + IL_0085: ldstr "FAILED" + IL_008a: br.s IL_0091 - .method private hidebysig static void Callee3(valuetype TailcallVerify.ValueType3Bytes v1, - valuetype TailcallVerify.ValueType5Bytes v2, - valuetype TailcallVerify.ValueTypeSingleInt64 v3, - valuetype TailcallVerify.ValueType3Bytes v4, - valuetype TailcallVerify.ValueType5Bytes v5, - valuetype TailcallVerify.ValueType3Bytes v6) cil managed noinlining - { - // Code size 18 (0x12) - .maxstack 8 - IL_0000: ldarga.s v1 - IL_0002: ldc.i4.1 - IL_0003: volatile. - IL_0005: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition7::zero - IL_000a: div - IL_000b: conv.i2 - IL_000c: stfld int16 TailcallVerify.ValueType3Bytes::i2 - IL_0011: ret - } // end of method Condition7::Callee3 + IL_008c: ldstr "PASSED" + IL_0091: call string [mscorlib]System.String::Concat(string, + string) + IL_0096: call void [System.Console]System.Console::WriteLine(string) + IL_009b: ldsfld int32 TailcallVerify.Condition10::Result + IL_00a0: ret + } // end of method Condition10::Test4 - .method public hidebysig static int32 Test4() cil managed nooptimization + .method public hidebysig static int32 Test5() cil managed nooptimization { - // Code size 193 (0xc1) - .maxstack 6 - .locals init ([0] class [mscorlib]System.Exception e, - [1] valuetype TailcallVerify.ValueType3Bytes CS$0$0000, - [2] valuetype TailcallVerify.ValueType5Bytes CS$0$0001, - [3] valuetype TailcallVerify.ValueTypeSingleInt64 CS$0$0002, - [4] valuetype TailcallVerify.ValueType3Bytes CS$0$0003, - [5] valuetype TailcallVerify.ValueType5Bytes CS$0$0004, - [6] valuetype TailcallVerify.ValueType3Bytes CS$0$0005) - IL_0000: ldstr "Executing Condition7.Test4 - Caller: Arguments: mb" - + "3,mb5,mb8,mb3,mb5,mb3 - ReturnType: void; Callee: Arguments: mb3,mb5,mb" - + "8,mb3,mb5,mb3 - ReturnType: void" + // Code size 200 (0xc8) + .maxstack 3 + .locals init ([0] class TailcallVerify.Condition10/Foo1`2 foo1, + [1] class TailcallVerify.Condition10/Foo1`2 foo2, + [2] class TailcallVerify.Condition10/Foo1`2 foo3, + [3] class TailcallVerify.Condition10/Foo1`2 foo4, + [4] class [mscorlib]System.Exception e) + IL_0000: ldstr "Executing Condition10.Test5 - Caller: Arguments: N" + + "one - ReturnType: void; Callee: Arguments: None - ReturnType: v" + + "oid" IL_0005: call void [System.Console]System.Console::WriteLine(string) IL_000a: ldc.i4.s 100 - IL_000c: stsfld int32 TailcallVerify.Condition7::Result + IL_000c: stsfld int32 TailcallVerify.Condition10::Result .try { - IL_0011: ldloca.s CS$0$0000 - IL_0013: initobj TailcallVerify.ValueType3Bytes - IL_0019: ldloc.1 - IL_001a: ldloca.s CS$0$0001 - IL_001c: initobj TailcallVerify.ValueType5Bytes - IL_0022: ldloc.2 - IL_0023: ldloca.s CS$0$0002 - IL_0025: initobj TailcallVerify.ValueTypeSingleInt64 - IL_002b: ldloc.3 - IL_002c: ldloca.s CS$0$0003 - IL_002e: initobj TailcallVerify.ValueType3Bytes - IL_0034: ldloc.s CS$0$0003 - IL_0036: ldloca.s CS$0$0004 - IL_0038: initobj TailcallVerify.ValueType5Bytes - IL_003e: ldloc.s CS$0$0004 - IL_0040: ldloca.s CS$0$0005 - IL_0042: initobj TailcallVerify.ValueType3Bytes - IL_0048: ldloc.s CS$0$0005 - IL_004a: call void TailcallVerify.Condition7::Caller4(valuetype TailcallVerify.ValueType3Bytes, - valuetype TailcallVerify.ValueType5Bytes, - valuetype TailcallVerify.ValueTypeSingleInt64, - valuetype TailcallVerify.ValueType3Bytes, - valuetype TailcallVerify.ValueType5Bytes, - valuetype TailcallVerify.ValueType3Bytes) - IL_004f: leave.s IL_0097 + IL_0011: newobj instance void class TailcallVerify.Condition10/Foo1`2::.ctor() + IL_0016: stloc.0 + IL_0017: newobj instance void class TailcallVerify.Condition10/Foo1`2::.ctor() + IL_001c: stloc.1 + IL_001d: newobj instance void class TailcallVerify.Condition10/Foo1`2::.ctor() + IL_0022: stloc.2 + IL_0023: newobj instance void class TailcallVerify.Condition10/Foo1`2::.ctor() + IL_0028: stloc.3 + IL_0029: ldloc.0 + IL_002a: callvirt instance void class TailcallVerify.Condition10/Foo1`2::Test1Recursive() + IL_002f: ldloc.1 + IL_0030: callvirt instance void class TailcallVerify.Condition10/Foo1`2::Test1Recursive() + IL_0035: ldloc.2 + IL_0036: callvirt instance void class TailcallVerify.Condition10/Foo1`2::Test1Recursive() + IL_003b: ldloc.3 + IL_003c: callvirt instance void class TailcallVerify.Condition10/Foo1`2::Test1Recursive() + IL_0041: leave.s IL_009e } // end .try catch [mscorlib]System.Exception { - IL_0051: stloc.0 - IL_0052: ldloc.0 - IL_0053: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_0058: ldstr "Caller" - IL_005d: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_0062: ldc.i4.m1 - IL_0063: beq.s IL_0095 + IL_0043: stloc.s e + IL_0045: ldloc.s e + IL_0047: isinst [mscorlib]System.DivideByZeroException + IL_004c: brtrue.s IL_0057 - IL_0065: ldstr "FAILED: Found the word 'Caller' in the stacktrace." - IL_006a: call void [System.Console]System.Console::WriteLine(string) - IL_006f: ldstr "------------------------------------------------" - IL_0074: call void [System.Console]System.Console::WriteLine(string) - IL_0079: call void [System.Console]System.Console::WriteLine() - IL_007e: ldloc.0 - IL_007f: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_0084: call void [System.Console]System.Console::WriteLine(string) - IL_0089: call void [System.Console]System.Console::WriteLine() - IL_008e: ldc.i4.s 101 - IL_0090: stsfld int32 TailcallVerify.Condition7::Result - IL_0095: leave.s IL_0097 + IL_004e: ldc.i4.s 101 + IL_0050: stsfld int32 TailcallVerify.Condition10::Result + IL_0055: rethrow + IL_0057: ldloc.s e + IL_0059: callvirt instance string [mscorlib]System.Exception::get_StackTrace() + IL_005e: ldstr "Caller" + IL_0063: callvirt instance int32 [mscorlib]System.String::IndexOf(string) + IL_0068: ldc.i4.m1 + IL_0069: beq.s IL_009c + + IL_006b: ldstr "FAILED: Found the word 'Caller' in the stacktrace." + IL_0070: call void [System.Console]System.Console::WriteLine(string) + IL_0075: ldstr "------------------------------------------------" + IL_007a: call void [System.Console]System.Console::WriteLine(string) + IL_007f: call void [System.Console]System.Console::WriteLine() + IL_0084: ldloc.s e + IL_0086: callvirt instance string [mscorlib]System.Exception::get_StackTrace() + IL_008b: call void [System.Console]System.Console::WriteLine(string) + IL_0090: call void [System.Console]System.Console::WriteLine() + IL_0095: ldc.i4.s 101 + IL_0097: stsfld int32 TailcallVerify.Condition10::Result + IL_009c: leave.s IL_009e } // end handler - IL_0097: ldstr "Execution finished - Test " - IL_009c: ldsfld int32 TailcallVerify.Condition7::Result - IL_00a1: ldc.i4.s 100 - IL_00a3: beq.s IL_00ac + IL_009e: ldstr "Execution finished - Test " + IL_00a3: ldsfld int32 TailcallVerify.Condition10::Result + IL_00a8: ldc.i4.s 100 + IL_00aa: beq.s IL_00b3 - IL_00a5: ldstr "FAILED" - IL_00aa: br.s IL_00b1 + IL_00ac: ldstr "FAILED" + IL_00b1: br.s IL_00b8 - IL_00ac: ldstr "PASSED" - IL_00b1: call string [mscorlib]System.String::Concat(string, + IL_00b3: ldstr "PASSED" + IL_00b8: call string [mscorlib]System.String::Concat(string, string) - IL_00b6: call void [System.Console]System.Console::WriteLine(string) - IL_00bb: ldsfld int32 TailcallVerify.Condition7::Result - IL_00c0: ret - } // end of method Condition7::Test4 - - .method private hidebysig static void Caller4(valuetype TailcallVerify.ValueType3Bytes v1, - valuetype TailcallVerify.ValueType5Bytes v2, - valuetype TailcallVerify.ValueTypeSingleInt64 v3, - valuetype TailcallVerify.ValueType3Bytes v4, - valuetype TailcallVerify.ValueType5Bytes v5, - valuetype TailcallVerify.ValueType3Bytes v6) cil managed - { - // Code size 81 (0x51) - .maxstack 7 - .locals init ([0] int32[] a) - IL_0000: ldc.i4.0 - IL_0001: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) - IL_0006: callvirt instance class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Diagnostics.StackFrame::GetMethod() - IL_000b: callvirt instance string [mscorlib]System.Reflection.MemberInfo::get_Name() - IL_0010: ldstr "Caller" - IL_0015: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_001a: ldc.i4.m1 - IL_001b: bne.un.s IL_002e - - IL_001d: ldstr "Failed, Method was inlined..." - IL_0022: call void [System.Console]System.Console::WriteLine(string) - IL_0027: ldc.i4.s 101 - IL_0029: stsfld int32 TailcallVerify.Condition7::Result - IL_002e: ldc.i4.5 - IL_002f: newarr [mscorlib]System.Int32 - IL_0034: dup - IL_0035: ldtoken field valuetype '{D1242658-CA16-4D11-A740-6635F112F4B5}'/'__StaticArrayInitTypeSize=20' '{D1242658-CA16-4D11-A740-6635F112F4B5}'::'$$method0x6000076-1' - IL_003a: call void [mscorlib]System.Runtime.CompilerServices.RuntimeHelpers::InitializeArray(class [mscorlib]System.Array, - valuetype [mscorlib]System.RuntimeFieldHandle) - IL_003f: stloc.0 - IL_0040: ldarg.0 - IL_0041: ldarg.1 - IL_0042: ldarg.2 - IL_0043: ldarg.3 - IL_0044: ldarg.s v5 - IL_0046: ldarg.s v6 - IL_0048: ldloc.0 - IL_0049: ldlen - IL_004a: conv.i4 - IL_004b: tail. call void TailcallVerify.Condition7::Callee4(valuetype TailcallVerify.ValueType3Bytes, - valuetype TailcallVerify.ValueType5Bytes, - valuetype TailcallVerify.ValueTypeSingleInt64, - valuetype TailcallVerify.ValueType3Bytes, - valuetype TailcallVerify.ValueType5Bytes, - valuetype TailcallVerify.ValueType3Bytes, - int32) - IL_0050: ret - } // end of method Condition7::Caller4 - - .method private hidebysig static void Callee4(valuetype TailcallVerify.ValueType3Bytes v1, - valuetype TailcallVerify.ValueType5Bytes v2, - valuetype TailcallVerify.ValueTypeSingleInt64 v3, - valuetype TailcallVerify.ValueType3Bytes v4, - valuetype TailcallVerify.ValueType5Bytes v5, - valuetype TailcallVerify.ValueType3Bytes v6, - int32 i7) cil managed noinlining - { - // Code size 18 (0x12) - .maxstack 8 - IL_0000: ldarga.s v1 - IL_0002: ldc.i4.1 - IL_0003: volatile. - IL_0005: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition7::zero - IL_000a: div - IL_000b: conv.i2 - IL_000c: stfld int16 TailcallVerify.ValueType3Bytes::i2 - IL_0011: ret - } // end of method Condition7::Callee4 + IL_00bd: call void [System.Console]System.Console::WriteLine(string) + IL_00c2: ldsfld int32 TailcallVerify.Condition10::Result + IL_00c7: ret + } // end of method Condition10::Test5 .method public hidebysig specialname rtspecialname instance void .ctor() cil managed @@ -7049,7 +4018,7 @@ IL_0000: ldarg.0 IL_0001: call instance void [mscorlib]System.Object::.ctor() IL_0006: ret - } // end of method Condition7::.ctor + } // end of method Condition10::.ctor .method private hidebysig specialname rtspecialname static void .cctor() cil managed @@ -7058,87 +4027,86 @@ .maxstack 8 IL_0000: ldc.i4.0 IL_0001: volatile. - IL_0003: stsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition7::zero + IL_0003: stsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition10::zero IL_0008: ldc.i4.s 100 - IL_000a: stsfld int32 TailcallVerify.Condition7::Result + IL_000a: stsfld int32 TailcallVerify.Condition10::Result IL_000f: ret - } // end of method Condition7::.cctor + } // end of method Condition10::.cctor -} // end of class TailcallVerify.Condition7 +} // end of class TailcallVerify.Condition10 -.class private auto ansi beforefieldinit TailcallVerify.Condition20 +.class private auto ansi beforefieldinit TailcallVerify.Condition7 extends [mscorlib]System.Object { + .field private static int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) zero .field private static int32 Result .method public hidebysig static int32 Test1() cil managed nooptimization { - // Code size 158 (0x9e) + // Code size 153 (0x99) .maxstack 3 .locals init ([0] class [mscorlib]System.Exception e) - IL_0000: ldstr "Executing Condition20.Test1 - Caller: Arguments: i" - + "nt - ReturnType: void; Callee: the same as Caller (called again)" + IL_0000: ldstr "Executing Condition7.Test1 - Caller: Arguments: No" + + "ne - ReturnType: void; Callee: Arguments: 10 x Int32 - ReturnType: void" IL_0005: call void [System.Console]System.Console::WriteLine(string) IL_000a: ldc.i4.s 100 - IL_000c: stsfld int32 TailcallVerify.Condition20::Result + IL_000c: stsfld int32 TailcallVerify.Condition7::Result .try { - IL_0011: ldc.i4 0xc8 - IL_0016: call void TailcallVerify.Condition20::Caller1(int32) - IL_001b: leave.s IL_0074 + IL_0011: call void TailcallVerify.Condition7::Caller1() + IL_0016: leave.s IL_006f } // end .try catch [mscorlib]System.Exception { - IL_001d: stloc.0 - IL_001e: ldloc.0 - IL_001f: isinst [mscorlib]System.DivideByZeroException - IL_0024: brtrue.s IL_002f + IL_0018: stloc.0 + IL_0019: ldloc.0 + IL_001a: isinst [mscorlib]System.DivideByZeroException + IL_001f: brtrue.s IL_002a - IL_0026: ldc.i4.s 101 - IL_0028: stsfld int32 TailcallVerify.Condition20::Result - IL_002d: rethrow - IL_002f: ldloc.0 - IL_0030: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_0035: ldstr "Caller" - IL_003a: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_003f: ldc.i4.m1 - IL_0040: bne.un.s IL_0072 + IL_0021: ldc.i4.s 101 + IL_0023: stsfld int32 TailcallVerify.Condition7::Result + IL_0028: rethrow + IL_002a: ldloc.0 + IL_002b: callvirt instance string [mscorlib]System.Exception::get_StackTrace() + IL_0030: ldstr "Caller" + IL_0035: callvirt instance int32 [mscorlib]System.String::IndexOf(string) + IL_003a: ldc.i4.m1 + IL_003b: beq.s IL_006d - IL_0042: ldstr "FAILED: Did not find the word 'Caller' in the stac" - + "ktrace." - IL_0047: call void [System.Console]System.Console::WriteLine(string) - IL_004c: ldstr "------------------------------------------------" - IL_0051: call void [System.Console]System.Console::WriteLine(string) - IL_0056: call void [System.Console]System.Console::WriteLine() - IL_005b: ldloc.0 - IL_005c: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_0061: call void [System.Console]System.Console::WriteLine(string) - IL_0066: call void [System.Console]System.Console::WriteLine() - IL_006b: ldc.i4.s 101 - IL_006d: stsfld int32 TailcallVerify.Condition20::Result - IL_0072: leave.s IL_0074 + IL_003d: ldstr "FAILED: Found the word 'Caller' in the stacktrace." + IL_0042: call void [System.Console]System.Console::WriteLine(string) + IL_0047: ldstr "------------------------------------------------" + IL_004c: call void [System.Console]System.Console::WriteLine(string) + IL_0051: call void [System.Console]System.Console::WriteLine() + IL_0056: ldloc.0 + IL_0057: callvirt instance string [mscorlib]System.Exception::get_StackTrace() + IL_005c: call void [System.Console]System.Console::WriteLine(string) + IL_0061: call void [System.Console]System.Console::WriteLine() + IL_0066: ldc.i4.s 101 + IL_0068: stsfld int32 TailcallVerify.Condition7::Result + IL_006d: leave.s IL_006f } // end handler - IL_0074: ldstr "Execution finished - Test " - IL_0079: ldsfld int32 TailcallVerify.Condition20::Result - IL_007e: ldc.i4.s 100 - IL_0080: beq.s IL_0089 + IL_006f: ldstr "Execution finished - Test " + IL_0074: ldsfld int32 TailcallVerify.Condition7::Result + IL_0079: ldc.i4.s 100 + IL_007b: beq.s IL_0084 - IL_0082: ldstr "FAILED" - IL_0087: br.s IL_008e + IL_007d: ldstr "FAILED" + IL_0082: br.s IL_0089 - IL_0089: ldstr "PASSED" - IL_008e: call string [mscorlib]System.String::Concat(string, + IL_0084: ldstr "PASSED" + IL_0089: call string [mscorlib]System.String::Concat(string, string) - IL_0093: call void [System.Console]System.Console::WriteLine(string) - IL_0098: ldsfld int32 TailcallVerify.Condition20::Result - IL_009d: ret - } // end of method Condition20::Test1 + IL_008e: call void [System.Console]System.Console::WriteLine(string) + IL_0093: ldsfld int32 TailcallVerify.Condition7::Result + IL_0098: ret + } // end of method Condition7::Test1 - .method private hidebysig static void Caller1(int32 i) cil managed noinlining + .method private hidebysig static void Caller1() cil managed { - // Code size 60 (0x3c) - .maxstack 8 + // Code size 63 (0x3f) + .maxstack 10 IL_0000: ldc.i4.0 IL_0001: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) IL_0006: callvirt instance class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Diagnostics.StackFrame::GetMethod() @@ -7151,108 +4119,125 @@ IL_001d: ldstr "Failed, Method was inlined..." IL_0022: call void [System.Console]System.Console::WriteLine(string) IL_0027: ldc.i4.s 101 - IL_0029: stsfld int32 TailcallVerify.Condition20::Result - IL_002e: ldc.i4.s 10 - IL_0030: ldarg.0 - IL_0031: div - IL_0032: pop - IL_0033: ldarg.0 - IL_0034: ldc.i4.1 - IL_0035: sub - IL_0036: call void TailcallVerify.Condition20::Caller1(int32) - IL_003b: ret - } // end of method Condition20::Caller1 + IL_0029: stsfld int32 TailcallVerify.Condition7::Result + IL_002e: ldc.i4.0 + IL_002f: ldc.i4.1 + IL_0030: ldc.i4.2 + IL_0031: ldc.i4.3 + IL_0032: ldc.i4.4 + IL_0033: ldc.i4.5 + IL_0034: ldc.i4.6 + IL_0035: ldc.i4.7 + IL_0036: ldc.i4.8 + IL_0037: ldc.i4.s 9 + IL_0039: tail. call void TailcallVerify.Condition7::Callee1(int32, + int32, + int32, + int32, + int32, + int32, + int32, + int32, + int32, + int32) + IL_003e: ret + } // end of method Condition7::Caller1 - .method public hidebysig specialname rtspecialname - instance void .ctor() cil managed + .method private hidebysig static void Callee1(int32 i1, + int32 i2, + int32 i3, + int32 i4, + int32 i5, + int32 i6, + int32 i7, + int32 i8, + int32 i9, + int32 i10) cil managed noinlining { - // Code size 7 (0x7) + // Code size 11 (0xb) .maxstack 8 IL_0000: ldarg.0 - IL_0001: call instance void [mscorlib]System.Object::.ctor() - IL_0006: ret - } // end of method Condition20::.ctor - - .method private hidebysig specialname rtspecialname static - void .cctor() cil managed - { - // Code size 8 (0x8) - .maxstack 8 - IL_0000: ldc.i4.s 100 - IL_0002: stsfld int32 TailcallVerify.Condition20::Result - IL_0007: ret - } // end of method Condition20::.cctor - -} // end of class TailcallVerify.Condition20 + IL_0001: volatile. + IL_0003: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition7::zero + IL_0008: div + IL_0009: pop + IL_000a: ret + } // end of method Condition7::Callee1 -.class private auto ansi beforefieldinit TailcallVerify.Condition6 - extends [mscorlib]System.Object -{ - .field private static int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) zero - .field private static int32 Result - .method public hidebysig static int32 Test1() cil managed nooptimization + .method public hidebysig static int32 Test2() cil managed nooptimization { - // Code size 136 (0x88) + // Code size 153 (0x99) .maxstack 3 .locals init ([0] class [mscorlib]System.Exception e) - IL_0000: ldstr "Executing Condition6.Test1 - Caller: Arguments: No" - + "ne - ReturnType: void; Callee: Arguments: 3 byte struct - ReturnType: v" - + "oid" + IL_0000: ldstr "Executing Condition7.Test2 - Caller: Arguments: No" + + "ne - ReturnType: void; Callee: Arguments: i32,i64,mb3,i16,u8,f64,f32,mb" + + "5 - ReturnType: void" IL_0005: call void [System.Console]System.Console::WriteLine(string) IL_000a: ldc.i4.s 100 - IL_000c: stsfld int32 TailcallVerify.Condition6::Result + IL_000c: stsfld int32 TailcallVerify.Condition7::Result .try { - IL_0011: call void TailcallVerify.Condition6::Caller1() - IL_0016: leave.s IL_005e + IL_0011: call void TailcallVerify.Condition7::Caller2() + IL_0016: leave.s IL_006f } // end .try catch [mscorlib]System.Exception { IL_0018: stloc.0 IL_0019: ldloc.0 - IL_001a: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_001f: ldstr "Caller" - IL_0024: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_0029: ldc.i4.m1 - IL_002a: beq.s IL_005c + IL_001a: isinst [mscorlib]System.DivideByZeroException + IL_001f: brtrue.s IL_002a - IL_002c: ldstr "FAILED: Found the word 'Caller' in the stacktrace." - IL_0031: call void [System.Console]System.Console::WriteLine(string) - IL_0036: ldstr "------------------------------------------------" - IL_003b: call void [System.Console]System.Console::WriteLine(string) - IL_0040: call void [System.Console]System.Console::WriteLine() - IL_0045: ldloc.0 - IL_0046: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_004b: call void [System.Console]System.Console::WriteLine(string) - IL_0050: call void [System.Console]System.Console::WriteLine() - IL_0055: ldc.i4.s 101 - IL_0057: stsfld int32 TailcallVerify.Condition6::Result - IL_005c: leave.s IL_005e + IL_0021: ldc.i4.s 101 + IL_0023: stsfld int32 TailcallVerify.Condition7::Result + IL_0028: rethrow + IL_002a: ldloc.0 + IL_002b: callvirt instance string [mscorlib]System.Exception::get_StackTrace() + IL_0030: ldstr "Caller" + IL_0035: callvirt instance int32 [mscorlib]System.String::IndexOf(string) + IL_003a: ldc.i4.m1 + IL_003b: beq.s IL_006d + + IL_003d: ldstr "FAILED: Found the word 'Caller' in the stacktrace." + IL_0042: call void [System.Console]System.Console::WriteLine(string) + IL_0047: ldstr "------------------------------------------------" + IL_004c: call void [System.Console]System.Console::WriteLine(string) + IL_0051: call void [System.Console]System.Console::WriteLine() + IL_0056: ldloc.0 + IL_0057: callvirt instance string [mscorlib]System.Exception::get_StackTrace() + IL_005c: call void [System.Console]System.Console::WriteLine(string) + IL_0061: call void [System.Console]System.Console::WriteLine() + IL_0066: ldc.i4.s 101 + IL_0068: stsfld int32 TailcallVerify.Condition7::Result + IL_006d: leave.s IL_006f } // end handler - IL_005e: ldstr "Execution finished - Test " - IL_0063: ldsfld int32 TailcallVerify.Condition6::Result - IL_0068: ldc.i4.s 100 - IL_006a: beq.s IL_0073 + IL_006f: ldstr "Execution finished - Test " + IL_0074: ldsfld int32 TailcallVerify.Condition7::Result + IL_0079: ldc.i4.s 100 + IL_007b: beq.s IL_0084 - IL_006c: ldstr "FAILED" - IL_0071: br.s IL_0078 + IL_007d: ldstr "FAILED" + IL_0082: br.s IL_0089 - IL_0073: ldstr "PASSED" - IL_0078: call string [mscorlib]System.String::Concat(string, + IL_0084: ldstr "PASSED" + IL_0089: call string [mscorlib]System.String::Concat(string, string) - IL_007d: call void [System.Console]System.Console::WriteLine(string) - IL_0082: ldsfld int32 TailcallVerify.Condition6::Result - IL_0087: ret - } // end of method Condition6::Test1 + IL_008e: call void [System.Console]System.Console::WriteLine(string) + IL_0093: ldsfld int32 TailcallVerify.Condition7::Result + IL_0098: ret + } // end of method Condition7::Test2 - .method private hidebysig static void Caller1() cil managed + .method private hidebysig static void Caller2() cil managed { - // Code size 70 (0x46) - .maxstack 2 - .locals init ([0] valuetype TailcallVerify.ValueType3Bytes CS$0$0000, - [1] valuetype TailcallVerify.ValueType5Bytes CS$0$0001) + // Code size 174 (0xae) + .maxstack 8 + .locals init ([0] valuetype TailcallVerify.ValueType3Bytes v3, + [1] valuetype TailcallVerify.ValueType5Bytes v5, + [2] valuetype TailcallVerify.ValueType3Bytes '<>g__initLocal0', + [3] valuetype TailcallVerify.ValueType5Bytes '<>g__initLocal1', + [4] valuetype TailcallVerify.ValueType3Bytes CS$0$0000, + [5] valuetype TailcallVerify.ValueType5Bytes CS$0$0001) IL_0000: ldc.i4.0 IL_0001: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) IL_0006: callvirt instance class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Diagnostics.StackFrame::GetMethod() @@ -7265,97 +4250,293 @@ IL_001d: ldstr "Failed, Method was inlined..." IL_0022: call void [System.Console]System.Console::WriteLine(string) IL_0027: ldc.i4.s 101 - IL_0029: stsfld int32 TailcallVerify.Condition6::Result + IL_0029: stsfld int32 TailcallVerify.Condition7::Result IL_002e: ldloca.s CS$0$0000 IL_0030: initobj TailcallVerify.ValueType3Bytes - IL_0036: ldloc.0 - IL_0037: ldloca.s CS$0$0001 - IL_0039: initobj TailcallVerify.ValueType5Bytes - IL_003f: ldloc.1 - IL_0040: tail. call void TailcallVerify.Condition6::Callee1(valuetype TailcallVerify.ValueType3Bytes, + IL_0036: ldloc.s CS$0$0000 + IL_0038: stloc.2 + IL_0039: ldloca.s '<>g__initLocal0' + IL_003b: ldc.i4.0 + IL_003c: stfld uint8 TailcallVerify.ValueType3Bytes::i1 + IL_0041: ldloca.s '<>g__initLocal0' + IL_0043: ldc.i4 0x7fff + IL_0048: stfld int16 TailcallVerify.ValueType3Bytes::i2 + IL_004d: ldloc.2 + IL_004e: stloc.0 + IL_004f: ldloca.s CS$0$0001 + IL_0051: initobj TailcallVerify.ValueType5Bytes + IL_0057: ldloc.s CS$0$0001 + IL_0059: stloc.3 + IL_005a: ldloca.s '<>g__initLocal1' + IL_005c: ldc.i4 0xff + IL_0061: stfld uint8 TailcallVerify.ValueType5Bytes::i1 + IL_0066: ldloca.s '<>g__initLocal1' + IL_0068: ldc.i4 0xffff8000 + IL_006d: stfld int16 TailcallVerify.ValueType5Bytes::i2 + IL_0072: ldloca.s '<>g__initLocal1' + IL_0074: ldc.i4 0x7fff + IL_0079: stfld int16 TailcallVerify.ValueType5Bytes::i3 + IL_007e: ldloc.3 + IL_007f: stloc.1 + IL_0080: ldc.i4 0x80000000 + IL_0085: ldc.i8 0x7fffffffffffffff + IL_008e: ldloc.0 + IL_008f: ldc.i4 0xffff8000 + IL_0094: ldc.i4 0xff + IL_0099: ldc.r8 -1.7976931348623157e+308 + IL_00a2: ldc.r4 3.4028235e+038 + IL_00a7: ldloc.1 + IL_00a8: tail. call void TailcallVerify.Condition7::Callee2(int32, + int64, + valuetype TailcallVerify.ValueType3Bytes, + int16, + uint8, + float64, + float32, valuetype TailcallVerify.ValueType5Bytes) - IL_0045: ret - } // end of method Condition6::Caller1 + IL_00ad: ret + } // end of method Condition7::Caller2 - .method private hidebysig static void Callee1(valuetype TailcallVerify.ValueType3Bytes v, - valuetype TailcallVerify.ValueType5Bytes v5) cil managed noinlining + .method private hidebysig static void Callee2(int32 i1, + int64 i2, + valuetype TailcallVerify.ValueType3Bytes v3, + int16 i4, + uint8 b5, + float64 d6, + float32 f7, + valuetype TailcallVerify.ValueType5Bytes v8) cil managed noinlining { - // Code size 18 (0x12) - .maxstack 8 - IL_0000: ldarga.s v - IL_0002: ldc.i4.1 - IL_0003: volatile. - IL_0005: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition6::zero - IL_000a: div - IL_000b: conv.i2 - IL_000c: stfld int16 TailcallVerify.ValueType3Bytes::i2 - IL_0011: ret - } // end of method Condition6::Callee1 + // Code size 308 (0x134) + .maxstack 4 + .locals init ([0] object[] CS$0$0000) + IL_0000: ldarg.0 + IL_0001: ldc.i4 0x80000000 + IL_0006: bne.un.s IL_007f - .method public hidebysig static int32 Test2() cil managed nooptimization + IL_0008: ldarg.1 + IL_0009: ldc.i8 0x7fffffffffffffff + IL_0012: bne.un.s IL_007f + + IL_0014: ldarga.s v3 + IL_0016: ldfld uint8 TailcallVerify.ValueType3Bytes::i1 + IL_001b: brtrue.s IL_007f + + IL_001d: ldarga.s v3 + IL_001f: ldfld int16 TailcallVerify.ValueType3Bytes::i2 + IL_0024: ldc.i4 0x7fff + IL_0029: bne.un.s IL_007f + + IL_002b: ldarg.3 + IL_002c: ldc.i4 0xffff8000 + IL_0031: bne.un.s IL_007f + + IL_0033: ldarg.s b5 + IL_0035: ldc.i4 0xff + IL_003a: bne.un.s IL_007f + + IL_003c: ldarg.s d6 + IL_003e: ldc.r8 -1.7976931348623157e+308 + IL_0047: bne.un.s IL_007f + + IL_0049: ldarg.s f7 + IL_004b: ldc.r4 3.4028235e+038 + IL_0050: bne.un.s IL_007f + + IL_0052: ldarga.s v8 + IL_0054: ldfld uint8 TailcallVerify.ValueType5Bytes::i1 + IL_0059: ldc.i4 0xff + IL_005e: bne.un.s IL_007f + + IL_0060: ldarga.s v8 + IL_0062: ldfld int16 TailcallVerify.ValueType5Bytes::i2 + IL_0067: ldc.i4 0xffff8000 + IL_006c: bne.un.s IL_007f + + IL_006e: ldarga.s v8 + IL_0070: ldfld int16 TailcallVerify.ValueType5Bytes::i3 + IL_0075: ldc.i4 0x7fff + IL_007a: beq IL_0129 + + IL_007f: ldc.i4.s 101 + IL_0081: stsfld int32 TailcallVerify.Condition7::Result + IL_0086: ldstr "FAILED: Passed in arguments are invalid." + IL_008b: call void [System.Console]System.Console::WriteLine(string) + IL_0090: ldstr "i1:{0} != Int32.MinValue || i2:{1} != Int64.MaxVal" + + "ue || v3.i1:{2} != byte.MinValue || v3.i2:{3} != short.MaxValue || i4:{" + + "4} != Int16.MinValue || b5:{5} != byte.MaxValue || d6:{6} != double.Min" + + "Value || f7:{7} != float.MaxValue || v8.i1:{8} != byte.MaxValue || v8.i" + + "2:{9} != short.MinValue || v8.i3:{10} != short.MaxValue" + IL_0095: ldc.i4.s 11 + IL_0097: newarr [mscorlib]System.Object + IL_009c: stloc.0 + IL_009d: ldloc.0 + IL_009e: ldc.i4.0 + IL_009f: ldarg.0 + IL_00a0: box [mscorlib]System.Int32 + IL_00a5: stelem.ref + IL_00a6: ldloc.0 + IL_00a7: ldc.i4.1 + IL_00a8: ldarg.1 + IL_00a9: box [mscorlib]System.Int64 + IL_00ae: stelem.ref + IL_00af: ldloc.0 + IL_00b0: ldc.i4.2 + IL_00b1: ldarga.s v3 + IL_00b3: ldfld uint8 TailcallVerify.ValueType3Bytes::i1 + IL_00b8: box [mscorlib]System.Byte + IL_00bd: stelem.ref + IL_00be: ldloc.0 + IL_00bf: ldc.i4.3 + IL_00c0: ldarga.s v3 + IL_00c2: ldfld int16 TailcallVerify.ValueType3Bytes::i2 + IL_00c7: box [mscorlib]System.Int16 + IL_00cc: stelem.ref + IL_00cd: ldloc.0 + IL_00ce: ldc.i4.4 + IL_00cf: ldarg.3 + IL_00d0: box [mscorlib]System.Int16 + IL_00d5: stelem.ref + IL_00d6: ldloc.0 + IL_00d7: ldc.i4.5 + IL_00d8: ldarg.s b5 + IL_00da: box [mscorlib]System.Byte + IL_00df: stelem.ref + IL_00e0: ldloc.0 + IL_00e1: ldc.i4.6 + IL_00e2: ldarg.s d6 + IL_00e4: box [mscorlib]System.Double + IL_00e9: stelem.ref + IL_00ea: ldloc.0 + IL_00eb: ldc.i4.7 + IL_00ec: ldarg.s f7 + IL_00ee: box [mscorlib]System.Single + IL_00f3: stelem.ref + IL_00f4: ldloc.0 + IL_00f5: ldc.i4.8 + IL_00f6: ldarga.s v8 + IL_00f8: ldfld uint8 TailcallVerify.ValueType5Bytes::i1 + IL_00fd: box [mscorlib]System.Byte + IL_0102: stelem.ref + IL_0103: ldloc.0 + IL_0104: ldc.i4.s 9 + IL_0106: ldarga.s v8 + IL_0108: ldfld int16 TailcallVerify.ValueType5Bytes::i2 + IL_010d: box [mscorlib]System.Int16 + IL_0112: stelem.ref + IL_0113: ldloc.0 + IL_0114: ldc.i4.s 10 + IL_0116: ldarga.s v8 + IL_0118: ldfld int16 TailcallVerify.ValueType5Bytes::i3 + IL_011d: box [mscorlib]System.Int16 + IL_0122: stelem.ref + IL_0123: ldloc.0 + IL_0124: call void [System.Console]System.Console::Write(string) + callvirt instance string [mscorlib]System.Object::ToString() + call void [System.Console]System.Console::WriteLine(string) + + IL_0129: ldc.i4.1 + IL_012a: volatile. + IL_012c: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition7::zero + IL_0131: div + IL_0132: pop + IL_0133: ret + } // end of method Condition7::Callee2 + + .method public hidebysig static int32 Test3() cil managed nooptimization { - // Code size 136 (0x88) - .maxstack 3 - .locals init ([0] class [mscorlib]System.Exception e) - IL_0000: ldstr "Executing Condition6.Test2 - Caller: Arguments: No" - + "ne - ReturnType: void; Callee: Arguments: 3 byte struct - ReturnType: v" - + "oid" + // Code size 193 (0xc1) + .maxstack 6 + .locals init ([0] class [mscorlib]System.Exception e, + [1] valuetype TailcallVerify.ValueType3Bytes CS$0$0000, + [2] valuetype TailcallVerify.ValueType5Bytes CS$0$0001, + [3] valuetype TailcallVerify.ValueTypeSingleInt64 CS$0$0002, + [4] valuetype TailcallVerify.ValueType3Bytes CS$0$0003, + [5] valuetype TailcallVerify.ValueType5Bytes CS$0$0004, + [6] valuetype TailcallVerify.ValueType3Bytes CS$0$0005) + IL_0000: ldstr "Executing Condition7.Test3 - Caller: Arguments: mb" + + "3,mb5,mb8,mb3,mb5,mb3 - ReturnType: void; Callee: Arguments: mb3,mb5,mb" + + "8,mb3,mb5,mb3 - ReturnType: void" IL_0005: call void [System.Console]System.Console::WriteLine(string) IL_000a: ldc.i4.s 100 - IL_000c: stsfld int32 TailcallVerify.Condition6::Result + IL_000c: stsfld int32 TailcallVerify.Condition7::Result .try { - IL_0011: call void TailcallVerify.Condition6::Caller2() - IL_0016: leave.s IL_005e + IL_0011: ldloca.s CS$0$0000 + IL_0013: initobj TailcallVerify.ValueType3Bytes + IL_0019: ldloc.1 + IL_001a: ldloca.s CS$0$0001 + IL_001c: initobj TailcallVerify.ValueType5Bytes + IL_0022: ldloc.2 + IL_0023: ldloca.s CS$0$0002 + IL_0025: initobj TailcallVerify.ValueTypeSingleInt64 + IL_002b: ldloc.3 + IL_002c: ldloca.s CS$0$0003 + IL_002e: initobj TailcallVerify.ValueType3Bytes + IL_0034: ldloc.s CS$0$0003 + IL_0036: ldloca.s CS$0$0004 + IL_0038: initobj TailcallVerify.ValueType5Bytes + IL_003e: ldloc.s CS$0$0004 + IL_0040: ldloca.s CS$0$0005 + IL_0042: initobj TailcallVerify.ValueType3Bytes + IL_0048: ldloc.s CS$0$0005 + IL_004a: call void TailcallVerify.Condition7::Caller3(valuetype TailcallVerify.ValueType3Bytes, + valuetype TailcallVerify.ValueType5Bytes, + valuetype TailcallVerify.ValueTypeSingleInt64, + valuetype TailcallVerify.ValueType3Bytes, + valuetype TailcallVerify.ValueType5Bytes, + valuetype TailcallVerify.ValueType3Bytes) + IL_004f: leave.s IL_0097 } // end .try catch [mscorlib]System.Exception { - IL_0018: stloc.0 - IL_0019: ldloc.0 - IL_001a: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_001f: ldstr "Caller" - IL_0024: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_0029: ldc.i4.m1 - IL_002a: beq.s IL_005c + IL_0051: stloc.0 + IL_0052: ldloc.0 + IL_0053: callvirt instance string [mscorlib]System.Exception::get_StackTrace() + IL_0058: ldstr "Caller" + IL_005d: callvirt instance int32 [mscorlib]System.String::IndexOf(string) + IL_0062: ldc.i4.m1 + IL_0063: beq.s IL_0095 - IL_002c: ldstr "FAILED: Found the word 'Caller' in the stacktrace." - IL_0031: call void [System.Console]System.Console::WriteLine(string) - IL_0036: ldstr "------------------------------------------------" - IL_003b: call void [System.Console]System.Console::WriteLine(string) - IL_0040: call void [System.Console]System.Console::WriteLine() - IL_0045: ldloc.0 - IL_0046: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_004b: call void [System.Console]System.Console::WriteLine(string) - IL_0050: call void [System.Console]System.Console::WriteLine() - IL_0055: ldc.i4.s 101 - IL_0057: stsfld int32 TailcallVerify.Condition6::Result - IL_005c: leave.s IL_005e + IL_0065: ldstr "FAILED: Found the word 'Caller' in the stacktrace." + IL_006a: call void [System.Console]System.Console::WriteLine(string) + IL_006f: ldstr "------------------------------------------------" + IL_0074: call void [System.Console]System.Console::WriteLine(string) + IL_0079: call void [System.Console]System.Console::WriteLine() + IL_007e: ldloc.0 + IL_007f: callvirt instance string [mscorlib]System.Exception::get_StackTrace() + IL_0084: call void [System.Console]System.Console::WriteLine(string) + IL_0089: call void [System.Console]System.Console::WriteLine() + IL_008e: ldc.i4.s 101 + IL_0090: stsfld int32 TailcallVerify.Condition7::Result + IL_0095: leave.s IL_0097 } // end handler - IL_005e: ldstr "Execution finished - Test " - IL_0063: ldsfld int32 TailcallVerify.Condition6::Result - IL_0068: ldc.i4.s 100 - IL_006a: beq.s IL_0073 + IL_0097: ldstr "Execution finished - Test " + IL_009c: ldsfld int32 TailcallVerify.Condition7::Result + IL_00a1: ldc.i4.s 100 + IL_00a3: beq.s IL_00ac - IL_006c: ldstr "FAILED" - IL_0071: br.s IL_0078 + IL_00a5: ldstr "FAILED" + IL_00aa: br.s IL_00b1 - IL_0073: ldstr "PASSED" - IL_0078: call string [mscorlib]System.String::Concat(string, + IL_00ac: ldstr "PASSED" + IL_00b1: call string [mscorlib]System.String::Concat(string, string) - IL_007d: call void [System.Console]System.Console::WriteLine(string) - IL_0082: ldsfld int32 TailcallVerify.Condition6::Result - IL_0087: ret - } // end of method Condition6::Test2 + IL_00b6: call void [System.Console]System.Console::WriteLine(string) + IL_00bb: ldsfld int32 TailcallVerify.Condition7::Result + IL_00c0: ret + } // end of method Condition7::Test3 - .method private hidebysig static void Caller2() cil managed + .method private hidebysig static void Caller3(valuetype TailcallVerify.ValueType3Bytes v1, + valuetype TailcallVerify.ValueType5Bytes v2, + valuetype TailcallVerify.ValueTypeSingleInt64 v3, + valuetype TailcallVerify.ValueType3Bytes v4, + valuetype TailcallVerify.ValueType5Bytes v5, + valuetype TailcallVerify.ValueType3Bytes v6) cil managed { - // Code size 79 (0x4f) - .maxstack 3 - .locals init ([0] valuetype TailcallVerify.ValueType3Bytes CS$0$0000, - [1] valuetype TailcallVerify.ValueType5Bytes CS$0$0001, - [2] valuetype TailcallVerify.ValueTypeSingleInt64 CS$0$0002) + // Code size 60 (0x3c) + .maxstack 8 IL_0000: ldc.i4.0 IL_0001: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) IL_0006: callvirt instance class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Diagnostics.StackFrame::GetMethod() @@ -7368,103 +4549,137 @@ IL_001d: ldstr "Failed, Method was inlined..." IL_0022: call void [System.Console]System.Console::WriteLine(string) IL_0027: ldc.i4.s 101 - IL_0029: stsfld int32 TailcallVerify.Condition6::Result - IL_002e: ldloca.s CS$0$0000 - IL_0030: initobj TailcallVerify.ValueType3Bytes - IL_0036: ldloc.0 - IL_0037: ldloca.s CS$0$0001 - IL_0039: initobj TailcallVerify.ValueType5Bytes - IL_003f: ldloc.1 - IL_0040: ldloca.s CS$0$0002 - IL_0042: initobj TailcallVerify.ValueTypeSingleInt64 - IL_0048: ldloc.2 - IL_0049: tail. call void TailcallVerify.Condition6::Callee2(valuetype TailcallVerify.ValueType3Bytes, + IL_0029: stsfld int32 TailcallVerify.Condition7::Result + IL_002e: ldarg.0 + IL_002f: ldarg.1 + IL_0030: ldarg.2 + IL_0031: ldarg.3 + IL_0032: ldarg.s v5 + IL_0034: ldarg.s v6 + IL_0036: tail. call void TailcallVerify.Condition7::Callee3(valuetype TailcallVerify.ValueType3Bytes, valuetype TailcallVerify.ValueType5Bytes, - valuetype TailcallVerify.ValueTypeSingleInt64) - IL_004e: ret - } // end of method Condition6::Caller2 + valuetype TailcallVerify.ValueTypeSingleInt64, + valuetype TailcallVerify.ValueType3Bytes, + valuetype TailcallVerify.ValueType5Bytes, + valuetype TailcallVerify.ValueType3Bytes) + IL_003b: ret + } // end of method Condition7::Caller3 - .method private hidebysig static void Callee2(valuetype TailcallVerify.ValueType3Bytes v1, + .method private hidebysig static void Callee3(valuetype TailcallVerify.ValueType3Bytes v1, valuetype TailcallVerify.ValueType5Bytes v2, - valuetype TailcallVerify.ValueTypeSingleInt64 v3) cil managed noinlining + valuetype TailcallVerify.ValueTypeSingleInt64 v3, + valuetype TailcallVerify.ValueType3Bytes v4, + valuetype TailcallVerify.ValueType5Bytes v5, + valuetype TailcallVerify.ValueType3Bytes v6) cil managed noinlining { // Code size 18 (0x12) .maxstack 8 IL_0000: ldarga.s v1 IL_0002: ldc.i4.1 IL_0003: volatile. - IL_0005: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition6::zero + IL_0005: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition7::zero IL_000a: div IL_000b: conv.i2 IL_000c: stfld int16 TailcallVerify.ValueType3Bytes::i2 IL_0011: ret - } // end of method Condition6::Callee2 + } // end of method Condition7::Callee3 - .method public hidebysig static int32 Test3() cil managed nooptimization + .method public hidebysig static int32 Test4() cil managed nooptimization { - // Code size 136 (0x88) - .maxstack 3 - .locals init ([0] class [mscorlib]System.Exception e) - IL_0000: ldstr "Executing Condition6.Test3 - Caller: Arguments: No" - + "ne - ReturnType: void; Callee: Arguments: 3 byte struct - ReturnType: v" - + "oid" + // Code size 193 (0xc1) + .maxstack 6 + .locals init ([0] class [mscorlib]System.Exception e, + [1] valuetype TailcallVerify.ValueType3Bytes CS$0$0000, + [2] valuetype TailcallVerify.ValueType5Bytes CS$0$0001, + [3] valuetype TailcallVerify.ValueTypeSingleInt64 CS$0$0002, + [4] valuetype TailcallVerify.ValueType3Bytes CS$0$0003, + [5] valuetype TailcallVerify.ValueType5Bytes CS$0$0004, + [6] valuetype TailcallVerify.ValueType3Bytes CS$0$0005) + IL_0000: ldstr "Executing Condition7.Test4 - Caller: Arguments: mb" + + "3,mb5,mb8,mb3,mb5,mb3 - ReturnType: void; Callee: Arguments: mb3,mb5,mb" + + "8,mb3,mb5,mb3 - ReturnType: void" IL_0005: call void [System.Console]System.Console::WriteLine(string) IL_000a: ldc.i4.s 100 - IL_000c: stsfld int32 TailcallVerify.Condition6::Result + IL_000c: stsfld int32 TailcallVerify.Condition7::Result .try { - IL_0011: call void TailcallVerify.Condition6::Caller3() - IL_0016: leave.s IL_005e + IL_0011: ldloca.s CS$0$0000 + IL_0013: initobj TailcallVerify.ValueType3Bytes + IL_0019: ldloc.1 + IL_001a: ldloca.s CS$0$0001 + IL_001c: initobj TailcallVerify.ValueType5Bytes + IL_0022: ldloc.2 + IL_0023: ldloca.s CS$0$0002 + IL_0025: initobj TailcallVerify.ValueTypeSingleInt64 + IL_002b: ldloc.3 + IL_002c: ldloca.s CS$0$0003 + IL_002e: initobj TailcallVerify.ValueType3Bytes + IL_0034: ldloc.s CS$0$0003 + IL_0036: ldloca.s CS$0$0004 + IL_0038: initobj TailcallVerify.ValueType5Bytes + IL_003e: ldloc.s CS$0$0004 + IL_0040: ldloca.s CS$0$0005 + IL_0042: initobj TailcallVerify.ValueType3Bytes + IL_0048: ldloc.s CS$0$0005 + IL_004a: call void TailcallVerify.Condition7::Caller4(valuetype TailcallVerify.ValueType3Bytes, + valuetype TailcallVerify.ValueType5Bytes, + valuetype TailcallVerify.ValueTypeSingleInt64, + valuetype TailcallVerify.ValueType3Bytes, + valuetype TailcallVerify.ValueType5Bytes, + valuetype TailcallVerify.ValueType3Bytes) + IL_004f: leave.s IL_0097 } // end .try catch [mscorlib]System.Exception { - IL_0018: stloc.0 - IL_0019: ldloc.0 - IL_001a: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_001f: ldstr "Caller" - IL_0024: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_0029: ldc.i4.m1 - IL_002a: beq.s IL_005c + IL_0051: stloc.0 + IL_0052: ldloc.0 + IL_0053: callvirt instance string [mscorlib]System.Exception::get_StackTrace() + IL_0058: ldstr "Caller" + IL_005d: callvirt instance int32 [mscorlib]System.String::IndexOf(string) + IL_0062: ldc.i4.m1 + IL_0063: beq.s IL_0095 - IL_002c: ldstr "FAILED: Found the word 'Caller' in the stacktrace." - IL_0031: call void [System.Console]System.Console::WriteLine(string) - IL_0036: ldstr "------------------------------------------------" - IL_003b: call void [System.Console]System.Console::WriteLine(string) - IL_0040: call void [System.Console]System.Console::WriteLine() - IL_0045: ldloc.0 - IL_0046: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_004b: call void [System.Console]System.Console::WriteLine(string) - IL_0050: call void [System.Console]System.Console::WriteLine() - IL_0055: ldc.i4.s 101 - IL_0057: stsfld int32 TailcallVerify.Condition6::Result - IL_005c: leave.s IL_005e + IL_0065: ldstr "FAILED: Found the word 'Caller' in the stacktrace." + IL_006a: call void [System.Console]System.Console::WriteLine(string) + IL_006f: ldstr "------------------------------------------------" + IL_0074: call void [System.Console]System.Console::WriteLine(string) + IL_0079: call void [System.Console]System.Console::WriteLine() + IL_007e: ldloc.0 + IL_007f: callvirt instance string [mscorlib]System.Exception::get_StackTrace() + IL_0084: call void [System.Console]System.Console::WriteLine(string) + IL_0089: call void [System.Console]System.Console::WriteLine() + IL_008e: ldc.i4.s 101 + IL_0090: stsfld int32 TailcallVerify.Condition7::Result + IL_0095: leave.s IL_0097 } // end handler - IL_005e: ldstr "Execution finished - Test " - IL_0063: ldsfld int32 TailcallVerify.Condition6::Result - IL_0068: ldc.i4.s 100 - IL_006a: beq.s IL_0073 + IL_0097: ldstr "Execution finished - Test " + IL_009c: ldsfld int32 TailcallVerify.Condition7::Result + IL_00a1: ldc.i4.s 100 + IL_00a3: beq.s IL_00ac - IL_006c: ldstr "FAILED" - IL_0071: br.s IL_0078 + IL_00a5: ldstr "FAILED" + IL_00aa: br.s IL_00b1 - IL_0073: ldstr "PASSED" - IL_0078: call string [mscorlib]System.String::Concat(string, + IL_00ac: ldstr "PASSED" + IL_00b1: call string [mscorlib]System.String::Concat(string, string) - IL_007d: call void [System.Console]System.Console::WriteLine(string) - IL_0082: ldsfld int32 TailcallVerify.Condition6::Result - IL_0087: ret - } // end of method Condition6::Test3 + IL_00b6: call void [System.Console]System.Console::WriteLine(string) + IL_00bb: ldsfld int32 TailcallVerify.Condition7::Result + IL_00c0: ret + } // end of method Condition7::Test4 - .method private hidebysig static void Caller3() cil managed + .method private hidebysig static void Caller4(valuetype TailcallVerify.ValueType3Bytes v1, + valuetype TailcallVerify.ValueType5Bytes v2, + valuetype TailcallVerify.ValueTypeSingleInt64 v3, + valuetype TailcallVerify.ValueType3Bytes v4, + valuetype TailcallVerify.ValueType5Bytes v5, + valuetype TailcallVerify.ValueType3Bytes v6) cil managed { - // Code size 88 (0x58) - .maxstack 4 - .locals init ([0] valuetype TailcallVerify.ValueType3Bytes CS$0$0000, - [1] valuetype TailcallVerify.ValueType5Bytes CS$0$0001, - [2] valuetype TailcallVerify.ValueTypeSingleInt64 CS$0$0002, - [3] valuetype TailcallVerify.ValueType3Bytes CS$0$0003) + // Code size 81 (0x51) + .maxstack 7 + .locals init ([0] int32[] a) IL_0000: ldc.i4.0 IL_0001: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) IL_0006: callvirt instance class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Diagnostics.StackFrame::GetMethod() @@ -7477,109 +4692,151 @@ IL_001d: ldstr "Failed, Method was inlined..." IL_0022: call void [System.Console]System.Console::WriteLine(string) IL_0027: ldc.i4.s 101 - IL_0029: stsfld int32 TailcallVerify.Condition6::Result - IL_002e: ldloca.s CS$0$0000 - IL_0030: initobj TailcallVerify.ValueType3Bytes - IL_0036: ldloc.0 - IL_0037: ldloca.s CS$0$0001 - IL_0039: initobj TailcallVerify.ValueType5Bytes - IL_003f: ldloc.1 - IL_0040: ldloca.s CS$0$0002 - IL_0042: initobj TailcallVerify.ValueTypeSingleInt64 - IL_0048: ldloc.2 - IL_0049: ldloca.s CS$0$0003 - IL_004b: initobj TailcallVerify.ValueType3Bytes - IL_0051: ldloc.3 - IL_0052: tail. call void TailcallVerify.Condition6::Callee3(valuetype TailcallVerify.ValueType3Bytes, + IL_0029: stsfld int32 TailcallVerify.Condition7::Result + IL_002e: ldc.i4.5 + IL_002f: newarr [mscorlib]System.Int32 + IL_0034: dup + IL_0035: ldtoken field valuetype '{D1242658-CA16-4D11-A740-6635F112F4B5}'/'__StaticArrayInitTypeSize=20' '{D1242658-CA16-4D11-A740-6635F112F4B5}'::'$$method0x6000076-1' + IL_003a: call void [mscorlib]System.Runtime.CompilerServices.RuntimeHelpers::InitializeArray(class [mscorlib]System.Array, + valuetype [mscorlib]System.RuntimeFieldHandle) + IL_003f: stloc.0 + IL_0040: ldarg.0 + IL_0041: ldarg.1 + IL_0042: ldarg.2 + IL_0043: ldarg.3 + IL_0044: ldarg.s v5 + IL_0046: ldarg.s v6 + IL_0048: ldloc.0 + IL_0049: ldlen + IL_004a: conv.i4 + IL_004b: tail. call void TailcallVerify.Condition7::Callee4(valuetype TailcallVerify.ValueType3Bytes, valuetype TailcallVerify.ValueType5Bytes, valuetype TailcallVerify.ValueTypeSingleInt64, - valuetype TailcallVerify.ValueType3Bytes) - IL_0057: ret - } // end of method Condition6::Caller3 + valuetype TailcallVerify.ValueType3Bytes, + valuetype TailcallVerify.ValueType5Bytes, + valuetype TailcallVerify.ValueType3Bytes, + int32) + IL_0050: ret + } // end of method Condition7::Caller4 - .method private hidebysig static void Callee3(valuetype TailcallVerify.ValueType3Bytes v1, + .method private hidebysig static void Callee4(valuetype TailcallVerify.ValueType3Bytes v1, valuetype TailcallVerify.ValueType5Bytes v2, valuetype TailcallVerify.ValueTypeSingleInt64 v3, - valuetype TailcallVerify.ValueType3Bytes v4) cil managed noinlining + valuetype TailcallVerify.ValueType3Bytes v4, + valuetype TailcallVerify.ValueType5Bytes v5, + valuetype TailcallVerify.ValueType3Bytes v6, + int32 i7) cil managed noinlining { // Code size 18 (0x12) .maxstack 8 IL_0000: ldarga.s v1 IL_0002: ldc.i4.1 IL_0003: volatile. - IL_0005: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition6::zero + IL_0005: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition7::zero IL_000a: div IL_000b: conv.i2 IL_000c: stfld int16 TailcallVerify.ValueType3Bytes::i2 IL_0011: ret - } // end of method Condition6::Callee3 + } // end of method Condition7::Callee4 - .method public hidebysig static int32 Test4() cil managed nooptimization + .method public hidebysig specialname rtspecialname + instance void .ctor() cil managed { - // Code size 136 (0x88) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: call instance void [mscorlib]System.Object::.ctor() + IL_0006: ret + } // end of method Condition7::.ctor + + .method private hidebysig specialname rtspecialname static + void .cctor() cil managed + { + // Code size 16 (0x10) + .maxstack 8 + IL_0000: ldc.i4.0 + IL_0001: volatile. + IL_0003: stsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition7::zero + IL_0008: ldc.i4.s 100 + IL_000a: stsfld int32 TailcallVerify.Condition7::Result + IL_000f: ret + } // end of method Condition7::.cctor + +} // end of class TailcallVerify.Condition7 + +.class private auto ansi beforefieldinit TailcallVerify.Condition20 + extends [mscorlib]System.Object +{ + .field private static int32 Result + .method public hidebysig static int32 Test1() cil managed nooptimization + { + // Code size 158 (0x9e) .maxstack 3 .locals init ([0] class [mscorlib]System.Exception e) - IL_0000: ldstr "Executing Condition6.Test4 - Caller: Arguments: No" - + "ne - ReturnType: void; Callee: Arguments: 3 byte struct - ReturnType: v" - + "oid" + IL_0000: ldstr "Executing Condition20.Test1 - Caller: Arguments: i" + + "nt - ReturnType: void; Callee: the same as Caller (called again)" IL_0005: call void [System.Console]System.Console::WriteLine(string) IL_000a: ldc.i4.s 100 - IL_000c: stsfld int32 TailcallVerify.Condition6::Result + IL_000c: stsfld int32 TailcallVerify.Condition20::Result .try { - IL_0011: call void TailcallVerify.Condition6::Caller4() - IL_0016: leave.s IL_005e + IL_0011: ldc.i4 0xc8 + IL_0016: call void TailcallVerify.Condition20::Caller1(int32) + IL_001b: leave.s IL_0074 } // end .try catch [mscorlib]System.Exception { - IL_0018: stloc.0 - IL_0019: ldloc.0 - IL_001a: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_001f: ldstr "Caller" - IL_0024: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_0029: ldc.i4.m1 - IL_002a: beq.s IL_005c + IL_001d: stloc.0 + IL_001e: ldloc.0 + IL_001f: isinst [mscorlib]System.DivideByZeroException + IL_0024: brtrue.s IL_002f - IL_002c: ldstr "FAILED: Found the word 'Caller' in the stacktrace." - IL_0031: call void [System.Console]System.Console::WriteLine(string) - IL_0036: ldstr "------------------------------------------------" - IL_003b: call void [System.Console]System.Console::WriteLine(string) - IL_0040: call void [System.Console]System.Console::WriteLine() - IL_0045: ldloc.0 - IL_0046: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_004b: call void [System.Console]System.Console::WriteLine(string) - IL_0050: call void [System.Console]System.Console::WriteLine() - IL_0055: ldc.i4.s 101 - IL_0057: stsfld int32 TailcallVerify.Condition6::Result - IL_005c: leave.s IL_005e + IL_0026: ldc.i4.s 101 + IL_0028: stsfld int32 TailcallVerify.Condition20::Result + IL_002d: rethrow + IL_002f: ldloc.0 + IL_0030: callvirt instance string [mscorlib]System.Exception::get_StackTrace() + IL_0035: ldstr "Caller" + IL_003a: callvirt instance int32 [mscorlib]System.String::IndexOf(string) + IL_003f: ldc.i4.m1 + IL_0040: bne.un.s IL_0072 + + IL_0042: ldstr "FAILED: Did not find the word 'Caller' in the stac" + + "ktrace." + IL_0047: call void [System.Console]System.Console::WriteLine(string) + IL_004c: ldstr "------------------------------------------------" + IL_0051: call void [System.Console]System.Console::WriteLine(string) + IL_0056: call void [System.Console]System.Console::WriteLine() + IL_005b: ldloc.0 + IL_005c: callvirt instance string [mscorlib]System.Exception::get_StackTrace() + IL_0061: call void [System.Console]System.Console::WriteLine(string) + IL_0066: call void [System.Console]System.Console::WriteLine() + IL_006b: ldc.i4.s 101 + IL_006d: stsfld int32 TailcallVerify.Condition20::Result + IL_0072: leave.s IL_0074 } // end handler - IL_005e: ldstr "Execution finished - Test " - IL_0063: ldsfld int32 TailcallVerify.Condition6::Result - IL_0068: ldc.i4.s 100 - IL_006a: beq.s IL_0073 + IL_0074: ldstr "Execution finished - Test " + IL_0079: ldsfld int32 TailcallVerify.Condition20::Result + IL_007e: ldc.i4.s 100 + IL_0080: beq.s IL_0089 - IL_006c: ldstr "FAILED" - IL_0071: br.s IL_0078 + IL_0082: ldstr "FAILED" + IL_0087: br.s IL_008e - IL_0073: ldstr "PASSED" - IL_0078: call string [mscorlib]System.String::Concat(string, + IL_0089: ldstr "PASSED" + IL_008e: call string [mscorlib]System.String::Concat(string, string) - IL_007d: call void [System.Console]System.Console::WriteLine(string) - IL_0082: ldsfld int32 TailcallVerify.Condition6::Result - IL_0087: ret - } // end of method Condition6::Test4 + IL_0093: call void [System.Console]System.Console::WriteLine(string) + IL_0098: ldsfld int32 TailcallVerify.Condition20::Result + IL_009d: ret + } // end of method Condition20::Test1 - .method private hidebysig static void Caller4() cil managed + .method private hidebysig static void Caller1(int32 i) cil managed noinlining { - // Code size 98 (0x62) - .maxstack 5 - .locals init ([0] valuetype TailcallVerify.ValueType3Bytes CS$0$0000, - [1] valuetype TailcallVerify.ValueType5Bytes CS$0$0001, - [2] valuetype TailcallVerify.ValueTypeSingleInt64 CS$0$0002, - [3] valuetype TailcallVerify.ValueType3Bytes CS$0$0003, - [4] valuetype TailcallVerify.ValueType5Bytes CS$0$0004) + // Code size 60 (0x3c) + .maxstack 8 IL_0000: ldc.i4.0 IL_0001: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) IL_0006: callvirt instance class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Diagnostics.StackFrame::GetMethod() @@ -7592,54 +4849,51 @@ IL_001d: ldstr "Failed, Method was inlined..." IL_0022: call void [System.Console]System.Console::WriteLine(string) IL_0027: ldc.i4.s 101 - IL_0029: stsfld int32 TailcallVerify.Condition6::Result - IL_002e: ldloca.s CS$0$0000 - IL_0030: initobj TailcallVerify.ValueType3Bytes - IL_0036: ldloc.0 - IL_0037: ldloca.s CS$0$0001 - IL_0039: initobj TailcallVerify.ValueType5Bytes - IL_003f: ldloc.1 - IL_0040: ldloca.s CS$0$0002 - IL_0042: initobj TailcallVerify.ValueTypeSingleInt64 - IL_0048: ldloc.2 - IL_0049: ldloca.s CS$0$0003 - IL_004b: initobj TailcallVerify.ValueType3Bytes - IL_0051: ldloc.3 - IL_0052: ldloca.s CS$0$0004 - IL_0054: initobj TailcallVerify.ValueType5Bytes - IL_005a: ldloc.s CS$0$0004 - IL_005c: tail. call void TailcallVerify.Condition6::Callee4(valuetype TailcallVerify.ValueType3Bytes, - valuetype TailcallVerify.ValueType5Bytes, - valuetype TailcallVerify.ValueTypeSingleInt64, - valuetype TailcallVerify.ValueType3Bytes, - valuetype TailcallVerify.ValueType5Bytes) - IL_0061: ret - } // end of method Condition6::Caller4 + IL_0029: stsfld int32 TailcallVerify.Condition20::Result + IL_002e: ldc.i4.s 10 + IL_0030: ldarg.0 + IL_0031: div + IL_0032: pop + IL_0033: ldarg.0 + IL_0034: ldc.i4.1 + IL_0035: sub + IL_0036: call void TailcallVerify.Condition20::Caller1(int32) + IL_003b: ret + } // end of method Condition20::Caller1 - .method private hidebysig static void Callee4(valuetype TailcallVerify.ValueType3Bytes v1, - valuetype TailcallVerify.ValueType5Bytes v2, - valuetype TailcallVerify.ValueTypeSingleInt64 v3, - valuetype TailcallVerify.ValueType3Bytes v4, - valuetype TailcallVerify.ValueType5Bytes v5) cil managed noinlining + .method public hidebysig specialname rtspecialname + instance void .ctor() cil managed { - // Code size 18 (0x12) + // Code size 7 (0x7) .maxstack 8 - IL_0000: ldarga.s v1 - IL_0002: ldc.i4.1 - IL_0003: volatile. - IL_0005: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition6::zero - IL_000a: div - IL_000b: conv.i2 - IL_000c: stfld int16 TailcallVerify.ValueType3Bytes::i2 - IL_0011: ret - } // end of method Condition6::Callee4 + IL_0000: ldarg.0 + IL_0001: call instance void [mscorlib]System.Object::.ctor() + IL_0006: ret + } // end of method Condition20::.ctor - .method public hidebysig static int32 Test5() cil managed nooptimization + .method private hidebysig specialname rtspecialname static + void .cctor() cil managed + { + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldc.i4.s 100 + IL_0002: stsfld int32 TailcallVerify.Condition20::Result + IL_0007: ret + } // end of method Condition20::.cctor + +} // end of class TailcallVerify.Condition20 + +.class private auto ansi beforefieldinit TailcallVerify.Condition6 + extends [mscorlib]System.Object +{ + .field private static int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) zero + .field private static int32 Result + .method public hidebysig static int32 Test1() cil managed nooptimization { // Code size 136 (0x88) .maxstack 3 .locals init ([0] class [mscorlib]System.Exception e) - IL_0000: ldstr "Executing Condition6.Test5 - Caller: Arguments: No" + IL_0000: ldstr "Executing Condition6.Test1 - Caller: Arguments: No" + "ne - ReturnType: void; Callee: Arguments: 3 byte struct - ReturnType: v" + "oid" IL_0005: call void [System.Console]System.Console::WriteLine(string) @@ -7647,7 +4901,7 @@ IL_000c: stsfld int32 TailcallVerify.Condition6::Result .try { - IL_0011: call void TailcallVerify.Condition6::Caller5() + IL_0011: call void TailcallVerify.Condition6::Caller1() IL_0016: leave.s IL_005e } // end .try @@ -7689,18 +4943,14 @@ IL_007d: call void [System.Console]System.Console::WriteLine(string) IL_0082: ldsfld int32 TailcallVerify.Condition6::Result IL_0087: ret - } // end of method Condition6::Test5 + } // end of method Condition6::Test1 - .method private hidebysig static void Caller5() cil managed + .method private hidebysig static void Caller1() cil managed { - // Code size 108 (0x6c) - .maxstack 6 + // Code size 70 (0x46) + .maxstack 2 .locals init ([0] valuetype TailcallVerify.ValueType3Bytes CS$0$0000, - [1] valuetype TailcallVerify.ValueType5Bytes CS$0$0001, - [2] valuetype TailcallVerify.ValueTypeSingleInt64 CS$0$0002, - [3] valuetype TailcallVerify.ValueType3Bytes CS$0$0003, - [4] valuetype TailcallVerify.ValueType5Bytes CS$0$0004, - [5] valuetype TailcallVerify.ValueType3Bytes CS$0$0005) + [1] valuetype TailcallVerify.ValueType5Bytes CS$0$0001) IL_0000: ldc.i4.0 IL_0001: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) IL_0006: callvirt instance class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Diagnostics.StackFrame::GetMethod() @@ -7720,37 +4970,17 @@ IL_0037: ldloca.s CS$0$0001 IL_0039: initobj TailcallVerify.ValueType5Bytes IL_003f: ldloc.1 - IL_0040: ldloca.s CS$0$0002 - IL_0042: initobj TailcallVerify.ValueTypeSingleInt64 - IL_0048: ldloc.2 - IL_0049: ldloca.s CS$0$0003 - IL_004b: initobj TailcallVerify.ValueType3Bytes - IL_0051: ldloc.3 - IL_0052: ldloca.s CS$0$0004 - IL_0054: initobj TailcallVerify.ValueType5Bytes - IL_005a: ldloc.s CS$0$0004 - IL_005c: ldloca.s CS$0$0005 - IL_005e: initobj TailcallVerify.ValueType3Bytes - IL_0064: ldloc.s CS$0$0005 - IL_0066: tail. call void TailcallVerify.Condition6::Callee5(valuetype TailcallVerify.ValueType3Bytes, - valuetype TailcallVerify.ValueType5Bytes, - valuetype TailcallVerify.ValueTypeSingleInt64, - valuetype TailcallVerify.ValueType3Bytes, - valuetype TailcallVerify.ValueType5Bytes, - valuetype TailcallVerify.ValueType3Bytes) - IL_006b: ret - } // end of method Condition6::Caller5 + IL_0040: tail. call void TailcallVerify.Condition6::Callee1(valuetype TailcallVerify.ValueType3Bytes, + valuetype TailcallVerify.ValueType5Bytes) + IL_0045: ret + } // end of method Condition6::Caller1 - .method private hidebysig static void Callee5(valuetype TailcallVerify.ValueType3Bytes v1, - valuetype TailcallVerify.ValueType5Bytes v2, - valuetype TailcallVerify.ValueTypeSingleInt64 v3, - valuetype TailcallVerify.ValueType3Bytes v4, - valuetype TailcallVerify.ValueType5Bytes v5, - valuetype TailcallVerify.ValueType3Bytes v6) cil managed noinlining + .method private hidebysig static void Callee1(valuetype TailcallVerify.ValueType3Bytes v, + valuetype TailcallVerify.ValueType5Bytes v5) cil managed noinlining { // Code size 18 (0x12) .maxstack 8 - IL_0000: ldarga.s v1 + IL_0000: ldarga.s v IL_0002: ldc.i4.1 IL_0003: volatile. IL_0005: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition6::zero @@ -7758,202 +4988,72 @@ IL_000b: conv.i2 IL_000c: stfld int16 TailcallVerify.ValueType3Bytes::i2 IL_0011: ret - } // end of method Condition6::Callee5 - - .method public hidebysig specialname rtspecialname - instance void .ctor() cil managed - { - // Code size 7 (0x7) - .maxstack 8 - IL_0000: ldarg.0 - IL_0001: call instance void [mscorlib]System.Object::.ctor() - IL_0006: ret - } // end of method Condition6::.ctor - - .method private hidebysig specialname rtspecialname static - void .cctor() cil managed - { - // Code size 16 (0x10) - .maxstack 8 - IL_0000: ldc.i4.0 - IL_0001: volatile. - IL_0003: stsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition6::zero - IL_0008: ldc.i4.s 100 - IL_000a: stsfld int32 TailcallVerify.Condition6::Result - IL_000f: ret - } // end of method Condition6::.cctor - -} // end of class TailcallVerify.Condition6 - -.class private auto ansi beforefieldinit TailcallVerify.Condition5 - extends [mscorlib]System.Object -{ - .field private static int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) dummy - .field private static int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) zero - .field private static int32 Result - .method public hidebysig static int32 Test1() cil managed nooptimization - { - // Code size 104 (0x68) - .maxstack 3 - .locals init ([0] class [mscorlib]System.Exception e) - IL_0000: ldstr "Executing Condition5.Test1 - There is a 'conv.i2' " - + "IL instruction between the tail. call to the Callee and the ret IL instructio" - + "n which is not allowed. Expecting to catch an InvalidProgramException i" - + "nternally if tail. prefix is present." - IL_0005: call void [System.Console]System.Console::WriteLine(string) - IL_000a: ldc.i4.s 100 - IL_000c: stsfld int32 TailcallVerify.Condition5::Result - .try - { - IL_0011: call int16 TailcallVerify.Condition5::Caller1() - IL_0016: pop - IL_0017: leave.s IL_003e - - } // end .try - catch [mscorlib]System.Exception - { - IL_0019: stloc.0 - IL_001a: ldloc.0 - IL_001b: isinst [mscorlib]System.InvalidProgramException - IL_0020: brtrue.s IL_002a - - IL_0022: ldloc.0 - IL_0023: isinst [mscorlib]System.DivideByZeroException - IL_0028: brfalse.s IL_0033 - - IL_002a: ldc.i4.s 100 - IL_002c: stsfld int32 TailcallVerify.Condition5::Result - IL_0031: br.s IL_003c - - IL_0033: ldc.i4.s 101 - IL_0035: stsfld int32 TailcallVerify.Condition5::Result - IL_003a: rethrow - IL_003c: leave.s IL_003e - - } // end handler - IL_003e: ldstr "Execution finished - Test " - IL_0043: ldsfld int32 TailcallVerify.Condition5::Result - IL_0048: ldc.i4.s 100 - IL_004a: beq.s IL_0053 - - IL_004c: ldstr "FAILED" - IL_0051: br.s IL_0058 - - IL_0053: ldstr "PASSED" - IL_0058: call string [mscorlib]System.String::Concat(string, - string) - IL_005d: call void [System.Console]System.Console::WriteLine(string) - IL_0062: ldsfld int32 TailcallVerify.Condition5::Result - IL_0067: ret - } // end of method Condition5::Test1 - - .method private hidebysig static int16 - Caller1() cil managed - { - // Code size 53 (0x35) - .maxstack 8 - IL_0000: ldc.i4.0 - IL_0001: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) - IL_0006: callvirt instance class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Diagnostics.StackFrame::GetMethod() - IL_000b: callvirt instance string [mscorlib]System.Reflection.MemberInfo::get_Name() - IL_0010: ldstr "Caller" - IL_0015: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_001a: ldc.i4.m1 - IL_001b: bne.un.s IL_002e - - IL_001d: ldstr "Failed, Method was inlined..." - IL_0022: call void [System.Console]System.Console::WriteLine(string) - IL_0027: ldc.i4.s 101 - IL_0029: stsfld int32 TailcallVerify.Condition5::Result - IL_002e: tail. call int32 TailcallVerify.Condition5::Callee1() - IL_0033: conv.i2 - IL_0034: ret - } // end of method Condition5::Caller1 - - .method private hidebysig static int32 - Callee1() cil managed noinlining - { - // Code size 12 (0xc) - .maxstack 2 - .locals init ([0] int32 i) - IL_0000: ldc.i4.1 - IL_0001: volatile. - IL_0003: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition5::zero - IL_0008: div - IL_0009: stloc.0 - IL_000a: ldloc.0 - IL_000b: ret - } // end of method Condition5::Callee1 + } // end of method Condition6::Callee1 .method public hidebysig static int32 Test2() cil managed nooptimization { - // Code size 154 (0x9a) + // Code size 136 (0x88) .maxstack 3 .locals init ([0] class [mscorlib]System.Exception e) - IL_0000: ldstr "Executing Condition5.Test2 - Caller: Arguments: No" - + "ne - ReturnType: byte; Callee: Arguments: None - ReturnType: byte" + IL_0000: ldstr "Executing Condition6.Test2 - Caller: Arguments: No" + + "ne - ReturnType: void; Callee: Arguments: 3 byte struct - ReturnType: v" + + "oid" IL_0005: call void [System.Console]System.Console::WriteLine(string) IL_000a: ldc.i4.s 100 - IL_000c: stsfld int32 TailcallVerify.Condition5::Result + IL_000c: stsfld int32 TailcallVerify.Condition6::Result .try { - IL_0011: call uint8 TailcallVerify.Condition5::Caller2() - IL_0016: pop - IL_0017: leave.s IL_0070 + IL_0011: call void TailcallVerify.Condition6::Caller2() + IL_0016: leave.s IL_005e } // end .try catch [mscorlib]System.Exception { - IL_0019: stloc.0 - IL_001a: ldloc.0 - IL_001b: isinst [mscorlib]System.DivideByZeroException - IL_0020: brtrue.s IL_002b - - IL_0022: ldc.i4.s 101 - IL_0024: stsfld int32 TailcallVerify.Condition5::Result - IL_0029: rethrow - IL_002b: ldloc.0 - IL_002c: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_0031: ldstr "Caller" - IL_0036: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_003b: ldc.i4.m1 - IL_003c: beq.s IL_006e + IL_0018: stloc.0 + IL_0019: ldloc.0 + IL_001a: callvirt instance string [mscorlib]System.Exception::get_StackTrace() + IL_001f: ldstr "Caller" + IL_0024: callvirt instance int32 [mscorlib]System.String::IndexOf(string) + IL_0029: ldc.i4.m1 + IL_002a: beq.s IL_005c - IL_003e: ldstr "FAILED: Found the word 'Caller' in the stacktrace." - IL_0043: call void [System.Console]System.Console::WriteLine(string) - IL_0048: ldstr "------------------------------------------------" - IL_004d: call void [System.Console]System.Console::WriteLine(string) - IL_0052: call void [System.Console]System.Console::WriteLine() - IL_0057: ldloc.0 - IL_0058: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_005d: call void [System.Console]System.Console::WriteLine(string) - IL_0062: call void [System.Console]System.Console::WriteLine() - IL_0067: ldc.i4.s 101 - IL_0069: stsfld int32 TailcallVerify.Condition5::Result - IL_006e: leave.s IL_0070 + IL_002c: ldstr "FAILED: Found the word 'Caller' in the stacktrace." + IL_0031: call void [System.Console]System.Console::WriteLine(string) + IL_0036: ldstr "------------------------------------------------" + IL_003b: call void [System.Console]System.Console::WriteLine(string) + IL_0040: call void [System.Console]System.Console::WriteLine() + IL_0045: ldloc.0 + IL_0046: callvirt instance string [mscorlib]System.Exception::get_StackTrace() + IL_004b: call void [System.Console]System.Console::WriteLine(string) + IL_0050: call void [System.Console]System.Console::WriteLine() + IL_0055: ldc.i4.s 101 + IL_0057: stsfld int32 TailcallVerify.Condition6::Result + IL_005c: leave.s IL_005e } // end handler - IL_0070: ldstr "Execution finished - Test " - IL_0075: ldsfld int32 TailcallVerify.Condition5::Result - IL_007a: ldc.i4.s 100 - IL_007c: beq.s IL_0085 + IL_005e: ldstr "Execution finished - Test " + IL_0063: ldsfld int32 TailcallVerify.Condition6::Result + IL_0068: ldc.i4.s 100 + IL_006a: beq.s IL_0073 - IL_007e: ldstr "FAILED" - IL_0083: br.s IL_008a + IL_006c: ldstr "FAILED" + IL_0071: br.s IL_0078 - IL_0085: ldstr "PASSED" - IL_008a: call string [mscorlib]System.String::Concat(string, - string) - IL_008f: call void [System.Console]System.Console::WriteLine(string) - IL_0094: ldsfld int32 TailcallVerify.Condition5::Result - IL_0099: ret - } // end of method Condition5::Test2 + IL_0073: ldstr "PASSED" + IL_0078: call string [mscorlib]System.String::Concat(string, + string) + IL_007d: call void [System.Console]System.Console::WriteLine(string) + IL_0082: ldsfld int32 TailcallVerify.Condition6::Result + IL_0087: ret + } // end of method Condition6::Test2 - .method private hidebysig static uint8 - Caller2() cil managed + .method private hidebysig static void Caller2() cil managed { - // Code size 52 (0x34) - .maxstack 8 + // Code size 79 (0x4f) + .maxstack 3 + .locals init ([0] valuetype TailcallVerify.ValueType3Bytes CS$0$0000, + [1] valuetype TailcallVerify.ValueType5Bytes CS$0$0001, + [2] valuetype TailcallVerify.ValueTypeSingleInt64 CS$0$0002) IL_0000: ldc.i4.0 IL_0001: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) IL_0006: callvirt instance class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Diagnostics.StackFrame::GetMethod() @@ -7966,94 +5066,103 @@ IL_001d: ldstr "Failed, Method was inlined..." IL_0022: call void [System.Console]System.Console::WriteLine(string) IL_0027: ldc.i4.s 101 - IL_0029: stsfld int32 TailcallVerify.Condition5::Result - IL_002e: tail. call uint8 TailcallVerify.Condition5::Callee2() - IL_0033: ret - } // end of method Condition5::Caller2 + IL_0029: stsfld int32 TailcallVerify.Condition6::Result + IL_002e: ldloca.s CS$0$0000 + IL_0030: initobj TailcallVerify.ValueType3Bytes + IL_0036: ldloc.0 + IL_0037: ldloca.s CS$0$0001 + IL_0039: initobj TailcallVerify.ValueType5Bytes + IL_003f: ldloc.1 + IL_0040: ldloca.s CS$0$0002 + IL_0042: initobj TailcallVerify.ValueTypeSingleInt64 + IL_0048: ldloc.2 + IL_0049: tail. call void TailcallVerify.Condition6::Callee2(valuetype TailcallVerify.ValueType3Bytes, + valuetype TailcallVerify.ValueType5Bytes, + valuetype TailcallVerify.ValueTypeSingleInt64) + IL_004e: ret + } // end of method Condition6::Caller2 - .method private hidebysig static uint8 - Callee2() cil managed noinlining + .method private hidebysig static void Callee2(valuetype TailcallVerify.ValueType3Bytes v1, + valuetype TailcallVerify.ValueType5Bytes v2, + valuetype TailcallVerify.ValueTypeSingleInt64 v3) cil managed noinlining { - // Code size 17 (0x11) + // Code size 18 (0x12) .maxstack 8 - IL_0000: volatile. - IL_0002: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition5::dummy - IL_0007: volatile. - IL_0009: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition5::zero - IL_000e: div - IL_000f: conv.u1 - IL_0010: ret - } // end of method Condition5::Callee2 + IL_0000: ldarga.s v1 + IL_0002: ldc.i4.1 + IL_0003: volatile. + IL_0005: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition6::zero + IL_000a: div + IL_000b: conv.i2 + IL_000c: stfld int16 TailcallVerify.ValueType3Bytes::i2 + IL_0011: ret + } // end of method Condition6::Callee2 .method public hidebysig static int32 Test3() cil managed nooptimization { - // Code size 154 (0x9a) + // Code size 136 (0x88) .maxstack 3 .locals init ([0] class [mscorlib]System.Exception e) - IL_0000: ldstr "Executing Condition5.Test3 - Caller: Arguments: No" - + "ne - ReturnType: Int32; Callee: Arguments: None - ReturnType: Int32" + IL_0000: ldstr "Executing Condition6.Test3 - Caller: Arguments: No" + + "ne - ReturnType: void; Callee: Arguments: 3 byte struct - ReturnType: v" + + "oid" IL_0005: call void [System.Console]System.Console::WriteLine(string) IL_000a: ldc.i4.s 100 - IL_000c: stsfld int32 TailcallVerify.Condition5::Result + IL_000c: stsfld int32 TailcallVerify.Condition6::Result .try { - IL_0011: call int32 TailcallVerify.Condition5::Caller3() - IL_0016: pop - IL_0017: leave.s IL_0070 + IL_0011: call void TailcallVerify.Condition6::Caller3() + IL_0016: leave.s IL_005e } // end .try catch [mscorlib]System.Exception { - IL_0019: stloc.0 - IL_001a: ldloc.0 - IL_001b: isinst [mscorlib]System.DivideByZeroException - IL_0020: brtrue.s IL_002b - - IL_0022: ldc.i4.s 101 - IL_0024: stsfld int32 TailcallVerify.Condition5::Result - IL_0029: rethrow - IL_002b: ldloc.0 - IL_002c: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_0031: ldstr "Caller" - IL_0036: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_003b: ldc.i4.m1 - IL_003c: beq.s IL_006e + IL_0018: stloc.0 + IL_0019: ldloc.0 + IL_001a: callvirt instance string [mscorlib]System.Exception::get_StackTrace() + IL_001f: ldstr "Caller" + IL_0024: callvirt instance int32 [mscorlib]System.String::IndexOf(string) + IL_0029: ldc.i4.m1 + IL_002a: beq.s IL_005c - IL_003e: ldstr "FAILED: Found the word 'Caller' in the stacktrace." - IL_0043: call void [System.Console]System.Console::WriteLine(string) - IL_0048: ldstr "------------------------------------------------" - IL_004d: call void [System.Console]System.Console::WriteLine(string) - IL_0052: call void [System.Console]System.Console::WriteLine() - IL_0057: ldloc.0 - IL_0058: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_005d: call void [System.Console]System.Console::WriteLine(string) - IL_0062: call void [System.Console]System.Console::WriteLine() - IL_0067: ldc.i4.s 101 - IL_0069: stsfld int32 TailcallVerify.Condition5::Result - IL_006e: leave.s IL_0070 + IL_002c: ldstr "FAILED: Found the word 'Caller' in the stacktrace." + IL_0031: call void [System.Console]System.Console::WriteLine(string) + IL_0036: ldstr "------------------------------------------------" + IL_003b: call void [System.Console]System.Console::WriteLine(string) + IL_0040: call void [System.Console]System.Console::WriteLine() + IL_0045: ldloc.0 + IL_0046: callvirt instance string [mscorlib]System.Exception::get_StackTrace() + IL_004b: call void [System.Console]System.Console::WriteLine(string) + IL_0050: call void [System.Console]System.Console::WriteLine() + IL_0055: ldc.i4.s 101 + IL_0057: stsfld int32 TailcallVerify.Condition6::Result + IL_005c: leave.s IL_005e } // end handler - IL_0070: ldstr "Execution finished - Test " - IL_0075: ldsfld int32 TailcallVerify.Condition5::Result - IL_007a: ldc.i4.s 100 - IL_007c: beq.s IL_0085 + IL_005e: ldstr "Execution finished - Test " + IL_0063: ldsfld int32 TailcallVerify.Condition6::Result + IL_0068: ldc.i4.s 100 + IL_006a: beq.s IL_0073 - IL_007e: ldstr "FAILED" - IL_0083: br.s IL_008a + IL_006c: ldstr "FAILED" + IL_0071: br.s IL_0078 - IL_0085: ldstr "PASSED" - IL_008a: call string [mscorlib]System.String::Concat(string, + IL_0073: ldstr "PASSED" + IL_0078: call string [mscorlib]System.String::Concat(string, string) - IL_008f: call void [System.Console]System.Console::WriteLine(string) - IL_0094: ldsfld int32 TailcallVerify.Condition5::Result - IL_0099: ret - } // end of method Condition5::Test3 + IL_007d: call void [System.Console]System.Console::WriteLine(string) + IL_0082: ldsfld int32 TailcallVerify.Condition6::Result + IL_0087: ret + } // end of method Condition6::Test3 - .method private hidebysig static int32 - Caller3() cil managed + .method private hidebysig static void Caller3() cil managed { - // Code size 52 (0x34) - .maxstack 8 + // Code size 88 (0x58) + .maxstack 4 + .locals init ([0] valuetype TailcallVerify.ValueType3Bytes CS$0$0000, + [1] valuetype TailcallVerify.ValueType5Bytes CS$0$0001, + [2] valuetype TailcallVerify.ValueTypeSingleInt64 CS$0$0002, + [3] valuetype TailcallVerify.ValueType3Bytes CS$0$0003) IL_0000: ldc.i4.0 IL_0001: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) IL_0006: callvirt instance class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Diagnostics.StackFrame::GetMethod() @@ -8066,93 +5175,109 @@ IL_001d: ldstr "Failed, Method was inlined..." IL_0022: call void [System.Console]System.Console::WriteLine(string) IL_0027: ldc.i4.s 101 - IL_0029: stsfld int32 TailcallVerify.Condition5::Result - IL_002e: tail. call int32 TailcallVerify.Condition5::Callee3() - IL_0033: ret - } // end of method Condition5::Caller3 + IL_0029: stsfld int32 TailcallVerify.Condition6::Result + IL_002e: ldloca.s CS$0$0000 + IL_0030: initobj TailcallVerify.ValueType3Bytes + IL_0036: ldloc.0 + IL_0037: ldloca.s CS$0$0001 + IL_0039: initobj TailcallVerify.ValueType5Bytes + IL_003f: ldloc.1 + IL_0040: ldloca.s CS$0$0002 + IL_0042: initobj TailcallVerify.ValueTypeSingleInt64 + IL_0048: ldloc.2 + IL_0049: ldloca.s CS$0$0003 + IL_004b: initobj TailcallVerify.ValueType3Bytes + IL_0051: ldloc.3 + IL_0052: tail. call void TailcallVerify.Condition6::Callee3(valuetype TailcallVerify.ValueType3Bytes, + valuetype TailcallVerify.ValueType5Bytes, + valuetype TailcallVerify.ValueTypeSingleInt64, + valuetype TailcallVerify.ValueType3Bytes) + IL_0057: ret + } // end of method Condition6::Caller3 - .method private hidebysig static int32 - Callee3() cil managed noinlining + .method private hidebysig static void Callee3(valuetype TailcallVerify.ValueType3Bytes v1, + valuetype TailcallVerify.ValueType5Bytes v2, + valuetype TailcallVerify.ValueTypeSingleInt64 v3, + valuetype TailcallVerify.ValueType3Bytes v4) cil managed noinlining { - // Code size 16 (0x10) + // Code size 18 (0x12) .maxstack 8 - IL_0000: volatile. - IL_0002: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition5::dummy - IL_0007: volatile. - IL_0009: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition5::zero - IL_000e: div - IL_000f: ret - } // end of method Condition5::Callee3 + IL_0000: ldarga.s v1 + IL_0002: ldc.i4.1 + IL_0003: volatile. + IL_0005: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition6::zero + IL_000a: div + IL_000b: conv.i2 + IL_000c: stfld int16 TailcallVerify.ValueType3Bytes::i2 + IL_0011: ret + } // end of method Condition6::Callee3 .method public hidebysig static int32 Test4() cil managed nooptimization { - // Code size 154 (0x9a) + // Code size 136 (0x88) .maxstack 3 .locals init ([0] class [mscorlib]System.Exception e) - IL_0000: ldstr "Executing Condition5.Test4 - Caller: Arguments: No" - + "ne - ReturnType: UInt32; Callee: Arguments: None - ReturnType: Int32" + IL_0000: ldstr "Executing Condition6.Test4 - Caller: Arguments: No" + + "ne - ReturnType: void; Callee: Arguments: 3 byte struct - ReturnType: v" + + "oid" IL_0005: call void [System.Console]System.Console::WriteLine(string) IL_000a: ldc.i4.s 100 - IL_000c: stsfld int32 TailcallVerify.Condition5::Result + IL_000c: stsfld int32 TailcallVerify.Condition6::Result .try { - IL_0011: call uint32 TailcallVerify.Condition5::Caller4() - IL_0016: pop - IL_0017: leave.s IL_0070 + IL_0011: call void TailcallVerify.Condition6::Caller4() + IL_0016: leave.s IL_005e } // end .try catch [mscorlib]System.Exception { - IL_0019: stloc.0 - IL_001a: ldloc.0 - IL_001b: isinst [mscorlib]System.DivideByZeroException - IL_0020: brtrue.s IL_002b - - IL_0022: ldc.i4.s 101 - IL_0024: stsfld int32 TailcallVerify.Condition5::Result - IL_0029: rethrow - IL_002b: ldloc.0 - IL_002c: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_0031: ldstr "Caller" - IL_0036: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_003b: ldc.i4.m1 - IL_003c: beq.s IL_006e + IL_0018: stloc.0 + IL_0019: ldloc.0 + IL_001a: callvirt instance string [mscorlib]System.Exception::get_StackTrace() + IL_001f: ldstr "Caller" + IL_0024: callvirt instance int32 [mscorlib]System.String::IndexOf(string) + IL_0029: ldc.i4.m1 + IL_002a: beq.s IL_005c - IL_003e: ldstr "FAILED: Found the word 'Caller' in the stacktrace." - IL_0043: call void [System.Console]System.Console::WriteLine(string) - IL_0048: ldstr "------------------------------------------------" - IL_004d: call void [System.Console]System.Console::WriteLine(string) - IL_0052: call void [System.Console]System.Console::WriteLine() - IL_0057: ldloc.0 - IL_0058: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_005d: call void [System.Console]System.Console::WriteLine(string) - IL_0062: call void [System.Console]System.Console::WriteLine() - IL_0067: ldc.i4.s 101 - IL_0069: stsfld int32 TailcallVerify.Condition5::Result - IL_006e: leave.s IL_0070 + IL_002c: ldstr "FAILED: Found the word 'Caller' in the stacktrace." + IL_0031: call void [System.Console]System.Console::WriteLine(string) + IL_0036: ldstr "------------------------------------------------" + IL_003b: call void [System.Console]System.Console::WriteLine(string) + IL_0040: call void [System.Console]System.Console::WriteLine() + IL_0045: ldloc.0 + IL_0046: callvirt instance string [mscorlib]System.Exception::get_StackTrace() + IL_004b: call void [System.Console]System.Console::WriteLine(string) + IL_0050: call void [System.Console]System.Console::WriteLine() + IL_0055: ldc.i4.s 101 + IL_0057: stsfld int32 TailcallVerify.Condition6::Result + IL_005c: leave.s IL_005e } // end handler - IL_0070: ldstr "Execution finished - Test " - IL_0075: ldsfld int32 TailcallVerify.Condition5::Result - IL_007a: ldc.i4.s 100 - IL_007c: beq.s IL_0085 + IL_005e: ldstr "Execution finished - Test " + IL_0063: ldsfld int32 TailcallVerify.Condition6::Result + IL_0068: ldc.i4.s 100 + IL_006a: beq.s IL_0073 - IL_007e: ldstr "FAILED" - IL_0083: br.s IL_008a + IL_006c: ldstr "FAILED" + IL_0071: br.s IL_0078 - IL_0085: ldstr "PASSED" - IL_008a: call string [mscorlib]System.String::Concat(string, + IL_0073: ldstr "PASSED" + IL_0078: call string [mscorlib]System.String::Concat(string, string) - IL_008f: call void [System.Console]System.Console::WriteLine(string) - IL_0094: ldsfld int32 TailcallVerify.Condition5::Result - IL_0099: ret - } // end of method Condition5::Test4 + IL_007d: call void [System.Console]System.Console::WriteLine(string) + IL_0082: ldsfld int32 TailcallVerify.Condition6::Result + IL_0087: ret + } // end of method Condition6::Test4 - .method private hidebysig static uint32 - Caller4() cil managed + .method private hidebysig static void Caller4() cil managed { - // Code size 52 (0x34) - .maxstack 8 + // Code size 98 (0x62) + .maxstack 5 + .locals init ([0] valuetype TailcallVerify.ValueType3Bytes CS$0$0000, + [1] valuetype TailcallVerify.ValueType5Bytes CS$0$0001, + [2] valuetype TailcallVerify.ValueTypeSingleInt64 CS$0$0002, + [3] valuetype TailcallVerify.ValueType3Bytes CS$0$0003, + [4] valuetype TailcallVerify.ValueType5Bytes CS$0$0004) IL_0000: ldc.i4.0 IL_0001: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) IL_0006: callvirt instance class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Diagnostics.StackFrame::GetMethod() @@ -8165,93 +5290,115 @@ IL_001d: ldstr "Failed, Method was inlined..." IL_0022: call void [System.Console]System.Console::WriteLine(string) IL_0027: ldc.i4.s 101 - IL_0029: stsfld int32 TailcallVerify.Condition5::Result - IL_002e: tail. call int32 TailcallVerify.Condition5::Callee4() - IL_0033: ret - } // end of method Condition5::Caller4 + IL_0029: stsfld int32 TailcallVerify.Condition6::Result + IL_002e: ldloca.s CS$0$0000 + IL_0030: initobj TailcallVerify.ValueType3Bytes + IL_0036: ldloc.0 + IL_0037: ldloca.s CS$0$0001 + IL_0039: initobj TailcallVerify.ValueType5Bytes + IL_003f: ldloc.1 + IL_0040: ldloca.s CS$0$0002 + IL_0042: initobj TailcallVerify.ValueTypeSingleInt64 + IL_0048: ldloc.2 + IL_0049: ldloca.s CS$0$0003 + IL_004b: initobj TailcallVerify.ValueType3Bytes + IL_0051: ldloc.3 + IL_0052: ldloca.s CS$0$0004 + IL_0054: initobj TailcallVerify.ValueType5Bytes + IL_005a: ldloc.s CS$0$0004 + IL_005c: tail. call void TailcallVerify.Condition6::Callee4(valuetype TailcallVerify.ValueType3Bytes, + valuetype TailcallVerify.ValueType5Bytes, + valuetype TailcallVerify.ValueTypeSingleInt64, + valuetype TailcallVerify.ValueType3Bytes, + valuetype TailcallVerify.ValueType5Bytes) + IL_0061: ret + } // end of method Condition6::Caller4 - .method private hidebysig static int32 - Callee4() cil managed noinlining + .method private hidebysig static void Callee4(valuetype TailcallVerify.ValueType3Bytes v1, + valuetype TailcallVerify.ValueType5Bytes v2, + valuetype TailcallVerify.ValueTypeSingleInt64 v3, + valuetype TailcallVerify.ValueType3Bytes v4, + valuetype TailcallVerify.ValueType5Bytes v5) cil managed noinlining { - // Code size 16 (0x10) + // Code size 18 (0x12) .maxstack 8 - IL_0000: volatile. - IL_0002: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition5::dummy - IL_0007: volatile. - IL_0009: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition5::zero - IL_000e: div - IL_000f: ret - } // end of method Condition5::Callee4 + IL_0000: ldarga.s v1 + IL_0002: ldc.i4.1 + IL_0003: volatile. + IL_0005: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition6::zero + IL_000a: div + IL_000b: conv.i2 + IL_000c: stfld int16 TailcallVerify.ValueType3Bytes::i2 + IL_0011: ret + } // end of method Condition6::Callee4 .method public hidebysig static int32 Test5() cil managed nooptimization { - // Code size 154 (0x9a) + // Code size 136 (0x88) .maxstack 3 .locals init ([0] class [mscorlib]System.Exception e) - IL_0000: ldstr "Executing Condition5.Test5 - Caller: Arguments: No" - + "ne - ReturnType: Int32; Callee: Arguments: None - ReturnType: UInt32" + IL_0000: ldstr "Executing Condition6.Test5 - Caller: Arguments: No" + + "ne - ReturnType: void; Callee: Arguments: 3 byte struct - ReturnType: v" + + "oid" IL_0005: call void [System.Console]System.Console::WriteLine(string) IL_000a: ldc.i4.s 100 - IL_000c: stsfld int32 TailcallVerify.Condition5::Result + IL_000c: stsfld int32 TailcallVerify.Condition6::Result .try { - IL_0011: call int32 TailcallVerify.Condition5::Caller5() - IL_0016: pop - IL_0017: leave.s IL_0070 + IL_0011: call void TailcallVerify.Condition6::Caller5() + IL_0016: leave.s IL_005e } // end .try catch [mscorlib]System.Exception { - IL_0019: stloc.0 - IL_001a: ldloc.0 - IL_001b: isinst [mscorlib]System.DivideByZeroException - IL_0020: brtrue.s IL_002b - - IL_0022: ldc.i4.s 101 - IL_0024: stsfld int32 TailcallVerify.Condition5::Result - IL_0029: rethrow - IL_002b: ldloc.0 - IL_002c: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_0031: ldstr "Caller" - IL_0036: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_003b: ldc.i4.m1 - IL_003c: beq.s IL_006e + IL_0018: stloc.0 + IL_0019: ldloc.0 + IL_001a: callvirt instance string [mscorlib]System.Exception::get_StackTrace() + IL_001f: ldstr "Caller" + IL_0024: callvirt instance int32 [mscorlib]System.String::IndexOf(string) + IL_0029: ldc.i4.m1 + IL_002a: beq.s IL_005c - IL_003e: ldstr "FAILED: Found the word 'Caller' in the stacktrace." - IL_0043: call void [System.Console]System.Console::WriteLine(string) - IL_0048: ldstr "------------------------------------------------" - IL_004d: call void [System.Console]System.Console::WriteLine(string) - IL_0052: call void [System.Console]System.Console::WriteLine() - IL_0057: ldloc.0 - IL_0058: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_005d: call void [System.Console]System.Console::WriteLine(string) - IL_0062: call void [System.Console]System.Console::WriteLine() - IL_0067: ldc.i4.s 101 - IL_0069: stsfld int32 TailcallVerify.Condition5::Result - IL_006e: leave.s IL_0070 + IL_002c: ldstr "FAILED: Found the word 'Caller' in the stacktrace." + IL_0031: call void [System.Console]System.Console::WriteLine(string) + IL_0036: ldstr "------------------------------------------------" + IL_003b: call void [System.Console]System.Console::WriteLine(string) + IL_0040: call void [System.Console]System.Console::WriteLine() + IL_0045: ldloc.0 + IL_0046: callvirt instance string [mscorlib]System.Exception::get_StackTrace() + IL_004b: call void [System.Console]System.Console::WriteLine(string) + IL_0050: call void [System.Console]System.Console::WriteLine() + IL_0055: ldc.i4.s 101 + IL_0057: stsfld int32 TailcallVerify.Condition6::Result + IL_005c: leave.s IL_005e } // end handler - IL_0070: ldstr "Execution finished - Test " - IL_0075: ldsfld int32 TailcallVerify.Condition5::Result - IL_007a: ldc.i4.s 100 - IL_007c: beq.s IL_0085 + IL_005e: ldstr "Execution finished - Test " + IL_0063: ldsfld int32 TailcallVerify.Condition6::Result + IL_0068: ldc.i4.s 100 + IL_006a: beq.s IL_0073 - IL_007e: ldstr "FAILED" - IL_0083: br.s IL_008a + IL_006c: ldstr "FAILED" + IL_0071: br.s IL_0078 - IL_0085: ldstr "PASSED" - IL_008a: call string [mscorlib]System.String::Concat(string, + IL_0073: ldstr "PASSED" + IL_0078: call string [mscorlib]System.String::Concat(string, string) - IL_008f: call void [System.Console]System.Console::WriteLine(string) - IL_0094: ldsfld int32 TailcallVerify.Condition5::Result - IL_0099: ret - } // end of method Condition5::Test5 + IL_007d: call void [System.Console]System.Console::WriteLine(string) + IL_0082: ldsfld int32 TailcallVerify.Condition6::Result + IL_0087: ret + } // end of method Condition6::Test5 - .method private hidebysig static int32 - Caller5() cil managed + .method private hidebysig static void Caller5() cil managed { - // Code size 52 (0x34) - .maxstack 8 + // Code size 108 (0x6c) + .maxstack 6 + .locals init ([0] valuetype TailcallVerify.ValueType3Bytes CS$0$0000, + [1] valuetype TailcallVerify.ValueType5Bytes CS$0$0001, + [2] valuetype TailcallVerify.ValueTypeSingleInt64 CS$0$0002, + [3] valuetype TailcallVerify.ValueType3Bytes CS$0$0003, + [4] valuetype TailcallVerify.ValueType5Bytes CS$0$0004, + [5] valuetype TailcallVerify.ValueType3Bytes CS$0$0005) IL_0000: ldc.i4.0 IL_0001: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) IL_0006: callvirt instance class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Diagnostics.StackFrame::GetMethod() @@ -8264,92 +5411,144 @@ IL_001d: ldstr "Failed, Method was inlined..." IL_0022: call void [System.Console]System.Console::WriteLine(string) IL_0027: ldc.i4.s 101 - IL_0029: stsfld int32 TailcallVerify.Condition5::Result - IL_002e: tail. call uint32 TailcallVerify.Condition5::Callee5() - IL_0033: ret - } // end of method Condition5::Caller5 + IL_0029: stsfld int32 TailcallVerify.Condition6::Result + IL_002e: ldloca.s CS$0$0000 + IL_0030: initobj TailcallVerify.ValueType3Bytes + IL_0036: ldloc.0 + IL_0037: ldloca.s CS$0$0001 + IL_0039: initobj TailcallVerify.ValueType5Bytes + IL_003f: ldloc.1 + IL_0040: ldloca.s CS$0$0002 + IL_0042: initobj TailcallVerify.ValueTypeSingleInt64 + IL_0048: ldloc.2 + IL_0049: ldloca.s CS$0$0003 + IL_004b: initobj TailcallVerify.ValueType3Bytes + IL_0051: ldloc.3 + IL_0052: ldloca.s CS$0$0004 + IL_0054: initobj TailcallVerify.ValueType5Bytes + IL_005a: ldloc.s CS$0$0004 + IL_005c: ldloca.s CS$0$0005 + IL_005e: initobj TailcallVerify.ValueType3Bytes + IL_0064: ldloc.s CS$0$0005 + IL_0066: tail. call void TailcallVerify.Condition6::Callee5(valuetype TailcallVerify.ValueType3Bytes, + valuetype TailcallVerify.ValueType5Bytes, + valuetype TailcallVerify.ValueTypeSingleInt64, + valuetype TailcallVerify.ValueType3Bytes, + valuetype TailcallVerify.ValueType5Bytes, + valuetype TailcallVerify.ValueType3Bytes) + IL_006b: ret + } // end of method Condition6::Caller5 - .method private hidebysig static uint32 - Callee5() cil managed noinlining + .method private hidebysig static void Callee5(valuetype TailcallVerify.ValueType3Bytes v1, + valuetype TailcallVerify.ValueType5Bytes v2, + valuetype TailcallVerify.ValueTypeSingleInt64 v3, + valuetype TailcallVerify.ValueType3Bytes v4, + valuetype TailcallVerify.ValueType5Bytes v5, + valuetype TailcallVerify.ValueType3Bytes v6) cil managed noinlining + { + // Code size 18 (0x12) + .maxstack 8 + IL_0000: ldarga.s v1 + IL_0002: ldc.i4.1 + IL_0003: volatile. + IL_0005: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition6::zero + IL_000a: div + IL_000b: conv.i2 + IL_000c: stfld int16 TailcallVerify.ValueType3Bytes::i2 + IL_0011: ret + } // end of method Condition6::Callee5 + + .method public hidebysig specialname rtspecialname + instance void .ctor() cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: call instance void [mscorlib]System.Object::.ctor() + IL_0006: ret + } // end of method Condition6::.ctor + + .method private hidebysig specialname rtspecialname static + void .cctor() cil managed { // Code size 16 (0x10) .maxstack 8 - IL_0000: volatile. - IL_0002: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition5::dummy - IL_0007: volatile. - IL_0009: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition5::zero - IL_000e: div + IL_0000: ldc.i4.0 + IL_0001: volatile. + IL_0003: stsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition6::zero + IL_0008: ldc.i4.s 100 + IL_000a: stsfld int32 TailcallVerify.Condition6::Result IL_000f: ret - } // end of method Condition5::Callee5 + } // end of method Condition6::.cctor - .method public hidebysig static int32 Test6() cil managed nooptimization +} // end of class TailcallVerify.Condition6 + +.class private auto ansi beforefieldinit TailcallVerify.Condition5 + extends [mscorlib]System.Object +{ + .field private static int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) dummy + .field private static int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) zero + .field private static int32 Result + .method public hidebysig static int32 Test1() cil managed nooptimization { - // Code size 154 (0x9a) + // Code size 104 (0x68) .maxstack 3 .locals init ([0] class [mscorlib]System.Exception e) - IL_0000: ldstr "Executing Condition5.Test6 - Caller: Arguments: No" - + "ne - ReturnType: Int64; Callee: Arguments: None - ReturnType: UInt64" + IL_0000: ldstr "Executing Condition5.Test1 - There is a 'conv.i2' " + + "IL instruction between the tail. call to the Callee and the ret IL instructio" + + "n which is not allowed. Expecting to catch an InvalidProgramException i" + + "nternally if tail. prefix is present." IL_0005: call void [System.Console]System.Console::WriteLine(string) IL_000a: ldc.i4.s 100 IL_000c: stsfld int32 TailcallVerify.Condition5::Result .try { - IL_0011: call int64 TailcallVerify.Condition5::Caller6() + IL_0011: call int16 TailcallVerify.Condition5::Caller1() IL_0016: pop - IL_0017: leave.s IL_0070 + IL_0017: leave.s IL_003e } // end .try catch [mscorlib]System.Exception { IL_0019: stloc.0 IL_001a: ldloc.0 - IL_001b: isinst [mscorlib]System.DivideByZeroException - IL_0020: brtrue.s IL_002b + IL_001b: isinst [mscorlib]System.InvalidProgramException + IL_0020: brtrue.s IL_002a - IL_0022: ldc.i4.s 101 - IL_0024: stsfld int32 TailcallVerify.Condition5::Result - IL_0029: rethrow - IL_002b: ldloc.0 - IL_002c: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_0031: ldstr "Caller" - IL_0036: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_003b: ldc.i4.m1 - IL_003c: beq.s IL_006e + IL_0022: ldloc.0 + IL_0023: isinst [mscorlib]System.DivideByZeroException + IL_0028: brfalse.s IL_0033 - IL_003e: ldstr "FAILED: Found the word 'Caller' in the stacktrace." - IL_0043: call void [System.Console]System.Console::WriteLine(string) - IL_0048: ldstr "------------------------------------------------" - IL_004d: call void [System.Console]System.Console::WriteLine(string) - IL_0052: call void [System.Console]System.Console::WriteLine() - IL_0057: ldloc.0 - IL_0058: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_005d: call void [System.Console]System.Console::WriteLine(string) - IL_0062: call void [System.Console]System.Console::WriteLine() - IL_0067: ldc.i4.s 101 - IL_0069: stsfld int32 TailcallVerify.Condition5::Result - IL_006e: leave.s IL_0070 + IL_002a: ldc.i4.s 100 + IL_002c: stsfld int32 TailcallVerify.Condition5::Result + IL_0031: br.s IL_003c + + IL_0033: ldc.i4.s 101 + IL_0035: stsfld int32 TailcallVerify.Condition5::Result + IL_003a: rethrow + IL_003c: leave.s IL_003e } // end handler - IL_0070: ldstr "Execution finished - Test " - IL_0075: ldsfld int32 TailcallVerify.Condition5::Result - IL_007a: ldc.i4.s 100 - IL_007c: beq.s IL_0085 + IL_003e: ldstr "Execution finished - Test " + IL_0043: ldsfld int32 TailcallVerify.Condition5::Result + IL_0048: ldc.i4.s 100 + IL_004a: beq.s IL_0053 - IL_007e: ldstr "FAILED" - IL_0083: br.s IL_008a + IL_004c: ldstr "FAILED" + IL_0051: br.s IL_0058 - IL_0085: ldstr "PASSED" - IL_008a: call string [mscorlib]System.String::Concat(string, + IL_0053: ldstr "PASSED" + IL_0058: call string [mscorlib]System.String::Concat(string, string) - IL_008f: call void [System.Console]System.Console::WriteLine(string) - IL_0094: ldsfld int32 TailcallVerify.Condition5::Result - IL_0099: ret - } // end of method Condition5::Test6 + IL_005d: call void [System.Console]System.Console::WriteLine(string) + IL_0062: ldsfld int32 TailcallVerify.Condition5::Result + IL_0067: ret + } // end of method Condition5::Test1 - .method private hidebysig static int64 - Caller6() cil managed + .method private hidebysig static int16 + Caller1() cil managed { - // Code size 52 (0x34) + // Code size 53 (0x35) .maxstack 8 IL_0000: ldc.i4.0 IL_0001: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) @@ -8364,37 +5563,39 @@ IL_0022: call void [System.Console]System.Console::WriteLine(string) IL_0027: ldc.i4.s 101 IL_0029: stsfld int32 TailcallVerify.Condition5::Result - IL_002e: tail. call uint64 TailcallVerify.Condition5::Callee6() - IL_0033: ret - } // end of method Condition5::Caller6 + IL_002e: tail. call int32 TailcallVerify.Condition5::Callee1() + IL_0033: conv.i2 + IL_0034: ret + } // end of method Condition5::Caller1 - .method private hidebysig static uint64 - Callee6() cil managed noinlining + .method private hidebysig static int32 + Callee1() cil managed noinlining { - // Code size 17 (0x11) - .maxstack 8 - IL_0000: volatile. - IL_0002: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition5::dummy - IL_0007: volatile. - IL_0009: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition5::zero - IL_000e: div - IL_000f: conv.i8 - IL_0010: ret - } // end of method Condition5::Callee6 + // Code size 12 (0xc) + .maxstack 2 + .locals init ([0] int32 i) + IL_0000: ldc.i4.1 + IL_0001: volatile. + IL_0003: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition5::zero + IL_0008: div + IL_0009: stloc.0 + IL_000a: ldloc.0 + IL_000b: ret + } // end of method Condition5::Callee1 - .method public hidebysig static int32 Test7() cil managed nooptimization + .method public hidebysig static int32 Test2() cil managed nooptimization { // Code size 154 (0x9a) .maxstack 3 .locals init ([0] class [mscorlib]System.Exception e) - IL_0000: ldstr "Executing Condition5.Test7 - Caller: Arguments: No" - + "ne - ReturnType: UInt64; Callee: Arguments: None - ReturnType: Int64" + IL_0000: ldstr "Executing Condition5.Test2 - Caller: Arguments: No" + + "ne - ReturnType: byte; Callee: Arguments: None - ReturnType: byte" IL_0005: call void [System.Console]System.Console::WriteLine(string) IL_000a: ldc.i4.s 100 IL_000c: stsfld int32 TailcallVerify.Condition5::Result .try { - IL_0011: call int64 TailcallVerify.Condition5::Caller7() + IL_0011: call uint8 TailcallVerify.Condition5::Caller2() IL_0016: pop IL_0017: leave.s IL_0070 @@ -8444,10 +5645,10 @@ IL_008f: call void [System.Console]System.Console::WriteLine(string) IL_0094: ldsfld int32 TailcallVerify.Condition5::Result IL_0099: ret - } // end of method Condition5::Test7 + } // end of method Condition5::Test2 - .method private hidebysig static int64 - Caller7() cil managed + .method private hidebysig static uint8 + Caller2() cil managed { // Code size 52 (0x34) .maxstack 8 @@ -8464,181 +5665,92 @@ IL_0022: call void [System.Console]System.Console::WriteLine(string) IL_0027: ldc.i4.s 101 IL_0029: stsfld int32 TailcallVerify.Condition5::Result - IL_002e: tail. call uint64 TailcallVerify.Condition5::Callee7() + IL_002e: tail. call uint8 TailcallVerify.Condition5::Callee2() IL_0033: ret - } // end of method Condition5::Caller7 - - .method private hidebysig static uint64 - Callee7() cil managed noinlining - { - // Code size 17 (0x11) - .maxstack 8 - IL_0000: volatile. - IL_0002: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition5::dummy - IL_0007: volatile. - IL_0009: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition5::zero - IL_000e: div - IL_000f: conv.i8 - IL_0010: ret - } // end of method Condition5::Callee7 - - .method public hidebysig static int32 Test8() cil managed nooptimization - { - // Code size 104 (0x68) - .maxstack 3 - .locals init ([0] class [mscorlib]System.Exception e) - IL_0000: ldstr "Executing Condition5.Test8 - Caller: Arguments: No" - + "ne - ReturnType: UInt64; Callee: Arguments: None - ReturnType: UInt32 -" - + " Expecting a InvalidProgramException" - IL_0005: call void [System.Console]System.Console::WriteLine(string) - IL_000a: ldc.i4.s 100 - IL_000c: stsfld int32 TailcallVerify.Condition5::Result - .try - { - IL_0011: call int64 TailcallVerify.Condition5::Caller8() - IL_0016: pop - IL_0017: leave.s IL_003e - - } // end .try - catch [mscorlib]System.Exception - { - IL_0019: stloc.0 - IL_001a: ldloc.0 - IL_001b: isinst [mscorlib]System.InvalidProgramException - IL_0020: brtrue.s IL_002a - - IL_0022: ldloc.0 - IL_0023: isinst [mscorlib]System.DivideByZeroException - IL_0028: brfalse.s IL_0033 - - IL_002a: ldc.i4.s 100 - IL_002c: stsfld int32 TailcallVerify.Condition5::Result - IL_0031: br.s IL_003c - - IL_0033: ldc.i4.s 101 - IL_0035: stsfld int32 TailcallVerify.Condition5::Result - IL_003a: rethrow - IL_003c: leave.s IL_003e - - } // end handler - IL_003e: ldstr "Execution finished - Test " - IL_0043: ldsfld int32 TailcallVerify.Condition5::Result - IL_0048: ldc.i4.s 100 - IL_004a: beq.s IL_0053 - - IL_004c: ldstr "FAILED" - IL_0051: br.s IL_0058 - - IL_0053: ldstr "PASSED" - IL_0058: call string [mscorlib]System.String::Concat(string, - string) - IL_005d: call void [System.Console]System.Console::WriteLine(string) - IL_0062: ldsfld int32 TailcallVerify.Condition5::Result - IL_0067: ret - } // end of method Condition5::Test8 - - .method private hidebysig static int64 - Caller8() cil managed - { - // Code size 57 (0x39) - .maxstack 8 - IL_0000: ldc.i4.0 - IL_0001: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) - IL_0006: callvirt instance class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Diagnostics.StackFrame::GetMethod() - IL_000b: callvirt instance string [mscorlib]System.Reflection.MemberInfo::get_Name() - IL_0010: ldstr "Caller" - IL_0015: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_001a: ldc.i4.m1 - IL_001b: bne.un.s IL_002e - - IL_001d: ldstr "Failed, Method was inlined..." - IL_0022: call void [System.Console]System.Console::WriteLine(string) - IL_0027: ldc.i4.s 101 - IL_0029: stsfld int32 TailcallVerify.Condition5::Result - IL_002e: tail. call valuetype TailcallVerify.ValueTypeSingleInt64 TailcallVerify.Condition5::Callee8() - IL_0033: ldfld int64 TailcallVerify.ValueTypeSingleInt64::i1 - IL_0038: ret - } // end of method Condition5::Caller8 + } // end of method Condition5::Caller2 - .method private hidebysig static valuetype TailcallVerify.ValueTypeSingleInt64 - Callee8() cil managed noinlining - { - // Code size 33 (0x21) - .maxstack 3 - .locals init ([0] valuetype TailcallVerify.ValueTypeSingleInt64 v) - IL_0000: ldloca.s v - IL_0002: initobj TailcallVerify.ValueTypeSingleInt64 - IL_0008: ldloca.s v - IL_000a: volatile. - IL_000c: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition5::dummy - IL_0011: volatile. - IL_0013: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition5::zero - IL_0018: div - IL_0019: conv.i8 - IL_001a: stfld int64 TailcallVerify.ValueTypeSingleInt64::i1 - IL_001f: ldloc.0 - IL_0020: ret - } // end of method Condition5::Callee8 + .method private hidebysig static uint8 + Callee2() cil managed noinlining + { + // Code size 17 (0x11) + .maxstack 8 + IL_0000: volatile. + IL_0002: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition5::dummy + IL_0007: volatile. + IL_0009: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition5::zero + IL_000e: div + IL_000f: conv.u1 + IL_0010: ret + } // end of method Condition5::Callee2 - .method public hidebysig static int32 Test9() cil managed nooptimization + .method public hidebysig static int32 Test3() cil managed nooptimization { - // Code size 104 (0x68) + // Code size 154 (0x9a) .maxstack 3 .locals init ([0] class [mscorlib]System.Exception e) - IL_0000: ldstr "Executing Condition5.Test9 - Caller: Arguments: No" - + "ne - ReturnType: UInt32; Callee: Arguments: None - ReturnType: UInt64 -" - + " Expecting a InvalidProgramException" + IL_0000: ldstr "Executing Condition5.Test3 - Caller: Arguments: No" + + "ne - ReturnType: Int32; Callee: Arguments: None - ReturnType: Int32" IL_0005: call void [System.Console]System.Console::WriteLine(string) IL_000a: ldc.i4.s 100 IL_000c: stsfld int32 TailcallVerify.Condition5::Result .try { - IL_0011: call uint32 TailcallVerify.Condition5::Caller9() + IL_0011: call int32 TailcallVerify.Condition5::Caller3() IL_0016: pop - IL_0017: leave.s IL_003e + IL_0017: leave.s IL_0070 } // end .try catch [mscorlib]System.Exception { IL_0019: stloc.0 IL_001a: ldloc.0 - IL_001b: isinst [mscorlib]System.InvalidProgramException - IL_0020: brtrue.s IL_002a - - IL_0022: ldloc.0 - IL_0023: isinst [mscorlib]System.DivideByZeroException - IL_0028: brfalse.s IL_0033 + IL_001b: isinst [mscorlib]System.DivideByZeroException + IL_0020: brtrue.s IL_002b - IL_002a: ldc.i4.s 100 - IL_002c: stsfld int32 TailcallVerify.Condition5::Result - IL_0031: br.s IL_003c + IL_0022: ldc.i4.s 101 + IL_0024: stsfld int32 TailcallVerify.Condition5::Result + IL_0029: rethrow + IL_002b: ldloc.0 + IL_002c: callvirt instance string [mscorlib]System.Exception::get_StackTrace() + IL_0031: ldstr "Caller" + IL_0036: callvirt instance int32 [mscorlib]System.String::IndexOf(string) + IL_003b: ldc.i4.m1 + IL_003c: beq.s IL_006e - IL_0033: ldc.i4.s 101 - IL_0035: stsfld int32 TailcallVerify.Condition5::Result - IL_003a: rethrow - IL_003c: leave.s IL_003e + IL_003e: ldstr "FAILED: Found the word 'Caller' in the stacktrace." + IL_0043: call void [System.Console]System.Console::WriteLine(string) + IL_0048: ldstr "------------------------------------------------" + IL_004d: call void [System.Console]System.Console::WriteLine(string) + IL_0052: call void [System.Console]System.Console::WriteLine() + IL_0057: ldloc.0 + IL_0058: callvirt instance string [mscorlib]System.Exception::get_StackTrace() + IL_005d: call void [System.Console]System.Console::WriteLine(string) + IL_0062: call void [System.Console]System.Console::WriteLine() + IL_0067: ldc.i4.s 101 + IL_0069: stsfld int32 TailcallVerify.Condition5::Result + IL_006e: leave.s IL_0070 } // end handler - IL_003e: ldstr "Execution finished - Test " - IL_0043: ldsfld int32 TailcallVerify.Condition5::Result - IL_0048: ldc.i4.s 100 - IL_004a: beq.s IL_0053 + IL_0070: ldstr "Execution finished - Test " + IL_0075: ldsfld int32 TailcallVerify.Condition5::Result + IL_007a: ldc.i4.s 100 + IL_007c: beq.s IL_0085 - IL_004c: ldstr "FAILED" - IL_0051: br.s IL_0058 + IL_007e: ldstr "FAILED" + IL_0083: br.s IL_008a - IL_0053: ldstr "PASSED" - IL_0058: call string [mscorlib]System.String::Concat(string, + IL_0085: ldstr "PASSED" + IL_008a: call string [mscorlib]System.String::Concat(string, string) - IL_005d: call void [System.Console]System.Console::WriteLine(string) - IL_0062: ldsfld int32 TailcallVerify.Condition5::Result - IL_0067: ret - } // end of method Condition5::Test9 + IL_008f: call void [System.Console]System.Console::WriteLine(string) + IL_0094: ldsfld int32 TailcallVerify.Condition5::Result + IL_0099: ret + } // end of method Condition5::Test3 - .method private hidebysig static uint32 - Caller9() cil managed + .method private hidebysig static int32 + Caller3() cil managed { - // Code size 53 (0x35) + // Code size 52 (0x34) .maxstack 8 IL_0000: ldc.i4.0 IL_0001: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) @@ -8653,72 +5765,36 @@ IL_0022: call void [System.Console]System.Console::WriteLine(string) IL_0027: ldc.i4.s 101 IL_0029: stsfld int32 TailcallVerify.Condition5::Result - IL_002e: tail. call uint64 TailcallVerify.Condition5::Callee9() - IL_0033: conv.u4 - IL_0034: ret - } // end of method Condition5::Caller9 + IL_002e: tail. call int32 TailcallVerify.Condition5::Callee3() + IL_0033: ret + } // end of method Condition5::Caller3 - .method private hidebysig static uint64 - Callee9() cil managed noinlining + .method private hidebysig static int32 + Callee3() cil managed noinlining { - // Code size 17 (0x11) + // Code size 16 (0x10) .maxstack 8 IL_0000: volatile. IL_0002: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition5::dummy IL_0007: volatile. IL_0009: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition5::zero IL_000e: div - IL_000f: conv.i8 - IL_0010: ret - } // end of method Condition5::Callee9 - - .method public hidebysig specialname rtspecialname - instance void .ctor() cil managed - { - // Code size 7 (0x7) - .maxstack 8 - IL_0000: ldarg.0 - IL_0001: call instance void [mscorlib]System.Object::.ctor() - IL_0006: ret - } // end of method Condition5::.ctor - - .method private hidebysig specialname rtspecialname static - void .cctor() cil managed - { - // Code size 24 (0x18) - .maxstack 8 - IL_0000: ldc.i4.0 - IL_0001: volatile. - IL_0003: stsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition5::dummy - IL_0008: ldc.i4.0 - IL_0009: volatile. - IL_000b: stsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition5::zero - IL_0010: ldc.i4.s 100 - IL_0012: stsfld int32 TailcallVerify.Condition5::Result - IL_0017: ret - } // end of method Condition5::.cctor - -} // end of class TailcallVerify.Condition5 + IL_000f: ret + } // end of method Condition5::Callee3 -.class private auto ansi beforefieldinit TailcallVerify.Condition4 - extends [mscorlib]System.Object -{ - .field private static int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) zero - .field public static int32 Result - .method public hidebysig static int32 Test1() cil managed nooptimization + .method public hidebysig static int32 Test4() cil managed nooptimization { // Code size 154 (0x9a) .maxstack 3 .locals init ([0] class [mscorlib]System.Exception e) - IL_0000: ldstr "Executing Condition4.Test1 - Caller: Arguments: No" - + "ne - ReturnType: 3 byte struct; Callee: Arguments: None - ReturnType: 3" - + " byte struct" + IL_0000: ldstr "Executing Condition5.Test4 - Caller: Arguments: No" + + "ne - ReturnType: UInt32; Callee: Arguments: None - ReturnType: Int32" IL_0005: call void [System.Console]System.Console::WriteLine(string) IL_000a: ldc.i4.s 100 - IL_000c: stsfld int32 TailcallVerify.Condition4::Result + IL_000c: stsfld int32 TailcallVerify.Condition5::Result .try { - IL_0011: call valuetype TailcallVerify.ValueType3Bytes TailcallVerify.Condition4::Caller1() + IL_0011: call uint32 TailcallVerify.Condition5::Caller4() IL_0016: pop IL_0017: leave.s IL_0070 @@ -8731,7 +5807,7 @@ IL_0020: brtrue.s IL_002b IL_0022: ldc.i4.s 101 - IL_0024: stsfld int32 TailcallVerify.Condition4::Result + IL_0024: stsfld int32 TailcallVerify.Condition5::Result IL_0029: rethrow IL_002b: ldloc.0 IL_002c: callvirt instance string [mscorlib]System.Exception::get_StackTrace() @@ -8750,12 +5826,12 @@ IL_005d: call void [System.Console]System.Console::WriteLine(string) IL_0062: call void [System.Console]System.Console::WriteLine() IL_0067: ldc.i4.s 101 - IL_0069: stsfld int32 TailcallVerify.Condition4::Result + IL_0069: stsfld int32 TailcallVerify.Condition5::Result IL_006e: leave.s IL_0070 } // end handler IL_0070: ldstr "Execution finished - Test " - IL_0075: ldsfld int32 TailcallVerify.Condition4::Result + IL_0075: ldsfld int32 TailcallVerify.Condition5::Result IL_007a: ldc.i4.s 100 IL_007c: beq.s IL_0085 @@ -8766,12 +5842,12 @@ IL_008a: call string [mscorlib]System.String::Concat(string, string) IL_008f: call void [System.Console]System.Console::WriteLine(string) - IL_0094: ldsfld int32 TailcallVerify.Condition4::Result + IL_0094: ldsfld int32 TailcallVerify.Condition5::Result IL_0099: ret - } // end of method Condition4::Test1 + } // end of method Condition5::Test4 - .method private hidebysig static valuetype TailcallVerify.ValueType3Bytes - Caller1() cil managed + .method private hidebysig static uint32 + Caller4() cil managed { // Code size 52 (0x34) .maxstack 8 @@ -8787,108 +5863,90 @@ IL_001d: ldstr "Failed, Method was inlined..." IL_0022: call void [System.Console]System.Console::WriteLine(string) IL_0027: ldc.i4.s 101 - IL_0029: stsfld int32 TailcallVerify.Condition4::Result - IL_002e: tail. call valuetype TailcallVerify.ValueType3Bytes TailcallVerify.Condition4::Callee1() + IL_0029: stsfld int32 TailcallVerify.Condition5::Result + IL_002e: tail. call int32 TailcallVerify.Condition5::Callee4() IL_0033: ret - } // end of method Condition4::Caller1 + } // end of method Condition5::Caller4 - .method private hidebysig static valuetype TailcallVerify.ValueType3Bytes - Callee1() cil managed noinlining + .method private hidebysig static int32 + Callee4() cil managed noinlining { - // Code size 27 (0x1b) - .maxstack 3 - .locals init ([0] valuetype TailcallVerify.ValueType3Bytes v) - IL_0000: ldloca.s v - IL_0002: initobj TailcallVerify.ValueType3Bytes - IL_0008: ldloca.s v - IL_000a: ldc.i4.1 - IL_000b: volatile. - IL_000d: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition4::zero - IL_0012: div - IL_0013: conv.i2 - IL_0014: stfld int16 TailcallVerify.ValueType3Bytes::i2 - IL_0019: ldloc.0 - IL_001a: ret - } // end of method Condition4::Callee1 + // Code size 16 (0x10) + .maxstack 8 + IL_0000: volatile. + IL_0002: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition5::dummy + IL_0007: volatile. + IL_0009: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition5::zero + IL_000e: div + IL_000f: ret + } // end of method Condition5::Callee4 - .method public hidebysig static int32 Test2() cil managed nooptimization + .method public hidebysig static int32 Test5() cil managed nooptimization { - // Code size 172 (0xac) + // Code size 154 (0x9a) .maxstack 3 - .locals init ([0] valuetype TailcallVerify.ValueType3Bytes v, - [1] class [mscorlib]System.Exception e) - IL_0000: ldstr "Executing Condition4.Test2 - Caller: Arguments: No" - + "ne - ReturnType: 3 byte struct; Callee: Arguments: None - ReturnType: 3" - + " byte struct [Verifying the field values in the return type struct]" + .locals init ([0] class [mscorlib]System.Exception e) + IL_0000: ldstr "Executing Condition5.Test5 - Caller: Arguments: No" + + "ne - ReturnType: Int32; Callee: Arguments: None - ReturnType: UInt32" IL_0005: call void [System.Console]System.Console::WriteLine(string) IL_000a: ldc.i4.s 100 - IL_000c: stsfld int32 TailcallVerify.Condition4::Result + IL_000c: stsfld int32 TailcallVerify.Condition5::Result .try { - IL_0011: call valuetype TailcallVerify.ValueType3Bytes TailcallVerify.Condition4::Caller2() - IL_0016: stloc.0 - IL_0017: ldloca.s v - IL_0019: ldfld uint8 TailcallVerify.ValueType3Bytes::i1 - IL_001e: brtrue.s IL_002e + IL_0011: call int32 TailcallVerify.Condition5::Caller5() + IL_0016: pop + IL_0017: leave.s IL_0070 - IL_0020: ldloca.s v - IL_0022: ldfld int16 TailcallVerify.ValueType3Bytes::i2 - IL_0027: ldc.i4 0x7fff - IL_002c: beq.s IL_0061 + } // end .try + catch [mscorlib]System.Exception + { + IL_0019: stloc.0 + IL_001a: ldloc.0 + IL_001b: isinst [mscorlib]System.DivideByZeroException + IL_0020: brtrue.s IL_002b - IL_002e: ldc.i4.s 101 - IL_0030: stsfld int32 TailcallVerify.Condition4::Result - IL_0035: ldstr "FAILED: The fields in the return type struct have " - + "the wrong values." - IL_003a: call void [System.Console]System.Console::WriteLine(string) - IL_003f: ldstr "v.i1: != byte.MinValue || v.i2: != short.M" - + "axValue" - call void [System.Console]System.Console::WriteLine(string) - IL_0044: ldloca.s v - IL_0046: ldfld uint8 TailcallVerify.ValueType3Bytes::i1 - IL_004b: box [mscorlib]System.Byte - callvirt instance string [mscorlib]System.Object::ToString() - call void [System.Console]System.Console::WriteLine(string) - IL_0050: ldloca.s v - IL_0052: ldfld int16 TailcallVerify.ValueType3Bytes::i2 - IL_0057: box [mscorlib]System.Int16 - callvirt instance string [mscorlib]System.Object::ToString() - IL_005c: call void [System.Console]System.Console::WriteLine(string) - IL_0061: leave.s IL_0082 + IL_0022: ldc.i4.s 101 + IL_0024: stsfld int32 TailcallVerify.Condition5::Result + IL_0029: rethrow + IL_002b: ldloc.0 + IL_002c: callvirt instance string [mscorlib]System.Exception::get_StackTrace() + IL_0031: ldstr "Caller" + IL_0036: callvirt instance int32 [mscorlib]System.String::IndexOf(string) + IL_003b: ldc.i4.m1 + IL_003c: beq.s IL_006e - } // end .try - catch [mscorlib]System.Exception - { - IL_0063: stloc.1 - IL_0064: ldc.i4.s 101 - IL_0066: stsfld int32 TailcallVerify.Condition4::Result - IL_006b: ldstr "FAILED: Unexpected exception: " - IL_0070: ldloc.1 - IL_0071: callvirt instance string [mscorlib]System.Object::ToString() - IL_0076: call string [mscorlib]System.String::Concat(string, - string) - IL_007b: call void [System.Console]System.Console::WriteLine(string) - IL_0080: leave.s IL_0082 + IL_003e: ldstr "FAILED: Found the word 'Caller' in the stacktrace." + IL_0043: call void [System.Console]System.Console::WriteLine(string) + IL_0048: ldstr "------------------------------------------------" + IL_004d: call void [System.Console]System.Console::WriteLine(string) + IL_0052: call void [System.Console]System.Console::WriteLine() + IL_0057: ldloc.0 + IL_0058: callvirt instance string [mscorlib]System.Exception::get_StackTrace() + IL_005d: call void [System.Console]System.Console::WriteLine(string) + IL_0062: call void [System.Console]System.Console::WriteLine() + IL_0067: ldc.i4.s 101 + IL_0069: stsfld int32 TailcallVerify.Condition5::Result + IL_006e: leave.s IL_0070 } // end handler - IL_0082: ldstr "Execution finished - Test " - IL_0087: ldsfld int32 TailcallVerify.Condition4::Result - IL_008c: ldc.i4.s 100 - IL_008e: beq.s IL_0097 + IL_0070: ldstr "Execution finished - Test " + IL_0075: ldsfld int32 TailcallVerify.Condition5::Result + IL_007a: ldc.i4.s 100 + IL_007c: beq.s IL_0085 - IL_0090: ldstr "FAILED" - IL_0095: br.s IL_009c + IL_007e: ldstr "FAILED" + IL_0083: br.s IL_008a - IL_0097: ldstr "PASSED" - IL_009c: call string [mscorlib]System.String::Concat(string, + IL_0085: ldstr "PASSED" + IL_008a: call string [mscorlib]System.String::Concat(string, string) - IL_00a1: call void [System.Console]System.Console::WriteLine(string) - IL_00a6: ldsfld int32 TailcallVerify.Condition4::Result - IL_00ab: ret - } // end of method Condition4::Test2 + IL_008f: call void [System.Console]System.Console::WriteLine(string) + IL_0094: ldsfld int32 TailcallVerify.Condition5::Result + IL_0099: ret + } // end of method Condition5::Test5 - .method private hidebysig static valuetype TailcallVerify.ValueType3Bytes - Caller2() cil managed + .method private hidebysig static int32 + Caller5() cil managed { // Code size 52 (0x34) .maxstack 8 @@ -8904,73 +5962,37 @@ IL_001d: ldstr "Failed, Method was inlined..." IL_0022: call void [System.Console]System.Console::WriteLine(string) IL_0027: ldc.i4.s 101 - IL_0029: stsfld int32 TailcallVerify.Condition4::Result - IL_002e: tail. call valuetype TailcallVerify.ValueType3Bytes TailcallVerify.Condition4::Callee2() + IL_0029: stsfld int32 TailcallVerify.Condition5::Result + IL_002e: tail. call uint32 TailcallVerify.Condition5::Callee5() IL_0033: ret - } // end of method Condition4::Caller2 - - .method private hidebysig static valuetype TailcallVerify.ValueType3Bytes - Callee2() cil managed noinlining - { - // Code size 30 (0x1e) - .maxstack 2 - .locals init ([0] valuetype TailcallVerify.ValueType3Bytes v) - IL_0000: ldloca.s v - IL_0002: initobj TailcallVerify.ValueType3Bytes - IL_0008: ldloca.s v - IL_000a: ldc.i4.0 - IL_000b: stfld uint8 TailcallVerify.ValueType3Bytes::i1 - IL_0010: ldloca.s v - IL_0012: ldc.i4 0x7fff - IL_0017: stfld int16 TailcallVerify.ValueType3Bytes::i2 - IL_001c: ldloc.0 - IL_001d: ret - } // end of method Condition4::Callee2 - - .method public hidebysig specialname rtspecialname - instance void .ctor() cil managed - { - // Code size 7 (0x7) - .maxstack 8 - IL_0000: ldarg.0 - IL_0001: call instance void [mscorlib]System.Object::.ctor() - IL_0006: ret - } // end of method Condition4::.ctor + } // end of method Condition5::Caller5 - .method private hidebysig specialname rtspecialname static - void .cctor() cil managed + .method private hidebysig static uint32 + Callee5() cil managed noinlining { // Code size 16 (0x10) .maxstack 8 - IL_0000: ldc.i4.0 - IL_0001: volatile. - IL_0003: stsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition4::zero - IL_0008: ldc.i4.s 100 - IL_000a: stsfld int32 TailcallVerify.Condition4::Result + IL_0000: volatile. + IL_0002: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition5::dummy + IL_0007: volatile. + IL_0009: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition5::zero + IL_000e: div IL_000f: ret - } // end of method Condition4::.cctor - -} // end of class TailcallVerify.Condition4 + } // end of method Condition5::Callee5 -.class private auto ansi beforefieldinit TailcallVerify.Condition3 - extends [mscorlib]System.Object -{ - .field private static int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) dummy - .field private static int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) zero - .field private static int32 Result - .method public hidebysig static int32 Test1() cil managed nooptimization + .method public hidebysig static int32 Test6() cil managed nooptimization { // Code size 154 (0x9a) .maxstack 3 .locals init ([0] class [mscorlib]System.Exception e) - IL_0000: ldstr "Executing Condition3.Test1 - Caller: Arguments: No" - + "ne - ReturnType: Int32; Callee: Arguments: None - ReturnType: Int32" + IL_0000: ldstr "Executing Condition5.Test6 - Caller: Arguments: No" + + "ne - ReturnType: Int64; Callee: Arguments: None - ReturnType: UInt64" IL_0005: call void [System.Console]System.Console::WriteLine(string) IL_000a: ldc.i4.s 100 - IL_000c: stsfld int32 TailcallVerify.Condition3::Result + IL_000c: stsfld int32 TailcallVerify.Condition5::Result .try { - IL_0011: call int32 TailcallVerify.Condition3::Caller1() + IL_0011: call int64 TailcallVerify.Condition5::Caller6() IL_0016: pop IL_0017: leave.s IL_0070 @@ -8983,7 +6005,7 @@ IL_0020: brtrue.s IL_002b IL_0022: ldc.i4.s 101 - IL_0024: stsfld int32 TailcallVerify.Condition3::Result + IL_0024: stsfld int32 TailcallVerify.Condition5::Result IL_0029: rethrow IL_002b: ldloc.0 IL_002c: callvirt instance string [mscorlib]System.Exception::get_StackTrace() @@ -9002,12 +6024,12 @@ IL_005d: call void [System.Console]System.Console::WriteLine(string) IL_0062: call void [System.Console]System.Console::WriteLine() IL_0067: ldc.i4.s 101 - IL_0069: stsfld int32 TailcallVerify.Condition3::Result + IL_0069: stsfld int32 TailcallVerify.Condition5::Result IL_006e: leave.s IL_0070 } // end handler IL_0070: ldstr "Execution finished - Test " - IL_0075: ldsfld int32 TailcallVerify.Condition3::Result + IL_0075: ldsfld int32 TailcallVerify.Condition5::Result IL_007a: ldc.i4.s 100 IL_007c: beq.s IL_0085 @@ -9018,12 +6040,12 @@ IL_008a: call string [mscorlib]System.String::Concat(string, string) IL_008f: call void [System.Console]System.Console::WriteLine(string) - IL_0094: ldsfld int32 TailcallVerify.Condition3::Result + IL_0094: ldsfld int32 TailcallVerify.Condition5::Result IL_0099: ret - } // end of method Condition3::Test1 + } // end of method Condition5::Test6 - .method private hidebysig static int32 - Caller1() cil managed + .method private hidebysig static int64 + Caller6() cil managed { // Code size 52 (0x34) .maxstack 8 @@ -9039,39 +6061,38 @@ IL_001d: ldstr "Failed, Method was inlined..." IL_0022: call void [System.Console]System.Console::WriteLine(string) IL_0027: ldc.i4.s 101 - IL_0029: stsfld int32 TailcallVerify.Condition3::Result - IL_002e: tail. call int32 TailcallVerify.Condition3::Callee1() + IL_0029: stsfld int32 TailcallVerify.Condition5::Result + IL_002e: tail. call uint64 TailcallVerify.Condition5::Callee6() IL_0033: ret - } // end of method Condition3::Caller1 + } // end of method Condition5::Caller6 - .method private hidebysig static int32 - Callee1() cil managed noinlining + .method private hidebysig static uint64 + Callee6() cil managed noinlining { - // Code size 12 (0xc) - .maxstack 2 - .locals init ([0] int32 i) - IL_0000: ldc.i4.1 - IL_0001: volatile. - IL_0003: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition3::zero - IL_0008: div - IL_0009: stloc.0 - IL_000a: ldloc.0 - IL_000b: ret - } // end of method Condition3::Callee1 + // Code size 17 (0x11) + .maxstack 8 + IL_0000: volatile. + IL_0002: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition5::dummy + IL_0007: volatile. + IL_0009: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition5::zero + IL_000e: div + IL_000f: conv.i8 + IL_0010: ret + } // end of method Condition5::Callee6 - .method public hidebysig static int32 Test2() cil managed nooptimization + .method public hidebysig static int32 Test7() cil managed nooptimization { // Code size 154 (0x9a) .maxstack 3 .locals init ([0] class [mscorlib]System.Exception e) - IL_0000: ldstr "Executing Condition3.Test2 - Caller: Arguments: No" - + "ne - ReturnType: void; Callee: Arguments: None - ReturnType: string" + IL_0000: ldstr "Executing Condition5.Test7 - Caller: Arguments: No" + + "ne - ReturnType: UInt64; Callee: Arguments: None - ReturnType: Int64" IL_0005: call void [System.Console]System.Console::WriteLine(string) IL_000a: ldc.i4.s 100 - IL_000c: stsfld int32 TailcallVerify.Condition3::Result + IL_000c: stsfld int32 TailcallVerify.Condition5::Result .try { - IL_0011: call string TailcallVerify.Condition3::Caller2() + IL_0011: call int64 TailcallVerify.Condition5::Caller7() IL_0016: pop IL_0017: leave.s IL_0070 @@ -9084,7 +6105,7 @@ IL_0020: brtrue.s IL_002b IL_0022: ldc.i4.s 101 - IL_0024: stsfld int32 TailcallVerify.Condition3::Result + IL_0024: stsfld int32 TailcallVerify.Condition5::Result IL_0029: rethrow IL_002b: ldloc.0 IL_002c: callvirt instance string [mscorlib]System.Exception::get_StackTrace() @@ -9103,12 +6124,12 @@ IL_005d: call void [System.Console]System.Console::WriteLine(string) IL_0062: call void [System.Console]System.Console::WriteLine() IL_0067: ldc.i4.s 101 - IL_0069: stsfld int32 TailcallVerify.Condition3::Result + IL_0069: stsfld int32 TailcallVerify.Condition5::Result IL_006e: leave.s IL_0070 } // end handler IL_0070: ldstr "Execution finished - Test " - IL_0075: ldsfld int32 TailcallVerify.Condition3::Result + IL_0075: ldsfld int32 TailcallVerify.Condition5::Result IL_007a: ldc.i4.s 100 IL_007c: beq.s IL_0085 @@ -9119,12 +6140,12 @@ IL_008a: call string [mscorlib]System.String::Concat(string, string) IL_008f: call void [System.Console]System.Console::WriteLine(string) - IL_0094: ldsfld int32 TailcallVerify.Condition3::Result + IL_0094: ldsfld int32 TailcallVerify.Condition5::Result IL_0099: ret - } // end of method Condition3::Test2 + } // end of method Condition5::Test7 - .method private hidebysig static string - Caller2() cil managed + .method private hidebysig static int64 + Caller7() cil managed { // Code size 52 (0x34) .maxstack 8 @@ -9140,128 +6161,84 @@ IL_001d: ldstr "Failed, Method was inlined..." IL_0022: call void [System.Console]System.Console::WriteLine(string) IL_0027: ldc.i4.s 101 - IL_0029: stsfld int32 TailcallVerify.Condition3::Result - IL_002e: tail. call string TailcallVerify.Condition3::Callee2() + IL_0029: stsfld int32 TailcallVerify.Condition5::Result + IL_002e: tail. call uint64 TailcallVerify.Condition5::Callee7() IL_0033: ret - } // end of method Condition3::Caller2 + } // end of method Condition5::Caller7 - .method private hidebysig static string - Callee2() cil managed noinlining + .method private hidebysig static uint64 + Callee7() cil managed noinlining { - // Code size 29 (0x1d) + // Code size 17 (0x11) .maxstack 8 IL_0000: volatile. - IL_0002: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition3::dummy + IL_0002: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition5::dummy IL_0007: volatile. - IL_0009: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition3::zero + IL_0009: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition5::zero IL_000e: div - IL_000f: conv.i2 - IL_0010: volatile. - IL_0012: stsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition3::dummy - IL_0017: ldstr "foo" - IL_001c: ret - } // end of method Condition3::Callee2 - - .method public hidebysig specialname rtspecialname - instance void .ctor() cil managed - { - // Code size 7 (0x7) - .maxstack 8 - IL_0000: ldarg.0 - IL_0001: call instance void [mscorlib]System.Object::.ctor() - IL_0006: ret - } // end of method Condition3::.ctor - - .method private hidebysig specialname rtspecialname static - void .cctor() cil managed - { - // Code size 24 (0x18) - .maxstack 8 - IL_0000: ldc.i4.0 - IL_0001: volatile. - IL_0003: stsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition3::dummy - IL_0008: ldc.i4.0 - IL_0009: volatile. - IL_000b: stsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition3::zero - IL_0010: ldc.i4.s 100 - IL_0012: stsfld int32 TailcallVerify.Condition3::Result - IL_0017: ret - } // end of method Condition3::.cctor - -} // end of class TailcallVerify.Condition3 + IL_000f: conv.i8 + IL_0010: ret + } // end of method Condition5::Callee7 -.class private auto ansi beforefieldinit TailcallVerify.Condition2 - extends [mscorlib]System.Object -{ - .field private static int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) dummy - .field private static int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) zero - .field private static int32 Result - .method public hidebysig static int32 Test1() cil managed nooptimization + .method public hidebysig static int32 Test8() cil managed nooptimization { - // Code size 153 (0x99) + // Code size 104 (0x68) .maxstack 3 .locals init ([0] class [mscorlib]System.Exception e) - IL_0000: ldstr "Executing Condition2.Test1 - Caller: Arguments: N" - + "one - ReturnType: void; Callee: Arguments: 0 - ReturnType: Int32" + IL_0000: ldstr "Executing Condition5.Test8 - Caller: Arguments: No" + + "ne - ReturnType: UInt64; Callee: Arguments: None - ReturnType: UInt32 -" + + " Expecting a InvalidProgramException" IL_0005: call void [System.Console]System.Console::WriteLine(string) IL_000a: ldc.i4.s 100 - IL_000c: stsfld int32 TailcallVerify.Condition2::Result + IL_000c: stsfld int32 TailcallVerify.Condition5::Result .try { - IL_0011: call void TailcallVerify.Condition2::Caller1() - IL_0016: leave.s IL_006f + IL_0011: call int64 TailcallVerify.Condition5::Caller8() + IL_0016: pop + IL_0017: leave.s IL_003e } // end .try catch [mscorlib]System.Exception { - IL_0018: stloc.0 - IL_0019: ldloc.0 - IL_001a: isinst [mscorlib]System.DivideByZeroException - IL_001f: brtrue.s IL_002a + IL_0019: stloc.0 + IL_001a: ldloc.0 + IL_001b: isinst [mscorlib]System.InvalidProgramException + IL_0020: brtrue.s IL_002a - IL_0021: ldc.i4.s 101 - IL_0023: stsfld int32 TailcallVerify.Condition2::Result - IL_0028: rethrow - IL_002a: ldloc.0 - IL_002b: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_0030: ldstr "Caller" - IL_0035: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_003a: ldc.i4.m1 - IL_003b: beq.s IL_006d + IL_0022: ldloc.0 + IL_0023: isinst [mscorlib]System.DivideByZeroException + IL_0028: brfalse.s IL_0033 - IL_003d: ldstr "FAILED: Found the word 'Caller' in the stacktrace." - IL_0042: call void [System.Console]System.Console::WriteLine(string) - IL_0047: ldstr "------------------------------------------------" - IL_004c: call void [System.Console]System.Console::WriteLine(string) - IL_0051: call void [System.Console]System.Console::WriteLine() - IL_0056: ldloc.0 - IL_0057: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_005c: call void [System.Console]System.Console::WriteLine(string) - IL_0061: call void [System.Console]System.Console::WriteLine() - IL_0066: ldc.i4.s 101 - IL_0068: stsfld int32 TailcallVerify.Condition2::Result - IL_006d: leave.s IL_006f + IL_002a: ldc.i4.s 100 + IL_002c: stsfld int32 TailcallVerify.Condition5::Result + IL_0031: br.s IL_003c + + IL_0033: ldc.i4.s 101 + IL_0035: stsfld int32 TailcallVerify.Condition5::Result + IL_003a: rethrow + IL_003c: leave.s IL_003e } // end handler - IL_006f: ldstr "Execution finished - Test " - IL_0074: ldsfld int32 TailcallVerify.Condition2::Result - IL_0079: ldc.i4.s 100 - IL_007b: beq.s IL_0084 + IL_003e: ldstr "Execution finished - Test " + IL_0043: ldsfld int32 TailcallVerify.Condition5::Result + IL_0048: ldc.i4.s 100 + IL_004a: beq.s IL_0053 - IL_007d: ldstr "FAILED" - IL_0082: br.s IL_0089 + IL_004c: ldstr "FAILED" + IL_0051: br.s IL_0058 - IL_0084: ldstr "PASSED" - IL_0089: call string [mscorlib]System.String::Concat(string, + IL_0053: ldstr "PASSED" + IL_0058: call string [mscorlib]System.String::Concat(string, string) - IL_008e: call void [System.Console]System.Console::WriteLine(string) - IL_0093: ldsfld int32 TailcallVerify.Condition2::Result - IL_0098: ret - } // end of method Condition2::Test1 + IL_005d: call void [System.Console]System.Console::WriteLine(string) + IL_0062: ldsfld int32 TailcallVerify.Condition5::Result + IL_0067: ret + } // end of method Condition5::Test8 - .method private hidebysig static void Caller1() cil managed + .method private hidebysig static int64 + Caller8() cil managed { - // Code size 53 (0x35) + // Code size 57 (0x39) .maxstack 8 IL_0000: ldc.i4.0 IL_0001: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) @@ -9275,94 +6252,91 @@ IL_001d: ldstr "Failed, Method was inlined..." IL_0022: call void [System.Console]System.Console::WriteLine(string) IL_0027: ldc.i4.s 101 - IL_0029: stsfld int32 TailcallVerify.Condition2::Result -// tail. // tail.call, pop, ret sequence is never valid for .NET Core (but is accepted by .NET x64) - IL_002e: call int32 TailcallVerify.Condition2::Callee1() - IL_0033: pop - IL_0034: ret - } // end of method Condition2::Caller1 + IL_0029: stsfld int32 TailcallVerify.Condition5::Result + IL_002e: tail. call valuetype TailcallVerify.ValueTypeSingleInt64 TailcallVerify.Condition5::Callee8() + IL_0033: ldfld int64 TailcallVerify.ValueTypeSingleInt64::i1 + IL_0038: ret + } // end of method Condition5::Caller8 - .method private hidebysig static int32 - Callee1() cil managed noinlining + .method private hidebysig static valuetype TailcallVerify.ValueTypeSingleInt64 + Callee8() cil managed noinlining { - // Code size 12 (0xc) - .maxstack 2 - .locals init ([0] int32 i) - IL_0000: ldc.i4.1 - IL_0001: volatile. - IL_0003: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition2::zero - IL_0008: div - IL_0009: stloc.0 - IL_000a: ldloc.0 - IL_000b: ret - } // end of method Condition2::Callee1 + // Code size 33 (0x21) + .maxstack 3 + .locals init ([0] valuetype TailcallVerify.ValueTypeSingleInt64 v) + IL_0000: ldloca.s v + IL_0002: initobj TailcallVerify.ValueTypeSingleInt64 + IL_0008: ldloca.s v + IL_000a: volatile. + IL_000c: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition5::dummy + IL_0011: volatile. + IL_0013: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition5::zero + IL_0018: div + IL_0019: conv.i8 + IL_001a: stfld int64 TailcallVerify.ValueTypeSingleInt64::i1 + IL_001f: ldloc.0 + IL_0020: ret + } // end of method Condition5::Callee8 - .method public hidebysig static int32 Test2() cil managed nooptimization + .method public hidebysig static int32 Test9() cil managed nooptimization { - // Code size 153 (0x99) + // Code size 104 (0x68) .maxstack 3 .locals init ([0] class [mscorlib]System.Exception e) - IL_0000: ldstr "Executing Condition2.Test2 - Caller: Arguments: N" - + "one - ReturnType: void; Callee: Arguments: Int32 - ReturnType: string" + IL_0000: ldstr "Executing Condition5.Test9 - Caller: Arguments: No" + + "ne - ReturnType: UInt32; Callee: Arguments: None - ReturnType: UInt64 -" + + " Expecting a InvalidProgramException" IL_0005: call void [System.Console]System.Console::WriteLine(string) IL_000a: ldc.i4.s 100 - IL_000c: stsfld int32 TailcallVerify.Condition2::Result + IL_000c: stsfld int32 TailcallVerify.Condition5::Result .try { - IL_0011: call void TailcallVerify.Condition2::Caller2() - IL_0016: leave.s IL_006f + IL_0011: call uint32 TailcallVerify.Condition5::Caller9() + IL_0016: pop + IL_0017: leave.s IL_003e } // end .try catch [mscorlib]System.Exception { - IL_0018: stloc.0 - IL_0019: ldloc.0 - IL_001a: isinst [mscorlib]System.DivideByZeroException - IL_001f: brtrue.s IL_002a + IL_0019: stloc.0 + IL_001a: ldloc.0 + IL_001b: isinst [mscorlib]System.InvalidProgramException + IL_0020: brtrue.s IL_002a - IL_0021: ldc.i4.s 101 - IL_0023: stsfld int32 TailcallVerify.Condition2::Result - IL_0028: rethrow - IL_002a: ldloc.0 - IL_002b: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_0030: ldstr "Caller" - IL_0035: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_003a: ldc.i4.m1 - IL_003b: beq.s IL_006d + IL_0022: ldloc.0 + IL_0023: isinst [mscorlib]System.DivideByZeroException + IL_0028: brfalse.s IL_0033 - IL_003d: ldstr "FAILED: Found the word 'Caller' in the stacktrace." - IL_0042: call void [System.Console]System.Console::WriteLine(string) - IL_0047: ldstr "------------------------------------------------" - IL_004c: call void [System.Console]System.Console::WriteLine(string) - IL_0051: call void [System.Console]System.Console::WriteLine() - IL_0056: ldloc.0 - IL_0057: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_005c: call void [System.Console]System.Console::WriteLine(string) - IL_0061: call void [System.Console]System.Console::WriteLine() - IL_0066: ldc.i4.s 101 - IL_0068: stsfld int32 TailcallVerify.Condition2::Result - IL_006d: leave.s IL_006f + IL_002a: ldc.i4.s 100 + IL_002c: stsfld int32 TailcallVerify.Condition5::Result + IL_0031: br.s IL_003c + + IL_0033: ldc.i4.s 101 + IL_0035: stsfld int32 TailcallVerify.Condition5::Result + IL_003a: rethrow + IL_003c: leave.s IL_003e } // end handler - IL_006f: ldstr "Execution finished - Test " - IL_0074: ldsfld int32 TailcallVerify.Condition2::Result - IL_0079: ldc.i4.s 100 - IL_007b: beq.s IL_0084 + IL_003e: ldstr "Execution finished - Test " + IL_0043: ldsfld int32 TailcallVerify.Condition5::Result + IL_0048: ldc.i4.s 100 + IL_004a: beq.s IL_0053 - IL_007d: ldstr "FAILED" - IL_0082: br.s IL_0089 + IL_004c: ldstr "FAILED" + IL_0051: br.s IL_0058 - IL_0084: ldstr "PASSED" - IL_0089: call string [mscorlib]System.String::Concat(string, + IL_0053: ldstr "PASSED" + IL_0058: call string [mscorlib]System.String::Concat(string, string) - IL_008e: call void [System.Console]System.Console::WriteLine(string) - IL_0093: ldsfld int32 TailcallVerify.Condition2::Result - IL_0098: ret - } // end of method Condition2::Test2 + IL_005d: call void [System.Console]System.Console::WriteLine(string) + IL_0062: ldsfld int32 TailcallVerify.Condition5::Result + IL_0067: ret + } // end of method Condition5::Test9 - .method private hidebysig static void Caller2() cil managed + .method private hidebysig static uint32 + Caller9() cil managed { - // Code size 54 (0x36) + // Code size 53 (0x35) .maxstack 8 IL_0000: ldc.i4.0 IL_0001: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) @@ -9376,29 +6350,25 @@ IL_001d: ldstr "Failed, Method was inlined..." IL_0022: call void [System.Console]System.Console::WriteLine(string) IL_0027: ldc.i4.s 101 - IL_0029: stsfld int32 TailcallVerify.Condition2::Result - IL_002e: ldc.i4.0 -// tail. // tail.call, pop, ret sequence is never valid for .NET Core (but is accepted by .NET x64) - IL_002f: call string TailcallVerify.Condition2::Callee2(int32) - IL_0034: pop - IL_0035: ret - } // end of method Condition2::Caller2 + IL_0029: stsfld int32 TailcallVerify.Condition5::Result + IL_002e: tail. call uint64 TailcallVerify.Condition5::Callee9() + IL_0033: conv.u4 + IL_0034: ret + } // end of method Condition5::Caller9 - .method private hidebysig static string - Callee2(int32 i) cil managed noinlining + .method private hidebysig static uint64 + Callee9() cil managed noinlining { - // Code size 23 (0x17) + // Code size 17 (0x11) .maxstack 8 - IL_0000: ldarg.0 - IL_0001: volatile. - IL_0003: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition2::zero - IL_0008: div - IL_0009: conv.i2 - IL_000a: volatile. - IL_000c: stsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition2::dummy - IL_0011: ldstr "foo" - IL_0016: ret - } // end of method Condition2::Callee2 + IL_0000: volatile. + IL_0002: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition5::dummy + IL_0007: volatile. + IL_0009: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition5::zero + IL_000e: div + IL_000f: conv.i8 + IL_0010: ret + } // end of method Condition5::Callee9 .method public hidebysig specialname rtspecialname instance void .ctor() cil managed @@ -9408,7 +6378,7 @@ IL_0000: ldarg.0 IL_0001: call instance void [mscorlib]System.Object::.ctor() IL_0006: ret - } // end of method Condition2::.ctor + } // end of method Condition5::.ctor .method private hidebysig specialname rtspecialname static void .cctor() cil managed @@ -9417,89 +6387,91 @@ .maxstack 8 IL_0000: ldc.i4.0 IL_0001: volatile. - IL_0003: stsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition2::dummy + IL_0003: stsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition5::dummy IL_0008: ldc.i4.0 IL_0009: volatile. - IL_000b: stsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition2::zero + IL_000b: stsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition5::zero IL_0010: ldc.i4.s 100 - IL_0012: stsfld int32 TailcallVerify.Condition2::Result + IL_0012: stsfld int32 TailcallVerify.Condition5::Result IL_0017: ret - } // end of method Condition2::.cctor + } // end of method Condition5::.cctor -} // end of class TailcallVerify.Condition2 +} // end of class TailcallVerify.Condition5 -.class private auto ansi beforefieldinit TailcallVerify.Condition1 +.class private auto ansi beforefieldinit TailcallVerify.Condition4 extends [mscorlib]System.Object { - .field private static int32 Result .field private static int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) zero + .field public static int32 Result .method public hidebysig static int32 Test1() cil managed nooptimization { - // Code size 153 (0x99) + // Code size 154 (0x9a) .maxstack 3 .locals init ([0] class [mscorlib]System.Exception e) - IL_0000: ldstr "Executing Condition1.Test1 - Caller: Arguments: No" - + "ne - ReturnType: void; Callee: Arguments: None - ReturnType: 3 byte str" - + "uct" + IL_0000: ldstr "Executing Condition4.Test1 - Caller: Arguments: No" + + "ne - ReturnType: 3 byte struct; Callee: Arguments: None - ReturnType: 3" + + " byte struct" IL_0005: call void [System.Console]System.Console::WriteLine(string) IL_000a: ldc.i4.s 100 - IL_000c: stsfld int32 TailcallVerify.Condition1::Result + IL_000c: stsfld int32 TailcallVerify.Condition4::Result .try { - IL_0011: call void TailcallVerify.Condition1::Caller1() - IL_0016: leave.s IL_006f + IL_0011: call valuetype TailcallVerify.ValueType3Bytes TailcallVerify.Condition4::Caller1() + IL_0016: pop + IL_0017: leave.s IL_0070 } // end .try catch [mscorlib]System.Exception { - IL_0018: stloc.0 - IL_0019: ldloc.0 - IL_001a: isinst [mscorlib]System.DivideByZeroException - IL_001f: brtrue.s IL_002a - - IL_0021: ldc.i4.s 101 - IL_0023: stsfld int32 TailcallVerify.Condition1::Result - IL_0028: rethrow - IL_002a: ldloc.0 - IL_002b: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_0030: ldstr "Caller" - IL_0035: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_003a: ldc.i4.m1 - IL_003b: beq.s IL_006d + IL_0019: stloc.0 + IL_001a: ldloc.0 + IL_001b: isinst [mscorlib]System.DivideByZeroException + IL_0020: brtrue.s IL_002b - IL_003d: ldstr "FAILED: Found the word 'Caller' in the stacktrace." - IL_0042: call void [System.Console]System.Console::WriteLine(string) - IL_0047: ldstr "------------------------------------------------" - IL_004c: call void [System.Console]System.Console::WriteLine(string) - IL_0051: call void [System.Console]System.Console::WriteLine() - IL_0056: ldloc.0 - IL_0057: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_005c: call void [System.Console]System.Console::WriteLine(string) - IL_0061: call void [System.Console]System.Console::WriteLine() - IL_0066: ldc.i4.s 101 - IL_0068: stsfld int32 TailcallVerify.Condition1::Result - IL_006d: leave.s IL_006f + IL_0022: ldc.i4.s 101 + IL_0024: stsfld int32 TailcallVerify.Condition4::Result + IL_0029: rethrow + IL_002b: ldloc.0 + IL_002c: callvirt instance string [mscorlib]System.Exception::get_StackTrace() + IL_0031: ldstr "Caller" + IL_0036: callvirt instance int32 [mscorlib]System.String::IndexOf(string) + IL_003b: ldc.i4.m1 + IL_003c: beq.s IL_006e + + IL_003e: ldstr "FAILED: Found the word 'Caller' in the stacktrace." + IL_0043: call void [System.Console]System.Console::WriteLine(string) + IL_0048: ldstr "------------------------------------------------" + IL_004d: call void [System.Console]System.Console::WriteLine(string) + IL_0052: call void [System.Console]System.Console::WriteLine() + IL_0057: ldloc.0 + IL_0058: callvirt instance string [mscorlib]System.Exception::get_StackTrace() + IL_005d: call void [System.Console]System.Console::WriteLine(string) + IL_0062: call void [System.Console]System.Console::WriteLine() + IL_0067: ldc.i4.s 101 + IL_0069: stsfld int32 TailcallVerify.Condition4::Result + IL_006e: leave.s IL_0070 } // end handler - IL_006f: ldstr "Execution finished - Test " - IL_0074: ldsfld int32 TailcallVerify.Condition1::Result - IL_0079: ldc.i4.s 100 - IL_007b: beq.s IL_0084 + IL_0070: ldstr "Execution finished - Test " + IL_0075: ldsfld int32 TailcallVerify.Condition4::Result + IL_007a: ldc.i4.s 100 + IL_007c: beq.s IL_0085 - IL_007d: ldstr "FAILED" - IL_0082: br.s IL_0089 + IL_007e: ldstr "FAILED" + IL_0083: br.s IL_008a - IL_0084: ldstr "PASSED" - IL_0089: call string [mscorlib]System.String::Concat(string, + IL_0085: ldstr "PASSED" + IL_008a: call string [mscorlib]System.String::Concat(string, string) - IL_008e: call void [System.Console]System.Console::WriteLine(string) - IL_0093: ldsfld int32 TailcallVerify.Condition1::Result - IL_0098: ret - } // end of method Condition1::Test1 + IL_008f: call void [System.Console]System.Console::WriteLine(string) + IL_0094: ldsfld int32 TailcallVerify.Condition4::Result + IL_0099: ret + } // end of method Condition4::Test1 - .method private hidebysig static void Caller1() cil managed + .method private hidebysig static valuetype TailcallVerify.ValueType3Bytes + Caller1() cil managed { - // Code size 53 (0x35) + // Code size 52 (0x34) .maxstack 8 IL_0000: ldc.i4.0 IL_0001: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) @@ -9513,99 +6485,110 @@ IL_001d: ldstr "Failed, Method was inlined..." IL_0022: call void [System.Console]System.Console::WriteLine(string) IL_0027: ldc.i4.s 101 - IL_0029: stsfld int32 TailcallVerify.Condition1::Result -// tail. // tail.call, pop, ret sequence is never valid for .NET Core (but is accepted by .NET x64) - IL_002e: call valuetype TailcallVerify.ValueType3Bytes TailcallVerify.Condition1::Callee1() - IL_0033: pop - IL_0034: ret - } // end of method Condition1::Caller1 + IL_0029: stsfld int32 TailcallVerify.Condition4::Result + IL_002e: tail. call valuetype TailcallVerify.ValueType3Bytes TailcallVerify.Condition4::Callee1() + IL_0033: ret + } // end of method Condition4::Caller1 .method private hidebysig static valuetype TailcallVerify.ValueType3Bytes Callee1() cil managed noinlining { // Code size 27 (0x1b) .maxstack 3 - .locals init ([0] valuetype TailcallVerify.ValueType3Bytes temp) - IL_0000: ldloca.s temp + .locals init ([0] valuetype TailcallVerify.ValueType3Bytes v) + IL_0000: ldloca.s v IL_0002: initobj TailcallVerify.ValueType3Bytes - IL_0008: ldloca.s temp + IL_0008: ldloca.s v IL_000a: ldc.i4.1 IL_000b: volatile. - IL_000d: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition1::zero + IL_000d: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition4::zero IL_0012: div IL_0013: conv.i2 IL_0014: stfld int16 TailcallVerify.ValueType3Bytes::i2 IL_0019: ldloc.0 IL_001a: ret - } // end of method Condition1::Callee1 + } // end of method Condition4::Callee1 .method public hidebysig static int32 Test2() cil managed nooptimization { - // Code size 153 (0x99) + // Code size 172 (0xac) .maxstack 3 - .locals init ([0] class [mscorlib]System.Exception e) - IL_0000: ldstr "Executing Condition1.Test2 - Caller: Arguments: No" - + "ne - ReturnType: void; Callee: Arguments: Int32 - ReturnType: 3 byte st" - + "ruct" + .locals init ([0] valuetype TailcallVerify.ValueType3Bytes v, + [1] class [mscorlib]System.Exception e) + IL_0000: ldstr "Executing Condition4.Test2 - Caller: Arguments: No" + + "ne - ReturnType: 3 byte struct; Callee: Arguments: None - ReturnType: 3" + + " byte struct [Verifying the field values in the return type struct]" IL_0005: call void [System.Console]System.Console::WriteLine(string) IL_000a: ldc.i4.s 100 - IL_000c: stsfld int32 TailcallVerify.Condition1::Result + IL_000c: stsfld int32 TailcallVerify.Condition4::Result .try { - IL_0011: call void TailcallVerify.Condition1::Caller2() - IL_0016: leave.s IL_006f + IL_0011: call valuetype TailcallVerify.ValueType3Bytes TailcallVerify.Condition4::Caller2() + IL_0016: stloc.0 + IL_0017: ldloca.s v + IL_0019: ldfld uint8 TailcallVerify.ValueType3Bytes::i1 + IL_001e: brtrue.s IL_002e + + IL_0020: ldloca.s v + IL_0022: ldfld int16 TailcallVerify.ValueType3Bytes::i2 + IL_0027: ldc.i4 0x7fff + IL_002c: beq.s IL_0061 + + IL_002e: ldc.i4.s 101 + IL_0030: stsfld int32 TailcallVerify.Condition4::Result + IL_0035: ldstr "FAILED: The fields in the return type struct have " + + "the wrong values." + IL_003a: call void [System.Console]System.Console::WriteLine(string) + IL_003f: ldstr "v.i1: != byte.MinValue || v.i2: != short.M" + + "axValue" + call void [System.Console]System.Console::WriteLine(string) + IL_0044: ldloca.s v + IL_0046: ldfld uint8 TailcallVerify.ValueType3Bytes::i1 + IL_004b: box [mscorlib]System.Byte + callvirt instance string [mscorlib]System.Object::ToString() + call void [System.Console]System.Console::WriteLine(string) + IL_0050: ldloca.s v + IL_0052: ldfld int16 TailcallVerify.ValueType3Bytes::i2 + IL_0057: box [mscorlib]System.Int16 + callvirt instance string [mscorlib]System.Object::ToString() + IL_005c: call void [System.Console]System.Console::WriteLine(string) + IL_0061: leave.s IL_0082 } // end .try catch [mscorlib]System.Exception { - IL_0018: stloc.0 - IL_0019: ldloc.0 - IL_001a: isinst [mscorlib]System.DivideByZeroException - IL_001f: brtrue.s IL_002a - - IL_0021: ldc.i4.s 101 - IL_0023: stsfld int32 TailcallVerify.Condition1::Result - IL_0028: rethrow - IL_002a: ldloc.0 - IL_002b: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_0030: ldstr "Caller" - IL_0035: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_003a: ldc.i4.m1 - IL_003b: beq.s IL_006d - - IL_003d: ldstr "FAILED: Found the word 'Caller' in the stacktrace." - IL_0042: call void [System.Console]System.Console::WriteLine(string) - IL_0047: ldstr "------------------------------------------------" - IL_004c: call void [System.Console]System.Console::WriteLine(string) - IL_0051: call void [System.Console]System.Console::WriteLine() - IL_0056: ldloc.0 - IL_0057: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_005c: call void [System.Console]System.Console::WriteLine(string) - IL_0061: call void [System.Console]System.Console::WriteLine() - IL_0066: ldc.i4.s 101 - IL_0068: stsfld int32 TailcallVerify.Condition1::Result - IL_006d: leave.s IL_006f + IL_0063: stloc.1 + IL_0064: ldc.i4.s 101 + IL_0066: stsfld int32 TailcallVerify.Condition4::Result + IL_006b: ldstr "FAILED: Unexpected exception: " + IL_0070: ldloc.1 + IL_0071: callvirt instance string [mscorlib]System.Object::ToString() + IL_0076: call string [mscorlib]System.String::Concat(string, + string) + IL_007b: call void [System.Console]System.Console::WriteLine(string) + IL_0080: leave.s IL_0082 } // end handler - IL_006f: ldstr "Execution finished - Test " - IL_0074: ldsfld int32 TailcallVerify.Condition1::Result - IL_0079: ldc.i4.s 100 - IL_007b: beq.s IL_0084 + IL_0082: ldstr "Execution finished - Test " + IL_0087: ldsfld int32 TailcallVerify.Condition4::Result + IL_008c: ldc.i4.s 100 + IL_008e: beq.s IL_0097 - IL_007d: ldstr "FAILED" - IL_0082: br.s IL_0089 + IL_0090: ldstr "FAILED" + IL_0095: br.s IL_009c - IL_0084: ldstr "PASSED" - IL_0089: call string [mscorlib]System.String::Concat(string, + IL_0097: ldstr "PASSED" + IL_009c: call string [mscorlib]System.String::Concat(string, string) - IL_008e: call void [System.Console]System.Console::WriteLine(string) - IL_0093: ldsfld int32 TailcallVerify.Condition1::Result - IL_0098: ret - } // end of method Condition1::Test2 + IL_00a1: call void [System.Console]System.Console::WriteLine(string) + IL_00a6: ldsfld int32 TailcallVerify.Condition4::Result + IL_00ab: ret + } // end of method Condition4::Test2 - .method private hidebysig static void Caller2() cil managed + .method private hidebysig static valuetype TailcallVerify.ValueType3Bytes + Caller2() cil managed { - // Code size 54 (0x36) + // Code size 52 (0x34) .maxstack 8 IL_0000: ldc.i4.0 IL_0001: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) @@ -9619,100 +6602,128 @@ IL_001d: ldstr "Failed, Method was inlined..." IL_0022: call void [System.Console]System.Console::WriteLine(string) IL_0027: ldc.i4.s 101 - IL_0029: stsfld int32 TailcallVerify.Condition1::Result - IL_002e: ldc.i4.0 -// tail. // tail.call, pop, ret sequence is never valid for .NET Core (but is accepted by .NET x64) - IL_002f: call valuetype TailcallVerify.ValueType3Bytes TailcallVerify.Condition1::Callee2(int32) - IL_0034: pop - IL_0035: ret - } // end of method Condition1::Caller2 + IL_0029: stsfld int32 TailcallVerify.Condition4::Result + IL_002e: tail. call valuetype TailcallVerify.ValueType3Bytes TailcallVerify.Condition4::Callee2() + IL_0033: ret + } // end of method Condition4::Caller2 .method private hidebysig static valuetype TailcallVerify.ValueType3Bytes - Callee2(int32 i) cil managed noinlining + Callee2() cil managed noinlining { - // Code size 27 (0x1b) - .maxstack 3 - .locals init ([0] valuetype TailcallVerify.ValueType3Bytes temp) - IL_0000: ldloca.s temp + // Code size 30 (0x1e) + .maxstack 2 + .locals init ([0] valuetype TailcallVerify.ValueType3Bytes v) + IL_0000: ldloca.s v IL_0002: initobj TailcallVerify.ValueType3Bytes - IL_0008: ldloca.s temp - IL_000a: ldarg.0 - IL_000b: volatile. - IL_000d: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition1::zero - IL_0012: div - IL_0013: conv.i2 - IL_0014: stfld int16 TailcallVerify.ValueType3Bytes::i2 - IL_0019: ldloc.0 - IL_001a: ret - } // end of method Condition1::Callee2 + IL_0008: ldloca.s v + IL_000a: ldc.i4.0 + IL_000b: stfld uint8 TailcallVerify.ValueType3Bytes::i1 + IL_0010: ldloca.s v + IL_0012: ldc.i4 0x7fff + IL_0017: stfld int16 TailcallVerify.ValueType3Bytes::i2 + IL_001c: ldloc.0 + IL_001d: ret + } // end of method Condition4::Callee2 - .method public hidebysig static int32 Test3() cil managed nooptimization + .method public hidebysig specialname rtspecialname + instance void .ctor() cil managed { - // Code size 153 (0x99) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: call instance void [mscorlib]System.Object::.ctor() + IL_0006: ret + } // end of method Condition4::.ctor + + .method private hidebysig specialname rtspecialname static + void .cctor() cil managed + { + // Code size 16 (0x10) + .maxstack 8 + IL_0000: ldc.i4.0 + IL_0001: volatile. + IL_0003: stsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition4::zero + IL_0008: ldc.i4.s 100 + IL_000a: stsfld int32 TailcallVerify.Condition4::Result + IL_000f: ret + } // end of method Condition4::.cctor + +} // end of class TailcallVerify.Condition4 + +.class private auto ansi beforefieldinit TailcallVerify.Condition3 + extends [mscorlib]System.Object +{ + .field private static int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) dummy + .field private static int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) zero + .field private static int32 Result + .method public hidebysig static int32 Test1() cil managed nooptimization + { + // Code size 154 (0x9a) .maxstack 3 .locals init ([0] class [mscorlib]System.Exception e) - IL_0000: ldstr "Executing Condition1.Test3 - Caller: Arguments: No" - + "ne - ReturnType: void; Callee: Arguments: 8 x int - ReturnType: 3 byte " - + "struct" + IL_0000: ldstr "Executing Condition3.Test1 - Caller: Arguments: No" + + "ne - ReturnType: Int32; Callee: Arguments: None - ReturnType: Int32" IL_0005: call void [System.Console]System.Console::WriteLine(string) IL_000a: ldc.i4.s 100 - IL_000c: stsfld int32 TailcallVerify.Condition1::Result + IL_000c: stsfld int32 TailcallVerify.Condition3::Result .try { - IL_0011: call void TailcallVerify.Condition1::Caller3() - IL_0016: leave.s IL_006f + IL_0011: call int32 TailcallVerify.Condition3::Caller1() + IL_0016: pop + IL_0017: leave.s IL_0070 } // end .try catch [mscorlib]System.Exception { - IL_0018: stloc.0 - IL_0019: ldloc.0 - IL_001a: isinst [mscorlib]System.DivideByZeroException - IL_001f: brtrue.s IL_002a - - IL_0021: ldc.i4.s 101 - IL_0023: stsfld int32 TailcallVerify.Condition1::Result - IL_0028: rethrow - IL_002a: ldloc.0 - IL_002b: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_0030: ldstr "Caller" - IL_0035: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_003a: ldc.i4.m1 - IL_003b: beq.s IL_006d + IL_0019: stloc.0 + IL_001a: ldloc.0 + IL_001b: isinst [mscorlib]System.DivideByZeroException + IL_0020: brtrue.s IL_002b - IL_003d: ldstr "FAILED: Found the word 'Caller' in the stacktrace." - IL_0042: call void [System.Console]System.Console::WriteLine(string) - IL_0047: ldstr "------------------------------------------------" - IL_004c: call void [System.Console]System.Console::WriteLine(string) - IL_0051: call void [System.Console]System.Console::WriteLine() - IL_0056: ldloc.0 - IL_0057: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_005c: call void [System.Console]System.Console::WriteLine(string) - IL_0061: call void [System.Console]System.Console::WriteLine() - IL_0066: ldc.i4.s 101 - IL_0068: stsfld int32 TailcallVerify.Condition1::Result - IL_006d: leave.s IL_006f + IL_0022: ldc.i4.s 101 + IL_0024: stsfld int32 TailcallVerify.Condition3::Result + IL_0029: rethrow + IL_002b: ldloc.0 + IL_002c: callvirt instance string [mscorlib]System.Exception::get_StackTrace() + IL_0031: ldstr "Caller" + IL_0036: callvirt instance int32 [mscorlib]System.String::IndexOf(string) + IL_003b: ldc.i4.m1 + IL_003c: beq.s IL_006e + + IL_003e: ldstr "FAILED: Found the word 'Caller' in the stacktrace." + IL_0043: call void [System.Console]System.Console::WriteLine(string) + IL_0048: ldstr "------------------------------------------------" + IL_004d: call void [System.Console]System.Console::WriteLine(string) + IL_0052: call void [System.Console]System.Console::WriteLine() + IL_0057: ldloc.0 + IL_0058: callvirt instance string [mscorlib]System.Exception::get_StackTrace() + IL_005d: call void [System.Console]System.Console::WriteLine(string) + IL_0062: call void [System.Console]System.Console::WriteLine() + IL_0067: ldc.i4.s 101 + IL_0069: stsfld int32 TailcallVerify.Condition3::Result + IL_006e: leave.s IL_0070 } // end handler - IL_006f: ldstr "Execution finished - Test " - IL_0074: ldsfld int32 TailcallVerify.Condition1::Result - IL_0079: ldc.i4.s 100 - IL_007b: beq.s IL_0084 + IL_0070: ldstr "Execution finished - Test " + IL_0075: ldsfld int32 TailcallVerify.Condition3::Result + IL_007a: ldc.i4.s 100 + IL_007c: beq.s IL_0085 - IL_007d: ldstr "FAILED" - IL_0082: br.s IL_0089 + IL_007e: ldstr "FAILED" + IL_0083: br.s IL_008a - IL_0084: ldstr "PASSED" - IL_0089: call string [mscorlib]System.String::Concat(string, + IL_0085: ldstr "PASSED" + IL_008a: call string [mscorlib]System.String::Concat(string, string) - IL_008e: call void [System.Console]System.Console::WriteLine(string) - IL_0093: ldsfld int32 TailcallVerify.Condition1::Result - IL_0098: ret - } // end of method Condition1::Test3 + IL_008f: call void [System.Console]System.Console::WriteLine(string) + IL_0094: ldsfld int32 TailcallVerify.Condition3::Result + IL_0099: ret + } // end of method Condition3::Test1 - .method private hidebysig static void Caller3() cil managed + .method private hidebysig static int32 + Caller1() cil managed { - // Code size 93 (0x5d) + // Code size 52 (0x34) .maxstack 8 IL_0000: ldc.i4.0 IL_0001: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) @@ -9726,162 +6737,95 @@ IL_001d: ldstr "Failed, Method was inlined..." IL_0022: call void [System.Console]System.Console::WriteLine(string) IL_0027: ldc.i4.s 101 - IL_0029: stsfld int32 TailcallVerify.Condition1::Result - IL_002e: ldc.i4 0x80000000 - IL_0033: ldc.i4 0x7fffffff - IL_0038: ldc.i4 0x80000000 - IL_003d: ldc.i4 0x7fffffff - IL_0042: ldc.i4 0x80000000 - IL_0047: ldc.i4 0x7fffffff - IL_004c: ldc.i4 0x80000000 - IL_0051: ldc.i4 0x7fffffff -// tail. // tail.call, pop, ret sequence is never valid for .NET Core (but is accepted by .NET x64) - IL_0056: call valuetype TailcallVerify.ValueType3Bytes TailcallVerify.Condition1::Callee3(int32, - int32, - int32, - int32, - int32, - int32, - int32, - int32) - IL_005b: pop - IL_005c: ret - } // end of method Condition1::Caller3 + IL_0029: stsfld int32 TailcallVerify.Condition3::Result + IL_002e: tail. call int32 TailcallVerify.Condition3::Callee1() + IL_0033: ret + } // end of method Condition3::Caller1 - .method private hidebysig static valuetype TailcallVerify.ValueType3Bytes - Callee3(int32 i1, - int32 i2, - int32 i3, - int32 i4, - int32 i5, - int32 i6, - int32 i7, - int32 i8) cil managed noinlining - { - // Code size 105 (0x69) + .method private hidebysig static int32 + Callee1() cil managed noinlining + { + // Code size 12 (0xc) .maxstack 2 - .locals init ([0] valuetype TailcallVerify.ValueType3Bytes temp) - IL_0000: ldloca.s temp - IL_0002: initobj TailcallVerify.ValueType3Bytes - IL_0008: ldarg.0 - IL_0009: ldc.i4 0x80000000 - IL_000e: bne.un.s IL_004c - - IL_0010: ldarg.1 - IL_0011: ldc.i4 0x7fffffff - IL_0016: bne.un.s IL_004c - - IL_0018: ldarg.2 - IL_0019: ldc.i4 0x80000000 - IL_001e: bne.un.s IL_004c - - IL_0020: ldarg.3 - IL_0021: ldc.i4 0x7fffffff - IL_0026: bne.un.s IL_004c - - IL_0028: ldarg.s i5 - IL_002a: ldc.i4 0x80000000 - IL_002f: bne.un.s IL_004c - - IL_0031: ldarg.s i6 - IL_0033: ldc.i4 0x7fffffff - IL_0038: bne.un.s IL_004c - - IL_003a: ldarg.s i7 - IL_003c: ldc.i4 0x80000000 - IL_0041: bne.un.s IL_004c - - IL_0043: ldarg.s i8 - IL_0045: ldc.i4 0x7fffffff - IL_004a: beq.s IL_005d - - IL_004c: ldstr "FAILED: Passed in arguments are invalid." - IL_0051: call void [System.Console]System.Console::WriteLine(string) - IL_0056: ldc.i4.s 101 - IL_0058: stsfld int32 TailcallVerify.Condition1::Result - IL_005d: ldc.i4.1 - IL_005e: volatile. - IL_0060: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition1::zero - IL_0065: div - IL_0066: pop - IL_0067: ldloc.0 - IL_0068: ret - } // end of method Condition1::Callee3 + .locals init ([0] int32 i) + IL_0000: ldc.i4.1 + IL_0001: volatile. + IL_0003: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition3::zero + IL_0008: div + IL_0009: stloc.0 + IL_000a: ldloc.0 + IL_000b: ret + } // end of method Condition3::Callee1 - .method public hidebysig static int32 Test4() cil managed nooptimization + .method public hidebysig static int32 Test2() cil managed nooptimization { - // Code size 153 (0x99) + // Code size 154 (0x9a) .maxstack 3 .locals init ([0] class [mscorlib]System.Exception e) - IL_0000: ldstr "Executing Condition1.Test4 - Caller: Arguments: No" - + "ne - ReturnType: void; Callee: Arguments: i32,i64,mb3,i16,u8,f64,f32,mb" - + "5 - ReturnType: 3 byte struct" + IL_0000: ldstr "Executing Condition3.Test2 - Caller: Arguments: No" + + "ne - ReturnType: void; Callee: Arguments: None - ReturnType: string" IL_0005: call void [System.Console]System.Console::WriteLine(string) IL_000a: ldc.i4.s 100 - IL_000c: stsfld int32 TailcallVerify.Condition1::Result + IL_000c: stsfld int32 TailcallVerify.Condition3::Result .try { - IL_0011: call void TailcallVerify.Condition1::Caller4() - IL_0016: leave.s IL_006f + IL_0011: call string TailcallVerify.Condition3::Caller2() + IL_0016: pop + IL_0017: leave.s IL_0070 } // end .try catch [mscorlib]System.Exception { - IL_0018: stloc.0 - IL_0019: ldloc.0 - IL_001a: isinst [mscorlib]System.DivideByZeroException - IL_001f: brtrue.s IL_002a + IL_0019: stloc.0 + IL_001a: ldloc.0 + IL_001b: isinst [mscorlib]System.DivideByZeroException + IL_0020: brtrue.s IL_002b - IL_0021: ldc.i4.s 101 - IL_0023: stsfld int32 TailcallVerify.Condition1::Result - IL_0028: rethrow - IL_002a: ldloc.0 - IL_002b: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_0030: ldstr "Caller" - IL_0035: callvirt instance int32 [mscorlib]System.String::IndexOf(string) - IL_003a: ldc.i4.m1 - IL_003b: beq.s IL_006d + IL_0022: ldc.i4.s 101 + IL_0024: stsfld int32 TailcallVerify.Condition3::Result + IL_0029: rethrow + IL_002b: ldloc.0 + IL_002c: callvirt instance string [mscorlib]System.Exception::get_StackTrace() + IL_0031: ldstr "Caller" + IL_0036: callvirt instance int32 [mscorlib]System.String::IndexOf(string) + IL_003b: ldc.i4.m1 + IL_003c: beq.s IL_006e - IL_003d: ldstr "FAILED: Found the word 'Caller' in the stacktrace." - IL_0042: call void [System.Console]System.Console::WriteLine(string) - IL_0047: ldstr "------------------------------------------------" - IL_004c: call void [System.Console]System.Console::WriteLine(string) - IL_0051: call void [System.Console]System.Console::WriteLine() - IL_0056: ldloc.0 - IL_0057: callvirt instance string [mscorlib]System.Exception::get_StackTrace() - IL_005c: call void [System.Console]System.Console::WriteLine(string) - IL_0061: call void [System.Console]System.Console::WriteLine() - IL_0066: ldc.i4.s 101 - IL_0068: stsfld int32 TailcallVerify.Condition1::Result - IL_006d: leave.s IL_006f + IL_003e: ldstr "FAILED: Found the word 'Caller' in the stacktrace." + IL_0043: call void [System.Console]System.Console::WriteLine(string) + IL_0048: ldstr "------------------------------------------------" + IL_004d: call void [System.Console]System.Console::WriteLine(string) + IL_0052: call void [System.Console]System.Console::WriteLine() + IL_0057: ldloc.0 + IL_0058: callvirt instance string [mscorlib]System.Exception::get_StackTrace() + IL_005d: call void [System.Console]System.Console::WriteLine(string) + IL_0062: call void [System.Console]System.Console::WriteLine() + IL_0067: ldc.i4.s 101 + IL_0069: stsfld int32 TailcallVerify.Condition3::Result + IL_006e: leave.s IL_0070 } // end handler - IL_006f: ldstr "Execution finished - Test " - IL_0074: ldsfld int32 TailcallVerify.Condition1::Result - IL_0079: ldc.i4.s 100 - IL_007b: beq.s IL_0084 + IL_0070: ldstr "Execution finished - Test " + IL_0075: ldsfld int32 TailcallVerify.Condition3::Result + IL_007a: ldc.i4.s 100 + IL_007c: beq.s IL_0085 - IL_007d: ldstr "FAILED" - IL_0082: br.s IL_0089 + IL_007e: ldstr "FAILED" + IL_0083: br.s IL_008a - IL_0084: ldstr "PASSED" - IL_0089: call string [mscorlib]System.String::Concat(string, + IL_0085: ldstr "PASSED" + IL_008a: call string [mscorlib]System.String::Concat(string, string) - IL_008e: call void [System.Console]System.Console::WriteLine(string) - IL_0093: ldsfld int32 TailcallVerify.Condition1::Result - IL_0098: ret - } // end of method Condition1::Test4 + IL_008f: call void [System.Console]System.Console::WriteLine(string) + IL_0094: ldsfld int32 TailcallVerify.Condition3::Result + IL_0099: ret + } // end of method Condition3::Test2 - .method private hidebysig static void Caller4() cil managed + .method private hidebysig static string + Caller2() cil managed { - // Code size 175 (0xaf) + // Code size 52 (0x34) .maxstack 8 - .locals init ([0] valuetype TailcallVerify.ValueType3Bytes v3, - [1] valuetype TailcallVerify.ValueType5Bytes v5, - [2] valuetype TailcallVerify.ValueType3Bytes '<>g__initLocal0', - [3] valuetype TailcallVerify.ValueType5Bytes '<>g__initLocal1', - [4] valuetype TailcallVerify.ValueType3Bytes CS$0$0000, - [5] valuetype TailcallVerify.ValueType5Bytes CS$0$0001) IL_0000: ldc.i4.0 IL_0001: newobj instance void [mscorlib]System.Diagnostics.StackFrame::.ctor(bool) IL_0006: callvirt instance class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Diagnostics.StackFrame::GetMethod() @@ -9894,202 +6838,27 @@ IL_001d: ldstr "Failed, Method was inlined..." IL_0022: call void [System.Console]System.Console::WriteLine(string) IL_0027: ldc.i4.s 101 - IL_0029: stsfld int32 TailcallVerify.Condition1::Result - IL_002e: ldloca.s CS$0$0000 - IL_0030: initobj TailcallVerify.ValueType3Bytes - IL_0036: ldloc.s CS$0$0000 - IL_0038: stloc.2 - IL_0039: ldloca.s '<>g__initLocal0' - IL_003b: ldc.i4.0 - IL_003c: stfld uint8 TailcallVerify.ValueType3Bytes::i1 - IL_0041: ldloca.s '<>g__initLocal0' - IL_0043: ldc.i4 0x7fff - IL_0048: stfld int16 TailcallVerify.ValueType3Bytes::i2 - IL_004d: ldloc.2 - IL_004e: stloc.0 - IL_004f: ldloca.s CS$0$0001 - IL_0051: initobj TailcallVerify.ValueType5Bytes - IL_0057: ldloc.s CS$0$0001 - IL_0059: stloc.3 - IL_005a: ldloca.s '<>g__initLocal1' - IL_005c: ldc.i4 0xff - IL_0061: stfld uint8 TailcallVerify.ValueType5Bytes::i1 - IL_0066: ldloca.s '<>g__initLocal1' - IL_0068: ldc.i4 0xffff8000 - IL_006d: stfld int16 TailcallVerify.ValueType5Bytes::i2 - IL_0072: ldloca.s '<>g__initLocal1' - IL_0074: ldc.i4 0x7fff - IL_0079: stfld int16 TailcallVerify.ValueType5Bytes::i3 - IL_007e: ldloc.3 - IL_007f: stloc.1 - IL_0080: ldc.i4 0x80000000 - IL_0085: ldc.i8 0x7fffffffffffffff - IL_008e: ldloc.0 - IL_008f: ldc.i4 0xffff8000 - IL_0094: ldc.i4 0xff - IL_0099: ldc.r8 -1.7976931348623157e+308 - IL_00a2: ldc.r4 3.4028235e+038 - IL_00a7: ldloc.1 -// tail. // tail.call, pop, ret sequence is never valid for .NET Core (but is accepted by .NET x64) - IL_00a8: call valuetype TailcallVerify.ValueType3Bytes TailcallVerify.Condition1::Callee4(int32, - int64, - valuetype TailcallVerify.ValueType3Bytes, - int16, - uint8, - float64, - float32, - valuetype TailcallVerify.ValueType5Bytes) - IL_00ad: pop - IL_00ae: ret - } // end of method Condition1::Caller4 + IL_0029: stsfld int32 TailcallVerify.Condition3::Result + IL_002e: tail. call string TailcallVerify.Condition3::Callee2() + IL_0033: ret + } // end of method Condition3::Caller2 - .method private hidebysig static valuetype TailcallVerify.ValueType3Bytes - Callee4(int32 i1, - int64 i2, - valuetype TailcallVerify.ValueType3Bytes v3, - int16 i4, - uint8 b5, - float64 d6, - float32 f7, - valuetype TailcallVerify.ValueType5Bytes v8) cil managed noinlining - { - // Code size 317 (0x13d) - .maxstack 4 - .locals init ([0] valuetype TailcallVerify.ValueType3Bytes temp, - [1] object[] CS$0$0000) - IL_0000: ldloca.s temp - IL_0002: initobj TailcallVerify.ValueType3Bytes - IL_0008: ldarg.0 - IL_0009: ldc.i4 0x80000000 - IL_000e: bne.un.s IL_0087 - - IL_0010: ldarg.1 - IL_0011: ldc.i8 0x7fffffffffffffff - IL_001a: bne.un.s IL_0087 - - IL_001c: ldarga.s v3 - IL_001e: ldfld uint8 TailcallVerify.ValueType3Bytes::i1 - IL_0023: brtrue.s IL_0087 - - IL_0025: ldarga.s v3 - IL_0027: ldfld int16 TailcallVerify.ValueType3Bytes::i2 - IL_002c: ldc.i4 0x7fff - IL_0031: bne.un.s IL_0087 - - IL_0033: ldarg.3 - IL_0034: ldc.i4 0xffff8000 - IL_0039: bne.un.s IL_0087 - - IL_003b: ldarg.s b5 - IL_003d: ldc.i4 0xff - IL_0042: bne.un.s IL_0087 - - IL_0044: ldarg.s d6 - IL_0046: ldc.r8 -1.7976931348623157e+308 - IL_004f: bne.un.s IL_0087 - - IL_0051: ldarg.s f7 - IL_0053: ldc.r4 3.4028235e+038 - IL_0058: bne.un.s IL_0087 - - IL_005a: ldarga.s v8 - IL_005c: ldfld uint8 TailcallVerify.ValueType5Bytes::i1 - IL_0061: ldc.i4 0xff - IL_0066: bne.un.s IL_0087 - - IL_0068: ldarga.s v8 - IL_006a: ldfld int16 TailcallVerify.ValueType5Bytes::i2 - IL_006f: ldc.i4 0xffff8000 - IL_0074: bne.un.s IL_0087 - - IL_0076: ldarga.s v8 - IL_0078: ldfld int16 TailcallVerify.ValueType5Bytes::i3 - IL_007d: ldc.i4 0x7fff - IL_0082: beq IL_0131 - - IL_0087: ldstr "FAILED: Passed in arguments are invalid." - IL_008c: call void [System.Console]System.Console::WriteLine(string) - IL_0091: ldstr "i1:{0} != Int32.MinValue || i2:{1} != Int64.MaxVal" - + "ue || v3.i1:{2} != byte.MinValue || v3.i2:{3} != short.MaxValue || i4:{" - + "4} != Int16.MinValue || b5:{5} != byte.MaxValue || d6:{6} != double.Min" - + "Value || f7:{7} != float.MaxValue || v8.i1:{8} != byte.MaxValue || v8.i" - + "2:{9} != short.MinValue || v8.i3:{10} != short.MaxValue" - IL_0096: ldc.i4.s 11 - IL_0098: newarr [mscorlib]System.Object - IL_009d: stloc.1 - IL_009e: ldloc.1 - IL_009f: ldc.i4.0 - IL_00a0: ldarg.0 - IL_00a1: box [mscorlib]System.Int32 - IL_00a6: stelem.ref - IL_00a7: ldloc.1 - IL_00a8: ldc.i4.1 - IL_00a9: ldarg.1 - IL_00aa: box [mscorlib]System.Int64 - IL_00af: stelem.ref - IL_00b0: ldloc.1 - IL_00b1: ldc.i4.2 - IL_00b2: ldarga.s v3 - IL_00b4: ldfld uint8 TailcallVerify.ValueType3Bytes::i1 - IL_00b9: box [mscorlib]System.Byte - IL_00be: stelem.ref - IL_00bf: ldloc.1 - IL_00c0: ldc.i4.3 - IL_00c1: ldarga.s v3 - IL_00c3: ldfld int16 TailcallVerify.ValueType3Bytes::i2 - IL_00c8: box [mscorlib]System.Int16 - IL_00cd: stelem.ref - IL_00ce: ldloc.1 - IL_00cf: ldc.i4.4 - IL_00d0: ldarg.3 - IL_00d1: box [mscorlib]System.Int16 - IL_00d6: stelem.ref - IL_00d7: ldloc.1 - IL_00d8: ldc.i4.5 - IL_00d9: ldarg.s b5 - IL_00db: box [mscorlib]System.Byte - IL_00e0: stelem.ref - IL_00e1: ldloc.1 - IL_00e2: ldc.i4.6 - IL_00e3: ldarg.s d6 - IL_00e5: box [mscorlib]System.Double - IL_00ea: stelem.ref - IL_00eb: ldloc.1 - IL_00ec: ldc.i4.7 - IL_00ed: ldarg.s f7 - IL_00ef: box [mscorlib]System.Single - IL_00f4: stelem.ref - IL_00f5: ldloc.1 - IL_00f6: ldc.i4.8 - IL_00f7: ldarga.s v8 - IL_00f9: ldfld uint8 TailcallVerify.ValueType5Bytes::i1 - IL_00fe: box [mscorlib]System.Byte - IL_0103: stelem.ref - IL_0104: ldloc.1 - IL_0105: ldc.i4.s 9 - IL_0107: ldarga.s v8 - IL_0109: ldfld int16 TailcallVerify.ValueType5Bytes::i2 - IL_010e: box [mscorlib]System.Int16 - IL_0113: stelem.ref - IL_0114: ldloc.1 - IL_0115: ldc.i4.s 10 - IL_0117: ldarga.s v8 - IL_0119: ldfld int16 TailcallVerify.ValueType5Bytes::i3 - IL_011e: box [mscorlib]System.Int16 - IL_0123: stelem.ref - IL_0124: ldloc.1 - IL_0125: call void [System.Console]System.Console::WriteLine(string, - object[]) - IL_012a: ldc.i4.s 101 - IL_012c: stsfld int32 TailcallVerify.Condition1::Result - IL_0131: ldc.i4.1 - IL_0132: volatile. - IL_0134: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition1::zero - IL_0139: div - IL_013a: pop - IL_013b: ldloc.0 - IL_013c: ret - } // end of method Condition1::Callee4 + .method private hidebysig static string + Callee2() cil managed noinlining + { + // Code size 29 (0x1d) + .maxstack 8 + IL_0000: volatile. + IL_0002: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition3::dummy + IL_0007: volatile. + IL_0009: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition3::zero + IL_000e: div + IL_000f: conv.i2 + IL_0010: volatile. + IL_0012: stsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition3::dummy + IL_0017: ldstr "foo" + IL_001c: ret + } // end of method Condition3::Callee2 .method public hidebysig specialname rtspecialname instance void .ctor() cil managed @@ -10099,22 +6868,25 @@ IL_0000: ldarg.0 IL_0001: call instance void [mscorlib]System.Object::.ctor() IL_0006: ret - } // end of method Condition1::.ctor + } // end of method Condition3::.ctor .method private hidebysig specialname rtspecialname static void .cctor() cil managed { - // Code size 16 (0x10) + // Code size 24 (0x18) .maxstack 8 - IL_0000: ldc.i4.s 100 - IL_0002: stsfld int32 TailcallVerify.Condition1::Result - IL_0007: ldc.i4.0 - IL_0008: volatile. - IL_000a: stsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition1::zero - IL_000f: ret - } // end of method Condition1::.cctor + IL_0000: ldc.i4.0 + IL_0001: volatile. + IL_0003: stsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition3::dummy + IL_0008: ldc.i4.0 + IL_0009: volatile. + IL_000b: stsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition3::zero + IL_0010: ldc.i4.s 100 + IL_0012: stsfld int32 TailcallVerify.Condition3::Result + IL_0017: ret + } // end of method Condition3::.cctor -} // end of class TailcallVerify.Condition1 +} // end of class TailcallVerify.Condition3 .class private sequential ansi sealed beforefieldinit TailcallVerify.ValueType3Bytes extends [mscorlib]System.ValueType @@ -10166,6 +6938,29 @@ } // end of class TailcallVerify.Win32Interop +.class private auto ansi beforefieldinit TailcallVerify.UnixInterop + extends [System.Runtime]System.Object +{ + .method public hidebysig static pinvokeimpl("libc" as "printf" winapi) + void Callee(string format) cil managed preservesig + { + } + .method public hidebysig static pinvokeimpl("libc" winapi) + void printf(string format) cil managed preservesig + { + } + .method public hidebysig specialname rtspecialname + instance void .ctor() cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: call instance void [System.Runtime]System.Object::.ctor() + IL_0006: ret + } // end of method TailcallVerify.UnixInterop::.ctor + +} // end of class TailcallVerify.UnixInterop + .class private auto ansi beforefieldinit TailcallVerify.Condition19 extends [mscorlib]System.Object { @@ -10261,20 +7056,29 @@ { // Code size 43 (0x2b) .maxstack 8 - IL_0000: ldc.i4.0 - IL_0001: call void TailcallVerify.Win32Interop::Sleep(int32) - IL_0006: ldstr "result: " - IL_000b: call int32 [mscorlib]System.Runtime.InteropServices.Marshal::GetLastWin32Error() - IL_0010: box [mscorlib]System.Int32 - IL_0015: call string [mscorlib]System.String::Concat(object, + IL_0000: call class [System.Runtime.Extensions]System.OperatingSystem [System.Runtime.Extensions]System.Environment::get_OSVersion() + IL_0005: callvirt instance valuetype [System.Runtime.Extensions]System.PlatformID [System.Runtime.Extensions]System.OperatingSystem::get_Platform() + IL_000a: ldc.i4.2 + IL_000b: bne.un.s IL_UNIX + + IL_000d: ldc.i4.0 + IL_000e: call void TailcallVerify.Win32Interop::Sleep(int32) + ldstr "result: " + call int32 [mscorlib]System.Runtime.InteropServices.Marshal::GetLastWin32Error() + box [mscorlib]System.Int32 + call string [mscorlib]System.String::Concat(object, object) - IL_001a: call void [System.Console]System.Console::WriteLine(string) - IL_001f: ldc.i4.1 - IL_0020: volatile. - IL_0022: ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition19::zero - IL_0027: div - IL_0028: starg.s i - IL_002a: ret + call void [System.Console]System.Console::WriteLine(string) + br.s IL_AFTER + + IL_UNIX: ldstr "Hello" + call void TailcallVerify.UnixInterop::printf(string) + IL_AFTER: ldc.i4.1 + volatile. + ldsfld int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile) TailcallVerify.Condition19::zero + div + starg.s i + ret } // end of method Condition19::Callee1 .method public hidebysig static int32 Test2() cil managed nooptimization @@ -10364,9 +7168,19 @@ IL_003d: call string [mscorlib]System.String::Concat(object, object) IL_0042: call void [System.Console]System.Console::WriteLine(string) - IL_0047: ldc.i4.0 - IL_0048: tail. call void TailcallVerify.Win32Interop::Callee(int32) - IL_004d: ret + + call class [System.Runtime.Extensions]System.OperatingSystem [System.Runtime.Extensions]System.Environment::get_OSVersion() + callvirt instance valuetype [System.Runtime.Extensions]System.PlatformID [System.Runtime.Extensions]System.OperatingSystem::get_Platform() + ldc.i4.2 + bne.un.s IL_UNIX + + ldc.i4.0 + tail. call void TailcallVerify.Win32Interop::Callee(int32) + ret + + IL_UNIX: ldstr "Hello" + tail. call void TailcallVerify.UnixInterop::Callee(string) + ret } // end of method Condition19::Caller2 .method public hidebysig specialname rtspecialname -- 2.34.1