Skip to content
New issue

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

Sign up for GitHub

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

Already on GitHub? Sign in to your account

Jump to bottom

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

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

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

a74nh opened this issue Oct 26, 2023 · 13 comments
Labels
api-approved API was approved in API review, it can be implemented area-System.Runtime.Intrinsics arm-sve Work related to arm64 SVE/SVE2 support
Milestone
10.0.0

Comments

@a74nh
Copy link
Contributor

a74nh commented Oct 26, 2023 •
edited
Loading 

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 ghost added the untriaged New issue has not been triaged by the area owner label Oct 26, 2023
@ghost
Copy link

ghost commented Oct 26, 2023

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

Issue Details 
namespace System.Runtime.Intrinsics.Arm

/// VectorT Summary
public abstract class Sve : AdvSimd /// Feature: FEAT_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
Copy link
Contributor Author

a74nh commented Oct 26, 2023 •
edited
Loading 

/// 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
Copy link
Contributor Author

a74nh commented Oct 26, 2023 

/// Rejected:
/// None yet

@a74nh
Copy link
Contributor Author

a74nh commented Oct 26, 2023

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.

This was referenced Oct 26, 2023
Open
Closed
Open
Open
@a74nh a74nh changed the title [API Proposal]: Arm64: FEAT_SVE: GatherLoads [API Proposal]: Arm64: FEAT_SVE: gather loads Oct 26, 2023
@tannergooding tannergooding added the api-suggestion Early API idea and discussion, it is NOT ready for implementation label Oct 26, 2023
@tannergooding tannergooding added this to the 9.0.0 milestone Oct 26, 2023
@ghost ghost removed the untriaged New issue has not been triaged by the area owner label Oct 26, 2023
@tannergooding
Copy link
Member

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.

@tannergooding tannergooding added the needs-author-action An issue or pull request that requires more info or actions from the author. label Oct 26, 2023
@ghost
Copy link

ghost commented Oct 26, 2023

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

@a74nh
Copy link
Contributor Author

a74nh commented Oct 30, 2023

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.

@ghost ghost added needs-further-triage Issue has been initially triaged, but needs deeper consideration or reconsideration and removed needs-author-action An issue or pull request that requires more info or actions from the author. labels Oct 30, 2023
@tannergooding tannergooding added api-ready-for-review API is ready for review, it is NOT ready for implementation and removed api-suggestion Early API idea and discussion, it is NOT ready for implementation needs-further-triage Issue has been initially triaged, but needs deeper consideration or reconsideration labels Oct 30, 2023
@a74nh a74nh mentioned this issue Nov 13, 2023
Closed
@terrajobst
Copy link
Member

terrajobst commented Feb 1, 2024 •
edited by tannergooding
Loading

  • 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* address should be T* address
    • Vector<T> addresses 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)
    • GatherVectorUInt16ZeroExtend and other ZeroExtend methods should say UInt16 (et al) not Int16
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);
}

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

a74nh commented Feb 5, 2024

  • 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
Copy link
Member

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

@ghost
Copy link

ghost commented Feb 8, 2024

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

Issue Details 
namespace System.Runtime.Intrinsics.Arm;

/// VectorT Summary
public abstract 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

}
Author: a74nh
Assignees: -
Labels:

api-approved, area-System.Runtime.Intrinsics
Milestone: 9.0.0

@tannergooding
Copy link
Member

Updated to match the approved API surface

@a74nh
Copy link
Contributor Author

a74nh commented Feb 9, 2024

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);

@a74nh a74nh mentioned this issue Feb 9, 2024
Open
@kunalspathak kunalspathak mentioned this issue Mar 19, 2024
Closed
@kunalspathak kunalspathak mentioned this issue Jun 7, 2024
Merged
@jeffhandley jeffhandley added the arm-sve Work related to arm64 SVE/SVE2 support label Jul 28, 2024
@jeffhandley jeffhandley modified the milestones: 9.0.0, 10.0.0 Jul 28, 2024
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Assignees
No one assigned
Labels
api-approved API was approved in API review, it can be implemented area-System.Runtime.Intrinsics arm-sve Work related to arm64 SVE/SVE2 support
Projects
None yet
Milestone
10.0.0
Development

No branches or pull requests
4 participants
@jeffhandley @a74nh @terrajobst @tannergooding