add i32x4.dot_i16x8_s SIMD operation

crates/core/src/simd.rs

@@ -9,44 +9,44 @@
 pub struct V128([u8; 16]);
 
 impl From<[u8; 16]> for V128 {
     fn from(bytes: [u8; 16]) -> Self {
         Self(bytes)
     }
 }
 
 impl From<i128> for V128 {
     fn from(value: i128) -> Self {
         Self(value.to_le_bytes())
     }
 }
 
 impl From<UntypedVal> for V128 {
     fn from(value: UntypedVal) -> Self {
         let u128 = (u128::from(value.hi64) << 64) | (u128::from(value.lo64));
         Self(u128.to_le_bytes())
     }
 }
 
 impl From<V128> for UntypedVal {
     fn from(value: V128) -> Self {
         let u128 = u128::from_le_bytes(value.0);
         let lo64 = u128 as u64;
         let hi64 = (u128 >> 64) as u64;
         Self { lo64, hi64 }
     }
 }
 
 impl ReadAs<V128> for UntypedVal {
     fn read_as(&self) -> V128 {
         // Note: we can re-use the `From` impl since both types are of equal size.
         V128::from(*self)
     }
 }
 
 impl WriteAs<V128> for UntypedVal {
     fn write_as(&mut self, value: V128) {
         // Note: we can re-use the `From` impl since both types are of equal size.
         *self = UntypedVal::from(value);
     }
 }
 
@@ -73,9 +73,9 @@
     ) => {
         $(
             $( #[$attr] )*
             #[derive(Debug, Copy, Clone, PartialEq, Eq)]
             #[repr(transparent)]
             pub struct $name(u8);
 
             impl IntoLaneIdx for [(); $n] {
                 type LaneIdx = $name;
@@ -88,19 +88,19 @@
                 /// Returns the lane id as `u8`.
                 ///
                 /// This will never return a `u8` value that is out of bounds for `self`.
                 pub fn get(self) -> u8 {
                     self.0 & Self::MASK
                 }
             }
 
             impl TryFrom<u8> for $name {
                 type Error = OutOfBoundsLaneId;
 
                 fn try_from(lane: u8) -> Result<Self, Self::Error> {
                     if lane > Self::MASK {
                         return Err(OutOfBoundsLaneId)
                     }
                     Ok(Self(lane))
                 }
             }
         )*
@@ -194,7 +194,7 @@
     ) => {
         $(
             $( #[$attr] )*
             #[derive(Copy, Clone)]
             #[repr(transparent)]
             struct $name([$ty; $n]);
 
@@ -211,7 +211,7 @@
                 const ALL_ONES: Self::Item = <$ty>::from_le_bytes([0xFF_u8; 16 / $n]);
                 const ALL_ZEROS: Self::Item = <$ty>::from_le_bytes([0x00_u8; 16 / $n]);
 
                 fn from_v128(value: V128) -> Self {
                     // SAFETY: the types chosen to implement `Split` are always
                     //         of same size as `V128` and have no invalid bit-patterns.
                     //
@@ -220,46 +220,46 @@
                     //       out that _not_ using unsafe transmutation confused the
                     //       optimizer enough that optimizations became very flaky.
                     //       This was tested across a variety of compiler versions.
                     Self(unsafe { ::core::mem::transmute::<V128, [$ty; $n]>(value) })
                 }
 
                 fn into_v128(self) -> V128 {
                     // SAFETY: the types chosen to implement `Combine` are always
                     //         of same size as `V128` and have no invalid bit-patterns.
                     //
                     // Note: see note from `from_v128` method above.
                     unsafe { ::core::mem::transmute::<[$ty; $n], V128>(self.0) }
                 }
 
                 fn splat(value: Self::Item) -> Self {
                     Self([value; $n])
                 }
 
                 fn extract_lane(self, lane: Self::LaneIdx) -> Self::Item {
                     self.0[lane.get() as usize]
                 }
 
                 fn replace_lane(self, lane: Self::LaneIdx, item: Self::Item) -> Self {
                     let mut this = self;
                     this.0[lane.get() as usize] = item;
                     this
                 }
 
                 fn lanewise_unary(self, f: impl Fn(Self::Item) -> Self::Item) -> Self {
                     let mut this = self.0;
                     for i in 0..Self::LANES {
                         this[i] = f(this[i]);
                     }
                     Self(this)
                 }
 
                 fn lanewise_binary(self, other: Self, f: impl Fn(Self::Item, Self::Item) -> Self::Item) -> Self {
                     let mut lhs = self.0;
                     let rhs = other.0;
                     for i in 0..Self::LANES {
                         lhs[i] = f(lhs[i], rhs[i]);
                     }
                     Self(lhs)
                 }
 
                 fn lanewise_comparison(self, other: Self, f: impl Fn(Self::Item, Self::Item) -> bool) -> Self {
@@ -356,7 +356,7 @@
                     Self(result)
                 }
 
                 fn lanewise_widening_binary(
                     lhs: Self::Narrow,
                     rhs: Self::Narrow,
                     f: impl Fn(
@@ -364,14 +364,14 @@
                         [<Self::Narrow as Lanes>::Item; 2],
                     ) -> Self::Item,
                 ) -> Self {
                     let a = lhs.0;
                     let b = rhs.0;
                     #[rustfmt::skip]
                     let result = [
                         f([a[0], a[1]], [b[0], b[1]]),
                         f([a[2], a[3]], [b[2], b[3]]),
                     ];
                     Self(result)
                 }
             }
         )*
@@ -395,22 +395,22 @@
             impl LanewiseWidening for $ty {
                 type Narrow = $narrow_ty;
 
                 fn lanewise_widening_unary(
                     value: Self::Narrow,
                     f: impl Fn(<Self::Narrow as Lanes>::Item, <Self::Narrow as Lanes>::Item) -> Self::Item,
                 ) -> Self {
                     let a = value.0;
                     #[rustfmt::skip]
                     let result = [
                         f(a[0], a[1]),
                         f(a[2], a[3]),
                         f(a[4], a[5]),
                         f(a[6], a[7]),
                     ];
                     Self(result)
                 }
 
                 fn lanewise_widening_binary(
                     lhs: Self::Narrow,
                     rhs: Self::Narrow,
                     f: impl Fn(
@@ -418,16 +418,16 @@
                         [<Self::Narrow as Lanes>::Item; 2],
                     ) -> Self::Item,
                 ) -> Self {
                     let a = lhs.0;
                     let b = rhs.0;
                     #[rustfmt::skip]
                     let result = [
                         f([a[0], a[1]], [b[0], b[1]]),
                         f([a[2], a[3]], [b[2], b[3]]),
                         f([a[4], a[5]], [b[4], b[5]]),
                         f([a[6], a[7]], [b[6], b[7]]),
                     ];
                     Self(result)
                 }
             }
         )*
@@ -451,26 +451,26 @@
             impl LanewiseWidening for $ty {
                 type Narrow = $narrow_ty;
 
                 fn lanewise_widening_unary(
                     value: Self::Narrow,
                     f: impl Fn(<Self::Narrow as Lanes>::Item, <Self::Narrow as Lanes>::Item) -> Self::Item,
                 ) -> Self {
                     let a = value.0;
                     #[rustfmt::skip]
                     let result = [
                         f(a[ 0], a[ 1]),
                         f(a[ 2], a[ 3]),
                         f(a[ 4], a[ 5]),
                         f(a[ 6], a[ 7]),
                         f(a[ 8], a[ 9]),
                         f(a[10], a[11]),
                         f(a[12], a[13]),
                         f(a[14], a[15]),
                     ];
                     Self(result)
                 }
 
                 fn lanewise_widening_binary(
                     lhs: Self::Narrow,
                     rhs: Self::Narrow,
                     f: impl Fn(
@@ -478,20 +478,20 @@
                         [<Self::Narrow as Lanes>::Item; 2],
                     ) -> Self::Item,
                 ) -> Self {
                     let a = lhs.0;
                     let b = rhs.0;
                     #[rustfmt::skip]
                     let result = [
                         f([a[ 0], a[ 1]], [b[ 0], b[ 1]]),
                         f([a[ 2], a[ 3]], [b[ 2], b[ 3]]),
                         f([a[ 4], a[ 5]], [b[ 4], b[ 5]]),
                         f([a[ 6], a[ 7]], [b[ 6], b[ 7]]),
                         f([a[ 8], a[ 9]], [b[ 8], b[ 9]]),
                         f([a[10], a[11]], [b[10], b[11]]),
                         f([a[12], a[13]], [b[12], b[13]]),
                         f([a[14], a[15]], [b[14], b[15]]),
                     ];
                     Self(result)
                 }
             }
         )*
@@ -665,65 +665,65 @@
 
 impl V128 {
     /// Convenience method to help implement splatting methods.
     fn splat<T: IntoLanes>(value: T) -> Self {
         <<T as IntoLanes>::Lanes>::splat(value).into_v128()
     }
 
     /// Convenience method to help implement lane extraction methods.
     fn extract_lane<T: IntoLanes>(self, lane: <T as IntoLanes>::LaneIdx) -> T {
         <<T as IntoLanes>::Lanes>::from_v128(self).extract_lane(lane)
     }
 
     /// Convenience method to help implement lane replacement methods.
     fn replace_lane<T: IntoLanes>(self, lane: <T as IntoLanes>::LaneIdx, item: T) -> Self {
         <<T as IntoLanes>::Lanes>::from_v128(self)
             .replace_lane(lane, item)
             .into_v128()
     }
 
     /// Convenience method to help implement lanewise unary methods.
     fn lanewise_unary<T: IntoLanes>(self, f: impl Fn(T) -> T) -> Self {
         <<T as IntoLanes>::Lanes>::from_v128(self)
             .lanewise_unary(f)
             .into_v128()
     }
 
     /// Convenience method to help implement lanewise binary methods.
     fn lanewise_binary<T: IntoLanes>(lhs: Self, rhs: Self, f: impl Fn(T, T) -> T) -> Self {
         let lhs = <<T as IntoLanes>::Lanes>::from_v128(lhs);
         let rhs = <<T as IntoLanes>::Lanes>::from_v128(rhs);
         lhs.lanewise_binary(rhs, f).into_v128()
     }
 
     /// Convenience method to help implement lanewise comparison methods.
     fn lanewise_comparison<T: IntoLanes>(lhs: Self, rhs: Self, f: impl Fn(T, T) -> bool) -> Self {
         let lhs = <<T as IntoLanes>::Lanes>::from_v128(lhs);
         let rhs = <<T as IntoLanes>::Lanes>::from_v128(rhs);
         lhs.lanewise_comparison(rhs, f).into_v128()
     }
 
     /// Convenience method to help implement lanewise unary widening methods.
     fn lanewise_widening_unary<T: IntoLanewiseWidening>(
         self,
         f: impl Fn(T, T) -> <T as IntoLanewiseWidening>::WideItem,
     ) -> Self {
         <<T as IntoLanewiseWidening>::Wide>::lanewise_widening_unary(
             <T as IntoLanes>::Lanes::from_v128(self),
             f,
         )
         .into_v128()
     }
 
     /// Convenience method to help implement lanewise binary widening methods.
     fn lanewise_widening_binary<T: IntoLanewiseWidening>(
         lhs: Self,
         rhs: Self,
         f: impl Fn([T; 2], [T; 2]) -> <T as IntoLanewiseWidening>::WideItem,
     ) -> Self {
         <<T as IntoLanewiseWidening>::Wide>::lanewise_widening_binary(
             <T as IntoLanes>::Lanes::from_v128(lhs),
             <T as IntoLanes>::Lanes::from_v128(rhs),
             f,
         )
         .into_v128()
     }
@@ -733,7 +733,7 @@
         self,
         f: impl Fn(<T::Wide as Lanes>::Item) -> [T::Item; 2],
     ) -> Self {
         T::lanewise_narrowing_unary(<T::Wide as Lanes>::from_v128(self), f).into_v128()
     }
 
     /// Convenience method to help implement lanewise binary narrowing methods.
@@ -743,25 +743,25 @@
         f: impl Fn(<T::Wide as Lanes>::Item, <T::Wide as Lanes>::Item) -> [T::Item; 2],
     ) -> Self {
         T::lanewise_narrowing_binary(
             <T::Wide as Lanes>::from_v128(lhs),
             <T::Wide as Lanes>::from_v128(rhs),
             f,
         )
         .into_v128()
     }
 }
 
 /// Concenience identity helper function.
 fn identity<T>(x: T) -> T {
     x
 }
 
 macro_rules! impl_splat_for {
     ( $( fn $name:ident(value: $ty:ty) -> Self; )* ) => {
         $(
             #[doc = concat!("Executes a Wasm `", stringify!($name), "` instruction.")]
             pub fn $name(value: $ty) -> Self {
                 Self::splat(value)
             }
         )*
     };
@@ -781,8 +781,8 @@
     ( $( fn $name:ident(self, lane: $lane_ty:ty) -> $ret_ty:ty = $convert:expr; )* ) => {
         $(
             #[doc = concat!("Executes a Wasm `", stringify!($name), "` instruction.")]
             pub fn $name(self, lane: $lane_ty) -> $ret_ty {
                 ($convert)(self.extract_lane(lane))
             }
         )*
     };
@@ -804,8 +804,8 @@
     ( $( fn $name:ident(self, lane: $lane_ty:ty, item: $item_ty:ty) -> Self; )* ) => {
         $(
             #[doc = concat!("Executes a Wasm `", stringify!($name), "` instruction.")]
             pub fn $name(self, lane: $lane_ty, item: $item_ty) -> Self {
                 self.replace_lane(lane, item)
             }
         )*
     };
@@ -825,24 +825,24 @@
     ( $( fn $name:ident(self) -> Self = $lanewise_expr:expr; )* ) => {
         $(
             #[doc = concat!("Executes a Wasm `", stringify!($name), "` instruction.")]
             pub fn $name(self) -> Self {
                 Self::lanewise_unary(self, $lanewise_expr)
             }
         )*
     };
 }
 
 /// Lanewise operation for the Wasm `q15mulr_sat` SIMD operation.
 fn i16x8_q15mulr_sat(x: i16, y: i16) -> i16 {
     (x * y + 0x4000) >> 15
 }
 
 macro_rules! impl_binary_for {
     ( $( fn $name:ident(lhs: Self, rhs: Self) -> Self = $lanewise_expr:expr; )* ) => {
         $(
             #[doc = concat!("Executes a Wasm `", stringify!($name), "` instruction.")]
             pub fn $name(lhs: Self, rhs: Self) -> Self {
                 Self::lanewise_binary(lhs, rhs, $lanewise_expr)
             }
         )*
     };
@@ -888,13 +888,13 @@
         fn i32x4_max_s(lhs: Self, rhs: Self) -> Self = i32::max;
         fn i32x4_max_u(lhs: Self, rhs: Self) -> Self = u32::max;
 
         fn i8x16_avgr_u(lhs: Self, rhs: Self) -> Self = |a: u8, b: u8| (a + b + 1) / 2;
         fn i16x8_avgr_u(lhs: Self, rhs: Self) -> Self = |a: u16, b: u16| (a + b + 1) / 2;
 
         fn v128_and(lhs: Self, rhs: Self) -> Self = <i64 as BitAnd>::bitand;
         fn v128_or(lhs: Self, rhs: Self) -> Self = <i64 as BitOr>::bitor;
         fn v128_xor(lhs: Self, rhs: Self) -> Self = <i64 as BitXor>::bitxor;
         fn v128_andnot(lhs: Self, rhs: Self) -> Self = |a: i64, b: i64| a & !b;
     }
 
     impl_unary_for! {
@@ -910,7 +910,7 @@
 
         fn v128_not(self) -> Self = <i64 as Not>::not;
 
         fn i8x16_popcnt(self) -> Self = |v: u8| v.count_ones() as u8;
     }
 }
 
@@ -926,23 +926,23 @@
     ) => {
         $(
             #[doc = concat!("Executes a Wasm `", stringify!($extmul_low), "` instruction.")]
             pub fn $extmul_low(lhs: Self, rhs: Self) -> Self {
                 fn extmul(a: [$narrow; 2], b: [$narrow; 2]) -> $wide {
                     let a = <$wide>::from(a[0]);
                     let b = <$wide>::from(b[0]);
                     a.wrapping_mul(b)
                 }
                 Self::lanewise_widening_binary(lhs, rhs, extmul)
             }
 
             #[doc = concat!("Executes a Wasm `", stringify!($extmul_high), "` instruction.")]
             pub fn $extmul_high(lhs: Self, rhs: Self) -> Self {
                 fn extmul(a: [$narrow; 2], b: [$narrow; 2]) -> $wide {
                     let a = <$wide>::from(a[1]);
                     let b = <$wide>::from(b[1]);
                     a.wrapping_mul(b)
                 }
                 Self::lanewise_widening_binary(lhs, rhs, extmul)
             }
         )*
     };
@@ -988,13 +988,13 @@
     ) => {
         $(
             #[doc = concat!("Executes a Wasm `", stringify!($name), "` instruction.")]
             pub fn $name(self) -> Self {
                 fn extadd_pairwise(a: $narrow, b: $narrow) -> $wide {
                     let a = <$wide>::from(a);
                     let b = <$wide>::from(b);
                     a.wrapping_add(b)
                 }
                 self.lanewise_widening_unary(extadd_pairwise)
             }
         )*
     };
@@ -1014,8 +1014,8 @@
     ) => {
         $(
             #[doc = concat!("Executes a Wasm `", stringify!($name), "` instruction.")]
             pub fn $name(self, rhs: u32) -> Self {
                 self.lanewise_unary(|v| $lanewise_expr(v, rhs))
             }
         )*
     };
@@ -1038,8 +1038,20 @@
 }
 
 impl V128 {
+    /// Execute a Wasm `i32x4.dot_i16x8_s` instruction.
+    pub fn i32x4_dot_i16x8_s(lhs: Self, rhs: Self) -> Self {
+        fn dot(a: [i16; 2], b: [i16; 2]) -> i32 {
+            let a = a.map(i32::from);
+            let b = b.map(i32::from);
+            let dot0 = a[0].wrapping_mul(b[0]);
+            let dot1 = a[1].wrapping_mul(b[1]);
+            dot0.wrapping_add(dot1)
+        }
+        Self::lanewise_widening_binary(lhs, rhs, dot)
+    }
+
     /// Execute a Wasm `v128.bitselect` instruction.
     pub fn v128_bitselect(v1: Self, v2: Self, c: Self) -> Self {
         Self::v128_or(Self::v128_and(v1, c), Self::v128_andnot(v2, c))
     }
 }