[API Proposal]: Add defaulted offset to the SVE load/store APIs

[a74nh]

Background and motivation

The SVE load instructions all have the option to take in an immediate offset for the address.

For example, LDFF1B Zresult.S, Pg/Z, [Xarray, Xindex].

Today the API matching this instruction is:
public static unsafe Vector<int> LoadVectorByteZeroExtendFirstFaulting(byte* address);

This method could be extended to take in an offset, which is defaulted to 0.
public static unsafe Vector<int> LoadVectorByteZeroExtendFirstFaulting(byte* address, [ConstantExpected] int offset = 0);

API Proposal

TODO: Fix up the default arg placements in this list.

   public static unsafe Vector<bfloat16> LoadVector(Vector<bfloat16> mask, bfloat16* address, [Constant Expected] long vnum = 0); // svld1_vnum[_bf16]
   public static unsafe Vector<bfloat16> LoadVectorFirstFaulting(Vector<bfloat16> mask, bfloat16* address, [Constant Expected] long vnum = 0); // svldff1_vnum[_bf16]
   public static unsafe Vector<bfloat16> LoadVectorNonFaulting(bfloat16* address, [Constant Expected] long vnum = 0); // svldnf1_vnum[_bf16]
   public static unsafe Vector<bfloat16> LoadVectorNonTemporal(Vector<bfloat16> mask, bfloat16* address, [Constant Expected] long vnum = 0); // svldnt1_vnum[_bf16]
   public static unsafe (Vector<bfloat16>, Vector<bfloat16>) LoadVectorx2(Vector<bfloat16> mask, bfloat16* address, [Constant Expected] long vnum = 0); // svld2_vnum[_bf16]
   public static unsafe (Vector<bfloat16>, Vector<bfloat16>, Vector<bfloat16>) LoadVectorx3(Vector<bfloat16> mask, bfloat16* address, [Constant Expected] long vnum = 0); // svld3_vnum[_bf16]
   public static unsafe (Vector<bfloat16>, Vector<bfloat16>, Vector<bfloat16>, Vector<bfloat16>) LoadVectorx4(Vector<bfloat16> mask, bfloat16* address, [Constant Expected] long vnum = 0); // svld4_vnum[_bf16]
   public static unsafe void Store(Vector<bfloat16> mask, bfloat16* base, [Constant Expected] long vnum = 0, Vector<bfloat16> data); // svst1_vnum[_bf16]
   public static unsafe void Store(Vector<bfloat16> mask, bfloat16* base, [Constant Expected] long vnum = 0, (Vector<bfloat16> data1, Vector<bfloat16> data2)); // svst2_vnum[_bf16]
   public static unsafe void Store(Vector<bfloat16> mask, bfloat16* base, [Constant Expected] long vnum = 0, (Vector<bfloat16> data1, Vector<bfloat16> data2, Vector<bfloat16> data3)); // svst3_vnum[_bf16]
   public static unsafe void Store(Vector<bfloat16> mask, bfloat16* base, [Constant Expected] long vnum = 0, (Vector<bfloat16> data1, Vector<bfloat16> data2, Vector<bfloat16> data3, Vector<bfloat16> data4)); // svst4_vnum[_bf16]
   public static unsafe void StoreNonTemporal(Vector<bfloat16> mask, bfloat16* base, [Constant Expected] long vnum = 0, Vector<bfloat16> data); // svstnt1_vnum[_bf16]
   public static unsafe Vector<half> LoadVector(Vector<half> mask, half* address, [Constant Expected] long vnum = 0); // svld1_vnum[_f16]
   public static unsafe Vector<half> LoadVectorFirstFaulting(Vector<half> mask, half* address, [Constant Expected] long vnum = 0); // svldff1_vnum[_f16]
   public static unsafe Vector<half> LoadVectorNonFaulting(half* address, [Constant Expected] long vnum = 0); // svldnf1_vnum[_f16]
   public static unsafe Vector<half> LoadVectorNonTemporal(Vector<half> mask, half* address, [Constant Expected] long vnum = 0); // svldnt1_vnum[_f16]
   public static unsafe (Vector<half>, Vector<half>) LoadVectorx2(Vector<half> mask, half* address, [Constant Expected] long vnum = 0); // svld2_vnum[_f16]
   public static unsafe (Vector<half>, Vector<half>, Vector<half>) LoadVectorx3(Vector<half> mask, half* address, [Constant Expected] long vnum = 0); // svld3_vnum[_f16]
   public static unsafe (Vector<half>, Vector<half>, Vector<half>, Vector<half>) LoadVectorx4(Vector<half> mask, half* address, [Constant Expected] long vnum = 0); // svld4_vnum[_f16]
   public static unsafe void Store(Vector<half> mask, half* base, [Constant Expected] long vnum = 0, Vector<half> data); // svst1_vnum[_f16]
   public static unsafe void Store(Vector<half> mask, half* base, [Constant Expected] long vnum = 0, (Vector<half> data1, Vector<half> data2)); // svst2_vnum[_f16]
   public static unsafe void Store(Vector<half> mask, half* base, [Constant Expected] long vnum = 0, (Vector<half> data1, Vector<half> data2, Vector<half> data3)); // svst3_vnum[_f16]
   public static unsafe void Store(Vector<half> mask, half* base, [Constant Expected] long vnum = 0, (Vector<half> data1, Vector<half> data2, Vector<half> data3, Vector<half> data4)); // svst4_vnum[_f16]
   public static unsafe void StoreNonTemporal(Vector<half> mask, half* base, [Constant Expected] long vnum = 0, Vector<half> data); // svstnt1_vnum[_f16]
   public static unsafe Vector<short> LoadVectorByteZeroExtendFirstFaulting(Vector<short> mask, byte* address, [Constant Expected] long vnum = 0); // svldff1ub_vnum_s16
   public static unsafe Vector<int> LoadVectorByteZeroExtendFirstFaulting(Vector<int> mask, byte* address, [Constant Expected] long vnum = 0); // svldff1ub_vnum_s32
   public static unsafe Vector<long> LoadVectorByteZeroExtendFirstFaulting(Vector<long> mask, byte* address, [Constant Expected] long vnum = 0); // svldff1ub_vnum_s64
   public static unsafe Vector<ushort> LoadVectorByteZeroExtendFirstFaulting(Vector<ushort> mask, byte* address, [Constant Expected] long vnum = 0); // svldff1ub_vnum_u16
   public static unsafe Vector<uint> LoadVectorByteZeroExtendFirstFaulting(Vector<uint> mask, byte* address, [Constant Expected] long vnum = 0); // svldff1ub_vnum_u32
   public static unsafe Vector<ulong> LoadVectorByteZeroExtendFirstFaulting(Vector<ulong> mask, byte* address, [Constant Expected] long vnum = 0); // svldff1ub_vnum_u64
   public static unsafe Vector<float> LoadVectorFirstFaulting(Vector<float> mask, float* address, [Constant Expected] long vnum = 0); // svldff1_vnum[_f32]
   public static unsafe Vector<double> LoadVectorFirstFaulting(Vector<double> mask, double* address, [Constant Expected] long vnum = 0); // svldff1_vnum[_f64]
   public static unsafe Vector<sbyte> LoadVectorFirstFaulting(Vector<sbyte> mask, sbyte* address, [Constant Expected] long vnum = 0); // svldff1_vnum[_s8]
   public static unsafe Vector<short> LoadVectorFirstFaulting(Vector<short> mask, short* address, [Constant Expected] long vnum = 0); // svldff1_vnum[_s16]
   public static unsafe Vector<int> LoadVectorFirstFaulting(Vector<int> mask, int* address, [Constant Expected] long vnum = 0); // svldff1_vnum[_s32]
   public static unsafe Vector<long> LoadVectorFirstFaulting(Vector<long> mask, long* address, [Constant Expected] long vnum = 0); // svldff1_vnum[_s64]
   public static unsafe Vector<byte> LoadVectorFirstFaulting(Vector<byte> mask, byte* address, [Constant Expected] long vnum = 0); // svldff1_vnum[_u8]
   public static unsafe Vector<ushort> LoadVectorFirstFaulting(Vector<ushort> mask, ushort* address, [Constant Expected] long vnum = 0); // svldff1_vnum[_u16]
   public static unsafe Vector<uint> LoadVectorFirstFaulting(Vector<uint> mask, uint* address, [Constant Expected] long vnum = 0); // svldff1_vnum[_u32]
   public static unsafe Vector<ulong> LoadVectorFirstFaulting(Vector<ulong> mask, ulong* address, [Constant Expected] long vnum = 0); // svldff1_vnum[_u64]
   public static unsafe Vector<int> LoadVectorInt16SignExtendFirstFaulting(Vector<int> mask, short* address, [Constant Expected] long vnum = 0); // svldff1sh_vnum_s32
   public static unsafe Vector<long> LoadVectorInt16SignExtendFirstFaulting(Vector<long> mask, short* address, [Constant Expected] long vnum = 0); // svldff1sh_vnum_s64
   public static unsafe Vector<uint> LoadVectorInt16SignExtendFirstFaulting(Vector<uint> mask, short* address, [Constant Expected] long vnum = 0); // svldff1sh_vnum_u32
   public static unsafe Vector<ulong> LoadVectorInt16SignExtendFirstFaulting(Vector<ulong> mask, short* address, [Constant Expected] long vnum = 0); // svldff1sh_vnum_u64
   public static unsafe Vector<long> LoadVectorInt32SignExtendFirstFaulting(Vector<long> mask, int* address, [Constant Expected] long vnum = 0); // svldff1sw_vnum_s64
   public static unsafe Vector<ulong> LoadVectorInt32SignExtendFirstFaulting(Vector<ulong> mask, int* address, [Constant Expected] long vnum = 0); // svldff1sw_vnum_u64
   public static unsafe Vector<short> LoadVectorSByteSignExtendFirstFaulting(Vector<short> mask, sbyte* address, [Constant Expected] long vnum = 0); // svldff1sb_vnum_s16
   public static unsafe Vector<int> LoadVectorSByteSignExtendFirstFaulting(Vector<int> mask, sbyte* address, [Constant Expected] long vnum = 0); // svldff1sb_vnum_s32
   public static unsafe Vector<long> LoadVectorSByteSignExtendFirstFaulting(Vector<long> mask, sbyte* address, [Constant Expected] long vnum = 0); // svldff1sb_vnum_s64
   public static unsafe Vector<ushort> LoadVectorSByteSignExtendFirstFaulting(Vector<ushort> mask, sbyte* address, [Constant Expected] long vnum = 0); // svldff1sb_vnum_u16
   public static unsafe Vector<uint> LoadVectorSByteSignExtendFirstFaulting(Vector<uint> mask, sbyte* address, [Constant Expected] long vnum = 0); // svldff1sb_vnum_u32
   public static unsafe Vector<ulong> LoadVectorSByteSignExtendFirstFaulting(Vector<ulong> mask, sbyte* address, [Constant Expected] long vnum = 0); // svldff1sb_vnum_u64
   public static unsafe Vector<int> LoadVectorUInt16ZeroExtendFirstFaulting(Vector<int> mask, ushort* address, [Constant Expected] long vnum = 0); // svldff1uh_vnum_s32
   public static unsafe Vector<long> LoadVectorUInt16ZeroExtendFirstFaulting(Vector<long> mask, ushort* address, [Constant Expected] long vnum = 0); // svldff1uh_vnum_s64
   public static unsafe Vector<uint> LoadVectorUInt16ZeroExtendFirstFaulting(Vector<uint> mask, ushort* address, [Constant Expected] long vnum = 0); // svldff1uh_vnum_u32
   public static unsafe Vector<ulong> LoadVectorUInt16ZeroExtendFirstFaulting(Vector<ulong> mask, ushort* address, [Constant Expected] long vnum = 0); // svldff1uh_vnum_u64
   public static unsafe Vector<long> LoadVectorUInt32ZeroExtendFirstFaulting(Vector<long> mask, uint* address, [Constant Expected] long vnum = 0); // svldff1uw_vnum_s64
   public static unsafe Vector<ulong> LoadVectorUInt32ZeroExtendFirstFaulting(Vector<ulong> mask, uint* address, [Constant Expected] long vnum = 0); // svldff1uw_vnum_u64
   public static unsafe Vector<float> LoadVector(Vector<float> mask, float* address, [Constant Expected] long vnum = 0); // svld1_vnum[_f32]
   public static unsafe Vector<double> LoadVector(Vector<double> mask, double* address, [Constant Expected] long vnum = 0); // svld1_vnum[_f64]
   public static unsafe Vector<sbyte> LoadVector(Vector<sbyte> mask, sbyte* address, [Constant Expected] long vnum = 0); // svld1_vnum[_s8]
   public static unsafe Vector<short> LoadVector(Vector<short> mask, short* address, [Constant Expected] long vnum = 0); // svld1_vnum[_s16]
   public static unsafe Vector<int> LoadVector(Vector<int> mask, int* address, [Constant Expected] long vnum = 0); // svld1_vnum[_s32]
   public static unsafe Vector<long> LoadVector(Vector<long> mask, long* address, [Constant Expected] long vnum = 0); // svld1_vnum[_s64]
   public static unsafe Vector<byte> LoadVector(Vector<byte> mask, byte* address, [Constant Expected] long vnum = 0); // svld1_vnum[_u8]
   public static unsafe Vector<ushort> LoadVector(Vector<ushort> mask, ushort* address, [Constant Expected] long vnum = 0); // svld1_vnum[_u16]
   public static unsafe Vector<uint> LoadVector(Vector<uint> mask, uint* address, [Constant Expected] long vnum = 0); // svld1_vnum[_u32]
   public static unsafe Vector<ulong> LoadVector(Vector<ulong> mask, ulong* address, [Constant Expected] long vnum = 0); // svld1_vnum[_u64]
   public static unsafe Vector<short> LoadVectorByteNonFaultingZeroExtendToInt16(byte* address, [Constant Expected] long vnum = 0); // svldnf1ub_vnum_s16
   public static unsafe Vector<int> LoadVectorByteNonFaultingZeroExtendToInt32(byte* address, [Constant Expected] long vnum = 0); // svldnf1ub_vnum_s32
   public static unsafe Vector<long> LoadVectorByteNonFaultingZeroExtendToInt64(byte* address, [Constant Expected] long vnum = 0); // svldnf1ub_vnum_s64
   public static unsafe Vector<ushort> LoadVectorByteNonFaultingZeroExtendToUInt16(byte* address, [Constant Expected] long vnum = 0); // svldnf1ub_vnum_u16
   public static unsafe Vector<uint> LoadVectorByteNonFaultingZeroExtendToUInt32(byte* address, [Constant Expected] long vnum = 0); // svldnf1ub_vnum_u32
   public static unsafe Vector<ulong> LoadVectorByteNonFaultingZeroExtendToUInt64(byte* address, [Constant Expected] long vnum = 0); // svldnf1ub_vnum_u64
   public static unsafe Vector<short> LoadVectorByteZeroExtendToInt16(Vector<short> mask, byte* address, [Constant Expected] long vnum = 0); // svld1ub_vnum_s16
   public static unsafe Vector<int> LoadVectorByteZeroExtendToInt32(Vector<int> mask, byte* address, [Constant Expected] long vnum = 0); // svld1ub_vnum_s32
   public static unsafe Vector<long> LoadVectorByteZeroExtendToInt64(Vector<long> mask, byte* address, [Constant Expected] long vnum = 0); // svld1ub_vnum_s64
   public static unsafe Vector<ushort> LoadVectorByteZeroExtendToUInt16(Vector<ushort> mask, byte* address, [Constant Expected] long vnum = 0); // svld1ub_vnum_u16
   public static unsafe Vector<uint> LoadVectorByteZeroExtendToUInt32(Vector<uint> mask, byte* address, [Constant Expected] long vnum = 0); // svld1ub_vnum_u32
   public static unsafe Vector<ulong> LoadVectorByteZeroExtendToUInt64(Vector<ulong> mask, byte* address, [Constant Expected] long vnum = 0); // svld1ub_vnum_u64
   public static unsafe Vector<int> LoadVectorInt16NonFaultingSignExtendToInt32(short* address, [Constant Expected] long vnum = 0); // svldnf1sh_vnum_s32
   public static unsafe Vector<long> LoadVectorInt16NonFaultingSignExtendToInt64(short* address, [Constant Expected] long vnum = 0); // svldnf1sh_vnum_s64
   public static unsafe Vector<uint> LoadVectorInt16NonFaultingSignExtendToUInt32(short* address, [Constant Expected] long vnum = 0); // svldnf1sh_vnum_u32
   public static unsafe Vector<ulong> LoadVectorInt16NonFaultingSignExtendToUInt64(short* address, [Constant Expected] long vnum = 0); // svldnf1sh_vnum_u64
   public static unsafe Vector<int> LoadVectorInt16SignExtendToInt32(Vector<int> mask, short* address, [Constant Expected] long vnum = 0); // svld1sh_vnum_s32
   public static unsafe Vector<long> LoadVectorInt16SignExtendToInt64(Vector<long> mask, short* address, [Constant Expected] long vnum = 0); // svld1sh_vnum_s64
   public static unsafe Vector<uint> LoadVectorInt16SignExtendToUInt32(Vector<uint> mask, short* address, [Constant Expected] long vnum = 0); // svld1sh_vnum_u32
   public static unsafe Vector<ulong> LoadVectorInt16SignExtendToUInt64(Vector<ulong> mask, short* address, [Constant Expected] long vnum = 0); // svld1sh_vnum_u64
   public static unsafe Vector<long> LoadVectorInt32NonFaultingSignExtendToInt64(int* address, [Constant Expected] long vnum = 0); // svldnf1sw_vnum_s64
   public static unsafe Vector<ulong> LoadVectorInt32NonFaultingSignExtendToUInt64(int* address, [Constant Expected] long vnum = 0); // svldnf1sw_vnum_u64
   public static unsafe Vector<long> LoadVectorInt32SignExtendToInt64(Vector<long> mask, int* address, [Constant Expected] long vnum = 0); // svld1sw_vnum_s64
   public static unsafe Vector<ulong> LoadVectorInt32SignExtendToUInt64(Vector<ulong> mask, int* address, [Constant Expected] long vnum = 0); // svld1sw_vnum_u64
   public static unsafe Vector<float> LoadVectorNonFaulting(float* address, [Constant Expected] long vnum = 0); // svldnf1_vnum[_f32]
   public static unsafe Vector<double> LoadVectorNonFaulting(double* address, [Constant Expected] long vnum = 0); // svldnf1_vnum[_f64]
   public static unsafe Vector<sbyte> LoadVectorNonFaulting(sbyte* address, [Constant Expected] long vnum = 0); // svldnf1_vnum[_s8]
   public static unsafe Vector<short> LoadVectorNonFaulting(short* address, [Constant Expected] long vnum = 0); // svldnf1_vnum[_s16]
   public static unsafe Vector<int> LoadVectorNonFaulting(int* address, [Constant Expected] long vnum = 0); // svldnf1_vnum[_s32]
   public static unsafe Vector<long> LoadVectorNonFaulting(long* address, [Constant Expected] long vnum = 0); // svldnf1_vnum[_s64]
   public static unsafe Vector<byte> LoadVectorNonFaulting(byte* address, [Constant Expected] long vnum = 0); // svldnf1_vnum[_u8]
   public static unsafe Vector<ushort> LoadVectorNonFaulting(ushort* address, [Constant Expected] long vnum = 0); // svldnf1_vnum[_u16]
   public static unsafe Vector<uint> LoadVectorNonFaulting(uint* address, [Constant Expected] long vnum = 0); // svldnf1_vnum[_u32]
   public static unsafe Vector<ulong> LoadVectorNonFaulting(ulong* address, [Constant Expected] long vnum = 0); // svldnf1_vnum[_u64]
   public static unsafe Vector<float> LoadVectorNonTemporal(Vector<float> mask, float* address, [Constant Expected] long vnum = 0); // svldnt1_vnum[_f32]
   public static unsafe Vector<double> LoadVectorNonTemporal(Vector<double> mask, double* address, [Constant Expected] long vnum = 0); // svldnt1_vnum[_f64]
   public static unsafe Vector<sbyte> LoadVectorNonTemporal(Vector<sbyte> mask, sbyte* address, [Constant Expected] long vnum = 0); // svldnt1_vnum[_s8]
   public static unsafe Vector<short> LoadVectorNonTemporal(Vector<short> mask, short* address, [Constant Expected] long vnum = 0); // svldnt1_vnum[_s16]
   public static unsafe Vector<int> LoadVectorNonTemporal(Vector<int> mask, int* address, [Constant Expected] long vnum = 0); // svldnt1_vnum[_s32]
   public static unsafe Vector<long> LoadVectorNonTemporal(Vector<long> mask, long* address, [Constant Expected] long vnum = 0); // svldnt1_vnum[_s64]
   public static unsafe Vector<byte> LoadVectorNonTemporal(Vector<byte> mask, byte* address, [Constant Expected] long vnum = 0); // svldnt1_vnum[_u8]
   public static unsafe Vector<ushort> LoadVectorNonTemporal(Vector<ushort> mask, ushort* address, [Constant Expected] long vnum = 0); // svldnt1_vnum[_u16]
   public static unsafe Vector<uint> LoadVectorNonTemporal(Vector<uint> mask, uint* address, [Constant Expected] long vnum = 0); // svldnt1_vnum[_u32]
   public static unsafe Vector<ulong> LoadVectorNonTemporal(Vector<ulong> mask, ulong* address, [Constant Expected] long vnum = 0); // svldnt1_vnum[_u64]
   public static unsafe Vector<short> LoadVectorSByteNonFaultingSignExtendToInt16(sbyte* address, [Constant Expected] long vnum = 0); // svldnf1sb_vnum_s16
   public static unsafe Vector<int> LoadVectorSByteNonFaultingSignExtendToInt32(sbyte* address, [Constant Expected] long vnum = 0); // svldnf1sb_vnum_s32
   public static unsafe Vector<long> LoadVectorSByteNonFaultingSignExtendToInt64(sbyte* address, [Constant Expected] long vnum = 0); // svldnf1sb_vnum_s64
   public static unsafe Vector<ushort> LoadVectorSByteNonFaultingSignExtendToUInt16(sbyte* address, [Constant Expected] long vnum = 0); // svldnf1sb_vnum_u16
   public static unsafe Vector<uint> LoadVectorSByteNonFaultingSignExtendToUInt32(sbyte* address, [Constant Expected] long vnum = 0); // svldnf1sb_vnum_u32
   public static unsafe Vector<ulong> LoadVectorSByteNonFaultingSignExtendToUInt64(sbyte* address, [Constant Expected] long vnum = 0); // svldnf1sb_vnum_u64
   public static unsafe Vector<short> LoadVectorSByteSignExtendToInt16(Vector<short> mask, sbyte* address, [Constant Expected] long vnum = 0); // svld1sb_vnum_s16
   public static unsafe Vector<int> LoadVectorSByteSignExtendToInt32(Vector<int> mask, sbyte* address, [Constant Expected] long vnum = 0); // svld1sb_vnum_s32
   public static unsafe Vector<long> LoadVectorSByteSignExtendToInt64(Vector<long> mask, sbyte* address, [Constant Expected] long vnum = 0); // svld1sb_vnum_s64
   public static unsafe Vector<ushort> LoadVectorSByteSignExtendToUInt16(Vector<ushort> mask, sbyte* address, [Constant Expected] long vnum = 0); // svld1sb_vnum_u16
   public static unsafe Vector<uint> LoadVectorSByteSignExtendToUInt32(Vector<uint> mask, sbyte* address, [Constant Expected] long vnum = 0); // svld1sb_vnum_u32
   public static unsafe Vector<ulong> LoadVectorSByteSignExtendToUInt64(Vector<ulong> mask, sbyte* address, [Constant Expected] long vnum = 0); // svld1sb_vnum_u64
   public static unsafe Vector<int> LoadVectorUInt16NonFaultingZeroExtendToInt32(ushort* address, [Constant Expected] long vnum = 0); // svldnf1uh_vnum_s32
   public static unsafe Vector<long> LoadVectorUInt16NonFaultingZeroExtendToInt64(ushort* address, [Constant Expected] long vnum = 0); // svldnf1uh_vnum_s64
   public static unsafe Vector<uint> LoadVectorUInt16NonFaultingZeroExtendToUInt32(ushort* address, [Constant Expected] long vnum = 0); // svldnf1uh_vnum_u32
   public static unsafe Vector<ulong> LoadVectorUInt16NonFaultingZeroExtendToUInt64(ushort* address, [Constant Expected] long vnum = 0); // svldnf1uh_vnum_u64
   public static unsafe Vector<int> LoadVectorUInt16ZeroExtendToInt32(Vector<int> mask, ushort* address, [Constant Expected] long vnum = 0); // svld1uh_vnum_s32
   public static unsafe Vector<long> LoadVectorUInt16ZeroExtendToInt64(Vector<long> mask, ushort* address, [Constant Expected] long vnum = 0); // svld1uh_vnum_s64
   public static unsafe Vector<uint> LoadVectorUInt16ZeroExtendToUInt32(Vector<uint> mask, ushort* address, [Constant Expected] long vnum = 0); // svld1uh_vnum_u32
   public static unsafe Vector<ulong> LoadVectorUInt16ZeroExtendToUInt64(Vector<ulong> mask, ushort* address, [Constant Expected] long vnum = 0); // svld1uh_vnum_u64
   public static unsafe Vector<long> LoadVectorUInt32NonFaultingZeroExtendToInt64(uint* address, [Constant Expected] long vnum = 0); // svldnf1uw_vnum_s64
   public static unsafe Vector<ulong> LoadVectorUInt32NonFaultingZeroExtendToUInt64(uint* address, [Constant Expected] long vnum = 0); // svldnf1uw_vnum_u64
   public static unsafe Vector<long> LoadVectorUInt32ZeroExtendToInt64(Vector<long> mask, uint* address, [Constant Expected] long vnum = 0); // svld1uw_vnum_s64
   public static unsafe Vector<ulong> LoadVectorUInt32ZeroExtendToUInt64(Vector<ulong> mask, uint* address, [Constant Expected] long vnum = 0); // svld1uw_vnum_u64
   public static unsafe (Vector<float>, Vector<float>) LoadVectorx2(Vector<float> mask, float* address, [Constant Expected] long vnum = 0); // svld2_vnum[_f32]
   public static unsafe (Vector<double>, Vector<double>) LoadVectorx2(Vector<double> mask, double* address, [Constant Expected] long vnum = 0); // svld2_vnum[_f64]
   public static unsafe (Vector<sbyte>, Vector<sbyte>) LoadVectorx2(Vector<sbyte> mask, sbyte* address, [Constant Expected] long vnum = 0); // svld2_vnum[_s8]
   public static unsafe (Vector<short>, Vector<short>) LoadVectorx2(Vector<short> mask, short* address, [Constant Expected] long vnum = 0); // svld2_vnum[_s16]
   public static unsafe (Vector<int>, Vector<int>) LoadVectorx2(Vector<int> mask, int* address, [Constant Expected] long vnum = 0); // svld2_vnum[_s32]
   public static unsafe (Vector<long>, Vector<long>) LoadVectorx2(Vector<long> mask, long* address, [Constant Expected] long vnum = 0); // svld2_vnum[_s64]
   public static unsafe (Vector<byte>, Vector<byte>) LoadVectorx2(Vector<byte> mask, byte* address, [Constant Expected] long vnum = 0); // svld2_vnum[_u8]
   public static unsafe (Vector<ushort>, Vector<ushort>) LoadVectorx2(Vector<ushort> mask, ushort* address, [Constant Expected] long vnum = 0); // svld2_vnum[_u16]
   public static unsafe (Vector<uint>, Vector<uint>) LoadVectorx2(Vector<uint> mask, uint* address, [Constant Expected] long vnum = 0); // svld2_vnum[_u32]
   public static unsafe (Vector<ulong>, Vector<ulong>) LoadVectorx2(Vector<ulong> mask, ulong* address, [Constant Expected] long vnum = 0); // svld2_vnum[_u64]
   public static unsafe (Vector<float>, Vector<float>, Vector<float>) LoadVectorx3(Vector<float> mask, float* address, [Constant Expected] long vnum = 0); // svld3_vnum[_f32]
   public static unsafe (Vector<double>, Vector<double>, Vector<double>) LoadVectorx3(Vector<double> mask, double* address, [Constant Expected] long vnum = 0); // svld3_vnum[_f64]
   public static unsafe (Vector<sbyte>, Vector<sbyte>, Vector<sbyte>) LoadVectorx3(Vector<sbyte> mask, sbyte* address, [Constant Expected] long vnum = 0); // svld3_vnum[_s8]
   public static unsafe (Vector<short>, Vector<short>, Vector<short>) LoadVectorx3(Vector<short> mask, short* address, [Constant Expected] long vnum = 0); // svld3_vnum[_s16]
   public static unsafe (Vector<int>, Vector<int>, Vector<int>) LoadVectorx3(Vector<int> mask, int* address, [Constant Expected] long vnum = 0); // svld3_vnum[_s32]
   public static unsafe (Vector<long>, Vector<long>, Vector<long>) LoadVectorx3(Vector<long> mask, long* address, [Constant Expected] long vnum = 0); // svld3_vnum[_s64]
   public static unsafe (Vector<byte>, Vector<byte>, Vector<byte>) LoadVectorx3(Vector<byte> mask, byte* address, [Constant Expected] long vnum = 0); // svld3_vnum[_u8]
   public static unsafe (Vector<ushort>, Vector<ushort>, Vector<ushort>) LoadVectorx3(Vector<ushort> mask, ushort* address, [Constant Expected] long vnum = 0); // svld3_vnum[_u16]
   public static unsafe (Vector<uint>, Vector<uint>, Vector<uint>) LoadVectorx3(Vector<uint> mask, uint* address, [Constant Expected] long vnum = 0); // svld3_vnum[_u32]
   public static unsafe (Vector<ulong>, Vector<ulong>, Vector<ulong>) LoadVectorx3(Vector<ulong> mask, ulong* address, [Constant Expected] long vnum = 0); // svld3_vnum[_u64]
   public static unsafe (Vector<float>, Vector<float>, Vector<float>, Vector<float>) LoadVectorx4(Vector<float> mask, float* address, [Constant Expected] long vnum = 0); // svld4_vnum[_f32]
   public static unsafe (Vector<double>, Vector<double>, Vector<double>, Vector<double>) LoadVectorx4(Vector<double> mask, double* address, [Constant Expected] long vnum = 0); // svld4_vnum[_f64]
   public static unsafe (Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>) LoadVectorx4(Vector<sbyte> mask, sbyte* address, [Constant Expected] long vnum = 0); // svld4_vnum[_s8]
   public static unsafe (Vector<short>, Vector<short>, Vector<short>, Vector<short>) LoadVectorx4(Vector<short> mask, short* address, [Constant Expected] long vnum = 0); // svld4_vnum[_s16]
   public static unsafe (Vector<int>, Vector<int>, Vector<int>, Vector<int>) LoadVectorx4(Vector<int> mask, int* address, [Constant Expected] long vnum = 0); // svld4_vnum[_s32]
   public static unsafe (Vector<long>, Vector<long>, Vector<long>, Vector<long>) LoadVectorx4(Vector<long> mask, long* address, [Constant Expected] long vnum = 0); // svld4_vnum[_s64]
   public static unsafe (Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>) LoadVectorx4(Vector<byte> mask, byte* address, [Constant Expected] long vnum = 0); // svld4_vnum[_u8]
   public static unsafe (Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>) LoadVectorx4(Vector<ushort> mask, ushort* address, [Constant Expected] long vnum = 0); // svld4_vnum[_u16]
   public static unsafe (Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>) LoadVectorx4(Vector<uint> mask, uint* address, [Constant Expected] long vnum = 0); // svld4_vnum[_u32]
   public static unsafe (Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>) LoadVectorx4(Vector<ulong> mask, ulong* address, [Constant Expected] long vnum = 0); // svld4_vnum[_u64]
   public static unsafe void PrefetchBytes(Vector<byte> mask, void* address, [Constant Expected] long vnum = 0, [ConstantExpected] SvePrefetchType prefetchType); // svprfb_vnum
   public static unsafe void PrefetchInt16(Vector<ushort> mask, void* address, [Constant Expected] long vnum = 0, [ConstantExpected] SvePrefetchType prefetchType); // svprfh_vnum
   public static unsafe void PrefetchInt32(Vector<uint> mask, void* address, [Constant Expected] long vnum = 0, [ConstantExpected] SvePrefetchType prefetchType); // svprfw_vnum
   public static unsafe void PrefetchInt64(Vector<ulong> mask, void* address, [Constant Expected] long vnum = 0, [ConstantExpected] SvePrefetchType prefetchType); // svprfd_vnum
   public static unsafe void Store(Vector<float> mask, float* base, [Constant Expected] long vnum = 0, Vector<float> data); // svst1_vnum[_f32]
   public static unsafe void Store(Vector<double> mask, double* base, [Constant Expected] long vnum = 0, Vector<double> data); // svst1_vnum[_f64]
   public static unsafe void Store(Vector<sbyte> mask, sbyte* base, [Constant Expected] long vnum = 0, Vector<sbyte> data); // svst1_vnum[_s8]
   public static unsafe void Store(Vector<short> mask, short* base, [Constant Expected] long vnum = 0, Vector<short> data); // svst1_vnum[_s16]
   public static unsafe void Store(Vector<int> mask, int* base, [Constant Expected] long vnum = 0, Vector<int> data); // svst1_vnum[_s32]
   public static unsafe void Store(Vector<long> mask, long* base, [Constant Expected] long vnum = 0, Vector<long> data); // svst1_vnum[_s64]
   public static unsafe void Store(Vector<byte> mask, byte* base, [Constant Expected] long vnum = 0, Vector<byte> data); // svst1_vnum[_u8]
   public static unsafe void Store(Vector<ushort> mask, ushort* base, [Constant Expected] long vnum = 0, Vector<ushort> data); // svst1_vnum[_u16]
   public static unsafe void Store(Vector<uint> mask, uint* base, [Constant Expected] long vnum = 0, Vector<uint> data); // svst1_vnum[_u32]
   public static unsafe void Store(Vector<ulong> mask, ulong* base, [Constant Expected] long vnum = 0, Vector<ulong> data); // svst1_vnum[_u64]
   public static unsafe void Store(Vector<float> mask, float* base, [Constant Expected] long vnum = 0, (Vector<float> data1, Vector<float> data2)); // svst2_vnum[_f32]
   public static unsafe void Store(Vector<double> mask, double* base, [Constant Expected] long vnum = 0, (Vector<double> data1, Vector<double> data2)); // svst2_vnum[_f64]
   public static unsafe void Store(Vector<sbyte> mask, sbyte* base, [Constant Expected] long vnum = 0, (Vector<sbyte> data1, Vector<sbyte> data2)); // svst2_vnum[_s8]
   public static unsafe void Store(Vector<short> mask, short* base, [Constant Expected] long vnum = 0, (Vector<short> data1, Vector<short> data2)); // svst2_vnum[_s16]
   public static unsafe void Store(Vector<int> mask, int* base, [Constant Expected] long vnum = 0, (Vector<int> data1, Vector<int> data2)); // svst2_vnum[_s32]
   public static unsafe void Store(Vector<long> mask, long* base, [Constant Expected] long vnum = 0, (Vector<long> data1, Vector<long> data2)); // svst2_vnum[_s64]
   public static unsafe void Store(Vector<byte> mask, byte* base, [Constant Expected] long vnum = 0, (Vector<byte> data1, Vector<byte> data2)); // svst2_vnum[_u8]
   public static unsafe void Store(Vector<ushort> mask, ushort* base, [Constant Expected] long vnum = 0, (Vector<ushort> data1, Vector<ushort> data2)); // svst2_vnum[_u16]
   public static unsafe void Store(Vector<uint> mask, uint* base, [Constant Expected] long vnum = 0, (Vector<uint> data1, Vector<uint> data2)); // svst2_vnum[_u32]
   public static unsafe void Store(Vector<ulong> mask, ulong* base, [Constant Expected] long vnum = 0, (Vector<ulong> data1, Vector<ulong> data2)); // svst2_vnum[_u64]
   public static unsafe void Store(Vector<float> mask, float* base, [Constant Expected] long vnum = 0, (Vector<float> data1, Vector<float> data2, Vector<float> data3)); // svst3_vnum[_f32]
   public static unsafe void Store(Vector<double> mask, double* base, [Constant Expected] long vnum = 0, (Vector<double> data1, Vector<double> data2, Vector<double> data3)); // svst3_vnum[_f64]
   public static unsafe void Store(Vector<sbyte> mask, sbyte* base, [Constant Expected] long vnum = 0, (Vector<sbyte> data1, Vector<sbyte> data2, Vector<sbyte> data3)); // svst3_vnum[_s8]
   public static unsafe void Store(Vector<short> mask, short* base, [Constant Expected] long vnum = 0, (Vector<short> data1, Vector<short> data2, Vector<short> data3)); // svst3_vnum[_s16]
   public static unsafe void Store(Vector<int> mask, int* base, [Constant Expected] long vnum = 0, (Vector<int> data1, Vector<int> data2, Vector<int> data3)); // svst3_vnum[_s32]
   public static unsafe void Store(Vector<long> mask, long* base, [Constant Expected] long vnum = 0, (Vector<long> data1, Vector<long> data2, Vector<long> data3)); // svst3_vnum[_s64]
   public static unsafe void Store(Vector<byte> mask, byte* base, [Constant Expected] long vnum = 0, (Vector<byte> data1, Vector<byte> data2, Vector<byte> data3)); // svst3_vnum[_u8]
   public static unsafe void Store(Vector<ushort> mask, ushort* base, [Constant Expected] long vnum = 0, (Vector<ushort> data1, Vector<ushort> data2, Vector<ushort> data3)); // svst3_vnum[_u16]
   public static unsafe void Store(Vector<uint> mask, uint* base, [Constant Expected] long vnum = 0, (Vector<uint> data1, Vector<uint> data2, Vector<uint> data3)); // svst3_vnum[_u32]
   public static unsafe void Store(Vector<ulong> mask, ulong* base, [Constant Expected] long vnum = 0, (Vector<ulong> data1, Vector<ulong> data2, Vector<ulong> data3)); // svst3_vnum[_u64]
   public static unsafe void Store(Vector<float> mask, float* base, [Constant Expected] long vnum = 0, (Vector<float> data1, Vector<float> data2, Vector<float> data3, Vector<float> data4)); // svst4_vnum[_f32]
   public static unsafe void Store(Vector<double> mask, double* base, [Constant Expected] long vnum = 0, (Vector<double> data1, Vector<double> data2, Vector<double> data3, Vector<double> data4)); // svst4_vnum[_f64]
   public static unsafe void Store(Vector<sbyte> mask, sbyte* base, [Constant Expected] long vnum = 0, (Vector<sbyte> data1, Vector<sbyte> data2, Vector<sbyte> data3, Vector<sbyte> data4)); // svst4_vnum[_s8]
   public static unsafe void Store(Vector<short> mask, short* base, [Constant Expected] long vnum = 0, (Vector<short> data1, Vector<short> data2, Vector<short> data3, Vector<short> data4)); // svst4_vnum[_s16]
   public static unsafe void Store(Vector<int> mask, int* base, [Constant Expected] long vnum = 0, (Vector<int> data1, Vector<int> data2, Vector<int> data3, Vector<int> data4)); // svst4_vnum[_s32]
   public static unsafe void Store(Vector<long> mask, long* base, [Constant Expected] long vnum = 0, (Vector<long> data1, Vector<long> data2, Vector<long> data3, Vector<long> data4)); // svst4_vnum[_s64]
   public static unsafe void Store(Vector<byte> mask, byte* base, [Constant Expected] long vnum = 0, (Vector<byte> data1, Vector<byte> data2, Vector<byte> data3, Vector<byte> data4)); // svst4_vnum[_u8]
   public static unsafe void Store(Vector<ushort> mask, ushort* base, [Constant Expected] long vnum = 0, (Vector<ushort> data1, Vector<ushort> data2, Vector<ushort> data3, Vector<ushort> data4)); // svst4_vnum[_u16]
   public static unsafe void Store(Vector<uint> mask, uint* base, [Constant Expected] long vnum = 0, (Vector<uint> data1, Vector<uint> data2, Vector<uint> data3, Vector<uint> data4)); // svst4_vnum[_u32]
   public static unsafe void Store(Vector<ulong> mask, ulong* base, [Constant Expected] long vnum = 0, (Vector<ulong> data1, Vector<ulong> data2, Vector<ulong> data3, Vector<ulong> data4)); // svst4_vnum[_u64]
   public static unsafe void StoreNarrowing(Vector<short> mask, sbyte* base, [Constant Expected] long vnum = 0, Vector<short> data); // svst1b_vnum[_s16]
   public static unsafe void StoreNarrowing(Vector<int> mask, sbyte* base, [Constant Expected] long vnum = 0, Vector<int> data); // svst1b_vnum[_s32]
   public static unsafe void StoreNarrowing(Vector<long> mask, sbyte* base, [Constant Expected] long vnum = 0, Vector<long> data); // svst1b_vnum[_s64]
   public static unsafe void StoreNarrowing(Vector<ushort> mask, byte* base, [Constant Expected] long vnum = 0, Vector<ushort> data); // svst1b_vnum[_u16]
   public static unsafe void StoreNarrowing(Vector<uint> mask, byte* base, [Constant Expected] long vnum = 0, Vector<uint> data); // svst1b_vnum[_u32]
   public static unsafe void StoreNarrowing(Vector<ulong> mask, byte* base, [Constant Expected] long vnum = 0, Vector<ulong> data); // svst1b_vnum[_u64]
   public static unsafe void StoreNarrowing(Vector<int> mask, short* base, [Constant Expected] long vnum = 0, Vector<int> data); // svst1h_vnum[_s32]
   public static unsafe void StoreNarrowing(Vector<long> mask, short* base, [Constant Expected] long vnum = 0, Vector<long> data); // svst1h_vnum[_s64]
   public static unsafe void StoreNarrowing(Vector<uint> mask, ushort* base, [Constant Expected] long vnum = 0, Vector<uint> data); // svst1h_vnum[_u32]
   public static unsafe void StoreNarrowing(Vector<ulong> mask, ushort* base, [Constant Expected] long vnum = 0, Vector<ulong> data); // svst1h_vnum[_u64]
   public static unsafe void StoreNarrowing(Vector<long> mask, int* base, [Constant Expected] long vnum = 0, Vector<long> data); // svst1w_vnum[_s64]
   public static unsafe void StoreNarrowing(Vector<ulong> mask, uint* base, [Constant Expected] long vnum = 0, Vector<ulong> data); // svst1w_vnum[_u64]
   public static unsafe void StoreNonTemporal(Vector<float> mask, float* base, [Constant Expected] long vnum = 0, Vector<float> data); // svstnt1_vnum[_f32]
   public static unsafe void StoreNonTemporal(Vector<double> mask, double* base, [Constant Expected] long vnum = 0, Vector<double> data); // svstnt1_vnum[_f64]
   public static unsafe void StoreNonTemporal(Vector<sbyte> mask, sbyte* base, [Constant Expected] long vnum = 0, Vector<sbyte> data); // svstnt1_vnum[_s8]
   public static unsafe void StoreNonTemporal(Vector<short> mask, short* base, [Constant Expected] long vnum = 0, Vector<short> data); // svstnt1_vnum[_s16]
   public static unsafe void StoreNonTemporal(Vector<int> mask, int* base, [Constant Expected] long vnum = 0, Vector<int> data); // svstnt1_vnum[_s32]
   public static unsafe void StoreNonTemporal(Vector<long> mask, long* base, [Constant Expected] long vnum = 0, Vector<long> data); // svstnt1_vnum[_s64]
   public static unsafe void StoreNonTemporal(Vector<byte> mask, byte* base, [Constant Expected] long vnum = 0, Vector<byte> data); // svstnt1_vnum[_u8]
   public static unsafe void StoreNonTemporal(Vector<ushort> mask, ushort* base, [Constant Expected] long vnum = 0, Vector<ushort> data); // svstnt1_vnum[_u16]
   public static unsafe void StoreNonTemporal(Vector<uint> mask, uint* base, [Constant Expected] long vnum = 0, Vector<uint> data); // svstnt1_vnum[_u32]
   public static unsafe void StoreNonTemporal(Vector<ulong> mask, ulong* base, [Constant Expected] long vnum = 0, Vector<ulong> data); // svstnt1_vnum[_u64]

[dotnet-policy-service]

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

[tannergooding]

I don't believe we've used any optional parameters with the hardware intrinsics today.

I don't think it would cause any issues to do so either, but it is something to consider in contrast to explicit separate overloads.

[jkotas]

public static unsafe Vector LoadVectorByteZeroExtendFirstFaulting(byte* address, [ConstantExpected] int offset = 0);

Would it be better for the JIT to take care of this transparently by building the right addressing mode? I believe that it is how we have dealt with this in all other APIs so far.

ie can one write LoadVectorByteZeroExtendFirstFaulting(address + 16) instead of LoadVectorByteZeroExtendFirstFaulting(address, 16) to achieve the same result?

[bartonjs]

These API changes don't seem necessary given @jkotas' comment about just ensmartening the JIT here.

See also #108320.