maxmustermann/dotnet-core
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
dotnet-core/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Runtime.Intrinsics.Arm.Arm64.md
Ahson Khan e6b9c28c28
Add API diff between .NET Core 2.2 and .NET Core 3.0 preview1. (#2256) 
* Add API diff between .NET Core 2.2 and .NET Core 3.0 preview1.

* Only compare ref assemblies within M.NetCore.App rather than all impl
assemblies from the repo.

* Remove Microsoft.* namespaces and update heading.
2019-01-28 21:02:57 -08:00

14 KiB
Raw Blame History

System.Runtime.Intrinsics.Arm.Arm64

+namespace System.Runtime.Intrinsics.Arm.Arm64 {
+    public static class Aes {
+        public static bool IsSupported { get; }
+        public static Vector128<byte> Decrypt(Vector128<byte> value, Vector128<byte> roundKey);
+        public static Vector128<byte> Encrypt(Vector128<byte> value, Vector128<byte> roundKey);
+        public static Vector128<byte> InverseMixColumns(Vector128<byte> value);
+        public static Vector128<byte> MixColumns(Vector128<byte> value);
+    }
+    public static class Base {
+        public static bool IsSupported { get; }
+        public static int LeadingSignCount(int value);
+        public static int LeadingSignCount(long value);
+        public static int LeadingZeroCount(int value);
+        public static int LeadingZeroCount(long value);
+        public static int LeadingZeroCount(uint value);
+        public static int LeadingZeroCount(ulong value);
+    }
+    public static class Sha1 {
+        public static bool IsSupported { get; }
+        public static uint FixedRotate(uint hash_e);
+        public static Vector128<uint> HashChoose(Vector128<uint> hash_abcd, uint hash_e, Vector128<uint> wk);
+        public static Vector128<uint> HashMajority(Vector128<uint> hash_abcd, uint hash_e, Vector128<uint> wk);
+        public static Vector128<uint> HashParity(Vector128<uint> hash_abcd, uint hash_e, Vector128<uint> wk);
+        public static Vector128<uint> SchedulePart1(Vector128<uint> w0_3, Vector128<uint> w4_7, Vector128<uint> w8_11);
+        public static Vector128<uint> SchedulePart2(Vector128<uint> tw0_3, Vector128<uint> w12_15);
+    }
+    public static class Sha256 {
+        public static bool IsSupported { get; }
+        public static Vector128<uint> HashLower(Vector128<uint> hash_abcd, Vector128<uint> hash_efgh, Vector128<uint> wk);
+        public static Vector128<uint> HashUpper(Vector128<uint> hash_efgh, Vector128<uint> hash_abcd, Vector128<uint> wk);
+        public static Vector128<uint> SchedulePart1(Vector128<uint> w0_3, Vector128<uint> w4_7);
+        public static Vector128<uint> SchedulePart2(Vector128<uint> w0_3, Vector128<uint> w8_11, Vector128<uint> w12_15);
+    }
+    public static class Simd {
+        public static bool IsSupported { get; }
+        public static Vector128<double> Abs(Vector128<double> value);
+        public static Vector128<ushort> Abs(Vector128<short> value);
+        public static Vector128<uint> Abs(Vector128<int> value);
+        public static Vector128<ulong> Abs(Vector128<long> value);
+        public static Vector128<byte> Abs(Vector128<sbyte> value);
+        public static Vector128<float> Abs(Vector128<float> value);
+        public static Vector64<ushort> Abs(Vector64<short> value);
+        public static Vector64<uint> Abs(Vector64<int> value);
+        public static Vector64<byte> Abs(Vector64<sbyte> value);
+        public static Vector64<float> Abs(Vector64<float> value);
+        public static Vector128<T> Add<T>(Vector128<T> left, Vector128<T> right) where T : struct;
+        public static Vector64<T> Add<T>(Vector64<T> left, Vector64<T> right) where T : struct;
+        public static Vector128<T> And<T>(Vector128<T> left, Vector128<T> right) where T : struct;
+        public static Vector64<T> And<T>(Vector64<T> left, Vector64<T> right) where T : struct;
+        public static Vector128<T> AndNot<T>(Vector128<T> left, Vector128<T> right) where T : struct;
+        public static Vector64<T> AndNot<T>(Vector64<T> left, Vector64<T> right) where T : struct;
+        public static Vector128<T> BitwiseSelect<T>(Vector128<T> sel, Vector128<T> left, Vector128<T> right) where T : struct;
+        public static Vector64<T> BitwiseSelect<T>(Vector64<T> sel, Vector64<T> left, Vector64<T> right) where T : struct;
+        public static Vector128<T> CompareEqual<T>(Vector128<T> left, Vector128<T> right) where T : struct;
+        public static Vector64<T> CompareEqual<T>(Vector64<T> left, Vector64<T> right) where T : struct;
+        public static Vector128<T> CompareEqualZero<T>(Vector128<T> value) where T : struct;
+        public static Vector64<T> CompareEqualZero<T>(Vector64<T> value) where T : struct;
+        public static Vector128<T> CompareGreaterThan<T>(Vector128<T> left, Vector128<T> right) where T : struct;
+        public static Vector64<T> CompareGreaterThan<T>(Vector64<T> left, Vector64<T> right) where T : struct;
+        public static Vector128<T> CompareGreaterThanOrEqual<T>(Vector128<T> left, Vector128<T> right) where T : struct;
+        public static Vector64<T> CompareGreaterThanOrEqual<T>(Vector64<T> left, Vector64<T> right) where T : struct;
+        public static Vector128<T> CompareGreaterThanOrEqualZero<T>(Vector128<T> value) where T : struct;
+        public static Vector64<T> CompareGreaterThanOrEqualZero<T>(Vector64<T> value) where T : struct;
+        public static Vector128<T> CompareGreaterThanZero<T>(Vector128<T> value) where T : struct;
+        public static Vector64<T> CompareGreaterThanZero<T>(Vector64<T> value) where T : struct;
+        public static Vector128<T> CompareLessThanOrEqualZero<T>(Vector128<T> value) where T : struct;
+        public static Vector64<T> CompareLessThanOrEqualZero<T>(Vector64<T> value) where T : struct;
+        public static Vector128<T> CompareLessThanZero<T>(Vector128<T> value) where T : struct;
+        public static Vector64<T> CompareLessThanZero<T>(Vector64<T> value) where T : struct;
+        public static Vector128<T> CompareTest<T>(Vector128<T> left, Vector128<T> right) where T : struct;
+        public static Vector64<T> CompareTest<T>(Vector64<T> left, Vector64<T> right) where T : struct;
+        public static Vector128<double> Divide(Vector128<double> left, Vector128<double> right);
+        public static Vector128<float> Divide(Vector128<float> left, Vector128<float> right);
+        public static Vector64<float> Divide(Vector64<float> left, Vector64<float> right);
+        public static T Extract<T>(Vector128<T> vector, byte index) where T : struct;
+        public static T Extract<T>(Vector64<T> vector, byte index) where T : struct;
+        public static Vector128<T> Insert<T>(Vector128<T> vector, byte index, T data) where T : struct;
+        public static Vector64<T> Insert<T>(Vector64<T> vector, byte index, T data) where T : struct;
+        public static Vector128<short> LeadingSignCount(Vector128<short> value);
+        public static Vector128<int> LeadingSignCount(Vector128<int> value);
+        public static Vector128<sbyte> LeadingSignCount(Vector128<sbyte> value);
+        public static Vector64<short> LeadingSignCount(Vector64<short> value);
+        public static Vector64<int> LeadingSignCount(Vector64<int> value);
+        public static Vector64<sbyte> LeadingSignCount(Vector64<sbyte> value);
+        public static Vector128<byte> LeadingZeroCount(Vector128<byte> value);
+        public static Vector128<short> LeadingZeroCount(Vector128<short> value);
+        public static Vector128<int> LeadingZeroCount(Vector128<int> value);
+        public static Vector128<sbyte> LeadingZeroCount(Vector128<sbyte> value);
+        public static Vector128<ushort> LeadingZeroCount(Vector128<ushort> value);
+        public static Vector128<uint> LeadingZeroCount(Vector128<uint> value);
+        public static Vector64<byte> LeadingZeroCount(Vector64<byte> value);
+        public static Vector64<short> LeadingZeroCount(Vector64<short> value);
+        public static Vector64<int> LeadingZeroCount(Vector64<int> value);
+        public static Vector64<sbyte> LeadingZeroCount(Vector64<sbyte> value);
+        public static Vector64<ushort> LeadingZeroCount(Vector64<ushort> value);
+        public static Vector64<uint> LeadingZeroCount(Vector64<uint> value);
+        public static Vector128<byte> Max(Vector128<byte> left, Vector128<byte> right);
+        public static Vector128<double> Max(Vector128<double> left, Vector128<double> right);
+        public static Vector128<short> Max(Vector128<short> left, Vector128<short> right);
+        public static Vector128<int> Max(Vector128<int> left, Vector128<int> right);
+        public static Vector128<sbyte> Max(Vector128<sbyte> left, Vector128<sbyte> right);
+        public static Vector128<float> Max(Vector128<float> left, Vector128<float> right);
+        public static Vector128<ushort> Max(Vector128<ushort> left, Vector128<ushort> right);
+        public static Vector128<uint> Max(Vector128<uint> left, Vector128<uint> right);
+        public static Vector64<byte> Max(Vector64<byte> left, Vector64<byte> right);
+        public static Vector64<short> Max(Vector64<short> left, Vector64<short> right);
+        public static Vector64<int> Max(Vector64<int> left, Vector64<int> right);
+        public static Vector64<sbyte> Max(Vector64<sbyte> left, Vector64<sbyte> right);
+        public static Vector64<float> Max(Vector64<float> left, Vector64<float> right);
+        public static Vector64<ushort> Max(Vector64<ushort> left, Vector64<ushort> right);
+        public static Vector64<uint> Max(Vector64<uint> left, Vector64<uint> right);
+        public static Vector128<byte> Min(Vector128<byte> left, Vector128<byte> right);
+        public static Vector128<double> Min(Vector128<double> left, Vector128<double> right);
+        public static Vector128<short> Min(Vector128<short> left, Vector128<short> right);
+        public static Vector128<int> Min(Vector128<int> left, Vector128<int> right);
+        public static Vector128<sbyte> Min(Vector128<sbyte> left, Vector128<sbyte> right);
+        public static Vector128<float> Min(Vector128<float> left, Vector128<float> right);
+        public static Vector128<ushort> Min(Vector128<ushort> left, Vector128<ushort> right);
+        public static Vector128<uint> Min(Vector128<uint> left, Vector128<uint> right);
+        public static Vector64<byte> Min(Vector64<byte> left, Vector64<byte> right);
+        public static Vector64<short> Min(Vector64<short> left, Vector64<short> right);
+        public static Vector64<int> Min(Vector64<int> left, Vector64<int> right);
+        public static Vector64<sbyte> Min(Vector64<sbyte> left, Vector64<sbyte> right);
+        public static Vector64<float> Min(Vector64<float> left, Vector64<float> right);
+        public static Vector64<ushort> Min(Vector64<ushort> left, Vector64<ushort> right);
+        public static Vector64<uint> Min(Vector64<uint> left, Vector64<uint> right);
+        public static Vector128<byte> Multiply(Vector128<byte> left, Vector128<byte> right);
+        public static Vector128<double> Multiply(Vector128<double> left, Vector128<double> right);
+        public static Vector128<short> Multiply(Vector128<short> left, Vector128<short> right);
+        public static Vector128<int> Multiply(Vector128<int> left, Vector128<int> right);
+        public static Vector128<sbyte> Multiply(Vector128<sbyte> left, Vector128<sbyte> right);
+        public static Vector128<float> Multiply(Vector128<float> left, Vector128<float> right);
+        public static Vector128<ushort> Multiply(Vector128<ushort> left, Vector128<ushort> right);
+        public static Vector128<uint> Multiply(Vector128<uint> left, Vector128<uint> right);
+        public static Vector64<byte> Multiply(Vector64<byte> left, Vector64<byte> right);
+        public static Vector64<short> Multiply(Vector64<short> left, Vector64<short> right);
+        public static Vector64<int> Multiply(Vector64<int> left, Vector64<int> right);
+        public static Vector64<sbyte> Multiply(Vector64<sbyte> left, Vector64<sbyte> right);
+        public static Vector64<float> Multiply(Vector64<float> left, Vector64<float> right);
+        public static Vector64<ushort> Multiply(Vector64<ushort> left, Vector64<ushort> right);
+        public static Vector64<uint> Multiply(Vector64<uint> left, Vector64<uint> right);
+        public static Vector128<double> Negate(Vector128<double> value);
+        public static Vector128<short> Negate(Vector128<short> value);
+        public static Vector128<int> Negate(Vector128<int> value);
+        public static Vector128<long> Negate(Vector128<long> value);
+        public static Vector128<sbyte> Negate(Vector128<sbyte> value);
+        public static Vector128<float> Negate(Vector128<float> value);
+        public static Vector64<short> Negate(Vector64<short> value);
+        public static Vector64<int> Negate(Vector64<int> value);
+        public static Vector64<sbyte> Negate(Vector64<sbyte> value);
+        public static Vector64<float> Negate(Vector64<float> value);
+        public static Vector128<T> Not<T>(Vector128<T> value) where T : struct;
+        public static Vector64<T> Not<T>(Vector64<T> value) where T : struct;
+        public static Vector128<T> Or<T>(Vector128<T> left, Vector128<T> right) where T : struct;
+        public static Vector64<T> Or<T>(Vector64<T> left, Vector64<T> right) where T : struct;
+        public static Vector128<T> OrNot<T>(Vector128<T> left, Vector128<T> right) where T : struct;
+        public static Vector64<T> OrNot<T>(Vector64<T> left, Vector64<T> right) where T : struct;
+        public static Vector128<byte> PopCount(Vector128<byte> value);
+        public static Vector128<sbyte> PopCount(Vector128<sbyte> value);
+        public static Vector64<byte> PopCount(Vector64<byte> value);
+        public static Vector64<sbyte> PopCount(Vector64<sbyte> value);
+        public static Vector128<T> SetAllVector128<T>(T value) where T : struct;
+        public static Vector64<T> SetAllVector64<T>(T value) where T : struct;
+        public static Vector128<double> Sqrt(Vector128<double> value);
+        public static Vector128<float> Sqrt(Vector128<float> value);
+        public static Vector64<float> Sqrt(Vector64<float> value);
+        public static Vector128<T> Subtract<T>(Vector128<T> left, Vector128<T> right) where T : struct;
+        public static Vector64<T> Subtract<T>(Vector64<T> left, Vector64<T> right) where T : struct;
+        public static Vector128<T> Xor<T>(Vector128<T> left, Vector128<T> right) where T : struct;
+        public static Vector64<T> Xor<T>(Vector64<T> left, Vector64<T> right) where T : struct;
+    }
+}