search

dotnet / runtime

.NET is a cross-platform runtime for cloud, mobile, desktop, and IoT apps.
https://docs.microsoft.com/dotnet/core/
MIT License
15.26k stars 4.73k forks source link

[API Proposal]: Arm64: FEAT_SVE: gather loads #94007

Open a74nh opened 1 year ago

a74nh commented 1 year ago 
namespace System.Runtime.Intrinsics.Arm;

/// VectorT Summary
public abstract partial class Sve : AdvSimd /// Feature: FEAT_SVE  Category: gatherloads
{

  /// T: [byte, uint], [byte, ulong]
  public static unsafe void GatherPrefetchBytes(Vector<T> mask, Vector<T2> bases, [ConstantExpected] SvePrefetchType op); // PRFB

  /// T: [byte, int], [byte, uint], [byte, long], [byte, ulong]
  public static unsafe void GatherPrefetchBytes(Vector<T> mask, void* base, Vector<T2> offsets, [ConstantExpected] SvePrefetchType op); // PRFB

  /// T: [byte, uint], [byte, ulong]
  public static unsafe void GatherPrefetchBytes(Vector<T> mask, Vector<T2> bases, long offset, [ConstantExpected] SvePrefetchType op); // PRFB

  /// T: [ushort, uint], [ushort, ulong]
  public static unsafe void GatherPrefetchInt16(Vector<T> mask, Vector<T2> bases, [ConstantExpected] SvePrefetchType op); // PRFH

  /// T: [ushort, int], [ushort, uint], [ushort, long], [ushort, ulong]
  public static unsafe void GatherPrefetchInt16(Vector<T> mask, void* base, Vector<T2> indices, [ConstantExpected] SvePrefetchType op); // PRFH

  /// T: [ushort, uint], [ushort, ulong]
  public static unsafe void GatherPrefetchInt16(Vector<T> mask, Vector<T2> bases, long index, [ConstantExpected] SvePrefetchType op); // PRFH or PRFB

  public static unsafe void GatherPrefetchInt32(Vector<uint> mask, Vector<uint> bases, [ConstantExpected] SvePrefetchType op); // PRFW

  public static unsafe void GatherPrefetchInt32(Vector<uint> mask, Vector<ulong> bases, [ConstantExpected] SvePrefetchType op); // PRFW

  /// T: [uint, int], [uint, long], [uint, ulong]
  public static unsafe void GatherPrefetchInt32(Vector<T> mask, void* base, Vector<T2> indices, [ConstantExpected] SvePrefetchType op); // PRFW

  public static unsafe void GatherPrefetchInt32(Vector<uint> mask, void* base, Vector<uint> indices, [ConstantExpected] SvePrefetchType op); // PRFW

  public static unsafe void GatherPrefetchInt32(Vector<uint> mask, Vector<uint> bases, long index, [ConstantExpected] SvePrefetchType op); // PRFW or PRFB

  public static unsafe void GatherPrefetchInt32(Vector<uint> mask, Vector<ulong> bases, long index, [ConstantExpected] SvePrefetchType op); // PRFW or PRFB

  public static unsafe void GatherPrefetchInt64(Vector<ulong> mask, Vector<uint> bases, [ConstantExpected] SvePrefetchType op); // PRFD

  public static unsafe void GatherPrefetchInt64(Vector<ulong> mask, Vector<ulong> bases, [ConstantExpected] SvePrefetchType op); // PRFD

  /// T: [ulong, int], [ulong, uint], [ulong, long]
  public static unsafe void GatherPrefetchInt64(Vector<T> mask, void* base, Vector<T2> indices, [ConstantExpected] SvePrefetchType op); // PRFD

  public static unsafe void GatherPrefetchInt64(Vector<ulong> mask, void* base, Vector<ulong> indices, [ConstantExpected] SvePrefetchType op); // PRFD

  public static unsafe void GatherPrefetchInt64(Vector<ulong> mask, Vector<uint> bases, long index, [ConstantExpected] SvePrefetchType op); // PRFD or PRFB

  public static unsafe void GatherPrefetchInt64(Vector<ulong> mask, Vector<ulong> bases, long index, [ConstantExpected] SvePrefetchType op); // PRFD or PRFB

  /// T: [float, uint], [int, uint], [double, ulong], [long, ulong]
  public static unsafe Vector<T> GatherVector(Vector<T> mask, Vector<T2> bases); // LD1W or LD1D

  /// T: uint, ulong
  public static unsafe Vector<T> GatherVector(Vector<T> mask, Vector<T> bases); // LD1W or LD1D

  /// T: [float, int], [uint, int], [float, uint], [int, uint], [double, long], [ulong, long], [double, ulong], [long, ulong]
  public static unsafe Vector<T> GatherVector(Vector<T> mask, T* base, Vector<T2> offsets); // LD1W or LD1D

  /// T: int, uint, long, ulong
  public static unsafe Vector<T> GatherVector(Vector<T> mask, T* base, Vector<T> offsets); // LD1W or LD1D

  /// T: [float, int], [uint, int], [float, uint], [int, uint], [double, long], [ulong, long], [double, ulong], [long, ulong]
  public static unsafe Vector<T> GatherVector(Vector<T> mask, T* base, Vector<T2> indices); // LD1W or LD1D

  /// T: int, uint, long, ulong
  public static unsafe Vector<T> GatherVector(Vector<T> mask, T* base, Vector<T> indices); // LD1W or LD1D

  /// T: [float, uint], [int, uint], [double, ulong], [long, ulong]
  public static unsafe Vector<T> GatherVector(Vector<T> mask, Vector<T2> bases, long offset); // LD1W or LD1D

  /// T: uint, ulong
  public static unsafe Vector<T> GatherVector(Vector<T> mask, Vector<T> bases, long offset); // LD1W or LD1D

  /// T: [float, uint], [int, uint], [double, ulong], [long, ulong]
  public static unsafe Vector<T> GatherVector(Vector<T> mask, Vector<T2> bases, long index); // LD1W or LD1D

  /// T: uint, ulong
  public static unsafe Vector<T> GatherVector(Vector<T> mask, Vector<T> bases, long index); // LD1W or LD1D

  /// T: [int, uint], [long, ulong]
  public static unsafe Vector<T> GatherVectorByteZeroExtend(Vector<T> mask, Vector<T2> bases); // LD1B

  /// T: uint, ulong
  public static unsafe Vector<T> GatherVectorByteZeroExtend(Vector<T> mask, Vector<T> bases); // LD1B

  /// T: int, uint, long, ulong
  public static unsafe Vector<T> GatherVectorByteZeroExtend(Vector<T> mask, byte* base, Vector<T> offsets); // LD1B

  /// T: [uint, int], [int, uint], [ulong, long], [long, ulong]
  public static unsafe Vector<T> GatherVectorByteZeroExtend(Vector<T> mask, byte* base, Vector<T2> offsets); // LD1B

  /// T: [int, uint], [long, ulong]
  public static unsafe Vector<T> GatherVectorByteZeroExtend(Vector<T> mask, Vector<T2> bases, long offset); // LD1B

  /// T: uint, ulong
  public static unsafe Vector<T> GatherVectorByteZeroExtend(Vector<T> mask, Vector<T> bases, long offset); // LD1B

  /// T: [int, uint], [long, ulong]
  public static unsafe Vector<T> GatherVectorInt16SignExtend(Vector<T> mask, Vector<T2> bases); // LD1SH

  /// T: uint, ulong
  public static unsafe Vector<T> GatherVectorInt16SignExtend(Vector<T> mask, Vector<T> bases); // LD1SH

  /// T: int, uint, long, ulong
  public static unsafe Vector<T> GatherVectorInt16SignExtend(Vector<T> mask, short* base, Vector<T> offsets); // LD1SH

  /// T: [uint, int], [int, uint], [ulong, long], [long, ulong]
  public static unsafe Vector<T> GatherVectorInt16SignExtend(Vector<T> mask, short* base, Vector<T2> offsets); // LD1SH

  /// T: int, uint, long, ulong
  public static unsafe Vector<T> GatherVectorInt16SignExtend(Vector<T> mask, short* base, Vector<T> indices); // LD1SH

  /// T: [uint, int], [int, uint], [ulong, long], [long, ulong]
  public static unsafe Vector<T> GatherVectorInt16SignExtend(Vector<T> mask, short* base, Vector<T2> indices); // LD1SH

  /// T: [int, uint], [long, ulong]
  public static unsafe Vector<T> GatherVectorInt16SignExtend(Vector<T> mask, Vector<T2> bases, long offset); // LD1SH

  /// T: uint, ulong
  public static unsafe Vector<T> GatherVectorInt16SignExtend(Vector<T> mask, Vector<T> bases, long offset); // LD1SH

  /// T: [int, uint], [long, ulong]
  public static unsafe Vector<T> GatherVectorInt16SignExtend(Vector<T> mask, Vector<T2> bases, long index); // LD1SH

  /// T: uint, ulong
  public static unsafe Vector<T> GatherVectorInt16SignExtend(Vector<T> mask, Vector<T> bases, long index); // LD1SH

  /// T: [int, uint], [long, ulong]
  public static unsafe Vector<T> GatherVectorInt16ZeroExtend(Vector<T> mask, Vector<T2> bases); // LD1H

  /// T: uint, ulong
  public static unsafe Vector<T> GatherVectorInt16ZeroExtend(Vector<T> mask, Vector<T> bases); // LD1H

  /// T: int, uint, long, ulong
  public static unsafe Vector<T> GatherVectorInt16ZeroExtend(Vector<T> mask, ushort* base, Vector<T> offsets); // LD1H

  /// T: [uint, int], [int, uint], [ulong, long], [long, ulong]
  public static unsafe Vector<T> GatherVectorInt16ZeroExtend(Vector<T> mask, ushort* base, Vector<T2> offsets); // LD1H

  /// T: int, uint, long, ulong
  public static unsafe Vector<T> GatherVectorInt16ZeroExtend(Vector<T> mask, ushort* base, Vector<T> indices); // LD1H

  /// T: [uint, int], [int, uint], [ulong, long], [long, ulong]
  public static unsafe Vector<T> GatherVectorInt16ZeroExtend(Vector<T> mask, ushort* base, Vector<T2> indices); // LD1H

  /// T: [int, uint], [long, ulong]
  public static unsafe Vector<T> GatherVectorInt16ZeroExtend(Vector<T> mask, Vector<T2> bases, long offset); // LD1H

  /// T: uint, ulong
  public static unsafe Vector<T> GatherVectorInt16ZeroExtend(Vector<T> mask, Vector<T> bases, long offset); // LD1H

  /// T: [int, uint], [long, ulong]
  public static unsafe Vector<T> GatherVectorInt16ZeroExtend(Vector<T> mask, Vector<T2> bases, long index); // LD1H

  /// T: uint, ulong
  public static unsafe Vector<T> GatherVectorInt16ZeroExtend(Vector<T> mask, Vector<T> bases, long index); // LD1H

  public static unsafe Vector<long> GatherVectorInt32SignExtend(Vector<long> mask, Vector<ulong> bases); // LD1SW

  public static unsafe Vector<ulong> GatherVectorInt32SignExtend(Vector<ulong> mask, Vector<ulong> bases); // LD1SW

  /// T: long, ulong
  public static unsafe Vector<T> GatherVectorInt32SignExtend(Vector<T> mask, int* base, Vector<T> offsets); // LD1SW

  /// T: [ulong, long], [long, ulong]
  public static unsafe Vector<T> GatherVectorInt32SignExtend(Vector<T> mask, int* base, Vector<T2> offsets); // LD1SW

  /// T: long, ulong
  public static unsafe Vector<T> GatherVectorInt32SignExtend(Vector<T> mask, int* base, Vector<T> indices); // LD1SW

  /// T: [ulong, long], [long, ulong]
  public static unsafe Vector<T> GatherVectorInt32SignExtend(Vector<T> mask, int* base, Vector<T2> indices); // LD1SW

  public static unsafe Vector<long> GatherVectorInt32SignExtend(Vector<long> mask, Vector<ulong> bases, long offset); // LD1SW

  public static unsafe Vector<ulong> GatherVectorInt32SignExtend(Vector<ulong> mask, Vector<ulong> bases, long offset); // LD1SW

  public static unsafe Vector<long> GatherVectorInt32SignExtend(Vector<long> mask, Vector<ulong> bases, long index); // LD1SW

  public static unsafe Vector<ulong> GatherVectorInt32SignExtend(Vector<ulong> mask, Vector<ulong> bases, long index); // LD1SW

  public static unsafe Vector<long> GatherVectorInt32ZeroExtend(Vector<long> mask, Vector<ulong> bases); // LD1W

  public static unsafe Vector<ulong> GatherVectorInt32ZeroExtend(Vector<ulong> mask, Vector<ulong> bases); // LD1W

  /// T: long, ulong
  public static unsafe Vector<T> GatherVectorInt32ZeroExtend(Vector<T> mask, uint* base, Vector<T> offsets); // LD1W

  /// T: [ulong, long], [long, ulong]
  public static unsafe Vector<T> GatherVectorInt32ZeroExtend(Vector<T> mask, uint* base, Vector<T2> offsets); // LD1W

  /// T: long, ulong
  public static unsafe Vector<T> GatherVectorInt32ZeroExtend(Vector<T> mask, uint* base, Vector<T> indices); // LD1W

  /// T: [ulong, long], [long, ulong]
  public static unsafe Vector<T> GatherVectorInt32ZeroExtend(Vector<T> mask, uint* base, Vector<T2> indices); // LD1W

  public static unsafe Vector<long> GatherVectorInt32ZeroExtend(Vector<long> mask, Vector<ulong> bases, long offset); // LD1W

  public static unsafe Vector<ulong> GatherVectorInt32ZeroExtend(Vector<ulong> mask, Vector<ulong> bases, long offset); // LD1W

  public static unsafe Vector<long> GatherVectorInt32ZeroExtend(Vector<long> mask, Vector<ulong> bases, long index); // LD1W

  public static unsafe Vector<ulong> GatherVectorInt32ZeroExtend(Vector<ulong> mask, Vector<ulong> bases, long index); // LD1W

  /// T: [int, uint], [long, ulong]
  public static unsafe Vector<T> GatherVectorSByteSignExtend(Vector<T> mask, Vector<T2> bases); // LD1SB

  /// T: uint, ulong
  public static unsafe Vector<T> GatherVectorSByteSignExtend(Vector<T> mask, Vector<T> bases); // LD1SB

  /// T: int, uint, long, ulong
  public static unsafe Vector<T> GatherVectorSByteSignExtend(Vector<T> mask, sbyte* base, Vector<T> offsets); // LD1SB

  /// T: [uint, int], [int, uint], [ulong, long], [long, ulong]
  public static unsafe Vector<T> GatherVectorSByteSignExtend(Vector<T> mask, sbyte* base, Vector<T2> offsets); // LD1SB

  /// T: [int, uint], [long, ulong]
  public static unsafe Vector<T> GatherVectorSByteSignExtend(Vector<T> mask, Vector<T2> bases, long offset); // LD1SB

  /// T: uint, ulong
  public static unsafe Vector<T> GatherVectorSByteSignExtend(Vector<T> mask, Vector<T> bases, long offset); // LD1SB

  // All possible prefetch types
  enum SvePrefetchType
  {
    SV_PLDL1KEEP = 0,   // Temporal fetch the addressed location for reading, to L1 cache.
    SV_PLDL1STRM = 1,   // Streaming fetch the addressed location for reading, to L1 cache.
    SV_PLDL2KEEP = 2,   // Temporal fetch the addressed location for reading, to L2 cache.
    SV_PLDL2STRM = 3,   // Streaming fetch the addressed location for reading, to L2 cache.
    SV_PLDL3KEEP = 4,   // Temporal fetch the addressed location for reading, to L3 cache.
    SV_PLDL3STRM = 5,   // Streaming fetch the addressed location for reading, to L3 cache.
    SV_PSTL1KEEP = 8,   // Temporal fetch the addressed location for writing, to L1 cache.
    SV_PSTL1STRM = 9,   // Streaming fetch the addressed location for writing, to L1 cache.
    SV_PSTL2KEEP = 10,  // Temporal fetch the addressed location for writing, to L2 cache.
    SV_PSTL2STRM = 11,  // Streaming fetch the addressed location for writing, to L2 cache.
    SV_PSTL3KEEP = 12,  // Temporal fetch the addressed location for writing, to L3 cache.
    SV_PSTL3STRM = 13   // Streaming fetch the addressed location for writing, to L3 cache.
  };

  /// total method signatures: 80

}
ghost commented 1 year ago

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

Issue Details
```csharp namespace System.Runtime.Intrinsics.Arm /// VectorT Summary public abstract class Sve : AdvSimd /// Feature: FEAT_SVE Category: gatherloads { /// T: [float, uint], [int, uint], [double, ulong], [long, ulong] public static unsafe Vector GatherLoadVector(Vector bases); // LD1W or LD1D /// T: uint, ulong public static unsafe Vector GatherLoadVector(Vector bases); // LD1W or LD1D /// T: [float, int], [uint, int], [float, uint], [int, uint], [double, long], [ulong, long], [double, ulong], [long, ulong] public static unsafe Vector GatherLoadVector(const T *base, Vector offsets); // LD1W or LD1D /// T: int, uint, long, ulong public static unsafe Vector GatherLoadVector(const T *base, Vector offsets); // LD1W or LD1D /// T: [float, int], [uint, int], [float, uint], [int, uint], [double, long], [ulong, long], [double, ulong], [long, ulong] public static unsafe Vector GatherLoadVector(const T *base, Vector indices); // LD1W or LD1D /// T: int, uint, long, ulong public static unsafe Vector GatherLoadVector(const T *base, Vector indices); // LD1W or LD1D /// T: [float, uint], [int, uint], [double, ulong], [long, ulong] public static unsafe Vector GatherLoadVector(Vector bases, long offset); // LD1W or LD1D /// T: uint, ulong public static unsafe Vector GatherLoadVector(Vector bases, long offset); // LD1W or LD1D /// T: [float, uint], [int, uint], [double, ulong], [long, ulong] public static unsafe Vector GatherLoadVector(Vector bases, long index); // LD1W or LD1D /// T: uint, ulong public static unsafe Vector GatherLoadVector(Vector bases, long index); // LD1W or LD1D /// T: [int, uint], [long, ulong] public static unsafe Vector GatherLoadVector16SignExtend(Vector bases); // LD1SH /// T: uint, ulong public static unsafe Vector GatherLoadVector16SignExtend(Vector bases); // LD1SH /// T: int, uint, long, ulong public static unsafe Vector GatherLoadVector16SignExtend(const short *base, Vector offsets); // LD1SH /// T: [uint, int], [int, uint], [ulong, long], [long, ulong] public static unsafe Vector GatherLoadVector16SignExtend(const short *base, Vector offsets); // LD1SH /// T: int, uint, long, ulong public static unsafe Vector GatherLoadVector16SignExtend(const short *base, Vector indices); // LD1SH /// T: [uint, int], [int, uint], [ulong, long], [long, ulong] public static unsafe Vector GatherLoadVector16SignExtend(const short *base, Vector indices); // LD1SH /// T: [int, uint], [long, ulong] public static unsafe Vector GatherLoadVector16SignExtend(Vector bases, long offset); // LD1SH /// T: uint, ulong public static unsafe Vector GatherLoadVector16SignExtend(Vector bases, long offset); // LD1SH /// T: [int, uint], [long, ulong] public static unsafe Vector GatherLoadVector16SignExtend(Vector bases, long index); // LD1SH /// T: uint, ulong public static unsafe Vector GatherLoadVector16SignExtend(Vector bases, long index); // LD1SH /// T: [int, uint], [long, ulong] public static unsafe Vector GatherLoadVector16ZeroExtend(Vector bases); // LD1H /// T: uint, ulong public static unsafe Vector GatherLoadVector16ZeroExtend(Vector bases); // LD1H /// T: int, uint, long, ulong public static unsafe Vector GatherLoadVector16ZeroExtend(const ushort *base, Vector offsets); // LD1H /// T: [uint, int], [int, uint], [ulong, long], [long, ulong] public static unsafe Vector GatherLoadVector16ZeroExtend(const ushort *base, Vector offsets); // LD1H /// T: int, uint, long, ulong public static unsafe Vector GatherLoadVector16ZeroExtend(const ushort *base, Vector indices); // LD1H /// T: [uint, int], [int, uint], [ulong, long], [long, ulong] public static unsafe Vector GatherLoadVector16ZeroExtend(const ushort *base, Vector indices); // LD1H /// T: [int, uint], [long, ulong] public static unsafe Vector GatherLoadVector16ZeroExtend(Vector bases, long offset); // LD1H /// T: uint, ulong public static unsafe Vector GatherLoadVector16ZeroExtend(Vector bases, long offset); // LD1H /// T: [int, uint], [long, ulong] public static unsafe Vector GatherLoadVector16ZeroExtend(Vector bases, long index); // LD1H /// T: uint, ulong public static unsafe Vector GatherLoadVector16ZeroExtend(Vector bases, long index); // LD1H public static unsafe Vector GatherLoadVector32SignExtend(Vector bases); public static unsafe Vector GatherLoadVector32SignExtend(Vector bases); /// T: long, ulong public static unsafe Vector GatherLoadVector32SignExtend(const int *base, Vector offsets); // LD1SW /// T: [ulong, long], [long, ulong] public static unsafe Vector GatherLoadVector32SignExtend(const int *base, Vector offsets); // LD1SW /// T: long, ulong public static unsafe Vector GatherLoadVector32SignExtend(const int *base, Vector indices); // LD1SW /// T: [ulong, long], [long, ulong] public static unsafe Vector GatherLoadVector32SignExtend(const int *base, Vector indices); // LD1SW public static unsafe Vector GatherLoadVector32SignExtend(Vector bases, long offset); public static unsafe Vector GatherLoadVector32SignExtend(Vector bases, long offset); public static unsafe Vector GatherLoadVector32SignExtend(Vector bases, long index); public static unsafe Vector GatherLoadVector32SignExtend(Vector bases, long index); public static unsafe Vector GatherLoadVector32ZeroExtend(Vector bases); public static unsafe Vector GatherLoadVector32ZeroExtend(Vector bases); /// T: long, ulong public static unsafe Vector GatherLoadVector32ZeroExtend(const uint *base, Vector offsets); // LD1W /// T: [ulong, long], [long, ulong] public static unsafe Vector GatherLoadVector32ZeroExtend(const uint *base, Vector offsets); // LD1W /// T: long, ulong public static unsafe Vector GatherLoadVector32ZeroExtend(const uint *base, Vector indices); // LD1W /// T: [ulong, long], [long, ulong] public static unsafe Vector GatherLoadVector32ZeroExtend(const uint *base, Vector indices); // LD1W public static unsafe Vector GatherLoadVector32ZeroExtend(Vector bases, long offset); public static unsafe Vector GatherLoadVector32ZeroExtend(Vector bases, long offset); public static unsafe Vector GatherLoadVector32ZeroExtend(Vector bases, long index); public static unsafe Vector GatherLoadVector32ZeroExtend(Vector bases, long index); /// T: [int, uint], [long, ulong] public static unsafe Vector GatherLoadVector8SignExtend(Vector bases); // LD1SB /// T: uint, ulong public static unsafe Vector GatherLoadVector8SignExtend(Vector bases); // LD1SB /// T: int, uint, long, ulong public static unsafe Vector GatherLoadVector8SignExtend(const sbyte *base, Vector offsets); // LD1SB /// T: [uint, int], [int, uint], [ulong, long], [long, ulong] public static unsafe Vector GatherLoadVector8SignExtend(const sbyte *base, Vector offsets); // LD1SB /// T: [int, uint], [long, ulong] public static unsafe Vector GatherLoadVector8SignExtend(Vector bases, long offset); // LD1SB /// T: uint, ulong public static unsafe Vector GatherLoadVector8SignExtend(Vector bases, long offset); // LD1SB /// T: [int, uint], [long, ulong] public static unsafe Vector GatherLoadVector8ZeroExtend(Vector bases); // LD1B /// T: uint, ulong public static unsafe Vector GatherLoadVector8ZeroExtend(Vector bases); // LD1B /// T: int, uint, long, ulong public static unsafe Vector GatherLoadVector8ZeroExtend(const byte *base, Vector offsets); // LD1B /// T: [uint, int], [int, uint], [ulong, long], [long, ulong] public static unsafe Vector GatherLoadVector8ZeroExtend(const byte *base, Vector offsets); // LD1B /// T: [int, uint], [long, ulong] public static unsafe Vector GatherLoadVector8ZeroExtend(Vector bases, long offset); // LD1B /// T: uint, ulong public static unsafe Vector GatherLoadVector8ZeroExtend(Vector bases, long offset); // LD1B /// T: uint, ulong public static unsafe void GatherPrefetchBytes(Vector bases, enum svprfop op); // PRFB /// T: int, uint, long, ulong public static unsafe void GatherPrefetchBytes(const void *base, Vector offsets, enum svprfop op); // PRFB /// T: uint, ulong public static unsafe void GatherPrefetchBytes(Vector bases, long offset, enum svprfop op); // PRFB /// T: uint, ulong public static unsafe void GatherPrefetchDoublewords(Vector bases, enum svprfop op); // PRFD /// T: int, uint, long, ulong public static unsafe void GatherPrefetchDoublewords(const void *base, Vector indices, enum svprfop op); // PRFD /// T: uint, ulong public static unsafe void GatherPrefetchDoublewords(Vector bases, long index, enum svprfop op); // PRFD or PRFB /// T: uint, ulong public static unsafe void GatherPrefetchHalfwords(Vector bases, enum svprfop op); // PRFH /// T: int, uint, long, ulong public static unsafe void GatherPrefetchHalfwords(const void *base, Vector indices, enum svprfop op); // PRFH /// T: uint, ulong public static unsafe void GatherPrefetchHalfwords(Vector bases, long index, enum svprfop op); // PRFH or PRFB /// T: uint, ulong public static unsafe void GatherPrefetchWords(Vector bases, enum svprfop op); // PRFW /// T: int, uint, long, ulong public static unsafe void GatherPrefetchWords(const void *base, Vector indices, enum svprfop op); // PRFW /// T: uint, ulong public static unsafe void GatherPrefetchWords(Vector bases, long index, enum svprfop op); // PRFW or PRFB /// total method signatures: 74 } ```
Author: a74nh
Assignees: -
Labels: `area-System.Numerics`
Milestone: -
a74nh commented 1 year ago 

/// Full API
public abstract partial class Sve : AdvSimd /// Feature: FEAT_SVE  Category: gatherloads
{
    /// GatherPrefetchBytes : Prefetch bytes

    /// void svprfb_gather[_u32base](svbool_t pg, svuint32_t bases, enum svprfop op) : "PRFB op, Pg, [Zbases.S, #0]"
  public static unsafe void GatherPrefetchBytes(Vector<byte> mask, Vector<uint> bases, [ConstantExpected] SvePrefetchType op);

    /// void svprfb_gather[_u64base](svbool_t pg, svuint64_t bases, enum svprfop op) : "PRFB op, Pg, [Zbases.D, #0]"
  public static unsafe void GatherPrefetchBytes(Vector<byte> mask, Vector<ulong> bases, [ConstantExpected] SvePrefetchType op);

    /// void svprfb_gather_[s32]offset(svbool_t pg, const void *base, svint32_t offsets, enum svprfop op) : "PRFB op, Pg, [Xbase, Zoffsets.S, SXTW]"
  public static unsafe void GatherPrefetchBytes(Vector<byte> mask, void* base, Vector<int> offsets, [ConstantExpected] SvePrefetchType op);

    /// void svprfb_gather_[u32]offset(svbool_t pg, const void *base, svuint32_t offsets, enum svprfop op) : "PRFB op, Pg, [Xbase, Zoffsets.S, UXTW]"
  public static unsafe void GatherPrefetchBytes(Vector<byte> mask, void* base, Vector<uint> offsets, [ConstantExpected] SvePrefetchType op);

    /// void svprfb_gather_[s64]offset(svbool_t pg, const void *base, svint64_t offsets, enum svprfop op) : "PRFB op, Pg, [Xbase, Zoffsets.D]"
  public static unsafe void GatherPrefetchBytes(Vector<byte> mask, void* base, Vector<long> offsets, [ConstantExpected] SvePrefetchType op);

    /// void svprfb_gather_[u64]offset(svbool_t pg, const void *base, svuint64_t offsets, enum svprfop op) : "PRFB op, Pg, [Xbase, Zoffsets.D]"
  public static unsafe void GatherPrefetchBytes(Vector<byte> mask, void* base, Vector<ulong> offsets, [ConstantExpected] SvePrefetchType op);

    /// void svprfb_gather[_u32base]_offset(svbool_t pg, svuint32_t bases, int64_t offset, enum svprfop op) : "PRFB op, Pg, [Zbases.S, #offset]" or "PRFB op, Pg, [Xoffset, Zbases.S, UXTW]"
  public static unsafe void GatherPrefetchBytes(Vector<byte> mask, Vector<uint> bases, long offset, [ConstantExpected] SvePrefetchType op);

    /// void svprfb_gather[_u64base]_offset(svbool_t pg, svuint64_t bases, int64_t offset, enum svprfop op) : "PRFB op, Pg, [Zbases.D, #offset]" or "PRFB op, Pg, [Xoffset, Zbases.D]"
  public static unsafe void GatherPrefetchBytes(Vector<byte> mask, Vector<ulong> bases, long offset, [ConstantExpected] SvePrefetchType op);

    /// GatherPrefetchInt16 : Prefetch halfwords

    /// void svprfh_gather[_u32base](svbool_t pg, svuint32_t bases, enum svprfop op) : "PRFH op, Pg, [Zbases.S, #0]"
  public static unsafe void GatherPrefetchInt16(Vector<ushort> mask, Vector<uint> bases, [ConstantExpected] SvePrefetchType op);

    /// void svprfh_gather[_u64base](svbool_t pg, svuint64_t bases, enum svprfop op) : "PRFH op, Pg, [Zbases.D, #0]"
  public static unsafe void GatherPrefetchInt16(Vector<ushort> mask, Vector<ulong> bases, [ConstantExpected] SvePrefetchType op);

    /// void svprfh_gather_[s32]index(svbool_t pg, const void *base, svint32_t indices, enum svprfop op) : "PRFH op, Pg, [Xbase, Zindices.S, SXTW #1]"
  public static unsafe void GatherPrefetchInt16(Vector<ushort> mask, void* base, Vector<int> indices, [ConstantExpected] SvePrefetchType op);

    /// void svprfh_gather_[u32]index(svbool_t pg, const void *base, svuint32_t indices, enum svprfop op) : "PRFH op, Pg, [Xbase, Zindices.S, UXTW #1]"
  public static unsafe void GatherPrefetchInt16(Vector<ushort> mask, void* base, Vector<uint> indices, [ConstantExpected] SvePrefetchType op);

    /// void svprfh_gather_[s64]index(svbool_t pg, const void *base, svint64_t indices, enum svprfop op) : "PRFH op, Pg, [Xbase, Zindices.D, LSL #1]"
  public static unsafe void GatherPrefetchInt16(Vector<ushort> mask, void* base, Vector<long> indices, [ConstantExpected] SvePrefetchType op);

    /// void svprfh_gather_[u64]index(svbool_t pg, const void *base, svuint64_t indices, enum svprfop op) : "PRFH op, Pg, [Xbase, Zindices.D, LSL #1]"
  public static unsafe void GatherPrefetchInt16(Vector<ushort> mask, void* base, Vector<ulong> indices, [ConstantExpected] SvePrefetchType op);

    /// void svprfh_gather[_u32base]_index(svbool_t pg, svuint32_t bases, int64_t index, enum svprfop op) : "PRFH op, Pg, [Zbases.S, #index * 2]" or "PRFB op, Pg, [Xoffset, Zbases.S, UXTW]"
  public static unsafe void GatherPrefetchInt16(Vector<ushort> mask, Vector<uint> bases, long index, [ConstantExpected] SvePrefetchType op);

    /// void svprfh_gather[_u64base]_index(svbool_t pg, svuint64_t bases, int64_t index, enum svprfop op) : "PRFH op, Pg, [Zbases.D, #index * 2]" or "PRFB op, Pg, [Xoffset, Zbases.D]"
  public static unsafe void GatherPrefetchInt16(Vector<ushort> mask, Vector<ulong> bases, long index, [ConstantExpected] SvePrefetchType op);

    /// GatherPrefetchInt32 : Prefetch words

    /// void svprfw_gather[_u32base](svbool_t pg, svuint32_t bases, enum svprfop op) : "PRFW op, Pg, [Zbases.S, #0]"
  public static unsafe void GatherPrefetchInt32(Vector<uint> mask, Vector<uint> bases, [ConstantExpected] SvePrefetchType op);

    /// void svprfw_gather[_u64base](svbool_t pg, svuint64_t bases, enum svprfop op) : "PRFW op, Pg, [Zbases.D, #0]"
  public static unsafe void GatherPrefetchInt32(Vector<uint> mask, Vector<ulong> bases, [ConstantExpected] SvePrefetchType op);

    /// void svprfw_gather_[s32]index(svbool_t pg, const void *base, svint32_t indices, enum svprfop op) : "PRFW op, Pg, [Xbase, Zindices.S, SXTW #2]"
  public static unsafe void GatherPrefetchInt32(Vector<uint> mask, void* base, Vector<int> indices, [ConstantExpected] SvePrefetchType op);

    /// void svprfw_gather_[u32]index(svbool_t pg, const void *base, svuint32_t indices, enum svprfop op) : "PRFW op, Pg, [Xbase, Zindices.S, UXTW #2]"
  public static unsafe void GatherPrefetchInt32(Vector<uint> mask, void* base, Vector<uint> indices, [ConstantExpected] SvePrefetchType op);

    /// void svprfw_gather_[s64]index(svbool_t pg, const void *base, svint64_t indices, enum svprfop op) : "PRFW op, Pg, [Xbase, Zindices.D, LSL #2]"
  public static unsafe void GatherPrefetchInt32(Vector<uint> mask, void* base, Vector<long> indices, [ConstantExpected] SvePrefetchType op);

    /// void svprfw_gather_[u64]index(svbool_t pg, const void *base, svuint64_t indices, enum svprfop op) : "PRFW op, Pg, [Xbase, Zindices.D, LSL #2]"
  public static unsafe void GatherPrefetchInt32(Vector<uint> mask, void* base, Vector<ulong> indices, [ConstantExpected] SvePrefetchType op);

    /// void svprfw_gather[_u32base]_index(svbool_t pg, svuint32_t bases, int64_t index, enum svprfop op) : "PRFW op, Pg, [Zbases.S, #index * 4]" or "PRFB op, Pg, [Xoffset, Zbases.S, UXTW]"
  public static unsafe void GatherPrefetchInt32(Vector<uint> mask, Vector<uint> bases, long index, [ConstantExpected] SvePrefetchType op);

    /// void svprfw_gather[_u64base]_index(svbool_t pg, svuint64_t bases, int64_t index, enum svprfop op) : "PRFW op, Pg, [Zbases.D, #index * 4]" or "PRFB op, Pg, [Xoffset, Zbases.D]"
  public static unsafe void GatherPrefetchInt32(Vector<uint> mask, Vector<ulong> bases, long index, [ConstantExpected] SvePrefetchType op);

    /// GatherPrefetchInt64 : Prefetch doublewords

    /// void svprfd_gather[_u32base](svbool_t pg, svuint32_t bases, enum svprfop op) : "PRFD op, Pg, [Zbases.S, #0]"
  public static unsafe void GatherPrefetchInt64(Vector<ulong> mask, Vector<uint> bases, [ConstantExpected] SvePrefetchType op);

    /// void svprfd_gather[_u64base](svbool_t pg, svuint64_t bases, enum svprfop op) : "PRFD op, Pg, [Zbases.D, #0]"
  public static unsafe void GatherPrefetchInt64(Vector<ulong> mask, Vector<ulong> bases, [ConstantExpected] SvePrefetchType op);

    /// void svprfd_gather_[s32]index(svbool_t pg, const void *base, svint32_t indices, enum svprfop op) : "PRFD op, Pg, [Xbase, Zindices.S, SXTW #3]"
  public static unsafe void GatherPrefetchInt64(Vector<ulong> mask, void* base, Vector<int> indices, [ConstantExpected] SvePrefetchType op);

    /// void svprfd_gather_[u32]index(svbool_t pg, const void *base, svuint32_t indices, enum svprfop op) : "PRFD op, Pg, [Xbase, Zindices.S, UXTW #3]"
  public static unsafe void GatherPrefetchInt64(Vector<ulong> mask, void* base, Vector<uint> indices, [ConstantExpected] SvePrefetchType op);

    /// void svprfd_gather_[s64]index(svbool_t pg, const void *base, svint64_t indices, enum svprfop op) : "PRFD op, Pg, [Xbase, Zindices.D, LSL #3]"
  public static unsafe void GatherPrefetchInt64(Vector<ulong> mask, void* base, Vector<long> indices, [ConstantExpected] SvePrefetchType op);

    /// void svprfd_gather_[u64]index(svbool_t pg, const void *base, svuint64_t indices, enum svprfop op) : "PRFD op, Pg, [Xbase, Zindices.D, LSL #3]"
  public static unsafe void GatherPrefetchInt64(Vector<ulong> mask, void* base, Vector<ulong> indices, [ConstantExpected] SvePrefetchType op);

    /// void svprfd_gather[_u32base]_index(svbool_t pg, svuint32_t bases, int64_t index, enum svprfop op) : "PRFD op, Pg, [Zbases.S, #index * 8]" or "PRFB op, Pg, [Xoffset, Zbases.S, UXTW]"
  public static unsafe void GatherPrefetchInt64(Vector<ulong> mask, Vector<uint> bases, long index, [ConstantExpected] SvePrefetchType op);

    /// void svprfd_gather[_u64base]_index(svbool_t pg, svuint64_t bases, int64_t index, enum svprfop op) : "PRFD op, Pg, [Zbases.D, #index * 8]" or "PRFB op, Pg, [Xoffset, Zbases.D]"
  public static unsafe void GatherPrefetchInt64(Vector<ulong> mask, Vector<ulong> bases, long index, [ConstantExpected] SvePrefetchType op);

    /// GatherVector : Unextended load

    /// svfloat32_t svld1_gather[_u32base]_f32(svbool_t pg, svuint32_t bases) : "LD1W Zresult.S, Pg/Z, [Zbases.S, #0]"
  public static unsafe Vector<float> GatherVector(Vector<float> mask, Vector<uint> bases);

    /// svint32_t svld1_gather[_u32base]_s32(svbool_t pg, svuint32_t bases) : "LD1W Zresult.S, Pg/Z, [Zbases.S, #0]"
  public static unsafe Vector<int> GatherVector(Vector<int> mask, Vector<uint> bases);

    /// svuint32_t svld1_gather[_u32base]_u32(svbool_t pg, svuint32_t bases) : "LD1W Zresult.S, Pg/Z, [Zbases.S, #0]"
  public static unsafe Vector<uint> GatherVector(Vector<uint> mask, Vector<uint> bases);

    /// svfloat64_t svld1_gather[_u64base]_f64(svbool_t pg, svuint64_t bases) : "LD1D Zresult.D, Pg/Z, [Zbases.D, #0]"
  public static unsafe Vector<double> GatherVector(Vector<double> mask, Vector<ulong> bases);

    /// svint64_t svld1_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) : "LD1D Zresult.D, Pg/Z, [Zbases.D, #0]"
  public static unsafe Vector<long> GatherVector(Vector<long> mask, Vector<ulong> bases);

    /// svuint64_t svld1_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) : "LD1D Zresult.D, Pg/Z, [Zbases.D, #0]"
  public static unsafe Vector<ulong> GatherVector(Vector<ulong> mask, Vector<ulong> bases);

    /// svfloat32_t svld1_gather_[s32]offset[_f32](svbool_t pg, const float32_t *base, svint32_t offsets) : "LD1W Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW]"
  public static unsafe Vector<float> GatherVector(Vector<float> mask, float* base, Vector<int> offsets);

    /// svint32_t svld1_gather_[s32]offset[_s32](svbool_t pg, const int32_t *base, svint32_t offsets) : "LD1W Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW]"
  public static unsafe Vector<int> GatherVector(Vector<int> mask, int* base, Vector<int> offsets);

    /// svuint32_t svld1_gather_[s32]offset[_u32](svbool_t pg, const uint32_t *base, svint32_t offsets) : "LD1W Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW]"
  public static unsafe Vector<uint> GatherVector(Vector<uint> mask, uint* base, Vector<int> offsets);

    /// svfloat32_t svld1_gather_[u32]offset[_f32](svbool_t pg, const float32_t *base, svuint32_t offsets) : "LD1W Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW]"
  public static unsafe Vector<float> GatherVector(Vector<float> mask, float* base, Vector<uint> offsets);

    /// svint32_t svld1_gather_[u32]offset[_s32](svbool_t pg, const int32_t *base, svuint32_t offsets) : "LD1W Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW]"
  public static unsafe Vector<int> GatherVector(Vector<int> mask, int* base, Vector<uint> offsets);

    /// svuint32_t svld1_gather_[u32]offset[_u32](svbool_t pg, const uint32_t *base, svuint32_t offsets) : "LD1W Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW]"
  public static unsafe Vector<uint> GatherVector(Vector<uint> mask, uint* base, Vector<uint> offsets);

    /// svfloat64_t svld1_gather_[s64]offset[_f64](svbool_t pg, const float64_t *base, svint64_t offsets) : "LD1D Zresult.D, Pg/Z, [Xbase, Zoffsets.D]"
  public static unsafe Vector<double> GatherVector(Vector<double> mask, double* base, Vector<long> offsets);

    /// svint64_t svld1_gather_[s64]offset[_s64](svbool_t pg, const int64_t *base, svint64_t offsets) : "LD1D Zresult.D, Pg/Z, [Xbase, Zoffsets.D]"
  public static unsafe Vector<long> GatherVector(Vector<long> mask, long* base, Vector<long> offsets);

    /// svuint64_t svld1_gather_[s64]offset[_u64](svbool_t pg, const uint64_t *base, svint64_t offsets) : "LD1D Zresult.D, Pg/Z, [Xbase, Zoffsets.D]"
  public static unsafe Vector<ulong> GatherVector(Vector<ulong> mask, ulong* base, Vector<long> offsets);

    /// svfloat64_t svld1_gather_[u64]offset[_f64](svbool_t pg, const float64_t *base, svuint64_t offsets) : "LD1D Zresult.D, Pg/Z, [Xbase, Zoffsets.D]"
  public static unsafe Vector<double> GatherVector(Vector<double> mask, double* base, Vector<ulong> offsets);

    /// svint64_t svld1_gather_[u64]offset[_s64](svbool_t pg, const int64_t *base, svuint64_t offsets) : "LD1D Zresult.D, Pg/Z, [Xbase, Zoffsets.D]"
  public static unsafe Vector<long> GatherVector(Vector<long> mask, long* base, Vector<ulong> offsets);

    /// svuint64_t svld1_gather_[u64]offset[_u64](svbool_t pg, const uint64_t *base, svuint64_t offsets) : "LD1D Zresult.D, Pg/Z, [Xbase, Zoffsets.D]"
  public static unsafe Vector<ulong> GatherVector(Vector<ulong> mask, ulong* base, Vector<ulong> offsets);

    /// svfloat32_t svld1_gather_[s32]index[_f32](svbool_t pg, const float32_t *base, svint32_t indices) : "LD1W Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #2]"
  public static unsafe Vector<float> GatherVector(Vector<float> mask, float* base, Vector<int> indices);

    /// svint32_t svld1_gather_[s32]index[_s32](svbool_t pg, const int32_t *base, svint32_t indices) : "LD1W Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #2]"
  public static unsafe Vector<int> GatherVector(Vector<int> mask, int* base, Vector<int> indices);

    /// svuint32_t svld1_gather_[s32]index[_u32](svbool_t pg, const uint32_t *base, svint32_t indices) : "LD1W Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #2]"
  public static unsafe Vector<uint> GatherVector(Vector<uint> mask, uint* base, Vector<int> indices);

    /// svfloat32_t svld1_gather_[u32]index[_f32](svbool_t pg, const float32_t *base, svuint32_t indices) : "LD1W Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #2]"
  public static unsafe Vector<float> GatherVector(Vector<float> mask, float* base, Vector<uint> indices);

    /// svint32_t svld1_gather_[u32]index[_s32](svbool_t pg, const int32_t *base, svuint32_t indices) : "LD1W Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #2]"
  public static unsafe Vector<int> GatherVector(Vector<int> mask, int* base, Vector<uint> indices);

    /// svuint32_t svld1_gather_[u32]index[_u32](svbool_t pg, const uint32_t *base, svuint32_t indices) : "LD1W Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #2]"
  public static unsafe Vector<uint> GatherVector(Vector<uint> mask, uint* base, Vector<uint> indices);

    /// svfloat64_t svld1_gather_[s64]index[_f64](svbool_t pg, const float64_t *base, svint64_t indices) : "LD1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3]"
  public static unsafe Vector<double> GatherVector(Vector<double> mask, double* base, Vector<long> indices);

    /// svint64_t svld1_gather_[s64]index[_s64](svbool_t pg, const int64_t *base, svint64_t indices) : "LD1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3]"
  public static unsafe Vector<long> GatherVector(Vector<long> mask, long* base, Vector<long> indices);

    /// svuint64_t svld1_gather_[s64]index[_u64](svbool_t pg, const uint64_t *base, svint64_t indices) : "LD1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3]"
  public static unsafe Vector<ulong> GatherVector(Vector<ulong> mask, ulong* base, Vector<long> indices);

    /// svfloat64_t svld1_gather_[u64]index[_f64](svbool_t pg, const float64_t *base, svuint64_t indices) : "LD1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3]"
  public static unsafe Vector<double> GatherVector(Vector<double> mask, double* base, Vector<ulong> indices);

    /// svint64_t svld1_gather_[u64]index[_s64](svbool_t pg, const int64_t *base, svuint64_t indices) : "LD1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3]"
  public static unsafe Vector<long> GatherVector(Vector<long> mask, long* base, Vector<ulong> indices);

    /// svuint64_t svld1_gather_[u64]index[_u64](svbool_t pg, const uint64_t *base, svuint64_t indices) : "LD1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3]"
  public static unsafe Vector<ulong> GatherVector(Vector<ulong> mask, ulong* base, Vector<ulong> indices);

    /// svfloat32_t svld1_gather[_u32base]_offset_f32(svbool_t pg, svuint32_t bases, int64_t offset) : "LD1W Zresult.S, Pg/Z, [Zbases.S, #offset]" or "LD1W Zresult.S, Pg/Z, [Xoffset, Zbases.S, UXTW]"
  public static unsafe Vector<float> GatherVector(Vector<float> mask, Vector<uint> bases, long offset);

    /// svint32_t svld1_gather[_u32base]_offset_s32(svbool_t pg, svuint32_t bases, int64_t offset) : "LD1W Zresult.S, Pg/Z, [Zbases.S, #offset]" or "LD1W Zresult.S, Pg/Z, [Xoffset, Zbases.S, UXTW]"
  public static unsafe Vector<int> GatherVector(Vector<int> mask, Vector<uint> bases, long offset);

    /// svuint32_t svld1_gather[_u32base]_offset_u32(svbool_t pg, svuint32_t bases, int64_t offset) : "LD1W Zresult.S, Pg/Z, [Zbases.S, #offset]" or "LD1W Zresult.S, Pg/Z, [Xoffset, Zbases.S, UXTW]"
  public static unsafe Vector<uint> GatherVector(Vector<uint> mask, Vector<uint> bases, long offset);

    /// svfloat64_t svld1_gather[_u64base]_offset_f64(svbool_t pg, svuint64_t bases, int64_t offset) : "LD1D Zresult.D, Pg/Z, [Zbases.D, #offset]" or "LD1D Zresult.D, Pg/Z, [Xoffset, Zbases.D]"
  public static unsafe Vector<double> GatherVector(Vector<double> mask, Vector<ulong> bases, long offset);

    /// svint64_t svld1_gather[_u64base]_offset_s64(svbool_t pg, svuint64_t bases, int64_t offset) : "LD1D Zresult.D, Pg/Z, [Zbases.D, #offset]" or "LD1D Zresult.D, Pg/Z, [Xoffset, Zbases.D]"
  public static unsafe Vector<long> GatherVector(Vector<long> mask, Vector<ulong> bases, long offset);

    /// svuint64_t svld1_gather[_u64base]_offset_u64(svbool_t pg, svuint64_t bases, int64_t offset) : "LD1D Zresult.D, Pg/Z, [Zbases.D, #offset]" or "LD1D Zresult.D, Pg/Z, [Xoffset, Zbases.D]"
  public static unsafe Vector<ulong> GatherVector(Vector<ulong> mask, Vector<ulong> bases, long offset);

    /// svfloat32_t svld1_gather[_u32base]_index_f32(svbool_t pg, svuint32_t bases, int64_t index) : "LD1W Zresult.S, Pg/Z, [Zbases.S, #index * 4]" or "LD1W Zresult.S, Pg/Z, [Xoffset, Zbases.S, UXTW]"
  public static unsafe Vector<float> GatherVector(Vector<float> mask, Vector<uint> bases, long index);

    /// svint32_t svld1_gather[_u32base]_index_s32(svbool_t pg, svuint32_t bases, int64_t index) : "LD1W Zresult.S, Pg/Z, [Zbases.S, #index * 4]" or "LD1W Zresult.S, Pg/Z, [Xoffset, Zbases.S, UXTW]"
  public static unsafe Vector<int> GatherVector(Vector<int> mask, Vector<uint> bases, long index);

    /// svuint32_t svld1_gather[_u32base]_index_u32(svbool_t pg, svuint32_t bases, int64_t index) : "LD1W Zresult.S, Pg/Z, [Zbases.S, #index * 4]" or "LD1W Zresult.S, Pg/Z, [Xoffset, Zbases.S, UXTW]"
  public static unsafe Vector<uint> GatherVector(Vector<uint> mask, Vector<uint> bases, long index);

    /// svfloat64_t svld1_gather[_u64base]_index_f64(svbool_t pg, svuint64_t bases, int64_t index) : "LD1D Zresult.D, Pg/Z, [Zbases.D, #index * 8]" or "LD1D Zresult.D, Pg/Z, [Xoffset, Zbases.D]"
  public static unsafe Vector<double> GatherVector(Vector<double> mask, Vector<ulong> bases, long index);

    /// svint64_t svld1_gather[_u64base]_index_s64(svbool_t pg, svuint64_t bases, int64_t index) : "LD1D Zresult.D, Pg/Z, [Zbases.D, #index * 8]" or "LD1D Zresult.D, Pg/Z, [Xoffset, Zbases.D]"
  public static unsafe Vector<long> GatherVector(Vector<long> mask, Vector<ulong> bases, long index);

    /// svuint64_t svld1_gather[_u64base]_index_u64(svbool_t pg, svuint64_t bases, int64_t index) : "LD1D Zresult.D, Pg/Z, [Zbases.D, #index * 8]" or "LD1D Zresult.D, Pg/Z, [Xoffset, Zbases.D]"
  public static unsafe Vector<ulong> GatherVector(Vector<ulong> mask, Vector<ulong> bases, long index);

    /// GatherVectorByteZeroExtend : Load 8-bit data and zero-extend

    /// svint32_t svld1ub_gather[_u32base]_s32(svbool_t pg, svuint32_t bases) : "LD1B Zresult.S, Pg/Z, [Zbases.S, #0]"
  public static unsafe Vector<int> GatherVectorByteZeroExtend(Vector<int> mask, Vector<uint> bases);

    /// svuint32_t svld1ub_gather[_u32base]_u32(svbool_t pg, svuint32_t bases) : "LD1B Zresult.S, Pg/Z, [Zbases.S, #0]"
  public static unsafe Vector<uint> GatherVectorByteZeroExtend(Vector<uint> mask, Vector<uint> bases);

    /// svint64_t svld1ub_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) : "LD1B Zresult.D, Pg/Z, [Zbases.D, #0]"
  public static unsafe Vector<long> GatherVectorByteZeroExtend(Vector<long> mask, Vector<ulong> bases);

    /// svuint64_t svld1ub_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) : "LD1B Zresult.D, Pg/Z, [Zbases.D, #0]"
  public static unsafe Vector<ulong> GatherVectorByteZeroExtend(Vector<ulong> mask, Vector<ulong> bases);

    /// svint32_t svld1ub_gather_[s32]offset_s32(svbool_t pg, const uint8_t *base, svint32_t offsets) : "LD1B Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW]"
  public static unsafe Vector<int> GatherVectorByteZeroExtend(Vector<int> mask, byte* base, Vector<int> offsets);

    /// svuint32_t svld1ub_gather_[s32]offset_u32(svbool_t pg, const uint8_t *base, svint32_t offsets) : "LD1B Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW]"
  public static unsafe Vector<uint> GatherVectorByteZeroExtend(Vector<uint> mask, byte* base, Vector<int> offsets);

    /// svint32_t svld1ub_gather_[u32]offset_s32(svbool_t pg, const uint8_t *base, svuint32_t offsets) : "LD1B Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW]"
  public static unsafe Vector<int> GatherVectorByteZeroExtend(Vector<int> mask, byte* base, Vector<uint> offsets);

    /// svuint32_t svld1ub_gather_[u32]offset_u32(svbool_t pg, const uint8_t *base, svuint32_t offsets) : "LD1B Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW]"
  public static unsafe Vector<uint> GatherVectorByteZeroExtend(Vector<uint> mask, byte* base, Vector<uint> offsets);

    /// svint64_t svld1ub_gather_[s64]offset_s64(svbool_t pg, const uint8_t *base, svint64_t offsets) : "LD1B Zresult.D, Pg/Z, [Xbase, Zoffsets.D]"
  public static unsafe Vector<long> GatherVectorByteZeroExtend(Vector<long> mask, byte* base, Vector<long> offsets);

    /// svuint64_t svld1ub_gather_[s64]offset_u64(svbool_t pg, const uint8_t *base, svint64_t offsets) : "LD1B Zresult.D, Pg/Z, [Xbase, Zoffsets.D]"
  public static unsafe Vector<ulong> GatherVectorByteZeroExtend(Vector<ulong> mask, byte* base, Vector<long> offsets);

    /// svint64_t svld1ub_gather_[u64]offset_s64(svbool_t pg, const uint8_t *base, svuint64_t offsets) : "LD1B Zresult.D, Pg/Z, [Xbase, Zoffsets.D]"
  public static unsafe Vector<long> GatherVectorByteZeroExtend(Vector<long> mask, byte* base, Vector<ulong> offsets);

    /// svuint64_t svld1ub_gather_[u64]offset_u64(svbool_t pg, const uint8_t *base, svuint64_t offsets) : "LD1B Zresult.D, Pg/Z, [Xbase, Zoffsets.D]"
  public static unsafe Vector<ulong> GatherVectorByteZeroExtend(Vector<ulong> mask, byte* base, Vector<ulong> offsets);

    /// svint32_t svld1ub_gather[_u32base]_offset_s32(svbool_t pg, svuint32_t bases, int64_t offset) : "LD1B Zresult.S, Pg/Z, [Zbases.S, #offset]" or "LD1B Zresult.S, Pg/Z, [Xoffset, Zbases.S, UXTW]"
  public static unsafe Vector<int> GatherVectorByteZeroExtend(Vector<int> mask, Vector<uint> bases, long offset);

    /// svuint32_t svld1ub_gather[_u32base]_offset_u32(svbool_t pg, svuint32_t bases, int64_t offset) : "LD1B Zresult.S, Pg/Z, [Zbases.S, #offset]" or "LD1B Zresult.S, Pg/Z, [Xoffset, Zbases.S, UXTW]"
  public static unsafe Vector<uint> GatherVectorByteZeroExtend(Vector<uint> mask, Vector<uint> bases, long offset);

    /// svint64_t svld1ub_gather[_u64base]_offset_s64(svbool_t pg, svuint64_t bases, int64_t offset) : "LD1B Zresult.D, Pg/Z, [Zbases.D, #offset]" or "LD1B Zresult.D, Pg/Z, [Xoffset, Zbases.D]"
  public static unsafe Vector<long> GatherVectorByteZeroExtend(Vector<long> mask, Vector<ulong> bases, long offset);

    /// svuint64_t svld1ub_gather[_u64base]_offset_u64(svbool_t pg, svuint64_t bases, int64_t offset) : "LD1B Zresult.D, Pg/Z, [Zbases.D, #offset]" or "LD1B Zresult.D, Pg/Z, [Xoffset, Zbases.D]"
  public static unsafe Vector<ulong> GatherVectorByteZeroExtend(Vector<ulong> mask, Vector<ulong> bases, long offset);

    /// GatherVectorInt16SignExtend : Load 16-bit data and sign-extend

    /// svint32_t svld1sh_gather[_u32base]_s32(svbool_t pg, svuint32_t bases) : "LD1SH Zresult.S, Pg/Z, [Zbases.S, #0]"
  public static unsafe Vector<int> GatherVectorInt16SignExtend(Vector<int> mask, Vector<uint> bases);

    /// svuint32_t svld1sh_gather[_u32base]_u32(svbool_t pg, svuint32_t bases) : "LD1SH Zresult.S, Pg/Z, [Zbases.S, #0]"
  public static unsafe Vector<uint> GatherVectorInt16SignExtend(Vector<uint> mask, Vector<uint> bases);

    /// svint64_t svld1sh_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) : "LD1SH Zresult.D, Pg/Z, [Zbases.D, #0]"
  public static unsafe Vector<long> GatherVectorInt16SignExtend(Vector<long> mask, Vector<ulong> bases);

    /// svuint64_t svld1sh_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) : "LD1SH Zresult.D, Pg/Z, [Zbases.D, #0]"
  public static unsafe Vector<ulong> GatherVectorInt16SignExtend(Vector<ulong> mask, Vector<ulong> bases);

    /// svint32_t svld1sh_gather_[s32]offset_s32(svbool_t pg, const int16_t *base, svint32_t offsets) : "LD1SH Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW]"
  public static unsafe Vector<int> GatherVectorInt16SignExtend(Vector<int> mask, short* base, Vector<int> offsets);

    /// svuint32_t svld1sh_gather_[s32]offset_u32(svbool_t pg, const int16_t *base, svint32_t offsets) : "LD1SH Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW]"
  public static unsafe Vector<uint> GatherVectorInt16SignExtend(Vector<uint> mask, short* base, Vector<int> offsets);

    /// svint32_t svld1sh_gather_[u32]offset_s32(svbool_t pg, const int16_t *base, svuint32_t offsets) : "LD1SH Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW]"
  public static unsafe Vector<int> GatherVectorInt16SignExtend(Vector<int> mask, short* base, Vector<uint> offsets);

    /// svuint32_t svld1sh_gather_[u32]offset_u32(svbool_t pg, const int16_t *base, svuint32_t offsets) : "LD1SH Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW]"
  public static unsafe Vector<uint> GatherVectorInt16SignExtend(Vector<uint> mask, short* base, Vector<uint> offsets);

    /// svint64_t svld1sh_gather_[s64]offset_s64(svbool_t pg, const int16_t *base, svint64_t offsets) : "LD1SH Zresult.D, Pg/Z, [Xbase, Zoffsets.D]"
  public static unsafe Vector<long> GatherVectorInt16SignExtend(Vector<long> mask, short* base, Vector<long> offsets);

    /// svuint64_t svld1sh_gather_[s64]offset_u64(svbool_t pg, const int16_t *base, svint64_t offsets) : "LD1SH Zresult.D, Pg/Z, [Xbase, Zoffsets.D]"
  public static unsafe Vector<ulong> GatherVectorInt16SignExtend(Vector<ulong> mask, short* base, Vector<long> offsets);

    /// svint64_t svld1sh_gather_[u64]offset_s64(svbool_t pg, const int16_t *base, svuint64_t offsets) : "LD1SH Zresult.D, Pg/Z, [Xbase, Zoffsets.D]"
  public static unsafe Vector<long> GatherVectorInt16SignExtend(Vector<long> mask, short* base, Vector<ulong> offsets);

    /// svuint64_t svld1sh_gather_[u64]offset_u64(svbool_t pg, const int16_t *base, svuint64_t offsets) : "LD1SH Zresult.D, Pg/Z, [Xbase, Zoffsets.D]"
  public static unsafe Vector<ulong> GatherVectorInt16SignExtend(Vector<ulong> mask, short* base, Vector<ulong> offsets);

    /// svint32_t svld1sh_gather_[s32]index_s32(svbool_t pg, const int16_t *base, svint32_t indices) : "LD1SH Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #1]"
  public static unsafe Vector<int> GatherVectorInt16SignExtend(Vector<int> mask, short* base, Vector<int> indices);

    /// svuint32_t svld1sh_gather_[s32]index_u32(svbool_t pg, const int16_t *base, svint32_t indices) : "LD1SH Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #1]"
  public static unsafe Vector<uint> GatherVectorInt16SignExtend(Vector<uint> mask, short* base, Vector<int> indices);

    /// svint32_t svld1sh_gather_[u32]index_s32(svbool_t pg, const int16_t *base, svuint32_t indices) : "LD1SH Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #1]"
  public static unsafe Vector<int> GatherVectorInt16SignExtend(Vector<int> mask, short* base, Vector<uint> indices);

    /// svuint32_t svld1sh_gather_[u32]index_u32(svbool_t pg, const int16_t *base, svuint32_t indices) : "LD1SH Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #1]"
  public static unsafe Vector<uint> GatherVectorInt16SignExtend(Vector<uint> mask, short* base, Vector<uint> indices);

    /// svint64_t svld1sh_gather_[s64]index_s64(svbool_t pg, const int16_t *base, svint64_t indices) : "LD1SH Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1]"
  public static unsafe Vector<long> GatherVectorInt16SignExtend(Vector<long> mask, short* base, Vector<long> indices);

    /// svuint64_t svld1sh_gather_[s64]index_u64(svbool_t pg, const int16_t *base, svint64_t indices) : "LD1SH Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1]"
  public static unsafe Vector<ulong> GatherVectorInt16SignExtend(Vector<ulong> mask, short* base, Vector<long> indices);

    /// svint64_t svld1sh_gather_[u64]index_s64(svbool_t pg, const int16_t *base, svuint64_t indices) : "LD1SH Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1]"
  public static unsafe Vector<long> GatherVectorInt16SignExtend(Vector<long> mask, short* base, Vector<ulong> indices);

    /// svuint64_t svld1sh_gather_[u64]index_u64(svbool_t pg, const int16_t *base, svuint64_t indices) : "LD1SH Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1]"
  public static unsafe Vector<ulong> GatherVectorInt16SignExtend(Vector<ulong> mask, short* base, Vector<ulong> indices);

    /// svint32_t svld1sh_gather[_u32base]_offset_s32(svbool_t pg, svuint32_t bases, int64_t offset) : "LD1SH Zresult.S, Pg/Z, [Zbases.S, #offset]" or "LD1SH Zresult.S, Pg/Z, [Xoffset, Zbases.S, UXTW]"
  public static unsafe Vector<int> GatherVectorInt16SignExtend(Vector<int> mask, Vector<uint> bases, long offset);

    /// svuint32_t svld1sh_gather[_u32base]_offset_u32(svbool_t pg, svuint32_t bases, int64_t offset) : "LD1SH Zresult.S, Pg/Z, [Zbases.S, #offset]" or "LD1SH Zresult.S, Pg/Z, [Xoffset, Zbases.S, UXTW]"
  public static unsafe Vector<uint> GatherVectorInt16SignExtend(Vector<uint> mask, Vector<uint> bases, long offset);

    /// svint64_t svld1sh_gather[_u64base]_offset_s64(svbool_t pg, svuint64_t bases, int64_t offset) : "LD1SH Zresult.D, Pg/Z, [Zbases.D, #offset]" or "LD1SH Zresult.D, Pg/Z, [Xoffset, Zbases.D]"
  public static unsafe Vector<long> GatherVectorInt16SignExtend(Vector<long> mask, Vector<ulong> bases, long offset);

    /// svuint64_t svld1sh_gather[_u64base]_offset_u64(svbool_t pg, svuint64_t bases, int64_t offset) : "LD1SH Zresult.D, Pg/Z, [Zbases.D, #offset]" or "LD1SH Zresult.D, Pg/Z, [Xoffset, Zbases.D]"
  public static unsafe Vector<ulong> GatherVectorInt16SignExtend(Vector<ulong> mask, Vector<ulong> bases, long offset);

    /// svint32_t svld1sh_gather[_u32base]_index_s32(svbool_t pg, svuint32_t bases, int64_t index) : "LD1SH Zresult.S, Pg/Z, [Zbases.S, #index * 2]" or "LD1SH Zresult.S, Pg/Z, [Xoffset, Zbases.S, UXTW]"
  public static unsafe Vector<int> GatherVectorInt16SignExtend(Vector<int> mask, Vector<uint> bases, long index);

    /// svuint32_t svld1sh_gather[_u32base]_index_u32(svbool_t pg, svuint32_t bases, int64_t index) : "LD1SH Zresult.S, Pg/Z, [Zbases.S, #index * 2]" or "LD1SH Zresult.S, Pg/Z, [Xoffset, Zbases.S, UXTW]"
  public static unsafe Vector<uint> GatherVectorInt16SignExtend(Vector<uint> mask, Vector<uint> bases, long index);

    /// svint64_t svld1sh_gather[_u64base]_index_s64(svbool_t pg, svuint64_t bases, int64_t index) : "LD1SH Zresult.D, Pg/Z, [Zbases.D, #index * 2]" or "LD1SH Zresult.D, Pg/Z, [Xoffset, Zbases.D]"
  public static unsafe Vector<long> GatherVectorInt16SignExtend(Vector<long> mask, Vector<ulong> bases, long index);

    /// svuint64_t svld1sh_gather[_u64base]_index_u64(svbool_t pg, svuint64_t bases, int64_t index) : "LD1SH Zresult.D, Pg/Z, [Zbases.D, #index * 2]" or "LD1SH Zresult.D, Pg/Z, [Xoffset, Zbases.D]"
  public static unsafe Vector<ulong> GatherVectorInt16SignExtend(Vector<ulong> mask, Vector<ulong> bases, long index);

    /// GatherVectorInt16ZeroExtend : Load 16-bit data and zero-extend

    /// svint32_t svld1uh_gather[_u32base]_s32(svbool_t pg, svuint32_t bases) : "LD1H Zresult.S, Pg/Z, [Zbases.S, #0]"
  public static unsafe Vector<int> GatherVectorInt16ZeroExtend(Vector<int> mask, Vector<uint> bases);

    /// svuint32_t svld1uh_gather[_u32base]_u32(svbool_t pg, svuint32_t bases) : "LD1H Zresult.S, Pg/Z, [Zbases.S, #0]"
  public static unsafe Vector<uint> GatherVectorInt16ZeroExtend(Vector<uint> mask, Vector<uint> bases);

    /// svint64_t svld1uh_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) : "LD1H Zresult.D, Pg/Z, [Zbases.D, #0]"
  public static unsafe Vector<long> GatherVectorInt16ZeroExtend(Vector<long> mask, Vector<ulong> bases);

    /// svuint64_t svld1uh_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) : "LD1H Zresult.D, Pg/Z, [Zbases.D, #0]"
  public static unsafe Vector<ulong> GatherVectorInt16ZeroExtend(Vector<ulong> mask, Vector<ulong> bases);

    /// svint32_t svld1uh_gather_[s32]offset_s32(svbool_t pg, const uint16_t *base, svint32_t offsets) : "LD1H Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW]"
  public static unsafe Vector<int> GatherVectorInt16ZeroExtend(Vector<int> mask, ushort* base, Vector<int> offsets);

    /// svuint32_t svld1uh_gather_[s32]offset_u32(svbool_t pg, const uint16_t *base, svint32_t offsets) : "LD1H Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW]"
  public static unsafe Vector<uint> GatherVectorInt16ZeroExtend(Vector<uint> mask, ushort* base, Vector<int> offsets);

    /// svint32_t svld1uh_gather_[u32]offset_s32(svbool_t pg, const uint16_t *base, svuint32_t offsets) : "LD1H Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW]"
  public static unsafe Vector<int> GatherVectorInt16ZeroExtend(Vector<int> mask, ushort* base, Vector<uint> offsets);

    /// svuint32_t svld1uh_gather_[u32]offset_u32(svbool_t pg, const uint16_t *base, svuint32_t offsets) : "LD1H Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW]"
  public static unsafe Vector<uint> GatherVectorInt16ZeroExtend(Vector<uint> mask, ushort* base, Vector<uint> offsets);

    /// svint64_t svld1uh_gather_[s64]offset_s64(svbool_t pg, const uint16_t *base, svint64_t offsets) : "LD1H Zresult.D, Pg/Z, [Xbase, Zoffsets.D]"
  public static unsafe Vector<long> GatherVectorInt16ZeroExtend(Vector<long> mask, ushort* base, Vector<long> offsets);

    /// svuint64_t svld1uh_gather_[s64]offset_u64(svbool_t pg, const uint16_t *base, svint64_t offsets) : "LD1H Zresult.D, Pg/Z, [Xbase, Zoffsets.D]"
  public static unsafe Vector<ulong> GatherVectorInt16ZeroExtend(Vector<ulong> mask, ushort* base, Vector<long> offsets);

    /// svint64_t svld1uh_gather_[u64]offset_s64(svbool_t pg, const uint16_t *base, svuint64_t offsets) : "LD1H Zresult.D, Pg/Z, [Xbase, Zoffsets.D]"
  public static unsafe Vector<long> GatherVectorInt16ZeroExtend(Vector<long> mask, ushort* base, Vector<ulong> offsets);

    /// svuint64_t svld1uh_gather_[u64]offset_u64(svbool_t pg, const uint16_t *base, svuint64_t offsets) : "LD1H Zresult.D, Pg/Z, [Xbase, Zoffsets.D]"
  public static unsafe Vector<ulong> GatherVectorInt16ZeroExtend(Vector<ulong> mask, ushort* base, Vector<ulong> offsets);

    /// svint32_t svld1uh_gather_[s32]index_s32(svbool_t pg, const uint16_t *base, svint32_t indices) : "LD1H Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #1]"
  public static unsafe Vector<int> GatherVectorInt16ZeroExtend(Vector<int> mask, ushort* base, Vector<int> indices);

    /// svuint32_t svld1uh_gather_[s32]index_u32(svbool_t pg, const uint16_t *base, svint32_t indices) : "LD1H Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #1]"
  public static unsafe Vector<uint> GatherVectorInt16ZeroExtend(Vector<uint> mask, ushort* base, Vector<int> indices);

    /// svint32_t svld1uh_gather_[u32]index_s32(svbool_t pg, const uint16_t *base, svuint32_t indices) : "LD1H Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #1]"
  public static unsafe Vector<int> GatherVectorInt16ZeroExtend(Vector<int> mask, ushort* base, Vector<uint> indices);

    /// svuint32_t svld1uh_gather_[u32]index_u32(svbool_t pg, const uint16_t *base, svuint32_t indices) : "LD1H Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #1]"
  public static unsafe Vector<uint> GatherVectorInt16ZeroExtend(Vector<uint> mask, ushort* base, Vector<uint> indices);

    /// svint64_t svld1uh_gather_[s64]index_s64(svbool_t pg, const uint16_t *base, svint64_t indices) : "LD1H Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1]"
  public static unsafe Vector<long> GatherVectorInt16ZeroExtend(Vector<long> mask, ushort* base, Vector<long> indices);

    /// svuint64_t svld1uh_gather_[s64]index_u64(svbool_t pg, const uint16_t *base, svint64_t indices) : "LD1H Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1]"
  public static unsafe Vector<ulong> GatherVectorInt16ZeroExtend(Vector<ulong> mask, ushort* base, Vector<long> indices);

    /// svint64_t svld1uh_gather_[u64]index_s64(svbool_t pg, const uint16_t *base, svuint64_t indices) : "LD1H Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1]"
  public static unsafe Vector<long> GatherVectorInt16ZeroExtend(Vector<long> mask, ushort* base, Vector<ulong> indices);

    /// svuint64_t svld1uh_gather_[u64]index_u64(svbool_t pg, const uint16_t *base, svuint64_t indices) : "LD1H Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1]"
  public static unsafe Vector<ulong> GatherVectorInt16ZeroExtend(Vector<ulong> mask, ushort* base, Vector<ulong> indices);

    /// svint32_t svld1uh_gather[_u32base]_offset_s32(svbool_t pg, svuint32_t bases, int64_t offset) : "LD1H Zresult.S, Pg/Z, [Zbases.S, #offset]" or "LD1H Zresult.S, Pg/Z, [Xoffset, Zbases.S, UXTW]"
  public static unsafe Vector<int> GatherVectorInt16ZeroExtend(Vector<int> mask, Vector<uint> bases, long offset);

    /// svuint32_t svld1uh_gather[_u32base]_offset_u32(svbool_t pg, svuint32_t bases, int64_t offset) : "LD1H Zresult.S, Pg/Z, [Zbases.S, #offset]" or "LD1H Zresult.S, Pg/Z, [Xoffset, Zbases.S, UXTW]"
  public static unsafe Vector<uint> GatherVectorInt16ZeroExtend(Vector<uint> mask, Vector<uint> bases, long offset);

    /// svint64_t svld1uh_gather[_u64base]_offset_s64(svbool_t pg, svuint64_t bases, int64_t offset) : "LD1H Zresult.D, Pg/Z, [Zbases.D, #offset]" or "LD1H Zresult.D, Pg/Z, [Xoffset, Zbases.D]"
  public static unsafe Vector<long> GatherVectorInt16ZeroExtend(Vector<long> mask, Vector<ulong> bases, long offset);

    /// svuint64_t svld1uh_gather[_u64base]_offset_u64(svbool_t pg, svuint64_t bases, int64_t offset) : "LD1H Zresult.D, Pg/Z, [Zbases.D, #offset]" or "LD1H Zresult.D, Pg/Z, [Xoffset, Zbases.D]"
  public static unsafe Vector<ulong> GatherVectorInt16ZeroExtend(Vector<ulong> mask, Vector<ulong> bases, long offset);

    /// svint32_t svld1uh_gather[_u32base]_index_s32(svbool_t pg, svuint32_t bases, int64_t index) : "LD1H Zresult.S, Pg/Z, [Zbases.S, #index * 2]" or "LD1H Zresult.S, Pg/Z, [Xoffset, Zbases.S, UXTW]"
  public static unsafe Vector<int> GatherVectorInt16ZeroExtend(Vector<int> mask, Vector<uint> bases, long index);

    /// svuint32_t svld1uh_gather[_u32base]_index_u32(svbool_t pg, svuint32_t bases, int64_t index) : "LD1H Zresult.S, Pg/Z, [Zbases.S, #index * 2]" or "LD1H Zresult.S, Pg/Z, [Xoffset, Zbases.S, UXTW]"
  public static unsafe Vector<uint> GatherVectorInt16ZeroExtend(Vector<uint> mask, Vector<uint> bases, long index);

    /// svint64_t svld1uh_gather[_u64base]_index_s64(svbool_t pg, svuint64_t bases, int64_t index) : "LD1H Zresult.D, Pg/Z, [Zbases.D, #index * 2]" or "LD1H Zresult.D, Pg/Z, [Xoffset, Zbases.D]"
  public static unsafe Vector<long> GatherVectorInt16ZeroExtend(Vector<long> mask, Vector<ulong> bases, long index);

    /// svuint64_t svld1uh_gather[_u64base]_index_u64(svbool_t pg, svuint64_t bases, int64_t index) : "LD1H Zresult.D, Pg/Z, [Zbases.D, #index * 2]" or "LD1H Zresult.D, Pg/Z, [Xoffset, Zbases.D]"
  public static unsafe Vector<ulong> GatherVectorInt16ZeroExtend(Vector<ulong> mask, Vector<ulong> bases, long index);

    /// GatherVectorInt32SignExtend : Load 32-bit data and sign-extend

    /// svint64_t svld1sw_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) : "LD1SW Zresult.D, Pg/Z, [Zbases.D, #0]"
  public static unsafe Vector<long> GatherVectorInt32SignExtend(Vector<long> mask, Vector<ulong> bases);

    /// svuint64_t svld1sw_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) : "LD1SW Zresult.D, Pg/Z, [Zbases.D, #0]"
  public static unsafe Vector<ulong> GatherVectorInt32SignExtend(Vector<ulong> mask, Vector<ulong> bases);

    /// svint64_t svld1sw_gather_[s64]offset_s64(svbool_t pg, const int32_t *base, svint64_t offsets) : "LD1SW Zresult.D, Pg/Z, [Xbase, Zoffsets.D]"
  public static unsafe Vector<long> GatherVectorInt32SignExtend(Vector<long> mask, int* base, Vector<long> offsets);

    /// svuint64_t svld1sw_gather_[s64]offset_u64(svbool_t pg, const int32_t *base, svint64_t offsets) : "LD1SW Zresult.D, Pg/Z, [Xbase, Zoffsets.D]"
  public static unsafe Vector<ulong> GatherVectorInt32SignExtend(Vector<ulong> mask, int* base, Vector<long> offsets);

    /// svint64_t svld1sw_gather_[u64]offset_s64(svbool_t pg, const int32_t *base, svuint64_t offsets) : "LD1SW Zresult.D, Pg/Z, [Xbase, Zoffsets.D]"
  public static unsafe Vector<long> GatherVectorInt32SignExtend(Vector<long> mask, int* base, Vector<ulong> offsets);

    /// svuint64_t svld1sw_gather_[u64]offset_u64(svbool_t pg, const int32_t *base, svuint64_t offsets) : "LD1SW Zresult.D, Pg/Z, [Xbase, Zoffsets.D]"
  public static unsafe Vector<ulong> GatherVectorInt32SignExtend(Vector<ulong> mask, int* base, Vector<ulong> offsets);

    /// svint64_t svld1sw_gather_[s64]index_s64(svbool_t pg, const int32_t *base, svint64_t indices) : "LD1SW Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2]"
  public static unsafe Vector<long> GatherVectorInt32SignExtend(Vector<long> mask, int* base, Vector<long> indices);

    /// svuint64_t svld1sw_gather_[s64]index_u64(svbool_t pg, const int32_t *base, svint64_t indices) : "LD1SW Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2]"
  public static unsafe Vector<ulong> GatherVectorInt32SignExtend(Vector<ulong> mask, int* base, Vector<long> indices);

    /// svint64_t svld1sw_gather_[u64]index_s64(svbool_t pg, const int32_t *base, svuint64_t indices) : "LD1SW Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2]"
  public static unsafe Vector<long> GatherVectorInt32SignExtend(Vector<long> mask, int* base, Vector<ulong> indices);

    /// svuint64_t svld1sw_gather_[u64]index_u64(svbool_t pg, const int32_t *base, svuint64_t indices) : "LD1SW Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2]"
  public static unsafe Vector<ulong> GatherVectorInt32SignExtend(Vector<ulong> mask, int* base, Vector<ulong> indices);

    /// svint64_t svld1sw_gather[_u64base]_offset_s64(svbool_t pg, svuint64_t bases, int64_t offset) : "LD1SW Zresult.D, Pg/Z, [Zbases.D, #offset]" or "LD1SW Zresult.D, Pg/Z, [Xoffset, Zbases.D]"
  public static unsafe Vector<long> GatherVectorInt32SignExtend(Vector<long> mask, Vector<ulong> bases, long offset);

    /// svuint64_t svld1sw_gather[_u64base]_offset_u64(svbool_t pg, svuint64_t bases, int64_t offset) : "LD1SW Zresult.D, Pg/Z, [Zbases.D, #offset]" or "LD1SW Zresult.D, Pg/Z, [Xoffset, Zbases.D]"
  public static unsafe Vector<ulong> GatherVectorInt32SignExtend(Vector<ulong> mask, Vector<ulong> bases, long offset);

    /// svint64_t svld1sw_gather[_u64base]_index_s64(svbool_t pg, svuint64_t bases, int64_t index) : "LD1SW Zresult.D, Pg/Z, [Zbases.D, #index * 4]" or "LD1SW Zresult.D, Pg/Z, [Xoffset, Zbases.D]"
  public static unsafe Vector<long> GatherVectorInt32SignExtend(Vector<long> mask, Vector<ulong> bases, long index);

    /// svuint64_t svld1sw_gather[_u64base]_index_u64(svbool_t pg, svuint64_t bases, int64_t index) : "LD1SW Zresult.D, Pg/Z, [Zbases.D, #index * 4]" or "LD1SW Zresult.D, Pg/Z, [Xoffset, Zbases.D]"
  public static unsafe Vector<ulong> GatherVectorInt32SignExtend(Vector<ulong> mask, Vector<ulong> bases, long index);

    /// GatherVectorInt32ZeroExtend : Load 32-bit data and zero-extend

    /// svint64_t svld1uw_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) : "LD1W Zresult.D, Pg/Z, [Zbases.D, #0]"
  public static unsafe Vector<long> GatherVectorInt32ZeroExtend(Vector<long> mask, Vector<ulong> bases);

    /// svuint64_t svld1uw_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) : "LD1W Zresult.D, Pg/Z, [Zbases.D, #0]"
  public static unsafe Vector<ulong> GatherVectorInt32ZeroExtend(Vector<ulong> mask, Vector<ulong> bases);

    /// svint64_t svld1uw_gather_[s64]offset_s64(svbool_t pg, const uint32_t *base, svint64_t offsets) : "LD1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D]"
  public static unsafe Vector<long> GatherVectorInt32ZeroExtend(Vector<long> mask, uint* base, Vector<long> offsets);

    /// svuint64_t svld1uw_gather_[s64]offset_u64(svbool_t pg, const uint32_t *base, svint64_t offsets) : "LD1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D]"
  public static unsafe Vector<ulong> GatherVectorInt32ZeroExtend(Vector<ulong> mask, uint* base, Vector<long> offsets);

    /// svint64_t svld1uw_gather_[u64]offset_s64(svbool_t pg, const uint32_t *base, svuint64_t offsets) : "LD1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D]"
  public static unsafe Vector<long> GatherVectorInt32ZeroExtend(Vector<long> mask, uint* base, Vector<ulong> offsets);

    /// svuint64_t svld1uw_gather_[u64]offset_u64(svbool_t pg, const uint32_t *base, svuint64_t offsets) : "LD1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D]"
  public static unsafe Vector<ulong> GatherVectorInt32ZeroExtend(Vector<ulong> mask, uint* base, Vector<ulong> offsets);

    /// svint64_t svld1uw_gather_[s64]index_s64(svbool_t pg, const uint32_t *base, svint64_t indices) : "LD1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2]"
  public static unsafe Vector<long> GatherVectorInt32ZeroExtend(Vector<long> mask, uint* base, Vector<long> indices);

    /// svuint64_t svld1uw_gather_[s64]index_u64(svbool_t pg, const uint32_t *base, svint64_t indices) : "LD1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2]"
  public static unsafe Vector<ulong> GatherVectorInt32ZeroExtend(Vector<ulong> mask, uint* base, Vector<long> indices);

    /// svint64_t svld1uw_gather_[u64]index_s64(svbool_t pg, const uint32_t *base, svuint64_t indices) : "LD1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2]"
  public static unsafe Vector<long> GatherVectorInt32ZeroExtend(Vector<long> mask, uint* base, Vector<ulong> indices);

    /// svuint64_t svld1uw_gather_[u64]index_u64(svbool_t pg, const uint32_t *base, svuint64_t indices) : "LD1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2]"
  public static unsafe Vector<ulong> GatherVectorInt32ZeroExtend(Vector<ulong> mask, uint* base, Vector<ulong> indices);

    /// svint64_t svld1uw_gather[_u64base]_offset_s64(svbool_t pg, svuint64_t bases, int64_t offset) : "LD1W Zresult.D, Pg/Z, [Zbases.D, #offset]" or "LD1W Zresult.D, Pg/Z, [Xoffset, Zbases.D]"
  public static unsafe Vector<long> GatherVectorInt32ZeroExtend(Vector<long> mask, Vector<ulong> bases, long offset);

    /// svuint64_t svld1uw_gather[_u64base]_offset_u64(svbool_t pg, svuint64_t bases, int64_t offset) : "LD1W Zresult.D, Pg/Z, [Zbases.D, #offset]" or "LD1W Zresult.D, Pg/Z, [Xoffset, Zbases.D]"
  public static unsafe Vector<ulong> GatherVectorInt32ZeroExtend(Vector<ulong> mask, Vector<ulong> bases, long offset);

    /// svint64_t svld1uw_gather[_u64base]_index_s64(svbool_t pg, svuint64_t bases, int64_t index) : "LD1W Zresult.D, Pg/Z, [Zbases.D, #index * 4]" or "LD1W Zresult.D, Pg/Z, [Xoffset, Zbases.D]"
  public static unsafe Vector<long> GatherVectorInt32ZeroExtend(Vector<long> mask, Vector<ulong> bases, long index);

    /// svuint64_t svld1uw_gather[_u64base]_index_u64(svbool_t pg, svuint64_t bases, int64_t index) : "LD1W Zresult.D, Pg/Z, [Zbases.D, #index * 4]" or "LD1W Zresult.D, Pg/Z, [Xoffset, Zbases.D]"
  public static unsafe Vector<ulong> GatherVectorInt32ZeroExtend(Vector<ulong> mask, Vector<ulong> bases, long index);

    /// GatherVectorSByteSignExtend : Load 8-bit data and sign-extend

    /// svint32_t svld1sb_gather[_u32base]_s32(svbool_t pg, svuint32_t bases) : "LD1SB Zresult.S, Pg/Z, [Zbases.S, #0]"
  public static unsafe Vector<int> GatherVectorSByteSignExtend(Vector<int> mask, Vector<uint> bases);

    /// svuint32_t svld1sb_gather[_u32base]_u32(svbool_t pg, svuint32_t bases) : "LD1SB Zresult.S, Pg/Z, [Zbases.S, #0]"
  public static unsafe Vector<uint> GatherVectorSByteSignExtend(Vector<uint> mask, Vector<uint> bases);

    /// svint64_t svld1sb_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) : "LD1SB Zresult.D, Pg/Z, [Zbases.D, #0]"
  public static unsafe Vector<long> GatherVectorSByteSignExtend(Vector<long> mask, Vector<ulong> bases);

    /// svuint64_t svld1sb_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) : "LD1SB Zresult.D, Pg/Z, [Zbases.D, #0]"
  public static unsafe Vector<ulong> GatherVectorSByteSignExtend(Vector<ulong> mask, Vector<ulong> bases);

    /// svint32_t svld1sb_gather_[s32]offset_s32(svbool_t pg, const int8_t *base, svint32_t offsets) : "LD1SB Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW]"
  public static unsafe Vector<int> GatherVectorSByteSignExtend(Vector<int> mask, sbyte* base, Vector<int> offsets);

    /// svuint32_t svld1sb_gather_[s32]offset_u32(svbool_t pg, const int8_t *base, svint32_t offsets) : "LD1SB Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW]"
  public static unsafe Vector<uint> GatherVectorSByteSignExtend(Vector<uint> mask, sbyte* base, Vector<int> offsets);

    /// svint32_t svld1sb_gather_[u32]offset_s32(svbool_t pg, const int8_t *base, svuint32_t offsets) : "LD1SB Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW]"
  public static unsafe Vector<int> GatherVectorSByteSignExtend(Vector<int> mask, sbyte* base, Vector<uint> offsets);

    /// svuint32_t svld1sb_gather_[u32]offset_u32(svbool_t pg, const int8_t *base, svuint32_t offsets) : "LD1SB Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW]"
  public static unsafe Vector<uint> GatherVectorSByteSignExtend(Vector<uint> mask, sbyte* base, Vector<uint> offsets);

    /// svint64_t svld1sb_gather_[s64]offset_s64(svbool_t pg, const int8_t *base, svint64_t offsets) : "LD1SB Zresult.D, Pg/Z, [Xbase, Zoffsets.D]"
  public static unsafe Vector<long> GatherVectorSByteSignExtend(Vector<long> mask, sbyte* base, Vector<long> offsets);

    /// svuint64_t svld1sb_gather_[s64]offset_u64(svbool_t pg, const int8_t *base, svint64_t offsets) : "LD1SB Zresult.D, Pg/Z, [Xbase, Zoffsets.D]"
  public static unsafe Vector<ulong> GatherVectorSByteSignExtend(Vector<ulong> mask, sbyte* base, Vector<long> offsets);

    /// svint64_t svld1sb_gather_[u64]offset_s64(svbool_t pg, const int8_t *base, svuint64_t offsets) : "LD1SB Zresult.D, Pg/Z, [Xbase, Zoffsets.D]"
  public static unsafe Vector<long> GatherVectorSByteSignExtend(Vector<long> mask, sbyte* base, Vector<ulong> offsets);

    /// svuint64_t svld1sb_gather_[u64]offset_u64(svbool_t pg, const int8_t *base, svuint64_t offsets) : "LD1SB Zresult.D, Pg/Z, [Xbase, Zoffsets.D]"
  public static unsafe Vector<ulong> GatherVectorSByteSignExtend(Vector<ulong> mask, sbyte* base, Vector<ulong> offsets);

    /// svint32_t svld1sb_gather[_u32base]_offset_s32(svbool_t pg, svuint32_t bases, int64_t offset) : "LD1SB Zresult.S, Pg/Z, [Zbases.S, #offset]" or "LD1SB Zresult.S, Pg/Z, [Xoffset, Zbases.S, UXTW]"
  public static unsafe Vector<int> GatherVectorSByteSignExtend(Vector<int> mask, Vector<uint> bases, long offset);

    /// svuint32_t svld1sb_gather[_u32base]_offset_u32(svbool_t pg, svuint32_t bases, int64_t offset) : "LD1SB Zresult.S, Pg/Z, [Zbases.S, #offset]" or "LD1SB Zresult.S, Pg/Z, [Xoffset, Zbases.S, UXTW]"
  public static unsafe Vector<uint> GatherVectorSByteSignExtend(Vector<uint> mask, Vector<uint> bases, long offset);

    /// svint64_t svld1sb_gather[_u64base]_offset_s64(svbool_t pg, svuint64_t bases, int64_t offset) : "LD1SB Zresult.D, Pg/Z, [Zbases.D, #offset]" or "LD1SB Zresult.D, Pg/Z, [Xoffset, Zbases.D]"
  public static unsafe Vector<long> GatherVectorSByteSignExtend(Vector<long> mask, Vector<ulong> bases, long offset);

    /// svuint64_t svld1sb_gather[_u64base]_offset_u64(svbool_t pg, svuint64_t bases, int64_t offset) : "LD1SB Zresult.D, Pg/Z, [Zbases.D, #offset]" or "LD1SB Zresult.D, Pg/Z, [Xoffset, Zbases.D]"
  public static unsafe Vector<ulong> GatherVectorSByteSignExtend(Vector<ulong> mask, Vector<ulong> bases, long offset);

  /// total method signatures: 190
  /// total method names:      11
}

  /// Total ACLE covered across API:      190
a74nh commented 1 year ago 
/// Rejected:
/// None yet
a74nh commented 1 year ago

This contributes to https://github.com/dotnet/runtime/issues/93095

It covers instructions in FEAT_SVE related to gather loads.

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 https://github.com/dotnet/runtime/issues/88140 comment.

tannergooding commented 1 year ago

For xarch, we just use the term Gather, we don't specify it as GatherLoad. We could probably do the same here for simplicity.

Otherwise the same general comments apply as the main Load API.

ghost commented 1 year ago

This issue has been marked needs-author-action and may be missing some important information.

a74nh commented 1 year ago

For xarch, we just use the term Gather, we don't specify it as GatherLoad. We could probably do the same here for simplicity.

Done.

Otherwise the same general comments apply as the main Load API.

Done as these will have applied automatically.

terrajobst commented 9 months ago 
namespace System.Runtime.Intrinsics.Arm;

public enum SvePrefetchType
{
    LoadL1Temporal = 0,
    LoadL1NonTemporal = 1,
    LoadL2Temporal = 2,
    LoadL2NonTemporal = 3,
    LoadL3Temporal = 4,
    LoadL3NonTemporal = 5,
    StoreL1Temporal = 8,
    StoreL1NonTemporal = 9,
    StoreL2Temporal = 10,
    StoreL2NonTemporal = 11,
    StoreL3Temporal = 12,
    StoreL3NonTemporal = 13
};

public abstract partial class Sve : AdvSimd
{
  /// T: [byte, uint], [sbyte, uint], [byte, ulong], [sbyte, ulong]
  public static unsafe void GatherPrefetch8Bit(Vector<T> mask, Vector<T2> addresses, [ConstantExpected] SvePrefetchType prefetchType);

  /// T: [byte, int], [sbyte, int], [byte, uint], [sbyte, uint], [byte, long], [sbyte, long], [byte, ulong], [sbyte, ulong]
  public static unsafe void GatherPrefetch8Bit(Vector<T> mask, void* address, Vector<T2> offsets, [ConstantExpected] SvePrefetchType prefetchType);

  /// T: [short, uint], [ushort, uint], [short, ulong], [ushort, ulong]
  public static unsafe void GatherPrefetch16Bit(Vector<T> mask, Vector<T2> addresses, [ConstantExpected] SvePrefetchType prefetchType);

  /// T: [short, int], [ushort, int], [short, uint], [ushort, uint], [short, long], [ushort, long], [short, ulong], [ushort, ulong]
  public static unsafe void GatherPrefetch16Bit(Vector<T> mask, void* address, Vector<T2> indices, [ConstantExpected] SvePrefetchType prefetchType);

  /// T: [int, uint], [uint, uint], [int, ulong], [uint, ulong]
  public static unsafe void GatherPrefetch32Bit(Vector<T> mask, Vector<T2> addresses, [ConstantExpected] SvePrefetchType prefetchType);

  /// T: [int, int], [uint, int], [int, uint], [uint, uint], [int, long], [uint, long], [int, ulong], [uint, ulong]
  public static unsafe void GatherPrefetch32Bit(Vector<T> mask, void* address, Vector<T2> indices, [ConstantExpected] SvePrefetchType prefetchType);

  /// T: [long, uint], [ulong, uint], [long, ulong], [ulong, ulong]
  public static unsafe void GatherPrefetch64Bit(Vector<T> mask, Vector<T2> addresses, [ConstantExpected] SvePrefetchType prefetchType);

  /// T: [long, int], [ulong, int], [long, uint], [ulong, uint], [long, long], [ulong, long], [long, ulong], [ulong, ulong]
  public static unsafe void GatherPrefetch64Bit(Vector<T> mask, void* address, Vector<T2> indices, [ConstantExpected] SvePrefetchType prefetchType);

  /// T: [float, uint], [int, uint], [uint, uint], [double, ulong], [long, ulong], [ulong, ulong]
  public static unsafe Vector<T> GatherVector(Vector<T> mask, Vector<T2> addresses);

  /// T: [float, int], [int, int], [uint, int], [float, uint], [int, uint], [uint, uint], [double, long], [long, long], [ulong, long], [double, ulong], [long, ulong], [ulong, ulong]
  public static unsafe Vector<T> GatherVector(Vector<T> mask, T* address, Vector<T2> indices);

  /// T: [float, int], [int, int], [uint, int], [float, uint], [int, uint], [uint, uint], [double, long], [long, long], [ulong, long], [double, ulong], [long, ulong], [ulong, ulong]
  public static unsafe Vector<T> GatherVectorWithByteOffsets(Vector<T> mask, T* address, Vector<T2> offsets);

  /// T: [int, uint], [uint, uint], [long, ulong], [ulong, ulong]
  public static unsafe Vector<T> GatherVectorByteZeroExtend(Vector<T> mask, Vector<T2> addresses);

  /// T: [int, int], [uint, int], [int, uint], [uint, uint], [long, long], [ulong, long], [long, ulong], [ulong, ulong]
  public static unsafe Vector<T> GatherVectorByteZeroExtend(Vector<T> mask, byte* address, Vector<T2> indices);

  /// T: [int, uint], [uint, uint], [long, ulong], [ulong, ulong]
  public static unsafe Vector<T> GatherVectorInt16SignExtend(Vector<T> mask, Vector<T2> addresses);

  /// T: [int, int], [uint, int], [int, uint], [uint, uint], [long, long], [ulong, long], [long, ulong], [ulong, ulong]
  public static unsafe Vector<T> GatherVectorInt16SignExtend(Vector<T> mask, short* address, Vector<T2> indices);

  /// T: [int, int], [uint, int], [int, uint], [uint, uint], [long, long], [ulong, long], [long, ulong], [ulong, ulong]
  public static unsafe Vector<T> GatherVectorInt16WithByteOffsetsSignExtend(Vector<T> mask, short* address, Vector<T2> offsets);

  /// T: [int, uint], [uint, uint], [long, ulong], [ulong, ulong]
  public static unsafe Vector<T> GatherVectorUInt16ZeroExtend(Vector<T> mask, Vector<T2> addresses);

  /// T: [int, int], [uint, int], [int, uint], [uint, uint], [long, long], [ulong, long], [long, ulong], [ulong, ulong]
  public static unsafe Vector<T> GatherVectorUInt16ZeroExtend(Vector<T> mask, short* address, Vector<T2> indices);

  /// T: [int, int], [uint, int], [int, uint], [uint, uint], [long, long], [ulong, long], [long, ulong], [ulong, ulong]
  public static unsafe Vector<T> GatherVectorUInt16WithByteOffsetsZeroExtend(Vector<T> mask, short* address, Vector<T2> offsets);

  /// T: [int, uint], [uint, uint], [long, ulong], [ulong, ulong]
  public static unsafe Vector<T> GatherVectorInt32SignExtend(Vector<T> mask, Vector<T2> addresses);

  /// T: [int, int], [uint, int], [int, uint], [uint, uint], [long, long], [ulong, long], [long, ulong], [ulong, ulong]
  public static unsafe Vector<T> GatherVectorInt32SignExtend(Vector<T> mask, short* address, Vector<T2> indices);

  /// T: [int, int], [uint, int], [int, uint], [uint, uint], [long, long], [ulong, long], [long, ulong], [ulong, ulong]
  public static unsafe Vector<T> GatherVectorInt32WithByteOffsetsSignExtend(Vector<T> mask, short* address, Vector<T2> offsets);

  /// T: [int, uint], [uint, uint], [long, ulong], [ulong, ulong]
  public static unsafe Vector<T> GatherVectorUInt32ZeroExtend(Vector<T> mask, Vector<T2> addresses);

  /// T: [int, int], [uint, int], [int, uint], [uint, uint], [long, long], [ulong, long], [long, ulong], [ulong, ulong]
  public static unsafe Vector<T> GatherVectorUInt32ZeroExtend(Vector<T> mask, short* address, Vector<T2> indices);

  /// T: [int, int], [uint, int], [int, uint], [uint, uint], [long, long], [ulong, long], [long, ulong], [ulong, ulong]
  public static unsafe Vector<T> GatherVectorUInt32WithByteOffsetsZeroExtend(Vector<T> mask, short* address, Vector<T2> offsets);

  /// T: [int, uint], [uint, uint], [long, ulong], [ulong, ulong]
  public static unsafe Vector<T> GatherVectorSByteSignExtend(Vector<T> mask, Vector<T2> addresses);

  /// T: [int, int], [uint, int], [int, uint], [uint, uint], [long, long], [ulong, long], [long, ulong], [ulong, ulong]
  public static unsafe Vector<T> GatherVectorSByteSignExtend(Vector<T> mask, sbyte* address, Vector<T2> indices);
}
a74nh commented 9 months ago

  • SvePrefetchType should be a top-level type so it can be shared with later ISAs

    • The names should match .NET naming, for example, dropping the SV_ prefix and the names should be expanded, e.g. instead SV_PLDL1KEEP it would LoadL1Temporal and SV_PLDL1STRM would be LoadL1NonTemporal

  • GatherPrefetchInt64 and GatherPrefetch64Bit

    • We should remove all overloads that take long index because there is already a vector based index and we can use Vector.Create()
    • Some of the generic type arguments listed in the comments are wrong. @tannergooding will know which one ;-)

  • GatherVectorXxx

    • T* base should be T* address
    • Vector<T> bases should be Vector<T> addresses
    • If the last parameter is offsets should be named with a suffix like WithByteOffsets. For complex names, like GatherVectorByteZeroExtend that becomes an infix (GatherVectorByteWithByteOffsetsZeroExtend)
    • We should remove the long offset ones in favor of Vector.Create()
    • Consider if GatherVectorInt16SignExtend should be GatherVector16BitSignExtend (it seems like "no", but it came up)
    • GatherVectorInt16ZeroExtend and other ZeroExtend methods should say UInt16 (et al) not Int16

None of the changes mentioned here have been applied to the API shown below it. The API is just a copy/paste of the original API with no changes.

tannergooding commented 9 months ago

We should treat it as the actually discussed/approved surface. I will work on updating it here in a bit

ghost commented 8 months ago

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

Issue Details
```csharp namespace System.Runtime.Intrinsics.Arm; /// VectorT Summary public abstract partial class Sve : AdvSimd /// Feature: FEAT_SVE Category: gatherloads { /// T: [byte, uint], [byte, ulong] public static unsafe void GatherPrefetchBytes(Vector mask, Vector bases, [ConstantExpected] SvePrefetchType op); // PRFB /// T: [byte, int], [byte, uint], [byte, long], [byte, ulong] public static unsafe void GatherPrefetchBytes(Vector mask, void* base, Vector offsets, [ConstantExpected] SvePrefetchType op); // PRFB /// T: [byte, uint], [byte, ulong] public static unsafe void GatherPrefetchBytes(Vector mask, Vector bases, long offset, [ConstantExpected] SvePrefetchType op); // PRFB /// T: [ushort, uint], [ushort, ulong] public static unsafe void GatherPrefetchInt16(Vector mask, Vector bases, [ConstantExpected] SvePrefetchType op); // PRFH /// T: [ushort, int], [ushort, uint], [ushort, long], [ushort, ulong] public static unsafe void GatherPrefetchInt16(Vector mask, void* base, Vector indices, [ConstantExpected] SvePrefetchType op); // PRFH /// T: [ushort, uint], [ushort, ulong] public static unsafe void GatherPrefetchInt16(Vector mask, Vector bases, long index, [ConstantExpected] SvePrefetchType op); // PRFH or PRFB public static unsafe void GatherPrefetchInt32(Vector mask, Vector bases, [ConstantExpected] SvePrefetchType op); // PRFW public static unsafe void GatherPrefetchInt32(Vector mask, Vector bases, [ConstantExpected] SvePrefetchType op); // PRFW /// T: [uint, int], [uint, long], [uint, ulong] public static unsafe void GatherPrefetchInt32(Vector mask, void* base, Vector indices, [ConstantExpected] SvePrefetchType op); // PRFW public static unsafe void GatherPrefetchInt32(Vector mask, void* base, Vector indices, [ConstantExpected] SvePrefetchType op); // PRFW public static unsafe void GatherPrefetchInt32(Vector mask, Vector bases, long index, [ConstantExpected] SvePrefetchType op); // PRFW or PRFB public static unsafe void GatherPrefetchInt32(Vector mask, Vector bases, long index, [ConstantExpected] SvePrefetchType op); // PRFW or PRFB public static unsafe void GatherPrefetchInt64(Vector mask, Vector bases, [ConstantExpected] SvePrefetchType op); // PRFD public static unsafe void GatherPrefetchInt64(Vector mask, Vector bases, [ConstantExpected] SvePrefetchType op); // PRFD /// T: [ulong, int], [ulong, uint], [ulong, long] public static unsafe void GatherPrefetchInt64(Vector mask, void* base, Vector indices, [ConstantExpected] SvePrefetchType op); // PRFD public static unsafe void GatherPrefetchInt64(Vector mask, void* base, Vector indices, [ConstantExpected] SvePrefetchType op); // PRFD public static unsafe void GatherPrefetchInt64(Vector mask, Vector bases, long index, [ConstantExpected] SvePrefetchType op); // PRFD or PRFB public static unsafe void GatherPrefetchInt64(Vector mask, Vector bases, long index, [ConstantExpected] SvePrefetchType op); // PRFD or PRFB /// T: [float, uint], [int, uint], [double, ulong], [long, ulong] public static unsafe Vector GatherVector(Vector mask, Vector bases); // LD1W or LD1D /// T: uint, ulong public static unsafe Vector GatherVector(Vector mask, Vector bases); // LD1W or LD1D /// T: [float, int], [uint, int], [float, uint], [int, uint], [double, long], [ulong, long], [double, ulong], [long, ulong] public static unsafe Vector GatherVector(Vector mask, T* base, Vector offsets); // LD1W or LD1D /// T: int, uint, long, ulong public static unsafe Vector GatherVector(Vector mask, T* base, Vector offsets); // LD1W or LD1D /// T: [float, int], [uint, int], [float, uint], [int, uint], [double, long], [ulong, long], [double, ulong], [long, ulong] public static unsafe Vector GatherVector(Vector mask, T* base, Vector indices); // LD1W or LD1D /// T: int, uint, long, ulong public static unsafe Vector GatherVector(Vector mask, T* base, Vector indices); // LD1W or LD1D /// T: [float, uint], [int, uint], [double, ulong], [long, ulong] public static unsafe Vector GatherVector(Vector mask, Vector bases, long offset); // LD1W or LD1D /// T: uint, ulong public static unsafe Vector GatherVector(Vector mask, Vector bases, long offset); // LD1W or LD1D /// T: [float, uint], [int, uint], [double, ulong], [long, ulong] public static unsafe Vector GatherVector(Vector mask, Vector bases, long index); // LD1W or LD1D /// T: uint, ulong public static unsafe Vector GatherVector(Vector mask, Vector bases, long index); // LD1W or LD1D /// T: [int, uint], [long, ulong] public static unsafe Vector GatherVectorByteZeroExtend(Vector mask, Vector bases); // LD1B /// T: uint, ulong public static unsafe Vector GatherVectorByteZeroExtend(Vector mask, Vector bases); // LD1B /// T: int, uint, long, ulong public static unsafe Vector GatherVectorByteZeroExtend(Vector mask, byte* base, Vector offsets); // LD1B /// T: [uint, int], [int, uint], [ulong, long], [long, ulong] public static unsafe Vector GatherVectorByteZeroExtend(Vector mask, byte* base, Vector offsets); // LD1B /// T: [int, uint], [long, ulong] public static unsafe Vector GatherVectorByteZeroExtend(Vector mask, Vector bases, long offset); // LD1B /// T: uint, ulong public static unsafe Vector GatherVectorByteZeroExtend(Vector mask, Vector bases, long offset); // LD1B /// T: [int, uint], [long, ulong] public static unsafe Vector GatherVectorInt16SignExtend(Vector mask, Vector bases); // LD1SH /// T: uint, ulong public static unsafe Vector GatherVectorInt16SignExtend(Vector mask, Vector bases); // LD1SH /// T: int, uint, long, ulong public static unsafe Vector GatherVectorInt16SignExtend(Vector mask, short* base, Vector offsets); // LD1SH /// T: [uint, int], [int, uint], [ulong, long], [long, ulong] public static unsafe Vector GatherVectorInt16SignExtend(Vector mask, short* base, Vector offsets); // LD1SH /// T: int, uint, long, ulong public static unsafe Vector GatherVectorInt16SignExtend(Vector mask, short* base, Vector indices); // LD1SH /// T: [uint, int], [int, uint], [ulong, long], [long, ulong] public static unsafe Vector GatherVectorInt16SignExtend(Vector mask, short* base, Vector indices); // LD1SH /// T: [int, uint], [long, ulong] public static unsafe Vector GatherVectorInt16SignExtend(Vector mask, Vector bases, long offset); // LD1SH /// T: uint, ulong public static unsafe Vector GatherVectorInt16SignExtend(Vector mask, Vector bases, long offset); // LD1SH /// T: [int, uint], [long, ulong] public static unsafe Vector GatherVectorInt16SignExtend(Vector mask, Vector bases, long index); // LD1SH /// T: uint, ulong public static unsafe Vector GatherVectorInt16SignExtend(Vector mask, Vector bases, long index); // LD1SH /// T: [int, uint], [long, ulong] public static unsafe Vector GatherVectorInt16ZeroExtend(Vector mask, Vector bases); // LD1H /// T: uint, ulong public static unsafe Vector GatherVectorInt16ZeroExtend(Vector mask, Vector bases); // LD1H /// T: int, uint, long, ulong public static unsafe Vector GatherVectorInt16ZeroExtend(Vector mask, ushort* base, Vector offsets); // LD1H /// T: [uint, int], [int, uint], [ulong, long], [long, ulong] public static unsafe Vector GatherVectorInt16ZeroExtend(Vector mask, ushort* base, Vector offsets); // LD1H /// T: int, uint, long, ulong public static unsafe Vector GatherVectorInt16ZeroExtend(Vector mask, ushort* base, Vector indices); // LD1H /// T: [uint, int], [int, uint], [ulong, long], [long, ulong] public static unsafe Vector GatherVectorInt16ZeroExtend(Vector mask, ushort* base, Vector indices); // LD1H /// T: [int, uint], [long, ulong] public static unsafe Vector GatherVectorInt16ZeroExtend(Vector mask, Vector bases, long offset); // LD1H /// T: uint, ulong public static unsafe Vector GatherVectorInt16ZeroExtend(Vector mask, Vector bases, long offset); // LD1H /// T: [int, uint], [long, ulong] public static unsafe Vector GatherVectorInt16ZeroExtend(Vector mask, Vector bases, long index); // LD1H /// T: uint, ulong public static unsafe Vector GatherVectorInt16ZeroExtend(Vector mask, Vector bases, long index); // LD1H public static unsafe Vector GatherVectorInt32SignExtend(Vector mask, Vector bases); // LD1SW public static unsafe Vector GatherVectorInt32SignExtend(Vector mask, Vector bases); // LD1SW /// T: long, ulong public static unsafe Vector GatherVectorInt32SignExtend(Vector mask, int* base, Vector offsets); // LD1SW /// T: [ulong, long], [long, ulong] public static unsafe Vector GatherVectorInt32SignExtend(Vector mask, int* base, Vector offsets); // LD1SW /// T: long, ulong public static unsafe Vector GatherVectorInt32SignExtend(Vector mask, int* base, Vector indices); // LD1SW /// T: [ulong, long], [long, ulong] public static unsafe Vector GatherVectorInt32SignExtend(Vector mask, int* base, Vector indices); // LD1SW public static unsafe Vector GatherVectorInt32SignExtend(Vector mask, Vector bases, long offset); // LD1SW public static unsafe Vector GatherVectorInt32SignExtend(Vector mask, Vector bases, long offset); // LD1SW public static unsafe Vector GatherVectorInt32SignExtend(Vector mask, Vector bases, long index); // LD1SW public static unsafe Vector GatherVectorInt32SignExtend(Vector mask, Vector bases, long index); // LD1SW public static unsafe Vector GatherVectorInt32ZeroExtend(Vector mask, Vector bases); // LD1W public static unsafe Vector GatherVectorInt32ZeroExtend(Vector mask, Vector bases); // LD1W /// T: long, ulong public static unsafe Vector GatherVectorInt32ZeroExtend(Vector mask, uint* base, Vector offsets); // LD1W /// T: [ulong, long], [long, ulong] public static unsafe Vector GatherVectorInt32ZeroExtend(Vector mask, uint* base, Vector offsets); // LD1W /// T: long, ulong public static unsafe Vector GatherVectorInt32ZeroExtend(Vector mask, uint* base, Vector indices); // LD1W /// T: [ulong, long], [long, ulong] public static unsafe Vector GatherVectorInt32ZeroExtend(Vector mask, uint* base, Vector indices); // LD1W public static unsafe Vector GatherVectorInt32ZeroExtend(Vector mask, Vector bases, long offset); // LD1W public static unsafe Vector GatherVectorInt32ZeroExtend(Vector mask, Vector bases, long offset); // LD1W public static unsafe Vector GatherVectorInt32ZeroExtend(Vector mask, Vector bases, long index); // LD1W public static unsafe Vector GatherVectorInt32ZeroExtend(Vector mask, Vector bases, long index); // LD1W /// T: [int, uint], [long, ulong] public static unsafe Vector GatherVectorSByteSignExtend(Vector mask, Vector bases); // LD1SB /// T: uint, ulong public static unsafe Vector GatherVectorSByteSignExtend(Vector mask, Vector bases); // LD1SB /// T: int, uint, long, ulong public static unsafe Vector GatherVectorSByteSignExtend(Vector mask, sbyte* base, Vector offsets); // LD1SB /// T: [uint, int], [int, uint], [ulong, long], [long, ulong] public static unsafe Vector GatherVectorSByteSignExtend(Vector mask, sbyte* base, Vector offsets); // LD1SB /// T: [int, uint], [long, ulong] public static unsafe Vector GatherVectorSByteSignExtend(Vector mask, Vector bases, long offset); // LD1SB /// T: uint, ulong public static unsafe Vector GatherVectorSByteSignExtend(Vector mask, Vector bases, long offset); // LD1SB // All possible prefetch types enum SvePrefetchType { SV_PLDL1KEEP = 0, // Temporal fetch the addressed location for reading, to L1 cache. SV_PLDL1STRM = 1, // Streaming fetch the addressed location for reading, to L1 cache. SV_PLDL2KEEP = 2, // Temporal fetch the addressed location for reading, to L2 cache. SV_PLDL2STRM = 3, // Streaming fetch the addressed location for reading, to L2 cache. SV_PLDL3KEEP = 4, // Temporal fetch the addressed location for reading, to L3 cache. SV_PLDL3STRM = 5, // Streaming fetch the addressed location for reading, to L3 cache. SV_PSTL1KEEP = 8, // Temporal fetch the addressed location for writing, to L1 cache. SV_PSTL1STRM = 9, // Streaming fetch the addressed location for writing, to L1 cache. SV_PSTL2KEEP = 10, // Temporal fetch the addressed location for writing, to L2 cache. SV_PSTL2STRM = 11, // Streaming fetch the addressed location for writing, to L2 cache. SV_PSTL3KEEP = 12, // Temporal fetch the addressed location for writing, to L3 cache. SV_PSTL3STRM = 13 // Streaming fetch the addressed location for writing, to L3 cache. }; /// total method signatures: 80 } ```
Author: a74nh
Assignees: -
Labels: `api-approved`, `area-System.Runtime.Intrinsics`
Milestone: 9.0.0
tannergooding commented 8 months ago

Updated to match the approved API surface

a74nh commented 8 months ago

For these the address should be int and uint instead of short* ?


  /// T: [int, int], [uint, int], [int, uint], [uint, uint], [long, long], [ulong, long], [long, ulong], [ulong, ulong]
  public static unsafe Vector<T> GatherVectorInt32SignExtend(Vector<T> mask, short* address, Vector<T2> indices);

  /// T: [int, int], [uint, int], [int, uint], [uint, uint], [long, long], [ulong, long], [long, ulong], [ulong, ulong]
  public static unsafe Vector<T> GatherVectorInt32WithByteOffsetsSignExtend(Vector<T> mask, short* address, Vector<T2> offsets);

  /// T: [int, int], [uint, int], [int, uint], [uint, uint], [long, long], [ulong, long], [long, ulong], [ulong, ulong]
  public static unsafe Vector<T> GatherVectorUInt32WithByteOffsetsZeroExtend(Vector<T> mask, short* address, Vector<T2> offsets);

  /// T: [int, int], [uint, int], [int, uint], [uint, uint], [long, long], [ulong, long], [long, ulong], [ulong, ulong]
  public static unsafe Vector<T> GatherVectorUInt32ZeroExtend(Vector<T> mask, short* address, Vector<T2> indices);