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

[API Proposal]: Arm64: FEAT_SVE2: bitwise #94015

Open
a74nh opened this issue Oct 26, 2023 · 10 comments
Open

[API Proposal]: Arm64: FEAT_SVE2: bitwise #94015

a74nh opened this issue Oct 26, 2023 · 10 comments
Labels
api-approved API was approved in API review, it can be implemented area-System.Runtime.Intrinsics
Milestone
10.0.0

Comments

@a74nh
Copy link
Contributor

a74nh commented Oct 26, 2023 •
edited by tannergooding
Loading 

namespace System.Runtime.Intrinsics.Arm

/// VectorT Summary
public abstract class Sve2 : Sve /// Feature: FEAT_SVE2  Category: bitwise
{
  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  /// op1 ^ (op2 & ~op3)
  public static unsafe Vector<T> BitwiseClearXor(Vector<T> op1, Vector<T> op2, Vector<T> op3); // BCAX // MOVPRFX

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> BitwiseSelect(Vector<T> select, Vector<T> left, Vector<T> right); // BSL // MOVPRFX

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> BitwiseSelectLeftInverted(Vector<T> select, Vector<T> left, Vector<T> right); // BSL1N // MOVPRFX

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> BitwiseSelectInverted(Vector<T> select, Vector<T> left, Vector<T> right); // NBSL // MOVPRFX

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> BitwiseSelectRightInverted(Vector<T> select, Vector<T> left, Vector<T> right); // BSL2N // MOVPRFX

  /// T: sbyte, short, int, long
  public static unsafe Vector<T> ShiftArithmeticRounded(Vector<T> value, Vector<T> count); // SRSHL or SRSHLR // predicated, MOVPRFX

  /// T: [byte, sbyte], [ushort, short], [uint, int], [ulong, long]
  public static unsafe Vector<T> ShiftLogicalRounded(Vector<T> value, Vector<T2> count); // URSHL or URSHLR // predicated, MOVPRFX

  /// T: sbyte, short, int, long
  public static unsafe Vector<T> ShiftRightArithmeticRounded(Vector<T> value, [ConstantExpected] byte count); // SRSHR // predicated, MOVPRFX

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> ShiftRightLogicalRounded(Vector<T> value, [ConstantExpected] byte count); // URSHR // predicated, MOVPRFX

  /// T: sbyte, short, int, long
  public static unsafe Vector<T> ShiftRightArithmeticRoundedAdd(Vector<T> addend, Vector<T> value, [ConstantExpected] byte count); // SRSRA // MOVPRFX

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> ShiftRightLogicalRoundedAdd(Vector<T> addend, Vector<T> value, [ConstantExpected] byte count); // URSRA // MOVPRFX

  /// T: [sbyte, short], [short, int], [int, long], [byte, ushort], [ushort, uint], [uint, ulong]
  public static unsafe Vector<T> ShiftRightLogicalRoundedNarrowingEven(Vector<T2> value, [ConstantExpected] byte count); // RSHRNB

  /// T: [sbyte, short], [short, int], [int, long], [byte, ushort], [ushort, uint], [uint, ulong]
  public static unsafe Vector<T> ShiftRightLogicalRoundedNarrowingOdd(Vector<T> even, Vector<T2> value, [ConstantExpected] byte count); // RSHRNT

  /// T: sbyte, short, int, long
  public static unsafe Vector<T> ShiftArithmeticRoundedSaturate(Vector<T> value, Vector<T> count); // SQRSHL or SQRSHLR // predicated, MOVPRFX

  /// T: [byte, sbyte], [ushort, short], [uint, int], [ulong, long]
  public static unsafe Vector<T> ShiftLogicalRoundedSaturate(Vector<T> value, Vector<T2> count); // UQRSHL or UQRSHLR // predicated, MOVPRFX

  /// T: [sbyte, short], [short, int], [int, long]
  public static unsafe Vector<T> ShiftRightArithmeticRoundedNarrowingSaturateEven(Vector<T2> value, [ConstantExpected] byte count); // SQRSHRNB

  /// T: [sbyte, short], [short, int], [int, long]
  public static unsafe Vector<T> ShiftRightArithmeticRoundedNarrowingSaturateOdd(Vector<T> even, Vector<T2> value, [ConstantExpected] byte count); // SQRSHRNT 
  
  /// T: [sbyte, short], [short, int], [int, long], [byte, ushort], [ushort, uint], [uint, ulong]
  public static unsafe Vector<T> ShiftRightLogicalRoundedNarrowingSaturateEven(Vector<T2> value, [ConstantExpected] byte count); // UQRSHRNB

  /// T: [sbyte, short], [short, int], [int, long], [byte, ushort], [ushort, uint], [uint, ulong]
  public static unsafe Vector<T> ShiftRightLogicalRoundedNarrowingSaturateOdd(Vector<T> even, Vector<T2> value, [ConstantExpected] byte count); // UQRSHRNT

  /// T: [byte, short], [ushort, int], [uint, long]
  public static unsafe Vector<T> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedEven(Vector<T2> value, [ConstantExpected] byte count); // SQRSHRUNB

  /// T: [byte, short], [ushort, int], [uint, long]
  public static unsafe Vector<T> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedOdd(Vector<T> even, Vector<T2> value, [ConstantExpected] byte count); // SQRSHRUNT

  /// T: sbyte, short, int, long
  public static unsafe Vector<T> ShiftArithmeticSaturate(Vector<T> value, Vector<T> count); // SQSHL or SQSHLR // predicated, MOVPRFX

  /// T: [byte, sbyte], [ushort, short], [uint, int], [ulong, long]
  public static unsafe Vector<T> ShiftLeftLogicalSaturate(Vector<T> value, Vector<T2> count); // UQSHL or UQSHLR // predicated, MOVPRFX

  /// T: [byte, sbyte], [ushort, short], [uint, int], [ulong, long]
  public static unsafe Vector<T> ShiftLeftLogicalSaturateUnsigned(Vector<T2> value, [ConstantExpected] byte count); // SQSHLU // predicated, MOVPRFX

  /// T: [sbyte, short], [short, int], [int, long], [byte, ushort], [ushort, uint], [uint, ulong]
  public static unsafe Vector<T>  ShiftRightArithmeticNarrowingSaturateEven(Vector<T2> value, [ConstantExpected] byte count); // SQSHRNB or UQSHRNB

  /// T: [sbyte, short], [short, int], [int, long], [byte, ushort], [ushort, uint], [uint, ulong]
  public static unsafe Vector<T>  ShiftRightArithmeticNarrowingSaturateOdd(Vector<T> even, Vector<T2> value, [ConstantExpected] byte count); // SQSHRNT or UQSHRNT

  /// T: [byte, short], [ushort, int], [uint, long]
  public static unsafe Vector<T> ShiftRightArithmeticNarrowingSaturateUnsignedEven(Vector<T2> value, [ConstantExpected] byte count); // SQSHRUNB

  /// T: [byte, short], [ushort, int], [uint, long]
  public static unsafe Vector<T> ShiftRightArithmeticNarrowingSaturateUnsignedOdd(Vector<T> even, Vector<T2> value, [ConstantExpected] byte count); // SQSHRUNT

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> ShiftLeftAndInsert(Vector<T> left, Vector<T> right, [ConstantExpected] byte shift); // SLI

  /// T: [short, sbyte], [int, short], [long, int], [ushort, byte], [uint, ushort], [ulong, uint]
  public static unsafe Vector<T> ShiftLeftLogicalWideningEven(Vector<T2> value, [ConstantExpected] byte count); // SSHLLB or USHLLB

  /// T: [short, sbyte], [int, short], [long, int], [ushort, byte], [uint, ushort], [ulong, uint]
  public static unsafe Vector<T> ShiftLeftLogicalWideningOdd(Vector<T2> value, [ConstantExpected] byte count); // SSHLLT or USHLLT

  /// T: sbyte, short, int, long
  public static unsafe Vector<T> ShiftRightArithmeticAdd(Vector<T> addend, Vector<T> value, [ConstantExpected] byte count); // SSRA // MOVPRFX
  
  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> ShiftRightLogicalAdd(Vector<T> addend, Vector<T> value, [ConstantExpected] byte count); // USRA // MOVPRFX

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> ShiftRightAndInsert(Vector<T> left, Vector<T> right, [ConstantExpected] byte shift); // SRI

  /// T: [sbyte, short], [short, int], [int, long], [byte, ushort], [ushort, uint], [uint, ulong]
  public static unsafe Vector<T> ShiftRightLogicalNarrowingEven(Vector<T2> value, [ConstantExpected] byte count); // SHRNB

  /// T: [sbyte, short], [short, int], [int, long], [byte, ushort], [ushort, uint], [uint, ulong]
  public static unsafe Vector<T> ShiftRightLogicalNarrowingOdd(Vector<T> even, Vector<T2> value, [ConstantExpected] byte count); // SHRNT

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> Xor(Vector<T> op1, Vector<T> op2, Vector<T> op3); // EOR3 // MOVPRFX

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> XorRotateRight(Vector<T> op1, Vector<T> op2, ulong imm3); // XAR // MOVPRFX

  /// total method signatures: 33
}
@ghost ghost added the untriaged New issue has not been triaged by the area owner label Oct 26, 2023
@ghost
Copy link

ghost commented Oct 26, 2023

Tagging subscribers to this area: @dotnet/area-system-numerics
See info in area-owners.md if you want to be subscribed.

Issue Details 
namespace System.Runtime.Intrinsics.Arm

/// VectorT Summary
public abstract class Sve : AdvSimd /// Feature: FEAT_SVE2  Category: bitwise
{
  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> BitwiseClearXor(Vector<T> op1, Vector<T> op2, Vector<T> op3); // BCAX (MOVPRFX)

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> BitwiseSelect(Vector<T> op1, Vector<T> op2, Vector<T> op3); // BSL (MOVPRFX)

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> BitwiseSelectFirstInverted(Vector<T> op1, Vector<T> op2, Vector<T> op3); // BSL1N (MOVPRFX)

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> BitwiseSelectInverted(Vector<T> op1, Vector<T> op2, Vector<T> op3); // NBSL (MOVPRFX)

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> BitwiseSelectSecondInverted(Vector<T> op1, Vector<T> op2, Vector<T> op3); // BSL2N (MOVPRFX)

  /// T: sbyte, short, int, long
  public static unsafe Vector<T> RoundingShiftLeft(Vector<T> left, Vector<T> right); // SRSHL or SRSHLR (MOVPRFX)

  /// T: [byte, sbyte], [ushort, short], [uint, int], [ulong, long]
  public static unsafe Vector<T> RoundingShiftLeft(Vector<T> left, Vector<T2> right); // URSHL or URSHLR (MOVPRFX)

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> RoundingShiftRight(Vector<T> op1, ulong imm2); // SRSHR or URSHR (MOVPRFX)

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> RoundingShiftRightAndAccumulate(Vector<T> op1, Vector<T> op2, ulong imm3); // SRSRA or URSRA (MOVPRFX)

  /// T: [sbyte, short], [short, int], [int, long], [byte, ushort], [ushort, uint], [uint, ulong]
  public static unsafe Vector<T> RoundingShiftRightNarrowingLower(Vector<T2> op1, ulong imm2); // RSHRNB

  /// T: [sbyte, short], [short, int], [int, long], [byte, ushort], [ushort, uint], [uint, ulong]
  public static unsafe Vector<T> RoundingShiftRightNarrowingUpper(Vector<T> even, Vector<T2> op1, ulong imm2); // RSHRNT

  /// T: sbyte, short, int, long
  public static unsafe Vector<T> SaturatingRoundingShiftLeft(Vector<T> left, Vector<T> right); // SQRSHL or SQRSHLR (MOVPRFX)

  /// T: [byte, sbyte], [ushort, short], [uint, int], [ulong, long]
  public static unsafe Vector<T> SaturatingRoundingShiftLeft(Vector<T> left, Vector<T2> right); // UQRSHL or UQRSHLR (MOVPRFX)

  /// T: [sbyte, short], [short, int], [int, long], [byte, ushort], [ushort, uint], [uint, ulong]
  public static unsafe Vector<T> SaturatingRoundingShiftRightNarrowingLower(Vector<T2> op1, ulong imm2); // SQRSHRNB or UQRSHRNB

  /// T: [sbyte, short], [short, int], [int, long], [byte, ushort], [ushort, uint], [uint, ulong]
  public static unsafe Vector<T> SaturatingRoundingShiftRightNarrowingUpper(Vector<T> even, Vector<T2> op1, ulong imm2); // SQRSHRNT or UQRSHRNT

  /// T: [byte, short], [ushort, int], [uint, long]
  public static unsafe Vector<T> SaturatingRoundingShiftRightUnsignedNarrowingLower(Vector<T2> op1, ulong imm2); // SQRSHRUNB

  /// T: [byte, short], [ushort, int], [uint, long]
  public static unsafe Vector<T> SaturatingRoundingShiftRightUnsignedNarrowingUpper(Vector<T> even, Vector<T2> op1, ulong imm2); // SQRSHRUNT

  /// T: sbyte, short, int, long
  public static unsafe Vector<T> SaturatingShiftLeft(Vector<T> left, Vector<T> right); // SQSHL or SQSHLR (MOVPRFX)

  /// T: [byte, sbyte], [ushort, short], [uint, int], [ulong, long]
  public static unsafe Vector<T> SaturatingShiftLeft(Vector<T> left, Vector<T2> right); // UQSHL or UQSHLR (MOVPRFX)

  /// T: [byte, sbyte], [ushort, short], [uint, int], [ulong, long]
  public static unsafe Vector<T> SaturatingShiftLeftUnsigned(Vector<T2> op1, ulong imm2); // SQSHLU (MOVPRFX)

  /// T: [sbyte, short], [short, int], [int, long], [byte, ushort], [ushort, uint], [uint, ulong]
  public static unsafe Vector<T> SaturatingShiftRightNarrowingLower(Vector<T2> op1, ulong imm2); // SQSHRNB or UQSHRNB

  /// T: [sbyte, short], [short, int], [int, long], [byte, ushort], [ushort, uint], [uint, ulong]
  public static unsafe Vector<T> SaturatingShiftRightNarrowingUpper(Vector<T> even, Vector<T2> op1, ulong imm2); // SQSHRNT or UQSHRNT

  /// T: [byte, short], [ushort, int], [uint, long]
  public static unsafe Vector<T> SaturatingShiftRightUnsignedNarrowingLower(Vector<T2> op1, ulong imm2); // SQSHRUNB

  /// T: [byte, short], [ushort, int], [uint, long]
  public static unsafe Vector<T> SaturatingShiftRightUnsignedNarrowingUpper(Vector<T> even, Vector<T2> op1, ulong imm2); // SQSHRUNT

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> ShiftLeftAndInsert(Vector<T> op1, Vector<T> op2, ulong imm3); // SLI

  /// T: [short, sbyte], [int, short], [long, int], [ushort, byte], [uint, ushort], [ulong, uint]
  public static unsafe Vector<T> ShiftLeftWideningLower(Vector<T2> op1, ulong imm2); // SSHLLB or USHLLB

  /// T: [short, sbyte], [int, short], [long, int], [ushort, byte], [uint, ushort], [ulong, uint]
  public static unsafe Vector<T> ShiftLeftWideningUpper(Vector<T2> op1, ulong imm2); // SSHLLT or USHLLT

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> ShiftRightAndAccumulate(Vector<T> op1, Vector<T> op2, ulong imm3); // SSRA or USRA (MOVPRFX)

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> ShiftRightAndInsert(Vector<T> op1, Vector<T> op2, ulong imm3); // SRI

  /// T: [sbyte, short], [short, int], [int, long], [byte, ushort], [ushort, uint], [uint, ulong]
  public static unsafe Vector<T> ShiftRightNarrowingLower(Vector<T2> op1, ulong imm2); // SHRNB

  /// T: [sbyte, short], [short, int], [int, long], [byte, ushort], [ushort, uint], [uint, ulong]
  public static unsafe Vector<T> ShiftRightNarrowingUpper(Vector<T> even, Vector<T2> op1, ulong imm2); // SHRNT

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> Xor(Vector<T> op1, Vector<T> op2, Vector<T> op3); // EOR3 (MOVPRFX)

  /// total method signatures: 32
}
Author: a74nh
Assignees: -
Labels:

area-System.Numerics
Milestone: -

@a74nh
Copy link
Contributor Author

a74nh commented Oct 26, 2023 •
edited
Loading 

/// Full API
public abstract class Sve : AdvSimd /// Feature: FEAT_SVE2  Category: bitwise
{
    /// BitwiseClearXor : Bitwise clear and exclusive OR

    /// svint8_t svbcax[_s8](svint8_t op1, svint8_t op2, svint8_t op3) : "BCAX Ztied1.D, Ztied1.D, Zop2.D, Zop3.D" or "MOVPRFX Zresult, Zop1; BCAX Zresult.D, Zresult.D, Zop2.D, Zop3.D"
  public static unsafe Vector<sbyte> BitwiseClearXor(Vector<sbyte> op1, Vector<sbyte> op2, Vector<sbyte> op3);

    /// svint16_t svbcax[_s16](svint16_t op1, svint16_t op2, svint16_t op3) : "BCAX Ztied1.D, Ztied1.D, Zop2.D, Zop3.D" or "MOVPRFX Zresult, Zop1; BCAX Zresult.D, Zresult.D, Zop2.D, Zop3.D"
  public static unsafe Vector<short> BitwiseClearXor(Vector<short> op1, Vector<short> op2, Vector<short> op3);

    /// svint32_t svbcax[_s32](svint32_t op1, svint32_t op2, svint32_t op3) : "BCAX Ztied1.D, Ztied1.D, Zop2.D, Zop3.D" or "MOVPRFX Zresult, Zop1; BCAX Zresult.D, Zresult.D, Zop2.D, Zop3.D"
  public static unsafe Vector<int> BitwiseClearXor(Vector<int> op1, Vector<int> op2, Vector<int> op3);

    /// svint64_t svbcax[_s64](svint64_t op1, svint64_t op2, svint64_t op3) : "BCAX Ztied1.D, Ztied1.D, Zop2.D, Zop3.D" or "MOVPRFX Zresult, Zop1; BCAX Zresult.D, Zresult.D, Zop2.D, Zop3.D"
  public static unsafe Vector<long> BitwiseClearXor(Vector<long> op1, Vector<long> op2, Vector<long> op3);

    /// svuint8_t svbcax[_u8](svuint8_t op1, svuint8_t op2, svuint8_t op3) : "BCAX Ztied1.D, Ztied1.D, Zop2.D, Zop3.D" or "MOVPRFX Zresult, Zop1; BCAX Zresult.D, Zresult.D, Zop2.D, Zop3.D"
  public static unsafe Vector<byte> BitwiseClearXor(Vector<byte> op1, Vector<byte> op2, Vector<byte> op3);

    /// svuint16_t svbcax[_u16](svuint16_t op1, svuint16_t op2, svuint16_t op3) : "BCAX Ztied1.D, Ztied1.D, Zop2.D, Zop3.D" or "MOVPRFX Zresult, Zop1; BCAX Zresult.D, Zresult.D, Zop2.D, Zop3.D"
  public static unsafe Vector<ushort> BitwiseClearXor(Vector<ushort> op1, Vector<ushort> op2, Vector<ushort> op3);

    /// svuint32_t svbcax[_u32](svuint32_t op1, svuint32_t op2, svuint32_t op3) : "BCAX Ztied1.D, Ztied1.D, Zop2.D, Zop3.D" or "MOVPRFX Zresult, Zop1; BCAX Zresult.D, Zresult.D, Zop2.D, Zop3.D"
  public static unsafe Vector<uint> BitwiseClearXor(Vector<uint> op1, Vector<uint> op2, Vector<uint> op3);

    /// svuint64_t svbcax[_u64](svuint64_t op1, svuint64_t op2, svuint64_t op3) : "BCAX Ztied1.D, Ztied1.D, Zop2.D, Zop3.D" or "MOVPRFX Zresult, Zop1; BCAX Zresult.D, Zresult.D, Zop2.D, Zop3.D"
  public static unsafe Vector<ulong> BitwiseClearXor(Vector<ulong> op1, Vector<ulong> op2, Vector<ulong> op3);


    /// BitwiseSelect : Bitwise select

    /// svint8_t svbsl[_s8](svint8_t op1, svint8_t op2, svint8_t op3) : "BSL Ztied1.D, Ztied1.D, Zop2.D, Zop3.D" or "MOVPRFX Zresult, Zop1; BSL Zresult.D, Zresult.D, Zop2.D, Zop3.D"
  public static unsafe Vector<sbyte> BitwiseSelect(Vector<sbyte> op1, Vector<sbyte> op2, Vector<sbyte> op3);

    /// svint16_t svbsl[_s16](svint16_t op1, svint16_t op2, svint16_t op3) : "BSL Ztied1.D, Ztied1.D, Zop2.D, Zop3.D" or "MOVPRFX Zresult, Zop1; BSL Zresult.D, Zresult.D, Zop2.D, Zop3.D"
  public static unsafe Vector<short> BitwiseSelect(Vector<short> op1, Vector<short> op2, Vector<short> op3);

    /// svint32_t svbsl[_s32](svint32_t op1, svint32_t op2, svint32_t op3) : "BSL Ztied1.D, Ztied1.D, Zop2.D, Zop3.D" or "MOVPRFX Zresult, Zop1; BSL Zresult.D, Zresult.D, Zop2.D, Zop3.D"
  public static unsafe Vector<int> BitwiseSelect(Vector<int> op1, Vector<int> op2, Vector<int> op3);

    /// svint64_t svbsl[_s64](svint64_t op1, svint64_t op2, svint64_t op3) : "BSL Ztied1.D, Ztied1.D, Zop2.D, Zop3.D" or "MOVPRFX Zresult, Zop1; BSL Zresult.D, Zresult.D, Zop2.D, Zop3.D"
  public static unsafe Vector<long> BitwiseSelect(Vector<long> op1, Vector<long> op2, Vector<long> op3);

    /// svuint8_t svbsl[_u8](svuint8_t op1, svuint8_t op2, svuint8_t op3) : "BSL Ztied1.D, Ztied1.D, Zop2.D, Zop3.D" or "MOVPRFX Zresult, Zop1; BSL Zresult.D, Zresult.D, Zop2.D, Zop3.D"
  public static unsafe Vector<byte> BitwiseSelect(Vector<byte> op1, Vector<byte> op2, Vector<byte> op3);

    /// svuint16_t svbsl[_u16](svuint16_t op1, svuint16_t op2, svuint16_t op3) : "BSL Ztied1.D, Ztied1.D, Zop2.D, Zop3.D" or "MOVPRFX Zresult, Zop1; BSL Zresult.D, Zresult.D, Zop2.D, Zop3.D"
  public static unsafe Vector<ushort> BitwiseSelect(Vector<ushort> op1, Vector<ushort> op2, Vector<ushort> op3);

    /// svuint32_t svbsl[_u32](svuint32_t op1, svuint32_t op2, svuint32_t op3) : "BSL Ztied1.D, Ztied1.D, Zop2.D, Zop3.D" or "MOVPRFX Zresult, Zop1; BSL Zresult.D, Zresult.D, Zop2.D, Zop3.D"
  public static unsafe Vector<uint> BitwiseSelect(Vector<uint> op1, Vector<uint> op2, Vector<uint> op3);

    /// svuint64_t svbsl[_u64](svuint64_t op1, svuint64_t op2, svuint64_t op3) : "BSL Ztied1.D, Ztied1.D, Zop2.D, Zop3.D" or "MOVPRFX Zresult, Zop1; BSL Zresult.D, Zresult.D, Zop2.D, Zop3.D"
  public static unsafe Vector<ulong> BitwiseSelect(Vector<ulong> op1, Vector<ulong> op2, Vector<ulong> op3);


    /// BitwiseSelectFirstInverted : Bitwise select with first input inverted

    /// svint8_t svbsl1n[_s8](svint8_t op1, svint8_t op2, svint8_t op3) : "BSL1N Ztied1.D, Ztied1.D, Zop2.D, Zop3.D" or "MOVPRFX Zresult, Zop1; BSL1N Zresult.D, Zresult.D, Zop2.D, Zop3.D"
  public static unsafe Vector<sbyte> BitwiseSelectFirstInverted(Vector<sbyte> op1, Vector<sbyte> op2, Vector<sbyte> op3);

    /// svint16_t svbsl1n[_s16](svint16_t op1, svint16_t op2, svint16_t op3) : "BSL1N Ztied1.D, Ztied1.D, Zop2.D, Zop3.D" or "MOVPRFX Zresult, Zop1; BSL1N Zresult.D, Zresult.D, Zop2.D, Zop3.D"
  public static unsafe Vector<short> BitwiseSelectFirstInverted(Vector<short> op1, Vector<short> op2, Vector<short> op3);

    /// svint32_t svbsl1n[_s32](svint32_t op1, svint32_t op2, svint32_t op3) : "BSL1N Ztied1.D, Ztied1.D, Zop2.D, Zop3.D" or "MOVPRFX Zresult, Zop1; BSL1N Zresult.D, Zresult.D, Zop2.D, Zop3.D"
  public static unsafe Vector<int> BitwiseSelectFirstInverted(Vector<int> op1, Vector<int> op2, Vector<int> op3);

    /// svint64_t svbsl1n[_s64](svint64_t op1, svint64_t op2, svint64_t op3) : "BSL1N Ztied1.D, Ztied1.D, Zop2.D, Zop3.D" or "MOVPRFX Zresult, Zop1; BSL1N Zresult.D, Zresult.D, Zop2.D, Zop3.D"
  public static unsafe Vector<long> BitwiseSelectFirstInverted(Vector<long> op1, Vector<long> op2, Vector<long> op3);

    /// svuint8_t svbsl1n[_u8](svuint8_t op1, svuint8_t op2, svuint8_t op3) : "BSL1N Ztied1.D, Ztied1.D, Zop2.D, Zop3.D" or "MOVPRFX Zresult, Zop1; BSL1N Zresult.D, Zresult.D, Zop2.D, Zop3.D"
  public static unsafe Vector<byte> BitwiseSelectFirstInverted(Vector<byte> op1, Vector<byte> op2, Vector<byte> op3);

    /// svuint16_t svbsl1n[_u16](svuint16_t op1, svuint16_t op2, svuint16_t op3) : "BSL1N Ztied1.D, Ztied1.D, Zop2.D, Zop3.D" or "MOVPRFX Zresult, Zop1; BSL1N Zresult.D, Zresult.D, Zop2.D, Zop3.D"
  public static unsafe Vector<ushort> BitwiseSelectFirstInverted(Vector<ushort> op1, Vector<ushort> op2, Vector<ushort> op3);

    /// svuint32_t svbsl1n[_u32](svuint32_t op1, svuint32_t op2, svuint32_t op3) : "BSL1N Ztied1.D, Ztied1.D, Zop2.D, Zop3.D" or "MOVPRFX Zresult, Zop1; BSL1N Zresult.D, Zresult.D, Zop2.D, Zop3.D"
  public static unsafe Vector<uint> BitwiseSelectFirstInverted(Vector<uint> op1, Vector<uint> op2, Vector<uint> op3);

    /// svuint64_t svbsl1n[_u64](svuint64_t op1, svuint64_t op2, svuint64_t op3) : "BSL1N Ztied1.D, Ztied1.D, Zop2.D, Zop3.D" or "MOVPRFX Zresult, Zop1; BSL1N Zresult.D, Zresult.D, Zop2.D, Zop3.D"
  public static unsafe Vector<ulong> BitwiseSelectFirstInverted(Vector<ulong> op1, Vector<ulong> op2, Vector<ulong> op3);


    /// BitwiseSelectInverted : Bitwise select

    /// svint8_t svnbsl[_s8](svint8_t op1, svint8_t op2, svint8_t op3) : "NBSL Ztied1.D, Ztied1.D, Zop2.D, Zop3.D" or "MOVPRFX Zresult, Zop1; NBSL Zresult.D, Zresult.D, Zop2.D, Zop3.D"
  public static unsafe Vector<sbyte> BitwiseSelectInverted(Vector<sbyte> op1, Vector<sbyte> op2, Vector<sbyte> op3);

    /// svint16_t svnbsl[_s16](svint16_t op1, svint16_t op2, svint16_t op3) : "NBSL Ztied1.D, Ztied1.D, Zop2.D, Zop3.D" or "MOVPRFX Zresult, Zop1; NBSL Zresult.D, Zresult.D, Zop2.D, Zop3.D"
  public static unsafe Vector<short> BitwiseSelectInverted(Vector<short> op1, Vector<short> op2, Vector<short> op3);

    /// svint32_t svnbsl[_s32](svint32_t op1, svint32_t op2, svint32_t op3) : "NBSL Ztied1.D, Ztied1.D, Zop2.D, Zop3.D" or "MOVPRFX Zresult, Zop1; NBSL Zresult.D, Zresult.D, Zop2.D, Zop3.D"
  public static unsafe Vector<int> BitwiseSelectInverted(Vector<int> op1, Vector<int> op2, Vector<int> op3);

    /// svint64_t svnbsl[_s64](svint64_t op1, svint64_t op2, svint64_t op3) : "NBSL Ztied1.D, Ztied1.D, Zop2.D, Zop3.D" or "MOVPRFX Zresult, Zop1; NBSL Zresult.D, Zresult.D, Zop2.D, Zop3.D"
  public static unsafe Vector<long> BitwiseSelectInverted(Vector<long> op1, Vector<long> op2, Vector<long> op3);

    /// svuint8_t svnbsl[_u8](svuint8_t op1, svuint8_t op2, svuint8_t op3) : "NBSL Ztied1.D, Ztied1.D, Zop2.D, Zop3.D" or "MOVPRFX Zresult, Zop1; NBSL Zresult.D, Zresult.D, Zop2.D, Zop3.D"
  public static unsafe Vector<byte> BitwiseSelectInverted(Vector<byte> op1, Vector<byte> op2, Vector<byte> op3);

    /// svuint16_t svnbsl[_u16](svuint16_t op1, svuint16_t op2, svuint16_t op3) : "NBSL Ztied1.D, Ztied1.D, Zop2.D, Zop3.D" or "MOVPRFX Zresult, Zop1; NBSL Zresult.D, Zresult.D, Zop2.D, Zop3.D"
  public static unsafe Vector<ushort> BitwiseSelectInverted(Vector<ushort> op1, Vector<ushort> op2, Vector<ushort> op3);

    /// svuint32_t svnbsl[_u32](svuint32_t op1, svuint32_t op2, svuint32_t op3) : "NBSL Ztied1.D, Ztied1.D, Zop2.D, Zop3.D" or "MOVPRFX Zresult, Zop1; NBSL Zresult.D, Zresult.D, Zop2.D, Zop3.D"
  public static unsafe Vector<uint> BitwiseSelectInverted(Vector<uint> op1, Vector<uint> op2, Vector<uint> op3);

    /// svuint64_t svnbsl[_u64](svuint64_t op1, svuint64_t op2, svuint64_t op3) : "NBSL Ztied1.D, Ztied1.D, Zop2.D, Zop3.D" or "MOVPRFX Zresult, Zop1; NBSL Zresult.D, Zresult.D, Zop2.D, Zop3.D"
  public static unsafe Vector<ulong> BitwiseSelectInverted(Vector<ulong> op1, Vector<ulong> op2, Vector<ulong> op3);


    /// BitwiseSelectSecondInverted : Bitwise select with second input inverted

    /// svint8_t svbsl2n[_s8](svint8_t op1, svint8_t op2, svint8_t op3) : "BSL2N Ztied1.D, Ztied1.D, Zop2.D, Zop3.D" or "MOVPRFX Zresult, Zop1; BSL2N Zresult.D, Zresult.D, Zop2.D, Zop3.D"
  public static unsafe Vector<sbyte> BitwiseSelectSecondInverted(Vector<sbyte> op1, Vector<sbyte> op2, Vector<sbyte> op3);

    /// svint16_t svbsl2n[_s16](svint16_t op1, svint16_t op2, svint16_t op3) : "BSL2N Ztied1.D, Ztied1.D, Zop2.D, Zop3.D" or "MOVPRFX Zresult, Zop1; BSL2N Zresult.D, Zresult.D, Zop2.D, Zop3.D"
  public static unsafe Vector<short> BitwiseSelectSecondInverted(Vector<short> op1, Vector<short> op2, Vector<short> op3);

    /// svint32_t svbsl2n[_s32](svint32_t op1, svint32_t op2, svint32_t op3) : "BSL2N Ztied1.D, Ztied1.D, Zop2.D, Zop3.D" or "MOVPRFX Zresult, Zop1; BSL2N Zresult.D, Zresult.D, Zop2.D, Zop3.D"
  public static unsafe Vector<int> BitwiseSelectSecondInverted(Vector<int> op1, Vector<int> op2, Vector<int> op3);

    /// svint64_t svbsl2n[_s64](svint64_t op1, svint64_t op2, svint64_t op3) : "BSL2N Ztied1.D, Ztied1.D, Zop2.D, Zop3.D" or "MOVPRFX Zresult, Zop1; BSL2N Zresult.D, Zresult.D, Zop2.D, Zop3.D"
  public static unsafe Vector<long> BitwiseSelectSecondInverted(Vector<long> op1, Vector<long> op2, Vector<long> op3);

    /// svuint8_t svbsl2n[_u8](svuint8_t op1, svuint8_t op2, svuint8_t op3) : "BSL2N Ztied1.D, Ztied1.D, Zop2.D, Zop3.D" or "MOVPRFX Zresult, Zop1; BSL2N Zresult.D, Zresult.D, Zop2.D, Zop3.D"
  public static unsafe Vector<byte> BitwiseSelectSecondInverted(Vector<byte> op1, Vector<byte> op2, Vector<byte> op3);

    /// svuint16_t svbsl2n[_u16](svuint16_t op1, svuint16_t op2, svuint16_t op3) : "BSL2N Ztied1.D, Ztied1.D, Zop2.D, Zop3.D" or "MOVPRFX Zresult, Zop1; BSL2N Zresult.D, Zresult.D, Zop2.D, Zop3.D"
  public static unsafe Vector<ushort> BitwiseSelectSecondInverted(Vector<ushort> op1, Vector<ushort> op2, Vector<ushort> op3);

    /// svuint32_t svbsl2n[_u32](svuint32_t op1, svuint32_t op2, svuint32_t op3) : "BSL2N Ztied1.D, Ztied1.D, Zop2.D, Zop3.D" or "MOVPRFX Zresult, Zop1; BSL2N Zresult.D, Zresult.D, Zop2.D, Zop3.D"
  public static unsafe Vector<uint> BitwiseSelectSecondInverted(Vector<uint> op1, Vector<uint> op2, Vector<uint> op3);

    /// svuint64_t svbsl2n[_u64](svuint64_t op1, svuint64_t op2, svuint64_t op3) : "BSL2N Ztied1.D, Ztied1.D, Zop2.D, Zop3.D" or "MOVPRFX Zresult, Zop1; BSL2N Zresult.D, Zresult.D, Zop2.D, Zop3.D"
  public static unsafe Vector<ulong> BitwiseSelectSecondInverted(Vector<ulong> op1, Vector<ulong> op2, Vector<ulong> op3);


    /// RoundingShiftLeft : Rounding shift left

    /// svint8_t svrshl[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2) : "SRSHL Ztied1.B, Pg/M, Ztied1.B, Zop2.B" or "MOVPRFX Zresult, Zop1; SRSHL Zresult.B, Pg/M, Zresult.B, Zop2.B"
    /// svint8_t svrshl[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2) : "SRSHL Ztied1.B, Pg/M, Ztied1.B, Zop2.B" or "SRSHLR Ztied2.B, Pg/M, Ztied2.B, Zop1.B" or "MOVPRFX Zresult, Zop1; SRSHL Zresult.B, Pg/M, Zresult.B, Zop2.B"
    /// svint8_t svrshl[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2) : "MOVPRFX Zresult.B, Pg/Z, Zop1.B; SRSHL Zresult.B, Pg/M, Zresult.B, Zop2.B" or "MOVPRFX Zresult.B, Pg/Z, Zop2.B; SRSHLR Zresult.B, Pg/M, Zresult.B, Zop1.B"
  public static unsafe Vector<sbyte> RoundingShiftLeft(Vector<sbyte> left, Vector<sbyte> right);

    /// svint16_t svrshl[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2) : "SRSHL Ztied1.H, Pg/M, Ztied1.H, Zop2.H" or "MOVPRFX Zresult, Zop1; SRSHL Zresult.H, Pg/M, Zresult.H, Zop2.H"
    /// svint16_t svrshl[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2) : "SRSHL Ztied1.H, Pg/M, Ztied1.H, Zop2.H" or "SRSHLR Ztied2.H, Pg/M, Ztied2.H, Zop1.H" or "MOVPRFX Zresult, Zop1; SRSHL Zresult.H, Pg/M, Zresult.H, Zop2.H"
    /// svint16_t svrshl[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2) : "MOVPRFX Zresult.H, Pg/Z, Zop1.H; SRSHL Zresult.H, Pg/M, Zresult.H, Zop2.H" or "MOVPRFX Zresult.H, Pg/Z, Zop2.H; SRSHLR Zresult.H, Pg/M, Zresult.H, Zop1.H"
  public static unsafe Vector<short> RoundingShiftLeft(Vector<short> left, Vector<short> right);

    /// svint32_t svrshl[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2) : "SRSHL Ztied1.S, Pg/M, Ztied1.S, Zop2.S" or "MOVPRFX Zresult, Zop1; SRSHL Zresult.S, Pg/M, Zresult.S, Zop2.S"
    /// svint32_t svrshl[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2) : "SRSHL Ztied1.S, Pg/M, Ztied1.S, Zop2.S" or "SRSHLR Ztied2.S, Pg/M, Ztied2.S, Zop1.S" or "MOVPRFX Zresult, Zop1; SRSHL Zresult.S, Pg/M, Zresult.S, Zop2.S"
    /// svint32_t svrshl[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2) : "MOVPRFX Zresult.S, Pg/Z, Zop1.S; SRSHL Zresult.S, Pg/M, Zresult.S, Zop2.S" or "MOVPRFX Zresult.S, Pg/Z, Zop2.S; SRSHLR Zresult.S, Pg/M, Zresult.S, Zop1.S"
  public static unsafe Vector<int> RoundingShiftLeft(Vector<int> left, Vector<int> right);

    /// svint64_t svrshl[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2) : "SRSHL Ztied1.D, Pg/M, Ztied1.D, Zop2.D" or "MOVPRFX Zresult, Zop1; SRSHL Zresult.D, Pg/M, Zresult.D, Zop2.D"
    /// svint64_t svrshl[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2) : "SRSHL Ztied1.D, Pg/M, Ztied1.D, Zop2.D" or "SRSHLR Ztied2.D, Pg/M, Ztied2.D, Zop1.D" or "MOVPRFX Zresult, Zop1; SRSHL Zresult.D, Pg/M, Zresult.D, Zop2.D"
    /// svint64_t svrshl[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2) : "MOVPRFX Zresult.D, Pg/Z, Zop1.D; SRSHL Zresult.D, Pg/M, Zresult.D, Zop2.D" or "MOVPRFX Zresult.D, Pg/Z, Zop2.D; SRSHLR Zresult.D, Pg/M, Zresult.D, Zop1.D"
  public static unsafe Vector<long> RoundingShiftLeft(Vector<long> left, Vector<long> right);

    /// svuint8_t svrshl[_u8]_m(svbool_t pg, svuint8_t op1, svint8_t op2) : "URSHL Ztied1.B, Pg/M, Ztied1.B, Zop2.B" or "MOVPRFX Zresult, Zop1; URSHL Zresult.B, Pg/M, Zresult.B, Zop2.B"
    /// svuint8_t svrshl[_u8]_x(svbool_t pg, svuint8_t op1, svint8_t op2) : "URSHL Ztied1.B, Pg/M, Ztied1.B, Zop2.B" or "URSHLR Ztied2.B, Pg/M, Ztied2.B, Zop1.B" or "MOVPRFX Zresult, Zop1; URSHL Zresult.B, Pg/M, Zresult.B, Zop2.B"
    /// svuint8_t svrshl[_u8]_z(svbool_t pg, svuint8_t op1, svint8_t op2) : "MOVPRFX Zresult.B, Pg/Z, Zop1.B; URSHL Zresult.B, Pg/M, Zresult.B, Zop2.B" or "MOVPRFX Zresult.B, Pg/Z, Zop2.B; URSHLR Zresult.B, Pg/M, Zresult.B, Zop1.B"
  public static unsafe Vector<byte> RoundingShiftLeft(Vector<byte> left, Vector<sbyte> right);

    /// svuint16_t svrshl[_u16]_m(svbool_t pg, svuint16_t op1, svint16_t op2) : "URSHL Ztied1.H, Pg/M, Ztied1.H, Zop2.H" or "MOVPRFX Zresult, Zop1; URSHL Zresult.H, Pg/M, Zresult.H, Zop2.H"
    /// svuint16_t svrshl[_u16]_x(svbool_t pg, svuint16_t op1, svint16_t op2) : "URSHL Ztied1.H, Pg/M, Ztied1.H, Zop2.H" or "URSHLR Ztied2.H, Pg/M, Ztied2.H, Zop1.H" or "MOVPRFX Zresult, Zop1; URSHL Zresult.H, Pg/M, Zresult.H, Zop2.H"
    /// svuint16_t svrshl[_u16]_z(svbool_t pg, svuint16_t op1, svint16_t op2) : "MOVPRFX Zresult.H, Pg/Z, Zop1.H; URSHL Zresult.H, Pg/M, Zresult.H, Zop2.H" or "MOVPRFX Zresult.H, Pg/Z, Zop2.H; URSHLR Zresult.H, Pg/M, Zresult.H, Zop1.H"
  public static unsafe Vector<ushort> RoundingShiftLeft(Vector<ushort> left, Vector<short> right);

    /// svuint32_t svrshl[_u32]_m(svbool_t pg, svuint32_t op1, svint32_t op2) : "URSHL Ztied1.S, Pg/M, Ztied1.S, Zop2.S" or "MOVPRFX Zresult, Zop1; URSHL Zresult.S, Pg/M, Zresult.S, Zop2.S"
    /// svuint32_t svrshl[_u32]_x(svbool_t pg, svuint32_t op1, svint32_t op2) : "URSHL Ztied1.S, Pg/M, Ztied1.S, Zop2.S" or "URSHLR Ztied2.S, Pg/M, Ztied2.S, Zop1.S" or "MOVPRFX Zresult, Zop1; URSHL Zresult.S, Pg/M, Zresult.S, Zop2.S"
    /// svuint32_t svrshl[_u32]_z(svbool_t pg, svuint32_t op1, svint32_t op2) : "MOVPRFX Zresult.S, Pg/Z, Zop1.S; URSHL Zresult.S, Pg/M, Zresult.S, Zop2.S" or "MOVPRFX Zresult.S, Pg/Z, Zop2.S; URSHLR Zresult.S, Pg/M, Zresult.S, Zop1.S"
  public static unsafe Vector<uint> RoundingShiftLeft(Vector<uint> left, Vector<int> right);

    /// svuint64_t svrshl[_u64]_m(svbool_t pg, svuint64_t op1, svint64_t op2) : "URSHL Ztied1.D, Pg/M, Ztied1.D, Zop2.D" or "MOVPRFX Zresult, Zop1; URSHL Zresult.D, Pg/M, Zresult.D, Zop2.D"
    /// svuint64_t svrshl[_u64]_x(svbool_t pg, svuint64_t op1, svint64_t op2) : "URSHL Ztied1.D, Pg/M, Ztied1.D, Zop2.D" or "URSHLR Ztied2.D, Pg/M, Ztied2.D, Zop1.D" or "MOVPRFX Zresult, Zop1; URSHL Zresult.D, Pg/M, Zresult.D, Zop2.D"
    /// svuint64_t svrshl[_u64]_z(svbool_t pg, svuint64_t op1, svint64_t op2) : "MOVPRFX Zresult.D, Pg/Z, Zop1.D; URSHL Zresult.D, Pg/M, Zresult.D, Zop2.D" or "MOVPRFX Zresult.D, Pg/Z, Zop2.D; URSHLR Zresult.D, Pg/M, Zresult.D, Zop1.D"
  public static unsafe Vector<ulong> RoundingShiftLeft(Vector<ulong> left, Vector<long> right);


    /// RoundingShiftRight : Rounding shift right

    /// svint8_t svrshr[_n_s8]_m(svbool_t pg, svint8_t op1, uint64_t imm2) : "SRSHR Ztied1.B, Pg/M, Ztied1.B, #imm2" or "MOVPRFX Zresult, Zop1; SRSHR Zresult.B, Pg/M, Zresult.B, #imm2"
    /// svint8_t svrshr[_n_s8]_x(svbool_t pg, svint8_t op1, uint64_t imm2) : "SRSHR Ztied1.B, Pg/M, Ztied1.B, #imm2" or "MOVPRFX Zresult, Zop1; SRSHR Zresult.B, Pg/M, Zresult.B, #imm2"
    /// svint8_t svrshr[_n_s8]_z(svbool_t pg, svint8_t op1, uint64_t imm2) : "MOVPRFX Zresult.B, Pg/Z, Zop1.B; SRSHR Zresult.B, Pg/M, Zresult.B, #imm2"
  public static unsafe Vector<sbyte> RoundingShiftRight(Vector<sbyte> op1, ulong imm2);

    /// svint16_t svrshr[_n_s16]_m(svbool_t pg, svint16_t op1, uint64_t imm2) : "SRSHR Ztied1.H, Pg/M, Ztied1.H, #imm2" or "MOVPRFX Zresult, Zop1; SRSHR Zresult.H, Pg/M, Zresult.H, #imm2"
    /// svint16_t svrshr[_n_s16]_x(svbool_t pg, svint16_t op1, uint64_t imm2) : "SRSHR Ztied1.H, Pg/M, Ztied1.H, #imm2" or "MOVPRFX Zresult, Zop1; SRSHR Zresult.H, Pg/M, Zresult.H, #imm2"
    /// svint16_t svrshr[_n_s16]_z(svbool_t pg, svint16_t op1, uint64_t imm2) : "MOVPRFX Zresult.H, Pg/Z, Zop1.H; SRSHR Zresult.H, Pg/M, Zresult.H, #imm2"
  public static unsafe Vector<short> RoundingShiftRight(Vector<short> op1, ulong imm2);

    /// svint32_t svrshr[_n_s32]_m(svbool_t pg, svint32_t op1, uint64_t imm2) : "SRSHR Ztied1.S, Pg/M, Ztied1.S, #imm2" or "MOVPRFX Zresult, Zop1; SRSHR Zresult.S, Pg/M, Zresult.S, #imm2"
    /// svint32_t svrshr[_n_s32]_x(svbool_t pg, svint32_t op1, uint64_t imm2) : "SRSHR Ztied1.S, Pg/M, Ztied1.S, #imm2" or "MOVPRFX Zresult, Zop1; SRSHR Zresult.S, Pg/M, Zresult.S, #imm2"
    /// svint32_t svrshr[_n_s32]_z(svbool_t pg, svint32_t op1, uint64_t imm2) : "MOVPRFX Zresult.S, Pg/Z, Zop1.S; SRSHR Zresult.S, Pg/M, Zresult.S, #imm2"
  public static unsafe Vector<int> RoundingShiftRight(Vector<int> op1, ulong imm2);

    /// svint64_t svrshr[_n_s64]_m(svbool_t pg, svint64_t op1, uint64_t imm2) : "SRSHR Ztied1.D, Pg/M, Ztied1.D, #imm2" or "MOVPRFX Zresult, Zop1; SRSHR Zresult.D, Pg/M, Zresult.D, #imm2"
    /// svint64_t svrshr[_n_s64]_x(svbool_t pg, svint64_t op1, uint64_t imm2) : "SRSHR Ztied1.D, Pg/M, Ztied1.D, #imm2" or "MOVPRFX Zresult, Zop1; SRSHR Zresult.D, Pg/M, Zresult.D, #imm2"
    /// svint64_t svrshr[_n_s64]_z(svbool_t pg, svint64_t op1, uint64_t imm2) : "MOVPRFX Zresult.D, Pg/Z, Zop1.D; SRSHR Zresult.D, Pg/M, Zresult.D, #imm2"
  public static unsafe Vector<long> RoundingShiftRight(Vector<long> op1, ulong imm2);

    /// svuint8_t svrshr[_n_u8]_m(svbool_t pg, svuint8_t op1, uint64_t imm2) : "URSHR Ztied1.B, Pg/M, Ztied1.B, #imm2" or "MOVPRFX Zresult, Zop1; URSHR Zresult.B, Pg/M, Zresult.B, #imm2"
    /// svuint8_t svrshr[_n_u8]_x(svbool_t pg, svuint8_t op1, uint64_t imm2) : "URSHR Ztied1.B, Pg/M, Ztied1.B, #imm2" or "MOVPRFX Zresult, Zop1; URSHR Zresult.B, Pg/M, Zresult.B, #imm2"
    /// svuint8_t svrshr[_n_u8]_z(svbool_t pg, svuint8_t op1, uint64_t imm2) : "MOVPRFX Zresult.B, Pg/Z, Zop1.B; URSHR Zresult.B, Pg/M, Zresult.B, #imm2"
  public static unsafe Vector<byte> RoundingShiftRight(Vector<byte> op1, ulong imm2);

    /// svuint16_t svrshr[_n_u16]_m(svbool_t pg, svuint16_t op1, uint64_t imm2) : "URSHR Ztied1.H, Pg/M, Ztied1.H, #imm2" or "MOVPRFX Zresult, Zop1; URSHR Zresult.H, Pg/M, Zresult.H, #imm2"
    /// svuint16_t svrshr[_n_u16]_x(svbool_t pg, svuint16_t op1, uint64_t imm2) : "URSHR Ztied1.H, Pg/M, Ztied1.H, #imm2" or "MOVPRFX Zresult, Zop1; URSHR Zresult.H, Pg/M, Zresult.H, #imm2"
    /// svuint16_t svrshr[_n_u16]_z(svbool_t pg, svuint16_t op1, uint64_t imm2) : "MOVPRFX Zresult.H, Pg/Z, Zop1.H; URSHR Zresult.H, Pg/M, Zresult.H, #imm2"
  public static unsafe Vector<ushort> RoundingShiftRight(Vector<ushort> op1, ulong imm2);

    /// svuint32_t svrshr[_n_u32]_m(svbool_t pg, svuint32_t op1, uint64_t imm2) : "URSHR Ztied1.S, Pg/M, Ztied1.S, #imm2" or "MOVPRFX Zresult, Zop1; URSHR Zresult.S, Pg/M, Zresult.S, #imm2"
    /// svuint32_t svrshr[_n_u32]_x(svbool_t pg, svuint32_t op1, uint64_t imm2) : "URSHR Ztied1.S, Pg/M, Ztied1.S, #imm2" or "MOVPRFX Zresult, Zop1; URSHR Zresult.S, Pg/M, Zresult.S, #imm2"
    /// svuint32_t svrshr[_n_u32]_z(svbool_t pg, svuint32_t op1, uint64_t imm2) : "MOVPRFX Zresult.S, Pg/Z, Zop1.S; URSHR Zresult.S, Pg/M, Zresult.S, #imm2"
  public static unsafe Vector<uint> RoundingShiftRight(Vector<uint> op1, ulong imm2);

    /// svuint64_t svrshr[_n_u64]_m(svbool_t pg, svuint64_t op1, uint64_t imm2) : "URSHR Ztied1.D, Pg/M, Ztied1.D, #imm2" or "MOVPRFX Zresult, Zop1; URSHR Zresult.D, Pg/M, Zresult.D, #imm2"
    /// svuint64_t svrshr[_n_u64]_x(svbool_t pg, svuint64_t op1, uint64_t imm2) : "URSHR Ztied1.D, Pg/M, Ztied1.D, #imm2" or "MOVPRFX Zresult, Zop1; URSHR Zresult.D, Pg/M, Zresult.D, #imm2"
    /// svuint64_t svrshr[_n_u64]_z(svbool_t pg, svuint64_t op1, uint64_t imm2) : "MOVPRFX Zresult.D, Pg/Z, Zop1.D; URSHR Zresult.D, Pg/M, Zresult.D, #imm2"
  public static unsafe Vector<ulong> RoundingShiftRight(Vector<ulong> op1, ulong imm2);


    /// RoundingShiftRightAndAccumulate : Rounding shift right and accumulate

    /// svint8_t svrsra[_n_s8](svint8_t op1, svint8_t op2, uint64_t imm3) : "SRSRA Ztied1.B, Zop2.B, #imm3" or "MOVPRFX Zresult, Zop1; SRSRA Zresult.B, Zop2.B, #imm3"
  public static unsafe Vector<sbyte> RoundingShiftRightAndAccumulate(Vector<sbyte> op1, Vector<sbyte> op2, ulong imm3);

    /// svint16_t svrsra[_n_s16](svint16_t op1, svint16_t op2, uint64_t imm3) : "SRSRA Ztied1.H, Zop2.H, #imm3" or "MOVPRFX Zresult, Zop1; SRSRA Zresult.H, Zop2.H, #imm3"
  public static unsafe Vector<short> RoundingShiftRightAndAccumulate(Vector<short> op1, Vector<short> op2, ulong imm3);

    /// svint32_t svrsra[_n_s32](svint32_t op1, svint32_t op2, uint64_t imm3) : "SRSRA Ztied1.S, Zop2.S, #imm3" or "MOVPRFX Zresult, Zop1; SRSRA Zresult.S, Zop2.S, #imm3"
  public static unsafe Vector<int> RoundingShiftRightAndAccumulate(Vector<int> op1, Vector<int> op2, ulong imm3);

    /// svint64_t svrsra[_n_s64](svint64_t op1, svint64_t op2, uint64_t imm3) : "SRSRA Ztied1.D, Zop2.D, #imm3" or "MOVPRFX Zresult, Zop1; SRSRA Zresult.D, Zop2.D, #imm3"
  public static unsafe Vector<long> RoundingShiftRightAndAccumulate(Vector<long> op1, Vector<long> op2, ulong imm3);

    /// svuint8_t svrsra[_n_u8](svuint8_t op1, svuint8_t op2, uint64_t imm3) : "URSRA Ztied1.B, Zop2.B, #imm3" or "MOVPRFX Zresult, Zop1; URSRA Zresult.B, Zop2.B, #imm3"
  public static unsafe Vector<byte> RoundingShiftRightAndAccumulate(Vector<byte> op1, Vector<byte> op2, ulong imm3);

    /// svuint16_t svrsra[_n_u16](svuint16_t op1, svuint16_t op2, uint64_t imm3) : "URSRA Ztied1.H, Zop2.H, #imm3" or "MOVPRFX Zresult, Zop1; URSRA Zresult.H, Zop2.H, #imm3"
  public static unsafe Vector<ushort> RoundingShiftRightAndAccumulate(Vector<ushort> op1, Vector<ushort> op2, ulong imm3);

    /// svuint32_t svrsra[_n_u32](svuint32_t op1, svuint32_t op2, uint64_t imm3) : "URSRA Ztied1.S, Zop2.S, #imm3" or "MOVPRFX Zresult, Zop1; URSRA Zresult.S, Zop2.S, #imm3"
  public static unsafe Vector<uint> RoundingShiftRightAndAccumulate(Vector<uint> op1, Vector<uint> op2, ulong imm3);

    /// svuint64_t svrsra[_n_u64](svuint64_t op1, svuint64_t op2, uint64_t imm3) : "URSRA Ztied1.D, Zop2.D, #imm3" or "MOVPRFX Zresult, Zop1; URSRA Zresult.D, Zop2.D, #imm3"
  public static unsafe Vector<ulong> RoundingShiftRightAndAccumulate(Vector<ulong> op1, Vector<ulong> op2, ulong imm3);


    /// RoundingShiftRightNarrowingLower : Rounding shift right narrow (bottom)

    /// svint8_t svrshrnb[_n_s16](svint16_t op1, uint64_t imm2) : "RSHRNB Zresult.B, Zop1.H, #imm2"
  public static unsafe Vector<sbyte> RoundingShiftRightNarrowingLower(Vector<short> op1, ulong imm2);

    /// svint16_t svrshrnb[_n_s32](svint32_t op1, uint64_t imm2) : "RSHRNB Zresult.H, Zop1.S, #imm2"
  public static unsafe Vector<short> RoundingShiftRightNarrowingLower(Vector<int> op1, ulong imm2);

    /// svint32_t svrshrnb[_n_s64](svint64_t op1, uint64_t imm2) : "RSHRNB Zresult.S, Zop1.D, #imm2"
  public static unsafe Vector<int> RoundingShiftRightNarrowingLower(Vector<long> op1, ulong imm2);

    /// svuint8_t svrshrnb[_n_u16](svuint16_t op1, uint64_t imm2) : "RSHRNB Zresult.B, Zop1.H, #imm2"
  public static unsafe Vector<byte> RoundingShiftRightNarrowingLower(Vector<ushort> op1, ulong imm2);

    /// svuint16_t svrshrnb[_n_u32](svuint32_t op1, uint64_t imm2) : "RSHRNB Zresult.H, Zop1.S, #imm2"
  public static unsafe Vector<ushort> RoundingShiftRightNarrowingLower(Vector<uint> op1, ulong imm2);

    /// svuint32_t svrshrnb[_n_u64](svuint64_t op1, uint64_t imm2) : "RSHRNB Zresult.S, Zop1.D, #imm2"
  public static unsafe Vector<uint> RoundingShiftRightNarrowingLower(Vector<ulong> op1, ulong imm2);


    /// RoundingShiftRightNarrowingUpper : Rounding shift right narrow (top)

    /// svint8_t svrshrnt[_n_s16](svint8_t even, svint16_t op1, uint64_t imm2) : "RSHRNT Ztied.B, Zop1.H, #imm2"
  public static unsafe Vector<sbyte> RoundingShiftRightNarrowingUpper(Vector<sbyte> even, Vector<short> op1, ulong imm2);

    /// svint16_t svrshrnt[_n_s32](svint16_t even, svint32_t op1, uint64_t imm2) : "RSHRNT Ztied.H, Zop1.S, #imm2"
  public static unsafe Vector<short> RoundingShiftRightNarrowingUpper(Vector<short> even, Vector<int> op1, ulong imm2);

    /// svint32_t svrshrnt[_n_s64](svint32_t even, svint64_t op1, uint64_t imm2) : "RSHRNT Ztied.S, Zop1.D, #imm2"
  public static unsafe Vector<int> RoundingShiftRightNarrowingUpper(Vector<int> even, Vector<long> op1, ulong imm2);

    /// svuint8_t svrshrnt[_n_u16](svuint8_t even, svuint16_t op1, uint64_t imm2) : "RSHRNT Ztied.B, Zop1.H, #imm2"
  public static unsafe Vector<byte> RoundingShiftRightNarrowingUpper(Vector<byte> even, Vector<ushort> op1, ulong imm2);

    /// svuint16_t svrshrnt[_n_u32](svuint16_t even, svuint32_t op1, uint64_t imm2) : "RSHRNT Ztied.H, Zop1.S, #imm2"
  public static unsafe Vector<ushort> RoundingShiftRightNarrowingUpper(Vector<ushort> even, Vector<uint> op1, ulong imm2);

    /// svuint32_t svrshrnt[_n_u64](svuint32_t even, svuint64_t op1, uint64_t imm2) : "RSHRNT Ztied.S, Zop1.D, #imm2"
  public static unsafe Vector<uint> RoundingShiftRightNarrowingUpper(Vector<uint> even, Vector<ulong> op1, ulong imm2);


    /// SaturatingRoundingShiftLeft : Saturating rounding shift left

    /// svint8_t svqrshl[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2) : "SQRSHL Ztied1.B, Pg/M, Ztied1.B, Zop2.B" or "MOVPRFX Zresult, Zop1; SQRSHL Zresult.B, Pg/M, Zresult.B, Zop2.B"
    /// svint8_t svqrshl[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2) : "SQRSHL Ztied1.B, Pg/M, Ztied1.B, Zop2.B" or "SQRSHLR Ztied2.B, Pg/M, Ztied2.B, Zop1.B" or "MOVPRFX Zresult, Zop1; SQRSHL Zresult.B, Pg/M, Zresult.B, Zop2.B"
    /// svint8_t svqrshl[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2) : "MOVPRFX Zresult.B, Pg/Z, Zop1.B; SQRSHL Zresult.B, Pg/M, Zresult.B, Zop2.B" or "MOVPRFX Zresult.B, Pg/Z, Zop2.B; SQRSHLR Zresult.B, Pg/M, Zresult.B, Zop1.B"
  public static unsafe Vector<sbyte> SaturatingRoundingShiftLeft(Vector<sbyte> left, Vector<sbyte> right);

    /// svint16_t svqrshl[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2) : "SQRSHL Ztied1.H, Pg/M, Ztied1.H, Zop2.H" or "MOVPRFX Zresult, Zop1; SQRSHL Zresult.H, Pg/M, Zresult.H, Zop2.H"
    /// svint16_t svqrshl[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2) : "SQRSHL Ztied1.H, Pg/M, Ztied1.H, Zop2.H" or "SQRSHLR Ztied2.H, Pg/M, Ztied2.H, Zop1.H" or "MOVPRFX Zresult, Zop1; SQRSHL Zresult.H, Pg/M, Zresult.H, Zop2.H"
    /// svint16_t svqrshl[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2) : "MOVPRFX Zresult.H, Pg/Z, Zop1.H; SQRSHL Zresult.H, Pg/M, Zresult.H, Zop2.H" or "MOVPRFX Zresult.H, Pg/Z, Zop2.H; SQRSHLR Zresult.H, Pg/M, Zresult.H, Zop1.H"
  public static unsafe Vector<short> SaturatingRoundingShiftLeft(Vector<short> left, Vector<short> right);

    /// svint32_t svqrshl[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2) : "SQRSHL Ztied1.S, Pg/M, Ztied1.S, Zop2.S" or "MOVPRFX Zresult, Zop1; SQRSHL Zresult.S, Pg/M, Zresult.S, Zop2.S"
    /// svint32_t svqrshl[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2) : "SQRSHL Ztied1.S, Pg/M, Ztied1.S, Zop2.S" or "SQRSHLR Ztied2.S, Pg/M, Ztied2.S, Zop1.S" or "MOVPRFX Zresult, Zop1; SQRSHL Zresult.S, Pg/M, Zresult.S, Zop2.S"
    /// svint32_t svqrshl[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2) : "MOVPRFX Zresult.S, Pg/Z, Zop1.S; SQRSHL Zresult.S, Pg/M, Zresult.S, Zop2.S" or "MOVPRFX Zresult.S, Pg/Z, Zop2.S; SQRSHLR Zresult.S, Pg/M, Zresult.S, Zop1.S"
  public static unsafe Vector<int> SaturatingRoundingShiftLeft(Vector<int> left, Vector<int> right);

    /// svint64_t svqrshl[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2) : "SQRSHL Ztied1.D, Pg/M, Ztied1.D, Zop2.D" or "MOVPRFX Zresult, Zop1; SQRSHL Zresult.D, Pg/M, Zresult.D, Zop2.D"
    /// svint64_t svqrshl[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2) : "SQRSHL Ztied1.D, Pg/M, Ztied1.D, Zop2.D" or "SQRSHLR Ztied2.D, Pg/M, Ztied2.D, Zop1.D" or "MOVPRFX Zresult, Zop1; SQRSHL Zresult.D, Pg/M, Zresult.D, Zop2.D"
    /// svint64_t svqrshl[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2) : "MOVPRFX Zresult.D, Pg/Z, Zop1.D; SQRSHL Zresult.D, Pg/M, Zresult.D, Zop2.D" or "MOVPRFX Zresult.D, Pg/Z, Zop2.D; SQRSHLR Zresult.D, Pg/M, Zresult.D, Zop1.D"
  public static unsafe Vector<long> SaturatingRoundingShiftLeft(Vector<long> left, Vector<long> right);

    /// svuint8_t svqrshl[_u8]_m(svbool_t pg, svuint8_t op1, svint8_t op2) : "UQRSHL Ztied1.B, Pg/M, Ztied1.B, Zop2.B" or "MOVPRFX Zresult, Zop1; UQRSHL Zresult.B, Pg/M, Zresult.B, Zop2.B"
    /// svuint8_t svqrshl[_u8]_x(svbool_t pg, svuint8_t op1, svint8_t op2) : "UQRSHL Ztied1.B, Pg/M, Ztied1.B, Zop2.B" or "UQRSHLR Ztied2.B, Pg/M, Ztied2.B, Zop1.B" or "MOVPRFX Zresult, Zop1; UQRSHL Zresult.B, Pg/M, Zresult.B, Zop2.B"
    /// svuint8_t svqrshl[_u8]_z(svbool_t pg, svuint8_t op1, svint8_t op2) : "MOVPRFX Zresult.B, Pg/Z, Zop1.B; UQRSHL Zresult.B, Pg/M, Zresult.B, Zop2.B" or "MOVPRFX Zresult.B, Pg/Z, Zop2.B; UQRSHLR Zresult.B, Pg/M, Zresult.B, Zop1.B"
  public static unsafe Vector<byte> SaturatingRoundingShiftLeft(Vector<byte> left, Vector<sbyte> right);

    /// svuint16_t svqrshl[_u16]_m(svbool_t pg, svuint16_t op1, svint16_t op2) : "UQRSHL Ztied1.H, Pg/M, Ztied1.H, Zop2.H" or "MOVPRFX Zresult, Zop1; UQRSHL Zresult.H, Pg/M, Zresult.H, Zop2.H"
    /// svuint16_t svqrshl[_u16]_x(svbool_t pg, svuint16_t op1, svint16_t op2) : "UQRSHL Ztied1.H, Pg/M, Ztied1.H, Zop2.H" or "UQRSHLR Ztied2.H, Pg/M, Ztied2.H, Zop1.H" or "MOVPRFX Zresult, Zop1; UQRSHL Zresult.H, Pg/M, Zresult.H, Zop2.H"
    /// svuint16_t svqrshl[_u16]_z(svbool_t pg, svuint16_t op1, svint16_t op2) : "MOVPRFX Zresult.H, Pg/Z, Zop1.H; UQRSHL Zresult.H, Pg/M, Zresult.H, Zop2.H" or "MOVPRFX Zresult.H, Pg/Z, Zop2.H; UQRSHLR Zresult.H, Pg/M, Zresult.H, Zop1.H"
  public static unsafe Vector<ushort> SaturatingRoundingShiftLeft(Vector<ushort> left, Vector<short> right);

    /// svuint32_t svqrshl[_u32]_m(svbool_t pg, svuint32_t op1, svint32_t op2) : "UQRSHL Ztied1.S, Pg/M, Ztied1.S, Zop2.S" or "MOVPRFX Zresult, Zop1; UQRSHL Zresult.S, Pg/M, Zresult.S, Zop2.S"
    /// svuint32_t svqrshl[_u32]_x(svbool_t pg, svuint32_t op1, svint32_t op2) : "UQRSHL Ztied1.S, Pg/M, Ztied1.S, Zop2.S" or "UQRSHLR Ztied2.S, Pg/M, Ztied2.S, Zop1.S" or "MOVPRFX Zresult, Zop1; UQRSHL Zresult.S, Pg/M, Zresult.S, Zop2.S"
    /// svuint32_t svqrshl[_u32]_z(svbool_t pg, svuint32_t op1, svint32_t op2) : "MOVPRFX Zresult.S, Pg/Z, Zop1.S; UQRSHL Zresult.S, Pg/M, Zresult.S, Zop2.S" or "MOVPRFX Zresult.S, Pg/Z, Zop2.S; UQRSHLR Zresult.S, Pg/M, Zresult.S, Zop1.S"
  public static unsafe Vector<uint> SaturatingRoundingShiftLeft(Vector<uint> left, Vector<int> right);

    /// svuint64_t svqrshl[_u64]_m(svbool_t pg, svuint64_t op1, svint64_t op2) : "UQRSHL Ztied1.D, Pg/M, Ztied1.D, Zop2.D" or "MOVPRFX Zresult, Zop1; UQRSHL Zresult.D, Pg/M, Zresult.D, Zop2.D"
    /// svuint64_t svqrshl[_u64]_x(svbool_t pg, svuint64_t op1, svint64_t op2) : "UQRSHL Ztied1.D, Pg/M, Ztied1.D, Zop2.D" or "UQRSHLR Ztied2.D, Pg/M, Ztied2.D, Zop1.D" or "MOVPRFX Zresult, Zop1; UQRSHL Zresult.D, Pg/M, Zresult.D, Zop2.D"
    /// svuint64_t svqrshl[_u64]_z(svbool_t pg, svuint64_t op1, svint64_t op2) : "MOVPRFX Zresult.D, Pg/Z, Zop1.D; UQRSHL Zresult.D, Pg/M, Zresult.D, Zop2.D" or "MOVPRFX Zresult.D, Pg/Z, Zop2.D; UQRSHLR Zresult.D, Pg/M, Zresult.D, Zop1.D"
  public static unsafe Vector<ulong> SaturatingRoundingShiftLeft(Vector<ulong> left, Vector<long> right);


    /// SaturatingRoundingShiftRightNarrowingLower : Saturating rounding shift right narrow (bottom)

    /// svint8_t svqrshrnb[_n_s16](svint16_t op1, uint64_t imm2) : "SQRSHRNB Zresult.B, Zop1.H, #imm2"
  public static unsafe Vector<sbyte> SaturatingRoundingShiftRightNarrowingLower(Vector<short> op1, ulong imm2);

    /// svint16_t svqrshrnb[_n_s32](svint32_t op1, uint64_t imm2) : "SQRSHRNB Zresult.H, Zop1.S, #imm2"
  public static unsafe Vector<short> SaturatingRoundingShiftRightNarrowingLower(Vector<int> op1, ulong imm2);

    /// svint32_t svqrshrnb[_n_s64](svint64_t op1, uint64_t imm2) : "SQRSHRNB Zresult.S, Zop1.D, #imm2"
  public static unsafe Vector<int> SaturatingRoundingShiftRightNarrowingLower(Vector<long> op1, ulong imm2);

    /// svuint8_t svqrshrnb[_n_u16](svuint16_t op1, uint64_t imm2) : "UQRSHRNB Zresult.B, Zop1.H, #imm2"
  public static unsafe Vector<byte> SaturatingRoundingShiftRightNarrowingLower(Vector<ushort> op1, ulong imm2);

    /// svuint16_t svqrshrnb[_n_u32](svuint32_t op1, uint64_t imm2) : "UQRSHRNB Zresult.H, Zop1.S, #imm2"
  public static unsafe Vector<ushort> SaturatingRoundingShiftRightNarrowingLower(Vector<uint> op1, ulong imm2);

    /// svuint32_t svqrshrnb[_n_u64](svuint64_t op1, uint64_t imm2) : "UQRSHRNB Zresult.S, Zop1.D, #imm2"
  public static unsafe Vector<uint> SaturatingRoundingShiftRightNarrowingLower(Vector<ulong> op1, ulong imm2);


    /// SaturatingRoundingShiftRightNarrowingUpper : Saturating rounding shift right narrow (top)

    /// svint8_t svqrshrnt[_n_s16](svint8_t even, svint16_t op1, uint64_t imm2) : "SQRSHRNT Ztied.B, Zop1.H, #imm2"
  public static unsafe Vector<sbyte> SaturatingRoundingShiftRightNarrowingUpper(Vector<sbyte> even, Vector<short> op1, ulong imm2);

    /// svint16_t svqrshrnt[_n_s32](svint16_t even, svint32_t op1, uint64_t imm2) : "SQRSHRNT Ztied.H, Zop1.S, #imm2"
  public static unsafe Vector<short> SaturatingRoundingShiftRightNarrowingUpper(Vector<short> even, Vector<int> op1, ulong imm2);

    /// svint32_t svqrshrnt[_n_s64](svint32_t even, svint64_t op1, uint64_t imm2) : "SQRSHRNT Ztied.S, Zop1.D, #imm2"
  public static unsafe Vector<int> SaturatingRoundingShiftRightNarrowingUpper(Vector<int> even, Vector<long> op1, ulong imm2);

    /// svuint8_t svqrshrnt[_n_u16](svuint8_t even, svuint16_t op1, uint64_t imm2) : "UQRSHRNT Ztied.B, Zop1.H, #imm2"
  public static unsafe Vector<byte> SaturatingRoundingShiftRightNarrowingUpper(Vector<byte> even, Vector<ushort> op1, ulong imm2);

    /// svuint16_t svqrshrnt[_n_u32](svuint16_t even, svuint32_t op1, uint64_t imm2) : "UQRSHRNT Ztied.H, Zop1.S, #imm2"
  public static unsafe Vector<ushort> SaturatingRoundingShiftRightNarrowingUpper(Vector<ushort> even, Vector<uint> op1, ulong imm2);

    /// svuint32_t svqrshrnt[_n_u64](svuint32_t even, svuint64_t op1, uint64_t imm2) : "UQRSHRNT Ztied.S, Zop1.D, #imm2"
  public static unsafe Vector<uint> SaturatingRoundingShiftRightNarrowingUpper(Vector<uint> even, Vector<ulong> op1, ulong imm2);


    /// SaturatingRoundingShiftRightUnsignedNarrowingLower : Saturating rounding shift right unsigned narrow (bottom)

    /// svuint8_t svqrshrunb[_n_s16](svint16_t op1, uint64_t imm2) : "SQRSHRUNB Zresult.B, Zop1.H, #imm2"
  public static unsafe Vector<byte> SaturatingRoundingShiftRightUnsignedNarrowingLower(Vector<short> op1, ulong imm2);

    /// svuint16_t svqrshrunb[_n_s32](svint32_t op1, uint64_t imm2) : "SQRSHRUNB Zresult.H, Zop1.S, #imm2"
  public static unsafe Vector<ushort> SaturatingRoundingShiftRightUnsignedNarrowingLower(Vector<int> op1, ulong imm2);

    /// svuint32_t svqrshrunb[_n_s64](svint64_t op1, uint64_t imm2) : "SQRSHRUNB Zresult.S, Zop1.D, #imm2"
  public static unsafe Vector<uint> SaturatingRoundingShiftRightUnsignedNarrowingLower(Vector<long> op1, ulong imm2);


    /// SaturatingRoundingShiftRightUnsignedNarrowingUpper : Saturating rounding shift right unsigned narrow (top)

    /// svuint8_t svqrshrunt[_n_s16](svuint8_t even, svint16_t op1, uint64_t imm2) : "SQRSHRUNT Ztied.B, Zop1.H, #imm2"
  public static unsafe Vector<byte> SaturatingRoundingShiftRightUnsignedNarrowingUpper(Vector<byte> even, Vector<short> op1, ulong imm2);

    /// svuint16_t svqrshrunt[_n_s32](svuint16_t even, svint32_t op1, uint64_t imm2) : "SQRSHRUNT Ztied.H, Zop1.S, #imm2"
  public static unsafe Vector<ushort> SaturatingRoundingShiftRightUnsignedNarrowingUpper(Vector<ushort> even, Vector<int> op1, ulong imm2);

    /// svuint32_t svqrshrunt[_n_s64](svuint32_t even, svint64_t op1, uint64_t imm2) : "SQRSHRUNT Ztied.S, Zop1.D, #imm2"
  public static unsafe Vector<uint> SaturatingRoundingShiftRightUnsignedNarrowingUpper(Vector<uint> even, Vector<long> op1, ulong imm2);


    /// SaturatingShiftLeft : Saturating shift left

    /// svint8_t svqshl[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2) : "SQSHL Ztied1.B, Pg/M, Ztied1.B, Zop2.B" or "MOVPRFX Zresult, Zop1; SQSHL Zresult.B, Pg/M, Zresult.B, Zop2.B"
    /// svint8_t svqshl[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2) : "SQSHL Ztied1.B, Pg/M, Ztied1.B, Zop2.B" or "SQSHLR Ztied2.B, Pg/M, Ztied2.B, Zop1.B" or "MOVPRFX Zresult, Zop1; SQSHL Zresult.B, Pg/M, Zresult.B, Zop2.B"
    /// svint8_t svqshl[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2) : "MOVPRFX Zresult.B, Pg/Z, Zop1.B; SQSHL Zresult.B, Pg/M, Zresult.B, Zop2.B" or "MOVPRFX Zresult.B, Pg/Z, Zop2.B; SQSHLR Zresult.B, Pg/M, Zresult.B, Zop1.B"
  public static unsafe Vector<sbyte> SaturatingShiftLeft(Vector<sbyte> left, Vector<sbyte> right);

    /// svint16_t svqshl[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2) : "SQSHL Ztied1.H, Pg/M, Ztied1.H, Zop2.H" or "MOVPRFX Zresult, Zop1; SQSHL Zresult.H, Pg/M, Zresult.H, Zop2.H"
    /// svint16_t svqshl[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2) : "SQSHL Ztied1.H, Pg/M, Ztied1.H, Zop2.H" or "SQSHLR Ztied2.H, Pg/M, Ztied2.H, Zop1.H" or "MOVPRFX Zresult, Zop1; SQSHL Zresult.H, Pg/M, Zresult.H, Zop2.H"
    /// svint16_t svqshl[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2) : "MOVPRFX Zresult.H, Pg/Z, Zop1.H; SQSHL Zresult.H, Pg/M, Zresult.H, Zop2.H" or "MOVPRFX Zresult.H, Pg/Z, Zop2.H; SQSHLR Zresult.H, Pg/M, Zresult.H, Zop1.H"
  public static unsafe Vector<short> SaturatingShiftLeft(Vector<short> left, Vector<short> right);

    /// svint32_t svqshl[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2) : "SQSHL Ztied1.S, Pg/M, Ztied1.S, Zop2.S" or "MOVPRFX Zresult, Zop1; SQSHL Zresult.S, Pg/M, Zresult.S, Zop2.S"
    /// svint32_t svqshl[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2) : "SQSHL Ztied1.S, Pg/M, Ztied1.S, Zop2.S" or "SQSHLR Ztied2.S, Pg/M, Ztied2.S, Zop1.S" or "MOVPRFX Zresult, Zop1; SQSHL Zresult.S, Pg/M, Zresult.S, Zop2.S"
    /// svint32_t svqshl[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2) : "MOVPRFX Zresult.S, Pg/Z, Zop1.S; SQSHL Zresult.S, Pg/M, Zresult.S, Zop2.S" or "MOVPRFX Zresult.S, Pg/Z, Zop2.S; SQSHLR Zresult.S, Pg/M, Zresult.S, Zop1.S"
  public static unsafe Vector<int> SaturatingShiftLeft(Vector<int> left, Vector<int> right);

    /// svint64_t svqshl[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2) : "SQSHL Ztied1.D, Pg/M, Ztied1.D, Zop2.D" or "MOVPRFX Zresult, Zop1; SQSHL Zresult.D, Pg/M, Zresult.D, Zop2.D"
    /// svint64_t svqshl[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2) : "SQSHL Ztied1.D, Pg/M, Ztied1.D, Zop2.D" or "SQSHLR Ztied2.D, Pg/M, Ztied2.D, Zop1.D" or "MOVPRFX Zresult, Zop1; SQSHL Zresult.D, Pg/M, Zresult.D, Zop2.D"
    /// svint64_t svqshl[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2) : "MOVPRFX Zresult.D, Pg/Z, Zop1.D; SQSHL Zresult.D, Pg/M, Zresult.D, Zop2.D" or "MOVPRFX Zresult.D, Pg/Z, Zop2.D; SQSHLR Zresult.D, Pg/M, Zresult.D, Zop1.D"
  public static unsafe Vector<long> SaturatingShiftLeft(Vector<long> left, Vector<long> right);

    /// svuint8_t svqshl[_u8]_m(svbool_t pg, svuint8_t op1, svint8_t op2) : "UQSHL Ztied1.B, Pg/M, Ztied1.B, Zop2.B" or "MOVPRFX Zresult, Zop1; UQSHL Zresult.B, Pg/M, Zresult.B, Zop2.B"
    /// svuint8_t svqshl[_u8]_x(svbool_t pg, svuint8_t op1, svint8_t op2) : "UQSHL Ztied1.B, Pg/M, Ztied1.B, Zop2.B" or "UQSHLR Ztied2.B, Pg/M, Ztied2.B, Zop1.B" or "MOVPRFX Zresult, Zop1; UQSHL Zresult.B, Pg/M, Zresult.B, Zop2.B"
    /// svuint8_t svqshl[_u8]_z(svbool_t pg, svuint8_t op1, svint8_t op2) : "MOVPRFX Zresult.B, Pg/Z, Zop1.B; UQSHL Zresult.B, Pg/M, Zresult.B, Zop2.B" or "MOVPRFX Zresult.B, Pg/Z, Zop2.B; UQSHLR Zresult.B, Pg/M, Zresult.B, Zop1.B"
  public static unsafe Vector<byte> SaturatingShiftLeft(Vector<byte> left, Vector<sbyte> right);

    /// svuint16_t svqshl[_u16]_m(svbool_t pg, svuint16_t op1, svint16_t op2) : "UQSHL Ztied1.H, Pg/M, Ztied1.H, Zop2.H" or "MOVPRFX Zresult, Zop1; UQSHL Zresult.H, Pg/M, Zresult.H, Zop2.H"
    /// svuint16_t svqshl[_u16]_x(svbool_t pg, svuint16_t op1, svint16_t op2) : "UQSHL Ztied1.H, Pg/M, Ztied1.H, Zop2.H" or "UQSHLR Ztied2.H, Pg/M, Ztied2.H, Zop1.H" or "MOVPRFX Zresult, Zop1; UQSHL Zresult.H, Pg/M, Zresult.H, Zop2.H"
    /// svuint16_t svqshl[_u16]_z(svbool_t pg, svuint16_t op1, svint16_t op2) : "MOVPRFX Zresult.H, Pg/Z, Zop1.H; UQSHL Zresult.H, Pg/M, Zresult.H, Zop2.H" or "MOVPRFX Zresult.H, Pg/Z, Zop2.H; UQSHLR Zresult.H, Pg/M, Zresult.H, Zop1.H"
  public static unsafe Vector<ushort> SaturatingShiftLeft(Vector<ushort> left, Vector<short> right);

    /// svuint32_t svqshl[_u32]_m(svbool_t pg, svuint32_t op1, svint32_t op2) : "UQSHL Ztied1.S, Pg/M, Ztied1.S, Zop2.S" or "MOVPRFX Zresult, Zop1; UQSHL Zresult.S, Pg/M, Zresult.S, Zop2.S"
    /// svuint32_t svqshl[_u32]_x(svbool_t pg, svuint32_t op1, svint32_t op2) : "UQSHL Ztied1.S, Pg/M, Ztied1.S, Zop2.S" or "UQSHLR Ztied2.S, Pg/M, Ztied2.S, Zop1.S" or "MOVPRFX Zresult, Zop1; UQSHL Zresult.S, Pg/M, Zresult.S, Zop2.S"
    /// svuint32_t svqshl[_u32]_z(svbool_t pg, svuint32_t op1, svint32_t op2) : "MOVPRFX Zresult.S, Pg/Z, Zop1.S; UQSHL Zresult.S, Pg/M, Zresult.S, Zop2.S" or "MOVPRFX Zresult.S, Pg/Z, Zop2.S; UQSHLR Zresult.S, Pg/M, Zresult.S, Zop1.S"
  public static unsafe Vector<uint> SaturatingShiftLeft(Vector<uint> left, Vector<int> right);

    /// svuint64_t svqshl[_u64]_m(svbool_t pg, svuint64_t op1, svint64_t op2) : "UQSHL Ztied1.D, Pg/M, Ztied1.D, Zop2.D" or "MOVPRFX Zresult, Zop1; UQSHL Zresult.D, Pg/M, Zresult.D, Zop2.D"
    /// svuint64_t svqshl[_u64]_x(svbool_t pg, svuint64_t op1, svint64_t op2) : "UQSHL Ztied1.D, Pg/M, Ztied1.D, Zop2.D" or "UQSHLR Ztied2.D, Pg/M, Ztied2.D, Zop1.D" or "MOVPRFX Zresult, Zop1; UQSHL Zresult.D, Pg/M, Zresult.D, Zop2.D"
    /// svuint64_t svqshl[_u64]_z(svbool_t pg, svuint64_t op1, svint64_t op2) : "MOVPRFX Zresult.D, Pg/Z, Zop1.D; UQSHL Zresult.D, Pg/M, Zresult.D, Zop2.D" or "MOVPRFX Zresult.D, Pg/Z, Zop2.D; UQSHLR Zresult.D, Pg/M, Zresult.D, Zop1.D"
  public static unsafe Vector<ulong> SaturatingShiftLeft(Vector<ulong> left, Vector<long> right);


    /// SaturatingShiftLeftUnsigned : Saturating shift left unsigned

    /// svuint8_t svqshlu[_n_s8]_m(svbool_t pg, svint8_t op1, uint64_t imm2) : "SQSHLU Ztied1.B, Pg/M, Ztied1.B, #imm2" or "MOVPRFX Zresult, Zop1; SQSHLU Zresult.B, Pg/M, Zresult.B, #imm2"
    /// svuint8_t svqshlu[_n_s8]_x(svbool_t pg, svint8_t op1, uint64_t imm2) : "SQSHLU Ztied1.B, Pg/M, Ztied1.B, #imm2" or "MOVPRFX Zresult, Zop1; SQSHLU Zresult.B, Pg/M, Zresult.B, #imm2"
    /// svuint8_t svqshlu[_n_s8]_z(svbool_t pg, svint8_t op1, uint64_t imm2) : "MOVPRFX Zresult.B, Pg/Z, Zop1.B; SQSHLU Zresult.B, Pg/M, Zresult.B, #imm2"
  public static unsafe Vector<byte> SaturatingShiftLeftUnsigned(Vector<sbyte> op1, ulong imm2);

    /// svuint16_t svqshlu[_n_s16]_m(svbool_t pg, svint16_t op1, uint64_t imm2) : "SQSHLU Ztied1.H, Pg/M, Ztied1.H, #imm2" or "MOVPRFX Zresult, Zop1; SQSHLU Zresult.H, Pg/M, Zresult.H, #imm2"
    /// svuint16_t svqshlu[_n_s16]_x(svbool_t pg, svint16_t op1, uint64_t imm2) : "SQSHLU Ztied1.H, Pg/M, Ztied1.H, #imm2" or "MOVPRFX Zresult, Zop1; SQSHLU Zresult.H, Pg/M, Zresult.H, #imm2"
    /// svuint16_t svqshlu[_n_s16]_z(svbool_t pg, svint16_t op1, uint64_t imm2) : "MOVPRFX Zresult.H, Pg/Z, Zop1.H; SQSHLU Zresult.H, Pg/M, Zresult.H, #imm2"
  public static unsafe Vector<ushort> SaturatingShiftLeftUnsigned(Vector<short> op1, ulong imm2);

    /// svuint32_t svqshlu[_n_s32]_m(svbool_t pg, svint32_t op1, uint64_t imm2) : "SQSHLU Ztied1.S, Pg/M, Ztied1.S, #imm2" or "MOVPRFX Zresult, Zop1; SQSHLU Zresult.S, Pg/M, Zresult.S, #imm2"
    /// svuint32_t svqshlu[_n_s32]_x(svbool_t pg, svint32_t op1, uint64_t imm2) : "SQSHLU Ztied1.S, Pg/M, Ztied1.S, #imm2" or "MOVPRFX Zresult, Zop1; SQSHLU Zresult.S, Pg/M, Zresult.S, #imm2"
    /// svuint32_t svqshlu[_n_s32]_z(svbool_t pg, svint32_t op1, uint64_t imm2) : "MOVPRFX Zresult.S, Pg/Z, Zop1.S; SQSHLU Zresult.S, Pg/M, Zresult.S, #imm2"
  public static unsafe Vector<uint> SaturatingShiftLeftUnsigned(Vector<int> op1, ulong imm2);

    /// svuint64_t svqshlu[_n_s64]_m(svbool_t pg, svint64_t op1, uint64_t imm2) : "SQSHLU Ztied1.D, Pg/M, Ztied1.D, #imm2" or "MOVPRFX Zresult, Zop1; SQSHLU Zresult.D, Pg/M, Zresult.D, #imm2"
    /// svuint64_t svqshlu[_n_s64]_x(svbool_t pg, svint64_t op1, uint64_t imm2) : "SQSHLU Ztied1.D, Pg/M, Ztied1.D, #imm2" or "MOVPRFX Zresult, Zop1; SQSHLU Zresult.D, Pg/M, Zresult.D, #imm2"
    /// svuint64_t svqshlu[_n_s64]_z(svbool_t pg, svint64_t op1, uint64_t imm2) : "MOVPRFX Zresult.D, Pg/Z, Zop1.D; SQSHLU Zresult.D, Pg/M, Zresult.D, #imm2"
  public static unsafe Vector<ulong> SaturatingShiftLeftUnsigned(Vector<long> op1, ulong imm2);


    /// SaturatingShiftRightNarrowingLower : Saturating shift right narrow (bottom)

    /// svint8_t svqshrnb[_n_s16](svint16_t op1, uint64_t imm2) : "SQSHRNB Zresult.B, Zop1.H, #imm2"
  public static unsafe Vector<sbyte> SaturatingShiftRightNarrowingLower(Vector<short> op1, ulong imm2);

    /// svint16_t svqshrnb[_n_s32](svint32_t op1, uint64_t imm2) : "SQSHRNB Zresult.H, Zop1.S, #imm2"
  public static unsafe Vector<short> SaturatingShiftRightNarrowingLower(Vector<int> op1, ulong imm2);

    /// svint32_t svqshrnb[_n_s64](svint64_t op1, uint64_t imm2) : "SQSHRNB Zresult.S, Zop1.D, #imm2"
  public static unsafe Vector<int> SaturatingShiftRightNarrowingLower(Vector<long> op1, ulong imm2);

    /// svuint8_t svqshrnb[_n_u16](svuint16_t op1, uint64_t imm2) : "UQSHRNB Zresult.B, Zop1.H, #imm2"
  public static unsafe Vector<byte> SaturatingShiftRightNarrowingLower(Vector<ushort> op1, ulong imm2);

    /// svuint16_t svqshrnb[_n_u32](svuint32_t op1, uint64_t imm2) : "UQSHRNB Zresult.H, Zop1.S, #imm2"
  public static unsafe Vector<ushort> SaturatingShiftRightNarrowingLower(Vector<uint> op1, ulong imm2);

    /// svuint32_t svqshrnb[_n_u64](svuint64_t op1, uint64_t imm2) : "UQSHRNB Zresult.S, Zop1.D, #imm2"
  public static unsafe Vector<uint> SaturatingShiftRightNarrowingLower(Vector<ulong> op1, ulong imm2);


    /// SaturatingShiftRightNarrowingUpper : Saturating shift right narrow (top)

    /// svint8_t svqshrnt[_n_s16](svint8_t even, svint16_t op1, uint64_t imm2) : "SQSHRNT Ztied.B, Zop1.H, #imm2"
  public static unsafe Vector<sbyte> SaturatingShiftRightNarrowingUpper(Vector<sbyte> even, Vector<short> op1, ulong imm2);

    /// svint16_t svqshrnt[_n_s32](svint16_t even, svint32_t op1, uint64_t imm2) : "SQSHRNT Ztied.H, Zop1.S, #imm2"
  public static unsafe Vector<short> SaturatingShiftRightNarrowingUpper(Vector<short> even, Vector<int> op1, ulong imm2);

    /// svint32_t svqshrnt[_n_s64](svint32_t even, svint64_t op1, uint64_t imm2) : "SQSHRNT Ztied.S, Zop1.D, #imm2"
  public static unsafe Vector<int> SaturatingShiftRightNarrowingUpper(Vector<int> even, Vector<long> op1, ulong imm2);

    /// svuint8_t svqshrnt[_n_u16](svuint8_t even, svuint16_t op1, uint64_t imm2) : "UQSHRNT Ztied.B, Zop1.H, #imm2"
  public static unsafe Vector<byte> SaturatingShiftRightNarrowingUpper(Vector<byte> even, Vector<ushort> op1, ulong imm2);

    /// svuint16_t svqshrnt[_n_u32](svuint16_t even, svuint32_t op1, uint64_t imm2) : "UQSHRNT Ztied.H, Zop1.S, #imm2"
  public static unsafe Vector<ushort> SaturatingShiftRightNarrowingUpper(Vector<ushort> even, Vector<uint> op1, ulong imm2);

    /// svuint32_t svqshrnt[_n_u64](svuint32_t even, svuint64_t op1, uint64_t imm2) : "UQSHRNT Ztied.S, Zop1.D, #imm2"
  public static unsafe Vector<uint> SaturatingShiftRightNarrowingUpper(Vector<uint> even, Vector<ulong> op1, ulong imm2);


    /// SaturatingShiftRightUnsignedNarrowingLower : Saturating shift right unsigned narrow (bottom)

    /// svuint8_t svqshrunb[_n_s16](svint16_t op1, uint64_t imm2) : "SQSHRUNB Zresult.B, Zop1.H, #imm2"
  public static unsafe Vector<byte> SaturatingShiftRightUnsignedNarrowingLower(Vector<short> op1, ulong imm2);

    /// svuint16_t svqshrunb[_n_s32](svint32_t op1, uint64_t imm2) : "SQSHRUNB Zresult.H, Zop1.S, #imm2"
  public static unsafe Vector<ushort> SaturatingShiftRightUnsignedNarrowingLower(Vector<int> op1, ulong imm2);

    /// svuint32_t svqshrunb[_n_s64](svint64_t op1, uint64_t imm2) : "SQSHRUNB Zresult.S, Zop1.D, #imm2"
  public static unsafe Vector<uint> SaturatingShiftRightUnsignedNarrowingLower(Vector<long> op1, ulong imm2);


    /// SaturatingShiftRightUnsignedNarrowingUpper : Saturating shift right unsigned narrow (top)

    /// svuint8_t svqshrunt[_n_s16](svuint8_t even, svint16_t op1, uint64_t imm2) : "SQSHRUNT Ztied.B, Zop1.H, #imm2"
  public static unsafe Vector<byte> SaturatingShiftRightUnsignedNarrowingUpper(Vector<byte> even, Vector<short> op1, ulong imm2);

    /// svuint16_t svqshrunt[_n_s32](svuint16_t even, svint32_t op1, uint64_t imm2) : "SQSHRUNT Ztied.H, Zop1.S, #imm2"
  public static unsafe Vector<ushort> SaturatingShiftRightUnsignedNarrowingUpper(Vector<ushort> even, Vector<int> op1, ulong imm2);

    /// svuint32_t svqshrunt[_n_s64](svuint32_t even, svint64_t op1, uint64_t imm2) : "SQSHRUNT Ztied.S, Zop1.D, #imm2"
  public static unsafe Vector<uint> SaturatingShiftRightUnsignedNarrowingUpper(Vector<uint> even, Vector<long> op1, ulong imm2);


    /// ShiftLeftAndInsert : Shift left and insert

    /// svint8_t svsli[_n_s8](svint8_t op1, svint8_t op2, uint64_t imm3) : "SLI Ztied1.B, Zop2.B, #imm3"
  public static unsafe Vector<sbyte> ShiftLeftAndInsert(Vector<sbyte> op1, Vector<sbyte> op2, ulong imm3);

    /// svint16_t svsli[_n_s16](svint16_t op1, svint16_t op2, uint64_t imm3) : "SLI Ztied1.H, Zop2.H, #imm3"
  public static unsafe Vector<short> ShiftLeftAndInsert(Vector<short> op1, Vector<short> op2, ulong imm3);

    /// svint32_t svsli[_n_s32](svint32_t op1, svint32_t op2, uint64_t imm3) : "SLI Ztied1.S, Zop2.S, #imm3"
  public static unsafe Vector<int> ShiftLeftAndInsert(Vector<int> op1, Vector<int> op2, ulong imm3);

    /// svint64_t svsli[_n_s64](svint64_t op1, svint64_t op2, uint64_t imm3) : "SLI Ztied1.D, Zop2.D, #imm3"
  public static unsafe Vector<long> ShiftLeftAndInsert(Vector<long> op1, Vector<long> op2, ulong imm3);

    /// svuint8_t svsli[_n_u8](svuint8_t op1, svuint8_t op2, uint64_t imm3) : "SLI Ztied1.B, Zop2.B, #imm3"
  public static unsafe Vector<byte> ShiftLeftAndInsert(Vector<byte> op1, Vector<byte> op2, ulong imm3);

    /// svuint16_t svsli[_n_u16](svuint16_t op1, svuint16_t op2, uint64_t imm3) : "SLI Ztied1.H, Zop2.H, #imm3"
  public static unsafe Vector<ushort> ShiftLeftAndInsert(Vector<ushort> op1, Vector<ushort> op2, ulong imm3);

    /// svuint32_t svsli[_n_u32](svuint32_t op1, svuint32_t op2, uint64_t imm3) : "SLI Ztied1.S, Zop2.S, #imm3"
  public static unsafe Vector<uint> ShiftLeftAndInsert(Vector<uint> op1, Vector<uint> op2, ulong imm3);

    /// svuint64_t svsli[_n_u64](svuint64_t op1, svuint64_t op2, uint64_t imm3) : "SLI Ztied1.D, Zop2.D, #imm3"
  public static unsafe Vector<ulong> ShiftLeftAndInsert(Vector<ulong> op1, Vector<ulong> op2, ulong imm3);


    /// ShiftLeftWideningLower : Shift left long (bottom)

    /// svint16_t svshllb[_n_s16](svint8_t op1, uint64_t imm2) : "SSHLLB Zresult.H, Zop1.B, #imm2"
  public static unsafe Vector<short> ShiftLeftWideningLower(Vector<sbyte> op1, ulong imm2);

    /// svint32_t svshllb[_n_s32](svint16_t op1, uint64_t imm2) : "SSHLLB Zresult.S, Zop1.H, #imm2"
  public static unsafe Vector<int> ShiftLeftWideningLower(Vector<short> op1, ulong imm2);

    /// svint64_t svshllb[_n_s64](svint32_t op1, uint64_t imm2) : "SSHLLB Zresult.D, Zop1.S, #imm2"
  public static unsafe Vector<long> ShiftLeftWideningLower(Vector<int> op1, ulong imm2);

    /// svuint16_t svshllb[_n_u16](svuint8_t op1, uint64_t imm2) : "USHLLB Zresult.H, Zop1.B, #imm2"
  public static unsafe Vector<ushort> ShiftLeftWideningLower(Vector<byte> op1, ulong imm2);

    /// svuint32_t svshllb[_n_u32](svuint16_t op1, uint64_t imm2) : "USHLLB Zresult.S, Zop1.H, #imm2"
  public static unsafe Vector<uint> ShiftLeftWideningLower(Vector<ushort> op1, ulong imm2);

    /// svuint64_t svshllb[_n_u64](svuint32_t op1, uint64_t imm2) : "USHLLB Zresult.D, Zop1.S, #imm2"
  public static unsafe Vector<ulong> ShiftLeftWideningLower(Vector<uint> op1, ulong imm2);


    /// ShiftLeftWideningUpper : Shift left long (top)

    /// svint16_t svshllt[_n_s16](svint8_t op1, uint64_t imm2) : "SSHLLT Zresult.H, Zop1.B, #imm2"
  public static unsafe Vector<short> ShiftLeftWideningUpper(Vector<sbyte> op1, ulong imm2);

    /// svint32_t svshllt[_n_s32](svint16_t op1, uint64_t imm2) : "SSHLLT Zresult.S, Zop1.H, #imm2"
  public static unsafe Vector<int> ShiftLeftWideningUpper(Vector<short> op1, ulong imm2);

    /// svint64_t svshllt[_n_s64](svint32_t op1, uint64_t imm2) : "SSHLLT Zresult.D, Zop1.S, #imm2"
  public static unsafe Vector<long> ShiftLeftWideningUpper(Vector<int> op1, ulong imm2);

    /// svuint16_t svshllt[_n_u16](svuint8_t op1, uint64_t imm2) : "USHLLT Zresult.H, Zop1.B, #imm2"
  public static unsafe Vector<ushort> ShiftLeftWideningUpper(Vector<byte> op1, ulong imm2);

    /// svuint32_t svshllt[_n_u32](svuint16_t op1, uint64_t imm2) : "USHLLT Zresult.S, Zop1.H, #imm2"
  public static unsafe Vector<uint> ShiftLeftWideningUpper(Vector<ushort> op1, ulong imm2);

    /// svuint64_t svshllt[_n_u64](svuint32_t op1, uint64_t imm2) : "USHLLT Zresult.D, Zop1.S, #imm2"
  public static unsafe Vector<ulong> ShiftLeftWideningUpper(Vector<uint> op1, ulong imm2);


    /// ShiftRightAndAccumulate : Shift right and accumulate

    /// svint8_t svsra[_n_s8](svint8_t op1, svint8_t op2, uint64_t imm3) : "SSRA Ztied1.B, Zop2.B, #imm3" or "MOVPRFX Zresult, Zop1; SSRA Zresult.B, Zop2.B, #imm3"
  public static unsafe Vector<sbyte> ShiftRightAndAccumulate(Vector<sbyte> op1, Vector<sbyte> op2, ulong imm3);

    /// svint16_t svsra[_n_s16](svint16_t op1, svint16_t op2, uint64_t imm3) : "SSRA Ztied1.H, Zop2.H, #imm3" or "MOVPRFX Zresult, Zop1; SSRA Zresult.H, Zop2.H, #imm3"
  public static unsafe Vector<short> ShiftRightAndAccumulate(Vector<short> op1, Vector<short> op2, ulong imm3);

    /// svint32_t svsra[_n_s32](svint32_t op1, svint32_t op2, uint64_t imm3) : "SSRA Ztied1.S, Zop2.S, #imm3" or "MOVPRFX Zresult, Zop1; SSRA Zresult.S, Zop2.S, #imm3"
  public static unsafe Vector<int> ShiftRightAndAccumulate(Vector<int> op1, Vector<int> op2, ulong imm3);

    /// svint64_t svsra[_n_s64](svint64_t op1, svint64_t op2, uint64_t imm3) : "SSRA Ztied1.D, Zop2.D, #imm3" or "MOVPRFX Zresult, Zop1; SSRA Zresult.D, Zop2.D, #imm3"
  public static unsafe Vector<long> ShiftRightAndAccumulate(Vector<long> op1, Vector<long> op2, ulong imm3);

    /// svuint8_t svsra[_n_u8](svuint8_t op1, svuint8_t op2, uint64_t imm3) : "USRA Ztied1.B, Zop2.B, #imm3" or "MOVPRFX Zresult, Zop1; USRA Zresult.B, Zop2.B, #imm3"
  public static unsafe Vector<byte> ShiftRightAndAccumulate(Vector<byte> op1, Vector<byte> op2, ulong imm3);

    /// svuint16_t svsra[_n_u16](svuint16_t op1, svuint16_t op2, uint64_t imm3) : "USRA Ztied1.H, Zop2.H, #imm3" or "MOVPRFX Zresult, Zop1; USRA Zresult.H, Zop2.H, #imm3"
  public static unsafe Vector<ushort> ShiftRightAndAccumulate(Vector<ushort> op1, Vector<ushort> op2, ulong imm3);

    /// svuint32_t svsra[_n_u32](svuint32_t op1, svuint32_t op2, uint64_t imm3) : "USRA Ztied1.S, Zop2.S, #imm3" or "MOVPRFX Zresult, Zop1; USRA Zresult.S, Zop2.S, #imm3"
  public static unsafe Vector<uint> ShiftRightAndAccumulate(Vector<uint> op1, Vector<uint> op2, ulong imm3);

    /// svuint64_t svsra[_n_u64](svuint64_t op1, svuint64_t op2, uint64_t imm3) : "USRA Ztied1.D, Zop2.D, #imm3" or "MOVPRFX Zresult, Zop1; USRA Zresult.D, Zop2.D, #imm3"
  public static unsafe Vector<ulong> ShiftRightAndAccumulate(Vector<ulong> op1, Vector<ulong> op2, ulong imm3);


    /// ShiftRightAndInsert : Shift right and insert

    /// svint8_t svsri[_n_s8](svint8_t op1, svint8_t op2, uint64_t imm3) : "SRI Ztied1.B, Zop2.B, #imm3"
  public static unsafe Vector<sbyte> ShiftRightAndInsert(Vector<sbyte> op1, Vector<sbyte> op2, ulong imm3);

    /// svint16_t svsri[_n_s16](svint16_t op1, svint16_t op2, uint64_t imm3) : "SRI Ztied1.H, Zop2.H, #imm3"
  public static unsafe Vector<short> ShiftRightAndInsert(Vector<short> op1, Vector<short> op2, ulong imm3);

    /// svint32_t svsri[_n_s32](svint32_t op1, svint32_t op2, uint64_t imm3) : "SRI Ztied1.S, Zop2.S, #imm3"
  public static unsafe Vector<int> ShiftRightAndInsert(Vector<int> op1, Vector<int> op2, ulong imm3);

    /// svint64_t svsri[_n_s64](svint64_t op1, svint64_t op2, uint64_t imm3) : "SRI Ztied1.D, Zop2.D, #imm3"
  public static unsafe Vector<long> ShiftRightAndInsert(Vector<long> op1, Vector<long> op2, ulong imm3);

    /// svuint8_t svsri[_n_u8](svuint8_t op1, svuint8_t op2, uint64_t imm3) : "SRI Ztied1.B, Zop2.B, #imm3"
  public static unsafe Vector<byte> ShiftRightAndInsert(Vector<byte> op1, Vector<byte> op2, ulong imm3);

    /// svuint16_t svsri[_n_u16](svuint16_t op1, svuint16_t op2, uint64_t imm3) : "SRI Ztied1.H, Zop2.H, #imm3"
  public static unsafe Vector<ushort> ShiftRightAndInsert(Vector<ushort> op1, Vector<ushort> op2, ulong imm3);

    /// svuint32_t svsri[_n_u32](svuint32_t op1, svuint32_t op2, uint64_t imm3) : "SRI Ztied1.S, Zop2.S, #imm3"
  public static unsafe Vector<uint> ShiftRightAndInsert(Vector<uint> op1, Vector<uint> op2, ulong imm3);

    /// svuint64_t svsri[_n_u64](svuint64_t op1, svuint64_t op2, uint64_t imm3) : "SRI Ztied1.D, Zop2.D, #imm3"
  public static unsafe Vector<ulong> ShiftRightAndInsert(Vector<ulong> op1, Vector<ulong> op2, ulong imm3);


    /// ShiftRightNarrowingLower : Shift right narrow (bottom)

    /// svint8_t svshrnb[_n_s16](svint16_t op1, uint64_t imm2) : "SHRNB Zresult.B, Zop1.H, #imm2"
  public static unsafe Vector<sbyte> ShiftRightNarrowingLower(Vector<short> op1, ulong imm2);

    /// svint16_t svshrnb[_n_s32](svint32_t op1, uint64_t imm2) : "SHRNB Zresult.H, Zop1.S, #imm2"
  public static unsafe Vector<short> ShiftRightNarrowingLower(Vector<int> op1, ulong imm2);

    /// svint32_t svshrnb[_n_s64](svint64_t op1, uint64_t imm2) : "SHRNB Zresult.S, Zop1.D, #imm2"
  public static unsafe Vector<int> ShiftRightNarrowingLower(Vector<long> op1, ulong imm2);

    /// svuint8_t svshrnb[_n_u16](svuint16_t op1, uint64_t imm2) : "SHRNB Zresult.B, Zop1.H, #imm2"
  public static unsafe Vector<byte> ShiftRightNarrowingLower(Vector<ushort> op1, ulong imm2);

    /// svuint16_t svshrnb[_n_u32](svuint32_t op1, uint64_t imm2) : "SHRNB Zresult.H, Zop1.S, #imm2"
  public static unsafe Vector<ushort> ShiftRightNarrowingLower(Vector<uint> op1, ulong imm2);

    /// svuint32_t svshrnb[_n_u64](svuint64_t op1, uint64_t imm2) : "SHRNB Zresult.S, Zop1.D, #imm2"
  public static unsafe Vector<uint> ShiftRightNarrowingLower(Vector<ulong> op1, ulong imm2);


    /// ShiftRightNarrowingUpper : Shift right narrow (top)

    /// svint8_t svshrnt[_n_s16](svint8_t even, svint16_t op1, uint64_t imm2) : "SHRNT Ztied.B, Zop1.H, #imm2"
  public static unsafe Vector<sbyte> ShiftRightNarrowingUpper(Vector<sbyte> even, Vector<short> op1, ulong imm2);

    /// svint16_t svshrnt[_n_s32](svint16_t even, svint32_t op1, uint64_t imm2) : "SHRNT Ztied.H, Zop1.S, #imm2"
  public static unsafe Vector<short> ShiftRightNarrowingUpper(Vector<short> even, Vector<int> op1, ulong imm2);

    /// svint32_t svshrnt[_n_s64](svint32_t even, svint64_t op1, uint64_t imm2) : "SHRNT Ztied.S, Zop1.D, #imm2"
  public static unsafe Vector<int> ShiftRightNarrowingUpper(Vector<int> even, Vector<long> op1, ulong imm2);

    /// svuint8_t svshrnt[_n_u16](svuint8_t even, svuint16_t op1, uint64_t imm2) : "SHRNT Ztied.B, Zop1.H, #imm2"
  public static unsafe Vector<byte> ShiftRightNarrowingUpper(Vector<byte> even, Vector<ushort> op1, ulong imm2);

    /// svuint16_t svshrnt[_n_u32](svuint16_t even, svuint32_t op1, uint64_t imm2) : "SHRNT Ztied.H, Zop1.S, #imm2"
  public static unsafe Vector<ushort> ShiftRightNarrowingUpper(Vector<ushort> even, Vector<uint> op1, ulong imm2);

    /// svuint32_t svshrnt[_n_u64](svuint32_t even, svuint64_t op1, uint64_t imm2) : "SHRNT Ztied.S, Zop1.D, #imm2"
  public static unsafe Vector<uint> ShiftRightNarrowingUpper(Vector<uint> even, Vector<ulong> op1, ulong imm2);


    /// Xor : Bitwise exclusive OR of three vectors

    /// svint8_t sveor3[_s8](svint8_t op1, svint8_t op2, svint8_t op3) : "EOR3 Ztied1.D, Ztied1.D, Zop2.D, Zop3.D" or "EOR3 Ztied2.D, Ztied2.D, Zop3.D, Zop1.D" or "EOR3 Ztied3.D, Ztied3.D, Zop1.D, Zop2.D" or "MOVPRFX Zresult, Zop1; EOR3 Zresult.D, Zresult.D, Zop2.D, Zop3.D"
  public static unsafe Vector<sbyte> Xor(Vector<sbyte> op1, Vector<sbyte> op2, Vector<sbyte> op3);

    /// svint16_t sveor3[_s16](svint16_t op1, svint16_t op2, svint16_t op3) : "EOR3 Ztied1.D, Ztied1.D, Zop2.D, Zop3.D" or "EOR3 Ztied2.D, Ztied2.D, Zop3.D, Zop1.D" or "EOR3 Ztied3.D, Ztied3.D, Zop1.D, Zop2.D" or "MOVPRFX Zresult, Zop1; EOR3 Zresult.D, Zresult.D, Zop2.D, Zop3.D"
  public static unsafe Vector<short> Xor(Vector<short> op1, Vector<short> op2, Vector<short> op3);

    /// svint32_t sveor3[_s32](svint32_t op1, svint32_t op2, svint32_t op3) : "EOR3 Ztied1.D, Ztied1.D, Zop2.D, Zop3.D" or "EOR3 Ztied2.D, Ztied2.D, Zop3.D, Zop1.D" or "EOR3 Ztied3.D, Ztied3.D, Zop1.D, Zop2.D" or "MOVPRFX Zresult, Zop1; EOR3 Zresult.D, Zresult.D, Zop2.D, Zop3.D"
  public static unsafe Vector<int> Xor(Vector<int> op1, Vector<int> op2, Vector<int> op3);

    /// svint64_t sveor3[_s64](svint64_t op1, svint64_t op2, svint64_t op3) : "EOR3 Ztied1.D, Ztied1.D, Zop2.D, Zop3.D" or "EOR3 Ztied2.D, Ztied2.D, Zop3.D, Zop1.D" or "EOR3 Ztied3.D, Ztied3.D, Zop1.D, Zop2.D" or "MOVPRFX Zresult, Zop1; EOR3 Zresult.D, Zresult.D, Zop2.D, Zop3.D"
  public static unsafe Vector<long> Xor(Vector<long> op1, Vector<long> op2, Vector<long> op3);

    /// svuint8_t sveor3[_u8](svuint8_t op1, svuint8_t op2, svuint8_t op3) : "EOR3 Ztied1.D, Ztied1.D, Zop2.D, Zop3.D" or "EOR3 Ztied2.D, Ztied2.D, Zop3.D, Zop1.D" or "EOR3 Ztied3.D, Ztied3.D, Zop1.D, Zop2.D" or "MOVPRFX Zresult, Zop1; EOR3 Zresult.D, Zresult.D, Zop2.D, Zop3.D"
  public static unsafe Vector<byte> Xor(Vector<byte> op1, Vector<byte> op2, Vector<byte> op3);

    /// svuint16_t sveor3[_u16](svuint16_t op1, svuint16_t op2, svuint16_t op3) : "EOR3 Ztied1.D, Ztied1.D, Zop2.D, Zop3.D" or "EOR3 Ztied2.D, Ztied2.D, Zop3.D, Zop1.D" or "EOR3 Ztied3.D, Ztied3.D, Zop1.D, Zop2.D" or "MOVPRFX Zresult, Zop1; EOR3 Zresult.D, Zresult.D, Zop2.D, Zop3.D"
  public static unsafe Vector<ushort> Xor(Vector<ushort> op1, Vector<ushort> op2, Vector<ushort> op3);

    /// svuint32_t sveor3[_u32](svuint32_t op1, svuint32_t op2, svuint32_t op3) : "EOR3 Ztied1.D, Ztied1.D, Zop2.D, Zop3.D" or "EOR3 Ztied2.D, Ztied2.D, Zop3.D, Zop1.D" or "EOR3 Ztied3.D, Ztied3.D, Zop1.D, Zop2.D" or "MOVPRFX Zresult, Zop1; EOR3 Zresult.D, Zresult.D, Zop2.D, Zop3.D"
  public static unsafe Vector<uint> Xor(Vector<uint> op1, Vector<uint> op2, Vector<uint> op3);

    /// svuint64_t sveor3[_u64](svuint64_t op1, svuint64_t op2, svuint64_t op3) : "EOR3 Ztied1.D, Ztied1.D, Zop2.D, Zop3.D" or "EOR3 Ztied2.D, Ztied2.D, Zop3.D, Zop1.D" or "EOR3 Ztied3.D, Ztied3.D, Zop1.D, Zop2.D" or "MOVPRFX Zresult, Zop1; EOR3 Zresult.D, Zresult.D, Zop2.D, Zop3.D"
  public static unsafe Vector<ulong> Xor(Vector<ulong> op1, Vector<ulong> op2, Vector<ulong> op3);


    /// XorRotateRight : Bitwise exclusive OR and rotate right

    /// svint8_t svxar[_n_s8](svint8_t op1, svint8_t op2, uint64_t imm3) : "XAR Ztied1.B, Ztied1.B, Zop2.B, #imm3" or "XAR Ztied2.B, Ztied2.B, Zop1.B, #imm3" or "MOVPRFX Zresult, Zop1; XAR Zresult.B, Zresult.B, Zop2.B, #imm3"
  public static unsafe Vector<sbyte> XorRotateRight(Vector<sbyte> op1, Vector<sbyte> op2, ulong imm3);

    /// svint16_t svxar[_n_s16](svint16_t op1, svint16_t op2, uint64_t imm3) : "XAR Ztied1.H, Ztied1.H, Zop2.H, #imm3" or "XAR Ztied2.H, Ztied2.H, Zop1.H, #imm3" or "MOVPRFX Zresult, Zop1; XAR Zresult.H, Zresult.H, Zop2.H, #imm3"
  public static unsafe Vector<short> XorRotateRight(Vector<short> op1, Vector<short> op2, ulong imm3);

    /// svint32_t svxar[_n_s32](svint32_t op1, svint32_t op2, uint64_t imm3) : "XAR Ztied1.S, Ztied1.S, Zop2.S, #imm3" or "XAR Ztied2.S, Ztied2.S, Zop1.S, #imm3" or "MOVPRFX Zresult, Zop1; XAR Zresult.S, Zresult.S, Zop2.S, #imm3"
  public static unsafe Vector<int> XorRotateRight(Vector<int> op1, Vector<int> op2, ulong imm3);

    /// svint64_t svxar[_n_s64](svint64_t op1, svint64_t op2, uint64_t imm3) : "XAR Ztied1.D, Ztied1.D, Zop2.D, #imm3" or "XAR Ztied2.D, Ztied2.D, Zop1.D, #imm3" or "MOVPRFX Zresult, Zop1; XAR Zresult.D, Zresult.D, Zop2.D, #imm3"
  public static unsafe Vector<long> XorRotateRight(Vector<long> op1, Vector<long> op2, ulong imm3);

    /// svuint8_t svxar[_n_u8](svuint8_t op1, svuint8_t op2, uint64_t imm3) : "XAR Ztied1.B, Ztied1.B, Zop2.B, #imm3" or "XAR Ztied2.B, Ztied2.B, Zop1.B, #imm3" or "MOVPRFX Zresult, Zop1; XAR Zresult.B, Zresult.B, Zop2.B, #imm3"
  public static unsafe Vector<byte> XorRotateRight(Vector<byte> op1, Vector<byte> op2, ulong imm3);

    /// svuint16_t svxar[_n_u16](svuint16_t op1, svuint16_t op2, uint64_t imm3) : "XAR Ztied1.H, Ztied1.H, Zop2.H, #imm3" or "XAR Ztied2.H, Ztied2.H, Zop1.H, #imm3" or "MOVPRFX Zresult, Zop1; XAR Zresult.H, Zresult.H, Zop2.H, #imm3"
  public static unsafe Vector<ushort> XorRotateRight(Vector<ushort> op1, Vector<ushort> op2, ulong imm3);

    /// svuint32_t svxar[_n_u32](svuint32_t op1, svuint32_t op2, uint64_t imm3) : "XAR Ztied1.S, Ztied1.S, Zop2.S, #imm3" or "XAR Ztied2.S, Ztied2.S, Zop1.S, #imm3" or "MOVPRFX Zresult, Zop1; XAR Zresult.S, Zresult.S, Zop2.S, #imm3"
  public static unsafe Vector<uint> XorRotateRight(Vector<uint> op1, Vector<uint> op2, ulong imm3);

    /// svuint64_t svxar[_n_u64](svuint64_t op1, svuint64_t op2, uint64_t imm3) : "XAR Ztied1.D, Ztied1.D, Zop2.D, #imm3" or "XAR Ztied2.D, Ztied2.D, Zop1.D, #imm3" or "MOVPRFX Zresult, Zop1; XAR Zresult.D, Zresult.D, Zop2.D, #imm3"
  public static unsafe Vector<ulong> XorRotateRight(Vector<ulong> op1, Vector<ulong> op2, ulong imm3);


  /// total method signatures: 196
  /// total method names:      30
}

@a74nh
Copy link
Contributor Author

a74nh commented Oct 26, 2023 •
edited
Loading 

  /// Optional Entries:
  ///   public static unsafe Vector<sbyte> BitwiseClearXor(Vector<sbyte> op1, Vector<sbyte> op2, sbyte op3); // svbcax[_n_s8]
  ///   public static unsafe Vector<short> BitwiseClearXor(Vector<short> op1, Vector<short> op2, short op3); // svbcax[_n_s16]
  ///   public static unsafe Vector<int> BitwiseClearXor(Vector<int> op1, Vector<int> op2, int op3); // svbcax[_n_s32]
  ///   public static unsafe Vector<long> BitwiseClearXor(Vector<long> op1, Vector<long> op2, long op3); // svbcax[_n_s64]
  ///   public static unsafe Vector<byte> BitwiseClearXor(Vector<byte> op1, Vector<byte> op2, byte op3); // svbcax[_n_u8]
  ///   public static unsafe Vector<ushort> BitwiseClearXor(Vector<ushort> op1, Vector<ushort> op2, ushort op3); // svbcax[_n_u16]
  ///   public static unsafe Vector<uint> BitwiseClearXor(Vector<uint> op1, Vector<uint> op2, uint op3); // svbcax[_n_u32]
  ///   public static unsafe Vector<ulong> BitwiseClearXor(Vector<ulong> op1, Vector<ulong> op2, ulong op3); // svbcax[_n_u64]
  ///   public static unsafe Vector<sbyte> BitwiseSelect(Vector<sbyte> op1, Vector<sbyte> op2, sbyte op3); // svbsl[_n_s8]
  ///   public static unsafe Vector<short> BitwiseSelect(Vector<short> op1, Vector<short> op2, short op3); // svbsl[_n_s16]
  ///   public static unsafe Vector<int> BitwiseSelect(Vector<int> op1, Vector<int> op2, int op3); // svbsl[_n_s32]
  ///   public static unsafe Vector<long> BitwiseSelect(Vector<long> op1, Vector<long> op2, long op3); // svbsl[_n_s64]
  ///   public static unsafe Vector<byte> BitwiseSelect(Vector<byte> op1, Vector<byte> op2, byte op3); // svbsl[_n_u8]
  ///   public static unsafe Vector<ushort> BitwiseSelect(Vector<ushort> op1, Vector<ushort> op2, ushort op3); // svbsl[_n_u16]
  ///   public static unsafe Vector<uint> BitwiseSelect(Vector<uint> op1, Vector<uint> op2, uint op3); // svbsl[_n_u32]
  ///   public static unsafe Vector<ulong> BitwiseSelect(Vector<ulong> op1, Vector<ulong> op2, ulong op3); // svbsl[_n_u64]
  ///   public static unsafe Vector<sbyte> BitwiseSelectFirstInverted(Vector<sbyte> op1, Vector<sbyte> op2, sbyte op3); // svbsl1n[_n_s8]
  ///   public static unsafe Vector<short> BitwiseSelectFirstInverted(Vector<short> op1, Vector<short> op2, short op3); // svbsl1n[_n_s16]
  ///   public static unsafe Vector<int> BitwiseSelectFirstInverted(Vector<int> op1, Vector<int> op2, int op3); // svbsl1n[_n_s32]
  ///   public static unsafe Vector<long> BitwiseSelectFirstInverted(Vector<long> op1, Vector<long> op2, long op3); // svbsl1n[_n_s64]
  ///   public static unsafe Vector<byte> BitwiseSelectFirstInverted(Vector<byte> op1, Vector<byte> op2, byte op3); // svbsl1n[_n_u8]
  ///   public static unsafe Vector<ushort> BitwiseSelectFirstInverted(Vector<ushort> op1, Vector<ushort> op2, ushort op3); // svbsl1n[_n_u16]
  ///   public static unsafe Vector<uint> BitwiseSelectFirstInverted(Vector<uint> op1, Vector<uint> op2, uint op3); // svbsl1n[_n_u32]
  ///   public static unsafe Vector<ulong> BitwiseSelectFirstInverted(Vector<ulong> op1, Vector<ulong> op2, ulong op3); // svbsl1n[_n_u64]
  ///   public static unsafe Vector<sbyte> BitwiseSelectInverted(Vector<sbyte> op1, Vector<sbyte> op2, sbyte op3); // svnbsl[_n_s8]
  ///   public static unsafe Vector<short> BitwiseSelectInverted(Vector<short> op1, Vector<short> op2, short op3); // svnbsl[_n_s16]
  ///   public static unsafe Vector<int> BitwiseSelectInverted(Vector<int> op1, Vector<int> op2, int op3); // svnbsl[_n_s32]
  ///   public static unsafe Vector<long> BitwiseSelectInverted(Vector<long> op1, Vector<long> op2, long op3); // svnbsl[_n_s64]
  ///   public static unsafe Vector<byte> BitwiseSelectInverted(Vector<byte> op1, Vector<byte> op2, byte op3); // svnbsl[_n_u8]
  ///   public static unsafe Vector<ushort> BitwiseSelectInverted(Vector<ushort> op1, Vector<ushort> op2, ushort op3); // svnbsl[_n_u16]
  ///   public static unsafe Vector<uint> BitwiseSelectInverted(Vector<uint> op1, Vector<uint> op2, uint op3); // svnbsl[_n_u32]
  ///   public static unsafe Vector<ulong> BitwiseSelectInverted(Vector<ulong> op1, Vector<ulong> op2, ulong op3); // svnbsl[_n_u64]
  ///   public static unsafe Vector<sbyte> BitwiseSelectSecondInverted(Vector<sbyte> op1, Vector<sbyte> op2, sbyte op3); // svbsl2n[_n_s8]
  ///   public static unsafe Vector<short> BitwiseSelectSecondInverted(Vector<short> op1, Vector<short> op2, short op3); // svbsl2n[_n_s16]
  ///   public static unsafe Vector<int> BitwiseSelectSecondInverted(Vector<int> op1, Vector<int> op2, int op3); // svbsl2n[_n_s32]
  ///   public static unsafe Vector<long> BitwiseSelectSecondInverted(Vector<long> op1, Vector<long> op2, long op3); // svbsl2n[_n_s64]
  ///   public static unsafe Vector<byte> BitwiseSelectSecondInverted(Vector<byte> op1, Vector<byte> op2, byte op3); // svbsl2n[_n_u8]
  ///   public static unsafe Vector<ushort> BitwiseSelectSecondInverted(Vector<ushort> op1, Vector<ushort> op2, ushort op3); // svbsl2n[_n_u16]
  ///   public static unsafe Vector<uint> BitwiseSelectSecondInverted(Vector<uint> op1, Vector<uint> op2, uint op3); // svbsl2n[_n_u32]
  ///   public static unsafe Vector<ulong> BitwiseSelectSecondInverted(Vector<ulong> op1, Vector<ulong> op2, ulong op3); // svbsl2n[_n_u64]
  ///   public static unsafe Vector<sbyte> RoundingShiftLeft(Vector<sbyte> left, sbyte right); // svrshl[_n_s8]_m or svrshl[_n_s8]_x or svrshl[_n_s8]_z
  ///   public static unsafe Vector<short> RoundingShiftLeft(Vector<short> left, short right); // svrshl[_n_s16]_m or svrshl[_n_s16]_x or svrshl[_n_s16]_z
  ///   public static unsafe Vector<int> RoundingShiftLeft(Vector<int> left, int right); // svrshl[_n_s32]_m or svrshl[_n_s32]_x or svrshl[_n_s32]_z
  ///   public static unsafe Vector<long> RoundingShiftLeft(Vector<long> left, long right); // svrshl[_n_s64]_m or svrshl[_n_s64]_x or svrshl[_n_s64]_z
  ///   public static unsafe Vector<byte> RoundingShiftLeft(Vector<byte> left, sbyte right); // svrshl[_n_u8]_m or svrshl[_n_u8]_x or svrshl[_n_u8]_z
  ///   public static unsafe Vector<ushort> RoundingShiftLeft(Vector<ushort> left, short right); // svrshl[_n_u16]_m or svrshl[_n_u16]_x or svrshl[_n_u16]_z
  ///   public static unsafe Vector<uint> RoundingShiftLeft(Vector<uint> left, int right); // svrshl[_n_u32]_m or svrshl[_n_u32]_x or svrshl[_n_u32]_z
  ///   public static unsafe Vector<ulong> RoundingShiftLeft(Vector<ulong> left, long right); // svrshl[_n_u64]_m or svrshl[_n_u64]_x or svrshl[_n_u64]_z
  ///   public static unsafe Vector<sbyte> SaturatingRoundingShiftLeft(Vector<sbyte> left, sbyte right); // svqrshl[_n_s8]_m or svqrshl[_n_s8]_x or svqrshl[_n_s8]_z
  ///   public static unsafe Vector<short> SaturatingRoundingShiftLeft(Vector<short> left, short right); // svqrshl[_n_s16]_m or svqrshl[_n_s16]_x or svqrshl[_n_s16]_z
  ///   public static unsafe Vector<int> SaturatingRoundingShiftLeft(Vector<int> left, int right); // svqrshl[_n_s32]_m or svqrshl[_n_s32]_x or svqrshl[_n_s32]_z
  ///   public static unsafe Vector<long> SaturatingRoundingShiftLeft(Vector<long> left, long right); // svqrshl[_n_s64]_m or svqrshl[_n_s64]_x or svqrshl[_n_s64]_z
  ///   public static unsafe Vector<byte> SaturatingRoundingShiftLeft(Vector<byte> left, sbyte right); // svqrshl[_n_u8]_m or svqrshl[_n_u8]_x or svqrshl[_n_u8]_z
  ///   public static unsafe Vector<ushort> SaturatingRoundingShiftLeft(Vector<ushort> left, short right); // svqrshl[_n_u16]_m or svqrshl[_n_u16]_x or svqrshl[_n_u16]_z
  ///   public static unsafe Vector<uint> SaturatingRoundingShiftLeft(Vector<uint> left, int right); // svqrshl[_n_u32]_m or svqrshl[_n_u32]_x or svqrshl[_n_u32]_z
  ///   public static unsafe Vector<ulong> SaturatingRoundingShiftLeft(Vector<ulong> left, long right); // svqrshl[_n_u64]_m or svqrshl[_n_u64]_x or svqrshl[_n_u64]_z
  ///   public static unsafe Vector<sbyte> SaturatingShiftLeft(Vector<sbyte> left, sbyte right); // svqshl[_n_s8]_m or svqshl[_n_s8]_x or svqshl[_n_s8]_z
  ///   public static unsafe Vector<short> SaturatingShiftLeft(Vector<short> left, short right); // svqshl[_n_s16]_m or svqshl[_n_s16]_x or svqshl[_n_s16]_z
  ///   public static unsafe Vector<int> SaturatingShiftLeft(Vector<int> left, int right); // svqshl[_n_s32]_m or svqshl[_n_s32]_x or svqshl[_n_s32]_z
  ///   public static unsafe Vector<long> SaturatingShiftLeft(Vector<long> left, long right); // svqshl[_n_s64]_m or svqshl[_n_s64]_x or svqshl[_n_s64]_z
  ///   public static unsafe Vector<byte> SaturatingShiftLeft(Vector<byte> left, sbyte right); // svqshl[_n_u8]_m or svqshl[_n_u8]_x or svqshl[_n_u8]_z
  ///   public static unsafe Vector<ushort> SaturatingShiftLeft(Vector<ushort> left, short right); // svqshl[_n_u16]_m or svqshl[_n_u16]_x or svqshl[_n_u16]_z
  ///   public static unsafe Vector<uint> SaturatingShiftLeft(Vector<uint> left, int right); // svqshl[_n_u32]_m or svqshl[_n_u32]_x or svqshl[_n_u32]_z
  ///   public static unsafe Vector<ulong> SaturatingShiftLeft(Vector<ulong> left, long right); // svqshl[_n_u64]_m or svqshl[_n_u64]_x or svqshl[_n_u64]_z
  ///   public static unsafe Vector<sbyte> Xor(Vector<sbyte> op1, Vector<sbyte> op2, sbyte op3); // sveor3[_n_s8]
  ///   public static unsafe Vector<short> Xor(Vector<short> op1, Vector<short> op2, short op3); // sveor3[_n_s16]
  ///   public static unsafe Vector<int> Xor(Vector<int> op1, Vector<int> op2, int op3); // sveor3[_n_s32]
  ///   public static unsafe Vector<long> Xor(Vector<long> op1, Vector<long> op2, long op3); // sveor3[_n_s64]
  ///   public static unsafe Vector<byte> Xor(Vector<byte> op1, Vector<byte> op2, byte op3); // sveor3[_n_u8]
  ///   public static unsafe Vector<ushort> Xor(Vector<ushort> op1, Vector<ushort> op2, ushort op3); // sveor3[_n_u16]
  ///   public static unsafe Vector<uint> Xor(Vector<uint> op1, Vector<uint> op2, uint op3); // sveor3[_n_u32]
  ///   public static unsafe Vector<ulong> Xor(Vector<ulong> op1, Vector<ulong> op2, ulong op3); // sveor3[_n_u64]
  ///   Total Maybe: 72

  /// Total ACLE covered across API:      388

@a74nh
Copy link
Contributor Author

a74nh commented Oct 26, 2023 •
edited
Loading

This contributes to #93095

It covers instructions in FEAT_SVE2 related to bitwise operations. They are similar to the SVE bitwise methods.

This list was auto generated from the C ACLE for SVE, and is in three parts:

The methods list reduced down to Vector versions. All possible varaints of T are given above the method.
The complete list of all methods. The corresponding ACLE methods and SVE instructions are given above the method.
All rejected ACLE methods. These are methods we have agreed that do not need including in C#.
Where possible, existing C# naming conventions have been matched.

Many of the C functions include predicate argument(s), of type svbool_t as the first argument. These are missing from the C# method. It is expected that the Jit will create predicates where required, or combine with uses of conditionalSelect(). For more discussion see #88140 comment.

@a74nh a74nh mentioned this issue Oct 26, 2023
Closed
31 tasks
@a74nh
Copy link
Contributor Author

a74nh commented Nov 6, 2023

Updated to reflect review comments from other API proposals.

@a74nh a74nh mentioned this issue Nov 13, 2023
Closed
@kunalspathak kunalspathak added the api-ready-for-review API is ready for review, it is NOT ready for implementation label Feb 7, 2024
@ghost
Copy link

ghost commented Feb 8, 2024

Tagging subscribers to this area: @dotnet/area-system-runtime-intrinsics
See info in area-owners.md if you want to be subscribed.

Issue Details 
namespace System.Runtime.Intrinsics.Arm

/// VectorT Summary
public abstract class Sve : AdvSimd /// Feature: FEAT_SVE2  Category: bitwise
{

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> BitwiseClearXor(Vector<T> op1, Vector<T> op2, Vector<T> op3); // BCAX // MOVPRFX

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> BitwiseSelect(Vector<T> op1, Vector<T> op2, Vector<T> op3); // BSL // MOVPRFX

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> BitwiseSelectFirstInverted(Vector<T> op1, Vector<T> op2, Vector<T> op3); // BSL1N // MOVPRFX

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> BitwiseSelectInverted(Vector<T> op1, Vector<T> op2, Vector<T> op3); // NBSL // MOVPRFX

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> BitwiseSelectSecondInverted(Vector<T> op1, Vector<T> op2, Vector<T> op3); // BSL2N // MOVPRFX

  /// T: sbyte, short, int, long
  public static unsafe Vector<T> RoundingShiftLeft(Vector<T> left, Vector<T> right); // SRSHL or SRSHLR // predicated, MOVPRFX

  /// T: [byte, sbyte], [ushort, short], [uint, int], [ulong, long]
  public static unsafe Vector<T> RoundingShiftLeft(Vector<T> left, Vector<T2> right); // URSHL or URSHLR // predicated, MOVPRFX

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> RoundingShiftRight(Vector<T> op1, ulong imm2); // SRSHR or URSHR // predicated, MOVPRFX

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> RoundingShiftRightAndAccumulate(Vector<T> op1, Vector<T> op2, ulong imm3); // SRSRA or URSRA // MOVPRFX

  /// T: [sbyte, short], [short, int], [int, long], [byte, ushort], [ushort, uint], [uint, ulong]
  public static unsafe Vector<T> RoundingShiftRightNarrowingLower(Vector<T2> op1, ulong imm2); // RSHRNB

  /// T: [sbyte, short], [short, int], [int, long], [byte, ushort], [ushort, uint], [uint, ulong]
  public static unsafe Vector<T> RoundingShiftRightNarrowingUpper(Vector<T> even, Vector<T2> op1, ulong imm2); // RSHRNT

  /// T: sbyte, short, int, long
  public static unsafe Vector<T> SaturatingRoundingShiftLeft(Vector<T> left, Vector<T> right); // SQRSHL or SQRSHLR // predicated, MOVPRFX

  /// T: [byte, sbyte], [ushort, short], [uint, int], [ulong, long]
  public static unsafe Vector<T> SaturatingRoundingShiftLeft(Vector<T> left, Vector<T2> right); // UQRSHL or UQRSHLR // predicated, MOVPRFX

  /// T: [sbyte, short], [short, int], [int, long], [byte, ushort], [ushort, uint], [uint, ulong]
  public static unsafe Vector<T> SaturatingRoundingShiftRightNarrowingLower(Vector<T2> op1, ulong imm2); // SQRSHRNB or UQRSHRNB

  /// T: [sbyte, short], [short, int], [int, long], [byte, ushort], [ushort, uint], [uint, ulong]
  public static unsafe Vector<T> SaturatingRoundingShiftRightNarrowingUpper(Vector<T> even, Vector<T2> op1, ulong imm2); // SQRSHRNT or UQRSHRNT

  /// T: [byte, short], [ushort, int], [uint, long]
  public static unsafe Vector<T> SaturatingRoundingShiftRightUnsignedNarrowingLower(Vector<T2> op1, ulong imm2); // SQRSHRUNB

  /// T: [byte, short], [ushort, int], [uint, long]
  public static unsafe Vector<T> SaturatingRoundingShiftRightUnsignedNarrowingUpper(Vector<T> even, Vector<T2> op1, ulong imm2); // SQRSHRUNT

  /// T: sbyte, short, int, long
  public static unsafe Vector<T> SaturatingShiftLeft(Vector<T> left, Vector<T> right); // SQSHL or SQSHLR // predicated, MOVPRFX

  /// T: [byte, sbyte], [ushort, short], [uint, int], [ulong, long]
  public static unsafe Vector<T> SaturatingShiftLeft(Vector<T> left, Vector<T2> right); // UQSHL or UQSHLR // predicated, MOVPRFX

  /// T: [byte, sbyte], [ushort, short], [uint, int], [ulong, long]
  public static unsafe Vector<T> SaturatingShiftLeftUnsigned(Vector<T2> op1, ulong imm2); // SQSHLU // predicated, MOVPRFX

  /// T: [sbyte, short], [short, int], [int, long], [byte, ushort], [ushort, uint], [uint, ulong]
  public static unsafe Vector<T> SaturatingShiftRightNarrowingLower(Vector<T2> op1, ulong imm2); // SQSHRNB or UQSHRNB

  /// T: [sbyte, short], [short, int], [int, long], [byte, ushort], [ushort, uint], [uint, ulong]
  public static unsafe Vector<T> SaturatingShiftRightNarrowingUpper(Vector<T> even, Vector<T2> op1, ulong imm2); // SQSHRNT or UQSHRNT

  /// T: [byte, short], [ushort, int], [uint, long]
  public static unsafe Vector<T> SaturatingShiftRightUnsignedNarrowingLower(Vector<T2> op1, ulong imm2); // SQSHRUNB

  /// T: [byte, short], [ushort, int], [uint, long]
  public static unsafe Vector<T> SaturatingShiftRightUnsignedNarrowingUpper(Vector<T> even, Vector<T2> op1, ulong imm2); // SQSHRUNT

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> ShiftLeftAndInsert(Vector<T> op1, Vector<T> op2, ulong imm3); // SLI

  /// T: [short, sbyte], [int, short], [long, int], [ushort, byte], [uint, ushort], [ulong, uint]
  public static unsafe Vector<T> ShiftLeftWideningLower(Vector<T2> op1, ulong imm2); // SSHLLB or USHLLB

  /// T: [short, sbyte], [int, short], [long, int], [ushort, byte], [uint, ushort], [ulong, uint]
  public static unsafe Vector<T> ShiftLeftWideningUpper(Vector<T2> op1, ulong imm2); // SSHLLT or USHLLT

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> ShiftRightAndAccumulate(Vector<T> op1, Vector<T> op2, ulong imm3); // SSRA or USRA // MOVPRFX

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> ShiftRightAndInsert(Vector<T> op1, Vector<T> op2, ulong imm3); // SRI

  /// T: [sbyte, short], [short, int], [int, long], [byte, ushort], [ushort, uint], [uint, ulong]
  public static unsafe Vector<T> ShiftRightNarrowingLower(Vector<T2> op1, ulong imm2); // SHRNB

  /// T: [sbyte, short], [short, int], [int, long], [byte, ushort], [ushort, uint], [uint, ulong]
  public static unsafe Vector<T> ShiftRightNarrowingUpper(Vector<T> even, Vector<T2> op1, ulong imm2); // SHRNT

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> Xor(Vector<T> op1, Vector<T> op2, Vector<T> op3); // EOR3 // MOVPRFX

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> XorRotateRight(Vector<T> op1, Vector<T> op2, ulong imm3); // XAR // MOVPRFX

  /// total method signatures: 33


  /// Optional Entries:

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> BitwiseClearXor(Vector<T> op1, Vector<T> op2, T op3); // BCAX // MOVPRFX

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> BitwiseSelect(Vector<T> op1, Vector<T> op2, T op3); // BSL // MOVPRFX

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> BitwiseSelectFirstInverted(Vector<T> op1, Vector<T> op2, T op3); // BSL1N // MOVPRFX

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> BitwiseSelectInverted(Vector<T> op1, Vector<T> op2, T op3); // NBSL // MOVPRFX

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> BitwiseSelectSecondInverted(Vector<T> op1, Vector<T> op2, T op3); // BSL2N // MOVPRFX

  /// T: sbyte, short, int, long, byte
  public static unsafe Vector<T> RoundingShiftLeft(Vector<T> left, sbyte right); // LSL or SRSHR or SRSHL or URSHR or URSHL or SRSHLR or URSHLR // predicated, MOVPRFX

  /// T: ushort, short
  public static unsafe Vector<T> RoundingShiftLeft(Vector<T> left, short right); // LSL or URSHR or URSHL or SRSHR or SRSHL or SRSHLR or URSHLR // predicated, MOVPRFX

  /// T: uint, int
  public static unsafe Vector<T> RoundingShiftLeft(Vector<T> left, int right); // LSL or URSHR or URSHL or SRSHR or SRSHL or SRSHLR or URSHLR // predicated, MOVPRFX

  /// T: ulong, long
  public static unsafe Vector<T> RoundingShiftLeft(Vector<T> left, long right); // LSL or URSHR or URSHL or SRSHR or SRSHL or SRSHLR or URSHLR // predicated, MOVPRFX

  /// T: sbyte, short, int, long, byte
  public static unsafe Vector<T> SaturatingRoundingShiftLeft(Vector<T> left, sbyte right); // SQSHL or SRSHR or SQRSHL or UQSHL or URSHR or UQRSHL or SQRSHLR or UQRSHLR // predicated, MOVPRFX

  /// T: ushort, short
  public static unsafe Vector<T> SaturatingRoundingShiftLeft(Vector<T> left, short right); // UQSHL or URSHR or UQRSHL or SQSHL or SRSHR or SQRSHL or SQRSHLR or UQRSHLR // predicated, MOVPRFX

  /// T: uint, int
  public static unsafe Vector<T> SaturatingRoundingShiftLeft(Vector<T> left, int right); // UQSHL or URSHR or UQRSHL or SQSHL or SRSHR or SQRSHL or SQRSHLR or UQRSHLR // predicated, MOVPRFX

  /// T: ulong, long
  public static unsafe Vector<T> SaturatingRoundingShiftLeft(Vector<T> left, long right); // UQSHL or URSHR or UQRSHL or SQSHL or SRSHR or SQRSHL or SQRSHLR or UQRSHLR // predicated, MOVPRFX

  /// T: sbyte, short, int, long, byte
  public static unsafe Vector<T> SaturatingShiftLeft(Vector<T> left, sbyte right); // SQSHL or ASR or UQSHL or LSR or SQSHLR or UQSHLR // predicated, MOVPRFX

  /// T: ushort, short
  public static unsafe Vector<T> SaturatingShiftLeft(Vector<T> left, short right); // UQSHL or LSR or SQSHL or ASR or SQSHLR or UQSHLR // predicated, MOVPRFX

  /// T: uint, int
  public static unsafe Vector<T> SaturatingShiftLeft(Vector<T> left, int right); // UQSHL or LSR or SQSHL or ASR or SQSHLR or UQSHLR // predicated, MOVPRFX

  /// T: ulong, long
  public static unsafe Vector<T> SaturatingShiftLeft(Vector<T> left, long right); // UQSHL or LSR or SQSHL or ASR or SQSHLR or UQSHLR // predicated, MOVPRFX

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> Xor(Vector<T> op1, Vector<T> op2, T op3); // EOR3 // MOVPRFX

  /// total optional method signatures: 18

}
Author: a74nh
Assignees: -
Labels:

area-System.Runtime.Intrinsics, untriaged, api-ready-for-review
Milestone: -

@tannergooding tannergooding removed the untriaged New issue has not been triaged by the area owner label Feb 8, 2024
@tannergooding
Copy link
Member

tannergooding commented Feb 8, 2024 •
edited
Loading

Fixed various method names to match those used in AdvSimd and fixed the class name to be Sve2

The suffixes Odd and Even were used to match the *Odd and *Even suffixes from SIMD (which is what they do and is dissimilar to *Lower and *Upper)

@bartonjs
Copy link
Member

bartonjs commented Feb 8, 2024 •
edited by dotnet-api-review bot
Loading

Video

  • BitwiseClearXor should probably have been BitwiseClearAndXor, but since "And" could also be interpreted as "Bitwise AND", it's left out.
    • BitwiseClearXor(op1, op2, op3) => (xor, value, mask), as (value, mask) is already what op2/op3 are called in BitwiseClear.
  • Since BitwiseSelectInverted(sel, left, right) is just BitwiseSelect(sel, right, left) it's cut to avoid the confusion of "Inverted", and "RightInverted" having a very high cognative difference.
  • We talked for a while on the "Even" and "Odd" suffixes, and decided they're consistent how they're proposed. There is known confusion in the future (...RoundToEvenOdd), but we'll address those as one-offs, since the suffix pattern is too well established at this point.
  • Xor(op1, op2, op3) => Xor(value1, value2, value3)
  • XorRotateRight(op1, op2, imm3) => XorRotateRight(left, right, [ConstantExpected] byte count)
namespace System.Runtime.Intrinsics.Arm;

/// VectorT Summary
public abstract class Sve2 : Sve /// Feature: FEAT_SVE2  Category: bitwise
{
  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  /// op1 ^ (op2 & ~op3)
  public static unsafe Vector<T> BitwiseClearXor(Vector<T> xor, Vector<T> value, Vector<T> mask); // BCAX // MOVPRFX

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> BitwiseSelect(Vector<T> select, Vector<T> left, Vector<T> right); // BSL // MOVPRFX

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> BitwiseSelectLeftInverted(Vector<T> select, Vector<T> left, Vector<T> right); // BSL1N // MOVPRFX

    /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> BitwiseSelectRightInverted(Vector<T> select, Vector<T> left, Vector<T> right); // BSL2N // MOVPRFX

  /// T: sbyte, short, int, long
  public static unsafe Vector<T> ShiftArithmeticRounded(Vector<T> value, Vector<T> count); // SRSHL or SRSHLR // predicated, MOVPRFX

  /// T: [byte, sbyte], [ushort, short], [uint, int], [ulong, long]
  public static unsafe Vector<T> ShiftLogicalRounded(Vector<T> value, Vector<T2> count); // URSHL or URSHLR // predicated, MOVPRFX

  /// T: sbyte, short, int, long
  public static unsafe Vector<T> ShiftRightArithmeticRounded(Vector<T> value, [ConstantExpected] byte count); // SRSHR // predicated, MOVPRFX

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> ShiftRightLogicalRounded(Vector<T> value, [ConstantExpected] byte count); // URSHR // predicated, MOVPRFX

  /// T: sbyte, short, int, long
  public static unsafe Vector<T> ShiftRightArithmeticRoundedAdd(Vector<T> addend, Vector<T> value, [ConstantExpected] byte count); // SRSRA // MOVPRFX

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> ShiftRightLogicalRoundedAdd(Vector<T> addend, Vector<T> value, [ConstantExpected] byte count); // URSRA // MOVPRFX

  /// T: [sbyte, short], [short, int], [int, long], [byte, ushort], [ushort, uint], [uint, ulong]
  public static unsafe Vector<T> ShiftRightLogicalRoundedNarrowingEven(Vector<T2> value, [ConstantExpected] byte count); // RSHRNB

  /// T: [sbyte, short], [short, int], [int, long], [byte, ushort], [ushort, uint], [uint, ulong]
  public static unsafe Vector<T> ShiftRightLogicalRoundedNarrowingOdd(Vector<T> even, Vector<T2> value, [ConstantExpected] byte count); // RSHRNT

  /// T: sbyte, short, int, long
  public static unsafe Vector<T> ShiftArithmeticRoundedSaturate(Vector<T> value, Vector<T> count); // SQRSHL or SQRSHLR // predicated, MOVPRFX

  /// T: [byte, sbyte], [ushort, short], [uint, int], [ulong, long]
  public static unsafe Vector<T> ShiftLogicalRoundedSaturate(Vector<T> value, Vector<T2> count); // UQRSHL or UQRSHLR // predicated, MOVPRFX

  /// T: [sbyte, short], [short, int], [int, long]
  public static unsafe Vector<T> ShiftRightArithmeticRoundedNarrowingSaturateEven(Vector<T2> value, [ConstantExpected] byte count); // SQRSHRNB

  /// T: [sbyte, short], [short, int], [int, long]
  public static unsafe Vector<T> ShiftRightArithmeticRoundedNarrowingSaturateOdd(Vector<T> even, Vector<T2> value, [ConstantExpected] byte count); // SQRSHRNT 
  
  /// T: [sbyte, short], [short, int], [int, long], [byte, ushort], [ushort, uint], [uint, ulong]
  public static unsafe Vector<T> ShiftRightLogicalRoundedNarrowingSaturateEven(Vector<T2> value, [ConstantExpected] byte count); // UQRSHRNB

  /// T: [sbyte, short], [short, int], [int, long], [byte, ushort], [ushort, uint], [uint, ulong]
  public static unsafe Vector<T> ShiftRightLogicalRoundedNarrowingSaturateOdd(Vector<T> even, Vector<T2> value, [ConstantExpected] byte count); // UQRSHRNT

  /// T: [byte, short], [ushort, int], [uint, long]
  public static unsafe Vector<T> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedEven(Vector<T2> value, [ConstantExpected] byte count); // SQRSHRUNB

  /// T: [byte, short], [ushort, int], [uint, long]
  public static unsafe Vector<T> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedOdd(Vector<T> even, Vector<T2> value, [ConstantExpected] byte count); // SQRSHRUNT

  /// T: sbyte, short, int, long
  public static unsafe Vector<T> ShiftArithmeticSaturate(Vector<T> value, Vector<T> count); // SQSHL or SQSHLR // predicated, MOVPRFX

  /// T: [byte, sbyte], [ushort, short], [uint, int], [ulong, long]
  public static unsafe Vector<T> ShiftLeftLogicalSaturate(Vector<T> value, Vector<T2> count); // UQSHL or UQSHLR // predicated, MOVPRFX

  /// T: [byte, sbyte], [ushort, short], [uint, int], [ulong, long]
  public static unsafe Vector<T> ShiftLeftLogicalSaturateUnsigned(Vector<T2> value, [ConstantExpected] byte count); // SQSHLU // predicated, MOVPRFX

  /// T: [sbyte, short], [short, int], [int, long], [byte, ushort], [ushort, uint], [uint, ulong]
  public static unsafe Vector<T>  ShiftRightArithmeticNarrowingSaturateEven(Vector<T2> value, [ConstantExpected] byte count); // SQSHRNB or UQSHRNB

  /// T: [sbyte, short], [short, int], [int, long], [byte, ushort], [ushort, uint], [uint, ulong]
  public static unsafe Vector<T>  ShiftRightArithmeticNarrowingSaturateOdd(Vector<T> even, Vector<T2> value, [ConstantExpected] byte count); // SQSHRNT or UQSHRNT

  /// T: [byte, short], [ushort, int], [uint, long]
  public static unsafe Vector<T> ShiftRightArithmeticNarrowingSaturateUnsignedEven(Vector<T2> value, [ConstantExpected] byte count); // SQSHRUNB

  /// T: [byte, short], [ushort, int], [uint, long]
  public static unsafe Vector<T> ShiftRightArithmeticNarrowingSaturateUnsignedOdd(Vector<T> even, Vector<T2> value, [ConstantExpected] byte count); // SQSHRUNT

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> ShiftLeftAndInsert(Vector<T> left, Vector<T> right, [ConstantExpected] byte shift); // SLI

  /// T: [short, sbyte], [int, short], [long, int], [ushort, byte], [uint, ushort], [ulong, uint]
  public static unsafe Vector<T> ShiftLeftLogicalWideningEven(Vector<T2> value, [ConstantExpected] byte count); // SSHLLB or USHLLB

  /// T: [short, sbyte], [int, short], [long, int], [ushort, byte], [uint, ushort], [ulong, uint]
  public static unsafe Vector<T> ShiftLeftLogicalWideningOdd(Vector<T2> value, [ConstantExpected] byte count); // SSHLLT or USHLLT

  /// T: sbyte, short, int, long
  public static unsafe Vector<T> ShiftRightArithmeticAdd(Vector<T> addend, Vector<T> value, [ConstantExpected] byte count); // SSRA // MOVPRFX
  
  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> ShiftRightLogicalAdd(Vector<T> addend, Vector<T> value, [ConstantExpected] byte count); // USRA // MOVPRFX

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> ShiftRightAndInsert(Vector<T> left, Vector<T> right, [ConstantExpected] byte shift); // SRI

  /// T: [sbyte, short], [short, int], [int, long], [byte, ushort], [ushort, uint], [uint, ulong]
  public static unsafe Vector<T> ShiftRightLogicalNarrowingEven(Vector<T2> value, [ConstantExpected] byte count); // SHRNB

  /// T: [sbyte, short], [short, int], [int, long], [byte, ushort], [ushort, uint], [uint, ulong]
  public static unsafe Vector<T> ShiftRightLogicalNarrowingOdd(Vector<T> even, Vector<T2> value, [ConstantExpected] byte count); // SHRNT

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> Xor(Vector<T> value1, Vector<T> value2, Vector<T> value3); // EOR3 // MOVPRFX

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> XorRotateRight(Vector<T> left, Vector<T> right, [ConstantExpected] byte count]); // XAR // MOVPRFX

  /// total method signatures: 33
}

@bartonjs bartonjs added api-approved API was approved in API review, it can be implemented and removed api-ready-for-review API is ready for review, it is NOT ready for implementation labels Feb 8, 2024
@a74nh
Copy link
Contributor Author

a74nh commented Feb 13, 2024 

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> ShiftRightLogicalAdd(Vector<T> addend, Vector<T> value, [ConstantExpected] byte count); // USRA // MOVPRFX

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> ShiftRightLogicalRounded(Vector<T> value, [ConstantExpected] byte count); // URSHR // predicated, MOVPRFX

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> ShiftRightLogicalRoundedAdd(Vector<T> addend, Vector<T> value, [ConstantExpected] byte count); // URSRA // MOVPRFX

  /// T: [sbyte, short], [short, int], [int, long], [byte, ushort], [ushort, uint], [uint, ulong]
  public static unsafe Vector<T> ShiftRightLogicalRoundedNarrowingSaturateEven(Vector<T2> value, [ConstantExpected] byte count); // UQRSHRNB

  /// T: [sbyte, short], [short, int], [int, long], [byte, ushort], [ushort, uint], [uint, ulong]
  public static unsafe Vector<T> ShiftRightLogicalRoundedNarrowingSaturateOdd(Vector<T> even, Vector<T2> value, [ConstantExpected] byte count); // UQRSHRNT

These are all unsigned functions where the signed version has been split from the unsigned version.
ie ShiftRightLogicalAdd() is USRA vs ShiftRightArithmeticAdd() is SSRA

For all of these unsigned calls, I think the signed types versions need removing.

The new version would be:

  /// T: byte, ushort, uint, ulong
  public static unsafe Vector<T> ShiftRightLogicalAdd(Vector<T> addend, Vector<T> value, [ConstantExpected] byte count); // USRA // MOVPRFX

  /// T: byte, ushort, uint, ulong
  public static unsafe Vector<T> ShiftRightLogicalRounded(Vector<T> value, [ConstantExpected] byte count); // URSHR // predicated, MOVPRFX

  /// T: byte, ushort, uint, ulong
  public static unsafe Vector<T> ShiftRightLogicalRoundedAdd(Vector<T> addend, Vector<T> value, [ConstantExpected] byte count); // URSRA // MOVPRFX

  /// T: [byte, ushort], [ushort, uint], [uint, ulong]
  public static unsafe Vector<T> ShiftRightLogicalRoundedNarrowingSaturateEven(Vector<T2> value, [ConstantExpected] byte count); // UQRSHRNB

  /// T: [byte, ushort], [ushort, uint], [uint, ulong]
  public static unsafe Vector<T> ShiftRightLogicalRoundedNarrowingSaturateOdd(Vector<T> even, Vector<T2> value, [ConstantExpected] byte count); // UQRSHRNT

@tannergooding
Copy link
Member

tannergooding commented Feb 13, 2024 •
edited
Loading

For all of these unsigned calls, I think the signed types versions need removing.

This was explicit to include them. While Arithmetic Right Shift only applies to signed integers because it necessitates information on the sign bit (which unsigned types don't have), Logical Right Shift applies to all integers, because it just always propagates in a zero bit.

Many languages actually provide explicit operators to give access to logical right shift for all types, accordingly.

In C# we have:

  • x << y - Logical Left Shift
  • x >> y - Logical Right Shift - Unsigned
  • x >> y - Arithmetic Right Shift - Signed
  • x >>> y - Logical Right Shift - Signed

This then also matches ShiftRightLogical* that is exposed in AdvSimd, which was done for the same reasons.

@kunalspathak kunalspathak mentioned this issue Mar 19, 2024
Closed
@stephentoub stephentoub added this to the 10.0.0 milestone Jul 19, 2024
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Assignees
No one assigned
Labels
api-approved API was approved in API review, it can be implemented area-System.Runtime.Intrinsics
Projects
None yet
Milestone
10.0.0
Development

No branches or pull requests
5 participants
@stephentoub @a74nh @tannergooding @bartonjs @kunalspathak