Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

ARM Doubling Multiply intrinsics #36696

Closed
tannergooding opened this issue May 19, 2020 · 4 comments · Fixed by #38957
Closed

ARM Doubling Multiply intrinsics #36696

tannergooding opened this issue May 19, 2020 · 4 comments · Fixed by #38957
Assignees
@echesakov
Labels
api-approved API was approved in API review, it can be implemented arch-arm64 area-System.Runtime.Intrinsics
Milestone
5.0.0

Comments

@tannergooding
Copy link
Member 

namespace System.Runtime.Intrinsics.Arm
{
    public abstract class AdvSimd
    {
        /// <summary>
        /// Signed saturating doubling multiply returning high half
        /// Corresponds to vector forms of SQDMULH and VQDMULH
        /// </summary>
        public static Vector64<short> DoublingMultiplySaturateHigh(Vector64<short> left, Vector64<short> right);
        public static Vector64<int> DoublingMultiplySaturateHigh(Vector64<int> left, Vector64<int> right);
        public static Vector128<short> DoublingMultiplySaturateHigh(Vector128<short> left, Vector128<short> right);
        public static Vector128<int> DoublingMultiplySaturateHigh(Vector128<int> left, Vector128<int> right);

        public static Vector64<short> DoublingMultiplyBySelectedScalarSaturateHigh(Vector64<short> left, Vector64<short> right, byte rightIndex);
        public static Vector64<int> DoublingMultiplyBySelectedScalarSaturateHigh(Vector64<int> left, Vector64<int> right, byte rightIndex);
        public static Vector64<short> DoublingMultiplyBySelectedScalarSaturateHigh(Vector64<short> left, Vector128<short> right, byte rightIndex);
        public static Vector64<int> DoublingMultiplyBySelectedScalarSaturateHigh(Vector64<int> left, Vector128<int> right, byte rightIndex);
        public static Vector128<short> DoublingMultiplyBySelectedScalarSaturateHigh(Vector128<short> left, Vector64<short> right, byte rightIndex);
        public static Vector128<int> DoublingMultiplyBySelectedScalarSaturateHigh(Vector128<int> left, Vector64<int> right, byte rightIndex);
        public static Vector128<short> DoublingMultiplyBySelectedScalarSaturateHigh(Vector128<short> left, Vector128<short> right, byte rightIndex);
        public static Vector128<int> DoublingMultiplyBySelectedScalarSaturateHigh(Vector128<int> left, Vector128<int> right, byte rightIndex);

        public static Vector64<short> DoublingMultiplySaturateHighScalar(Vector64<short> left, Vector64<short> right);
        public static Vector64<int> DoublingMultiplySaturateHighScalar(Vector64<int> left, Vector64<int> right);

        // TODO: Scalar BySelectedScalar variant

        /// <summary>
        /// Signed saturating rounding doubling multiply returning high half
        /// Corresponds to vector forms of SQRDMULH and VQRDMULH
        /// </summary>
        public static Vector64<short> RoundedDoublingMultiplySaturateHigh(Vector64<short> left, Vector64<short> right);
        public static Vector64<int> RoundedDoublingMultiplySaturateHigh(Vector64<int> left, Vector64<int> right);
        public static Vector128<short> RoundedDoublingMultiplySaturateHigh(Vector128<short> left, Vector128<short> right);
        public static Vector128<int> RoundedDoublingMultiplySaturateHigh(Vector128<int> left, Vector128<int> right);

        public static Vector64<short> RoundedDoublingMultiplyBySelectedScalarSaturateHigh(Vector64<short> left, Vector64<short> right, byte rightIndex);
        public static Vector64<int> RoundedDoublingMultiplyBySelectedScalarSaturateHigh(Vector64<int> left, Vector64<int> right, byte rightIndex);
        public static Vector64<short> RoundedDoublingMultiplyBySelectedScalarSaturateHigh(Vector64<short> left, Vector128<short> right, byte rightIndex);
        public static Vector64<int> RoundedDoublingMultiplyBySelectedScalarSaturateHigh(Vector64<int> left, Vector128<int> right, byte rightIndex);
        public static Vector128<short> RoundedDoublingMultiplyBySelectedScalarSaturateHigh(Vector128<short> left, Vector64<short> right, byte rightIndex);
        public static Vector128<int> RoundedDoublingMultiplyBySelectedScalarSaturateHigh(Vector128<int> left, Vector64<int> right, byte rightIndex);
        public static Vector128<short> RoundedDoublingMultiplyBySelectedScalarSaturateHigh(Vector128<short> left, Vector128<short> right, byte rightIndex);
        public static Vector128<int> RoundedDoublingMultiplyBySelectedScalarSaturateHigh(Vector128<int> left, Vector128<int> right, byte rightIndex);

        public static Vector64<short> RoundedDoublingMultiplySaturateHighScalar(Vector64<short> left, Vector64<short> right);
        public static Vector64<int> RoundedDoublingMultiplySaturateHighScalar(Vector64<int> left, Vector64<int> right);

        // TODO: Scalar BySelectedScalar variant

        /// <summary>
        /// Signed Saturating Rounding Doubling Multiply Accumulate returning High Half
        /// Corresponds to vector forms of SQRDMLAH and VQRDMLAH
        /// </summary>
        public static Vector64<short> RoundedDoublingMultiplyAddSaturateHigh(Vector64<short> addend, Vector64<short> left, Vector64<short> right);
        public static Vector64<int> RoundedDoublingMultiplyAddSaturateHigh(Vector64<int> addend, Vector64<int> left, Vector64<int> right);
        public static Vector128<short> RoundedDoublingMultiplyAddSaturateHigh(Vector128<short> addend, Vector128<short> left, Vector128<short> right);
        public static Vector128<int> RoundedDoublingMultiplyAddSaturateHigh(Vector128<int> addend, Vector128<int> left, Vector128<int> right);

        public static Vector64<short> RoundedDoublingMultiplyAddBySelectedScalarSaturateHigh(Vector64<short> addend, Vector64<short> left, Vector64<short> right, byte rightIndex);
        public static Vector64<int> RoundedDoublingMultiplyAddBySelectedScalarSaturateHigh(Vector64<int> addend, Vector64<int> left, Vector64<int> right, byte rightIndex);
        public static Vector64<short> RoundedDoublingMultiplyAddBySelectedScalarSaturateHigh(Vector64<short> addend, Vector64<short> left, Vector128<short> right, byte rightIndex);
        public static Vector64<int> RoundedDoublingMultiplyAddBySelectedScalarSaturateHigh(Vector64<int> addend, Vector64<int> left, Vector128<int> right, byte rightIndex);
        public static Vector128<short> RoundedDoublingMultiplyAddBySelectedScalarSaturateHigh(Vector128<short> addend, Vector128<short> left, Vector64<short> right, byte rightIndex);
        public static Vector128<int> RoundedDoublingMultiplyAddBySelectedScalarSaturateHigh(Vector128<int> addend, Vector128<int> left, Vector64<int> right, byte rightIndex);
        public static Vector128<short> RoundedDoublingMultiplyAddBySelectedScalarSaturateHigh(Vector128<short> addend, Vector128<short> left, Vector128<short> right, byte rightIndex);
        public static Vector128<int> RoundedDoublingMultiplyAddBySelectedScalarSaturateHigh(Vector128<int> addend, Vector128<int> left, Vector128<int> right, byte rightIndex);

        public static Vector64<short> RoundedDoublingMultiplyAddSaturateHighScalar(Vector64<short> addend, Vector64<short> left, Vector64<short> right);
        public static Vector64<int> RoundedDoublingMultiplyAddSaturateHighScalar(Vector64<int> addend, Vector64<int> left, Vector64<int> right);

        // TODO: Scalar BySelectedScalar variant

        /// <summary>
        /// Signed saturating rounding doubling multiply subtract returning high half
        /// Corresponds to vector forms of SQRDMLSH and VQRDMLSH
        /// </summary>
        public static Vector64<short> RoundedDoublingMultiplySubtractSaturateHigh(Vector64<short> minuend, Vector64<short> left, Vector64<short> right);
        public static Vector64<int> RoundedDoublingMultiplySubtractSaturateHigh(Vector64<int> minuend, Vector64<int> left, Vector64<int> right);
        public static Vector128<short> RoundedDoublingMultiplySubtractSaturateHigh(Vector128<short> minuend, Vector128<short> left, Vector128<short> right);
        public static Vector128<int> RoundedDoublingMultiplySubtractSaturateHigh(Vector128<int> minuend, Vector128<int> left, Vector128<int> right);

        public static Vector64<short> RoundedDoublingMultiplySubtractBySelectedScalarSaturateHigh(Vector64<short> minuend, Vector64<short> left, Vector64<short> right, byte rightIndex);
        public static Vector64<int> RoundedDoublingMultiplySubtractBySelectedScalarSaturateHigh(Vector64<int> minuend, Vector64<int> left, Vector64<int> right, byte rightIndex);
        public static Vector64<short> RoundedDoublingMultiplySubtractBySelectedScalarSaturateHigh(Vector64<short> minuend, Vector64<short> left, Vector128<short> right, byte rightIndex);
        public static Vector64<int> RoundedDoublingMultiplySubtractBySelectedScalarSaturateHigh(Vector64<int> minuend, Vector64<int> left, Vector128<int> right, byte rightIndex);
        public static Vector128<short> RoundedDoublingMultiplySubtractBySelectedScalarSaturateHigh(Vector128<short> minuend, Vector128<short> left, Vector64<short> right, byte rightIndex);
        public static Vector128<int> RoundedDoublingMultiplySubtractBySelectedScalarSaturateHigh(Vector128<int> minuend, Vector128<int> left, Vector64<int> right, byte rightIndex);
        public static Vector128<short> RoundedDoublingMultiplySubtractBySelectedScalarSaturateHigh(Vector128<short> minuend, Vector128<short> left, Vector128<short> right, byte rightIndex);
        public static Vector128<int> RoundedDoublingMultiplySubtractBySelectedScalarSaturateHigh(Vector128<int> minuend, Vector128<int> left, Vector128<int> right, byte rightIndex);

        public static Vector64<short> RoundedDoublingMultiplySubtractSaturateHighScalar(Vector64<short> minuend, Vector64<short> left, Vector64<short> right);
        public static Vector64<int> RoundedDoublingMultiplySubtractSaturateHighScalar(Vector64<int> minuend, Vector64<int> left, Vector64<int> right);

        // TODO: Scalar BySelectedScalar variant

        /// <summary>
        /// Signed saturating Doubling Multiply-Add Long
        /// Corresponds to vector forms of SQDMULL and VQDMULL
        /// </summary>
        public static Vector64<short> DoublingMultiplyWideningLowerSaturate(Vector64<short> left, Vector64<short> right);
        public static Vector64<int> DoublingMultiplyWideningLowerSaturate(Vector64<int> left, Vector64<int> right);
        public static Vector128<short> DoublingMultiplyWideningLowerSaturate(Vector128<short> left, Vector128<short> right);
        public static Vector128<int> DoublingMultiplyWideningLowerSaturate(Vector128<int> left, Vector128<int> right);

        public static Vector64<short> DoublingMultiplyWideningLowerBySelectedScalarSaturate(Vector64<short> left, Vector64<short> right, byte rightIndex);
        public static Vector64<int> DoublingMultiplyWideningLowerBySelectedScalarSaturate(Vector64<int> left, Vector64<int> right, byte rightIndex);
        public static Vector64<short> DoublingMultiplyWideningLowerBySelectedScalarSaturate(Vector64<short> left, Vector128<short> right, byte rightIndex);
        public static Vector64<int> DoublingMultiplyWideningLowerBySelectedScalarSaturate(Vector64<int> left, Vector128<int> right, byte rightIndex);
        public static Vector128<short> DoublingMultiplyWideningLowerBySelectedScalarSaturate(Vector128<short> left, Vector64<short> right, byte rightIndex);
        public static Vector128<int> DoublingMultiplyWideningLowerBySelectedScalarSaturate(Vector128<int> left, Vector64<int> right, byte rightIndex);
        public static Vector128<short> DoublingMultiplyWideningLowerBySelectedScalarSaturate(Vector128<short> left, Vector128<short> right, byte rightIndex);
        public static Vector128<int> DoublingMultiplyWideningLowerBySelectedScalarSaturate(Vector128<int> left, Vector128<int> right, byte rightIndex);

        public static Vector64<short> DoublingMultiplyWideningLowerSaturateScalar(Vector64<short> left, Vector64<short> right);
        public static Vector64<int> DoublingMultiplyWideningLowerSaturateScalar(Vector64<int> left, Vector64<int> right);

        // TODO: Scalar BySelectedScalar variant

        /// <summary>
        /// Signed saturating Doubling Multiply-Add Long
        /// Corresponds to vector forms of SQDMLAL and VQDMLAL
        /// </summary>
        public static Vector64<short> DoublingMultiplyAddWideningLowerSaturate(Vector64<short> addend, Vector64<short> left, Vector64<short> right);
        public static Vector64<int> DoublingMultiplyAddWideningLowerSaturate(Vector64<int> addend, Vector64<int> left, Vector64<int> right);
        public static Vector128<short> DoublingMultiplyAddWideningLowerSaturate(Vector128<short> addend, Vector128<short> left, Vector128<short> right);
        public static Vector128<int> DoublingMultiplyAddWideningLowerSaturate(Vector128<int> addend, Vector128<int> left, Vector128<int> right);

        public static Vector64<short> DoublingMultiplyAddWideningLowerBySelectedScalarSaturate(Vector64<short> addend, Vector64<short> left, Vector64<short> right, byte rightIndex);
        public static Vector64<int> DoublingMultiplyAddWideningLowerBySelectedScalarSaturate(Vector64<int> addend, Vector64<int> left, Vector64<int> right, byte rightIndex);
        public static Vector64<short> DoublingMultiplyAddWideningLowerBySelectedScalarSaturate(Vector64<short> addend, Vector64<short> left, Vector128<short> right, byte rightIndex);
        public static Vector64<int> DoublingMultiplyAddWideningLowerBySelectedScalarSaturate(Vector64<int> addend, Vector64<int> left, Vector128<int> right, byte rightIndex);
        public static Vector128<short> DoublingMultiplyAddWideningLowerBySelectedScalarSaturate(Vector128<short> addend, Vector128<short> left, Vector64<short> right, byte rightIndex);
        public static Vector128<int> DoublingMultiplyAddWideningLowerBySelectedScalarSaturate(Vector128<int> addend, Vector128<int> left, Vector64<int> right, byte rightIndex);
        public static Vector128<short> DoublingMultiplyAddWideningLowerBySelectedScalarSaturate(Vector128<short> addend, Vector128<short> left, Vector128<short> right, byte rightIndex);
        public static Vector128<int> DoublingMultiplyAddWideningLowerBySelectedScalarSaturate(Vector128<int> addend, Vector128<int> left, Vector128<int> right, byte rightIndex);

        public static Vector64<short> DoublingMultiplyAddWideningLowerSaturateScalar(Vector64<short> addend, Vector64<short> left, Vector64<short> right);
        public static Vector64<int> DoublingMultiplyAddWideningLowerSaturateScalar(Vector64<int> addend, Vector64<int> left, Vector64<int> right);

        // TODO: Scalar BySelectedScalar variant

        /// <summary>
        /// Signed saturating Doubling Multiply-Subtract Long
        /// Corresponds to vector forms of SQDMLSL and VQDMLSL
        /// </summary>
        public static Vector64<short> DoublingMultiplySubtractWideningLowerSaturate(Vector64<short> minuend, Vector64<short> left, Vector64<short> right);
        public static Vector64<int> DoublingMultiplySubtractWideningLowerSaturate(Vector64<int> minuend, Vector64<int> left, Vector64<int> right);
        public static Vector128<short> DoublingMultiplySubtractWideningLowerSaturate(Vector128<short> minuend, Vector128<short> left, Vector128<short> right);
        public static Vector128<int> DoublingMultiplySubtractWideningLowerSaturate(Vector128<int> minuend, Vector128<int> left, Vector128<int> right);

        public static Vector64<short> DoublingMultiplySubtractWideningLowerBySelectedScalarSaturate(Vector64<short> minuend, Vector64<short> left, Vector64<short> right, byte rightIndex);
        public static Vector64<int> DoublingMultiplySubtractWideningLowerBySelectedScalarSaturate(Vector64<int> minuend, Vector64<int> left, Vector64<int> right, byte rightIndex);
        public static Vector64<short> DoublingMultiplySubtractWideningLowerBySelectedScalarSaturate(Vector64<short> minuend, Vector64<short> left, Vector128<short> right, byte rightIndex);
        public static Vector64<int> DoublingMultiplySubtractWideningLowerBySelectedScalarSaturate(Vector64<int> minuend, Vector64<int> left, Vector128<int> right, byte rightIndex);
        public static Vector128<short> DoublingMultiplySubtractWideningLowerBySelectedScalarSaturate(Vector128<short> minuend, Vector128<short> left, Vector64<short> right, byte rightIndex);
        public static Vector128<int> DoublingMultiplySubtractWideningLowerBySelectedScalarSaturate(Vector128<int> minuend, Vector128<int> left, Vector64<int> right, byte rightIndex);
        public static Vector128<short> DoublingMultiplySubtractWideningLowerBySelectedScalarSaturate(Vector128<short> minuend, Vector128<short> left, Vector128<short> right, byte rightIndex);
        public static Vector128<int> DoublingMultiplySubtractWideningLowerBySelectedScalarSaturate(Vector128<int> minuend, Vector128<int> left, Vector128<int> right, byte rightIndex);

        public static Vector64<short> DoublingMultiplySubtractWideningLowerSaturateScalar(Vector64<short> minuend, Vector64<short> left, Vector64<short> right);
        public static Vector64<int> DoublingMultiplySubtractWideningLowerSaturateScalar(Vector64<int> minuend, Vector64<int> left, Vector64<int> right);

        // TODO: Scalar BySelectedScalar variant
    }
}
@ghost
Copy link

ghost commented May 19, 2020

Tagging subscribers to this area: @tannergooding
Notify danmosemsft if you want to be subscribed.

@Dotnet-GitSync-Bot Dotnet-GitSync-Bot added the untriaged New issue has not been triaged by the area owner label May 19, 2020
@tannergooding
Copy link
Member Author

CC. @CarolEidt, @echesakovMSFT, @TamarChristinaArm

@tannergooding tannergooding removed the untriaged New issue has not been triaged by the area owner label May 26, 2020
@echesakov echesakov self-assigned this Jun 18, 2020
@echesakov
Copy link
Contributor

SQRDMLAH and SQRDMLSH should not be exposed here - they belong to ARMv8.1

@echesakov echesakov added this to the 5.0.0 milestone Jun 19, 2020
@echesakov echesakov mentioned this issue Jun 24, 2020
Merged
@terrajobst
Copy link
Member

terrajobst commented Jun 25, 2020 •
edited
Loading

Video

  • The TODO versions are also approved
namespace System.Runtime.Intrinsics.Arm
{
    public abstract class AdvSimd
    {
        public static Vector64<short>  MultiplyDoublingSaturateHigh(Vector64<short>  left, Vector64<short>  right);
        public static Vector64<int>    MultiplyDoublingSaturateHigh(Vector64<int>    left, Vector64<int>    right);
        public static Vector128<short> MultiplyDoublingSaturateHigh(Vector128<short> left, Vector128<short> right);
        public static Vector128<int>   MultiplyDoublingSaturateHigh(Vector128<int>   left, Vector128<int>   right);

        public static Vector64<short>  MultiplyDoublingBySelectedScalarSaturateHigh(Vector64<short>  left, Vector64<short>  right, byte rightIndex);
        public static Vector64<int>    MultiplyDoublingBySelectedScalarSaturateHigh(Vector64<int>    left, Vector64<int>    right, byte rightIndex);
        public static Vector64<short>  MultiplyDoublingBySelectedScalarSaturateHigh(Vector64<short>  left, Vector128<short> right, byte rightIndex);
        public static Vector64<int>    MultiplyDoublingBySelectedScalarSaturateHigh(Vector64<int>    left, Vector128<int>   right, byte rightIndex);
        public static Vector128<short> MultiplyDoublingBySelectedScalarSaturateHigh(Vector128<short> left, Vector64<short>  right, byte rightIndex);
        public static Vector128<int>   MultiplyDoublingBySelectedScalarSaturateHigh(Vector128<int>   left, Vector64<int>    right, byte rightIndex);
        public static Vector128<short> MultiplyDoublingBySelectedScalarSaturateHigh(Vector128<short> left, Vector128<short> right, byte rightIndex);
        public static Vector128<int>   MultiplyDoublingBySelectedScalarSaturateHigh(Vector128<int>   left, Vector128<int>   right, byte rightIndex);

        public static Vector64<short>  MultiplyDoublingSaturateHighScalar(Vector64<short> left, Vector64<short> right);
        public static Vector64<int>    MultiplyDoublingSaturateHighScalar(Vector64<int>   left, Vector64<int>   right);

        // TODO: Scalar BySelectedScalar variant

        public static Vector64<short>  MultiplyRoundedDoublingSaturateHigh(Vector64<short>  left, Vector64<short>  right);
        public static Vector64<int>    MultiplyRoundedDoublingSaturateHigh(Vector64<int>    left, Vector64<int>    right);
        public static Vector128<short> MultiplyRoundedDoublingSaturateHigh(Vector128<short> left, Vector128<short> right);
        public static Vector128<int>   MultiplyRoundedDoublingSaturateHigh(Vector128<int>   left, Vector128<int>   right);

        public static Vector64<short>  MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector64<short>  left, Vector64<short>  right, byte rightIndex);
        public static Vector64<int>    MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector64<int>    left, Vector64<int>    right, byte rightIndex);
        public static Vector64<short>  MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector64<short>  left, Vector128<short> right, byte rightIndex);
        public static Vector64<int>    MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector64<int>    left, Vector128<int>   right, byte rightIndex);
        public static Vector128<short> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector128<short> left, Vector64<short>  right, byte rightIndex);
        public static Vector128<int>   MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector128<int>   left, Vector64<int>    right, byte rightIndex);
        public static Vector128<short> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector128<short> left, Vector128<short> right, byte rightIndex);
        public static Vector128<int>   MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector128<int>   left, Vector128<int>   right, byte rightIndex);

        public static Vector64<short>  MultiplyRoundedDoublingSaturateHighScalar(Vector64<short> left, Vector64<short> right);
        public static Vector64<int>    MultiplyRoundedDoublingSaturateHighScalar(Vector64<int>   left, Vector64<int>   right);

        // TODO: Scalar BySelectedScalar variant

        public static Vector64<short>  MultiplyDoublingWideningSaturateLower(Vector64<short>  left, Vector64<short>  right);
        public static Vector64<int>    MultiplyDoublingWideningSaturateLower(Vector64<int>    left, Vector64<int>    right);
        public static Vector128<short> MultiplyDoublingWideningSaturateLower(Vector128<short> left, Vector128<short> right);
        public static Vector128<int>   MultiplyDoublingWideningSaturateLower(Vector128<int>   left, Vector128<int>   right);

        public static Vector64<short>  MultiplyDoublingWideningLowerBySelectedScalarSaturate(Vector64<short>  left, Vector64<short>  right, byte rightIndex);
        public static Vector64<int>    MultiplyDoublingWideningLowerBySelectedScalarSaturate(Vector64<int>    left, Vector64<int>    right, byte rightIndex);
        public static Vector64<short>  MultiplyDoublingWideningLowerBySelectedScalarSaturate(Vector64<short>  left, Vector128<short> right, byte rightIndex);
        public static Vector64<int>    MultiplyDoublingWideningLowerBySelectedScalarSaturate(Vector64<int>    left, Vector128<int>   right, byte rightIndex);
        public static Vector128<short> MultiplyDoublingWideningLowerBySelectedScalarSaturate(Vector128<short> left, Vector64<short>  right, byte rightIndex);
        public static Vector128<int>   MultiplyDoublingWideningLowerBySelectedScalarSaturate(Vector128<int>   left, Vector64<int>    right, byte rightIndex);
        public static Vector128<short> MultiplyDoublingWideningLowerBySelectedScalarSaturate(Vector128<short> left, Vector128<short> right, byte rightIndex);
        public static Vector128<int>   MultiplyDoublingWideningLowerBySelectedScalarSaturate(Vector128<int>   left, Vector128<int>   right, byte rightIndex);

        public static Vector64<short>  MultiplyDoublingWideningSaturateLowerScalar(Vector64<short> left, Vector64<short> right);
        public static Vector64<int>    MultiplyDoublingWideningSaturateLowerScalar(Vector64<int>   left, Vector64<int>   right);

        // TODO: Scalar BySelectedScalar variant

        public static Vector64<short>  MultiplyDoublingAddWideningLowerSaturate(Vector64<short>  addend, Vector64<short>  left, Vector64<short>  right);
        public static Vector64<int>    MultiplyDoublingAddWideningLowerSaturate(Vector64<int>    addend, Vector64<int>    left, Vector64<int>    right);
        public static Vector128<short> MultiplyDoublingAddWideningLowerSaturate(Vector128<short> addend, Vector128<short> left, Vector128<short> right);
        public static Vector128<int>   MultiplyDoublingAddWideningLowerSaturate(Vector128<int>   addend, Vector128<int>   left, Vector128<int>   right);

        public static Vector64<short>  MultiplyDoublingAddWideningLowerBySelectedScalarSaturate(Vector64<short>  addend, Vector64<short>  left, Vector64<short>  right, byte rightIndex);
        public static Vector64<int>    MultiplyDoublingAddWideningLowerBySelectedScalarSaturate(Vector64<int>    addend, Vector64<int>    left, Vector64<int>    right, byte rightIndex);
        public static Vector64<short>  MultiplyDoublingAddWideningLowerBySelectedScalarSaturate(Vector64<short>  addend, Vector64<short>  left, Vector128<short> right, byte rightIndex);
        public static Vector64<int>    MultiplyDoublingAddWideningLowerBySelectedScalarSaturate(Vector64<int>    addend, Vector64<int>    left, Vector128<int>   right, byte rightIndex);
        public static Vector128<short> MultiplyDoublingAddWideningLowerBySelectedScalarSaturate(Vector128<short> addend, Vector128<short> left, Vector64<short>  right, byte rightIndex);
        public static Vector128<int>   MultiplyDoublingAddWideningLowerBySelectedScalarSaturate(Vector128<int>   addend, Vector128<int>   left, Vector64<int>    right, byte rightIndex);
        public static Vector128<short> MultiplyDoublingAddWideningLowerBySelectedScalarSaturate(Vector128<short> addend, Vector128<short> left, Vector128<short> right, byte rightIndex);
        public static Vector128<int>   MultiplyDoublingAddWideningLowerBySelectedScalarSaturate(Vector128<int>   addend, Vector128<int>   left, Vector128<int>   right, byte rightIndex);

        public static Vector64<short> MultiplyDoublingAddWideningLowerSaturateScalar(Vector64<short> addend, Vector64<short> left, Vector64<short> right);
        public static Vector64<int>   MultiplyDoublingAddWideningLowerSaturateScalar(Vector64<int>   addend, Vector64<int>   left, Vector64<int>   right);

        // TODO: Scalar BySelectedScalar variant

        public static Vector64<short>  MultiplyDoublingSubtractWideningLowerSaturate(Vector64<short>  minuend, Vector64<short>  left, Vector64<short>  right);
        public static Vector64<int>    MultiplyDoublingSubtractWideningLowerSaturate(Vector64<int>    minuend, Vector64<int>    left, Vector64<int>    right);
        public static Vector128<short> MultiplyDoublingSubtractWideningLowerSaturate(Vector128<short> minuend, Vector128<short> left, Vector128<short> right);
        public static Vector128<int>   MultiplyDoublingSubtractWideningLowerSaturate(Vector128<int>   minuend, Vector128<int>   left, Vector128<int>   right);

        public static Vector64<short>  MultiplyDoublingSubtractWideningLowerBySelectedScalarSaturate(Vector64<short>  minuend, Vector64<short>  left, Vector64<short>  right, byte rightIndex);
        public static Vector64<int>    MultiplyDoublingSubtractWideningLowerBySelectedScalarSaturate(Vector64<int>    minuend, Vector64<int>    left, Vector64<int>    right, byte rightIndex);
        public static Vector64<short>  MultiplyDoublingSubtractWideningLowerBySelectedScalarSaturate(Vector64<short>  minuend, Vector64<short>  left, Vector128<short> right, byte rightIndex);
        public static Vector64<int>    MultiplyDoublingSubtractWideningLowerBySelectedScalarSaturate(Vector64<int>    minuend, Vector64<int>    left, Vector128<int>   right, byte rightIndex);
        public static Vector128<short> MultiplyDoublingSubtractWideningLowerBySelectedScalarSaturate(Vector128<short> minuend, Vector128<short> left, Vector64<short>  right, byte rightIndex);
        public static Vector128<int>   MultiplyDoublingSubtractWideningLowerBySelectedScalarSaturate(Vector128<int>   minuend, Vector128<int>   left, Vector64<int>    right, byte rightIndex);
        public static Vector128<short> MultiplyDoublingSubtractWideningLowerBySelectedScalarSaturate(Vector128<short> minuend, Vector128<short> left, Vector128<short> right, byte rightIndex);
        public static Vector128<int>   MultiplyDoublingSubtractWideningLowerBySelectedScalarSaturate(Vector128<int>   minuend, Vector128<int>   left, Vector128<int>   right, byte rightIndex);

        public static Vector64<short>  MultiplyDoublingSubtractWideningLowerSaturateScalar(Vector64<short> minuend, Vector64<short> left, Vector64<short> right);
        public static Vector64<int>    MultiplyDoublingSubtractWideningLowerSaturateScalar(Vector64<int>   minuend, Vector64<int>   left, Vector64<int>   right);

        // TODO: Scalar BySelectedScalar variant
    }

    public abstract class Rdm : AdvSimd
    {
        public static bool IsSupported { get; }

        // TODO: Scalar BySelectedScalar variant

        public static Vector64<short>  MultiplyRoundedDoublingAddSaturateHigh(Vector64<short>  addend, Vector64<short>  left, Vector64<short>   right);
        public static Vector64<int>    MultiplyRoundedDoublingAddSaturateHigh(Vector64<int>    addend, Vector64<int>    left, Vector64<int>     right);
        public static Vector128<short> MultiplyRoundedDoublingAddSaturateHigh(Vector128<short> addend, Vector128<short> left, Vector128<short>  right);
        public static Vector128<int>   MultiplyRoundedDoublingAddSaturateHigh(Vector128<int>   addend, Vector128<int>   left, Vector128<int>    right);

        public static Vector64<short>  MultiplyRoundedDoublingAddBySelectedScalarSaturateHigh(Vector64<short>  addend, Vector64<short>  left, Vector64<short>  right, byte rightIndex);
        public static Vector64<int>    MultiplyRoundedDoublingAddBySelectedScalarSaturateHigh(Vector64<int>    addend, Vector64<int>    left, Vector64<int>    right, byte rightIndex);
        public static Vector64<short>  MultiplyRoundedDoublingAddBySelectedScalarSaturateHigh(Vector64<short>  addend, Vector64<short>  left, Vector128<short> right, byte rightIndex);
        public static Vector64<int>    MultiplyRoundedDoublingAddBySelectedScalarSaturateHigh(Vector64<int>    addend, Vector64<int>    left, Vector128<int>   right, byte rightIndex);
        public static Vector128<short> MultiplyRoundedDoublingAddBySelectedScalarSaturateHigh(Vector128<short> addend, Vector128<short> left, Vector64<short>  right, byte rightIndex);
        public static Vector128<int>   MultiplyRoundedDoublingAddBySelectedScalarSaturateHigh(Vector128<int>   addend, Vector128<int>   left, Vector64<int>    right, byte rightIndex);
        public static Vector128<short> MultiplyRoundedDoublingAddBySelectedScalarSaturateHigh(Vector128<short> addend, Vector128<short> left, Vector128<short> right, byte rightIndex);
        public static Vector128<int>   MultiplyRoundedDoublingAddBySelectedScalarSaturateHigh(Vector128<int>   addend, Vector128<int>   left, Vector128<int>   right, byte rightIndex);

        public static Vector64<short>  MultiplyRoundedDoublingAddSaturateHighScalar(Vector64<short> addend, Vector64<short> left, Vector64<short> right);
        public static Vector64<int>    MultiplyRoundedDoublingAddSaturateHighScalar(Vector64<int>   addend, Vector64<int>   left, Vector64<int> right);

        // TODO: Scalar BySelectedScalar variant

        public static Vector64<short>  MultiplyRoundedDoublingSubtractSaturateHigh(Vector64<short>  minuend, Vector64<short>  left, Vector64<short>  right);
        public static Vector64<int>    MultiplyRoundedDoublingSubtractSaturateHigh(Vector64<int>    minuend, Vector64<int>    left, Vector64<int>    right);
        public static Vector128<short> MultiplyRoundedDoublingSubtractSaturateHigh(Vector128<short> minuend, Vector128<short> left, Vector128<short> right);
        public static Vector128<int>   MultiplyRoundedDoublingSubtractSaturateHigh(Vector128<int>   minuend, Vector128<int>   left, Vector128<int>   right);

        public static Vector64<short>  MultiplyRoundedDoublingSubtractBySelectedScalarSaturateHigh(Vector64<short>  minuend, Vector64<short>  left, Vector64<short>  right, byte rightIndex);
        public static Vector64<int>    MultiplyRoundedDoublingSubtractBySelectedScalarSaturateHigh(Vector64<int>    minuend, Vector64<int>    left, Vector64<int>    right, byte rightIndex);
        public static Vector64<short>  MultiplyRoundedDoublingSubtractBySelectedScalarSaturateHigh(Vector64<short>  minuend, Vector64<short>  left, Vector128<short> right, byte rightIndex);
        public static Vector64<int>    MultiplyRoundedDoublingSubtractBySelectedScalarSaturateHigh(Vector64<int>    minuend, Vector64<int>    left, Vector128<int>   right, byte rightIndex);
        public static Vector128<short> MultiplyRoundedDoublingSubtractBySelectedScalarSaturateHigh(Vector128<short> minuend, Vector128<short> left, Vector64<short>  right, byte rightIndex);
        public static Vector128<int>   MultiplyRoundedDoublingSubtractBySelectedScalarSaturateHigh(Vector128<int>   minuend, Vector128<int>   left, Vector64<int>    right, byte rightIndex);
        public static Vector128<short> MultiplyRoundedDoublingSubtractBySelectedScalarSaturateHigh(Vector128<short> minuend, Vector128<short> left, Vector128<short> right, byte rightIndex);
        public static Vector128<int>   MultiplyRoundedDoublingSubtractBySelectedScalarSaturateHigh(Vector128<int>   minuend, Vector128<int>   left, Vector128<int>   right, byte rightIndex);

        public static Vector64<short>  MultiplyRoundedDoublingSubtractSaturateHighScalar(Vector64<short> minuend, Vector64<short> left, Vector64<short> right);
        public static Vector64<int>    MultiplyRoundedDoublingSubtractSaturateHighScalar(Vector64<int>   minuend, Vector64<int>   left, Vector64<int>   right);    
    }
}

@terrajobst terrajobst added api-approved API was approved in API review, it can be implemented and removed api-ready-for-review labels Jun 25, 2020
This was referenced Jul 2, 2020
Merged
Merged
@ghost ghost locked as resolved and limited conversation to collaborators Dec 9, 2020
Sign up for free to subscribe to this conversation on GitHub. Already have an account? Sign in.
Assignees

@echesakov echesakov

Labels
api-approved API was approved in API review, it can be implemented arch-arm64 area-System.Runtime.Intrinsics
Projects
None yet
Milestone
5.0.0
Development

Successfully merging a pull request may close this issue.

[Arm64] ASIMD DotProduct and Rounding Double Multiply Add/Subtract echesakov/runtime
4 participants
@terrajobst @echesakov @tannergooding @Dotnet-GitSync-Bot