API Proposal : Arm TableVectorLookup and TableVectorExtension intrinsics

The instructions `TBL` and `TBX` do a table lookup using a vector of indices and a "table" which is created by concatenating all the input vectors together.

The difference between a `TBL` and a `TBX` is that a `TBL` will return `0` for any indices that are out of range and `TBX` is a destructive variant which will leave the corresponding value to the out of range index untouched.

I've modelled them using tuples for the register list as the instructions have an explicit requirement that the input vectors must use consecutive registers.

This fits in the general design of https://github.com/dotnet/corefx/issues/26574

```C#
namespace System.Runtime.Intrinsics.Arm
{
    public abstract partial class AdvSimd : System.Runtime.Intrinsics.Arm.ArmBase
    {
        /// <summary>
        ///  uint8x8_t vqvtbx1_u8(uint8x8_t r, uint8x16_t t, uint8x8_t idx)
        ///   A32: VTBX Dd,{Dn, Dn+1},Dm
        ///   A64: TBX Vd.8B,{Vn.16B},Vm.8B
        /// </summary>
        public static Vector64<byte> VectorTableExtension (Vector64<byte> result, ValueTuple<Vector128<byte>> list, Vector64<byte> idx) { throw null; }

        /// <summary>
        ///  uint8x8_t vqvtbl1_u8(uint8x16_t t, uint8x8_t idx)
        ///   A32: VTBL Dd,{Dn, Dn+1},Dm
        ///   A64: TBL Vd.8B,{Vn.16B},Vm.8B
        /// </summary>
        public static Vector64<byte> VectorTableLookup (ValueTuple<Vector128<byte>> list, Vector64<byte> idx) { throw null; }

        /// <summary>
        ///  uint8x8_t vqvtbx2_u8(uint8x8_t r, uint8x16x2_t t, uint8x8_t idx)
        ///   A32: VTBX Dd,{Dn, Dn+1, Dn+2, Dn+3},Dm
        ///   A64: TBX Vd.8B,{Vn.16B - Vn+1.16B},Vm.8B
        /// </summary>
        public static Vector64<byte> VectorTableExtension (Vector64<byte> result, ValueTuple<Vector128<byte>,Vector128<byte>> list, Vector64<byte> idx) { throw null; }

        /// <summary>
        ///  uint8x8_t vqvtbl2_u8(uint8x16x2_t t, uint8x8_t idx)
        ///   A32: VTBL Dd,{Dn, Dn+1, Dn+2, Dn+3},Dm
        ///   A64: TBL Vd.8B,{Vn.16B - Vn+1.16B},Vm.8B
        /// </summary>
        public static Vector64<byte> VectorTableLookup (ValueTuple<Vector128<byte>,Vector128<byte>> list, Vector64<byte> idx) { throw null; }

        /// <summary>
        ///  int8x8_t vqvtbx1_s8(int8x8_t r, int8x16_t t, uint8x8_t idx)
        ///   A32: VTBX Dd,{Dn, Dn+1},Dm
        ///   A64: TBX Vd.8B,{Vn.16B},Vm.8B
        /// </summary>
        public static Vector64<sbyte> VectorTableExtension (Vector64<byte> result, ValueTuple<Vector128<sbyte>> list, Vector64<sbyte> idx) { throw null; }

        /// <summary>
        ///  int8x8_t vqvtbl1_s8(int8x16_t t, uint8x8_t idx)
        ///   A32: VTBL Dd,{Dn, Dn+1},Dm
        ///   A64: TBL Vd.8B,{Vn.16B},Vm.8B
        /// </summary>
        public static Vector64<sbyte> VectorTableLookup (ValueTuple<Vector128<sbyte>> list, Vector64<sbyte> idx) { throw null; }

        /// <summary>
        ///  int8x8_t vqvtbx2_s8(int8x8_t r, int8x16x2_t t, uint8x8_t idx)
        ///   A32: VTBX Dd,{Dn, Dn+1, Dn+2, Dn+3},Dm
        ///   A64: TBX Vd.8B,{Vn.16B - Vn+1.16B},Vm.8B
        /// </summary>
        public static Vector64<sbyte> VectorTableExtension (Vector64<byte> result, ValueTuple<Vector128<sbyte>,Vector128<sbyte>> list, Vector64<sbyte> idx) { throw null; }

        /// <summary>
        ///  int8x8_t vqvtbl2_s8(int8x16x2_t t, uint8x8_t idx)
        ///   A32: VTBL Dd,{Dn, Dn+1, Dn+2, Dn+3},Dm
        ///   A64: TBL Vd.8B,{Vn.16B - Vn+1.16B},Vm.8B
        /// </summary>
        public static Vector64<sbyte> VectorTableLookup (ValueTuple<Vector128<sbyte>,Vector128<sbyte>> list, Vector64<sbyte> idx) { throw null; }

        public new abstract partial class Arm64 : System.Runtime.Intrinsics.Arm.ArmBase.Arm64
        {
           /// <summary>
           ///  uint8x8_t vqvtbx3_u8(uint8x8_t r, uint8x16x3_t t, uint8x8_t idx)
           ///   A64: TBX Vd.8B,{Vn.16B - Vn+2.16B},Vm.8B
           /// </summary>
           public static Vector64<byte> VectorTableExtension (Vector64<byte> result, ValueTuple<Vector128<byte>,Vector128<byte>,Vector128<byte>> list, Vector64<byte> idx) { throw null; }

           /// <summary>
           ///  uint8x8_t vqvtbl3_u8(uint8x16x3_t t, uint8x8_t idx)
           ///   A64: TBL Vd.8B,{Vn.16B - Vn+2.16B},Vm.8B
           /// </summary>
           public static Vector64<byte> VectorTableLookup (ValueTuple<Vector128<byte>,Vector128<byte>,Vector128<byte>> list, Vector64<byte> idx) { throw null; }

           /// <summary>
           ///  uint8x8_t vqvtbx4_u8(uint8x8_t r, uint8x16x4_t t, uint8x8_t idx)
           ///   A64: TBX Vd.8B,{Vn.16B - Vn+3.16B},Vm.8B
           /// </summary>
           public static Vector64<byte> VectorTableExtension (Vector64<byte> result, ValueTuple<Vector128<byte>,Vector128<byte>,Vector128<byte>,Vector128<byte>> list, Vector64<byte> idx) { throw null; }

           /// <summary>
           ///  uint8x8_t vqvtbl4_u8(uint8x16x4_t t, uint8x8_t idx)
           ///   A64: TBL Vd.8B,{Vn.16B - Vn+3.16B},Vm.8B
           /// </summary>
           public static Vector64<byte> VectorTableLookup (ValueTuple<Vector128<byte>,Vector128<byte>,Vector128<byte>,Vector128<byte>> list, Vector64<byte> idx) { throw null; }

           /// <summary>
           ///  int8x8_t vqvtbx3_s8(int8x8_t r, int8x16x3_t t, uint8x8_t idx)
           ///   A64: TBX Vd.8B,{Vn.16B - Vn+2.16B},Vm.8B
           /// </summary>
           public static Vector64<sbyte> VectorTableExtension (Vector64<byte> result, ValueTuple<Vector128<sbyte>,Vector128<sbyte>,Vector128<sbyte>> list, Vector64<sbyte> idx) { throw null; }

           /// <summary>
           ///  int8x8_t vqvtbl3_s8(int8x16x3_t t, uint8x8_t idx)
           ///   A64: TBL Vd.8B,{Vn.16B - Vn+2.16B},Vm.8B
           /// </summary>
           public static Vector64<sbyte> VectorTableLookup (ValueTuple<Vector128<sbyte>,Vector128<sbyte>,Vector128<sbyte>> list, Vector64<sbyte> idx) { throw null; }

           /// <summary>
           ///  int8x8_t vqvtbx4_s8(int8x8_t r, int8x16x4_t t, uint8x8_t idx)
           ///   A64: TBX Vd.8B,{Vn.16B - Vn+3.16B},Vm.8B
           /// </summary>
           public static Vector64<sbyte> VectorTableExtension (Vector64<byte> result, ValueTuple<Vector128<sbyte>,Vector128<sbyte>,Vector128<sbyte>,Vector128<sbyte>> list, Vector64<sbyte> idx) { throw null; }

           /// <summary>
           ///  int8x8_t vqvtbl4_s8(int8x16x4_t t, uint8x8_t idx)
           ///   A64: TBL Vd.8B,{Vn.16B - Vn+3.16B},Vm.8B
           /// </summary>
           public static Vector64<sbyte> VectorTableLookup (ValueTuple<Vector128<sbyte>,Vector128<sbyte>,Vector128<sbyte>,Vector128<sbyte>> list, Vector64<sbyte> idx) { throw null; }

           /// <summary>
           ///  uint8x16_t vqvtbx1q_u8(uint8x16_t r, int8x16_t t, uint8x16_t idx)
           ///   A64: TBX Vd.16B,{Vn.16B},Vm.16B
           /// </summary>
           public static Vector128<byte> VectorTableExtension (Vector128<byte> result, ValueTuple<Vector128<byte>> list, Vector128<byte> idx) { throw null; }

           /// <summary>
           ///  uint8x16_t vqvtbl1q_u8(uint8x16_t t, uint8x16_t idx)
           ///   A64: TBL Vd.16B,{Vn.16B},Vm.16B
           /// </summary>
           public static Vector128<byte> VectorTableLookup (ValueTuple<Vector128<byte>> list, Vector128<byte> idx) { throw null; }

           /// <summary>
           ///  uint8x16_t vqvtbx2q_u8(uint8x16_t r, uint8x16x2_t t, uint8x16_t idx)
           ///   A64: TBX Vd.16B,{Vn.16B - Vn+1.16B},Vm.16B
           /// </summary>
           public static Vector128<byte> VectorTableExtension (Vector128<byte> result, ValueTuple<Vector128<byte>,Vector128<byte>> list, Vector128<byte> idx) { throw null; }

           /// <summary>
           ///  uint8x16_t vqvtbl2q_u8(uint8x16x2_t t, uint8x16_t idx)
           ///   A64: TBL Vd.16B,{Vn.16B - Vn+1.16B},Vm.16B
           /// </summary>
           public static Vector128<byte> VectorTableLookup (ValueTuple<Vector128<byte>,Vector128<byte>> list, Vector128<byte> idx) { throw null; }

           /// <summary>
           ///  uint8x16_t vqvtbx3q_u8(uint8x16_t r, uint8x16x3_t t, uint8x16_t idx)
           ///   A64: TBX Vd.16B,{Vn.16B - Vn+2.16B},Vm.16B
           /// </summary>
           public static Vector128<byte> VectorTableExtension (Vector128<byte> result, ValueTuple<Vector128<byte>,Vector128<byte>,Vector128<byte>> list, Vector128<byte> idx) { throw null; }

           /// <summary>
           ///  uint8x16_t vqvtbl3q_u8(uint8x16x3_t t, uint8x16_t idx)
           ///   A64: TBL Vd.16B,{Vn.16B - Vn+2.16B},Vm.16B
           /// </summary>
           public static Vector128<byte> VectorTableLookup (ValueTuple<Vector128<byte>,Vector128<byte>,Vector128<byte>> list, Vector128<byte> idx) { throw null; }

           /// <summary>
           ///  uint8x16_t vqvtbx3q_u8(uint8x16_t r, uint8x16x3_t t, uint8x16_t idx)
           ///   A64: TBX Vd.16B,{Vn.16B - Vn+2.16B},Vm.16B
           /// </summary>
           public static Vector128<byte> VectorTableExtension (Vector128<byte> result, ValueTuple<Vector128<byte>,Vector128<byte>,Vector128<byte>,Vector128<byte>> list, Vector128<byte> idx) { throw null; }

           /// <summary>
           ///  uint8x16_t vqvtbl3q_u8(uint8x16x3_t t, uint8x16_t idx)
           ///   A64: TBL Vd.16B,{Vn.16B - Vn+2.16B},Vm.16B
           /// </summary>
           public static Vector128<byte> VectorTableLookup (ValueTuple<Vector128<byte>,Vector128<byte>,Vector128<byte>,Vector128<byte>> list, Vector128<byte> idx) { throw null; }

           /// <summary>
           ///  int8x16_t vqvtbx1q_s8(int8x16_t r, int8x16_t t, uint8x16_t idx)
           ///   A64: TBX Vd.16B,{Vn.16B},Vm.16B
           /// </summary>
           public static Vector128<sbyte> VectorTableExtension (Vector128<byte> result, ValueTuple<Vector128<sbyte>> list, Vector128<sbyte> idx) { throw null; }

           /// <summary>
           ///  int8x16_t vqvtbl1q_s8(int8x16_t t, uint8x16_t idx)
           ///   A64: TBL Vd.16B,{Vn.16B},Vm.16B
           /// </summary>
           public static Vector128<sbyte> VectorTableLookup (ValueTuple<Vector128<sbyte>> list, Vector128<sbyte> idx) { throw null; }

           /// <summary>
           ///  int8x16_t vqvtbx2q_s8(int8x16_t r, int8x16x2_t t, uint8x16_t idx)
           ///   A64: TBX Vd.16B,{Vn.16B - Vn+1.16B},Vm.16B
           /// </summary>
           public static Vector128<sbyte> VectorTableExtension (Vector128<byte> result, ValueTuple<Vector128<sbyte>,Vector128<sbyte>> list, Vector128<sbyte> idx) { throw null; }

           /// <summary>
           ///  int8x16_t vqvtbl2q_s8(int8x16x2_t t, uint8x16_t idx)
           ///   A64: TBL Vd.16B,{Vn.16B - Vn+1.16B},Vm.16B
           /// </summary>
           public static Vector128<sbyte> VectorTableLookup (ValueTuple<Vector128<sbyte>,Vector128<sbyte>> list, Vector128<sbyte> idx) { throw null; }

           /// <summary>
           ///  int8x16_t vqvtbx3q_s8(int8x16_t r, int8x16x3_t t, uint8x16_t idx)
           ///   A64: TBX Vd.16B,{Vn.16B - Vn+2.16B},Vm.16B
           /// </summary>
           public static Vector128<sbyte> VectorTableExtension (Vector128<byte> result, ValueTuple<Vector128<sbyte>,Vector128<sbyte>,Vector128<sbyte>> list, Vector128<sbyte> idx) { throw null; }

           /// <summary>
           ///  int8x16_t vqvtbl3q_s8(int8x16x3_t t, uint8x16_t idx)
           ///   A64: TBL Vd.16B,{Vn.16B - Vn+2.16B},Vm.16B
           /// </summary>
           public static Vector128<sbyte> VectorTableLookup (ValueTuple<Vector128<sbyte>,Vector128<sbyte>,Vector128<sbyte>> list, Vector128<sbyte> idx) { throw null; }

           /// <summary>
           ///  int8x16_t vqvtbl4q_s8(int8x16_t r, int8x16x4_t t, uint8x16_t idx)
           ///   A64: TBL Vd.16B,{Vn.16B - Vn+3.16B},Vm.16B
           /// </summary>
           public static Vector128<sbyte> VectorTableExtension (Vector128<byte> result, ValueTuple<Vector128<sbyte>,Vector128<sbyte>,Vector128<sbyte>,Vector128<sbyte>> list, Vector128<sbyte> idx) { throw null; }

           /// <summary>
           ///  int8x16_t vqvtbl4q_s8(int8x16x4_t t, uint8x16_t idx)
           ///   A64: TBL Vd.16B,{Vn.16B - Vn+3.16B},Vm.16B
           /// </summary>
           public static Vector128<sbyte> VectorTableLookup (ValueTuple<Vector128<sbyte>,Vector128<sbyte>,Vector128<sbyte>,Vector128<sbyte>> list, Vector128<sbyte> idx) { throw null; }
        }

        public new abstract partial class Arm32 : System.Runtime.Intrinsics.Arm.ArmBase.Arm32
        {
           /// <summary>
           ///  uint8x8_t vtbx1_u8(uint8x8_t r, uint8x8_t a, uint8x8_t idx)
           ///   A32: TBX Vd.8B,{Vn.16B},Vm.8B
           /// </summary>
           public static Vector64<byte> VectorTableExtension (Vector64<byte> result, ValueTuple<Vector64<byte>> list, Vector64<byte> idx) { throw null; }

           /// <summary>
           ///  uint8x8_t vtbl1_u8(uint8x8_t a, uint8x8_t idx)
           ///   A32: TBL Vd.8B,{Vn.16B},Vm.8B
           /// </summary>
           public static Vector64<byte> VectorTableLookup (ValueTuple<Vector64<byte>> list, Vector64<byte> idx) { throw null; }

           /// <summary>
           ///  uint8x8_t vtbx2_u8(uint8x8_t r, uint8x8x2_t a, uint8x8_t idx)
           ///   A32: TBX Vd.8B,{Vn.16B},Vm.8B
           /// </summary>
           public static Vector64<byte> VectorTableExtension (Vector64<byte> result, ValueTuple<Vector64<byte>,Vector64<byte>> list, Vector64<byte> idx) { throw null; }

           /// <summary>
           ///  uint8x8_t vtbl2_u8(uint8x8x2_t a, uint8x8_t idx)
           ///   A32: TBL Vd.8B,{Vn.16B},Vm.8B
           /// </summary>
           public static Vector64<byte> VectorTableLookup (ValueTuple<Vector64<byte>,Vector64<byte>> list, Vector64<byte> idx) { throw null; }

           /// <summary>
           ///  uint8x8_t vtbx3_u8(uint8x8_t r, uint8x8x3_t a, uint8x8_t idx)
           ///   A32: TBX Vd.8B,{Vn.16B,Vn+1.16B},Vm.8B
           /// </summary>
           public static Vector64<byte> VectorTableExtension (Vector64<byte> result, ValueTuple<Vector64<byte>,Vector64<byte>,Vector64<byte>> list, Vector64<byte> idx) { throw null; }

           /// <summary>
           ///  uint8x8_t vtbl3_u8(uint8x8x3_t a, uint8x8_t idx)
           ///   A32: TBL Vd.8B,{Vn.16B,Vn+1.16B},Vm.8B
           /// </summary>
           public static Vector64<byte> VectorTableLookup (ValueTuple<Vector64<byte>,Vector64<byte>,Vector64<byte>> list, Vector64<byte> idx) { throw null; }

           /// <summary>
           ///  uint8x8_t vtbx4_u8(uint8x8_t r, uint8x8x4_t a, uint8x8_t idx)
           ///   A32: TBX Vd.8B,{Vn.16B,Vn+1.16B},Vm.8B
           /// </summary>
           public static Vector64<byte> VectorTableExtension (Vector64<byte> result, ValueTuple<Vector64<byte>,Vector64<byte>,Vector64<byte>,Vector64<byte>> list, Vector64<byte> idx) { throw null; }

           /// <summary>
           ///  uint8x8_t vtbl4_u8(uint8x8x4_t a, uint8x8_t idx)
           ///   A32: TBL Vd.8B,{Vn.16B,Vn+1.16B},Vm.8B
           /// </summary>
           public static Vector64<byte> VectorTableLookup (ValueTuple<Vector64<byte>,Vector64<byte>,Vector64<byte>,Vector64<byte>> list, Vector64<byte> idx) { throw null; }

           /// <summary>
           ///  int8x8_t vtbx1_s8(int8x8_t r, int8x8_t a, int8x8_t idx)
           ///   A32: TBX Vd.8B,{Vn.16B},Vm.8B
           /// </summary>
           public static Vector64<sbyte> VectorTableExtension (Vector64<byte> result, ValueTuple<Vector64<sbyte>> list, Vector64<sbyte> idx) { throw null; }

           /// <summary>
           ///  int8x8_t vtbl1_s8(int8x8_t a, int8x8_t idx)
           ///   A32: TBL Vd.8B,{Vn.16B},Vm.8B
           /// </summary>
           public static Vector64<sbyte> VectorTableLookup (ValueTuple<Vector64<sbyte>> list, Vector64<sbyte> idx) { throw null; }

           /// <summary>
           ///  int8x8_t vtbx2_s8(int8x8_t r, int8x8x2_t a, int8x8_t idx)
           ///   A32: TBX Vd.8B,{Vn.16B},Vm.8B
           /// </summary>
           public static Vector64<sbyte> VectorTableExtension (Vector64<byte> result, ValueTuple<Vector64<sbyte>,Vector64<sbyte>> list, Vector64<sbyte> idx) { throw null; }

           /// <summary>
           ///  int8x8_t vtbl2_s8(int8x8x2_t a, int8x8_t idx)
           ///   A32: TBL Vd.8B,{Vn.16B},Vm.8B
           /// </summary>
           public static Vector64<sbyte> VectorTableLookup (ValueTuple<Vector64<sbyte>,Vector64<sbyte>> list, Vector64<sbyte> idx) { throw null; }

           /// <summary>
           ///  int8x8_t vtbx3_s8(int8x8_t r, int8x8x3_t a, int8x8_t idx)
           ///   A32: TBX Vd.8B,{Vn.16B,Vn+1.16B},Vm.8B
           /// </summary>
           public static Vector64<sbyte> VectorTableExtension (Vector64<byte> result, ValueTuple<Vector64<sbyte>,Vector64<sbyte>,Vector64<sbyte>> list, Vector64<sbyte> idx) { throw null; }

           /// <summary>
           ///  int8x8_t vtbl3_s8(int8x8x3_t a, int8x8_t idx)
           ///   A32: TBL Vd.8B,{Vn.16B,Vn+1.16B},Vm.8B
           /// </summary>
           public static Vector64<sbyte> VectorTableLookup (ValueTuple<Vector64<sbyte>,Vector64<sbyte>,Vector64<sbyte>> list, Vector64<sbyte> idx) { throw null; }

           /// <summary>
           ///  int8x8_t vtbx4_s8(int8x8_t r, int8x8x4_t a, int8x8_t idx)
           ///   A32: TBX Vd.8B,{Vn.16B,Vn+1.16B},Vm.8B
           /// </summary>
           public static Vector64<sbyte> VectorTableExtension (Vector64<byte> result, ValueTuple<Vector64<sbyte>,Vector64<sbyte>,Vector64<sbyte>,Vector64<sbyte>> list, Vector64<sbyte> idx) { throw null; }

           /// <summary>
           ///  int8x8_t vtbl4_s8(int8x8x4_t a, int8x8_t idx)
           ///   A32: TBL Vd.8B,{Vn.16B,Vn+1.16B},Vm.8B
           /// </summary>
           public static Vector64<sbyte> VectorTableLookup (ValueTuple<Vector64<sbyte>,Vector64<sbyte>,Vector64<sbyte>,Vector64<sbyte>> list, Vector64<sbyte> idx) { throw null; }
        }
    }
}
```

/cc @tannergooding @CarolEidt @echesakovMSFT

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

API Proposal : Arm TableVectorLookup and TableVectorExtension intrinsics #1277

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

API Proposal : Arm TableVectorLookup and TableVectorExtension intrinsics #1277

Description

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions