diff options
Diffstat (limited to 'tests/src/JIT')
15 files changed, 1709 insertions, 307 deletions
diff --git a/tests/src/JIT/CheckProjects/CheckProjects.cs b/tests/src/JIT/CheckProjects/CheckProjects.cs index dc44d2e634..be42ab9cfe 100644 --- a/tests/src/JIT/CheckProjects/CheckProjects.cs +++ b/tests/src/JIT/CheckProjects/CheckProjects.cs @@ -52,9 +52,9 @@ internal class ScanProjectFiles if (binIndex < 0) { - Console.WriteLine("CORE_ROOT must be set to full path to repo test dir; was '{0}'.", - coreRoot); - return -1; + Console.WriteLine("No bin directory found in CORE_ROOT path `{0}`," + + " so no checking will be performed.", coreRoot); + return 100; } string repoRoot = coreRoot.Substring(0, binIndex); @@ -78,8 +78,8 @@ internal class ScanProjectFiles if (!Directory.Exists(projectRoot)) { - Console.WriteLine("Project directory does not exist"); - return -1; + Console.WriteLine("Project directory does not exist, so no checking will be performed."); + return 100; } DirectoryInfo projectRootDir = new DirectoryInfo(projectRoot); diff --git a/tests/src/JIT/Directed/pinvoke/calli_excep.il b/tests/src/JIT/Directed/pinvoke/calli_excep.il index 157643f70c..87683448a6 100644 --- a/tests/src/JIT/Directed/pinvoke/calli_excep.il +++ b/tests/src/JIT/Directed/pinvoke/calli_excep.il @@ -33,7 +33,7 @@ int32 V_1) .try { - ldc.i4 0xc0000005 + ldc.i4 0xC0000017 ldc.i4.0 dup dup @@ -44,7 +44,7 @@ calli void (unsigned int32, unsigned int32, unsigned int32, native uint) leave.s IL_001d } // end .try - catch [mscorlib]System.AccessViolationException + catch [mscorlib]System.OutOfMemoryException { IL_000f: stloc.0 IL_0010: ldloc.0 diff --git a/tests/src/JIT/Performance/CodeQuality/Span/Indexer.cs b/tests/src/JIT/Performance/CodeQuality/Span/Indexer.cs new file mode 100644 index 0000000000..4a7264ba92 --- /dev/null +++ b/tests/src/JIT/Performance/CodeQuality/Span/Indexer.cs @@ -0,0 +1,1021 @@ +// 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. + +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Linq; +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Text; +using Xunit; +using Microsoft.Xunit.Performance; + +[assembly: OptimizeForBenchmarks] +[assembly: MeasureInstructionsRetired] + +namespace Span +{ + class Sink + { + [MethodImpl(MethodImplOptions.NoInlining)] + public static Sink NewSink() { return new Sink(); } + + public byte b; + public int i; + } + + [AttributeUsage(AttributeTargets.Method, Inherited = false)] + class CategoryAttribute : Attribute + { + public CategoryAttribute(string name) + { + _name = name; + } + string _name; + public string Name => _name; + } + + public class IndexerBench + { + const int Iterations = 1000000; + const int DefaultLength = 1024; + const byte Expected = 70; + static bool HasFailure = false; + + [Benchmark(InnerIterationCount = Iterations)] + [InlineData(DefaultLength)] + [Category("Indexer in-loop bounds check elimination")] + public static void Ref(int length) + { + byte[] a = GetData(length); + + Invoke((int innerIterationCount) => + { + Span<byte> s = new Span<byte>(a); + byte result = 0; + for (int i = 0; i < innerIterationCount; ++i) + { + result = TestRef(s); + } + return result; + }, + "Ref({0})", length); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static byte TestRef(Span<byte> data) + { + ref byte p = ref data.DangerousGetPinnableReference(); + int length = data.Length; + byte x = 0; + + for (var idx = 0; idx < length; idx++) + { + x ^= Unsafe.Add(ref p, idx); + } + + return x; + } + + [Benchmark(InnerIterationCount = Iterations)] + [InlineData(DefaultLength)] + [Category("Indexer in-loop bounds check elimination")] + public static void Fixed1(int length) + { + byte[] a = GetData(length); + + Invoke((int innerIterationCount) => + { + Span<byte> s = new Span<byte>(a); + byte result = 0; + for (int i = 0; i < innerIterationCount; ++i) + { + result = TestFixed1(s); + } + return result; + }, + "Fixed1({0})", length); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static unsafe byte TestFixed1(Span<byte> data) + { + fixed (byte* pData = &data.DangerousGetPinnableReference()) + { + int length = data.Length; + byte x = 0; + byte* p = pData; + + for (var idx = 0; idx < length; idx++) + { + x ^= *(p + idx); + } + + return x; + } + } + + [Benchmark(InnerIterationCount = Iterations)] + [InlineData(DefaultLength)] + [Category("Indexer in-loop bounds check elimination")] + public static void Fixed2(int length) + { + byte[] a = GetData(length); + + Invoke((int innerIterationCount) => + { + Span<byte> s = new Span<byte>(a); + byte result = 0; + for (int i = 0; i < innerIterationCount; ++i) + { + result = TestFixed2(s); + } + return result; + }, + "Fixed2({0})", length); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static unsafe byte TestFixed2(Span<byte> data) + { + fixed (byte* pData = &data.DangerousGetPinnableReference()) + { + int length = data.Length; + byte x = 0; + + for (var idx = 0; idx < length; idx++) + { + x ^= pData[idx]; + } + + return x; + } + } + + [Benchmark(InnerIterationCount = Iterations)] + [InlineData(DefaultLength)] + [Category("Indexer in-loop bounds check elimination")] + public static void Indexer1(int length) + { + byte[] a = GetData(length); + + Invoke((int innerIterationCount) => + { + Span<byte> s = new Span<byte>(a); + byte result = 0; + for (int i = 0; i < innerIterationCount; ++i) + { + result = TestIndexer1(s); + } + return result; + }, + "Indexer1({0})", length); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static byte TestIndexer1(Span<byte> data) + { + int length = data.Length; + byte x = 0; + + for (var idx = 0; idx < length; idx++) + { + x ^= data[idx]; + } + + return x; + } + + [Benchmark(InnerIterationCount = Iterations)] + [InlineData(DefaultLength)] + [Category("Indexer in-loop bounds check elimination")] + public static void Indexer2(int length) + { + byte[] a = GetData(length); + + Invoke((int innerIterationCount) => + { + Span<byte> s = new Span<byte>(a); + byte result = 0; + for (int i = 0; i < innerIterationCount; ++i) + { + result = TestIndexer2(s); + } + return result; + }, + "Indexer2({0})", length); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static byte TestIndexer2(Span<byte> data) + { + byte x = 0; + + for (var idx = 0; idx < data.Length; idx++) + { + x ^= data[idx]; + } + + return x; + } + + [Benchmark(InnerIterationCount = Iterations)] + [InlineData(DefaultLength)] + [Category("Indexer in-loop bounds check elimination")] + public static void Indexer3(int length) + { + byte[] a = GetData(length); + + Invoke((int innerIterationCount) => + { + Span<byte> s = new Span<byte>(a); + byte result = 0; + for (int i = 0; i < innerIterationCount; ++i) + { + result = TestIndexer3(s); + } + return result; + }, + "Indexer3({0})", length); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static byte TestIndexer3(Span<byte> data) + { + Span<byte> data2 = data; + + byte x = 0; + + for (var idx = 0; idx < data2.Length; idx++) + { + x ^= data2[idx]; + } + + return x; + } + + [Benchmark(InnerIterationCount=Iterations / 10)] + [InlineData(DefaultLength)] + [Category("Indexer in-loop bounds check elimination")] + public static void Indexer4(int length) + { + byte[] a = GetData(length); + + Invoke((int innerIterationCount) => + { + Span<byte> s = new Span<byte>(a); + byte result = 0; + int inner = Math.Max(1, (innerIterationCount / 10)); + for (int i = 0; i < inner ; ++i) + { + result = TestIndexer4(s, 10); + } + return result; + }, + "Indexer4({0})", length); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static byte TestIndexer4(Span<byte> data, int iterations) + { + byte x = 0; + int length = data.Length; + + // This does more or less the same work as TestIndexer1 + // but is expressed as a loop nest. + for (int i = 0; i < iterations; i++) + { + x = 0; + + for (var idx = 0; idx < length; idx++) + { + x ^= data[idx]; + } + } + + return x; + } + + [Benchmark(InnerIterationCount = Iterations)] + [InlineData(DefaultLength)] + [Category("Indexer in-loop bounds check elimination")] + public static void Indexer5(int length) + { + byte[] a = GetData(length); + int z = 0; + + Invoke((int innerIterationCount) => + { + Span<byte> s = new Span<byte>(a); + byte result = 0; + for (int i = 0; i < innerIterationCount; ++i) + { + result = TestIndexer5(s, out z); + } + return result; + }, + "Indexer5({0})", length); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static byte TestIndexer5(Span<byte> data, out int z) + { + byte x = 0; + z = -1; + + // Write to z here should not be able to modify + // the span. + for (var idx = 0; idx < data.Length; idx++) + { + x ^= data[idx]; + z = idx; + } + + return x; + } + + [Benchmark(InnerIterationCount = Iterations)] + [InlineData(DefaultLength)] + [Category("Indexer in-loop bounds check elimination")] + public static void Indexer6(int length) + { + byte[] a = GetData(length); + + Invoke((int innerIterationCount) => + { + Span<byte> s = new Span<byte>(a); + byte result = 0; + for (int i = 0; i < innerIterationCount; ++i) + { + result = TestIndexer6(s); + } + return result; + }, + "Indexer6({0})", length); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static byte TestIndexer6(Span<byte> data) + { + byte x = 0; + Sink s = Sink.NewSink(); + + // Write to s.i here should not be able to modify + // the span. + for (var idx = 0; idx < data.Length; idx++) + { + x ^= data[idx]; + s.i = 0; + } + + return x; + } + + [Benchmark(InnerIterationCount = Iterations)] + [InlineData(DefaultLength)] + [Category("Indexer in-loop bounds check elimination")] + public static void ReadOnlyIndexer1(int length) + { + byte[] a = GetData(length); + + Invoke((int innerIterationCount) => + { + ReadOnlySpan<byte> s = new ReadOnlySpan<byte>(a); + byte result = 0; + for (int i = 0; i < innerIterationCount; ++i) + { + result = TestReadOnlyIndexer1(s); + } + return result; + }, + "ReadOnlyIndexer1({0})", length); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static byte TestReadOnlyIndexer1(ReadOnlySpan<byte> data) + { + int length = data.Length; + byte x = 0; + + for (var idx = 0; idx < length; idx++) + { + x ^= data[idx]; + } + + return x; + } + + [Benchmark(InnerIterationCount = Iterations)] + [InlineData(DefaultLength)] + [Category("Indexer in-loop bounds check elimination")] + public static void ReadOnlyIndexer2(int length) + { + byte[] a = GetData(length); + + Invoke((int innerIterationCount) => + { + ReadOnlySpan<byte> s = new ReadOnlySpan<byte>(a); + byte result = 0; + for (int i = 0; i < innerIterationCount; ++i) + { + result = TestReadOnlyIndexer2(s); + } + return result; + }, + "ReadOnlyIndexer2({0})", length); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static byte TestReadOnlyIndexer2(ReadOnlySpan<byte> data) + { + byte x = 0; + + for (var idx = 0; idx < data.Length; idx++) + { + x ^= data[idx]; + } + + return x; + } + + [Benchmark(InnerIterationCount = Iterations)] + [InlineData(DefaultLength)] + [Category("Indexer in-loop bounds check elimination w/ writes")] + public static void WriteViaIndexer1(int length) + { + byte[] a = GetData(length); + + Invoke((int innerIterationCount) => + { + Span<byte> s = new Span<byte>(a); + byte result = 0; + for (int i = 0; i < innerIterationCount; ++i) + { + result = TestWriteViaIndexer1(s); + } + return result; + }, + "WriteViaIndexer1({0})", length); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static byte TestWriteViaIndexer1(Span<byte> data) + { + byte q = data[0]; + + for (var idx = 1; idx < data.Length; idx++) + { + data[0] ^= data[idx]; + } + + byte x = data[0]; + data[0] = q; + + return x; + } + + [Benchmark(InnerIterationCount = Iterations)] + [InlineData(DefaultLength)] + [Category("Indexer in-loop bounds check elimination w/ writes")] + public static void WriteViaIndexer2(int length) + { + byte[] a = GetData(length); + + Invoke((int innerIterationCount) => + { + Span<byte> s = new Span<byte>(a); + byte result = 0; + for (int i = 0; i < innerIterationCount; ++i) + { + result = TestWriteViaIndexer2(s, 0, length); + } + return result; + }, + "WriteViaIndexer2({0})", length); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static byte TestWriteViaIndexer2(Span<byte> data, int start, int end) + { + byte x = 0; + + for (var idx = start; idx < end; idx++) + { + // Bounds checks are redundant + byte b = data[idx]; + x ^= b; + data[idx] = b; + } + + return x; + } + + [Benchmark(InnerIterationCount = Iterations)] + [InlineData(DefaultLength)] + [Category("Span known size bounds check elimination")] + public static void KnownSizeArray(int length) + { + if (length != 1024) + { + throw new Exception("test requires 1024 byte length"); + } + + Invoke((int innerIterationCount) => + { + byte result = TestKnownSizeArray(innerIterationCount); + return result; + }, + "KnownSizeArray({0})", length); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static byte TestKnownSizeArray(int innerIterationCount) + { + byte[] a = new byte[1024]; + SetData(a); + Span<byte> data = new Span<byte>(a); + byte x = 0; + + for (int i = 0; i < innerIterationCount; i++) + { + x = 0; + for (var idx = 0; idx < data.Length; idx++) + { + x ^= data[idx]; + } + } + + return x; + } + + [Benchmark(InnerIterationCount = Iterations)] + [InlineData(DefaultLength)] + [Category("Span known size bounds check elimination")] + public static void KnownSizeCtor(int length) + { + if (length < 1024) + { + throw new Exception("test requires at least 1024 byte length"); + } + + byte[] a = GetData(length); + + Invoke((int innerIterationCount) => + { + byte result = TestKnownSizeCtor(a, innerIterationCount); + return result; + }, + "KnownSizeCtor({0})", length); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static byte TestKnownSizeCtor(byte[] a, int innerIterationCount) + { + Span<byte> data = new Span<byte>(a, 0, 1024); + byte x = 0; + + for (int i = 0; i < innerIterationCount; i++) + { + x = 0; + for (var idx = 0; idx < data.Length; idx++) + { + x ^= data[idx]; + } + } + + return x; + } + + [Benchmark(InnerIterationCount = Iterations)] + [InlineData(DefaultLength)] + [Category("Span known size bounds check elimination")] + public static void KnownSizeCtor2(int length) + { + if (length < 1024) + { + throw new Exception("test requires at least 1024 byte length"); + } + + byte[] a = GetData(length); + + Invoke((int innerIterationCount) => + { + byte result = TestKnownSizeCtor2(a, innerIterationCount); + return result; + }, + "KnownSizeCtor2({0})", length); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static byte TestKnownSizeCtor2(byte[] a, int innerIterationCount) + { + Span<byte> data1 = new Span<byte>(a, 0, 512); + Span<byte> data2 = new Span<byte>(a, 512, 512); + byte x = 0; + + for (int i = 0; i < innerIterationCount; i++) + { + x = 0; + for (var idx = 0; idx < data1.Length; idx++) + { + x ^= data1[idx]; + } + for (var idx = 0; idx < data2.Length; idx++) + { + x ^= data2[idx]; + } + } + + return x; + } + + [Benchmark(InnerIterationCount = Iterations)] + [InlineData(DefaultLength)] + [Category("Same index in-loop redundant bounds check elimination")] + public static void SameIndex1(int length) + { + byte[] a = GetData(length); + + Invoke((int innerIterationCount) => + { + Span<byte> s = new Span<byte>(a); + byte result = 0; + for (int i = 0; i < innerIterationCount; ++i) + { + result = TestSameIndex1(s, 0, length); + } + return result; + }, + "SameIndex1({0})", length); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static byte TestSameIndex1(Span<byte> data, int start, int end) + { + byte x = 0; + byte y = 0; + + for (var idx = start; idx < end; idx++) + { + x ^= data[idx]; + y ^= data[idx]; + } + + byte t = (byte)(y ^ x ^ y); + + return t; + } + + [Benchmark(InnerIterationCount = Iterations)] + [InlineData(DefaultLength)] + [Category("Same index in-loop redundant bounds check elimination")] + public static void SameIndex2(int length) + { + byte[] a = GetData(length); + + Invoke((int innerIterationCount) => + { + Span<byte> s = new Span<byte>(a); + byte result = 0; + for (int i = 0; i < innerIterationCount; ++i) + { + result = TestSameIndex2(s, ref s[0], 0, length); + } + return result; + }, + "SameIndex2({0})", length); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static byte TestSameIndex2(Span<byte> data, ref byte b, int start, int end) + { + byte x = 0; + byte y = 0; + byte ye = 121; + byte q = data[0]; + + for (var idx = start; idx < end; idx++) + { + // Bounds check is redundant, but values are not CSEs. + x ^= data[idx]; + b = 1; + y ^= data[idx]; + } + + byte t = (byte)(y ^ x ^ ye); + data[0] = q; + + return t; + } + + [Benchmark(InnerIterationCount = Iterations)] + [InlineData(DefaultLength)] + [Category("Covered index in-loop redundant bounds check elimination")] + public static void CoveredIndex1(int length) + { + if (length < 100) + { + throw new Exception("test requires at least 100 byte length"); + } + + byte[] a = GetData(length); + + Invoke((int innerIterationCount) => + { + Span<byte> s = new Span<byte>(a); + byte result = 0; + for (int i = 0; i < innerIterationCount; ++i) + { + result = TestCoveredIndex1(s, 0, length); + } + return result; + }, + "CoveredIndex1({0})", length); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static byte TestCoveredIndex1(Span<byte> data, int start, int end) + { + byte x = 0; + byte y = 0; + + for (var idx = start; idx < end - 100; idx++) + { + x ^= data[idx + 100]; + y ^= data[idx]; + } + + for (var idx = end - 100; idx < end; idx++) + { + y ^= data[idx]; + x ^= data[idx - 100]; + } + + byte r = (byte)(x ^ y ^ x); + + return r; + } + + [Benchmark(InnerIterationCount = Iterations)] + [InlineData(DefaultLength)] + [Category("Covered index in-loop redundant bounds check elimination")] + public static void CoveredIndex2(int length) + { + byte[] a = GetData(length); + + Invoke((int innerIterationCount) => + { + Span<byte> s = new Span<byte>(a); + byte result = 0; + for (int i = 0; i < innerIterationCount; ++i) + { + result = TestCoveredIndex2(s, 0, length); + } + return result; + }, + "CoveredIndex2({0})", length); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static byte TestCoveredIndex2(Span<byte> data, int start, int end) + { + byte x = 0; + byte y = 0; + + for (var idx = start; idx < end; idx++) + { + x ^= data[idx]; + + if (idx != 100) + { + // Should be able to eliminate this bounds check + y ^= data[0]; + } + } + + byte r = (byte)(y ^ x ^ y); + + return r; + } + + [Benchmark(InnerIterationCount = Iterations)] + [InlineData(DefaultLength)] + [Category("Covered index in-loop redundant bounds check elimination")] + public static void CoveredIndex3(int length) + { + if (length < 50) + { + throw new Exception("test requires at least 100 byte length"); + } + + byte[] a = GetData(length); + + Invoke((int innerIterationCount) => + { + Span<byte> s = new Span<byte>(a); + byte result = 0; + for (int i = 0; i < innerIterationCount; ++i) + { + result = TestCoveredIndex3(s, 0, length); + } + return result; + }, + "CoveredIndex3({0})", length); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static byte TestCoveredIndex3(Span<byte> data, int start, int end) + { + byte x = 0; + byte y = 0; + byte z = 0; + + for (var idx = start; idx < end; idx++) + { + x ^= data[idx]; + + if (idx != 100) + { + y ^= data[50]; + // Should be able to eliminate this bounds check + z ^= data[25]; + } + } + + byte r = (byte)(z ^ y ^ x ^ y ^ z); + + return r; + } + + // Invoke routine to abstract away the difference between running under xunit-perf vs running from the + // command line. Inner loop to be measured is taken as an Func<int, byte>, and invoked passing the number + // of iterations that the inner loop should execute. + static void Invoke(Func<int, byte> innerLoop, string nameFormat, params object[] nameArgs) + { + if (IsXunitInvocation) + { + foreach (var iteration in Benchmark.Iterations) + using (iteration.StartMeasurement()) + innerLoop((int)Benchmark.InnerIterationCount); + } + else + { + if (DoWarmUp) + { + // Run some warm-up iterations before measuring + innerLoop(CommandLineInnerIterationCount); + // Clear the flag since we're now warmed up (caller will + // reset it before calling new code) + DoWarmUp = false; + } + + // Now do the timed run of the inner loop. + Stopwatch sw = Stopwatch.StartNew(); + byte check = innerLoop(CommandLineInnerIterationCount); + sw.Stop(); + + // Print result. + string name = String.Format(nameFormat, nameArgs); + double timeInMs = sw.Elapsed.TotalMilliseconds; + Console.Write("{0,25}: {1,7:F2}ms", name, timeInMs); + + bool failed = (check != Expected); + if (failed) + { + Console.Write(" -- failed to validate, got {0} expected {1}", check, Expected); + HasFailure = true; + } + Console.WriteLine(); + } + } + + static byte[] GetData(int size) + { + byte[] data = new byte[size]; + SetData(data); + return data; + } + + static void SetData(byte[] data) + { + Random Rnd = new Random(42); + Rnd.NextBytes(data); + } + + static bool IsXunitInvocation = true; + static int CommandLineInnerIterationCount = 1; + static bool DoWarmUp; + + public static void Usage() + { + Console.WriteLine(" pass -bench for benchmark mode w/default iterations"); + Console.WriteLine(" pass [#iterations] for benchmark mode w/iterations"); + Console.WriteLine(); + } + + public static int Main(string[] args) + { + if (args.Length > 0) + { + if (args[0].Equals("-bench")) + { + CommandLineInnerIterationCount = Iterations; + } + else + { + bool parsed = Int32.TryParse(args[0], out CommandLineInnerIterationCount); + if (!parsed) + { + Usage(); + return -1; + } + } + + Console.WriteLine("Running as command line perf test: {0} iterations", + CommandLineInnerIterationCount); + Console.WriteLine(); + } + else + { + Console.WriteLine("Running as correctness test: {0} iterations", + CommandLineInnerIterationCount); + Usage(); + } + + // When we call into Invoke, it'll need to know this isn't xunit-perf running + IsXunitInvocation = false; + + // Discover what tests to run via reflection + TypeInfo t = typeof(IndexerBench).GetTypeInfo(); + + var testsByCategory = new Dictionary<string, List<MethodInfo>>(); + + // Do a first pass to find out what categories of benchmarks we have. + foreach(MethodInfo m in t.DeclaredMethods) + { + BenchmarkAttribute benchAttr = m.GetCustomAttribute<BenchmarkAttribute>(); + if (benchAttr != null) + { + string category = "none"; + CategoryAttribute categoryAttr = m.GetCustomAttribute<CategoryAttribute>(); + if (categoryAttr != null) + { + category = categoryAttr.Name; + } + + List<MethodInfo> tests = null; + + if (!testsByCategory.ContainsKey(category)) + { + tests = new List<MethodInfo>(); + testsByCategory.Add(category, tests); + } + else + { + tests = testsByCategory[category]; + } + + tests.Add(m); + } + } + + foreach(string categoryName in testsByCategory.Keys) + { + Console.WriteLine("**** {0} ****", categoryName); + + foreach(MethodInfo m in testsByCategory[categoryName]) + { + // Request a warm-up iteration before measuring this benchmark method. + DoWarmUp = true; + + // Get the benchmark to measure as a delegate taking the number of inner-loop iterations to run + var invokeMethod = m.CreateDelegate(typeof(Action<int>)) as Action<int>; + + // All the benchmarks methods in this test use [InlineData] to specify how many times and with + // what arguments they should be run. + foreach (InlineDataAttribute dataAttr in m.GetCustomAttributes<InlineDataAttribute>()) + { + foreach (object[] data in dataAttr.GetData(m)) + { + // All the benchmark methods in this test take a single int parameter + invokeMethod((int)data[0]); + } + } + } + + Console.WriteLine(); + } + + if (HasFailure) + { + Console.WriteLine("Some tests failed validation"); + return -1; + } + + return 100; + } + } +} diff --git a/tests/src/JIT/Performance/CodeQuality/Span/Indexer.csproj b/tests/src/JIT/Performance/CodeQuality/Span/Indexer.csproj new file mode 100644 index 0000000000..a871713d1d --- /dev/null +++ b/tests/src/JIT/Performance/CodeQuality/Span/Indexer.csproj @@ -0,0 +1,44 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <!-- Always use latest Roslyn compiler --> + <Import Project="..\..\..\..\..\..\Tools\net46\roslyn\build\Microsoft.Net.Compilers.props"/> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" /> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid> + <OutputType>Exe</OutputType> + <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids> + <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> + <NuGetTargetMoniker>.NETStandard,Version=v1.4</NuGetTargetMoniker> + </PropertyGroup> + <!-- Default configurations to help VS understand the configurations --> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + </PropertyGroup> + <PropertyGroup> + <DebugType>pdbonly</DebugType> + <Optimize>true</Optimize> + <AllowUnsafeBlocks>true</AllowUnsafeBlocks> + </PropertyGroup> + <ItemGroup> + <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies"> + <Visible>False</Visible> + </CodeAnalysisDependentAssemblyPaths> + </ItemGroup> + <ItemGroup> + <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" /> + </ItemGroup> + <ItemGroup> + <Compile Include="Indexer.cs" /> + </ItemGroup> + <PropertyGroup> + <ProjectJson>$(JitPackagesConfigFileDirectory)benchmark\project.json</ProjectJson> + <ProjectLockJson>$(JitPackagesConfigFileDirectory)benchmark\project.lock.json</ProjectLockJson> + </PropertyGroup> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" /> + <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' "> + </PropertyGroup> +</Project> diff --git a/tests/src/JIT/Performance/RunBenchmarks/RunBenchmarks.cs b/tests/src/JIT/Performance/RunBenchmarks/RunBenchmarks.cs index d5920e4b3f..a1ffb56777 100644 --- a/tests/src/JIT/Performance/RunBenchmarks/RunBenchmarks.cs +++ b/tests/src/JIT/Performance/RunBenchmarks/RunBenchmarks.cs @@ -70,11 +70,11 @@ // using System; -using System.Collections; using System.Collections.Generic; using System.Diagnostics; +using System.Linq; using System.Xml; -using System.Xml.XPath; +using System.Xml.Linq; using System.IO; namespace BenchmarkConsoleApplication @@ -497,115 +497,6 @@ namespace BenchmarkConsoleApplication } } - // XML processing, select a single node given root node and xpath field name. - - public XmlNode SelectSingleNode - ( - XmlNode node, - string xpath - ) - { -#if DESKTOP - return node.SelectSingleNode(xpath); -#else - return XmlDocumentXPathExtensions.SelectSingleNode(node, xpath); -#endif - } - - // XML processing, get a string field value given a node and xpath field name. - // Can be optional field. - - public string GetField - ( - XmlNode node, - string xpath, - bool optional = false - ) - { - XmlNode fieldNode = SelectSingleNode(node, xpath); - if (fieldNode == null) - { - if (optional) - { - return ""; - } - throw new Exception("missing field: " + xpath); - } - - return fieldNode.InnerText; - } - - // XML processing, get a boolean field value given a node and xpath field name. - // Can be optional field. - - public bool GetBooleanField - ( - XmlNode node, - string xpath, - bool optional = false - ) - { - string value = GetField(node, xpath, optional); - - if (value == "true") - return true; - if (value == "false") - return false; - if (optional) - return false; - - throw new Exception("bad boolean value: " + value); - } - - // XML processing, get an integer field value given a node and xpath field name. - // Can be optional field. - - public int GetIntegerField - ( - XmlNode node, - string xpath, - bool optional = false - ) - { - string value = GetField(node, xpath, optional); - - if (value != "") - { - int number = Int32.Parse(value); - return number; - } - if (optional) - return 0; - - throw new Exception("bad integer value: " + value); - } - - // XML processing, select a list of nodes given root node and xpath field name. - - public XmlNodeList SelectNodes - ( - XmlNode node, - string xpath - ) - { -#if DESKTOP - return node.SelectNodes(xpath); -#else - return XmlDocumentXPathExtensions.SelectNodes(node, xpath); -#endif - } - - // XML processing, get a list of nodes given root node and xpath field name. - - public XmlNodeList GetList - ( - XmlNode node, - string xpath - ) - { - return SelectNodes(node, xpath); - } - // Exit benchmark system with specified exit code. public int Exit(int exitCode) @@ -657,6 +548,45 @@ namespace BenchmarkConsoleApplication return platformSpecificDirectoryName; } + public static bool GetBool + ( + XElement node, + string name, + bool optional = true + ) + { + string value = node.Element(name)?.Value; + + if (value == "true") + return true; + if (value == "false") + return false; + if (optional) + return false; + + throw new Exception("bad boolean value: " + value); + } + + public static int GetInteger + ( + XElement node, + string name, + bool optional = true + ) + { + string value = node.Element(name)?.Value; + + if (value != "") + { + int number = Int32.Parse(value); + return number; + } + if (optional) + return 0; + + throw new Exception("bad integer value: " + value); + } + // Build list of benchmarks by reading in and processing .XML file. public void BuildBenchmarksList() @@ -691,9 +621,7 @@ namespace BenchmarkConsoleApplication // Load XML description of benchmarks. - XmlDocument benchmarkXml = new XmlDocument(); - var xmlFile = new FileStream(benchmarkXmlFullFileName, FileMode.Open, FileAccess.Read); - benchmarkXml.Load(xmlFile); + XElement benchmarkXml = XElement.Load(benchmarkXmlFullFileName); // Get root directory for benchmark system. Command line argument overrides // specification in benchmark control file. @@ -701,7 +629,7 @@ namespace BenchmarkConsoleApplication benchmarkRootDirectoryName = Controls.BenchmarksRootDirectory; if (benchmarkRootDirectoryName == "") { - benchmarkRootDirectoryName = GetField(benchmarkXml.DocumentElement, "benchmark-root-directory"); + benchmarkRootDirectoryName = Controls.BenchmarksRootDirectory = benchmarkRootDirectoryName; } benchmarkRootDirectoryName = PlatformSpecificDirectoryName(benchmarkRootDirectoryName); @@ -709,26 +637,26 @@ namespace BenchmarkConsoleApplication // Process each benchmark suite in the list of benchmark suites. - XmlNodeList benchmarkSuiteList = GetList(benchmarkXml.DocumentElement, "benchmark-suite"); - foreach (XmlNode benchmarkSuite in benchmarkSuiteList) + var benchmarkSuiteList = from e in benchmarkXml.Descendants("benchmark-suite") select e; + foreach (XElement benchmarkSuite in benchmarkSuiteList) { - benchmarkSuiteName = GetField(benchmarkSuite, "name"); + benchmarkSuiteName = benchmarkSuite.Element("name").Value; //Process each benchmark in benchmark suite. - XmlNodeList benchmarkList = GetList(benchmarkSuite, "benchmark"); - foreach (XmlNode benchmark in benchmarkList) + var benchmarkList = from e in benchmarkSuite.Descendants("benchmark") select e; + foreach (XElement benchmark in benchmarkList) { - benchmarkName = GetField(benchmark, "name"); - benchmarkDirectoryName = GetField(benchmark, "directory", OptionalField); + benchmarkName = benchmark.Element("name").Value; + benchmarkDirectoryName = benchmark.Element("directory")?.Value ?? ""; benchmarkDirectoryName = PlatformSpecificDirectoryName(benchmarkDirectoryName); - benchmarkExecutableName = GetField(benchmark, "executable"); - benchmarkArgs = GetField(benchmark, "args", OptionalField); - useSSE = GetBooleanField(benchmark, "useSSE", OptionalField); - useAVX = GetBooleanField(benchmark, "useAVX", OptionalField); - expectedResults = GetIntegerField(benchmark, "expected-results", OptionalField); - doRunInShell = GetBooleanField(benchmark, "run-in-shell", OptionalField); - tags = GetField(benchmark, "tags", OptionalField); + benchmarkExecutableName = benchmark.Element("executable").Value; + benchmarkArgs = benchmark.Element("args")?.Value ?? ""; + useSSE = GetBool(benchmark, "useSSE"); + useAVX = GetBool(benchmark, "useAVX"); + doRunInShell = GetBool(benchmark, "run-in-shell"); + expectedResults = GetInteger(benchmark, "expected-results"); + tags = benchmark.Element("tags")?.Value ?? ""; AddBenchmark(benchmarkName, benchmarkSuiteName, tags, benchmarkDirectoryName, benchmarkExecutableName, benchmarkArgs, doRunInShell, useSSE, useAVX, expectedResults); } diff --git a/tests/src/JIT/Regression/JitBlue/DevDiv_397793/DevDiv_397793.il b/tests/src/JIT/Regression/JitBlue/DevDiv_397793/DevDiv_397793.il new file mode 100644 index 0000000000..95d40b6bed --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/DevDiv_397793/DevDiv_397793.il @@ -0,0 +1,147 @@ +// 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 mscorlib{} +.assembly ILGEN_MODULE{} + +// This test originally failed compilation during CSE due to value numbers that were discarded during remorphing. +// The arguments to and return value from `ILGEN_METHOD` are not meaningful; it is enough that this function +// compiles successfully. + +.class ILGEN_CLASS +{ + .method static float32 ILGEN_METHOD(int16, char, char, native int) + { + .maxstack 65535 + .locals init (int8, native unsigned int, int64, int8, bool, unsigned int64, char, float64, int64, native int, float32, int64, int64, unsigned int16) + + IL_0000: ldloc 0x000d + IL_0004: not + IL_0005: ldloc.s 0x06 + IL_0007: cgt.un + IL_0009: ldloc.s 0x06 + IL_000b: clt.un + IL_000d: conv.r4 + IL_000e: ldloc.s 0x08 + IL_0010: conv.r.un + IL_0011: mul + IL_0012: conv.i8 + IL_0013: ldloc.s 0x03 + IL_0015: conv.u1 + IL_0016: not + IL_0017: ldloc.s 0x00 + IL_0019: ldloc.s 0x07 + IL_001b: neg + IL_001c: conv.u1 + IL_001d: xor + IL_001e: sub + IL_001f: ldloc 0x000c + IL_0023: neg + IL_0024: conv.i8 + IL_0025: ldloc.s 0x07 + IL_0027: neg + IL_0028: conv.u8 + IL_0029: conv.i8 + IL_002a: ldc.i4 0x2487c9b5 + IL_002f: conv.i8 + IL_0030: rem.un + IL_0031: ldloc.s 0x09 + IL_0033: conv.i8 + IL_0034: ldloc.s 0x01 + IL_0036: neg + IL_0037: not + IL_0038: ldloc 0x0006 + IL_003c: mul + IL_003d: shr.un + IL_003e: add + IL_003f: ldloc.s 0x0b + IL_0041: conv.i4 + IL_0042: shr.un + IL_0043: ldarg.s 0x03 + IL_0045: conv.i4 + IL_0046: ldloc.s 0x00 + IL_0048: clt + IL_004a: neg + IL_004b: ldloc.s 0x09 + IL_004d: pop + IL_004e: conv.r.un + IL_004f: conv.u8 + IL_0050: ldloc.s 0x05 + IL_0052: mul + IL_0053: ldloc.s 0x0c + IL_0055: conv.i8 + IL_0056: not + IL_0057: cgt.un + IL_0059: neg + IL_005a: nop + IL_005b: shl + IL_005c: ldc.i8 0x6ddee7e52bcb7a50 + IL_0065: ldloc 0x0004 + IL_0069: shr.un + IL_006a: pop + IL_006b: and + IL_006c: conv.u2 + IL_006d: add + IL_006e: ldarg.s 0x02 + IL_0070: not + IL_0071: neg + IL_0072: pop + IL_0073: ldarg.s 0x01 + IL_0075: ldloc 0x0008 + IL_0079: ldloc 0x000b + IL_007d: clt + IL_007f: conv.r.un + IL_0080: pop + IL_0081: ldloc 0x000c + IL_0085: not + IL_0086: ldloc.s 0x0c + IL_0088: conv.u8 + IL_0089: mul + IL_008a: ldloc 0x000b + IL_008e: add + IL_008f: ldloc 0x0002 + IL_0093: ldloc.s 0x0b + IL_0095: rem + IL_0096: ldc.i8 0xfe6f83985a745065 + IL_009f: add + IL_00a0: neg + IL_00a1: cgt.un + IL_00a3: shr + IL_00a4: conv.u8 + IL_00a5: nop + IL_00a6: neg + IL_00a7: neg + IL_00a8: pop + IL_00a9: shr + IL_00aa: nop + IL_00ab: conv.r.un + IL_00ac: ret + } + + .method public static int32 Main() + { + .entrypoint + + .try + { + ldc.i4 0 + ldc.i4 0 + ldc.i4 0 + ldc.i4 0 + conv.i + call float32 ILGEN_CLASS::ILGEN_METHOD(int16, char, char, native int) + pop + leave done + } + catch [mscorlib]System.Exception + { + pop + leave done + } + + done: + ldc.i4 100 + ret + } +} diff --git a/tests/src/JIT/Regression/JitBlue/DevDiv_397793/DevDiv_397793.ilproj b/tests/src/JIT/Regression/JitBlue/DevDiv_397793/DevDiv_397793.ilproj new file mode 100644 index 0000000000..c722432ef9 --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/DevDiv_397793/DevDiv_397793.ilproj @@ -0,0 +1,34 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" /> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <AssemblyName>$(MSBuildProjectName)</AssemblyName> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid> + <OutputType>Exe</OutputType> + <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids> + <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> + </PropertyGroup> + <!-- Default configurations to help VS understand the configurations --> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "></PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "></PropertyGroup> + <ItemGroup> + <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies"> + <Visible>False</Visible> + </CodeAnalysisDependentAssemblyPaths> + </ItemGroup> + <PropertyGroup> + <DebugType>PdbOnly</DebugType> + <Optimize>True</Optimize> + </PropertyGroup> + <ItemGroup> + <Compile Include="DevDiv_397793.il" /> + </ItemGroup> + <ItemGroup> + <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" /> + </ItemGroup> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" /> + <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' "></PropertyGroup> +</Project> diff --git a/tests/src/JIT/Regression/JitBlue/DevDiv_406160/DevDiv_406160.il b/tests/src/JIT/Regression/JitBlue/DevDiv_406160/DevDiv_406160.il new file mode 100644 index 0000000000..a7eaea4def --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/DevDiv_406160/DevDiv_406160.il @@ -0,0 +1,83 @@ +// 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. + + +// Metadata version: v4.0.30319 +.assembly extern System.Runtime +{ + .publickeytoken = (B0 3F 5F 7F 11 D5 0A 3A ) // .?_....: + .ver 4:2:0:0 +} +.assembly extern System.Console +{ + .publickeytoken = (B0 3F 5F 7F 11 D5 0A 3A ) // .?_....: + .ver 4:1:0:0 +} +.assembly DevDiv_406160 +{ +} + +.class private auto ansi beforefieldinit Bug.Program + extends [System.Runtime]System.Object +{ + .method static char ILGEN_METHOD(int16, unsigned int16, native unsigned int) + { + .maxstack 65535 + .locals init (bool, int64, native unsigned int) + IL_0000: ldarg.s 0x00 + IL_0002: ldc.i4.1 + IL_0015: clt + IL_001b: starg.s 0x00 + IL_001d: ldloc 0x0001 + IL_0067: ldc.i8 0xc3ec93cfd869ae83 + IL_0072: ldc.r8 float64(0xb47a62a75e195a1c) + IL_007c: conv.ovf.u8 + IL_007d: ldc.i4.1 + IL_0081: conv.ovf.i8.un + IL_0088: div.un + IL_0089: add.ovf.un + IL_008c: ldloc 0x0001 + IL_009a: ldc.i8 0x97a27f9613c909c1 + IL_00a3: dup + IL_00a4: clt + IL_00a6: shr.un + IL_00a7: xor + IL_00a8: ldarg.s 0x00 + IL_00aa: conv.ovf.u8.un + IL_00ab: and + IL_00ac: ldloc.s 0x01 + IL_00ae: and + IL_00af: conv.ovf.i2.un + IL_00b0: xor + IL_00cd: conv.i4 + IL_00ce: ret + } + + .method public hidebysig static int32 Main() cil managed + { + .entrypoint + // Code size 22 (0x16) + .maxstack 8 + IL_0001: ldc.i4.0 + IL_0002: ldc.i4.0 + IL_0003: ldc.i4.0 + IL_0004: call char Bug.Program::ILGEN_METHOD(int16, unsigned int16, native unsigned int) + IL_0005: pop + IL_0009: ldstr "Pass" + IL_000e: call void [System.Console]System.Console::WriteLine(string) + IL_0013: ldc.i4.s 100 + IL_0015: ret + } // end of method Program::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 [System.Runtime]System.Object::.ctor() + IL_0006: ret + } // end of method Program::.ctor + +} // end of class Bug.Program
\ No newline at end of file diff --git a/tests/src/JIT/Regression/JitBlue/DevDiv_406160/DevDiv_406160.ilproj b/tests/src/JIT/Regression/JitBlue/DevDiv_406160/DevDiv_406160.ilproj new file mode 100644 index 0000000000..310db80682 --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/DevDiv_406160/DevDiv_406160.ilproj @@ -0,0 +1,37 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" /> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <AssemblyName>$(MSBuildProjectName)</AssemblyName> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid> + <OutputType>Exe</OutputType> + <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids> + <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> + </PropertyGroup> + <!-- Default configurations to help VS understand the configurations --> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + </PropertyGroup> + <ItemGroup> + <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies"> + <Visible>False</Visible> + </CodeAnalysisDependentAssemblyPaths> + </ItemGroup> + <PropertyGroup> + <DebugType>None</DebugType> + <Optimize>True</Optimize> + </PropertyGroup> + <ItemGroup> + <Compile Include="DevDiv_406160.il" /> + </ItemGroup> + <ItemGroup> + <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" /> + </ItemGroup> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" /> + <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' "> + </PropertyGroup> +</Project> diff --git a/tests/src/JIT/Regression/JitBlue/GitHub_10940/GitHub_10940.cs b/tests/src/JIT/Regression/JitBlue/GitHub_10940/GitHub_10940.cs new file mode 100644 index 0000000000..2a72bd8a85 --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/GitHub_10940/GitHub_10940.cs @@ -0,0 +1,58 @@ +// 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. + +using System.Runtime.CompilerServices; + +// This test checks whether or not the JIT properly spills side effects in the importer when dumping multi-reg values +// to temps. If the JIT does not do so correctly, the calls to GetString() and GetDecimal() will be reordered and the +// test will fail with exit code 0; if it does do so correctly, the calls will not be reordered and the test will +// pass. + +class Test +{ + abstract class ValueSourceBase + { + public abstract string GetString(); + public abstract decimal GetDecimal(); + public abstract int GetReturnValue(); + } + + class ValueSource : ValueSourceBase + { + int rv; + + public override string GetString() + { + rv = 0; + return ""; + } + + public override decimal GetDecimal() + { + rv = 100; + return 0; + } + + public override int GetReturnValue() + { + return rv; + } + } + + Test(string s, decimal d) + { + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static int M(ValueSourceBase vs) + { + new Test(vs.GetString(), vs.GetDecimal()); + return vs.GetReturnValue(); + } + + static int Main() + { + return M(new ValueSource()); + } +} diff --git a/tests/src/JIT/Regression/JitBlue/GitHub_10940/GitHub_10940.csproj b/tests/src/JIT/Regression/JitBlue/GitHub_10940/GitHub_10940.csproj new file mode 100644 index 0000000000..ef69a3b429 --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/GitHub_10940/GitHub_10940.csproj @@ -0,0 +1,42 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" /> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <AssemblyName>$(MSBuildProjectName)</AssemblyName> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid> + <OutputType>Exe</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <FileAlignment>512</FileAlignment> + <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids> + <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath> + <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> + + <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp> + </PropertyGroup> + <!-- Default configurations to help VS understand the configurations --> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + </PropertyGroup> + <ItemGroup> + <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies"> + <Visible>False</Visible> + </CodeAnalysisDependentAssemblyPaths> + </ItemGroup> + <PropertyGroup> + <DebugType></DebugType> + <Optimize>True</Optimize> + </PropertyGroup> + <ItemGroup> + <Compile Include="GitHub_10940.cs" /> + </ItemGroup> + <ItemGroup> + <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" /> + </ItemGroup> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" /> + <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' "> + </PropertyGroup> +</Project> diff --git a/tests/src/JIT/config/benchmark+roslyn/project.json b/tests/src/JIT/config/benchmark+roslyn/project.json index 7940c4038d..18907a1214 100644 --- a/tests/src/JIT/config/benchmark+roslyn/project.json +++ b/tests/src/JIT/config/benchmark+roslyn/project.json @@ -1,20 +1,20 @@ { "dependencies": { "Microsoft.CodeAnalysis.Compilers": "1.1.1", - "xunit.performance.api": "1.0.0-alpha-build0049", - "xunit.performance.core": "1.0.0-alpha-build0049", - "xunit.performance.execution": "1.0.0-alpha-build0049", - "xunit.performance.metrics": "1.0.0-alpha-build0049", + "xunit.performance.api": "1.0.0-beta-build0003", + "xunit.performance.core": "1.0.0-beta-build0003", + "xunit.performance.execution": "1.0.0-beta-build0003", + "xunit.performance.metrics": "1.0.0-beta-build0003", "Microsoft.Diagnostics.Tracing.TraceEvent": "1.0.3-alpha-experimental", - "Microsoft.NETCore.Platforms": "2.0.0-preview1-25210-01", + "Microsoft.NETCore.Platforms": "2.0.0-preview1-25221-01", "System.Console": "4.4.0-beta-24913-02", "System.Dynamic.Runtime": "4.4.0-beta-24913-02", "System.Linq": "4.4.0-beta-24913-02", "System.IO.FileSystem": "4.4.0-beta-24913-02", - "System.Numerics.Vectors": "4.4.0-preview1-25210-01", + "System.Numerics.Vectors": "4.4.0-preview1-25221-01", "System.Reflection": "4.4.0-beta-24913-02", "System.Reflection.Extensions": "4.4.0-beta-24913-02", - "System.Reflection.TypeExtensions": "4.4.0-preview1-25210-01", + "System.Reflection.TypeExtensions": "4.4.0-preview1-25221-01", "System.Runtime": "4.4.0-beta-24913-02", "System.Runtime.Extensions": "4.4.0-beta-24913-02", "System.Runtime.Numerics": "4.4.0-beta-24913-02", diff --git a/tests/src/JIT/config/benchmark+serialize/project.json b/tests/src/JIT/config/benchmark+serialize/project.json index 49d20c2118..b71701f9ef 100644 --- a/tests/src/JIT/config/benchmark+serialize/project.json +++ b/tests/src/JIT/config/benchmark+serialize/project.json @@ -1,11 +1,11 @@ { "dependencies": { - "xunit.performance.api": "1.0.0-alpha-build0049", - "xunit.performance.core": "1.0.0-alpha-build0049", - "xunit.performance.execution": "1.0.0-alpha-build0049", - "xunit.performance.metrics": "1.0.0-alpha-build0049", + "xunit.performance.api": "1.0.0-beta-build0003", + "xunit.performance.core": "1.0.0-beta-build0003", + "xunit.performance.execution": "1.0.0-beta-build0003", + "xunit.performance.metrics": "1.0.0-beta-build0003", "Microsoft.Diagnostics.Tracing.TraceEvent": "1.0.3-alpha-experimental", - "Microsoft.NETCore.Platforms": "2.0.0-preview1-25210-01", + "Microsoft.NETCore.Platforms": "2.0.0-preview1-25221-01", "Newtonsoft.Json": "7.0.1", "System.Console": "4.4.0-beta-24913-02", "System.IO": "4.4.0-beta-24913-02", @@ -15,7 +15,7 @@ "System.Dynamic.Runtime": "4.4.0-beta-24913-02", "System.Reflection": "4.4.0-beta-24913-02", "System.Reflection.Extensions": "4.4.0-beta-24913-02", - "System.Reflection.TypeExtensions": "4.4.0-preview1-25210-01", + "System.Reflection.TypeExtensions": "4.4.0-preview1-25221-01", "System.Runtime": "4.4.0-beta-24913-02", "System.Runtime.Serialization.Json": "4.4.0-beta-24913-02", "System.Runtime.Serialization.Primitives": "4.4.0-beta-24913-02", diff --git a/tests/src/JIT/config/benchmark/project.json b/tests/src/JIT/config/benchmark/project.json index e42976a2d8..aac92ecc0b 100644 --- a/tests/src/JIT/config/benchmark/project.json +++ b/tests/src/JIT/config/benchmark/project.json @@ -1,23 +1,24 @@ { "dependencies": { - "xunit.performance.api": "1.0.0-alpha-build0049", - "xunit.performance.core": "1.0.0-alpha-build0049", - "xunit.performance.execution": "1.0.0-alpha-build0049", - "xunit.performance.metrics": "1.0.0-alpha-build0049", + "xunit.performance.api": "1.0.0-beta-build0003", + "xunit.performance.core": "1.0.0-beta-build0003", + "xunit.performance.execution": "1.0.0-beta-build0003", + "xunit.performance.metrics": "1.0.0-beta-build0003", "Microsoft.Diagnostics.Tracing.TraceEvent": "1.0.3-alpha-experimental", - "Microsoft.NETCore.Platforms": "2.0.0-preview1-25210-01", + "Microsoft.NETCore.Platforms": "2.0.0-preview1-25221-01", "System.Collections.NonGeneric": "4.4.0-beta-24913-02", "System.Console": "4.4.0-beta-24913-02", "System.IO.FileSystem": "4.4.0-beta-24913-02", "System.Linq": "4.4.0-beta-24913-02", "System.Linq.Parallel": "4.4.0-beta-24913-02", "System.Linq.Expressions": "4.4.0-beta-24913-02", - "System.Memory": "4.4.0-preview1-25210-01", - "System.Numerics.Vectors": "4.4.0-preview1-25210-01", + "System.Memory": "4.4.0-preview1-25221-01", + "System.Numerics.Vectors": "4.4.0-preview1-25221-01", "System.Reflection": "4.4.0-beta-24913-02", "System.Reflection.Extensions": "4.4.0-beta-24913-02", - "System.Reflection.TypeExtensions": "4.4.0-preview1-25210-01", + "System.Reflection.TypeExtensions": "4.4.0-preview1-25221-01", "System.Runtime": "4.4.0-beta-24913-02", + "System.Runtime.CompilerServices.Unsafe": "4.4.0-preview1-25221-01", "System.Runtime.Extensions": "4.4.0-beta-24913-02", "System.Runtime.Numerics": "4.4.0-beta-24913-02", "System.Text.RegularExpressions": "4.4.0-beta-24913-02", @@ -27,8 +28,6 @@ "System.Threading.ThreadPool": "4.4.0-beta-24913-02", "System.Diagnostics.Process": "4.4.0-beta-24913-02", "System.Xml.XmlDocument": "4.4.0-beta-24913-02", - "System.Xml.XPath": "4.4.0-beta-24913-02", - "System.Xml.XPath.XmlDocument": "4.4.0-beta-24913-02", "xunit": "2.2.0-beta2-build3300", "xunit.console.netcore": "1.0.2-prerelease-00177", "xunit.runner.utility": "2.2.0-beta2-build3300" diff --git a/tests/src/JIT/jit64/hfa/main/dll/hfa_native.h b/tests/src/JIT/jit64/hfa/main/dll/hfa_native.h index 814ae4a6f6..7cfdb2820f 100644 --- a/tests/src/JIT/jit64/hfa/main/dll/hfa_native.h +++ b/tests/src/JIT/jit64/hfa/main/dll/hfa_native.h @@ -1,11 +1,20 @@ // Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. +#if !defined(_MSC_VER) +#if __i386__ +#define __stdcall __attribute__((stdcall)) +#else // __i386__ +#define __stdcall +#endif // !__i386__ +#endif // !defined(_MSC_VER) #if defined(_MSC_VER) #define HFADLL_API extern "C" __declspec(dllexport) +#define HFADLL_CALLCONV #else #define HFADLL_API extern "C" __attribute__((visibility("default"))) +#define HFADLL_CALLCONV __stdcall #endif @@ -102,13 +111,13 @@ const FLOATTYPE EXPECTED_SUM_HFA11 = static_cast<FLOATTYPE>(66); const FLOATTYPE EXPECTED_SUM_HFA19 = static_cast<FLOATTYPE>(190); #endif -HFADLL_API FLOATTYPE get_EXPECTED_SUM_HFA01() {return EXPECTED_SUM_HFA01;} -HFADLL_API FLOATTYPE get_EXPECTED_SUM_HFA02() {return EXPECTED_SUM_HFA02;} -HFADLL_API FLOATTYPE get_EXPECTED_SUM_HFA03() {return EXPECTED_SUM_HFA03;} -HFADLL_API FLOATTYPE get_EXPECTED_SUM_HFA05() {return EXPECTED_SUM_HFA05;} -HFADLL_API FLOATTYPE get_EXPECTED_SUM_HFA08() {return EXPECTED_SUM_HFA08;} -HFADLL_API FLOATTYPE get_EXPECTED_SUM_HFA11() {return EXPECTED_SUM_HFA11;} -HFADLL_API FLOATTYPE get_EXPECTED_SUM_HFA19() {return EXPECTED_SUM_HFA19;} +HFADLL_API FLOATTYPE HFADLL_CALLCONV get_EXPECTED_SUM_HFA01() {return EXPECTED_SUM_HFA01;} +HFADLL_API FLOATTYPE HFADLL_CALLCONV get_EXPECTED_SUM_HFA02() {return EXPECTED_SUM_HFA02;} +HFADLL_API FLOATTYPE HFADLL_CALLCONV get_EXPECTED_SUM_HFA03() {return EXPECTED_SUM_HFA03;} +HFADLL_API FLOATTYPE HFADLL_CALLCONV get_EXPECTED_SUM_HFA05() {return EXPECTED_SUM_HFA05;} +HFADLL_API FLOATTYPE HFADLL_CALLCONV get_EXPECTED_SUM_HFA08() {return EXPECTED_SUM_HFA08;} +HFADLL_API FLOATTYPE HFADLL_CALLCONV get_EXPECTED_SUM_HFA11() {return EXPECTED_SUM_HFA11;} +HFADLL_API FLOATTYPE HFADLL_CALLCONV get_EXPECTED_SUM_HFA19() {return EXPECTED_SUM_HFA19;} @@ -116,13 +125,13 @@ HFADLL_API FLOATTYPE get_EXPECTED_SUM_HFA19() {return EXPECTED_SUM_HFA19;} // init Methods // --------------------------------------------------- -HFADLL_API void init_HFA01(HFA01& hfa); -HFADLL_API void init_HFA02(HFA02& hfa); -HFADLL_API void init_HFA03(HFA03& hfa); -HFADLL_API void init_HFA05(HFA05& hfa); -HFADLL_API void init_HFA08(HFA08& hfa); -HFADLL_API void init_HFA11(HFA11& hfa); -HFADLL_API void init_HFA19(HFA19& hfa); +HFADLL_API void HFADLL_CALLCONV init_HFA01(HFA01& hfa); +HFADLL_API void HFADLL_CALLCONV init_HFA02(HFA02& hfa); +HFADLL_API void HFADLL_CALLCONV init_HFA03(HFA03& hfa); +HFADLL_API void HFADLL_CALLCONV init_HFA05(HFA05& hfa); +HFADLL_API void HFADLL_CALLCONV init_HFA08(HFA08& hfa); +HFADLL_API void HFADLL_CALLCONV init_HFA11(HFA11& hfa); +HFADLL_API void HFADLL_CALLCONV init_HFA19(HFA19& hfa); @@ -130,13 +139,13 @@ HFADLL_API void init_HFA19(HFA19& hfa); // identity methods // -------------------------------------------------------------- -HFADLL_API HFA01 identity_HFA01(HFA01 hfa); -HFADLL_API HFA02 identity_HFA02(HFA02 hfa); -HFADLL_API HFA03 identity_HFA03(HFA03 hfa); -HFADLL_API HFA05 identity_HFA05(HFA05 hfa); -HFADLL_API HFA08 identity_HFA08(HFA08 hfa); -HFADLL_API HFA11 identity_HFA11(HFA11 hfa); -HFADLL_API HFA19 identity_HFA19(HFA19 hfa); +HFADLL_API HFA01 HFADLL_CALLCONV identity_HFA01(HFA01 hfa); +HFADLL_API HFA02 HFADLL_CALLCONV identity_HFA02(HFA02 hfa); +HFADLL_API HFA03 HFADLL_CALLCONV identity_HFA03(HFA03 hfa); +HFADLL_API HFA05 HFADLL_CALLCONV identity_HFA05(HFA05 hfa); +HFADLL_API HFA08 HFADLL_CALLCONV identity_HFA08(HFA08 hfa); +HFADLL_API HFA11 HFADLL_CALLCONV identity_HFA11(HFA11 hfa); +HFADLL_API HFA19 HFADLL_CALLCONV identity_HFA19(HFA19 hfa); @@ -144,13 +153,13 @@ HFADLL_API HFA19 identity_HFA19(HFA19 hfa); // get methods // -------------------------------------------------------------- -HFADLL_API HFA01 get_HFA01(); -HFADLL_API HFA02 get_HFA02(); -HFADLL_API HFA03 get_HFA03(); -HFADLL_API HFA05 get_HFA05(); -HFADLL_API HFA08 get_HFA08(); -HFADLL_API HFA11 get_HFA11(); -HFADLL_API HFA19 get_HFA19(); +HFADLL_API HFA01 HFADLL_CALLCONV get_HFA01(); +HFADLL_API HFA02 HFADLL_CALLCONV get_HFA02(); +HFADLL_API HFA03 HFADLL_CALLCONV get_HFA03(); +HFADLL_API HFA05 HFADLL_CALLCONV get_HFA05(); +HFADLL_API HFA08 HFADLL_CALLCONV get_HFA08(); +HFADLL_API HFA11 HFADLL_CALLCONV get_HFA11(); +HFADLL_API HFA19 HFADLL_CALLCONV get_HFA19(); @@ -158,53 +167,53 @@ HFADLL_API HFA19 get_HFA19(); // sum Methods // --------------------------------------------------- -HFADLL_API FLOATTYPE sum_HFA01(HFA01 hfa); -HFADLL_API FLOATTYPE sum_HFA02(HFA02 hfa); -HFADLL_API FLOATTYPE sum_HFA03(HFA03 hfa); -HFADLL_API FLOATTYPE sum_HFA05(HFA05 hfa); -HFADLL_API FLOATTYPE sum_HFA08(HFA08 hfa); -HFADLL_API FLOATTYPE sum_HFA11(HFA11 hfa); -HFADLL_API FLOATTYPE sum_HFA19(HFA19 hfa); - -HFADLL_API FLOATTYPE sum3_HFA01(float v1, __int64 v2, HFA01 hfa); -HFADLL_API FLOATTYPE sum3_HFA02(float v1, __int64 v2, HFA02 hfa); -HFADLL_API FLOATTYPE sum3_HFA03(float v1, __int64 v2, HFA03 hfa); -HFADLL_API FLOATTYPE sum3_HFA05(float v1, __int64 v2, HFA05 hfa); -HFADLL_API FLOATTYPE sum3_HFA08(float v1, __int64 v2, HFA08 hfa); -HFADLL_API FLOATTYPE sum3_HFA11(float v1, __int64 v2, HFA11 hfa); -HFADLL_API FLOATTYPE sum3_HFA19(float v1, __int64 v2, HFA19 hfa); - -HFADLL_API FLOATTYPE sum5_HFA01(__int64 v1, double v2, short v3, signed char v4, HFA01 hfa); -HFADLL_API FLOATTYPE sum5_HFA02(__int64 v1, double v2, short v3, signed char v4, HFA02 hfa); -HFADLL_API FLOATTYPE sum5_HFA03(__int64 v1, double v2, short v3, signed char v4, HFA03 hfa); -HFADLL_API FLOATTYPE sum5_HFA05(__int64 v1, double v2, short v3, signed char v4, HFA05 hfa); -HFADLL_API FLOATTYPE sum5_HFA08(__int64 v1, double v2, short v3, signed char v4, HFA08 hfa); -HFADLL_API FLOATTYPE sum5_HFA11(__int64 v1, double v2, short v3, signed char v4, HFA11 hfa); -HFADLL_API FLOATTYPE sum5_HFA19(__int64 v1, double v2, short v3, signed char v4, HFA19 hfa); - -HFADLL_API FLOATTYPE sum8_HFA01(float v1, double v2, __int64 v3, signed char v4, double v5, HFA01 hfa); -HFADLL_API FLOATTYPE sum8_HFA02(float v1, double v2, __int64 v3, signed char v4, double v5, HFA02 hfa); -HFADLL_API FLOATTYPE sum8_HFA03(float v1, double v2, __int64 v3, signed char v4, double v5, HFA03 hfa); -HFADLL_API FLOATTYPE sum8_HFA05(float v1, double v2, __int64 v3, signed char v4, double v5, HFA05 hfa); -HFADLL_API FLOATTYPE sum8_HFA08(float v1, double v2, __int64 v3, signed char v4, double v5, HFA08 hfa); -HFADLL_API FLOATTYPE sum8_HFA11(float v1, double v2, __int64 v3, signed char v4, double v5, HFA11 hfa); -HFADLL_API FLOATTYPE sum8_HFA19(float v1, double v2, __int64 v3, signed char v4, double v5, HFA19 hfa); - -HFADLL_API FLOATTYPE sum11_HFA01(double v1, float v2, float v3, int v4, float v5, __int64 v6, double v7, float v8, HFA01 hfa); -HFADLL_API FLOATTYPE sum11_HFA02(double v1, float v2, float v3, int v4, float v5, __int64 v6, double v7, float v8, HFA02 hfa); -HFADLL_API FLOATTYPE sum11_HFA03(double v1, float v2, float v3, int v4, float v5, __int64 v6, double v7, float v8, HFA03 hfa); -HFADLL_API FLOATTYPE sum11_HFA05(double v1, float v2, float v3, int v4, float v5, __int64 v6, double v7, float v8, HFA05 hfa); -HFADLL_API FLOATTYPE sum11_HFA08(double v1, float v2, float v3, int v4, float v5, __int64 v6, double v7, float v8, HFA08 hfa); -HFADLL_API FLOATTYPE sum11_HFA11(double v1, float v2, float v3, int v4, float v5, __int64 v6, double v7, float v8, HFA11 hfa); -HFADLL_API FLOATTYPE sum11_HFA19(double v1, float v2, float v3, int v4, float v5, __int64 v6, double v7, float v8, HFA19 hfa); - -HFADLL_API FLOATTYPE sum19_HFA01(float v1, double v2, float v3, double v4, float v5, double v6, float v7, double v8, float v9, double v10, float v11, double v12, float v13, HFA01 hfa); -HFADLL_API FLOATTYPE sum19_HFA02(float v1, double v2, float v3, double v4, float v5, double v6, float v7, double v8, float v9, double v10, float v11, double v12, float v13, HFA02 hfa); -HFADLL_API FLOATTYPE sum19_HFA03(float v1, double v2, float v3, double v4, float v5, double v6, float v7, double v8, float v9, double v10, float v11, double v12, float v13, HFA03 hfa); -HFADLL_API FLOATTYPE sum19_HFA05(float v1, double v2, float v3, double v4, float v5, double v6, float v7, double v8, float v9, double v10, float v11, double v12, float v13, HFA05 hfa); -HFADLL_API FLOATTYPE sum19_HFA08(float v1, double v2, float v3, double v4, float v5, double v6, float v7, double v8, float v9, double v10, float v11, double v12, float v13, HFA08 hfa); -HFADLL_API FLOATTYPE sum19_HFA11(float v1, double v2, float v3, double v4, float v5, double v6, float v7, double v8, float v9, double v10, float v11, double v12, float v13, HFA11 hfa); -HFADLL_API FLOATTYPE sum19_HFA19(float v1, double v2, float v3, double v4, float v5, double v6, float v7, double v8, float v9, double v10, float v11, double v12, float v13, HFA19 hfa); +HFADLL_API FLOATTYPE HFADLL_CALLCONV sum_HFA01(HFA01 hfa); +HFADLL_API FLOATTYPE HFADLL_CALLCONV sum_HFA02(HFA02 hfa); +HFADLL_API FLOATTYPE HFADLL_CALLCONV sum_HFA03(HFA03 hfa); +HFADLL_API FLOATTYPE HFADLL_CALLCONV sum_HFA05(HFA05 hfa); +HFADLL_API FLOATTYPE HFADLL_CALLCONV sum_HFA08(HFA08 hfa); +HFADLL_API FLOATTYPE HFADLL_CALLCONV sum_HFA11(HFA11 hfa); +HFADLL_API FLOATTYPE HFADLL_CALLCONV sum_HFA19(HFA19 hfa); + +HFADLL_API FLOATTYPE HFADLL_CALLCONV sum3_HFA01(float v1, __int64 v2, HFA01 hfa); +HFADLL_API FLOATTYPE HFADLL_CALLCONV sum3_HFA02(float v1, __int64 v2, HFA02 hfa); +HFADLL_API FLOATTYPE HFADLL_CALLCONV sum3_HFA03(float v1, __int64 v2, HFA03 hfa); +HFADLL_API FLOATTYPE HFADLL_CALLCONV sum3_HFA05(float v1, __int64 v2, HFA05 hfa); +HFADLL_API FLOATTYPE HFADLL_CALLCONV sum3_HFA08(float v1, __int64 v2, HFA08 hfa); +HFADLL_API FLOATTYPE HFADLL_CALLCONV sum3_HFA11(float v1, __int64 v2, HFA11 hfa); +HFADLL_API FLOATTYPE HFADLL_CALLCONV sum3_HFA19(float v1, __int64 v2, HFA19 hfa); + +HFADLL_API FLOATTYPE HFADLL_CALLCONV sum5_HFA01(__int64 v1, double v2, short v3, signed char v4, HFA01 hfa); +HFADLL_API FLOATTYPE HFADLL_CALLCONV sum5_HFA02(__int64 v1, double v2, short v3, signed char v4, HFA02 hfa); +HFADLL_API FLOATTYPE HFADLL_CALLCONV sum5_HFA03(__int64 v1, double v2, short v3, signed char v4, HFA03 hfa); +HFADLL_API FLOATTYPE HFADLL_CALLCONV sum5_HFA05(__int64 v1, double v2, short v3, signed char v4, HFA05 hfa); +HFADLL_API FLOATTYPE HFADLL_CALLCONV sum5_HFA08(__int64 v1, double v2, short v3, signed char v4, HFA08 hfa); +HFADLL_API FLOATTYPE HFADLL_CALLCONV sum5_HFA11(__int64 v1, double v2, short v3, signed char v4, HFA11 hfa); +HFADLL_API FLOATTYPE HFADLL_CALLCONV sum5_HFA19(__int64 v1, double v2, short v3, signed char v4, HFA19 hfa); + +HFADLL_API FLOATTYPE HFADLL_CALLCONV sum8_HFA01(float v1, double v2, __int64 v3, signed char v4, double v5, HFA01 hfa); +HFADLL_API FLOATTYPE HFADLL_CALLCONV sum8_HFA02(float v1, double v2, __int64 v3, signed char v4, double v5, HFA02 hfa); +HFADLL_API FLOATTYPE HFADLL_CALLCONV sum8_HFA03(float v1, double v2, __int64 v3, signed char v4, double v5, HFA03 hfa); +HFADLL_API FLOATTYPE HFADLL_CALLCONV sum8_HFA05(float v1, double v2, __int64 v3, signed char v4, double v5, HFA05 hfa); +HFADLL_API FLOATTYPE HFADLL_CALLCONV sum8_HFA08(float v1, double v2, __int64 v3, signed char v4, double v5, HFA08 hfa); +HFADLL_API FLOATTYPE HFADLL_CALLCONV sum8_HFA11(float v1, double v2, __int64 v3, signed char v4, double v5, HFA11 hfa); +HFADLL_API FLOATTYPE HFADLL_CALLCONV sum8_HFA19(float v1, double v2, __int64 v3, signed char v4, double v5, HFA19 hfa); + +HFADLL_API FLOATTYPE HFADLL_CALLCONV sum11_HFA01(double v1, float v2, float v3, int v4, float v5, __int64 v6, double v7, float v8, HFA01 hfa); +HFADLL_API FLOATTYPE HFADLL_CALLCONV sum11_HFA02(double v1, float v2, float v3, int v4, float v5, __int64 v6, double v7, float v8, HFA02 hfa); +HFADLL_API FLOATTYPE HFADLL_CALLCONV sum11_HFA03(double v1, float v2, float v3, int v4, float v5, __int64 v6, double v7, float v8, HFA03 hfa); +HFADLL_API FLOATTYPE HFADLL_CALLCONV sum11_HFA05(double v1, float v2, float v3, int v4, float v5, __int64 v6, double v7, float v8, HFA05 hfa); +HFADLL_API FLOATTYPE HFADLL_CALLCONV sum11_HFA08(double v1, float v2, float v3, int v4, float v5, __int64 v6, double v7, float v8, HFA08 hfa); +HFADLL_API FLOATTYPE HFADLL_CALLCONV sum11_HFA11(double v1, float v2, float v3, int v4, float v5, __int64 v6, double v7, float v8, HFA11 hfa); +HFADLL_API FLOATTYPE HFADLL_CALLCONV sum11_HFA19(double v1, float v2, float v3, int v4, float v5, __int64 v6, double v7, float v8, HFA19 hfa); + +HFADLL_API FLOATTYPE HFADLL_CALLCONV sum19_HFA01(float v1, double v2, float v3, double v4, float v5, double v6, float v7, double v8, float v9, double v10, float v11, double v12, float v13, HFA01 hfa); +HFADLL_API FLOATTYPE HFADLL_CALLCONV sum19_HFA02(float v1, double v2, float v3, double v4, float v5, double v6, float v7, double v8, float v9, double v10, float v11, double v12, float v13, HFA02 hfa); +HFADLL_API FLOATTYPE HFADLL_CALLCONV sum19_HFA03(float v1, double v2, float v3, double v4, float v5, double v6, float v7, double v8, float v9, double v10, float v11, double v12, float v13, HFA03 hfa); +HFADLL_API FLOATTYPE HFADLL_CALLCONV sum19_HFA05(float v1, double v2, float v3, double v4, float v5, double v6, float v7, double v8, float v9, double v10, float v11, double v12, float v13, HFA05 hfa); +HFADLL_API FLOATTYPE HFADLL_CALLCONV sum19_HFA08(float v1, double v2, float v3, double v4, float v5, double v6, float v7, double v8, float v9, double v10, float v11, double v12, float v13, HFA08 hfa); +HFADLL_API FLOATTYPE HFADLL_CALLCONV sum19_HFA11(float v1, double v2, float v3, double v4, float v5, double v6, float v7, double v8, float v9, double v10, float v11, double v12, float v13, HFA11 hfa); +HFADLL_API FLOATTYPE HFADLL_CALLCONV sum19_HFA19(float v1, double v2, float v3, double v4, float v5, double v6, float v7, double v8, float v9, double v10, float v11, double v12, float v13, HFA19 hfa); @@ -212,53 +221,53 @@ HFADLL_API FLOATTYPE sum19_HFA19(float v1, double v2, float v3, double v4, floa // sverage Methods // --------------------------------------------------- -HFADLL_API FLOATTYPE average_HFA01(HFA01 hfa); -HFADLL_API FLOATTYPE average_HFA02(HFA02 hfa); -HFADLL_API FLOATTYPE average_HFA03(HFA03 hfa); -HFADLL_API FLOATTYPE average_HFA05(HFA05 hfa); -HFADLL_API FLOATTYPE average_HFA08(HFA08 hfa); -HFADLL_API FLOATTYPE average_HFA11(HFA11 hfa); -HFADLL_API FLOATTYPE average_HFA19(HFA19 hfa); - -HFADLL_API FLOATTYPE average3_HFA01(HFA01 hfa1, HFA01 hfa2, HFA01 hfa3); -HFADLL_API FLOATTYPE average3_HFA02(HFA02 hfa1, HFA02 hfa2, HFA02 hfa3); -HFADLL_API FLOATTYPE average3_HFA03(HFA03 hfa1, HFA03 hfa2, HFA03 hfa3); -HFADLL_API FLOATTYPE average3_HFA05(HFA05 hfa1, HFA05 hfa2, HFA05 hfa3); -HFADLL_API FLOATTYPE average3_HFA08(HFA08 hfa1, HFA08 hfa2, HFA08 hfa3); -HFADLL_API FLOATTYPE average3_HFA11(HFA11 hfa1, HFA11 hfa2, HFA11 hfa3); -HFADLL_API FLOATTYPE average3_HFA19(HFA19 hfa1, HFA19 hfa2, HFA19 hfa3); - -HFADLL_API FLOATTYPE average5_HFA01(HFA01 hfa1, HFA01 hfa2, HFA01 hfa3, HFA01 hfa4, HFA01 hfa5); -HFADLL_API FLOATTYPE average5_HFA02(HFA02 hfa1, HFA02 hfa2, HFA02 hfa3, HFA02 hfa4, HFA02 hfa5); -HFADLL_API FLOATTYPE average5_HFA03(HFA03 hfa1, HFA03 hfa2, HFA03 hfa3, HFA03 hfa4, HFA03 hfa5); -HFADLL_API FLOATTYPE average5_HFA05(HFA05 hfa1, HFA05 hfa2, HFA05 hfa3, HFA05 hfa4, HFA05 hfa5); -HFADLL_API FLOATTYPE average5_HFA08(HFA08 hfa1, HFA08 hfa2, HFA08 hfa3, HFA08 hfa4, HFA08 hfa5); -HFADLL_API FLOATTYPE average5_HFA11(HFA11 hfa1, HFA11 hfa2, HFA11 hfa3, HFA11 hfa4, HFA11 hfa5); -HFADLL_API FLOATTYPE average5_HFA19(HFA19 hfa1, HFA19 hfa2, HFA19 hfa3, HFA19 hfa4, HFA19 hfa5); - -HFADLL_API FLOATTYPE average8_HFA01(HFA01 hfa1, HFA01 hfa2, HFA01 hfa3, HFA01 hfa4, HFA01 hfa5, HFA01 hfa6, HFA01 hfa7, HFA01 hfa8); -HFADLL_API FLOATTYPE average8_HFA02(HFA02 hfa1, HFA02 hfa2, HFA02 hfa3, HFA02 hfa4, HFA02 hfa5, HFA02 hfa6, HFA02 hfa7, HFA02 hfa8); -HFADLL_API FLOATTYPE average8_HFA03(HFA03 hfa1, HFA03 hfa2, HFA03 hfa3, HFA03 hfa4, HFA03 hfa5, HFA03 hfa6, HFA03 hfa7, HFA03 hfa8); -HFADLL_API FLOATTYPE average8_HFA05(HFA05 hfa1, HFA05 hfa2, HFA05 hfa3, HFA05 hfa4, HFA05 hfa5, HFA05 hfa6, HFA05 hfa7, HFA05 hfa8); -HFADLL_API FLOATTYPE average8_HFA08(HFA08 hfa1, HFA08 hfa2, HFA08 hfa3, HFA08 hfa4, HFA08 hfa5, HFA08 hfa6, HFA08 hfa7, HFA08 hfa8); -HFADLL_API FLOATTYPE average8_HFA11(HFA11 hfa1, HFA11 hfa2, HFA11 hfa3, HFA11 hfa4, HFA11 hfa5, HFA11 hfa6, HFA11 hfa7, HFA11 hfa8); -HFADLL_API FLOATTYPE average8_HFA19(HFA19 hfa1, HFA19 hfa2, HFA19 hfa3, HFA19 hfa4, HFA19 hfa5, HFA19 hfa6, HFA19 hfa7, HFA19 hfa8); - -HFADLL_API FLOATTYPE average11_HFA01(HFA01 hfa1, HFA01 hfa2, HFA01 hfa3, HFA01 hfa4, HFA01 hfa5, HFA01 hfa6, HFA01 hfa7, HFA01 hfa8, HFA01 hfa9, HFA01 hfa10, HFA01 hfa11); -HFADLL_API FLOATTYPE average11_HFA02(HFA02 hfa1, HFA02 hfa2, HFA02 hfa3, HFA02 hfa4, HFA02 hfa5, HFA02 hfa6, HFA02 hfa7, HFA02 hfa8, HFA02 hfa9, HFA02 hfa10, HFA02 hfa11); -HFADLL_API FLOATTYPE average11_HFA03(HFA03 hfa1, HFA03 hfa2, HFA03 hfa3, HFA03 hfa4, HFA03 hfa5, HFA03 hfa6, HFA03 hfa7, HFA03 hfa8, HFA03 hfa9, HFA03 hfa10, HFA03 hfa11); -HFADLL_API FLOATTYPE average11_HFA05(HFA05 hfa1, HFA05 hfa2, HFA05 hfa3, HFA05 hfa4, HFA05 hfa5, HFA05 hfa6, HFA05 hfa7, HFA05 hfa8, HFA05 hfa9, HFA05 hfa10, HFA05 hfa11); -HFADLL_API FLOATTYPE average11_HFA08(HFA08 hfa1, HFA08 hfa2, HFA08 hfa3, HFA08 hfa4, HFA08 hfa5, HFA08 hfa6, HFA08 hfa7, HFA08 hfa8, HFA08 hfa9, HFA08 hfa10, HFA08 hfa11); -HFADLL_API FLOATTYPE average11_HFA11(HFA11 hfa1, HFA11 hfa2, HFA11 hfa3, HFA11 hfa4, HFA11 hfa5, HFA11 hfa6, HFA11 hfa7, HFA11 hfa8, HFA11 hfa9, HFA11 hfa10, HFA11 hfa11); -HFADLL_API FLOATTYPE average11_HFA19(HFA19 hfa1, HFA19 hfa2, HFA19 hfa3, HFA19 hfa4, HFA19 hfa5, HFA19 hfa6, HFA19 hfa7, HFA19 hfa8, HFA19 hfa9, HFA19 hfa10, HFA19 hfa11); - -HFADLL_API FLOATTYPE average19_HFA01(HFA01 hfa1, HFA01 hfa2, HFA01 hfa3, HFA01 hfa4, HFA01 hfa5, HFA01 hfa6, HFA01 hfa7, HFA01 hfa8, HFA01 hfa9, HFA01 hfa10, HFA01 hfa11, HFA01 hfa12, HFA01 hfa13, HFA01 hfa14, HFA01 hfa15, HFA01 hfa16, HFA01 hfa17, HFA01 hfa18, HFA01 hfa19); -HFADLL_API FLOATTYPE average19_HFA02(HFA02 hfa1, HFA02 hfa2, HFA02 hfa3, HFA02 hfa4, HFA02 hfa5, HFA02 hfa6, HFA02 hfa7, HFA02 hfa8, HFA02 hfa9, HFA02 hfa10, HFA02 hfa11, HFA02 hfa12, HFA02 hfa13, HFA02 hfa14, HFA02 hfa15, HFA02 hfa16, HFA02 hfa17, HFA02 hfa18, HFA02 hfa19); -HFADLL_API FLOATTYPE average19_HFA03(HFA03 hfa1, HFA03 hfa2, HFA03 hfa3, HFA03 hfa4, HFA03 hfa5, HFA03 hfa6, HFA03 hfa7, HFA03 hfa8, HFA03 hfa9, HFA03 hfa10, HFA03 hfa11, HFA03 hfa12, HFA03 hfa13, HFA03 hfa14, HFA03 hfa15, HFA03 hfa16, HFA03 hfa17, HFA03 hfa18, HFA03 hfa19); -HFADLL_API FLOATTYPE average19_HFA05(HFA05 hfa1, HFA05 hfa2, HFA05 hfa3, HFA05 hfa4, HFA05 hfa5, HFA05 hfa6, HFA05 hfa7, HFA05 hfa8, HFA05 hfa9, HFA05 hfa10, HFA05 hfa11, HFA05 hfa12, HFA05 hfa13, HFA05 hfa14, HFA05 hfa15, HFA05 hfa16, HFA05 hfa17, HFA05 hfa18, HFA05 hfa19); -HFADLL_API FLOATTYPE average19_HFA08(HFA08 hfa1, HFA08 hfa2, HFA08 hfa3, HFA08 hfa4, HFA08 hfa5, HFA08 hfa6, HFA08 hfa7, HFA08 hfa8, HFA08 hfa9, HFA08 hfa10, HFA08 hfa11, HFA08 hfa12, HFA08 hfa13, HFA08 hfa14, HFA08 hfa15, HFA08 hfa16, HFA08 hfa17, HFA08 hfa18, HFA08 hfa19); -HFADLL_API FLOATTYPE average19_HFA11(HFA11 hfa1, HFA11 hfa2, HFA11 hfa3, HFA11 hfa4, HFA11 hfa5, HFA11 hfa6, HFA11 hfa7, HFA11 hfa8, HFA11 hfa9, HFA11 hfa10, HFA11 hfa11, HFA11 hfa12, HFA11 hfa13, HFA11 hfa14, HFA11 hfa15, HFA11 hfa16, HFA11 hfa17, HFA11 hfa18, HFA11 hfa19); -HFADLL_API FLOATTYPE average19_HFA19(HFA19 hfa1, HFA19 hfa2, HFA19 hfa3, HFA19 hfa4, HFA19 hfa5, HFA19 hfa6, HFA19 hfa7, HFA19 hfa8, HFA19 hfa9, HFA19 hfa10, HFA19 hfa11, HFA19 hfa12, HFA19 hfa13, HFA19 hfa14, HFA19 hfa15, HFA19 hfa16, HFA19 hfa17, HFA19 hfa18, HFA19 hfa19); +HFADLL_API FLOATTYPE HFADLL_CALLCONV average_HFA01(HFA01 hfa); +HFADLL_API FLOATTYPE HFADLL_CALLCONV average_HFA02(HFA02 hfa); +HFADLL_API FLOATTYPE HFADLL_CALLCONV average_HFA03(HFA03 hfa); +HFADLL_API FLOATTYPE HFADLL_CALLCONV average_HFA05(HFA05 hfa); +HFADLL_API FLOATTYPE HFADLL_CALLCONV average_HFA08(HFA08 hfa); +HFADLL_API FLOATTYPE HFADLL_CALLCONV average_HFA11(HFA11 hfa); +HFADLL_API FLOATTYPE HFADLL_CALLCONV average_HFA19(HFA19 hfa); + +HFADLL_API FLOATTYPE HFADLL_CALLCONV average3_HFA01(HFA01 hfa1, HFA01 hfa2, HFA01 hfa3); +HFADLL_API FLOATTYPE HFADLL_CALLCONV average3_HFA02(HFA02 hfa1, HFA02 hfa2, HFA02 hfa3); +HFADLL_API FLOATTYPE HFADLL_CALLCONV average3_HFA03(HFA03 hfa1, HFA03 hfa2, HFA03 hfa3); +HFADLL_API FLOATTYPE HFADLL_CALLCONV average3_HFA05(HFA05 hfa1, HFA05 hfa2, HFA05 hfa3); +HFADLL_API FLOATTYPE HFADLL_CALLCONV average3_HFA08(HFA08 hfa1, HFA08 hfa2, HFA08 hfa3); +HFADLL_API FLOATTYPE HFADLL_CALLCONV average3_HFA11(HFA11 hfa1, HFA11 hfa2, HFA11 hfa3); +HFADLL_API FLOATTYPE HFADLL_CALLCONV average3_HFA19(HFA19 hfa1, HFA19 hfa2, HFA19 hfa3); + +HFADLL_API FLOATTYPE HFADLL_CALLCONV average5_HFA01(HFA01 hfa1, HFA01 hfa2, HFA01 hfa3, HFA01 hfa4, HFA01 hfa5); +HFADLL_API FLOATTYPE HFADLL_CALLCONV average5_HFA02(HFA02 hfa1, HFA02 hfa2, HFA02 hfa3, HFA02 hfa4, HFA02 hfa5); +HFADLL_API FLOATTYPE HFADLL_CALLCONV average5_HFA03(HFA03 hfa1, HFA03 hfa2, HFA03 hfa3, HFA03 hfa4, HFA03 hfa5); +HFADLL_API FLOATTYPE HFADLL_CALLCONV average5_HFA05(HFA05 hfa1, HFA05 hfa2, HFA05 hfa3, HFA05 hfa4, HFA05 hfa5); +HFADLL_API FLOATTYPE HFADLL_CALLCONV average5_HFA08(HFA08 hfa1, HFA08 hfa2, HFA08 hfa3, HFA08 hfa4, HFA08 hfa5); +HFADLL_API FLOATTYPE HFADLL_CALLCONV average5_HFA11(HFA11 hfa1, HFA11 hfa2, HFA11 hfa3, HFA11 hfa4, HFA11 hfa5); +HFADLL_API FLOATTYPE HFADLL_CALLCONV average5_HFA19(HFA19 hfa1, HFA19 hfa2, HFA19 hfa3, HFA19 hfa4, HFA19 hfa5); + +HFADLL_API FLOATTYPE HFADLL_CALLCONV average8_HFA01(HFA01 hfa1, HFA01 hfa2, HFA01 hfa3, HFA01 hfa4, HFA01 hfa5, HFA01 hfa6, HFA01 hfa7, HFA01 hfa8); +HFADLL_API FLOATTYPE HFADLL_CALLCONV average8_HFA02(HFA02 hfa1, HFA02 hfa2, HFA02 hfa3, HFA02 hfa4, HFA02 hfa5, HFA02 hfa6, HFA02 hfa7, HFA02 hfa8); +HFADLL_API FLOATTYPE HFADLL_CALLCONV average8_HFA03(HFA03 hfa1, HFA03 hfa2, HFA03 hfa3, HFA03 hfa4, HFA03 hfa5, HFA03 hfa6, HFA03 hfa7, HFA03 hfa8); +HFADLL_API FLOATTYPE HFADLL_CALLCONV average8_HFA05(HFA05 hfa1, HFA05 hfa2, HFA05 hfa3, HFA05 hfa4, HFA05 hfa5, HFA05 hfa6, HFA05 hfa7, HFA05 hfa8); +HFADLL_API FLOATTYPE HFADLL_CALLCONV average8_HFA08(HFA08 hfa1, HFA08 hfa2, HFA08 hfa3, HFA08 hfa4, HFA08 hfa5, HFA08 hfa6, HFA08 hfa7, HFA08 hfa8); +HFADLL_API FLOATTYPE HFADLL_CALLCONV average8_HFA11(HFA11 hfa1, HFA11 hfa2, HFA11 hfa3, HFA11 hfa4, HFA11 hfa5, HFA11 hfa6, HFA11 hfa7, HFA11 hfa8); +HFADLL_API FLOATTYPE HFADLL_CALLCONV average8_HFA19(HFA19 hfa1, HFA19 hfa2, HFA19 hfa3, HFA19 hfa4, HFA19 hfa5, HFA19 hfa6, HFA19 hfa7, HFA19 hfa8); + +HFADLL_API FLOATTYPE HFADLL_CALLCONV average11_HFA01(HFA01 hfa1, HFA01 hfa2, HFA01 hfa3, HFA01 hfa4, HFA01 hfa5, HFA01 hfa6, HFA01 hfa7, HFA01 hfa8, HFA01 hfa9, HFA01 hfa10, HFA01 hfa11); +HFADLL_API FLOATTYPE HFADLL_CALLCONV average11_HFA02(HFA02 hfa1, HFA02 hfa2, HFA02 hfa3, HFA02 hfa4, HFA02 hfa5, HFA02 hfa6, HFA02 hfa7, HFA02 hfa8, HFA02 hfa9, HFA02 hfa10, HFA02 hfa11); +HFADLL_API FLOATTYPE HFADLL_CALLCONV average11_HFA03(HFA03 hfa1, HFA03 hfa2, HFA03 hfa3, HFA03 hfa4, HFA03 hfa5, HFA03 hfa6, HFA03 hfa7, HFA03 hfa8, HFA03 hfa9, HFA03 hfa10, HFA03 hfa11); +HFADLL_API FLOATTYPE HFADLL_CALLCONV average11_HFA05(HFA05 hfa1, HFA05 hfa2, HFA05 hfa3, HFA05 hfa4, HFA05 hfa5, HFA05 hfa6, HFA05 hfa7, HFA05 hfa8, HFA05 hfa9, HFA05 hfa10, HFA05 hfa11); +HFADLL_API FLOATTYPE HFADLL_CALLCONV average11_HFA08(HFA08 hfa1, HFA08 hfa2, HFA08 hfa3, HFA08 hfa4, HFA08 hfa5, HFA08 hfa6, HFA08 hfa7, HFA08 hfa8, HFA08 hfa9, HFA08 hfa10, HFA08 hfa11); +HFADLL_API FLOATTYPE HFADLL_CALLCONV average11_HFA11(HFA11 hfa1, HFA11 hfa2, HFA11 hfa3, HFA11 hfa4, HFA11 hfa5, HFA11 hfa6, HFA11 hfa7, HFA11 hfa8, HFA11 hfa9, HFA11 hfa10, HFA11 hfa11); +HFADLL_API FLOATTYPE HFADLL_CALLCONV average11_HFA19(HFA19 hfa1, HFA19 hfa2, HFA19 hfa3, HFA19 hfa4, HFA19 hfa5, HFA19 hfa6, HFA19 hfa7, HFA19 hfa8, HFA19 hfa9, HFA19 hfa10, HFA19 hfa11); + +HFADLL_API FLOATTYPE HFADLL_CALLCONV average19_HFA01(HFA01 hfa1, HFA01 hfa2, HFA01 hfa3, HFA01 hfa4, HFA01 hfa5, HFA01 hfa6, HFA01 hfa7, HFA01 hfa8, HFA01 hfa9, HFA01 hfa10, HFA01 hfa11, HFA01 hfa12, HFA01 hfa13, HFA01 hfa14, HFA01 hfa15, HFA01 hfa16, HFA01 hfa17, HFA01 hfa18, HFA01 hfa19); +HFADLL_API FLOATTYPE HFADLL_CALLCONV average19_HFA02(HFA02 hfa1, HFA02 hfa2, HFA02 hfa3, HFA02 hfa4, HFA02 hfa5, HFA02 hfa6, HFA02 hfa7, HFA02 hfa8, HFA02 hfa9, HFA02 hfa10, HFA02 hfa11, HFA02 hfa12, HFA02 hfa13, HFA02 hfa14, HFA02 hfa15, HFA02 hfa16, HFA02 hfa17, HFA02 hfa18, HFA02 hfa19); +HFADLL_API FLOATTYPE HFADLL_CALLCONV average19_HFA03(HFA03 hfa1, HFA03 hfa2, HFA03 hfa3, HFA03 hfa4, HFA03 hfa5, HFA03 hfa6, HFA03 hfa7, HFA03 hfa8, HFA03 hfa9, HFA03 hfa10, HFA03 hfa11, HFA03 hfa12, HFA03 hfa13, HFA03 hfa14, HFA03 hfa15, HFA03 hfa16, HFA03 hfa17, HFA03 hfa18, HFA03 hfa19); +HFADLL_API FLOATTYPE HFADLL_CALLCONV average19_HFA05(HFA05 hfa1, HFA05 hfa2, HFA05 hfa3, HFA05 hfa4, HFA05 hfa5, HFA05 hfa6, HFA05 hfa7, HFA05 hfa8, HFA05 hfa9, HFA05 hfa10, HFA05 hfa11, HFA05 hfa12, HFA05 hfa13, HFA05 hfa14, HFA05 hfa15, HFA05 hfa16, HFA05 hfa17, HFA05 hfa18, HFA05 hfa19); +HFADLL_API FLOATTYPE HFADLL_CALLCONV average19_HFA08(HFA08 hfa1, HFA08 hfa2, HFA08 hfa3, HFA08 hfa4, HFA08 hfa5, HFA08 hfa6, HFA08 hfa7, HFA08 hfa8, HFA08 hfa9, HFA08 hfa10, HFA08 hfa11, HFA08 hfa12, HFA08 hfa13, HFA08 hfa14, HFA08 hfa15, HFA08 hfa16, HFA08 hfa17, HFA08 hfa18, HFA08 hfa19); +HFADLL_API FLOATTYPE HFADLL_CALLCONV average19_HFA11(HFA11 hfa1, HFA11 hfa2, HFA11 hfa3, HFA11 hfa4, HFA11 hfa5, HFA11 hfa6, HFA11 hfa7, HFA11 hfa8, HFA11 hfa9, HFA11 hfa10, HFA11 hfa11, HFA11 hfa12, HFA11 hfa13, HFA11 hfa14, HFA11 hfa15, HFA11 hfa16, HFA11 hfa17, HFA11 hfa18, HFA11 hfa19); +HFADLL_API FLOATTYPE HFADLL_CALLCONV average19_HFA19(HFA19 hfa1, HFA19 hfa2, HFA19 hfa3, HFA19 hfa4, HFA19 hfa5, HFA19 hfa6, HFA19 hfa7, HFA19 hfa8, HFA19 hfa9, HFA19 hfa10, HFA19 hfa11, HFA19 hfa12, HFA19 hfa13, HFA19 hfa14, HFA19 hfa15, HFA19 hfa16, HFA19 hfa17, HFA19 hfa18, HFA19 hfa19); @@ -267,29 +276,29 @@ HFADLL_API FLOATTYPE average19_HFA19(HFA19 hfa1, HFA19 hfa2, HFA19 hfa3, HFA19 // add Methods // --------------------------------------------------- -HFADLL_API FLOATTYPE add01_HFA01(HFA01 hfa1, float v1, HFA01 hfa2, int v2, HFA01 hfa3, short v3, double v4, HFA01 hfa4, HFA01 hfa5, float v5, __int64 v6, float v7, HFA01 hfa6, float v8, HFA01 hfa7); -HFADLL_API FLOATTYPE add01_HFA02(HFA02 hfa1, float v1, HFA02 hfa2, int v2, HFA02 hfa3, short v3, double v4, HFA02 hfa4, HFA02 hfa5, float v5, __int64 v6, float v7, HFA02 hfa6, float v8, HFA02 hfa7); -HFADLL_API FLOATTYPE add01_HFA03(HFA03 hfa1, float v1, HFA03 hfa2, int v2, HFA03 hfa3, short v3, double v4, HFA03 hfa4, HFA03 hfa5, float v5, __int64 v6, float v7, HFA03 hfa6, float v8, HFA03 hfa7); -HFADLL_API FLOATTYPE add01_HFA05(HFA05 hfa1, float v1, HFA05 hfa2, int v2, HFA05 hfa3, short v3, double v4, HFA05 hfa4, HFA05 hfa5, float v5, __int64 v6, float v7, HFA05 hfa6, float v8, HFA05 hfa7); -HFADLL_API FLOATTYPE add01_HFA08(HFA08 hfa1, float v1, HFA08 hfa2, int v2, HFA08 hfa3, short v3, double v4, HFA08 hfa4, HFA08 hfa5, float v5, __int64 v6, float v7, HFA08 hfa6, float v8, HFA08 hfa7); -HFADLL_API FLOATTYPE add01_HFA11(HFA11 hfa1, float v1, HFA11 hfa2, int v2, HFA11 hfa3, short v3, double v4, HFA11 hfa4, HFA11 hfa5, float v5, __int64 v6, float v7, HFA11 hfa6, float v8, HFA11 hfa7); -HFADLL_API FLOATTYPE add01_HFA19(HFA19 hfa1, float v1, HFA19 hfa2, int v2, HFA19 hfa3, short v3, double v4, HFA19 hfa4, HFA19 hfa5, float v5, __int64 v6, float v7, HFA19 hfa6, float v8, HFA19 hfa7); -HFADLL_API FLOATTYPE add01_HFA00(HFA03 hfa1, float v1, HFA02 hfa2, int v2, HFA19 hfa3, short v3, double v4, HFA05 hfa4, HFA08 hfa5, float v5, __int64 v6, float v7, HFA11 hfa6, float v8, HFA01 hfa7); - -HFADLL_API FLOATTYPE add02_HFA01(HFA01 hfa1, HFA01 hfa2, __int64 v1, short v2, float v3, int v4, double v5, float v6, HFA01 hfa3, double v7, float v8, HFA01 hfa4, short v9, HFA01 hfa5, float v10, HFA01 hfa6, HFA01 hfa7); -HFADLL_API FLOATTYPE add02_HFA02(HFA02 hfa1, HFA02 hfa2, __int64 v1, short v2, float v3, int v4, double v5, float v6, HFA02 hfa3, double v7, float v8, HFA02 hfa4, short v9, HFA02 hfa5, float v10, HFA02 hfa6, HFA02 hfa7); -HFADLL_API FLOATTYPE add02_HFA03(HFA03 hfa1, HFA03 hfa2, __int64 v1, short v2, float v3, int v4, double v5, float v6, HFA03 hfa3, double v7, float v8, HFA03 hfa4, short v9, HFA03 hfa5, float v10, HFA03 hfa6, HFA03 hfa7); -HFADLL_API FLOATTYPE add02_HFA05(HFA05 hfa1, HFA05 hfa2, __int64 v1, short v2, float v3, int v4, double v5, float v6, HFA05 hfa3, double v7, float v8, HFA05 hfa4, short v9, HFA05 hfa5, float v10, HFA05 hfa6, HFA05 hfa7); -HFADLL_API FLOATTYPE add02_HFA08(HFA08 hfa1, HFA08 hfa2, __int64 v1, short v2, float v3, int v4, double v5, float v6, HFA08 hfa3, double v7, float v8, HFA08 hfa4, short v9, HFA08 hfa5, float v10, HFA08 hfa6, HFA08 hfa7); -HFADLL_API FLOATTYPE add02_HFA11(HFA11 hfa1, HFA11 hfa2, __int64 v1, short v2, float v3, int v4, double v5, float v6, HFA11 hfa3, double v7, float v8, HFA11 hfa4, short v9, HFA11 hfa5, float v10, HFA11 hfa6, HFA11 hfa7); -HFADLL_API FLOATTYPE add02_HFA19(HFA19 hfa1, HFA19 hfa2, __int64 v1, short v2, float v3, int v4, double v5, float v6, HFA19 hfa3, double v7, float v8, HFA19 hfa4, short v9, HFA19 hfa5, float v10, HFA19 hfa6, HFA19 hfa7); -HFADLL_API FLOATTYPE add02_HFA00(HFA01 hfa1, HFA05 hfa2, __int64 v1, short v2, float v3, int v4, double v5, float v6, HFA03 hfa3, double v7, float v8, HFA11 hfa4, short v9, HFA19 hfa5, float v10, HFA08 hfa6, HFA02 hfa7); - -HFADLL_API FLOATTYPE add03_HFA01(float v1, signed char v2, HFA01 hfa1, double v3, signed char v4, HFA01 hfa2, __int64 v5, short v6, int v7, HFA01 hfa3, HFA01 hfa4, float v8, HFA01 hfa5, float v9, HFA01 hfa6, float v10, HFA01 hfa7); -HFADLL_API FLOATTYPE add03_HFA02(float v1, signed char v2, HFA02 hfa1, double v3, signed char v4, HFA02 hfa2, __int64 v5, short v6, int v7, HFA02 hfa3, HFA02 hfa4, float v8, HFA02 hfa5, float v9, HFA02 hfa6, float v10, HFA02 hfa7); -HFADLL_API FLOATTYPE add03_HFA03(float v1, signed char v2, HFA03 hfa1, double v3, signed char v4, HFA03 hfa2, __int64 v5, short v6, int v7, HFA03 hfa3, HFA03 hfa4, float v8, HFA03 hfa5, float v9, HFA03 hfa6, float v10, HFA03 hfa7); -HFADLL_API FLOATTYPE add03_HFA05(float v1, signed char v2, HFA05 hfa1, double v3, signed char v4, HFA05 hfa2, __int64 v5, short v6, int v7, HFA05 hfa3, HFA05 hfa4, float v8, HFA05 hfa5, float v9, HFA05 hfa6, float v10, HFA05 hfa7); -HFADLL_API FLOATTYPE add03_HFA08(float v1, signed char v2, HFA08 hfa1, double v3, signed char v4, HFA08 hfa2, __int64 v5, short v6, int v7, HFA08 hfa3, HFA08 hfa4, float v8, HFA08 hfa5, float v9, HFA08 hfa6, float v10, HFA08 hfa7); -HFADLL_API FLOATTYPE add03_HFA11(float v1, signed char v2, HFA11 hfa1, double v3, signed char v4, HFA11 hfa2, __int64 v5, short v6, int v7, HFA11 hfa3, HFA11 hfa4, float v8, HFA11 hfa5, float v9, HFA11 hfa6, float v10, HFA11 hfa7); -HFADLL_API FLOATTYPE add03_HFA19(float v1, signed char v2, HFA19 hfa1, double v3, signed char v4, HFA19 hfa2, __int64 v5, short v6, int v7, HFA19 hfa3, HFA19 hfa4, float v8, HFA19 hfa5, float v9, HFA19 hfa6, float v10, HFA19 hfa7); -HFADLL_API FLOATTYPE add03_HFA00(float v1, signed char v2, HFA08 hfa1, double v3, signed char v4, HFA19 hfa2, __int64 v5, short v6, int v7, HFA03 hfa3, HFA01 hfa4, float v8, HFA11 hfa5, float v9, HFA02 hfa6, float v10, HFA05 hfa7); +HFADLL_API FLOATTYPE HFADLL_CALLCONV add01_HFA01(HFA01 hfa1, float v1, HFA01 hfa2, int v2, HFA01 hfa3, short v3, double v4, HFA01 hfa4, HFA01 hfa5, float v5, __int64 v6, float v7, HFA01 hfa6, float v8, HFA01 hfa7); +HFADLL_API FLOATTYPE HFADLL_CALLCONV add01_HFA02(HFA02 hfa1, float v1, HFA02 hfa2, int v2, HFA02 hfa3, short v3, double v4, HFA02 hfa4, HFA02 hfa5, float v5, __int64 v6, float v7, HFA02 hfa6, float v8, HFA02 hfa7); +HFADLL_API FLOATTYPE HFADLL_CALLCONV add01_HFA03(HFA03 hfa1, float v1, HFA03 hfa2, int v2, HFA03 hfa3, short v3, double v4, HFA03 hfa4, HFA03 hfa5, float v5, __int64 v6, float v7, HFA03 hfa6, float v8, HFA03 hfa7); +HFADLL_API FLOATTYPE HFADLL_CALLCONV add01_HFA05(HFA05 hfa1, float v1, HFA05 hfa2, int v2, HFA05 hfa3, short v3, double v4, HFA05 hfa4, HFA05 hfa5, float v5, __int64 v6, float v7, HFA05 hfa6, float v8, HFA05 hfa7); +HFADLL_API FLOATTYPE HFADLL_CALLCONV add01_HFA08(HFA08 hfa1, float v1, HFA08 hfa2, int v2, HFA08 hfa3, short v3, double v4, HFA08 hfa4, HFA08 hfa5, float v5, __int64 v6, float v7, HFA08 hfa6, float v8, HFA08 hfa7); +HFADLL_API FLOATTYPE HFADLL_CALLCONV add01_HFA11(HFA11 hfa1, float v1, HFA11 hfa2, int v2, HFA11 hfa3, short v3, double v4, HFA11 hfa4, HFA11 hfa5, float v5, __int64 v6, float v7, HFA11 hfa6, float v8, HFA11 hfa7); +HFADLL_API FLOATTYPE HFADLL_CALLCONV add01_HFA19(HFA19 hfa1, float v1, HFA19 hfa2, int v2, HFA19 hfa3, short v3, double v4, HFA19 hfa4, HFA19 hfa5, float v5, __int64 v6, float v7, HFA19 hfa6, float v8, HFA19 hfa7); +HFADLL_API FLOATTYPE HFADLL_CALLCONV add01_HFA00(HFA03 hfa1, float v1, HFA02 hfa2, int v2, HFA19 hfa3, short v3, double v4, HFA05 hfa4, HFA08 hfa5, float v5, __int64 v6, float v7, HFA11 hfa6, float v8, HFA01 hfa7); + +HFADLL_API FLOATTYPE HFADLL_CALLCONV add02_HFA01(HFA01 hfa1, HFA01 hfa2, __int64 v1, short v2, float v3, int v4, double v5, float v6, HFA01 hfa3, double v7, float v8, HFA01 hfa4, short v9, HFA01 hfa5, float v10, HFA01 hfa6, HFA01 hfa7); +HFADLL_API FLOATTYPE HFADLL_CALLCONV add02_HFA02(HFA02 hfa1, HFA02 hfa2, __int64 v1, short v2, float v3, int v4, double v5, float v6, HFA02 hfa3, double v7, float v8, HFA02 hfa4, short v9, HFA02 hfa5, float v10, HFA02 hfa6, HFA02 hfa7); +HFADLL_API FLOATTYPE HFADLL_CALLCONV add02_HFA03(HFA03 hfa1, HFA03 hfa2, __int64 v1, short v2, float v3, int v4, double v5, float v6, HFA03 hfa3, double v7, float v8, HFA03 hfa4, short v9, HFA03 hfa5, float v10, HFA03 hfa6, HFA03 hfa7); +HFADLL_API FLOATTYPE HFADLL_CALLCONV add02_HFA05(HFA05 hfa1, HFA05 hfa2, __int64 v1, short v2, float v3, int v4, double v5, float v6, HFA05 hfa3, double v7, float v8, HFA05 hfa4, short v9, HFA05 hfa5, float v10, HFA05 hfa6, HFA05 hfa7); +HFADLL_API FLOATTYPE HFADLL_CALLCONV add02_HFA08(HFA08 hfa1, HFA08 hfa2, __int64 v1, short v2, float v3, int v4, double v5, float v6, HFA08 hfa3, double v7, float v8, HFA08 hfa4, short v9, HFA08 hfa5, float v10, HFA08 hfa6, HFA08 hfa7); +HFADLL_API FLOATTYPE HFADLL_CALLCONV add02_HFA11(HFA11 hfa1, HFA11 hfa2, __int64 v1, short v2, float v3, int v4, double v5, float v6, HFA11 hfa3, double v7, float v8, HFA11 hfa4, short v9, HFA11 hfa5, float v10, HFA11 hfa6, HFA11 hfa7); +HFADLL_API FLOATTYPE HFADLL_CALLCONV add02_HFA19(HFA19 hfa1, HFA19 hfa2, __int64 v1, short v2, float v3, int v4, double v5, float v6, HFA19 hfa3, double v7, float v8, HFA19 hfa4, short v9, HFA19 hfa5, float v10, HFA19 hfa6, HFA19 hfa7); +HFADLL_API FLOATTYPE HFADLL_CALLCONV add02_HFA00(HFA01 hfa1, HFA05 hfa2, __int64 v1, short v2, float v3, int v4, double v5, float v6, HFA03 hfa3, double v7, float v8, HFA11 hfa4, short v9, HFA19 hfa5, float v10, HFA08 hfa6, HFA02 hfa7); + +HFADLL_API FLOATTYPE HFADLL_CALLCONV add03_HFA01(float v1, signed char v2, HFA01 hfa1, double v3, signed char v4, HFA01 hfa2, __int64 v5, short v6, int v7, HFA01 hfa3, HFA01 hfa4, float v8, HFA01 hfa5, float v9, HFA01 hfa6, float v10, HFA01 hfa7); +HFADLL_API FLOATTYPE HFADLL_CALLCONV add03_HFA02(float v1, signed char v2, HFA02 hfa1, double v3, signed char v4, HFA02 hfa2, __int64 v5, short v6, int v7, HFA02 hfa3, HFA02 hfa4, float v8, HFA02 hfa5, float v9, HFA02 hfa6, float v10, HFA02 hfa7); +HFADLL_API FLOATTYPE HFADLL_CALLCONV add03_HFA03(float v1, signed char v2, HFA03 hfa1, double v3, signed char v4, HFA03 hfa2, __int64 v5, short v6, int v7, HFA03 hfa3, HFA03 hfa4, float v8, HFA03 hfa5, float v9, HFA03 hfa6, float v10, HFA03 hfa7); +HFADLL_API FLOATTYPE HFADLL_CALLCONV add03_HFA05(float v1, signed char v2, HFA05 hfa1, double v3, signed char v4, HFA05 hfa2, __int64 v5, short v6, int v7, HFA05 hfa3, HFA05 hfa4, float v8, HFA05 hfa5, float v9, HFA05 hfa6, float v10, HFA05 hfa7); +HFADLL_API FLOATTYPE HFADLL_CALLCONV add03_HFA08(float v1, signed char v2, HFA08 hfa1, double v3, signed char v4, HFA08 hfa2, __int64 v5, short v6, int v7, HFA08 hfa3, HFA08 hfa4, float v8, HFA08 hfa5, float v9, HFA08 hfa6, float v10, HFA08 hfa7); +HFADLL_API FLOATTYPE HFADLL_CALLCONV add03_HFA11(float v1, signed char v2, HFA11 hfa1, double v3, signed char v4, HFA11 hfa2, __int64 v5, short v6, int v7, HFA11 hfa3, HFA11 hfa4, float v8, HFA11 hfa5, float v9, HFA11 hfa6, float v10, HFA11 hfa7); +HFADLL_API FLOATTYPE HFADLL_CALLCONV add03_HFA19(float v1, signed char v2, HFA19 hfa1, double v3, signed char v4, HFA19 hfa2, __int64 v5, short v6, int v7, HFA19 hfa3, HFA19 hfa4, float v8, HFA19 hfa5, float v9, HFA19 hfa6, float v10, HFA19 hfa7); +HFADLL_API FLOATTYPE HFADLL_CALLCONV add03_HFA00(float v1, signed char v2, HFA08 hfa1, double v3, signed char v4, HFA19 hfa2, __int64 v5, short v6, int v7, HFA03 hfa3, HFA01 hfa4, float v8, HFA11 hfa5, float v9, HFA02 hfa6, float v10, HFA05 hfa7); |