API Proposal: More SIMD HW Intrinsics

[sdmaclea]

@tannergooding: Updated according to match https://github.com/dotnet/corefx/issues/26581#issuecomment-539217015. Previous version is available in comment history.

namespace System.Runtime.Intrinsics.Arm
{
    public static class AdvSimd
    {
        public static bool IsSupported { get { throw null; } }

        /// <summary>
        /// Vector CompareGreaterThanOrEqual
        /// For each element result[elem] = (|left[elem]| >= |right[elem]|) ? ~0 : 0
        /// Corresponds to vector forms of ARM64 FACGE
        /// </summary>
        public static Vector64<float>   AbsoluteCompareGreaterThanOrEqual(Vector64<float>   left, Vector64<float>   right) { throw null; }
        public static Vector128<float>  AbsoluteCompareGreaterThanOrEqual(Vector128<float>  left, Vector128<float>  right) { throw null; }

        /// <summary>
        /// Vector CompareGreaterThan
        ///
        /// For each element result[elem] = (|left[elem]| > |right[elem]|) ? ~0 : 0
        ///
        /// Corresponds to vector forms of ARM64 FACGT
        /// </summary>
        public static Vector64<float>   AbsoluteCompareGreaterThan(Vector64<float>   left, Vector64<float>   right) { throw null; }
        public static Vector128<float>  AbsoluteCompareGreaterThan(Vector128<float>  left, Vector128<float>  right) { throw null; }

        /// <summary>
        /// Vector absolute difference
        /// Corresponds to vector forms of ARM64 SABD, UABD & FABD
        /// </summary>
        public static Vector64<byte>    AbsoluteDifference(Vector64<byte>    left, Vector64<byte>    right) { throw null; }
        public static Vector64<byte>    AbsoluteDifference(Vector64<sbyte>   left, Vector64<sbyte>   right) { throw null; }
        public static Vector64<ushort>  AbsoluteDifference(Vector64<ushort>  left, Vector64<ushort>  right) { throw null; }
        public static Vector64<ushort>  AbsoluteDifference(Vector64<short>   left, Vector64<short>   right) { throw null; }
        public static Vector64<uint>    AbsoluteDifference(Vector64<uint>    left, Vector64<uint>    right) { throw null; }
        public static Vector64<uint>    AbsoluteDifference(Vector64<int>     left, Vector64<int>     right) { throw null; }
        public static Vector64<float>   AbsoluteDifference(Vector64<float>   left, Vector64<float>   right) { throw null; }
        public static Vector128<byte>   AbsoluteDifference(Vector128<byte>   left, Vector128<byte>   right) { throw null; }
        public static Vector128<byte>   AbsoluteDifference(Vector128<sbyte>  left, Vector128<sbyte>  right) { throw null; }
        public static Vector128<ushort> AbsoluteDifference(Vector128<ushort> left, Vector128<ushort> right) { throw null; }
        public static Vector128<ushort> AbsoluteDifference(Vector128<short>  left, Vector128<short>  right) { throw null; }
        public static Vector128<uint>   AbsoluteDifference(Vector128<uint>   left, Vector128<uint>   right) { throw null; }
        public static Vector128<uint>   AbsoluteDifference(Vector128<int>    left, Vector128<int>    right) { throw null; }
        public static Vector128<float>  AbsoluteDifference(Vector128<float>  left, Vector128<float>  right) { throw null; }

        /// <summary>
        /// Vector absolute difference add
        ///
        /// For each element result[elem] = acc[elem] + | left[elem] - right[elem] |
        ///
        /// Corresponds to vector forms of ARM64 SABA, UABA
        /// </summary>
        public static Vector64<byte>    AbsoluteDifferenceAdd(Vector64<byte>    acc, Vector64<byte>    left, Vector64<byte>    right) { throw null; }
        public static Vector64<byte>    AbsoluteDifferenceAdd(Vector64<sbyte>   acc, Vector64<sbyte>   left, Vector64<sbyte>   right) { throw null; }
        public static Vector64<ushort>  AbsoluteDifferenceAdd(Vector64<ushort>  acc, Vector64<ushort>  left, Vector64<ushort>  right) { throw null; }
        public static Vector64<ushort>  AbsoluteDifferenceAdd(Vector64<short>   acc, Vector64<short>   left, Vector64<short>   right) { throw null; }
        public static Vector64<uint>    AbsoluteDifferenceAdd(Vector64<uint>    acc, Vector64<uint>    left, Vector64<uint>    right) { throw null; }
        public static Vector64<uint>    AbsoluteDifferenceAdd(Vector64<int>     acc, Vector64<int>     left, Vector64<int>     right) { throw null; }
        public static Vector128<byte>   AbsoluteDifferenceAdd(Vector128<byte>   acc, Vector128<byte>   left, Vector128<byte>   right) { throw null; }
        public static Vector128<byte>   AbsoluteDifferenceAdd(Vector128<sbyte>  acc, Vector128<sbyte>  left, Vector128<sbyte>  right) { throw null; }
        public static Vector128<ushort> AbsoluteDifferenceAdd(Vector128<ushort> acc, Vector128<ushort> left, Vector128<ushort> right) { throw null; }
        public static Vector128<ushort> AbsoluteDifferenceAdd(Vector128<short>  acc, Vector128<short>  left, Vector128<short>  right) { throw null; }
        public static Vector128<uint>   AbsoluteDifferenceAdd(Vector128<uint>   acc, Vector128<uint>   left, Vector128<uint>   right) { throw null; }
        public static Vector128<uint>   AbsoluteDifferenceAdd(Vector128<int>    acc, Vector128<int>    left, Vector128<int>    right) { throw null; }

        /// <summary>
        /// Vector add pairwise
        /// For each byte result[byte] = 2*byte < result.Length ? (left[2*byte] + left[2*byte + 1]) : (right[2*byte - result.Length] + right[2*byte + 1 - result.Length])
        /// Corresponds to vector forms of ARM64 ADDP & FADDP
        /// </summary>
        public static Vector64<byte>   AddPairwise<byte>(Vector64<byte>  left, Vector64<byte>  right)  { throw null; }
        public static Vector64<sbyte>  AddPairwise<sbyte>(Vector64<sbyte>  left, Vector64<sbyte>  right)  { throw null; }
        public static Vector64<ushort> AddPairwise<ushort>(Vector64<ushort>  left, Vector64<ushort>  right)  { throw null; }
        public static Vector64<short>  AddPairwise<short>(Vector64<short>  left, Vector64<short>  right)  { throw null; }
        public static Vector64<int>    AddPairwise<int>(Vector64<int>  left, Vector64<int>  right)  { throw null; }
        public static Vector64<uint>   AddPairwise<uint>(Vector64<uint>  left, Vector64<uint>  right)  { throw null; }
        public static Vector64<float>  AddPairwise<float>(Vector64<float>  left, Vector64<float>  right)  { throw null; }

        /// <summary>
        /// Vector extract from pair of vectors
        /// For each byte result[byte] = byte + index < result.Length ? left[byte + index] : right[byte + index - result.Length]
        ///
        /// Note: index must be a JIT time const expression which can be used to populate the literal immediate field
        ///
        /// Corresponds to vector forms of ARM64 EXT
        /// </summary>
        public static Vector64<byte>   ExtractVector<byte>(Vector64<byte>  left, Vector64<byte>  right, byte index) { throw null; }
        public static Vector64<sbyte>  ExtractVector<sbyte>(Vector64<sbyte>  left, Vector64<sbyte>  right, byte index) { throw null; }
        public static Vector64<short>  ExtractVector<short>(Vector64<short>  left, Vector64<short>  right, byte index) { throw null; }
        public static Vector64<ushort> ExtractVector<ushort>(Vector64<ushort>  left, Vector64<ushort>  right, byte index) { throw null; }
        public static Vector64<int>    ExtractVector<int>(Vector64<int>  left, Vector64<int>  right, byte index) { throw null; }
        public static Vector64<uint>   ExtractVector<uint>(Vector64<uint>  left, Vector64<uint>  right, byte index) { throw null; }

        public static Vector128<byte>   ExtractVector<byte>(Vector128<byte> left, Vector128<byte> right, byte index) { throw null; }
        public static Vector128<sbyte>  ExtractVector<sbyte>(Vector128<sbyte> left, Vector128<sbyte> right, byte index) { throw null; }
        public static Vector128<short>  ExtractVector<short>(Vector128<short> left, Vector128<short> right, byte index) { throw null; }
        public static Vector128<ushort> ExtractVector<ushort>(Vector128<ushort> left, Vector128<ushort> right, byte index) { throw null; }
        public static Vector128<int>    ExtractVector<int>(Vector128<int> left, Vector128<int> right, byte index) { throw null; }
        public static Vector128<uint>   ExtractVector<uint>(Vector128<uint> left, Vector128<uint> right, byte index) { throw null; }
        public static Vector128<long>   ExtractVector<long>(Vector128<long> left, Vector128<long> right, byte index) { throw null; }
        public static Vector128<ulong>  ExtractVector<ulong>(Vector128<ulong> left, Vector128<ulong> right, byte index) { throw null; }
        public static Vector128<float>  ExtractVector<double>(Vector128<float> left, Vector128<float> right, byte index) { throw null; }

        /// <summary>
        /// Vector max numeric
        /// Corresponds to vector forms of ARM64 FMAXNM
        /// </summary>
        public static Vector64<float>   MaxNumeric(Vector64<float>   left, Vector64<float>   right) { throw null; }
        public static Vector128<float>  MaxNumeric(Vector128<float>  left, Vector128<float>  right) { throw null; }

        /// <summary>
        /// Vector max pairwise
        ///
        /// For each element result[elem] = 2*elem < result.Length ? max(left[2*elem], left[2*byte + 1]) : max(right[2*byte - result.Length], right[2*byte + 1 - result.Length])
        ///
        /// Corresponds to vector forms of ARM64 SMAXP, UMAXP & FMAXP
        /// </summary>
        public static Vector64<byte>    MaxPairwise(Vector64<byte>    left, Vector64<byte>    right) { throw null; }
        public static Vector64<sbyte>   MaxPairwise(Vector64<sbyte>   left, Vector64<sbyte>   right) { throw null; }
        public static Vector64<ushort>  MaxPairwise(Vector64<ushort>  left, Vector64<ushort>  right) { throw null; }
        public static Vector64<short>   MaxPairwise(Vector64<short>   left, Vector64<short>   right) { throw null; }
        public static Vector64<uint>    MaxPairwise(Vector64<uint>    left, Vector64<uint>    right) { throw null; }
        public static Vector64<int>     MaxPairwise(Vector64<int>     left, Vector64<int>     right) { throw null; }
        public static Vector64<float>   MaxPairwise(Vector64<float>   left, Vector64<float>   right) { throw null; }

        /// <summary>
        /// Vector min numeric
        /// Corresponds to vector forms of ARM64 FMINNM
        /// </summary>
        public static Vector64<float>   MinNumeric(Vector64<float>   left, Vector64<float>   right) { throw null; }
        public static Vector128<float>  MinNumeric(Vector128<float>  left, Vector128<float>  right) { throw null; }

        /// <summary>
        /// Vector min pairwise
        ///
        /// For each element result[elem] = 2*elem < result.Length ? min(left[2*elem], left[2*byte + 1]) : min(right[2*byte - result.Length], right[2*byte + 1 - result.Length])
        ///
        /// Corresponds to vector forms of ARM64 SMINP, UMINP & FMINP
        /// </summary>
        public static Vector64<byte>    MinPairwise(Vector64<byte>    left, Vector64<byte>    right) { throw null; }
        public static Vector64<sbyte>   MinPairwise(Vector64<sbyte>   left, Vector64<sbyte>   right) { throw null; }
        public static Vector64<ushort>  MinPairwise(Vector64<ushort>  left, Vector64<ushort>  right) { throw null; }
        public static Vector64<short>   MinPairwise(Vector64<short>   left, Vector64<short>   right) { throw null; }
        public static Vector64<uint>    MinPairwise(Vector64<uint>    left, Vector64<uint>    right) { throw null; }
        public static Vector64<int>     MinPairwise(Vector64<int>     left, Vector64<int>     right) { throw null; }
        public static Vector64<float>   MinPairwise(Vector64<float>   left, Vector64<float>   right) { throw null; }

        /// <summary>
        /// Vector multiply add
        ///
        /// For each element result[elem] = acc[elem] + left[elem] * right[elem]
        ///
        /// Corresponds to vector forms of ARM64 MLA
        /// </summary>
        public static Vector64<byte>    MultiplyAdd(Vector64<byte>    acc, Vector64<byte>    left, Vector64<byte>    right) { throw null; }
        public static Vector64<sbyte>   MultiplyAdd(Vector64<sbyte>   acc, Vector64<sbyte>   left, Vector64<sbyte>   right) { throw null; }
        public static Vector64<ushort>  MultiplyAdd(Vector64<ushort>  acc, Vector64<ushort>  left, Vector64<ushort>  right) { throw null; }
        public static Vector64<short>   MultiplyAdd(Vector64<short>   acc, Vector64<short>   left, Vector64<short>   right) { throw null; }
        public static Vector64<uint>    MultiplyAdd(Vector64<uint>    acc, Vector64<uint>    left, Vector64<uint>    right) { throw null; }
        public static Vector64<int>     MultiplyAdd(Vector64<int>     acc, Vector64<int>     left, Vector64<int>     right) { throw null; }
        public static Vector128<byte>   MultiplyAdd(Vector128<byte>   acc, Vector128<byte>   left, Vector128<byte>   right) { throw null; }
        public static Vector128<sbyte>  MultiplyAdd(Vector128<sbyte>  acc, Vector128<sbyte>  left, Vector128<sbyte>  right) { throw null; }
        public static Vector128<ushort> MultiplyAdd(Vector128<ushort> acc, Vector128<ushort> left, Vector128<ushort> right) { throw null; }
        public static Vector128<short>  MultiplyAdd(Vector128<short>  acc, Vector128<short>  left, Vector128<short>  right) { throw null; }
        public static Vector128<uint>   MultiplyAdd(Vector128<uint>   acc, Vector128<uint>   left, Vector128<uint>   right) { throw null; }
        public static Vector128<int>    MultiplyAdd(Vector128<int>    acc, Vector128<int>    left, Vector128<int>    right) { throw null; }

        /// <summary>
        /// Vector multiply add by element
        ///
        /// For each element result[elem] = acc[elem] + left[elem] * right
        ///
        /// Corresponds to vector forms of ARM64 MLA
        /// </summary>
        public static Vector64<byte>    MultiplyAdd(Vector64<byte>    acc, Vector64<byte>    left, byte    right) { throw null; }
        public static Vector64<sbyte>   MultiplyAdd(Vector64<sbyte>   acc, Vector64<sbyte>   left, sbyte   right) { throw null; }
        public static Vector64<ushort>  MultiplyAdd(Vector64<ushort>  acc, Vector64<ushort>  left, ushort  right) { throw null; }
        public static Vector64<short>   MultiplyAdd(Vector64<short>   acc, Vector64<short>   left, short   right) { throw null; }
        public static Vector64<uint>    MultiplyAdd(Vector64<uint>    acc, Vector64<uint>    left, uint    right) { throw null; }
        public static Vector64<int>     MultiplyAdd(Vector64<int>     acc, Vector64<int>     left, int     right) { throw null; }
        public static Vector128<byte>   MultiplyAdd(Vector128<byte>   acc, Vector128<byte>   left, byte    right) { throw null; }
        public static Vector128<sbyte>  MultiplyAdd(Vector128<sbyte>  acc, Vector128<sbyte>  left, sbyte   right) { throw null; }
        public static Vector128<ushort> MultiplyAdd(Vector128<ushort> acc, Vector128<ushort> left, ushort  right) { throw null; }
        public static Vector128<short>  MultiplyAdd(Vector128<short>  acc, Vector128<short>  left, short   right) { throw null; }
        public static Vector128<uint>   MultiplyAdd(Vector128<uint>   acc, Vector128<uint>   left, uint    right) { throw null; }
        public static Vector128<int>    MultiplyAdd(Vector128<int>    acc, Vector128<int>    left, int     right) { throw null; }

        /// <summary>
        /// Vector multiply subtract
        ///
        /// For each element result[elem] = acc[elem] - left[elem] * right[elem]
        ///
        /// Corresponds to vector forms of ARM64 MLS
        /// </summary>
        public static Vector64<byte>    MultiplySubtract(Vector64<byte>    acc, Vector64<byte>    left, Vector64<byte>    right) { throw null; }
        public static Vector64<sbyte>   MultiplySubtract(Vector64<sbyte>   acc, Vector64<sbyte>   left, Vector64<sbyte>   right) { throw null; }
        public static Vector64<ushort>  MultiplySubtract(Vector64<ushort>  acc, Vector64<ushort>  left, Vector64<ushort>  right) { throw null; }
        public static Vector64<short>   MultiplySubtract(Vector64<short>   acc, Vector64<short>   left, Vector64<short>   right) { throw null; }
        public static Vector64<uint>    MultiplySubtract(Vector64<uint>    acc, Vector64<uint>    left, Vector64<uint>    right) { throw null; }
        public static Vector64<int>     MultiplySubtract(Vector64<int>     acc, Vector64<int>     left, Vector64<int>     right) { throw null; }
        public static Vector128<byte>   MultiplySubtract(Vector128<byte>   acc, Vector128<byte>   left, Vector128<byte>   right) { throw null; }
        public static Vector128<sbyte>  MultiplySubtract(Vector128<sbyte>  acc, Vector128<sbyte>  left, Vector128<sbyte>  right) { throw null; }
        public static Vector128<ushort> MultiplySubtract(Vector128<ushort> acc, Vector128<ushort> left, Vector128<ushort> right) { throw null; }
        public static Vector128<short>  MultiplySubtract(Vector128<short>  acc, Vector128<short>  left, Vector128<short>  right) { throw null; }
        public static Vector128<uint>   MultiplySubtract(Vector128<uint>   acc, Vector128<uint>   left, Vector128<uint>   right) { throw null; }
        public static Vector128<int>    MultiplySubtract(Vector128<int>    acc, Vector128<int>    left, Vector128<int>    right) { throw null; }

        /// <summary>
        /// Vector multiply subtract by element
        ///
        /// For each element result[elem] = acc[elem] - left[elem] * right
        ///
        /// Corresponds to vector forms of ARM64 MLS
        /// </summary>
        public static Vector64<byte>    MultiplySubtract(Vector64<byte>    acc, Vector64<byte>    left, byte    right) { throw null; }
        public static Vector64<sbyte>   MultiplySubtract(Vector64<sbyte>   acc, Vector64<sbyte>   left, sbyte   right) { throw null; }
        public static Vector64<ushort>  MultiplySubtract(Vector64<ushort>  acc, Vector64<ushort>  left, ushort  right) { throw null; }
        public static Vector64<short>   MultiplySubtract(Vector64<short>   acc, Vector64<short>   left, short   right) { throw null; }
        public static Vector64<uint>    MultiplySubtract(Vector64<uint>    acc, Vector64<uint>    left, uint    right) { throw null; }
        public static Vector64<int>     MultiplySubtract(Vector64<int>     acc, Vector64<int>     left, int     right) { throw null; }
        public static Vector128<byte>   MultiplySubtract(Vector128<byte>   acc, Vector128<byte>   left, byte    right) { throw null; }
        public static Vector128<sbyte>  MultiplySubtract(Vector128<sbyte>  acc, Vector128<sbyte>  left, sbyte   right) { throw null; }
        public static Vector128<ushort> MultiplySubtract(Vector128<ushort> acc, Vector128<ushort> left, ushort  right) { throw null; }
        public static Vector128<short>  MultiplySubtract(Vector128<short>  acc, Vector128<short>  left, short   right) { throw null; }
        public static Vector128<uint>   MultiplySubtract(Vector128<uint>   acc, Vector128<uint>   left, uint    right) { throw null; }
        public static Vector128<int>    MultiplySubtract(Vector128<int>    acc, Vector128<int>    left, int     right) { throw null; }

        /// <summary>
        /// Vector fused multiply add
        ///
        /// For each element result[elem] = acc[elem] + left[elem] * right[elem]
        ///
        /// Corresponds to vector forms of ARM64 FMLA
        /// </summary>
        public static Vector64<float>   FusedMultiplyAdd(Vector64<float>   acc, Vector64<float>   left, Vector64<float>   right) { throw null; }
        public static Vector128<float>  FusedMultiplyAdd(Vector128<float>  acc, Vector128<float>  left, Vector128<float>  right) { throw null; }

        /// <summary>
        /// Vector fused multiply subtract
        ///
        /// For each element result[elem] = acc[elem] - left[elem] * right[elem]
        ///
        /// Corresponds to vector forms of ARM64 FMLS
        /// </summary>
        public static Vector64<float>   FusedMultiplySubtract(Vector64<float>   acc, Vector64<float>   left, Vector64<float>   right) { throw null; }
        public static Vector128<float>  FusedMultiplySubtract(Vector128<float>  acc, Vector128<float>  left, Vector128<float>  right) { throw null; }


        /// <summary>
        /// Vector polynomial multiply
        /// Corresponds to vector forms of ARM64 PMUL
        /// </summary>
        public static Vector64<byte>    PolynomialMultiply(Vector64<byte>    left, Vector64<byte>    right) { throw null; }
        public static Vector64<sbyte>   PolynomialMultiply(Vector64<sbyte>   left, Vector64<sbyte>   right) { throw null; }
        public static Vector128<byte>   PolynomialMultiply(Vector128<byte>   left, Vector128<byte>   right) { throw null; }
        public static Vector128<sbyte>  PolynomialMultiply(Vector128<sbyte>  left, Vector128<sbyte>  right) { throw null; }

        /// Vector reciprocal estimate
        ///
        /// See FRECPE docs
        ///
        /// Corresponds to vector forms of ARM64 FRECPE
        /// </summary>
        public static Vector64<float>   ReciprocalEstimate(Vector64<float>   value) { throw null; }
        public static Vector128<float>  ReciprocalEstimate(Vector128<float>  value) { throw null; }

        /// <summary>
        /// Vector reciprocal step
        ///
        /// See FRECPS docs
        ///
        /// Corresponds to vector forms of ARM64 FRECPS
        /// </summary>
        public static Vector64<float>   ReciprocalStep(Vector64<float>   left, Vector64<float>   right, byte index) { throw null; }
        public static Vector128<float>  ReciprocalStep(Vector128<float>  left, Vector128<float>  right, byte index) { throw null; }

        /// <summary>
        /// Vector reciprocal square root estimate
        ///
        /// See FRSQRTE docs
        ///
        /// Corresponds to vector forms of ARM64 FRSQRTE
        /// </summary>
        public static Vector64<float>   ReciprocalSquareRootEstimate(Vector64<float>   value) { throw null; }
        public static Vector128<float>  ReciprocalSquareRootEstimate(Vector128<float>  value) { throw null; }

        /// <summary>
        /// Vector reciprocal square root step
        ///
        /// See FRSQRTS docs
        ///
        /// Corresponds to vector forms of ARM64 FRSQRTS
        /// </summary>
        public static Vector64<float>   ReciprocalSquareRootEstimate(Vector64<float>   left, Vector64<float>   right, byte index) { throw null; }
        public static Vector128<float>  ReciprocalSquareRootEstimate(Vector128<float>  left, Vector128<float>  right, byte index) { throw null; }

        /// <summary>
        /// Vector reverse element bytes
        /// Corresponds to vector forms of ARM64 REV16, REV32, REV64
        /// </summary>
        public static Vector64<ushort>  ReverseElementBytes(Vector64<ushort>  value) { throw null; }
        public static Vector64<short>   ReverseElementBytes(Vector64<short>   value) { throw null; }
        public static Vector64<uint>    ReverseElementBytes(Vector64<uint>    value) { throw null; }
        public static Vector64<int>     ReverseElementBytes(Vector64<int>     value) { throw null; }
        public static Vector64<float>   ReverseElementBytes(Vector64<float>   value) { throw null; }
        public static Vector128<ushort> ReverseElementBytes(Vector128<ushort> value) { throw null; }
        public static Vector128<short>  ReverseElementBytes(Vector128<short>  value) { throw null; }
        public static Vector128<uint>   ReverseElementBytes(Vector128<uint>   value) { throw null; }
        public static Vector128<int>    ReverseElementBytes(Vector128<int>    value) { throw null; }
        public static Vector128<ulong>  ReverseElementBytes(Vector128<ulong>  value) { throw null; }
        public static Vector128<long>   ReverseElementBytes(Vector128<long>   value) { throw null; }
        public static Vector128<float>  ReverseElementBytes(Vector128<float>  value) { throw null; }

        public static class Arm32
        {
            public static bool IsSupported { get { throw null; } }

            /// <summary>
            /// Vector multiply add
            ///
            /// For each element result[elem] = acc[elem] + left[elem] * right[elem]
            ///
            /// Corresponds to vector forms of ARM32 VMLA
            /// </summary>=
            public static Vector64<float>   MultiplyAdd(Vector64<float>   acc, Vector64<float>   left, Vector64<float>   right) { throw null; }
            public static Vector128<float>  MultiplyAdd(Vector128<float>  acc, Vector128<float>  left, Vector128<float>  right) { throw null; }

            /// <summary>
            /// Vector multiply add by element
            ///
            /// For each element result[elem] = acc[elem] + left[elem] * right
            ///
            /// Corresponds to vector forms of ARM32 VMLA
            /// </summary>
            public static Vector64<float>   MultiplyAdd(Vector64<float>   acc, Vector64<float>   left, float   right) { throw null; }
            public static Vector128<float>  MultiplyAdd(Vector128<float>  acc, Vector128<float>  left, float   right) { throw null; }

            /// <summary>
            /// Vector multiply subtract
            ///
            /// For each element result[elem] = acc[elem] - left[elem] * right[elem]
            ///
            /// Corresponds to vector forms of ARM32 VMLS
            /// </summary>
            public static Vector64<float>   MultiplySubtract(Vector64<float>   acc, Vector64<float>   left, Vector64<float>   right) { throw null; }
            public static Vector128<float>  MultiplySubtract(Vector128<float>  acc, Vector128<float>  left, Vector128<float>  right) { throw null; }

            /// <summary>
            /// Vector multiply subtract by element
            ///
            /// For each element result[elem] = acc[elem] - left[elem] * right
            ///
            /// Corresponds to vector forms of ARM32 VMLS
            /// </summary>
            public static Vector64<float>   MultiplySubtract(Vector64<float>   acc, Vector64<float>   left, float   right) { throw null; }
            public static Vector128<float>  MultiplySubtract(Vector128<float>  acc, Vector128<float>  left, float   right) { throw null; }
        }

        public static class Arm64
        {
            public static bool IsSupported { get { throw null; } }

            /// <summary>
            /// Vector CompareGreaterThanOrEqual
            /// For each element result[elem] = (|left[elem]| >= |right[elem]|) ? ~0 : 0
            /// Corresponds to vector forms of ARM64 FACGE
            /// </summary>
            public static Vector128<double> AbsoluteCompareGreaterThanOrEqual(Vector128<double> left, Vector128<double> right) { throw null; }

            /// <summary>
            /// Vector CompareGreaterThan
            ///
            /// For each element result[elem] = (|left[elem]| > |right[elem]|) ? ~0 : 0
            ///
            /// Corresponds to vector forms of ARM64 FACGT
            /// </summary>
            public static Vector128<double> AbsoluteCompareGreaterThan(Vector128<double> left, Vector128<double> right) { throw null; }

            /// <summary>
            /// Vector absolute difference
            /// Corresponds to vector forms of ARM64 SABD, UABD & FABD
            /// </summary>
            public static Vector128<double> AbsoluteDifference(Vector128<double> left, Vector128<double> right) { throw null; }

            /// <summary>
            /// Vector add pairwise
            /// For each byte result[byte] = 2*byte < result.Length ? (left[2*byte] + left[2*byte + 1]) : (right[2*byte - result.Length] + right[2*byte + 1 - result.Length])
            /// Corresponds to vector forms of ARM64 ADDP & FADDP
            /// </summary>
            public static Vector128<T>      AddPairwise<byte>(Vector128<byte> left, Vector128<byte> right)  { throw null; }
            public static Vector128<T>      AddPairwise<sbyte>(Vector128<sbyte> left, Vector128<sbyte> right)  { throw null; }
            public static Vector128<T>      AddPairwise<ushort>(Vector128<ushort> left, Vector128<ushort> right)  { throw null; }
            public static Vector128<T>      AddPairwise<short>(Vector128<short> left, Vector128<short> right)  { throw null; }
            public static Vector128<long>   AddPairwise<long>(Vector128<long>  left, Vector128<long>  right)  { throw null; }
            public static Vector128<ulong>  AddPairwise<ulong>(Vector128<ulong>  left, Vector128<ulong>  right)  { throw null; }
            public static Vector128<T>      AddPairwise<float>(Vector128<float> left, Vector128<float> right)  { throw null; }
            public static Vector128<T>      AddPairwise<double>(Vector128<double> left, Vector128<double> right)  { throw null; }

            /// <summary>
            /// Vector extract from pair of vectors
            /// For each byte result[byte] = byte + index < result.Length ? left[byte + index] : right[byte + index - result.Length]
            ///
            /// Note: index must be a JIT time const expression which can be used to populate the literal immediate field
            ///
            /// Corresponds to vector forms of ARM64 EXT
            /// </summary>
            public static Vector128<double> ExtractVector<double>(Vector128<double> left, Vector128<double> right, byte index) { throw null; }

            /// <summary>
            /// Vector add across vector elements
            /// Corresponds to vector forms of ARM64 ADDV
            /// </summary>
            public static byte   AddAcross(Vector64<byte>    value) { throw null; }
            public static sbyte  AddAcross(Vector64<sbyte>   value) { throw null; }
            public static ushort AddAcross(Vector64<ushort>  value) { throw null; }
            public static short  AddAcross(Vector64<short>   value) { throw null; }
            public static uint   AddAcross(Vector64<uint>    value) { throw null; }
            public static int    AddAcross(Vector64<int>     value) { throw null; }
            public static byte   AddAcross(Vector128<byte>   value) { throw null; }
            public static sbyte  AddAcross(Vector128<sbyte>  value) { throw null; }
            public static ushort AddAcross(Vector128<ushort> value) { throw null; }
            public static short  AddAcross(Vector128<short>  value) { throw null; }
            public static uint   AddAcross(Vector128<uint>   value) { throw null; }
            public static int    AddAcross(Vector128<int>    value) { throw null; }

            /// <summary>
            /// Vector max numeric
            /// Corresponds to vector forms of ARM64 FMAXNM
            /// </summary>
            public static Vector128<double> MaxNumeric(Vector128<double> left, Vector128<double> right) { throw null; }

            /// <summary>
            /// Vector max numeric pairwise
            ///
            /// For each element result[elem] = 2*elem < result.Length ? max(left[2*elem], left[2*byte + 1]) : max(right[2*byte - result.Length], right[2*byte + 1 - result.Length])
            ///
            /// Corresponds to vector forms of ARM64 FMAXNMP
            /// </summary>
            public static Vector64<float>   MaxNumericPairwise(Vector64<float>   left, Vector64<float>   right) { throw null; }
            public static Vector128<float>  MaxNumericPairwise(Vector128<float>  left, Vector128<float>  right) { throw null; }
            public static Vector128<double> MaxNumericPairwise(Vector128<double> left, Vector128<double> right) { throw null; }

            /// <summary>
            /// Vector max numeric across
            ///
            /// result = max(value[0], ... , value[length -1])
            ///
            /// Corresponds to vector forms of ARM64 FMAXNMV
            /// </summary>
            public static float  MaxNumericAcross(Vector128<float>  value) { throw null; }

            /// <summary>
            /// Vector max pairwise
            ///
            /// For each element result[elem] = 2*elem < result.Length ? max(left[2*elem], left[2*byte + 1]) : max(right[2*byte - result.Length], right[2*byte + 1 - result.Length])
            ///
            /// Corresponds to vector forms of ARM64 SMAXP, UMAXP & FMAXP
            /// </summary>
            public static Vector128<byte>   MaxPairwise(Vector128<byte>   left, Vector128<byte>   right) { throw null; }
            public static Vector128<sbyte>  MaxPairwise(Vector128<sbyte>  left, Vector128<sbyte>  right) { throw null; }
            public static Vector128<ushort> MaxPairwise(Vector128<ushort> left, Vector128<ushort> right) { throw null; }
            public static Vector128<short>  MaxPairwise(Vector128<short>  left, Vector128<short>  right) { throw null; }
            public static Vector128<uint>   MaxPairwise(Vector128<uint>   left, Vector128<uint>   right) { throw null; }
            public static Vector128<int>    MaxPairwise(Vector128<int>    left, Vector128<int>    right) { throw null; }
            public static Vector128<float>  MaxPairwise(Vector128<float>  left, Vector128<float>  right) { throw null; }
            public static Vector128<double> MaxPairwise(Vector128<double> left, Vector128<double> right) { throw null; }

            /// <summary>
            /// Vector max across
            ///
            /// result = max(value[0], ... , value[length -1])
            ///
            /// Corresponds to vector forms of ARM64 SMAXV, UMAXV & FMAXV
            /// </summary>
            public static byte   MaxAcross(Vector64<byte>    value) { throw null; }
            public static sbyte  MaxAcross(Vector64<sbyte>   value) { throw null; }
            public static ushort MaxAcross(Vector64<ushort>  value) { throw null; }
            public static short  MaxAcross(Vector64<short>   value) { throw null; }
            public static uint   MaxAcross(Vector64<uint>    value) { throw null; }
            public static int    MaxAcross(Vector64<int>     value) { throw null; }
            public static float  MaxAcross(Vector64<float>   value) { throw null; }
            public static byte   MaxAcross(Vector128<byte>   value) { throw null; }
            public static sbyte  MaxAcross(Vector128<sbyte>  value) { throw null; }
            public static ushort MaxAcross(Vector128<ushort> value) { throw null; }
            public static short  MaxAcross(Vector128<short>  value) { throw null; }
            public static uint   MaxAcross(Vector128<uint>   value) { throw null; }
            public static int    MaxAcross(Vector128<int>    value) { throw null; }
            public static ulong  MaxAcross(Vector128<ulong>  value) { throw null; }
            public static long   MaxAcross(Vector128<long>   value) { throw null; }
            public static float  MaxAcross(Vector128<float>  value) { throw null; }
            public static double MaxAcross(Vector128<double> value) { throw null; }

            /// <summary>
            /// Vector min numeric
            /// Corresponds to vector forms of ARM64 FMINNM
            /// </summary>
            public static Vector128<double> MinNumeric(Vector128<double> left, Vector128<double> right) { throw null; }

            /// <summary>
            /// Vector min numeric pairwise
            ///
            /// For each element result[elem] = 2*elem < result.Length ? min(left[2*elem], left[2*byte + 1]) : min(right[2*byte - result.Length], right[2*byte + 1 - result.Length])
            ///
            /// Corresponds to vector forms of ARM64 FMINNMP
            /// </summary>
            public static Vector64<float>   MaxNumericPairwise(Vector64<float>   left, Vector64<float>   right) { throw null; }
            public static Vector128<float>  MaxNumericPairwise(Vector128<float>  left, Vector128<float>  right) { throw null; }
            public static Vector128<double> MaxNumericPairwise(Vector128<double> left, Vector128<double> right) { throw null; }

            /// <summary>
            /// Vector min numeric across
            ///
            /// result = min(value[0], ... , value[length -1])
            ///
            /// Corresponds to vector forms of ARM64 FMINNMV
            /// </summary>
            public static float  MaxNumericAcross(Vector128<float>  value) { throw null; }

            /// <summary>
            /// Vector min pairwise
            ///
            /// For each element result[elem] = 2*elem < result.Length ? min(left[2*elem], left[2*byte + 1]) : min(right[2*byte - result.Length], right[2*byte + 1 - result.Length])
            ///
            /// Corresponds to vector forms of ARM64 SMINP, UMINP & FMINP
            /// </summary>
            public static Vector128<byte>   MinPairwise(Vector128<byte>   left, Vector128<byte>   right) { throw null; }
            public static Vector128<sbyte>  MinPairwise(Vector128<sbyte>  left, Vector128<sbyte>  right) { throw null; }
            public static Vector128<ushort> MinPairwise(Vector128<ushort> left, Vector128<ushort> right) { throw null; }
            public static Vector128<short>  MinPairwise(Vector128<short>  left, Vector128<short>  right) { throw null; }
            public static Vector128<uint>   MinPairwise(Vector128<uint>   left, Vector128<uint>   right) { throw null; }
            public static Vector128<int>    MinPairwise(Vector128<int>    left, Vector128<int>    right) { throw null; }
            public static Vector128<float>  MinPairwise(Vector128<float>  left, Vector128<float>  right) { throw null; }
            public static Vector128<double> MinPairwise(Vector128<double> left, Vector128<double> right) { throw null; }

            /// <summary>
            /// Vector min across
            ///
            /// result = max(value[0], ... , value[length -1])
            ///
            /// Corresponds to vector forms of ARM64 SMINV, UMINV & FMINV
            /// </summary>
            public static byte   MinAcross(Vector64<byte>    value) { throw null; }
            public static sbyte  MinAcross(Vector64<sbyte>   value) { throw null; }
            public static ushort MinAcross(Vector64<ushort>  value) { throw null; }
            public static short  MinAcross(Vector64<short>   value) { throw null; }
            public static uint   MinAcross(Vector64<uint>    value) { throw null; }
            public static int    MinAcross(Vector64<int>     value) { throw null; }
            public static float  MinAcross(Vector64<float>   value) { throw null; }
            public static byte   MinAcross(Vector128<byte>   value) { throw null; }
            public static sbyte  MinAcross(Vector128<sbyte>  value) { throw null; }
            public static ushort MinAcross(Vector128<ushort> value) { throw null; }
            public static short  MinAcross(Vector128<short>  value) { throw null; }
            public static uint   MinAcross(Vector128<uint>   value) { throw null; }
            public static int    MinAcross(Vector128<int>    value) { throw null; }
            public static float  MinAcross(Vector128<float>  value) { throw null; }
            public static double MinAcross(Vector128<double> value) { throw null; }

            /// <summary>
            /// Vector fused multiply add
            ///
            /// For each element result[elem] = acc[elem] + left[elem] * right[elem]
            ///
            /// Corresponds to vector forms of ARM64 FMLA
            /// </summary>
            public static Vector128<double> FusedMultiplyAdd(Vector128<double> acc, Vector128<double> left, Vector128<double> right) { throw null; }

            /// <summary>
            /// Vector fused multiply add by element
            ///
            /// For each element result[elem] = acc[elem] + left[elem] * right
            ///
            /// Corresponds to vector forms of ARM64 FMLA
            /// </summary>
            public static Vector64<float>   FusedMultiplyAdd(Vector64<float>   acc, Vector64<float>   left, float   right) { throw null; }
            public static Vector128<float>  FusedMultiplyAdd(Vector128<float>  acc, Vector128<float>  left, float   right) { throw null; }
            public static Vector128<float>  FusedMultiplyAdd(Vector128<float>  acc, Vector128<float>  left, float   right) { throw null; }

            /// <summary>
            /// Vector fused multiply subtract
            ///
            /// For each element result[elem] = acc[elem] - left[elem] * right[elem]
            ///
            /// Corresponds to vector forms of ARM64 FMLS
            /// </summary>
            public static Vector128<double>  FusedMultiplySubtract(Vector128<double>  acc, Vector128<double>  left, Vector128<double>  right) { throw null; }

            /// <summary>
            /// Vector fused multiply subtract by element
            ///
            /// For each element result[elem] = acc[elem] - left[elem] * right
            ///
            /// Corresponds to vector forms of ARM64 FMLS
            /// </summary>
            public static Vector64<float>   FusedMultiplySubtract(Vector64<float>   acc, Vector64<float>   left, float   right) { throw null; }
            public static Vector128<float>  FusedMultiplySubtract(Vector128<float>  acc, Vector128<float>  left, float   right) { throw null; }
            public static Vector128<double> FusedMultiplySubtract(Vector128<double> acc, Vector128<double> left, float   right) { throw null; }

            /// <summary>
            /// Vector multiply extend
            ///
            /// For each element result[elem] = left[elem] * right[elem]
            /// Handle extend special cases zero and infinite.  FMULX
            ///
            /// Corresponds to vector forms of ARM64 FMULX
            /// </summary>
            public static Vector64<float>   MultiplyExtend(Vector64<float>   left, Vector64<float>   right) { throw null; }
            public static Vector128<float>  MultiplyExtend(Vector128<float>  left, Vector128<float>  right) { throw null; }
            public static Vector128<double> MultiplyExtend(Vector128<double> left, Vector128<double> right) { throw null; }

            /// <summary>
            /// Vector multiply extend by element
            ///
            /// For each element result[elem] = left[elem] * right
            /// Handle extend special cases zero and infinite.  FMULX
            ///
            /// Corresponds to vector forms of ARM64 FMULX
            /// </summary>
            public static Vector64<float>   MultiplyExtend(Vector64<float>   left, float  right) { throw null; }
            public static Vector128<float>  MultiplyExtend(Vector128<float>  left, float  right) { throw null; }
            public static Vector128<double> MultiplyExtend(Vector128<double> left, double right) { throw null; }

            /// Vector reciprocal estimate
            ///
            /// See FRECPE docs
            ///
            /// Corresponds to vector forms of ARM64 FRECPE
            /// </summary>
            public static Vector128<double> ReciprocalEstimate(Vector128<double> value) { throw null; }

            /// <summary>
            /// Vector reciprocal step
            ///
            /// See FRECPS docs
            ///
            /// Corresponds to vector forms of ARM64 FRECPS
            /// </summary>
            public static Vector128<double> ReciprocalStep(Vector128<double> left, Vector128<double> right, byte index) { throw null; }

            /// <summary>
            /// Vector reciprocal square root estimate
            ///
            /// See FRSQRTE docs
            ///
            /// Corresponds to vector forms of ARM64 FRSQRTE
            /// </summary>
            public static Vector128<double> ReciprocalSquareRootEstimate(Vector128<double> value) { throw null; }

            /// <summary>
            /// Vector reciprocal square root step
            ///
            /// See FRSQRTS docs
            ///
            /// Corresponds to vector forms of ARM64 FRSQRTS
            /// </summary>
            public static Vector128<double> ReciprocalSquareRootEstimate(Vector128<double> left, Vector128<double> right, byte index) { throw null; }

            /// <summary>
            /// Vector reverse byte bits
            /// Corresponds to vector forms of ARM64 RBIT
            /// </summary>
            public static Vector64<byte>    ReverseElementBits(Vector64<byte>    value) { throw null; }
            public static Vector64<sbyte>   ReverseElementBits(Vector64<sbyte>   value) { throw null; }
            public static Vector128<byte>   ReverseElementBits(Vector128<byte>   value) { throw null; }
            public static Vector128<sbyte>  ReverseElementBits(Vector128<sbyte>  value) { throw null; }
        }
  }
}

[sdmaclea]

This is the next wave of SIMD instructions which I plan to implement

@CarolEidt @RussKeldorph @eerhardt PTAL
@tannergooding @4creators @fiigii @dotnet/arm64-contrib @dotnet/jit-contrib

[sdmaclea]

This introduces more complicated intrinsic overloads. For instance

• Multiply(Vector64<float>, Vector64<float>)
• Multiply(Vector64<float>, float)

This introduces some implementation complexity. lookupHWIntrinsic must check Method arguments.

It may make the API less safe.

The second form represents multiply by vector element. It could be renamed to

• MultiplyByElement(Vector64<float>, float)

There are other cases Extract, MultiplyAdd ...

Opinions?

[sdmaclea]

Looks like X86 intrinsics is using MultiplyScalar(Vector64<float>, float) for Arm64's
MultiplyByElement(Vector64<float>, float). I'm OK with renaming.

[fiigii]

Looks like X86 intrinsics is using MultiplyScalar(Vector64, float) for Arm64's
MultiplyByElement(Vector64, float). I'm OK with renaming.

X86 does not have MultiplyScalar(Vector64<float>, float). In Intel HW intrinsics, Scalar means operating over Vector128<T> but only computing the first element.

[TamarChristinaArm]

Hi, I'm wondering what the status of this proposal is?

[sdmaclea]

@TamarChristinaArm When I moved to Microsoft, I stopped championing this. In my opinion it was in good shape when I left it.

The proposal is probably a little out of date. When some of the other intrinsic API were approved, the namespace changed.

If someone was motivated to implement this and we had consensus, the next step would be to mark this as API ready for review and have an API design review.

[TamarChristinaArm]

In my opinion it was in good shape when I left it.

@sdmaclea I agree. I have some of this implemented as I was going off a different list, but It would be best just to get these approved.

The namespace change shouldn't affect this much so I think it's fine to review as is. The other approved APIs need slight changes due to the namespaces too but it's easier to have them all approved as is (as it's mostly about the intrinsics themselves no? the namespace they end up in is determined by the ISA).

If someone was motivated to implement this and we had consensus, the next step would be to mark this as API ready for review and have an API design review.

How should I go about this? do I just add the label?

[sdmaclea]

I doubt you can add the label. I'll add it. I just tried but GitHub seems to have issues at the moment.

[tannergooding]

The namespace change shouldn't affect this much so I think it's fine to review as is.

Part of this is trivial and just involves updating the class name and namespace name.

The more difficult part comes from pulling out what is shared vs what is ARM64 specific; which needs to be done anyways.

I'm fine with marking this ready-for-review, but I'd like to see us get the proposal updated before it is reviewed, if possible. It tends to make the entire process easier and is ultimately part of implementing it anyways.

[sdmaclea]

@terrajobst Can we schedule this for API review? Can we include Arm on the call?

[sdmaclea]

@tannergooding @TamarChristinaArm My head is not in this space at the moment. I am happy to play admin, but I can't drive this.

If you comment on what needs changed, I am happy to update.

Either way marking ready for review seems fine. It will take at least a week to schedule the review. We should clean up as quickly as practical.

[TamarChristinaArm]

I'll post the changes require to adhere to dotnet/corefx#37199 today. I've already started on it.

[tannergooding]

If you comment on what needs changed, I am happy to update.

I can modify the original comment on any of these and you shouldn't need to worry about it 😄

I can also handle ensuring this gets a slot on the API review schedule, etc.

[TamarChristinaArm]

Extract in this proposal uses the same name for the intrinsics as in #24588, there's no clash because the overloads are different but they are completely different intrinsics. Should this one instead be something like ExtractVector?

[tannergooding]

I think ExtractVector makes sense, given my understanding of the API.