S.R.I.Wasm.PackedSimd API changes

[radekdoulik]

S.R.I.Wasm.PackedSimd API changes

During implementation of the PackedSimd class and intrinsics I found few issues in the API. I changed the affected methods and kept them internal until now. I would like to get these approved and make public in the next preview release. These are in the "Required changes" section bellow.

In the "Other changes to consider" I also propose few more changes based on the things I noticed and on the comments from @kg and @vargaz. These are for methods which are already public, but were present only in the preview releases, so I think we can still change them if they would get through the API review.

Required changes

Rename ConvertToInt32Saturate methods with uint return type to avoid signature conflict with public static Vector128<int> ConvertToInt32Saturate(...). They had the same name and arguments, while returning different types, signed and unsigned integers.

* original approved API

    public static Vector128<uint> ConvertToInt32Saturate(Vector128<float> value);
    public static Vector128<uint> ConvertToInt32Saturate(Vector128<double> value);

* proposed change

    public static Vector128<uint> ConvertToUInt32Saturate(Vector128<float> value);
    public static Vector128<uint> ConvertToUInt32Saturate(Vector128<double> value);

Update the narrowing convert methods to have signed arguments. Also remove methods with 64bit vector arguments as there are not narrowing instructions for this size. This change is based on the wasm SIMD proposal, where it states Regardless of the whether the operation is signed or unsigned, the input lanes are interpreted as signed integers and on the test of the implementation.

* original approved API

    public static Vector128<sbyte>  ConvertNarrowingSaturate(Vector128<short>  lower, Vector128<short>  upper);
    public static Vector128<byte>   ConvertNarrowingSaturate(Vector128<ushort> lower, Vector128<ushort> upper);
    public static Vector128<short>  ConvertNarrowingSaturate(Vector128<int>    lower, Vector128<int>    upper);
    public static Vector128<ushort> ConvertNarrowingSaturate(Vector128<uint>   lower, Vector128<uint>   upper);
    public static Vector128<int>    ConvertNarrowingSaturate(Vector128<long>   lower, Vector128<long>   upper);
    public static Vector128<uint>   ConvertNarrowingSaturate(Vector128<ulong>  lower, Vector128<ulong>  upper);

* proposed change

    public static Vector128<sbyte>  ConvertNarrowingSaturateSigned(Vector128<short> lower, Vector128<short> upper);
    public static Vector128<short>  ConvertNarrowingSaturateSigned(Vector128<int>   lower, Vector128<int>   upper);
    public static Vector128<byte>   ConvertNarrowingSaturateUnsigned(Vector128<short> lower, Vector128<short> upper);
    public static Vector128<ushort> ConvertNarrowingSaturateUnsigned(Vector128<int>   lower, Vector128<int>   upper);

Other changes to consider

Unify the Scalar/Lane terms in the method names. Use Scalar everywhere to be consistent.

* original approved API

public static int    ExtractLane(Vector128<sbyte>  value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte index);    // takes ImmLaneIdx16
public static uint   ExtractLane(Vector128<byte>   value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte index);    // takes ImmLaneIdx16
public static int    ExtractLane(Vector128<short>  value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte index);    // takes ImmLaneIdx8
public static uint   ExtractLane(Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte index);    // takes ImmLaneIdx8
public static int    ExtractLane(Vector128<int>    value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte index);    // takes ImmLaneIdx4
public static uint   ExtractLane(Vector128<uint>   value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte index);    // takes ImmLaneIdx4
public static long   ExtractLane(Vector128<long>   value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte index);    // takes ImmLaneIdx2
public static ulong  ExtractLane(Vector128<ulong>  value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte index);    // takes ImmLaneIdx2
public static float  ExtractLane(Vector128<float>  value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte index);    // takes ImmLaneIdx4
public static double ExtractLane(Vector128<double> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte index);    // takes ImmLaneIdx2
public static nint   ExtractLane(Vector128<nint>   value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte index);
public static nuint  ExtractLane(Vector128<nuint>  value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte index);
public static Vector128<sbyte>  ReplaceLane(Vector128<sbyte>  vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte imm, int    value);   // takes ImmLaneIdx16
public static Vector128<byte>   ReplaceLane(Vector128<byte>   vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte imm, uint   value);   // takes ImmLaneIdx16
public static Vector128<short>  ReplaceLane(Vector128<short>  vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte imm, int    value);   // takes ImmLaneIdx8
public static Vector128<ushort> ReplaceLane(Vector128<ushort> vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte imm, uint   value);   // takes ImmLaneIdx8
public static Vector128<int>    ReplaceLane(Vector128<int>    vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte imm, int    value);   // takes ImmLaneIdx4
public static Vector128<int>    ReplaceLane(Vector128<uint>   vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte imm, uint   value);   // takes ImmLaneIdx4
public static Vector128<long>   ReplaceLane(Vector128<long>   vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte imm, long   value);   // takes ImmLaneIdx2
public static Vector128<ulong>  ReplaceLane(Vector128<ulong>  vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte imm, ulong  value);   // takes ImmLaneIdx2
public static Vector128<float>  ReplaceLane(Vector128<float>  vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte imm, float  value);   // takes ImmLaneIdx4
public static Vector128<double> ReplaceLane(Vector128<double> vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte imm, double value);   // takes ImmLaneIdx2
public static Vector128<nint>   ReplaceLane(Vector128<nint>   vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte imm, nint   value);
public static Vector128<nuint>  ReplaceLane(Vector128<nuint>  vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte imm, nuint  value);

* proposed change:

public static int    ExtractScalar(Vector128<sbyte>  value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte index);    // takes ImmLaneIdx16
public static uint   ExtractScalar(Vector128<byte>   value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte index);    // takes ImmLaneIdx16
public static int    ExtractScalar(Vector128<short>  value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte index);    // takes ImmLaneIdx8
public static uint   ExtractScalar(Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte index);    // takes ImmLaneIdx8
public static int    ExtractScalar(Vector128<int>    value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte index);    // takes ImmLaneIdx4
public static uint   ExtractScalar(Vector128<uint>   value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte index);    // takes ImmLaneIdx4
public static long   ExtractScalar(Vector128<long>   value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte index);    // takes ImmLaneIdx2
public static ulong  ExtractScalar(Vector128<ulong>  value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte index);    // takes ImmLaneIdx2
public static float  ExtractScalar(Vector128<float>  value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte index);    // takes ImmLaneIdx4
public static double ExtractScalar(Vector128<double> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte index);    // takes ImmLaneIdx2
public static nint   ExtractScalar(Vector128<nint>   value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte index);
public static nuint  ExtractScalar(Vector128<nuint>  value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte index);
public static Vector128<sbyte>  ReplaceScalar(Vector128<sbyte>  vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte imm, int    value);   // takes ImmLaneIdx16
public static Vector128<byte>   ReplaceScalar(Vector128<byte>   vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte imm, uint   value);   // takes ImmLaneIdx16
public static Vector128<short>  ReplaceScalar(Vector128<short>  vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte imm, int    value);   // takes ImmLaneIdx8
public static Vector128<ushort> ReplaceScalar(Vector128<ushort> vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte imm, uint   value);   // takes ImmLaneIdx8
public static Vector128<int>    ReplaceScalar(Vector128<int>    vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte imm, int    value);   // takes ImmLaneIdx4
public static Vector128<int>    ReplaceScalar(Vector128<uint>   vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte imm, uint   value);   // takes ImmLaneIdx4
public static Vector128<long>   ReplaceScalar(Vector128<long>   vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte imm, long   value);   // takes ImmLaneIdx2
public static Vector128<ulong>  ReplaceScalar(Vector128<ulong>  vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte imm, ulong  value);   // takes ImmLaneIdx2
public static Vector128<float>  ReplaceScalar(Vector128<float>  vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte imm, float  value);   // takes ImmLaneIdx4
public static Vector128<double> ReplaceScalar(Vector128<double> vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte imm, double value);   // takes ImmLaneIdx2
public static Vector128<nint>   ReplaceScalar(Vector128<nint>   vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte imm, nint   value);
public static Vector128<nuint>  ReplaceScalar(Vector128<nuint>  vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte imm, nuint  value);

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

Issue Details

---

S.R.I.Wasm.PackedSimd API changes

During implementation of the PackedSimd class and intrinsics I found few issues in the API. I changed the affected methods and kept them internal until now. I would like to get these approved and make public in the next preview release. These are in the "Required changes" section bellow.

In the "Other changes to consider" I also propose few more changes based on the things I noticed and on the comments from @kg and @vargaz. These are for methods which are already public, but were present only in the preview releases, so I think we can still change them if they would get through the API review.

Required changes

Rename ConvertToInt32Saturate methods with uint return type to avoid signature conflict with public static Vector128<int> ConvertToInt32Saturate(...). They had the same name and arguments, while returning different types, signed and unsigned integers.

* original approved API

    public static Vector128<uint> ConvertToInt32Saturate(Vector128<float> value);
    public static Vector128<uint> ConvertToInt32Saturate(Vector128<double> value);

* proposed change

    public static Vector128<uint> ConvertToUnsignedInt32Saturate(Vector128<float> value);
    public static Vector128<uint> ConvertToUnsignedInt32Saturate(Vector128<double> value);

Update the narrowing convert methods to have signed arguments. Also remove methods with 64bit vector arguments as there are not narrowing instructions for this size. This change is based on the wasm SIMD proposal, where it states Regardless of the whether the operation is signed or unsigned, the input lanes are interpreted as signed integers and on the test of the implementation.

* original approved API

    public static Vector128<sbyte>  ConvertNarrowingSaturate(Vector128<short>  lower, Vector128<short>  upper);
    public static Vector128<byte>   ConvertNarrowingSaturate(Vector128<ushort> lower, Vector128<ushort> upper);
    public static Vector128<short>  ConvertNarrowingSaturate(Vector128<int>    lower, Vector128<int>    upper);
    public static Vector128<ushort> ConvertNarrowingSaturate(Vector128<uint>   lower, Vector128<uint>   upper);
    public static Vector128<int>    ConvertNarrowingSaturate(Vector128<long>   lower, Vector128<long>   upper);
    public static Vector128<uint>   ConvertNarrowingSaturate(Vector128<ulong>  lower, Vector128<ulong>  upper);

* proposed change

    public static Vector128<sbyte> ConvertNarrowingSignedSaturate(Vector128<short> lower, Vector128<short> upper);
    public static Vector128<short> ConvertNarrowingSignedSaturate(Vector128<int>   lower, Vector128<int>   upper);
    public static Vector128<byte>  ConvertNarrowingUnsignedSaturate(Vector128<short> lower, Vector128<short> upper);
    public static Vector128<ushort> ConvertNarrowingUnsignedSaturate(Vector128<int>  lower, Vector128<int>   upper);

Other changes to consider

Change Shuffle methods to take byte indices instead of Vector128. The shuffle instruction has 16 immediate bytes indices as input. Currently we cannot express the constant requirement on Vector128. We can change the signature to use byte indices and use [ConstantExpected] attribute on them to improve that. (it is also related to a problem where llvm crashes during compilation, when the indices are not constant)

* original approved API

    public static Vector128<sbyte> Shuffle(Vector128<sbyte> lower, Vector128<sbyte> upper, Vector128<sbyte> indices);
    public static Vector128<byte>  Shuffle(Vector128<byte>  lower, Vector128<byte>  upper, Vector128<byte> indices);

* proposed change

    public static Vector128<sbyte> Shuffle(Vector128<sbyte> lower, Vector128<sbyte> upper, [ConstantExpected] sbyte i0, ..., [ConstantExpected] sbyte i15);
    public static Vector128<byte>  Shuffle(Vector128<byte>  lower, Vector128<byte>  upper, [ConstantExpected] sbyte i0, ..., [ConstantExpected] sbyte i15);

Remove Vector128 from load method names. It is already clear from the return type, that these methods return Vector128.

* original approved API

    public static Vector128<sbyte>  LoadVector128(sbyte*  memarg);
    public static Vector128<byte>   LoadVector128(byte*   memarg);
    public static Vector128<short>  LoadVector128(short*  memarg);
    public static Vector128<ushort> LoadVector128(ushort* memarg);
    public static Vector128<int>    LoadVector128(int*    memarg);
    public static Vector128<uint>   LoadVector128(uint*   memarg);
    public static Vector128<long>   LoadVector128(long*   memarg);
    public static Vector128<ulong>  LoadVector128(ulong*  memarg);
    public static Vector128<float>  LoadVector128(float*  memarg);
    public static Vector128<double> LoadVector128(double* memarg);
    public static Vector128<nint>   LoadVector128(nint*   memarg);
    public static Vector128<nuint>  LoadVector128(nuint*  memarg);

    public static Vector128<int>    LoadScalarVector128(int*    memarg);
    public static Vector128<uint>   LoadScalarVector128(uint*   memarg);
    public static Vector128<long>   LoadScalarVector128(long*   memarg);
    public static Vector128<ulong>  LoadScalarVector128(ulong*  memarg);
    public static Vector128<float>  LoadScalarVector128(float*  memarg);
    public static Vector128<double> LoadScalarVector128(double* memarg);
    public static Vector128<nint>   LoadScalarVector128(nint*   memarg);
    public static Vector128<nuint>  LoadScalarVector128(nuint*  memarg);

    public static Vector128<sbyte>  LoadScalarAndSplatVector128(sbyte*  memarg);
    public static Vector128<byte>   LoadScalarAndSplatVector128(byte*   memarg);
    public static Vector128<short>  LoadScalarAndSplatVector128(short*  memarg);
    public static Vector128<ushort> LoadScalarAndSplatVector128(ushort* memarg);
    public static Vector128<int>    LoadScalarAndSplatVector128(int*    memarg);
    public static Vector128<uint>   LoadScalarAndSplatVector128(uint*   memarg);
    public static Vector128<long>   LoadScalarAndSplatVector128(long*   memarg);
    public static Vector128<ulong>  LoadScalarAndSplatVector128(ulong*  memarg);
    public static Vector128<float>  LoadScalarAndSplatVector128(float*  memarg);
    public static Vector128<double> LoadScalarAndSplatVector128(double* memarg);
    public static Vector128<nint>   LoadScalarAndSplatVector128(nint*   memarg);
    public static Vector128<nuint>  LoadScalarAndSplatVector128(nuint*  memarg);

    public static Vector128<short>  LoadWideningVector128(sbyte*  memarg);  // takes ImmLaneIdx16
    public static Vector128<ushort> LoadWideningVector128(byte*   memarg);  // takes ImmLaneIdx16
    public static Vector128<int>    LoadWideningVector128(short*  memarg);  // takes ImmLaneIdx8
    public static Vector128<uint>   LoadWideningVector128(ushort* memarg);  // takes ImmLaneIdx8
    public static Vector128<long>   LoadWideningVector128(int*    memarg);  // takes ImmLaneIdx4
    public static Vector128<ulong>  LoadWideningVector128(uint*   memarg);  // takes ImmLaneIdx4    

* proposed change

    public static Vector128<sbyte>  Load(sbyte*  memarg);
    public static Vector128<byte>   Load(byte*   memarg);
    public static Vector128<short>  Load(short*  memarg);
    public static Vector128<ushort> Load(ushort* memarg);
    public static Vector128<int>    Load(int*    memarg);
    public static Vector128<uint>   Load(uint*   memarg);
    public static Vector128<long>   Load(long*   memarg);
    public static Vector128<ulong>  Load(ulong*  memarg);
    public static Vector128<float>  Load(float*  memarg);
    public static Vector128<double> Load(double* memarg);
    public static Vector128<nint>   Load(nint*   memarg);
    public static Vector128<nuint>  Load(nuint*  memarg);

    public static Vector128<int>    LoadScalar(int*    memarg);
    public static Vector128<uint>   LoadScalar(uint*   memarg);
    public static Vector128<long>   LoadScalar(long*   memarg);
    public static Vector128<ulong>  LoadScalar(ulong*  memarg);
    public static Vector128<float>  LoadScalar(float*  memarg);
    public static Vector128<double> LoadScalar(double* memarg);
    public static Vector128<nint>   LoadScalar(nint*   memarg);
    public static Vector128<nuint>  LoadScalar(nuint*  memarg);

    public static Vector128<sbyte>  LoadScalarAndSplat(sbyte*  memarg);
    public static Vector128<byte>   LoadScalarAndSplat(byte*   memarg);
    public static Vector128<short>  LoadScalarAndSplat(short*  memarg);
    public static Vector128<ushort> LoadScalarAndSplat(ushort* memarg);
    public static Vector128<int>    LoadScalarAndSplat(int*    memarg);
    public static Vector128<uint>   LoadScalarAndSplat(uint*   memarg);
    public static Vector128<long>   LoadScalarAndSplat(long*   memarg);
    public static Vector128<ulong>  LoadScalarAndSplat(ulong*  memarg);
    public static Vector128<float>  LoadScalarAndSplat(float*  memarg);
    public static Vector128<double> LoadScalarAndSplat(double* memarg);
    public static Vector128<nint>   LoadScalarAndSplat(nint*   memarg);
    public static Vector128<nuint>  LoadScalarAndSplat(nuint*  memarg);

    public static Vector128<short>  LoadWidening(sbyte*  memarg);  // takes ImmLaneIdx16
    public static Vector128<ushort> LoadWidening(byte*   memarg);  // takes ImmLaneIdx16
    public static Vector128<int>    LoadWidening(short*  memarg);  // takes ImmLaneIdx8
    public static Vector128<uint>   LoadWidening(ushort* memarg);  // takes ImmLaneIdx8
    public static Vector128<long>   LoadWidening(int*    memarg);  // takes ImmLaneIdx4
    public static Vector128<ulong>  LoadWidening(uint*   memarg);  // takes ImmLaneIdx4    

Use Lane instead of Scalar in some method names. We already have ExtractLane and ReplaceLane methods. The names with Lane would be closer to instruction names as well.

    LoadScalarVector128         --> LoadLaneZero    (v128.load[8|16|32|64]_zero instructions)
    LoadScalarAndSplatVector128 --> LoadAndSplat    (v128.load[8|16|32|64]_splat instructions)
    LoadScalarAndInsert         --> LoadLane        (v128.load[8|16|32|64]_lane instructions)
    StoreSelectedScalar         --> StoreLane       (v128.store[8|16|32|64]_lane instructions)

    * original approved API

    public static unsafe Vector128<int>    LoadScalarVector128(int*    address);
    public static unsafe Vector128<uint>   LoadScalarVector128(uint*   address);
    public static unsafe Vector128<long>   LoadScalarVector128(long*   address);
    public static unsafe Vector128<ulong>  LoadScalarVector128(ulong*  address);
    public static unsafe Vector128<float>  LoadScalarVector128(float*  address);
    public static unsafe Vector128<double> LoadScalarVector128(double* address);
    public static unsafe Vector128<nint>   LoadScalarVector128(nint*   address);
    public static unsafe Vector128<nuint>  LoadScalarVector128(nuint*  address);
    public static unsafe Vector128<sbyte>  LoadScalarAndSplatVector128(sbyte*  address);
    public static unsafe Vector128<byte>   LoadScalarAndSplatVector128(byte*   address);
    public static unsafe Vector128<short>  LoadScalarAndSplatVector128(short*  address);
    public static unsafe Vector128<ushort> LoadScalarAndSplatVector128(ushort* address);
    public static unsafe Vector128<int>    LoadScalarAndSplatVector128(int*    address);
    public static unsafe Vector128<uint>   LoadScalarAndSplatVector128(uint*   address);
    public static unsafe Vector128<long>   LoadScalarAndSplatVector128(long*   address);
    public static unsafe Vector128<ulong>  LoadScalarAndSplatVector128(ulong*  address);
    public static unsafe Vector128<float>  LoadScalarAndSplatVector128(float*  address);
    public static unsafe Vector128<double> LoadScalarAndSplatVector128(double* address);
    public static unsafe Vector128<nint>   LoadScalarAndSplatVector128(nint*   address);
    public static unsafe Vector128<nuint>  LoadScalarAndSplatVector128(nuint*  address);
    public static unsafe Vector128<sbyte>  LoadScalarAndInsert(sbyte*  address, Vector128<sbyte>  vector, [ConstantExpected(Max = (byte)(15))] byte index);
    public static unsafe Vector128<byte>   LoadScalarAndInsert(byte*   address, Vector128<byte>   vector, [ConstantExpected(Max = (byte)(15))] byte index);
    public static unsafe Vector128<short>  LoadScalarAndInsert(short*  address, Vector128<short>  vector, [ConstantExpected(Max = (byte)(7))] byte index);
    public static unsafe Vector128<ushort> LoadScalarAndInsert(ushort* address, Vector128<ushort> vector, [ConstantExpected(Max = (byte)(7))] byte index);
    public static unsafe Vector128<int>    LoadScalarAndInsert(int*    address, Vector128<int>    vector, [ConstantExpected(Max = (byte)(3))] byte index);
    public static unsafe Vector128<uint>   LoadScalarAndInsert(uint*   address, Vector128<uint>   vector, [ConstantExpected(Max = (byte)(3))] byte index);
    public static unsafe Vector128<long>   LoadScalarAndInsert(long*   address, Vector128<long>   vector, [ConstantExpected(Max = (byte)(1))] byte index);
    public static unsafe Vector128<ulong>  LoadScalarAndInsert(ulong*  address, Vector128<ulong>  vector, [ConstantExpected(Max = (byte)(1))] byte index);
    public static unsafe Vector128<float>  LoadScalarAndInsert(float*  address, Vector128<float>  vector, [ConstantExpected(Max = (byte)(3))] byte index);
    public static unsafe Vector128<double> LoadScalarAndInsert(double* address, Vector128<double> vector, [ConstantExpected(Max = (byte)(1))] byte index);
    public static unsafe Vector128<nint>   LoadScalarAndInsert(nint*   address, Vector128<nint>   vector, [ConstantExpected(Max = (byte)(3))] byte index);
    public static unsafe Vector128<nuint>  LoadScalarAndInsert(nuint*  address, Vector128<nuint>  vector, [ConstantExpected(Max = (byte)(3))] byte index);
    public static unsafe void StoreSelectedScalar(sbyte*  address, Vector128<sbyte>  source, [ConstantExpected(Max = (byte)(15))] byte index); // takes ImmLaneIdx16
    public static unsafe void StoreSelectedScalar(byte*   address, Vector128<byte>   source, [ConstantExpected(Max = (byte)(15))] byte index); // takes ImmLaneIdx16
    public static unsafe void StoreSelectedScalar(short*  address, Vector128<short>  source, [ConstantExpected(Max = (byte)(7))] byte index); // takes ImmLaneIdx8
    public static unsafe void StoreSelectedScalar(ushort* address, Vector128<ushort> source, [ConstantExpected(Max = (byte)(7))] byte index); // takes ImmLaneIdx8
    public static unsafe void StoreSelectedScalar(int*    address, Vector128<int>    source, [ConstantExpected(Max = (byte)(3))] byte index); // takes ImmLaneIdx4
    public static unsafe void StoreSelectedScalar(uint*   address, Vector128<uint>   source, [ConstantExpected(Max = (byte)(3))] byte index); // takes ImmLaneIdx4
    public static unsafe void StoreSelectedScalar(long*   address, Vector128<long>   source, [ConstantExpected(Max = (byte)(1))] byte index); // takes ImmLaneIdx2
    public static unsafe void StoreSelectedScalar(ulong*  address, Vector128<ulong>  source, [ConstantExpected(Max = (byte)(1))] byte index); // takes ImmLaneIdx2
    public static unsafe void StoreSelectedScalar(float*  address, Vector128<float>  source, [ConstantExpected(Max = (byte)(3))] byte index); // takes ImmLaneIdx4
    public static unsafe void StoreSelectedScalar(double* address, Vector128<double> source, [ConstantExpected(Max = (byte)(1))] byte index); // takes ImmLaneIdx2
    public static unsafe void StoreSelectedScalar(nint*   address, Vector128<nint>   source, [ConstantExpected(Max = (byte)(3))] byte index);
    public static unsafe void StoreSelectedScalar(nuint*  address, Vector128<nuint>  source, [ConstantExpected(Max = (byte)(3))] byte index);

    * proposed change

    public static unsafe Vector128<int>    LoadLaneZero(int*    address);
    public static unsafe Vector128<uint>   LoadLaneZero(uint*   address);
    public static unsafe Vector128<long>   LoadLaneZero(long*   address);
    public static unsafe Vector128<ulong>  LoadLaneZero(ulong*  address);
    public static unsafe Vector128<float>  LoadLaneZero(float*  address);
    public static unsafe Vector128<double> LoadLaneZero(double* address);
    public static unsafe Vector128<nint>   LoadLaneZero(nint*   address);
    public static unsafe Vector128<nuint>  LoadLaneZero(nuint*  address);
    public static unsafe Vector128<sbyte>  LoadAndSplat(sbyte*  address);
    public static unsafe Vector128<byte>   LoadAndSplat(byte*   address);
    public static unsafe Vector128<short>  LoadAndSplat(short*  address);
    public static unsafe Vector128<ushort> LoadAndSplat(ushort* address);
    public static unsafe Vector128<int>    LoadAndSplat(int*    address);
    public static unsafe Vector128<uint>   LoadAndSplat(uint*   address);
    public static unsafe Vector128<long>   LoadAndSplat(long*   address);
    public static unsafe Vector128<ulong>  LoadAndSplat(ulong*  address);
    public static unsafe Vector128<float>  LoadAndSplat(float*  address);
    public static unsafe Vector128<double> LoadAndSplat(double* address);
    public static unsafe Vector128<nint>   LoadAndSplat(nint*   address);
    public static unsafe Vector128<nuint>  LoadAndSplat(nuint*  address);
    public static unsafe Vector128<sbyte>  LoadLane(sbyte*  address, Vector128<sbyte>  vector, [ConstantExpected(Max = (byte)(15))] byte index);
    public static unsafe Vector128<byte>   LoadLane(byte*   address, Vector128<byte>   vector, [ConstantExpected(Max = (byte)(15))] byte index);
    public static unsafe Vector128<short>  LoadLane(short*  address, Vector128<short>  vector, [ConstantExpected(Max = (byte)(7))] byte index);
    public static unsafe Vector128<ushort> LoadLane(ushort* address, Vector128<ushort> vector, [ConstantExpected(Max = (byte)(7))] byte index);
    public static unsafe Vector128<int>    LoadLane(int*    address, Vector128<int>    vector, [ConstantExpected(Max = (byte)(3))] byte index);
    public static unsafe Vector128<uint>   LoadLane(uint*   address, Vector128<uint>   vector, [ConstantExpected(Max = (byte)(3))] byte index);
    public static unsafe Vector128<long>   LoadLane(long*   address, Vector128<long>   vector, [ConstantExpected(Max = (byte)(1))] byte index);
    public static unsafe Vector128<ulong>  LoadLane(ulong*  address, Vector128<ulong>  vector, [ConstantExpected(Max = (byte)(1))] byte index);
    public static unsafe Vector128<float>  LoadLane(float*  address, Vector128<float>  vector, [ConstantExpected(Max = (byte)(3))] byte index);
    public static unsafe Vector128<double> LoadLane(double* address, Vector128<double> vector, [ConstantExpected(Max = (byte)(1))] byte index);
    public static unsafe Vector128<nint>   LoadLane(nint*   address, Vector128<nint>   vector, [ConstantExpected(Max = (byte)(3))] byte index);
    public static unsafe Vector128<nuint>  LoadLane(nuint*  address, Vector128<nuint>  vector, [ConstantExpected(Max = (byte)(3))] byte index);
    public static unsafe void StoreLane(sbyte*  address, Vector128<sbyte>  source, [ConstantExpected(Max = (byte)(15))] byte index); // takes ImmLaneIdx16
    public static unsafe void StoreLane(byte*   address, Vector128<byte>   source, [ConstantExpected(Max = (byte)(15))] byte index); // takes ImmLaneIdx16
    public static unsafe void StoreLane(short*  address, Vector128<short>  source, [ConstantExpected(Max = (byte)(7))] byte index); // takes ImmLaneIdx8
    public static unsafe void StoreLane(ushort* address, Vector128<ushort> source, [ConstantExpected(Max = (byte)(7))] byte index); // takes ImmLaneIdx8
    public static unsafe void StoreLane(int*    address, Vector128<int>    source, [ConstantExpected(Max = (byte)(3))] byte index); // takes ImmLaneIdx4
    public static unsafe void StoreLane(uint*   address, Vector128<uint>   source, [ConstantExpected(Max = (byte)(3))] byte index); // takes ImmLaneIdx4
    public static unsafe void StoreLane(long*   address, Vector128<long>   source, [ConstantExpected(Max = (byte)(1))] byte index); // takes ImmLaneIdx2
    public static unsafe void StoreLane(ulong*  address, Vector128<ulong>  source, [ConstantExpected(Max = (byte)(1))] byte index); // takes ImmLaneIdx2
    public static unsafe void StoreLane(float*  address, Vector128<float>  source, [ConstantExpected(Max = (byte)(3))] byte index); // takes ImmLaneIdx4
    public static unsafe void StoreLane(double* address, Vector128<double> source, [ConstantExpected(Max = (byte)(1))] byte index); // takes ImmLaneIdx2
    public static unsafe void StoreLane(nint*   address, Vector128<nint>   source, [ConstantExpected(Max = (byte)(3))] byte index);
    public static unsafe void StoreLane(nuint*  address, Vector128<nuint>  source, [ConstantExpected(Max = (byte)(3))] byte index);

Author:	radekdoulik
Assignees:	-
Labels:	area-System.Runtime.Intrinsics
Milestone:	-

[kg]

The new signature for Shuffle might be much harder to implement in the interpreter and jiterpreter, I'm not sure how I feel about it from a design perspective either

[teo-tsirpanis]

ConvertToUnsignedInt32Saturate➡️ConvertToUInt32Saturate?

[tannergooding]

@radekdoulik, some feedback below. If we can get this addressed then we can mark it **Blocking** and get it to API review.

Rename ConvertToInt32Saturate methods with uint return type to avoid signature conflict with public static Vector128 ConvertToInt32Saturate(...). They had the same name and arguments, while returning different types, signed and unsigned integers.

Should be, UInt32 as @teo-tsirpanis suggested. It's the standardized name we use in .NET

Update the narrowing convert methods to have signed arguments.

👍. Noting the name shoul dbe ConvertNarrowingSaturateSigned and ConvertNarrowingSaturateUnsigned (just slight ordering difference) to match the ordering we have on Arm64.

Change Shuffle methods to take byte indices instead of Vector128. The shuffle instruction has 16 immediate bytes indices as input. Currently we cannot express the constant requirement on Vector128. We can change the signature to use byte indices and use [ConstantExpected] attribute on them to improve that. (it is also related to a problem where llvm crashes during compilation, when the indices are not constant)

This change doesn't "fix" the problem. This also doesn't fix that the cross platform API signature takes a V128 and therefore the general handling must exist anyways.

Mono must support non-constant parameters being passed in and still do the right thing, even if that's fallback to emulation. This is necessary to ensure the API behaves correctly in the face of the debugger, reflection, delegate invocation, etc.

If WASM only performs "well" in the case of constant input, then we should instead update the [ConstantExpected] analyzer to special case V128 constants and ensure that Mono has the necessary general support for recognizing Vector128.Create(cns, cns, ..., cns) as an llvm:ConstantDataVector node (much as RyuJIT does for recognizing it as a GenTreeVecCon node).

Remove Vector128 from load method names. It is already clear from the return type, that these methods return Vector128.

The names exist because it may become ambiguous in the future if WASM ever decides to support larger vector types. Users wanting to type less should use the cross platform API Vector128.Load, which will do the same general thing.

Use Lane instead of Scalar in some method names. We already have ExtractLane and ReplaceLane methods. The names with Lane would be closer to instruction names as well.

Scalar is the term we use in the rest of the hardware intrinsics, whether cross platform or platform specific. The two terms are largely interchangeable and we decided back in Arm64 that standardizing on Scalar was the better option, even if its differing from the underlying platform here.

This is different from some other terms like Splat vs Broadcast or Pairwise vs Horizontal vs Across where there can be some subtle differences depending on the platform and vector size you're considering.

[kg]

Use Lane instead of Scalar in some method names. We already have ExtractLane and ReplaceLane methods. The names with Lane would be closer to instruction names as well.

Scalar is the term we use in the rest of the hardware intrinsics, whether cross platform or platform specific. The two terms are largely interchangeable and we decided back in Arm64 that standardizing on Scalar was the better option, even if its differing from the underlying platform here.

I'm one of (the?) people arguing for Lane here, because I think it makes sense for the Wasm PackedSimd intrinsic names to match the names/terminology of the underlying wasm opcodes where possible. From my perspective if you're writing code targeting wasm intrinsics that means you've probably got the spec open so you can look at the semantics of the intrinsics you're about to use to figure out how to use them, so it is unhelpful if we make up new names for all of them.

However, it does make a lot of sense that it would be useful for them to resemble the ARM or X64 intrinsics instead to ease the process of porting from one target to another. I'm not sure how to balance those tradeoffs.

[tannergooding]

Lane is in general a confusing term and it has many different meanings depending on platform/architecture. Some platforms use it to refer to the operation width of the instruction (e.g it could mean sizeof(T), it could mean sizeof(T) * n, etc)

Developers targeting WASM must think about the term Scalar regardless because of the APIs exposed on the vector types (e.g. Vector128.ToScalar) and that being the only way to do certain behaviors.

For WASM, Lane is nearly synonymous with Scalar, but there are places where it can differ. The term scalar is likewise used in the spec to describe the terminology of extract_lane and so its easier and ultimately less confusing for the end user (given the other consideration) if we just use the term Scalar everywhere where the consideration is Scalar operation.

[radekdoulik]

obsolete proposals:

Change Shuffle methods to take byte indices instead of Vector128. The shuffle instruction has 16 immediate bytes indices as input. Currently we cannot express the constant requirement on Vector128. We can change the signature to use byte indices and use [ConstantExpected] attribute on them to improve that. (it is also related to a problem where llvm crashes during compilation, when the indices are not constant)

* original approved API

    public static Vector128<sbyte> Shuffle(Vector128<sbyte> lower, Vector128<sbyte> upper, Vector128<sbyte> indices);
    public static Vector128<byte>  Shuffle(Vector128<byte>  lower, Vector128<byte>  upper, Vector128<byte> indices);

* proposed change

    public static Vector128<sbyte> Shuffle(Vector128<sbyte> lower, Vector128<sbyte> upper, [ConstantExpected] sbyte i0, ..., [ConstantExpected] sbyte i15);
    public static Vector128<byte>  Shuffle(Vector128<byte>  lower, Vector128<byte>  upper, [ConstantExpected] sbyte i0, ..., [ConstantExpected] sbyte i15);

Remove Vector128 from load method names. It is already clear from the return type, that these methods return Vector128.

* original approved API

    public static Vector128<sbyte>  LoadVector128(sbyte*  memarg);
    public static Vector128<byte>   LoadVector128(byte*   memarg);
    public static Vector128<short>  LoadVector128(short*  memarg);
    public static Vector128<ushort> LoadVector128(ushort* memarg);
    public static Vector128<int>    LoadVector128(int*    memarg);
    public static Vector128<uint>   LoadVector128(uint*   memarg);
    public static Vector128<long>   LoadVector128(long*   memarg);
    public static Vector128<ulong>  LoadVector128(ulong*  memarg);
    public static Vector128<float>  LoadVector128(float*  memarg);
    public static Vector128<double> LoadVector128(double* memarg);
    public static Vector128<nint>   LoadVector128(nint*   memarg);
    public static Vector128<nuint>  LoadVector128(nuint*  memarg);

    public static Vector128<int>    LoadScalarVector128(int*    memarg);
    public static Vector128<uint>   LoadScalarVector128(uint*   memarg);
    public static Vector128<long>   LoadScalarVector128(long*   memarg);
    public static Vector128<ulong>  LoadScalarVector128(ulong*  memarg);
    public static Vector128<float>  LoadScalarVector128(float*  memarg);
    public static Vector128<double> LoadScalarVector128(double* memarg);
    public static Vector128<nint>   LoadScalarVector128(nint*   memarg);
    public static Vector128<nuint>  LoadScalarVector128(nuint*  memarg);

    public static Vector128<sbyte>  LoadScalarAndSplatVector128(sbyte*  memarg);
    public static Vector128<byte>   LoadScalarAndSplatVector128(byte*   memarg);
    public static Vector128<short>  LoadScalarAndSplatVector128(short*  memarg);
    public static Vector128<ushort> LoadScalarAndSplatVector128(ushort* memarg);
    public static Vector128<int>    LoadScalarAndSplatVector128(int*    memarg);
    public static Vector128<uint>   LoadScalarAndSplatVector128(uint*   memarg);
    public static Vector128<long>   LoadScalarAndSplatVector128(long*   memarg);
    public static Vector128<ulong>  LoadScalarAndSplatVector128(ulong*  memarg);
    public static Vector128<float>  LoadScalarAndSplatVector128(float*  memarg);
    public static Vector128<double> LoadScalarAndSplatVector128(double* memarg);
    public static Vector128<nint>   LoadScalarAndSplatVector128(nint*   memarg);
    public static Vector128<nuint>  LoadScalarAndSplatVector128(nuint*  memarg);

    public static Vector128<short>  LoadWideningVector128(sbyte*  memarg);  // takes ImmLaneIdx16
    public static Vector128<ushort> LoadWideningVector128(byte*   memarg);  // takes ImmLaneIdx16
    public static Vector128<int>    LoadWideningVector128(short*  memarg);  // takes ImmLaneIdx8
    public static Vector128<uint>   LoadWideningVector128(ushort* memarg);  // takes ImmLaneIdx8
    public static Vector128<long>   LoadWideningVector128(int*    memarg);  // takes ImmLaneIdx4
    public static Vector128<ulong>  LoadWideningVector128(uint*   memarg);  // takes ImmLaneIdx4    

* proposed change

    public static Vector128<sbyte>  Load(sbyte*  memarg);
    public static Vector128<byte>   Load(byte*   memarg);
    public static Vector128<short>  Load(short*  memarg);
    public static Vector128<ushort> Load(ushort* memarg);
    public static Vector128<int>    Load(int*    memarg);
    public static Vector128<uint>   Load(uint*   memarg);
    public static Vector128<long>   Load(long*   memarg);
    public static Vector128<ulong>  Load(ulong*  memarg);
    public static Vector128<float>  Load(float*  memarg);
    public static Vector128<double> Load(double* memarg);
    public static Vector128<nint>   Load(nint*   memarg);
    public static Vector128<nuint>  Load(nuint*  memarg);

    public static Vector128<int>    LoadScalar(int*    memarg);
    public static Vector128<uint>   LoadScalar(uint*   memarg);
    public static Vector128<long>   LoadScalar(long*   memarg);
    public static Vector128<ulong>  LoadScalar(ulong*  memarg);
    public static Vector128<float>  LoadScalar(float*  memarg);
    public static Vector128<double> LoadScalar(double* memarg);
    public static Vector128<nint>   LoadScalar(nint*   memarg);
    public static Vector128<nuint>  LoadScalar(nuint*  memarg);

    public static Vector128<sbyte>  LoadScalarAndSplat(sbyte*  memarg);
    public static Vector128<byte>   LoadScalarAndSplat(byte*   memarg);
    public static Vector128<short>  LoadScalarAndSplat(short*  memarg);
    public static Vector128<ushort> LoadScalarAndSplat(ushort* memarg);
    public static Vector128<int>    LoadScalarAndSplat(int*    memarg);
    public static Vector128<uint>   LoadScalarAndSplat(uint*   memarg);
    public static Vector128<long>   LoadScalarAndSplat(long*   memarg);
    public static Vector128<ulong>  LoadScalarAndSplat(ulong*  memarg);
    public static Vector128<float>  LoadScalarAndSplat(float*  memarg);
    public static Vector128<double> LoadScalarAndSplat(double* memarg);
    public static Vector128<nint>   LoadScalarAndSplat(nint*   memarg);
    public static Vector128<nuint>  LoadScalarAndSplat(nuint*  memarg);

    public static Vector128<short>  LoadWidening(sbyte*  memarg);  // takes ImmLaneIdx16
    public static Vector128<ushort> LoadWidening(byte*   memarg);  // takes ImmLaneIdx16
    public static Vector128<int>    LoadWidening(short*  memarg);  // takes ImmLaneIdx8
    public static Vector128<uint>   LoadWidening(ushort* memarg);  // takes ImmLaneIdx8
    public static Vector128<long>   LoadWidening(int*    memarg);  // takes ImmLaneIdx4
    public static Vector128<ulong>  LoadWidening(uint*   memarg);  // takes ImmLaneIdx4    

Use Lane instead of Scalar in some method names. We already have ExtractLane and ReplaceLane methods. The names with Lane would be closer to instruction names as well.

    LoadScalarVector128         --> LoadLaneZero    (v128.load[8|16|32|64]_zero instructions)
    LoadScalarAndSplatVector128 --> LoadAndSplat    (v128.load[8|16|32|64]_splat instructions)
    LoadScalarAndInsert         --> LoadLane        (v128.load[8|16|32|64]_lane instructions)
    StoreSelectedScalar         --> StoreLane       (v128.store[8|16|32|64]_lane instructions)

    * original approved API

    public static unsafe Vector128<int>    LoadScalarVector128(int*    address);
    public static unsafe Vector128<uint>   LoadScalarVector128(uint*   address);
    public static unsafe Vector128<long>   LoadScalarVector128(long*   address);
    public static unsafe Vector128<ulong>  LoadScalarVector128(ulong*  address);
    public static unsafe Vector128<float>  LoadScalarVector128(float*  address);
    public static unsafe Vector128<double> LoadScalarVector128(double* address);
    public static unsafe Vector128<nint>   LoadScalarVector128(nint*   address);
    public static unsafe Vector128<nuint>  LoadScalarVector128(nuint*  address);
    public static unsafe Vector128<sbyte>  LoadScalarAndSplatVector128(sbyte*  address);
    public static unsafe Vector128<byte>   LoadScalarAndSplatVector128(byte*   address);
    public static unsafe Vector128<short>  LoadScalarAndSplatVector128(short*  address);
    public static unsafe Vector128<ushort> LoadScalarAndSplatVector128(ushort* address);
    public static unsafe Vector128<int>    LoadScalarAndSplatVector128(int*    address);
    public static unsafe Vector128<uint>   LoadScalarAndSplatVector128(uint*   address);
    public static unsafe Vector128<long>   LoadScalarAndSplatVector128(long*   address);
    public static unsafe Vector128<ulong>  LoadScalarAndSplatVector128(ulong*  address);
    public static unsafe Vector128<float>  LoadScalarAndSplatVector128(float*  address);
    public static unsafe Vector128<double> LoadScalarAndSplatVector128(double* address);
    public static unsafe Vector128<nint>   LoadScalarAndSplatVector128(nint*   address);
    public static unsafe Vector128<nuint>  LoadScalarAndSplatVector128(nuint*  address);
    public static unsafe Vector128<sbyte>  LoadScalarAndInsert(sbyte*  address, Vector128<sbyte>  vector, [ConstantExpected(Max = (byte)(15))] byte index);
    public static unsafe Vector128<byte>   LoadScalarAndInsert(byte*   address, Vector128<byte>   vector, [ConstantExpected(Max = (byte)(15))] byte index);
    public static unsafe Vector128<short>  LoadScalarAndInsert(short*  address, Vector128<short>  vector, [ConstantExpected(Max = (byte)(7))] byte index);
    public static unsafe Vector128<ushort> LoadScalarAndInsert(ushort* address, Vector128<ushort> vector, [ConstantExpected(Max = (byte)(7))] byte index);
    public static unsafe Vector128<int>    LoadScalarAndInsert(int*    address, Vector128<int>    vector, [ConstantExpected(Max = (byte)(3))] byte index);
    public static unsafe Vector128<uint>   LoadScalarAndInsert(uint*   address, Vector128<uint>   vector, [ConstantExpected(Max = (byte)(3))] byte index);
    public static unsafe Vector128<long>   LoadScalarAndInsert(long*   address, Vector128<long>   vector, [ConstantExpected(Max = (byte)(1))] byte index);
    public static unsafe Vector128<ulong>  LoadScalarAndInsert(ulong*  address, Vector128<ulong>  vector, [ConstantExpected(Max = (byte)(1))] byte index);
    public static unsafe Vector128<float>  LoadScalarAndInsert(float*  address, Vector128<float>  vector, [ConstantExpected(Max = (byte)(3))] byte index);
    public static unsafe Vector128<double> LoadScalarAndInsert(double* address, Vector128<double> vector, [ConstantExpected(Max = (byte)(1))] byte index);
    public static unsafe Vector128<nint>   LoadScalarAndInsert(nint*   address, Vector128<nint>   vector, [ConstantExpected(Max = (byte)(3))] byte index);
    public static unsafe Vector128<nuint>  LoadScalarAndInsert(nuint*  address, Vector128<nuint>  vector, [ConstantExpected(Max = (byte)(3))] byte index);
    public static unsafe void StoreSelectedScalar(sbyte*  address, Vector128<sbyte>  source, [ConstantExpected(Max = (byte)(15))] byte index); // takes ImmLaneIdx16
    public static unsafe void StoreSelectedScalar(byte*   address, Vector128<byte>   source, [ConstantExpected(Max = (byte)(15))] byte index); // takes ImmLaneIdx16
    public static unsafe void StoreSelectedScalar(short*  address, Vector128<short>  source, [ConstantExpected(Max = (byte)(7))] byte index); // takes ImmLaneIdx8
    public static unsafe void StoreSelectedScalar(ushort* address, Vector128<ushort> source, [ConstantExpected(Max = (byte)(7))] byte index); // takes ImmLaneIdx8
    public static unsafe void StoreSelectedScalar(int*    address, Vector128<int>    source, [ConstantExpected(Max = (byte)(3))] byte index); // takes ImmLaneIdx4
    public static unsafe void StoreSelectedScalar(uint*   address, Vector128<uint>   source, [ConstantExpected(Max = (byte)(3))] byte index); // takes ImmLaneIdx4
    public static unsafe void StoreSelectedScalar(long*   address, Vector128<long>   source, [ConstantExpected(Max = (byte)(1))] byte index); // takes ImmLaneIdx2
    public static unsafe void StoreSelectedScalar(ulong*  address, Vector128<ulong>  source, [ConstantExpected(Max = (byte)(1))] byte index); // takes ImmLaneIdx2
    public static unsafe void StoreSelectedScalar(float*  address, Vector128<float>  source, [ConstantExpected(Max = (byte)(3))] byte index); // takes ImmLaneIdx4
    public static unsafe void StoreSelectedScalar(double* address, Vector128<double> source, [ConstantExpected(Max = (byte)(1))] byte index); // takes ImmLaneIdx2
    public static unsafe void StoreSelectedScalar(nint*   address, Vector128<nint>   source, [ConstantExpected(Max = (byte)(3))] byte index);
    public static unsafe void StoreSelectedScalar(nuint*  address, Vector128<nuint>  source, [ConstantExpected(Max = (byte)(3))] byte index);

    * proposed change

    public static unsafe Vector128<int>    LoadLaneZero(int*    address);
    public static unsafe Vector128<uint>   LoadLaneZero(uint*   address);
    public static unsafe Vector128<long>   LoadLaneZero(long*   address);
    public static unsafe Vector128<ulong>  LoadLaneZero(ulong*  address);
    public static unsafe Vector128<float>  LoadLaneZero(float*  address);
    public static unsafe Vector128<double> LoadLaneZero(double* address);
    public static unsafe Vector128<nint>   LoadLaneZero(nint*   address);
    public static unsafe Vector128<nuint>  LoadLaneZero(nuint*  address);
    public static unsafe Vector128<sbyte>  LoadAndSplat(sbyte*  address);
    public static unsafe Vector128<byte>   LoadAndSplat(byte*   address);
    public static unsafe Vector128<short>  LoadAndSplat(short*  address);
    public static unsafe Vector128<ushort> LoadAndSplat(ushort* address);
    public static unsafe Vector128<int>    LoadAndSplat(int*    address);
    public static unsafe Vector128<uint>   LoadAndSplat(uint*   address);
    public static unsafe Vector128<long>   LoadAndSplat(long*   address);
    public static unsafe Vector128<ulong>  LoadAndSplat(ulong*  address);
    public static unsafe Vector128<float>  LoadAndSplat(float*  address);
    public static unsafe Vector128<double> LoadAndSplat(double* address);
    public static unsafe Vector128<nint>   LoadAndSplat(nint*   address);
    public static unsafe Vector128<nuint>  LoadAndSplat(nuint*  address);
    public static unsafe Vector128<sbyte>  LoadLane(sbyte*  address, Vector128<sbyte>  vector, [ConstantExpected(Max = (byte)(15))] byte index);
    public static unsafe Vector128<byte>   LoadLane(byte*   address, Vector128<byte>   vector, [ConstantExpected(Max = (byte)(15))] byte index);
    public static unsafe Vector128<short>  LoadLane(short*  address, Vector128<short>  vector, [ConstantExpected(Max = (byte)(7))] byte index);
    public static unsafe Vector128<ushort> LoadLane(ushort* address, Vector128<ushort> vector, [ConstantExpected(Max = (byte)(7))] byte index);
    public static unsafe Vector128<int>    LoadLane(int*    address, Vector128<int>    vector, [ConstantExpected(Max = (byte)(3))] byte index);
    public static unsafe Vector128<uint>   LoadLane(uint*   address, Vector128<uint>   vector, [ConstantExpected(Max = (byte)(3))] byte index);
    public static unsafe Vector128<long>   LoadLane(long*   address, Vector128<long>   vector, [ConstantExpected(Max = (byte)(1))] byte index);
    public static unsafe Vector128<ulong>  LoadLane(ulong*  address, Vector128<ulong>  vector, [ConstantExpected(Max = (byte)(1))] byte index);
    public static unsafe Vector128<float>  LoadLane(float*  address, Vector128<float>  vector, [ConstantExpected(Max = (byte)(3))] byte index);
    public static unsafe Vector128<double> LoadLane(double* address, Vector128<double> vector, [ConstantExpected(Max = (byte)(1))] byte index);
    public static unsafe Vector128<nint>   LoadLane(nint*   address, Vector128<nint>   vector, [ConstantExpected(Max = (byte)(3))] byte index);
    public static unsafe Vector128<nuint>  LoadLane(nuint*  address, Vector128<nuint>  vector, [ConstantExpected(Max = (byte)(3))] byte index);
    public static unsafe void StoreLane(sbyte*  address, Vector128<sbyte>  source, [ConstantExpected(Max = (byte)(15))] byte index); // takes ImmLaneIdx16
    public static unsafe void StoreLane(byte*   address, Vector128<byte>   source, [ConstantExpected(Max = (byte)(15))] byte index); // takes ImmLaneIdx16
    public static unsafe void StoreLane(short*  address, Vector128<short>  source, [ConstantExpected(Max = (byte)(7))] byte index); // takes ImmLaneIdx8
    public static unsafe void StoreLane(ushort* address, Vector128<ushort> source, [ConstantExpected(Max = (byte)(7))] byte index); // takes ImmLaneIdx8
    public static unsafe void StoreLane(int*    address, Vector128<int>    source, [ConstantExpected(Max = (byte)(3))] byte index); // takes ImmLaneIdx4
    public static unsafe void StoreLane(uint*   address, Vector128<uint>   source, [ConstantExpected(Max = (byte)(3))] byte index); // takes ImmLaneIdx4
    public static unsafe void StoreLane(long*   address, Vector128<long>   source, [ConstantExpected(Max = (byte)(1))] byte index); // takes ImmLaneIdx2
    public static unsafe void StoreLane(ulong*  address, Vector128<ulong>  source, [ConstantExpected(Max = (byte)(1))] byte index); // takes ImmLaneIdx2
    public static unsafe void StoreLane(float*  address, Vector128<float>  source, [ConstantExpected(Max = (byte)(3))] byte index); // takes ImmLaneIdx4
    public static unsafe void StoreLane(double* address, Vector128<double> source, [ConstantExpected(Max = (byte)(1))] byte index); // takes ImmLaneIdx2
    public static unsafe void StoreLane(nint*   address, Vector128<nint>   source, [ConstantExpected(Max = (byte)(3))] byte index);
    public static unsafe void StoreLane(nuint*  address, Vector128<nuint>  source, [ConstantExpected(Max = (byte)(3))] byte index);

[radekdoulik]

Change Shuffle methods to take byte indices instead of Vector128. The shuffle instruction has 16 immediate bytes indices as input. Currently we cannot express the constant requirement on Vector128. We can change the signature to use byte indices and use [ConstantExpected] attribute on them to improve that. (it is also related to a problem where llvm crashes during compilation, when the indices are not constant)

This change doesn't "fix" the problem. This also doesn't fix that the cross platform API signature takes a V128 and therefore the general handling must exist anyways.

The cross platform API has different Shuffle than wasm so it would help. The cross platform Shuffle is wasm's Swizzle, which doesn't need immediate values. I left it in "obsolete proposals:" to not block the review. Hopefully we can find better solution for the problem or get back to it later.