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 SVE: Unpredicated instructions #93614

Closed
a74nh opened this issue Oct 17, 2023 · 6 comments
Closed

[API Proposal]: ARM64 SVE: Unpredicated instructions #93614

a74nh opened this issue Oct 17, 2023 · 6 comments
Labels
api-suggestion Early API idea and discussion, it is NOT ready for implementation area-System.Runtime.Intrinsics

Comments

@a74nh
Copy link
Contributor

a74nh commented Oct 17, 2023 •
edited
Loading

Background and motivation

This API covers all the instructions from FEAT_SVE instructions that don't require predication.

List of SVE instructions

This list was auto generated from the C ACLE intrincs for SVE: SVE intrinsics doc

namespace System.Runtime.Intrinsics.Arm

public abstract class Sve : AdvSimd
{
    public static unsafe Vector<sbyte> AddSaturate(Vector<sbyte> left, Vector<sbyte> right);  // svqadd[_s8] : SQADD
    public static unsafe Vector<short> AddSaturate(Vector<short> left, Vector<short> right);  // svqadd[_s16] : SQADD
    public static unsafe Vector<int> AddSaturate(Vector<int> left, Vector<int> right);  // svqadd[_s32] : SQADD
    public static unsafe Vector<long> AddSaturate(Vector<long> left, Vector<long> right);  // svqadd[_s64] : SQADD
    public static unsafe Vector<byte> AddSaturate(Vector<byte> left, Vector<byte> right);  // svqadd[_u8] : UQADD
    public static unsafe Vector<ushort> AddSaturate(Vector<ushort> left, Vector<ushort> right);  // svqadd[_u16] : UQADD
    public static unsafe Vector<uint> AddSaturate(Vector<uint> left, Vector<uint> right);  // svqadd[_u32] : UQADD
    public static unsafe Vector<ulong> AddSaturate(Vector<ulong> left, Vector<ulong> right);  // svqadd[_u64] : UQADD
    public static unsafe Vector<sbyte> AddSaturate(Vector<sbyte> left, sbyte right);  // svqadd[_n_s8] : SQADD or SQSUB or SQADD
    public static unsafe Vector<short> AddSaturate(Vector<short> left, short right);  // svqadd[_n_s16] : SQADD or SQSUB or SQADD
    public static unsafe Vector<int> AddSaturate(Vector<int> left, int right);  // svqadd[_n_s32] : SQADD or SQSUB or SQADD
    public static unsafe Vector<long> AddSaturate(Vector<long> left, long right);  // svqadd[_n_s64] : SQADD or SQSUB or SQADD
    public static unsafe Vector<byte> AddSaturate(Vector<byte> left, byte right);  // svqadd[_n_u8] : UQADD or UQADD
    public static unsafe Vector<ushort> AddSaturate(Vector<ushort> left, ushort right);  // svqadd[_n_u16] : UQADD or UQADD
    public static unsafe Vector<uint> AddSaturate(Vector<uint> left, uint right);  // svqadd[_n_u32] : UQADD or UQADD
    public static unsafe Vector<ulong> AddSaturate(Vector<ulong> left, ulong right);  // svqadd[_n_u64] : UQADD or UQADD

    public static unsafe Vector<float> ComplexMultiplyAddWithRotate(Vector<float> op1, Vector<float> op2, Vector<float> op3, ulong imm_index, ulong imm_rotation);  // svcmla_lane[_f32] : FCMLA or MOVPRFX+FCMLA

    public static unsafe Vector<uint> ComputeVectorAddressesFor16BitData(Vector<uint> bases, Vector<int> indices);  // svadrh[_u32base]_[s32]index : ADR
    public static unsafe Vector<uint> ComputeVectorAddressesFor16BitData(Vector<uint> bases, Vector<uint> indices);  // svadrh[_u32base]_[u32]index : ADR
    public static unsafe Vector<ulong> ComputeVectorAddressesFor16BitData(Vector<ulong> bases, Vector<long> indices);  // svadrh[_u64base]_[s64]index : ADR
    public static unsafe Vector<ulong> ComputeVectorAddressesFor16BitData(Vector<ulong> bases, Vector<ulong> indices);  // svadrh[_u64base]_[u64]index : ADR

    public static unsafe Vector<uint> ComputeVectorAddressesFor32BitData(Vector<uint> bases, Vector<int> indices);  // svadrw[_u32base]_[s32]index : ADR
    public static unsafe Vector<uint> ComputeVectorAddressesFor32BitData(Vector<uint> bases, Vector<uint> indices);  // svadrw[_u32base]_[u32]index : ADR
    public static unsafe Vector<ulong> ComputeVectorAddressesFor32BitData(Vector<ulong> bases, Vector<long> indices);  // svadrw[_u64base]_[s64]index : ADR
    public static unsafe Vector<ulong> ComputeVectorAddressesFor32BitData(Vector<ulong> bases, Vector<ulong> indices);  // svadrw[_u64base]_[u64]index : ADR

    public static unsafe Vector<uint> ComputeVectorAddressesFor64BitData(Vector<uint> bases, Vector<int> indices);  // svadrd[_u32base]_[s32]index : ADR
    public static unsafe Vector<uint> ComputeVectorAddressesFor64BitData(Vector<uint> bases, Vector<uint> indices);  // svadrd[_u32base]_[u32]index : ADR
    public static unsafe Vector<ulong> ComputeVectorAddressesFor64BitData(Vector<ulong> bases, Vector<long> indices);  // svadrd[_u64base]_[s64]index : ADR
    public static unsafe Vector<ulong> ComputeVectorAddressesFor64BitData(Vector<ulong> bases, Vector<ulong> indices);  // svadrd[_u64base]_[u64]index : ADR

    public static unsafe Vector<uint> ComputeVectorAddressesFor8BitData(Vector<uint> bases, Vector<int> offsets);  // svadrb[_u32base]_[s32]offset : ADR
    public static unsafe Vector<uint> ComputeVectorAddressesFor8BitData(Vector<uint> bases, Vector<uint> offsets);  // svadrb[_u32base]_[u32]offset : ADR
    public static unsafe Vector<ulong> ComputeVectorAddressesFor8BitData(Vector<ulong> bases, Vector<long> offsets);  // svadrb[_u64base]_[s64]offset : ADR
    public static unsafe Vector<ulong> ComputeVectorAddressesFor8BitData(Vector<ulong> bases, Vector<ulong> offsets);  // svadrb[_u64base]_[u64]offset : ADR

    public static unsafe Vector<sbyte> CreateLinearSeries(sbyte base, sbyte step);  // svindex_s8 : INDEX or INDEX or INDEX or INDEX
    public static unsafe Vector<short> CreateLinearSeries(short base, short step);  // svindex_s16 : INDEX or INDEX or INDEX or INDEX
    public static unsafe Vector<int> CreateLinearSeries(int base, int step);  // svindex_s32 : INDEX or INDEX or INDEX or INDEX
    public static unsafe Vector<long> CreateLinearSeries(long base, long step);  // svindex_s64 : INDEX or INDEX or INDEX or INDEX
    public static unsafe Vector<byte> CreateLinearSeries(byte base, byte step);  // svindex_u8 : INDEX or INDEX or INDEX or INDEX
    public static unsafe Vector<ushort> CreateLinearSeries(ushort base, ushort step);  // svindex_u16 : INDEX or INDEX or INDEX or INDEX
    public static unsafe Vector<uint> CreateLinearSeries(uint base, uint step);  // svindex_u32 : INDEX or INDEX or INDEX or INDEX
    public static unsafe Vector<ulong> CreateLinearSeries(ulong base, ulong step);  // svindex_u64 : INDEX or INDEX or INDEX or INDEX

    public static unsafe Vector<int> DotProduct(Vector<int> op1, Vector<sbyte> op2, Vector<sbyte> op3);  // svdot[_s32] : SDOT or MOVPRFX+SDOT
    public static unsafe Vector<long> DotProduct(Vector<long> op1, Vector<short> op2, Vector<short> op3);  // svdot[_s64] : SDOT or MOVPRFX+SDOT
    public static unsafe Vector<uint> DotProduct(Vector<uint> op1, Vector<byte> op2, Vector<byte> op3);  // svdot[_u32] : UDOT or MOVPRFX+UDOT
    public static unsafe Vector<ulong> DotProduct(Vector<ulong> op1, Vector<ushort> op2, Vector<ushort> op3);  // svdot[_u64] : UDOT or MOVPRFX+UDOT
    public static unsafe Vector<int> DotProduct(Vector<int> op1, Vector<sbyte> op2, sbyte op3);  // svdot[_n_s32] : SDOT or MOVPRFX+SDOT
    public static unsafe Vector<long> DotProduct(Vector<long> op1, Vector<short> op2, short op3);  // svdot[_n_s64] : SDOT or MOVPRFX+SDOT
    public static unsafe Vector<uint> DotProduct(Vector<uint> op1, Vector<byte> op2, byte op3);  // svdot[_n_u32] : UDOT or MOVPRFX+UDOT
    public static unsafe Vector<ulong> DotProduct(Vector<ulong> op1, Vector<ushort> op2, ushort op3);  // svdot[_n_u64] : UDOT or MOVPRFX+UDOT
    public static unsafe Vector<int> DotProduct(Vector<int> op1, Vector<sbyte> op2, Vector<sbyte> op3, ulong imm_index);  // svdot_lane[_s32] : SDOT or MOVPRFX+SDOT
    public static unsafe Vector<long> DotProduct(Vector<long> op1, Vector<short> op2, Vector<short> op3, ulong imm_index);  // svdot_lane[_s64] : SDOT or MOVPRFX+SDOT
    public static unsafe Vector<uint> DotProduct(Vector<uint> op1, Vector<byte> op2, Vector<byte> op3, ulong imm_index);  // svdot_lane[_u32] : UDOT or MOVPRFX+UDOT
    public static unsafe Vector<ulong> DotProduct(Vector<ulong> op1, Vector<ushort> op2, Vector<ushort> op3, ulong imm_index);  // svdot_lane[_u64] : UDOT or MOVPRFX+UDOT

    public static unsafe Vector<float> DuplicateToVector(float value);  // svdup[_n]_f32 : DUP or FDUP or DUP or DUP
    public static unsafe Vector<double> DuplicateToVector(double value);  // svdup[_n]_f64 : DUP or FDUP or DUP or DUP
    public static unsafe Vector<sbyte> DuplicateToVector(sbyte value);  // svdup[_n]_s8 : DUP or FDUP or DUPM or DUP or DUP
    public static unsafe Vector<short> DuplicateToVector(short value);  // svdup[_n]_s16 : DUP or FDUP or DUPM or DUP or DUP
    public static unsafe Vector<int> DuplicateToVector(int value);  // svdup[_n]_s32 : DUP or FDUP or DUPM or DUP or DUP
    public static unsafe Vector<long> DuplicateToVector(long value);  // svdup[_n]_s64 : DUP or FDUP or DUPM or DUP or DUP
    public static unsafe Vector<byte> DuplicateToVector(byte value);  // svdup[_n]_u8 : DUP or FDUP or DUPM or DUP or DUP
    public static unsafe Vector<ushort> DuplicateToVector(ushort value);  // svdup[_n]_u16 : DUP or FDUP or DUPM or DUP or DUP
    public static unsafe Vector<uint> DuplicateToVector(uint value);  // svdup[_n]_u32 : DUP or FDUP or DUPM or DUP or DUP
    public static unsafe Vector<ulong> DuplicateToVector(ulong value);  // svdup[_n]_u64 : DUP or FDUP or DUPM or DUP or DUP
    public static unsafe Vector<float> DuplicateToVector(Vector<float> data, uint index);  // svdup_lane[_f32] : DUP or TBL
    public static unsafe Vector<double> DuplicateToVector(Vector<double> data, ulong index);  // svdup_lane[_f64] : DUP or TBL
    public static unsafe Vector<sbyte> DuplicateToVector(Vector<sbyte> data, byte index);  // svdup_lane[_s8] : DUP or TBL
    public static unsafe Vector<short> DuplicateToVector(Vector<short> data, ushort index);  // svdup_lane[_s16] : DUP or TBL
    public static unsafe Vector<int> DuplicateToVector(Vector<int> data, uint index);  // svdup_lane[_s32] : DUP or TBL
    public static unsafe Vector<long> DuplicateToVector(Vector<long> data, ulong index);  // svdup_lane[_s64] : DUP or TBL
    public static unsafe Vector<byte> DuplicateToVector(Vector<byte> data, byte index);  // svdup_lane[_u8] : DUP or TBL
    public static unsafe Vector<ushort> DuplicateToVector(Vector<ushort> data, ushort index);  // svdup_lane[_u16] : DUP or TBL
    public static unsafe Vector<uint> DuplicateToVector(Vector<uint> data, uint index);  // svdup_lane[_u32] : DUP or TBL
    public static unsafe Vector<ulong> DuplicateToVector(Vector<ulong> data, ulong index);  // svdup_lane[_u64] : DUP or TBL
    public static unsafe Vector<float> DuplicateToVector(Vector<float> data, ulong index);  // svdupq_lane[_f32] : DUP or TBL
    public static unsafe Vector<double> DuplicateToVector(Vector<double> data, ulong index);  // svdupq_lane[_f64] : DUP or TBL
    public static unsafe Vector<sbyte> DuplicateToVector(Vector<sbyte> data, ulong index);  // svdupq_lane[_s8] : DUP or TBL
    public static unsafe Vector<short> DuplicateToVector(Vector<short> data, ulong index);  // svdupq_lane[_s16] : DUP or TBL
    public static unsafe Vector<int> DuplicateToVector(Vector<int> data, ulong index);  // svdupq_lane[_s32] : DUP or TBL
    public static unsafe Vector<long> DuplicateToVector(Vector<long> data, ulong index);  // svdupq_lane[_s64] : DUP or TBL
    public static unsafe Vector<byte> DuplicateToVector(Vector<byte> data, ulong index);  // svdupq_lane[_u8] : DUP or TBL
    public static unsafe Vector<ushort> DuplicateToVector(Vector<ushort> data, ulong index);  // svdupq_lane[_u16] : DUP or TBL
    public static unsafe Vector<uint> DuplicateToVector(Vector<uint> data, ulong index);  // svdupq_lane[_u32] : DUP or TBL
    public static unsafe Vector<ulong> DuplicateToVector(Vector<ulong> data, ulong index);  // svdupq_lane[_u64] : DUP or TBL

    public static unsafe Vector<float> ExtractVector(Vector<float> upper, Vector<float> lower, ulong index);  // svext[_f32] : EXT or MOVPRFX+EXT
    public static unsafe Vector<double> ExtractVector(Vector<double> upper, Vector<double> lower, ulong index);  // svext[_f64] : EXT or MOVPRFX+EXT
    public static unsafe Vector<sbyte> ExtractVector(Vector<sbyte> upper, Vector<sbyte> lower, ulong index);  // svext[_s8] : EXT or MOVPRFX+EXT
    public static unsafe Vector<short> ExtractVector(Vector<short> upper, Vector<short> lower, ulong index);  // svext[_s16] : EXT or MOVPRFX+EXT
    public static unsafe Vector<int> ExtractVector(Vector<int> upper, Vector<int> lower, ulong index);  // svext[_s32] : EXT or MOVPRFX+EXT
    public static unsafe Vector<long> ExtractVector(Vector<long> upper, Vector<long> lower, ulong index);  // svext[_s64] : EXT or MOVPRFX+EXT
    public static unsafe Vector<byte> ExtractVector(Vector<byte> upper, Vector<byte> lower, ulong index);  // svext[_u8] : EXT or MOVPRFX+EXT
    public static unsafe Vector<ushort> ExtractVector(Vector<ushort> upper, Vector<ushort> lower, ulong index);  // svext[_u16] : EXT or MOVPRFX+EXT
    public static unsafe Vector<uint> ExtractVector(Vector<uint> upper, Vector<uint> lower, ulong index);  // svext[_u32] : EXT or MOVPRFX+EXT
    public static unsafe Vector<ulong> ExtractVector(Vector<ulong> upper, Vector<ulong> lower, ulong index);  // svext[_u64] : EXT or MOVPRFX+EXT

    public static unsafe Vector<float> FloatingPointExponentialAccelerator(Vector<uint> value);  // svexpa[_f32] : FEXPA
    public static unsafe Vector<double> FloatingPointExponentialAccelerator(Vector<ulong> value);  // svexpa[_f64] : FEXPA

    public static unsafe Vector<float> FusedMultiplyAdd(Vector<float> addend, Vector<float> left, Vector<float> right, ulong imm_index);  // svmla_lane[_f32] : FMLA or MOVPRFX+FMLA
    public static unsafe Vector<double> FusedMultiplyAdd(Vector<double> addend, Vector<double> left, Vector<double> right, ulong imm_index);  // svmla_lane[_f64] : FMLA or MOVPRFX+FMLA

    public static unsafe Vector<float> FusedMultiplySubtract(Vector<float> minuend, Vector<float> left, Vector<float> right, ulong imm_index);  // svmls_lane[_f32] : FMLS or MOVPRFX+FMLS
    public static unsafe Vector<double> FusedMultiplySubtract(Vector<double> minuend, Vector<double> left, Vector<double> right, ulong imm_index);  // svmls_lane[_f64] : FMLS or MOVPRFX+FMLS

    public static unsafe void InitializeTheFirstFaultRegisterToAllTrue();  // svsetffr : SETFFR

    public static unsafe Vector<float> InsertIntoShiftedVector(Vector<float> left, float right);  // svinsr[_n_f32] : INSR or INSR
    public static unsafe Vector<double> InsertIntoShiftedVector(Vector<double> left, double right);  // svinsr[_n_f64] : INSR or INSR
    public static unsafe Vector<sbyte> InsertIntoShiftedVector(Vector<sbyte> left, sbyte right);  // svinsr[_n_s8] : INSR or INSR
    public static unsafe Vector<short> InsertIntoShiftedVector(Vector<short> left, short right);  // svinsr[_n_s16] : INSR or INSR
    public static unsafe Vector<int> InsertIntoShiftedVector(Vector<int> left, int right);  // svinsr[_n_s32] : INSR or INSR
    public static unsafe Vector<long> InsertIntoShiftedVector(Vector<long> left, long right);  // svinsr[_n_s64] : INSR or INSR
    public static unsafe Vector<byte> InsertIntoShiftedVector(Vector<byte> left, byte right);  // svinsr[_n_u8] : INSR or INSR
    public static unsafe Vector<ushort> InsertIntoShiftedVector(Vector<ushort> left, ushort right);  // svinsr[_n_u16] : INSR or INSR
    public static unsafe Vector<uint> InsertIntoShiftedVector(Vector<uint> left, uint right);  // svinsr[_n_u32] : INSR or INSR
    public static unsafe Vector<ulong> InsertIntoShiftedVector(Vector<ulong> left, ulong right);  // svinsr[_n_u64] : INSR or INSR

    public static unsafe Vector<float> Multiply(Vector<float> left, Vector<float> right, ulong index);  // svmul_lane[_f32] : FMUL
    public static unsafe Vector<double> Multiply(Vector<double> left, Vector<double> right, ulong index);  // svmul_lane[_f64] : FMUL

    public static unsafe Vector<float> ReciprocalEstimate(Vector<float> value);  // svrecpe[_f32] : FRECPE
    public static unsafe Vector<double> ReciprocalEstimate(Vector<double> value);  // svrecpe[_f64] : FRECPE

    public static unsafe Vector<float> ReciprocalSquareRootEstimate(Vector<float> value);  // svrsqrte[_f32] : FRSQRTE
    public static unsafe Vector<double> ReciprocalSquareRootEstimate(Vector<double> value);  // svrsqrte[_f64] : FRSQRTE

    public static unsafe Vector<float> ReciprocalSquareRootStep(Vector<float> left, Vector<float> right);  // svrsqrts[_f32] : FRSQRTS
    public static unsafe Vector<double> ReciprocalSquareRootStep(Vector<double> left, Vector<double> right);  // svrsqrts[_f64] : FRSQRTS

    public static unsafe Vector<float> ReciprocalStep(Vector<float> left, Vector<float> right);  // svrecps[_f32] : FRECPS
    public static unsafe Vector<double> ReciprocalStep(Vector<double> left, Vector<double> right);  // svrecps[_f64] : FRECPS

    public static unsafe Vector<float> ReverseElement(Vector<float> value);  // svrev[_f32] : REV
    public static unsafe Vector<double> ReverseElement(Vector<double> value);  // svrev[_f64] : REV
    public static unsafe Vector<sbyte> ReverseElement(Vector<sbyte> value);  // svrev[_s8] : REV
    public static unsafe Vector<short> ReverseElement(Vector<short> value);  // svrev[_s16] : REV
    public static unsafe Vector<int> ReverseElement(Vector<int> value);  // svrev[_s32] : REV
    public static unsafe Vector<long> ReverseElement(Vector<long> value);  // svrev[_s64] : REV
    public static unsafe Vector<byte> ReverseElement(Vector<byte> value);  // svrev[_u8] : REV
    public static unsafe Vector<ushort> ReverseElement(Vector<ushort> value);  // svrev[_u16] : REV
    public static unsafe Vector<uint> ReverseElement(Vector<uint> value);  // svrev[_u32] : REV
    public static unsafe Vector<ulong> ReverseElement(Vector<ulong> value);  // svrev[_u64] : REV

    public static unsafe Vector<sbyte> SubtractSaturate(Vector<sbyte> left, Vector<sbyte> right);  // svqsub[_s8] : SQSUB
    public static unsafe Vector<short> SubtractSaturate(Vector<short> left, Vector<short> right);  // svqsub[_s16] : SQSUB
    public static unsafe Vector<int> SubtractSaturate(Vector<int> left, Vector<int> right);  // svqsub[_s32] : SQSUB
    public static unsafe Vector<long> SubtractSaturate(Vector<long> left, Vector<long> right);  // svqsub[_s64] : SQSUB
    public static unsafe Vector<byte> SubtractSaturate(Vector<byte> left, Vector<byte> right);  // svqsub[_u8] : UQSUB
    public static unsafe Vector<ushort> SubtractSaturate(Vector<ushort> left, Vector<ushort> right);  // svqsub[_u16] : UQSUB
    public static unsafe Vector<uint> SubtractSaturate(Vector<uint> left, Vector<uint> right);  // svqsub[_u32] : UQSUB
    public static unsafe Vector<ulong> SubtractSaturate(Vector<ulong> left, Vector<ulong> right);  // svqsub[_u64] : UQSUB
    public static unsafe Vector<sbyte> SubtractSaturate(Vector<sbyte> left, sbyte right);  // svqsub[_n_s8] : SQSUB or SQADD or SQSUB
    public static unsafe Vector<short> SubtractSaturate(Vector<short> left, short right);  // svqsub[_n_s16] : SQSUB or SQADD or SQSUB
    public static unsafe Vector<int> SubtractSaturate(Vector<int> left, int right);  // svqsub[_n_s32] : SQSUB or SQADD or SQSUB
    public static unsafe Vector<long> SubtractSaturate(Vector<long> left, long right);  // svqsub[_n_s64] : SQSUB or SQADD or SQSUB
    public static unsafe Vector<byte> SubtractSaturate(Vector<byte> left, byte right);  // svqsub[_n_u8] : UQSUB or UQSUB
    public static unsafe Vector<ushort> SubtractSaturate(Vector<ushort> left, ushort right);  // svqsub[_n_u16] : UQSUB or UQSUB
    public static unsafe Vector<uint> SubtractSaturate(Vector<uint> left, uint right);  // svqsub[_n_u32] : UQSUB or UQSUB
    public static unsafe Vector<ulong> SubtractSaturate(Vector<ulong> left, ulong right);  // svqsub[_n_u64] : UQSUB or UQSUB

    public static unsafe Vector<float> TransposeEven(Vector<float> left, Vector<float> right);  // svtrn1[_f32] : TRN1
    public static unsafe Vector<double> TransposeEven(Vector<double> left, Vector<double> right);  // svtrn1[_f64] : TRN1
    public static unsafe Vector<sbyte> TransposeEven(Vector<sbyte> left, Vector<sbyte> right);  // svtrn1[_s8] : TRN1
    public static unsafe Vector<short> TransposeEven(Vector<short> left, Vector<short> right);  // svtrn1[_s16] : TRN1
    public static unsafe Vector<int> TransposeEven(Vector<int> left, Vector<int> right);  // svtrn1[_s32] : TRN1
    public static unsafe Vector<long> TransposeEven(Vector<long> left, Vector<long> right);  // svtrn1[_s64] : TRN1
    public static unsafe Vector<byte> TransposeEven(Vector<byte> left, Vector<byte> right);  // svtrn1[_u8] : TRN1
    public static unsafe Vector<ushort> TransposeEven(Vector<ushort> left, Vector<ushort> right);  // svtrn1[_u16] : TRN1
    public static unsafe Vector<uint> TransposeEven(Vector<uint> left, Vector<uint> right);  // svtrn1[_u32] : TRN1
    public static unsafe Vector<ulong> TransposeEven(Vector<ulong> left, Vector<ulong> right);  // svtrn1[_u64] : TRN1

    public static unsafe Vector<float> TransposeOdd(Vector<float> left, Vector<float> right);  // svtrn2[_f32] : TRN2
    public static unsafe Vector<double> TransposeOdd(Vector<double> left, Vector<double> right);  // svtrn2[_f64] : TRN2
    public static unsafe Vector<sbyte> TransposeOdd(Vector<sbyte> left, Vector<sbyte> right);  // svtrn2[_s8] : TRN2
    public static unsafe Vector<short> TransposeOdd(Vector<short> left, Vector<short> right);  // svtrn2[_s16] : TRN2
    public static unsafe Vector<int> TransposeOdd(Vector<int> left, Vector<int> right);  // svtrn2[_s32] : TRN2
    public static unsafe Vector<long> TransposeOdd(Vector<long> left, Vector<long> right);  // svtrn2[_s64] : TRN2
    public static unsafe Vector<byte> TransposeOdd(Vector<byte> left, Vector<byte> right);  // svtrn2[_u8] : TRN2
    public static unsafe Vector<ushort> TransposeOdd(Vector<ushort> left, Vector<ushort> right);  // svtrn2[_u16] : TRN2
    public static unsafe Vector<uint> TransposeOdd(Vector<uint> left, Vector<uint> right);  // svtrn2[_u32] : TRN2
    public static unsafe Vector<ulong> TransposeOdd(Vector<ulong> left, Vector<ulong> right);  // svtrn2[_u64] : TRN2

    public static unsafe Vector<float> TrigonometricMultiplyAddCoefficient(Vector<float> op1, Vector<float> op2, ulong imm3);  // svtmad[_f32] : FTMAD or MOVPRFX+FTMAD
    public static unsafe Vector<double> TrigonometricMultiplyAddCoefficient(Vector<double> op1, Vector<double> op2, ulong imm3);  // svtmad[_f64] : FTMAD or MOVPRFX+FTMAD

    public static unsafe Vector<float> TrigonometricSelectCoefficient(Vector<float> left, Vector<uint> right);  // svtssel[_f32] : FTSSEL
    public static unsafe Vector<double> TrigonometricSelectCoefficient(Vector<double> left, Vector<ulong> right);  // svtssel[_f64] : FTSSEL

    public static unsafe Vector<float> TrigonometricStartingValue(Vector<float> left, Vector<uint> right);  // svtsmul[_f32] : FTSMUL
    public static unsafe Vector<double> TrigonometricStartingValue(Vector<double> left, Vector<ulong> right);  // svtsmul[_f64] : FTSMUL

    public static unsafe Vector<short> UnpackWidenLower(Vector<sbyte> value);  // svunpklo[_s16] : SUNPKLO
    public static unsafe Vector<int> UnpackWidenLower(Vector<short> value);  // svunpklo[_s32] : SUNPKLO
    public static unsafe Vector<long> UnpackWidenLower(Vector<int> value);  // svunpklo[_s64] : SUNPKLO
    public static unsafe Vector<ushort> UnpackWidenLower(Vector<byte> value);  // svunpklo[_u16] : UUNPKLO
    public static unsafe Vector<uint> UnpackWidenLower(Vector<ushort> value);  // svunpklo[_u32] : UUNPKLO
    public static unsafe Vector<ulong> UnpackWidenLower(Vector<uint> value);  // svunpklo[_u64] : UUNPKLO

    public static unsafe Vector<short> UnpackWidenUpper(Vector<sbyte> value);  // svunpkhi[_s16] : SUNPKHI
    public static unsafe Vector<int> UnpackWidenUpper(Vector<short> value);  // svunpkhi[_s32] : SUNPKHI
    public static unsafe Vector<long> UnpackWidenUpper(Vector<int> value);  // svunpkhi[_s64] : SUNPKHI
    public static unsafe Vector<ushort> UnpackWidenUpper(Vector<byte> value);  // svunpkhi[_u16] : UUNPKHI
    public static unsafe Vector<uint> UnpackWidenUpper(Vector<ushort> value);  // svunpkhi[_u32] : UUNPKHI
    public static unsafe Vector<ulong> UnpackWidenUpper(Vector<uint> value);  // svunpkhi[_u64] : UUNPKHI

    public static unsafe Vector<float> UnzipEven(Vector<float> left, Vector<float> right);  // svuzp1[_f32] : UZP1
    public static unsafe Vector<double> UnzipEven(Vector<double> left, Vector<double> right);  // svuzp1[_f64] : UZP1
    public static unsafe Vector<sbyte> UnzipEven(Vector<sbyte> left, Vector<sbyte> right);  // svuzp1[_s8] : UZP1
    public static unsafe Vector<short> UnzipEven(Vector<short> left, Vector<short> right);  // svuzp1[_s16] : UZP1
    public static unsafe Vector<int> UnzipEven(Vector<int> left, Vector<int> right);  // svuzp1[_s32] : UZP1
    public static unsafe Vector<long> UnzipEven(Vector<long> left, Vector<long> right);  // svuzp1[_s64] : UZP1
    public static unsafe Vector<byte> UnzipEven(Vector<byte> left, Vector<byte> right);  // svuzp1[_u8] : UZP1
    public static unsafe Vector<ushort> UnzipEven(Vector<ushort> left, Vector<ushort> right);  // svuzp1[_u16] : UZP1
    public static unsafe Vector<uint> UnzipEven(Vector<uint> left, Vector<uint> right);  // svuzp1[_u32] : UZP1
    public static unsafe Vector<ulong> UnzipEven(Vector<ulong> left, Vector<ulong> right);  // svuzp1[_u64] : UZP1

    public static unsafe Vector<float> UnzipOdd(Vector<float> left, Vector<float> right);  // svuzp2[_f32] : UZP2
    public static unsafe Vector<double> UnzipOdd(Vector<double> left, Vector<double> right);  // svuzp2[_f64] : UZP2
    public static unsafe Vector<sbyte> UnzipOdd(Vector<sbyte> left, Vector<sbyte> right);  // svuzp2[_s8] : UZP2
    public static unsafe Vector<short> UnzipOdd(Vector<short> left, Vector<short> right);  // svuzp2[_s16] : UZP2
    public static unsafe Vector<int> UnzipOdd(Vector<int> left, Vector<int> right);  // svuzp2[_s32] : UZP2
    public static unsafe Vector<long> UnzipOdd(Vector<long> left, Vector<long> right);  // svuzp2[_s64] : UZP2
    public static unsafe Vector<byte> UnzipOdd(Vector<byte> left, Vector<byte> right);  // svuzp2[_u8] : UZP2
    public static unsafe Vector<ushort> UnzipOdd(Vector<ushort> left, Vector<ushort> right);  // svuzp2[_u16] : UZP2
    public static unsafe Vector<uint> UnzipOdd(Vector<uint> left, Vector<uint> right);  // svuzp2[_u32] : UZP2
    public static unsafe Vector<ulong> UnzipOdd(Vector<ulong> left, Vector<ulong> right);  // svuzp2[_u64] : UZP2

    public static unsafe Vector<float> VectorTableLookup(Vector<float> data, Vector<uint> indices);  // svtbl[_f32] : TBL
    public static unsafe Vector<double> VectorTableLookup(Vector<double> data, Vector<ulong> indices);  // svtbl[_f64] : TBL
    public static unsafe Vector<sbyte> VectorTableLookup(Vector<sbyte> data, Vector<byte> indices);  // svtbl[_s8] : TBL
    public static unsafe Vector<short> VectorTableLookup(Vector<short> data, Vector<ushort> indices);  // svtbl[_s16] : TBL
    public static unsafe Vector<int> VectorTableLookup(Vector<int> data, Vector<uint> indices);  // svtbl[_s32] : TBL
    public static unsafe Vector<long> VectorTableLookup(Vector<long> data, Vector<ulong> indices);  // svtbl[_s64] : TBL
    public static unsafe Vector<byte> VectorTableLookup(Vector<byte> data, Vector<byte> indices);  // svtbl[_u8] : TBL
    public static unsafe Vector<ushort> VectorTableLookup(Vector<ushort> data, Vector<ushort> indices);  // svtbl[_u16] : TBL
    public static unsafe Vector<uint> VectorTableLookup(Vector<uint> data, Vector<uint> indices);  // svtbl[_u32] : TBL
    public static unsafe Vector<ulong> VectorTableLookup(Vector<ulong> data, Vector<ulong> indices);  // svtbl[_u64] : TBL

    public static unsafe Vector<float> ZipHigh(Vector<float> left, Vector<float> right);  // svzip2[_f32] : ZIP2
    public static unsafe Vector<double> ZipHigh(Vector<double> left, Vector<double> right);  // svzip2[_f64] : ZIP2
    public static unsafe Vector<sbyte> ZipHigh(Vector<sbyte> left, Vector<sbyte> right);  // svzip2[_s8] : ZIP2
    public static unsafe Vector<short> ZipHigh(Vector<short> left, Vector<short> right);  // svzip2[_s16] : ZIP2
    public static unsafe Vector<int> ZipHigh(Vector<int> left, Vector<int> right);  // svzip2[_s32] : ZIP2
    public static unsafe Vector<long> ZipHigh(Vector<long> left, Vector<long> right);  // svzip2[_s64] : ZIP2
    public static unsafe Vector<byte> ZipHigh(Vector<byte> left, Vector<byte> right);  // svzip2[_u8] : ZIP2
    public static unsafe Vector<ushort> ZipHigh(Vector<ushort> left, Vector<ushort> right);  // svzip2[_u16] : ZIP2
    public static unsafe Vector<uint> ZipHigh(Vector<uint> left, Vector<uint> right);  // svzip2[_u32] : ZIP2
    public static unsafe Vector<ulong> ZipHigh(Vector<ulong> left, Vector<ulong> right);  // svzip2[_u64] : ZIP2

    public static unsafe Vector<float> ZipLow(Vector<float> left, Vector<float> right);  // svzip1[_f32] : ZIP1
    public static unsafe Vector<double> ZipLow(Vector<double> left, Vector<double> right);  // svzip1[_f64] : ZIP1
    public static unsafe Vector<sbyte> ZipLow(Vector<sbyte> left, Vector<sbyte> right);  // svzip1[_s8] : ZIP1
    public static unsafe Vector<short> ZipLow(Vector<short> left, Vector<short> right);  // svzip1[_s16] : ZIP1
    public static unsafe Vector<int> ZipLow(Vector<int> left, Vector<int> right);  // svzip1[_s32] : ZIP1
    public static unsafe Vector<long> ZipLow(Vector<long> left, Vector<long> right);  // svzip1[_s64] : ZIP1
    public static unsafe Vector<byte> ZipLow(Vector<byte> left, Vector<byte> right);  // svzip1[_u8] : ZIP1
    public static unsafe Vector<ushort> ZipLow(Vector<ushort> left, Vector<ushort> right);  // svzip1[_u16] : ZIP1
    public static unsafe Vector<uint> ZipLow(Vector<uint> left, Vector<uint> right);  // svzip1[_u32] : ZIP1
    public static unsafe Vector<ulong> ZipLow(Vector<ulong> left, Vector<ulong> right);  // svzip1[_u64] : ZIP1

  // total: 234
}
@a74nh a74nh added the api-suggestion Early API idea and discussion, it is NOT ready for implementation label Oct 17, 2023
@ghost ghost added the untriaged New issue has not been triaged by the area owner label Oct 17, 2023
@ghost
Copy link

ghost commented Oct 17, 2023

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

Issue Details

Background and motivation

This API covers all the instructions from FEAT_SVE instructions that don't require predication.

List of SVE instructions

This list was auto generated from the C ACLE intrincs for SVE: SVE intrinsics doc


namespace System.Runtime.Intrinsics.Arm

public abstract class Sve : AdvSimd
{
    public static unsafe Vector AddSaturate(Vector left, Vector right);  // svqadd[_s8]: SQADD
    public static unsafe Vector AddSaturate(Vector left, Vector right);  // svqadd[_s16]: SQADD
    public static unsafe Vector AddSaturate(Vector left, Vector right);  // svqadd[_s32]: SQADD
    public static unsafe Vector AddSaturate(Vector left, Vector right);  // svqadd[_s64]: SQADD
    public static unsafe Vector AddSaturate(Vector left, Vector right);  // svqadd[_u8]: UQADD
    public static unsafe Vector AddSaturate(Vector left, Vector right);  // svqadd[_u16]: UQADD
    public static unsafe Vector AddSaturate(Vector left, Vector right);  // svqadd[_u32]: UQADD
    public static unsafe Vector AddSaturate(Vector left, Vector right);  // svqadd[_u64]: UQADD
    public static unsafe Vector AddSaturate(Vector left, sbyte right);  // svqadd[_n_s8]: SQADD or SQSUB or SQADD
    public static unsafe Vector AddSaturate(Vector left, short right);  // svqadd[_n_s16]: SQADD or SQSUB or SQADD
    public static unsafe Vector AddSaturate(Vector left, int right);  // svqadd[_n_s32]: SQADD or SQSUB or SQADD
    public static unsafe Vector AddSaturate(Vector left, long right);  // svqadd[_n_s64]: SQADD or SQSUB or SQADD
    public static unsafe Vector AddSaturate(Vector left, byte right);  // svqadd[_n_u8]: UQADD or UQADD
    public static unsafe Vector AddSaturate(Vector left, ushort right);  // svqadd[_n_u16]: UQADD or UQADD
    public static unsafe Vector AddSaturate(Vector left, uint right);  // svqadd[_n_u32]: UQADD or UQADD
    public static unsafe Vector AddSaturate(Vector left, ulong right);  // svqadd[_n_u64]: UQADD or UQADD

    public static unsafe Vector ComplexMultiplyAddWithRotate(Vector op1, Vector op2, Vector op3, ulong imm_index, ulong imm_rotation);  // svcmla_lane[_f32]: FCMLA or MOVPRFX+FCMLA

    public static unsafe Vector ComputeVectorAddressesFor16BitData(Vector bases, Vector indices);  // svadrh[_u32base]_[s32]index: ADR
    public static unsafe Vector ComputeVectorAddressesFor16BitData(Vector bases, Vector indices);  // svadrh[_u32base]_[u32]index: ADR
    public static unsafe Vector ComputeVectorAddressesFor16BitData(Vector bases, Vector indices);  // svadrh[_u64base]_[s64]index: ADR
    public static unsafe Vector ComputeVectorAddressesFor16BitData(Vector bases, Vector indices);  // svadrh[_u64base]_[u64]index: ADR

    public static unsafe Vector ComputeVectorAddressesFor32BitData(Vector bases, Vector indices);  // svadrw[_u32base]_[s32]index: ADR
    public static unsafe Vector ComputeVectorAddressesFor32BitData(Vector bases, Vector indices);  // svadrw[_u32base]_[u32]index: ADR
    public static unsafe Vector ComputeVectorAddressesFor32BitData(Vector bases, Vector indices);  // svadrw[_u64base]_[s64]index: ADR
    public static unsafe Vector ComputeVectorAddressesFor32BitData(Vector bases, Vector indices);  // svadrw[_u64base]_[u64]index: ADR

    public static unsafe Vector ComputeVectorAddressesFor64BitData(Vector bases, Vector indices);  // svadrd[_u32base]_[s32]index: ADR
    public static unsafe Vector ComputeVectorAddressesFor64BitData(Vector bases, Vector indices);  // svadrd[_u32base]_[u32]index: ADR
    public static unsafe Vector ComputeVectorAddressesFor64BitData(Vector bases, Vector indices);  // svadrd[_u64base]_[s64]index: ADR
    public static unsafe Vector ComputeVectorAddressesFor64BitData(Vector bases, Vector indices);  // svadrd[_u64base]_[u64]index: ADR

    public static unsafe Vector ComputeVectorAddressesFor8BitData(Vector bases, Vector offsets);  // svadrb[_u32base]_[s32]offset: ADR
    public static unsafe Vector ComputeVectorAddressesFor8BitData(Vector bases, Vector offsets);  // svadrb[_u32base]_[u32]offset: ADR
    public static unsafe Vector ComputeVectorAddressesFor8BitData(Vector bases, Vector offsets);  // svadrb[_u64base]_[s64]offset: ADR
    public static unsafe Vector ComputeVectorAddressesFor8BitData(Vector bases, Vector offsets);  // svadrb[_u64base]_[u64]offset: ADR

    public static unsafe Vector CreateLinearSeries(sbyte base, sbyte step);  // svindex_s8: INDEX or INDEX or INDEX or INDEX
    public static unsafe Vector CreateLinearSeries(short base, short step);  // svindex_s16: INDEX or INDEX or INDEX or INDEX
    public static unsafe Vector CreateLinearSeries(int base, int step);  // svindex_s32: INDEX or INDEX or INDEX or INDEX
    public static unsafe Vector CreateLinearSeries(long base, long step);  // svindex_s64: INDEX or INDEX or INDEX or INDEX
    public static unsafe Vector CreateLinearSeries(byte base, byte step);  // svindex_u8: INDEX or INDEX or INDEX or INDEX
    public static unsafe Vector CreateLinearSeries(ushort base, ushort step);  // svindex_u16: INDEX or INDEX or INDEX or INDEX
    public static unsafe Vector CreateLinearSeries(uint base, uint step);  // svindex_u32: INDEX or INDEX or INDEX or INDEX
    public static unsafe Vector CreateLinearSeries(ulong base, ulong step);  // svindex_u64: INDEX or INDEX or INDEX or INDEX

    public static unsafe Vector DotProduct(Vector op1, Vector op2, Vector op3);  // svdot[_s32]: SDOT or MOVPRFX+SDOT
    public static unsafe Vector DotProduct(Vector op1, Vector op2, Vector op3);  // svdot[_s64]: SDOT or MOVPRFX+SDOT
    public static unsafe Vector DotProduct(Vector op1, Vector op2, Vector op3);  // svdot[_u32]: UDOT or MOVPRFX+UDOT
    public static unsafe Vector DotProduct(Vector op1, Vector op2, Vector op3);  // svdot[_u64]: UDOT or MOVPRFX+UDOT
    public static unsafe Vector DotProduct(Vector op1, Vector op2, sbyte op3);  // svdot[_n_s32]: SDOT or MOVPRFX+SDOT
    public static unsafe Vector DotProduct(Vector op1, Vector op2, short op3);  // svdot[_n_s64]: SDOT or MOVPRFX+SDOT
    public static unsafe Vector DotProduct(Vector op1, Vector op2, byte op3);  // svdot[_n_u32]: UDOT or MOVPRFX+UDOT
    public static unsafe Vector DotProduct(Vector op1, Vector op2, ushort op3);  // svdot[_n_u64]: UDOT or MOVPRFX+UDOT
    public static unsafe Vector DotProduct(Vector op1, Vector op2, Vector op3, ulong imm_index);  // svdot_lane[_s32]: SDOT or MOVPRFX+SDOT
    public static unsafe Vector DotProduct(Vector op1, Vector op2, Vector op3, ulong imm_index);  // svdot_lane[_s64]: SDOT or MOVPRFX+SDOT
    public static unsafe Vector DotProduct(Vector op1, Vector op2, Vector op3, ulong imm_index);  // svdot_lane[_u32]: UDOT or MOVPRFX+UDOT
    public static unsafe Vector DotProduct(Vector op1, Vector op2, Vector op3, ulong imm_index);  // svdot_lane[_u64]: UDOT or MOVPRFX+UDOT

    public static unsafe Vector DuplicateToVector(float value);  // svdup[_n]_f32: DUP or FDUP or DUP or DUP
    public static unsafe Vector DuplicateToVector(double value);  // svdup[_n]_f64: DUP or FDUP or DUP or DUP
    public static unsafe Vector DuplicateToVector(sbyte value);  // svdup[_n]_s8: DUP or FDUP or DUPM or DUP or DUP
    public static unsafe Vector DuplicateToVector(short value);  // svdup[_n]_s16: DUP or FDUP or DUPM or DUP or DUP
    public static unsafe Vector DuplicateToVector(int value);  // svdup[_n]_s32: DUP or FDUP or DUPM or DUP or DUP
    public static unsafe Vector DuplicateToVector(long value);  // svdup[_n]_s64: DUP or FDUP or DUPM or DUP or DUP
    public static unsafe Vector DuplicateToVector(byte value);  // svdup[_n]_u8: DUP or FDUP or DUPM or DUP or DUP
    public static unsafe Vector DuplicateToVector(ushort value);  // svdup[_n]_u16: DUP or FDUP or DUPM or DUP or DUP
    public static unsafe Vector DuplicateToVector(uint value);  // svdup[_n]_u32: DUP or FDUP or DUPM or DUP or DUP
    public static unsafe Vector DuplicateToVector(ulong value);  // svdup[_n]_u64: DUP or FDUP or DUPM or DUP or DUP
    public static unsafe Vector DuplicateToVector(Vector data, uint index);  // svdup_lane[_f32]: DUP or TBL
    public static unsafe Vector DuplicateToVector(Vector data, ulong index);  // svdup_lane[_f64]: DUP or TBL
    public static unsafe Vector DuplicateToVector(Vector data, byte index);  // svdup_lane[_s8]: DUP or TBL
    public static unsafe Vector DuplicateToVector(Vector data, ushort index);  // svdup_lane[_s16]: DUP or TBL
    public static unsafe Vector DuplicateToVector(Vector data, uint index);  // svdup_lane[_s32]: DUP or TBL
    public static unsafe Vector DuplicateToVector(Vector data, ulong index);  // svdup_lane[_s64]: DUP or TBL
    public static unsafe Vector DuplicateToVector(Vector data, byte index);  // svdup_lane[_u8]: DUP or TBL
    public static unsafe Vector DuplicateToVector(Vector data, ushort index);  // svdup_lane[_u16]: DUP or TBL
    public static unsafe Vector DuplicateToVector(Vector data, uint index);  // svdup_lane[_u32]: DUP or TBL
    public static unsafe Vector DuplicateToVector(Vector data, ulong index);  // svdup_lane[_u64]: DUP or TBL
    public static unsafe Vector DuplicateToVector(Vector data, ulong index);  // svdupq_lane[_f32]: DUP or TBL
    public static unsafe Vector DuplicateToVector(Vector data, ulong index);  // svdupq_lane[_f64]: DUP or TBL
    public static unsafe Vector DuplicateToVector(Vector data, ulong index);  // svdupq_lane[_s8]: DUP or TBL
    public static unsafe Vector DuplicateToVector(Vector data, ulong index);  // svdupq_lane[_s16]: DUP or TBL
    public static unsafe Vector DuplicateToVector(Vector data, ulong index);  // svdupq_lane[_s32]: DUP or TBL
    public static unsafe Vector DuplicateToVector(Vector data, ulong index);  // svdupq_lane[_s64]: DUP or TBL
    public static unsafe Vector DuplicateToVector(Vector data, ulong index);  // svdupq_lane[_u8]: DUP or TBL
    public static unsafe Vector DuplicateToVector(Vector data, ulong index);  // svdupq_lane[_u16]: DUP or TBL
    public static unsafe Vector DuplicateToVector(Vector data, ulong index);  // svdupq_lane[_u32]: DUP or TBL
    public static unsafe Vector DuplicateToVector(Vector data, ulong index);  // svdupq_lane[_u64]: DUP or TBL

    public static unsafe Vector ExtractVector(Vector upper, Vector lower, ulong index);  // svext[_f32]: EXT or MOVPRFX+EXT
    public static unsafe Vector ExtractVector(Vector upper, Vector lower, ulong index);  // svext[_f64]: EXT or MOVPRFX+EXT
    public static unsafe Vector ExtractVector(Vector upper, Vector lower, ulong index);  // svext[_s8]: EXT or MOVPRFX+EXT
    public static unsafe Vector ExtractVector(Vector upper, Vector lower, ulong index);  // svext[_s16]: EXT or MOVPRFX+EXT
    public static unsafe Vector ExtractVector(Vector upper, Vector lower, ulong index);  // svext[_s32]: EXT or MOVPRFX+EXT
    public static unsafe Vector ExtractVector(Vector upper, Vector lower, ulong index);  // svext[_s64]: EXT or MOVPRFX+EXT
    public static unsafe Vector ExtractVector(Vector upper, Vector lower, ulong index);  // svext[_u8]: EXT or MOVPRFX+EXT
    public static unsafe Vector ExtractVector(Vector upper, Vector lower, ulong index);  // svext[_u16]: EXT or MOVPRFX+EXT
    public static unsafe Vector ExtractVector(Vector upper, Vector lower, ulong index);  // svext[_u32]: EXT or MOVPRFX+EXT
    public static unsafe Vector ExtractVector(Vector upper, Vector lower, ulong index);  // svext[_u64]: EXT or MOVPRFX+EXT

    public static unsafe Vector FloatingPointExponentialAccelerator(Vector value);  // svexpa[_f32]: FEXPA
    public static unsafe Vector FloatingPointExponentialAccelerator(Vector value);  // svexpa[_f64]: FEXPA

    public static unsafe Vector FusedMultiplyAdd(Vector addend, Vector left, Vector right, ulong imm_index);  // svmla_lane[_f32]: FMLA or MOVPRFX+FMLA
    public static unsafe Vector FusedMultiplyAdd(Vector addend, Vector left, Vector right, ulong imm_index);  // svmla_lane[_f64]: FMLA or MOVPRFX+FMLA

    public static unsafe Vector FusedMultiplySubtract(Vector minuend, Vector left, Vector right, ulong imm_index);  // svmls_lane[_f32]: FMLS or MOVPRFX+FMLS
    public static unsafe Vector FusedMultiplySubtract(Vector minuend, Vector left, Vector right, ulong imm_index);  // svmls_lane[_f64]: FMLS or MOVPRFX+FMLS

    public static unsafe void InitializeTheFirstFaultRegisterToAllTrue();  // svsetffr: SETFFR

    public static unsafe Vector InsertIntoShiftedVector(Vector left, float right);  // svinsr[_n_f32]: INSR or INSR
    public static unsafe Vector InsertIntoShiftedVector(Vector left, double right);  // svinsr[_n_f64]: INSR or INSR
    public static unsafe Vector InsertIntoShiftedVector(Vector left, sbyte right);  // svinsr[_n_s8]: INSR or INSR
    public static unsafe Vector InsertIntoShiftedVector(Vector left, short right);  //

@MichalPetryka
Copy link
Contributor

public static unsafe Vector InsertIntoShiftedVector(Vector

The list seems to have been truncated?

@a74nh
Copy link
Contributor Author

a74nh commented Oct 17, 2023

public static unsafe Vector InsertIntoShiftedVector(Vector

The list seems to have been truncated?

Fixed now.

I was using <pre><code> blocks instead of quoting so I could include links back to the c intrinsics doc (which then has links back to the Arm instructions doc). But doing that causes the block to truncate.
Also, I couldn't get C# highlighting working using <pre><code>.

So, I've switched back to a quoted block without the links.

@a74nh
Copy link
Contributor Author

a74nh commented Oct 17, 2023

This is the next version of the API proposed in #93459

This API is still auto generated, but the script has lots of replacements on various patterns.

For any methods with an matching method in AdvSimd intrinsics, I've named the method and the args to match the existing one. For all other methods, I've not attempted to guess at a name.

There are a lot fewer instructions now because it's only FEAT_SVE instructions.

@a74nh a74nh mentioned this issue Oct 17, 2023
Closed
@a74nh
Copy link
Contributor Author

a74nh commented Oct 17, 2023

@kunalspathak @tannergooding @BruceForstall @TamarChristinaArm

@a74nh
Copy link
Contributor Author

a74nh commented Oct 20, 2023

The idea of this issue was to quickly get the no predicated instruction approved. However, after looking in depth at predication, this list no longer really makes sense on its own.

Closing this issue. Intention of the next version will be to split by function category (bitwise, math, float, loads etc).

@a74nh a74nh closed this as completed Oct 20, 2023
@ghost ghost removed the untriaged New issue has not been triaged by the area owner label Oct 20, 2023
@ghost ghost locked as resolved and limited conversation to collaborators Nov 19, 2023
Sign up for free to subscribe to this conversation on GitHub. Already have an account? Sign in.
Assignees
No one assigned
Labels
api-suggestion Early API idea and discussion, it is NOT ready for implementation area-System.Runtime.Intrinsics
Projects
None yet
Milestone
No milestone
Development

No branches or pull requests
2 participants
@a74nh @MichalPetryka