[API Proposal]: Arm64: FEAT_SVE: gather loads

[a74nh]

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

}

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

Issue Details

---

namespace System.Runtime.Intrinsics.Arm

/// VectorT Summary
public abstract class Sve : AdvSimd /// Feature: FEAT_SVE  Category: gatherloads
{
  /// T: [float, uint], [int, uint], [double, ulong], [long, ulong]
  public static unsafe Vector<T> GatherLoadVector(Vector<T2> bases); // LD1W or LD1D

  /// T: uint, ulong
  public static unsafe Vector<T> GatherLoadVector(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> GatherLoadVector(const T *base, Vector<T2> offsets); // LD1W or LD1D

  /// T: int, uint, long, ulong
  public static unsafe Vector<T> GatherLoadVector(const 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> GatherLoadVector(const T *base, Vector<T2> indices); // LD1W or LD1D

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  public static unsafe Vector<long> GatherLoadVector32SignExtend(Vector<ulong> bases);

  public static unsafe Vector<ulong> GatherLoadVector32SignExtend(Vector<ulong> bases);

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

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

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

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

  public static unsafe Vector<long> GatherLoadVector32SignExtend(Vector<ulong> bases, long offset);

  public static unsafe Vector<ulong> GatherLoadVector32SignExtend(Vector<ulong> bases, long offset);

  public static unsafe Vector<long> GatherLoadVector32SignExtend(Vector<ulong> bases, long index);

  public static unsafe Vector<ulong> GatherLoadVector32SignExtend(Vector<ulong> bases, long index);

  public static unsafe Vector<long> GatherLoadVector32ZeroExtend(Vector<ulong> bases);

  public static unsafe Vector<ulong> GatherLoadVector32ZeroExtend(Vector<ulong> bases);

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

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

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

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

  public static unsafe Vector<long> GatherLoadVector32ZeroExtend(Vector<ulong> bases, long offset);

  public static unsafe Vector<ulong> GatherLoadVector32ZeroExtend(Vector<ulong> bases, long offset);

  public static unsafe Vector<long> GatherLoadVector32ZeroExtend(Vector<ulong> bases, long index);

  public static unsafe Vector<ulong> GatherLoadVector32ZeroExtend(Vector<ulong> bases, long index);

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

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

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

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

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

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

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

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

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

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

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

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

  /// T: uint, ulong
  public static unsafe void GatherPrefetchBytes(Vector<T> bases, enum svprfop op); // PRFB

  /// T: int, uint, long, ulong
  public static unsafe void GatherPrefetchBytes(const void *base, Vector<T> offsets, enum svprfop op); // PRFB

  /// T: uint, ulong
  public static unsafe void GatherPrefetchBytes(Vector<T> bases, long offset, enum svprfop op); // PRFB

  /// T: uint, ulong
  public static unsafe void GatherPrefetchDoublewords(Vector<T> bases, enum svprfop op); // PRFD

  /// T: int, uint, long, ulong
  public static unsafe void GatherPrefetchDoublewords(const void *base, Vector<T> indices, enum svprfop op); // PRFD

  /// T: uint, ulong
  public static unsafe void GatherPrefetchDoublewords(Vector<T> bases, long index, enum svprfop op); // PRFD or PRFB

  /// T: uint, ulong
  public static unsafe void GatherPrefetchHalfwords(Vector<T> bases, enum svprfop op); // PRFH

  /// T: int, uint, long, ulong
  public static unsafe void GatherPrefetchHalfwords(const void *base, Vector<T> indices, enum svprfop op); // PRFH

  /// T: uint, ulong
  public static unsafe void GatherPrefetchHalfwords(Vector<T> bases, long index, enum svprfop op); // PRFH or PRFB

  /// T: uint, ulong
  public static unsafe void GatherPrefetchWords(Vector<T> bases, enum svprfop op); // PRFW

  /// T: int, uint, long, ulong
  public static unsafe void GatherPrefetchWords(const void *base, Vector<T> indices, enum svprfop op); // PRFW

  /// T: uint, ulong
  public static unsafe void GatherPrefetchWords(Vector<T> bases, long index, enum svprfop op); // PRFW or PRFB

  /// total method signatures: 74
}

Author:	a74nh
Assignees:	-
Labels:	area-System.Numerics
Milestone:	-

[a74nh]

/// 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]

/// Rejected:
/// None yet

[a74nh]

This contributes to #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 #88140 comment.

[tannergooding]

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.