diff options
Diffstat (limited to 'tests/src/JIT/Directed/pinvoke/pinvoke-examples.cs')
| -rw-r--r-- | tests/src/JIT/Directed/pinvoke/pinvoke-examples.cs | 223 |
1 files changed, 223 insertions, 0 deletions
diff --git a/tests/src/JIT/Directed/pinvoke/pinvoke-examples.cs b/tests/src/JIT/Directed/pinvoke/pinvoke-examples.cs new file mode 100644 index 0000000000..26080d8d71 --- /dev/null +++ b/tests/src/JIT/Directed/pinvoke/pinvoke-examples.cs @@ -0,0 +1,223 @@ +// 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. + +// Test cases showing interaction of inlining and inline pinvoke, +// along with the impact of EH. + +using System; +using System.Runtime.CompilerServices; + + +namespace PInvokeTest +{ + internal class Test + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + static int AsForceInline() + { + return Environment.ProcessorCount; + } + + static int AsNormalInline() + { + return Environment.ProcessorCount; + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static int AsNoInline() + { + return Environment.ProcessorCount; + } + + static bool FromTryCatch() + { + bool result = false; + try + { + // All pinvokes should be inline, except on x64 + result = (Environment.ProcessorCount == AsNormalInline()); + } + catch (Exception) + { + result = false; + } + return result; + } + + static bool FromTryFinally() + { + bool result = false; + bool result1 = false; + bool result2 = false; + try + { + // All pinvokes should be inline, except on x64 + result1 = (Environment.ProcessorCount == AsNormalInline()); + result2 = (Environment.ProcessorCount == AsNormalInline()); + } + finally + { + result = result1 && result2; + } + return result; + } + + static bool FromTryFinally2() + { + bool result = false; + bool result1 = false; + bool result2 = false; + + try + { + // These two pinvokes should be inline, except on x64 + result1 = (Environment.ProcessorCount == AsNormalInline()); + } + finally + { + // These two pinvokes should *not* be inline (finally) + result2 = (Environment.ProcessorCount == AsNormalInline()); + result = result1 && result2; + } + + return result; + } + + static bool FromTryFinally3() + { + bool result = false; + bool result1 = false; + bool result2 = false; + + try + { + // These two pinvokes should be inline, except on x64 + result1 = (Environment.ProcessorCount == AsNormalInline()); + } + finally + { + try + { + // These two pinvokes should *not* be inline (finally) + result2 = (Environment.ProcessorCount == AsNormalInline()); + } + catch (Exception) + { + result2 = false; + } + + result = result1 && result2; + } + + return result; + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static bool FromInline() + { + // These two pinvokes should be inline + bool result = (Environment.ProcessorCount == AsForceInline()); + return result; + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static bool FromInline2() + { + // These four pinvokes should be inline + bool result1 = (Environment.ProcessorCount == AsNormalInline()); + bool result2 = (Environment.ProcessorCount == AsForceInline()); + return result1 && result2; + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static bool FromNoInline() + { + // The only pinvoke should be inline + bool result = (Environment.ProcessorCount == AsNoInline()); + return result; + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static bool FromNoInline2() + { + // Three pinvokes should be inline + bool result1 = (Environment.ProcessorCount == AsNormalInline()); + bool result2 = (Environment.ProcessorCount == AsNoInline()); + return result1 && result2; + } + + static bool FromFilter() + { + bool result = false; + + try + { + throw new Exception("expected"); + } + // These two pinvokes should *not* be inline (filter) + // + // For the first call the jit won't inline the wrapper, so + // it just calls get_ProcessorCount. + // + // For the second call, the force inline works, and the + // subsequent inline of get_ProcessorCount exposes a call + // to the pinvoke GetProcessorCount. This pinvoke will + // not be inline. + catch (Exception) when (Environment.ProcessorCount == AsForceInline()) + { + result = true; + } + + return result; + } + + static bool FromColdCode() + { + int pc = 0; + bool result1 = false; + bool result2 = false; + + try + { + // This pinvoke should not be inline (cold) + pc = Environment.ProcessorCount; + throw new Exception("expected"); + } + catch (Exception) + { + // These two pinvokes should not be inline (catch) + // + // For the first call the jit won't inline the + // wrapper, so it just calls get_ProcessorCount. + // + // For the second call, the force inline works, and + // the subsequent inline of get_ProcessorCount exposes + // a call to the pinvoke GetProcessorCount. This + // pinvoke will not be inline. + result1 = (pc == Environment.ProcessorCount); + result2 = (pc == AsForceInline()); + } + + return result1 && result2; + } + + private static int Main() + { + bool result = true; + + result &= FromTryCatch(); + result &= FromTryFinally(); + result &= FromTryFinally2(); + result &= FromTryFinally3(); + result &= FromInline(); + result &= FromInline2(); + result &= FromNoInline(); + result &= FromNoInline2(); + result &= FromFilter(); + result &= FromColdCode(); + + return (result ? 100 : -1); + } + } +} |