feat: Add simd shuffle / swizzle aliases for i16x8, i32x4, i64x2, f32x4 and f64x2 (#2368)

Author: MaxGraey

src/builtins.ts

@@ -541,6 +541,8 @@ export namespace BuiltinNames {
   export const i16x8_extmul_low_i8x16_u = "~lib/builtins/i16x8.extmul_low_i8x16_u";
   export const i16x8_extmul_high_i8x16_s = "~lib/builtins/i16x8.extmul_high_i8x16_s";
   export const i16x8_extmul_high_i8x16_u = "~lib/builtins/i16x8.extmul_high_i8x16_u";
+  export const i16x8_shuffle = "~lib/builtins/i16x8.shuffle";
+  export const i16x8_swizzle = "~lib/builtins/i16x8.swizzle";
 
   export const i32x4_splat = "~lib/builtins/i32x4.splat";
   export const i32x4_extract_lane = "~lib/builtins/i32x4.extract_lane";
@@ -584,6 +586,8 @@ export namespace BuiltinNames {
   export const i32x4_extmul_low_i16x8_u = "~lib/builtins/i32x4.extmul_low_i16x8_u";
   export const i32x4_extmul_high_i16x8_s = "~lib/builtins/i32x4.extmul_high_i16x8_s";
   export const i32x4_extmul_high_i16x8_u = "~lib/builtins/i32x4.extmul_high_i16x8_u";
+  export const i32x4_shuffle = "~lib/builtins/i32x4.shuffle";
+  export const i32x4_swizzle = "~lib/builtins/i32x4.swizzle";
 
   export const i64x2_splat = "~lib/builtins/i64x2.splat";
   export const i64x2_extract_lane = "~lib/builtins/i64x2.extract_lane";
@@ -616,6 +620,8 @@ export namespace BuiltinNames {
   export const i64x2_extmul_low_i32x4_u = "~lib/builtins/i64x2.extmul_low_i32x4_u";
   export const i64x2_extmul_high_i32x4_s = "~lib/builtins/i64x2.extmul_high_i32x4_s";
   export const i64x2_extmul_high_i32x4_u = "~lib/builtins/i64x2.extmul_high_i32x4_u";
+  export const i64x2_shuffle = "~lib/builtins/i64x2.shuffle";
+  export const i64x2_swizzle = "~lib/builtins/i64x2.swizzle";
 
   export const f32x4_splat = "~lib/builtins/f32x4.splat";
   export const f32x4_extract_lane = "~lib/builtins/f32x4.extract_lane";
@@ -644,6 +650,8 @@ export namespace BuiltinNames {
   export const f32x4_convert_i32x4_s = "~lib/builtins/f32x4.convert_i32x4_s";
   export const f32x4_convert_i32x4_u = "~lib/builtins/f32x4.convert_i32x4_u";
   export const f32x4_demote_f64x2_zero = "~lib/builtins/f32x4.demote_f64x2_zero";
+  export const f32x4_shuffle = "~lib/builtins/f32x4.shuffle";
+  export const f32x4_swizzle = "~lib/builtins/f32x4.swizzle";
 
   export const f64x2_splat = "~lib/builtins/f64x2.splat";
   export const f64x2_extract_lane = "~lib/builtins/f64x2.extract_lane";
@@ -672,6 +680,8 @@ export namespace BuiltinNames {
   export const f64x2_convert_low_i32x4_s = "~lib/builtins/f64x2.convert_low_i32x4_s";
   export const f64x2_convert_low_i32x4_u = "~lib/builtins/f64x2.convert_low_i32x4_u";
   export const f64x2_promote_low_f32x4 = "~lib/builtins/f64x2.promote_low_f32x4";
+  export const f64x2_shuffle = "~lib/builtins/f64x2.shuffle";
+  export const f64x2_swizzle = "~lib/builtins/f64x2.swizzle";
 
   export const i31_new = "~lib/builtins/i31.new";
   export const i31_get = "~lib/builtins/i31.get";
@@ -8337,7 +8347,6 @@ builtins.set(BuiltinNames.i8x16_shuffle, builtin_i8x16_shuffle);
 
 // i8x16.swizzle -> v128.swizzle
 function builtin_i8x16_swizzle(ctx: BuiltinContext): ExpressionRef {
-  checkTypeAbsent(ctx);
   ctx.typeArguments = null;
   ctx.contextualType = Type.v128;
   return builtin_v128_swizzle(ctx);
@@ -8758,6 +8767,23 @@ function builtin_i16x8_extmul_high_i8x16_u(ctx: BuiltinContext): ExpressionRef {
 }
 builtins.set(BuiltinNames.i16x8_extmul_high_i8x16_u, builtin_i16x8_extmul_high_i8x16_u);
 
+// i16x8.shuffle -> v128.shuffle<i16>
+function builtin_i16x8_shuffle(ctx: BuiltinContext): ExpressionRef {
+  checkTypeAbsent(ctx);
+  ctx.typeArguments = [ Type.i16 ];
+  ctx.contextualType = Type.v128;
+  return builtin_v128_shuffle(ctx);
+}
+builtins.set(BuiltinNames.i16x8_shuffle, builtin_i16x8_shuffle);
+
+// i16x8.swizzle -> v128.swizzle
+function builtin_i16x8_swizzle(ctx: BuiltinContext): ExpressionRef {
+  ctx.typeArguments = null;
+  ctx.contextualType = Type.v128;
+  return builtin_v128_swizzle(ctx);
+}
+builtins.set(BuiltinNames.i16x8_swizzle, builtin_i16x8_swizzle);
+
 // i32x4.splat -> v128.splat<i32>
 function builtin_i32x4_splat(ctx: BuiltinContext): ExpressionRef {
   checkTypeAbsent(ctx);
@@ -9136,6 +9162,23 @@ function builtin_i32x4_extmul_high_i16x8_u(ctx: BuiltinContext): ExpressionRef {
 }
 builtins.set(BuiltinNames.i32x4_extmul_high_i16x8_u, builtin_i32x4_extmul_high_i16x8_u);
 
+// i32x4.shuffle -> v128.shuffle<i32>
+function builtin_i32x4_shuffle(ctx: BuiltinContext): ExpressionRef {
+  checkTypeAbsent(ctx);
+  ctx.typeArguments = [ Type.i32 ];
+  ctx.contextualType = Type.v128;
+  return builtin_v128_shuffle(ctx);
+}
+builtins.set(BuiltinNames.i32x4_shuffle, builtin_i32x4_shuffle);
+
+// i32x4.swizzle -> v128.swizzle
+function builtin_i32x4_swizzle(ctx: BuiltinContext): ExpressionRef {
+  ctx.typeArguments = null;
+  ctx.contextualType = Type.v128;
+  return builtin_v128_swizzle(ctx);
+}
+builtins.set(BuiltinNames.i32x4_swizzle, builtin_i32x4_swizzle);
+
 // i64x2.splat -> v128.splat<i64>
 function builtin_i64x2_splat(ctx: BuiltinContext): ExpressionRef {
   checkTypeAbsent(ctx);
@@ -9379,6 +9422,23 @@ function builtin_i64x2_extmul_high_i32x4_u(ctx: BuiltinContext): ExpressionRef {
 }
 builtins.set(BuiltinNames.i64x2_extmul_high_i32x4_u, builtin_i64x2_extmul_high_i32x4_u);
 
+// i64x2.shuffle -> v128.shuffle<i64>
+function builtin_i64x2_shuffle(ctx: BuiltinContext): ExpressionRef {
+  checkTypeAbsent(ctx);
+  ctx.typeArguments = [ Type.i64 ];
+  ctx.contextualType = Type.v128;
+  return builtin_v128_shuffle(ctx);
+}
+builtins.set(BuiltinNames.i64x2_shuffle, builtin_i64x2_shuffle);
+
+// i64x2.swizzle -> v128.swizzle
+function builtin_i64x2_swizzle(ctx: BuiltinContext): ExpressionRef {
+  ctx.typeArguments = null;
+  ctx.contextualType = Type.v128;
+  return builtin_v128_swizzle(ctx);
+}
+builtins.set(BuiltinNames.i64x2_swizzle, builtin_i64x2_swizzle);
+
 // f32x4.splat -> v128.splat<f32>
 function builtin_f32x4_splat(ctx: BuiltinContext): ExpressionRef {
   checkTypeAbsent(ctx);
@@ -9622,6 +9682,23 @@ function builtin_f32x4_demote_f64x2_zero(ctx: BuiltinContext): ExpressionRef {
 }
 builtins.set(BuiltinNames.f32x4_demote_f64x2_zero, builtin_f32x4_demote_f64x2_zero);
 
+// f32x4.shuffle -> v128.shuffle<f32>
+function builtin_f32x4_shuffle(ctx: BuiltinContext): ExpressionRef {
+  checkTypeAbsent(ctx);
+  ctx.typeArguments = [ Type.f32 ];
+  ctx.contextualType = Type.v128;
+  return builtin_v128_shuffle(ctx);
+}
+builtins.set(BuiltinNames.f32x4_shuffle, builtin_f32x4_shuffle);
+
+// f32x4.swizzle -> v128.swizzle
+function builtin_f32x4_swizzle(ctx: BuiltinContext): ExpressionRef {
+  ctx.typeArguments = null;
+  ctx.contextualType = Type.v128;
+  return builtin_v128_swizzle(ctx);
+}
+builtins.set(BuiltinNames.f32x4_swizzle, builtin_f32x4_swizzle);
+
 // f64x2.splat -> v128.splat<f64>
 function builtin_f64x2_splat(ctx: BuiltinContext): ExpressionRef {
   checkTypeAbsent(ctx);
@@ -9865,6 +9942,23 @@ function builtin_f64x4_promote_low_f32x4(ctx: BuiltinContext): ExpressionRef {
 }
 builtins.set(BuiltinNames.f64x2_promote_low_f32x4, builtin_f64x4_promote_low_f32x4);
 
+// f64x2.shuffle -> v128.shuffle<f32>
+function builtin_f64x2_shuffle(ctx: BuiltinContext): ExpressionRef {
+  checkTypeAbsent(ctx);
+  ctx.typeArguments = [ Type.f64 ];
+  ctx.contextualType = Type.v128;
+  return builtin_v128_shuffle(ctx);
+}
+builtins.set(BuiltinNames.f64x2_shuffle, builtin_f64x2_shuffle);
+
+// f64x2.swizzle -> v128.swizzle
+function builtin_f64x2_swizzle(ctx: BuiltinContext): ExpressionRef {
+  ctx.typeArguments = null;
+  ctx.contextualType = Type.v128;
+  return builtin_v128_swizzle(ctx);
+}
+builtins.set(BuiltinNames.f64x2_swizzle, builtin_f64x2_swizzle);
+
 // === Internal helpers =======================================================================
 
 /** Compiles the `visit_globals` function. */

std/assembly/builtins.ts

@@ -1177,7 +1177,7 @@ export namespace v128 {
 
   // @ts-ignore: decorator
   @builtin
-  export declare function swizzle(a: v128, s: v128): v128;
+  export declare function swizzle(a: v128, b: v128): v128;
 
   // @ts-ignore: decorator
   @unsafe @builtin
@@ -1647,7 +1647,7 @@ export namespace i8x16 {
 
   // @ts-ignore: decorator
   @builtin
-  export declare function swizzle(a: v128, s: v128): v128;
+  export declare function swizzle(a: v128, b: v128): v128;
 }
 
 // @ts-ignore: decorator
@@ -1839,6 +1839,17 @@ export namespace i16x8 {
   // @ts-ignore: decorator
   @builtin
   export declare function extmul_high_i8x16_u(a: v128, b: v128): v128;
+
+  // @ts-ignore: decorator
+  @builtin
+  export declare function shuffle(
+    a: v128, b: v128,
+    l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8
+  ): v128;
+
+  // @ts-ignore: decorator
+  @builtin
+  export declare function swizzle(a: v128, b: v128): v128;
 }
 
 // @ts-ignore: decorator
@@ -2014,6 +2025,14 @@ export namespace i32x4 {
   // @ts-ignore: decorator
   @builtin
   export declare function extmul_high_i16x8_u(a: v128, b: v128): v128;
+
+  // @ts-ignore: decorator
+  @builtin
+  export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;
+
+  // @ts-ignore: decorator
+  @builtin
+  export declare function swizzle(a: v128, b: v128): v128;
 }
 
 // @ts-ignore: decorator
@@ -2129,6 +2148,14 @@ export namespace i64x2 {
   // @ts-ignore: decorator
   @builtin
   export declare function extmul_high_i32x4_u(a: v128, b: v128): v128;
+
+  // @ts-ignore: decorator
+  @builtin
+  export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;
+
+  // @ts-ignore: decorator
+  @builtin
+  export declare function swizzle(a: v128, b: v128): v128;
 }
 
 // @ts-ignore: decorator
@@ -2244,6 +2271,14 @@ export namespace f32x4 {
   // @ts-ignore: decorator
   @builtin
   export declare function demote_f64x2_zero(a: v128): v128;
+
+  // @ts-ignore: decorator
+  @builtin
+  export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;
+
+  // @ts-ignore: decorator
+  @builtin
+  export declare function swizzle(a: v128, b: v128): v128;
 }
 
 // @ts-ignore: decorator
@@ -2359,6 +2394,14 @@ export namespace f64x2 {
   // @ts-ignore: decorator
   @builtin
   export declare function promote_low_f32x4(a: v128): v128;
+
+  // @ts-ignore: decorator
+  @builtin
+  export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;
+
+  // @ts-ignore: decorator
+  @builtin
+  export declare function swizzle(a: v128, b: v128): v128;
 }
 
 @final

std/assembly/index.d.ts

@@ -1075,6 +1075,10 @@ declare namespace i16x8 {
   export function extmul_high_i8x16_s(a: v128, b: v128): v128;
   /** Performs the lane-wise 8-bit unsigned integer extended multiplication of the eight higher lanes producing twice wider 16-bit integer results. */
   export function extmul_high_i8x16_u(a: v128, b: v128): v128;
+  /** Selects 16-bit lanes from either vector according to the specified [0-7] respectively [8-15] lane indexes. */
+  export function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8): v128;
+  /** Selects 8-bit lanes from the first vector according to the indexes [0-15] specified by the 8-bit lanes of the second vector. */
+  export function swizzle(a: v128, s: v128): v128;
 }
 /** Initializes a 128-bit vector from four 32-bit integer values. Arguments must be compile-time constants. */
 declare function i32x4(a: i32, b: i32, c: i32, d: i32): v128;
@@ -1163,6 +1167,10 @@ declare namespace i32x4 {
   export function extmul_high_i16x8_s(a: v128, b: v128): v128;
   /** Performs the lane-wise 16-bit unsigned integer extended multiplication of the four higher lanes producing twice wider 32-bit integer results. */
   export function extmul_high_i16x8_u(a: v128, b: v128): v128;
+  /** Selects 32-bit lanes from either vector according to the specified [0-3] respectively [4-7] lane indexes. */
+  export function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;
+  /** Selects 8-bit lanes from the first vector according to the indexes [0-15] specified by the 8-bit lanes of the second vector. */
+  export function swizzle(a: v128, s: v128): v128;
 }
 /** Initializes a 128-bit vector from two 64-bit integer values. Arguments must be compile-time constants. */
 declare function i64x2(a: i64, b: i64): v128;
@@ -1221,6 +1229,10 @@ declare namespace i64x2 {
   export function extmul_high_i32x4_s(a: v128, b: v128): v128;
   /** Performs the lane-wise 32-bit unsigned integer extended multiplication of the two higher lanes producing twice wider 64-bit integer results. */
   export function extmul_high_i32x4_u(a: v128, b: v128): v128;
+  /** Selects 64-bit lanes from either vector according to the specified [0-1] respectively [2-3] lane indexes. */
+  export function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;
+  /** Selects 8-bit lanes from the first vector according to the indexes [0-15] specified by the 8-bit lanes of the second vector. */
+  export function swizzle(a: v128, s: v128): v128;
 }
 /** Initializes a 128-bit vector from four 32-bit float values. Arguments must be compile-time constants. */
 declare function f32x4(a: f32, b: f32, c: f32, d: f32): v128;
@@ -1279,6 +1291,10 @@ declare namespace f32x4 {
   export function convert_i32x4_u(a: v128): v128;
   /** Demotes each 64-bit float lane of a vector to single-precision. The higher lanes of the result are initialized to zero. */
   export function demote_f64x2_zero(a: v128): v128;
+  /** Selects 32-bit lanes from either vector according to the specified [0-3] respectively [4-7] lane indexes. */
+  export function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8, l4: u8): v128;
+  /** Selects 8-bit lanes from the first vector according to the indexes [0-15] specified by the 8-bit lanes of the second vector. */
+  export function swizzle(a: v128, s: v128): v128;
 }
 /** Initializes a 128-bit vector from two 64-bit float values. Arguments must be compile-time constants. */
 declare function f64x2(a: f64, b: f64): v128;
@@ -1337,6 +1353,10 @@ declare namespace f64x2 {
   export function convert_low_i32x4_u(a: v128): v128;
   /** Promotes the low 32-bit float lanes of a vector to double-precision. */
   export function promote_low_f32x4(a: v128): v128;
+  /** Selects 64-bit lanes from either vector according to the specified [0-1] respectively [2-3] lane indexes. */
+  export function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;
+  /** Selects 8-bit lanes from the first vector according to the indexes [0-15] specified by the 8-bit lanes of the second vector. */
+  export function swizzle(a: v128, s: v128): v128;
 }
 
 declare abstract class i31 {