add narrowing low-or SIMD ops

crates/core/src/simd.rs

@@ -6,7 +6,7 @@
 
 macro_rules! op {
     ($ty:ty, $op:tt) => {{
         |lhs: $ty, rhs: $ty| lhs $op rhs
     }};
 }
 
@@ -16,51 +16,51 @@
 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 V128 {
     /// Creates an `i128` value from the bytes of `self`.
     pub(crate) fn to_i128(self) -> i128 {
         i128::from_le_bytes(self.0)
     }
 }
 
 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);
     }
 }
 
@@ -87,9 +87,9 @@
     ) => {
         $(
             $( #[$attr] )*
             #[derive(Debug, Copy, Clone, PartialEq, Eq)]
             #[repr(transparent)]
             pub struct $name(u8);
 
             impl IntoLaneIdx for [(); $n] {
                 type LaneIdx = $name;
@@ -102,19 +102,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))
                 }
             }
         )*
@@ -211,7 +211,7 @@
     ) => {
         $(
             $( #[$attr] )*
             #[derive(Copy, Clone)]
             #[repr(transparent)]
             struct $name([$ty; $n]);
 
@@ -252,47 +252,47 @@
                     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 {
                     self.lanewise_binary(other, |lhs, rhs| match f(lhs, rhs) {
                         true => Self::ALL_ONES,
                         false => Self::ALL_ZEROS,
                     })
                 }
 
                 fn lanewise_reduce<T>(self, acc: T, f: impl Fn(u8, Self::Item, T) -> T) -> T {
                     let this = self.0;
                     let mut acc = acc;
                     for i in 0..Self::LANES {
                         acc = f(i as u8, this[i], acc);
                     }
                     acc
                 }
             }
         )*
@@ -363,12 +363,12 @@
     ( $( impl FromNarrow<$narrow_ty:ty> for $self_ty:ty; )* ) => {
         $(
             impl FromNarrow<$narrow_ty> for $self_ty {
                 fn from_pairwise_unary(
                     narrow: $narrow_ty,
                     f: impl Fn(<$narrow_ty as Lanes>::Item, <$narrow_ty as Lanes>::Item) -> Self::Item,
                 ) -> Self {
                     let narrow = narrow.0;
                     Self(array::from_fn(|i| f(narrow[2 * i], narrow[2 * i + 1])))
                 }
 
                 fn from_pairwise_binary(
@@ -386,33 +386,33 @@
                     }))
                 }
 
                 fn from_low_unary(narrow: $narrow_ty, f: impl Fn(<$narrow_ty as Lanes>::Item) -> Self::Item) -> Self {
                     Self(array::from_fn(|i| f(narrow.0[i])))
                 }
 
                 fn from_high_unary(narrow: $narrow_ty, f: impl Fn(<$narrow_ty as Lanes>::Item) -> Self::Item) -> Self {
                     Self(array::from_fn(|i| f(narrow.0[i + Self::LANES])))
                 }
 
                 fn from_low_binary(
                     narrow_lhs: $narrow_ty,
                     narrow_rhs: $narrow_ty,
                     f: impl Fn(<$narrow_ty as Lanes>::Item, <$narrow_ty as Lanes>::Item) -> Self::Item,
                 ) -> Self {
                     let narrow_lhs = narrow_lhs.0;
                     let narrow_rhs = narrow_rhs.0;
                     Self(array::from_fn(|i| f(narrow_lhs[i], narrow_rhs[i])))
                 }
 
                 fn from_high_binary(
                     narrow_lhs: $narrow_ty,
                     narrow_rhs: $narrow_ty,
                     f: impl Fn(<$narrow_ty as Lanes>::Item, <$narrow_ty as Lanes>::Item) -> Self::Item,
                 ) -> Self {
                     let narrow_lhs = narrow_lhs.0;
                     let narrow_rhs = narrow_rhs.0;
                     Self(array::from_fn(|i| {
                         f(narrow_lhs[i + Self::LANES], narrow_rhs[i + Self::LANES])
                     }))
                 }
             }
@@ -443,6 +443,13 @@
         high: WideLanes,
         f: impl Fn(WideLanes::Item) -> Self::Item,
     ) -> Self;
+
+    /// Construct `Self` from the application of `f` to the wide `low` or evaluate `high`.
+    fn from_low_or(
+        low: WideLanes,
+        high: impl Fn() -> Self::Item,
+        f: impl Fn(WideLanes::Item) -> Self::Item,
+    ) -> Self;
 }
 
 macro_rules! impl_from_wide_for {
@@ -451,25 +458,42 @@
     ) => {
         $(
             impl FromWide<$wide_ty> for $narrow_ty {
                 fn from_low_high(
                     low: $wide_ty,
                     high: $wide_ty,
                     f: impl Fn(<$wide_ty as Lanes>::Item) -> Self::Item,
                 ) -> Self {
                     let low = low.0;
                     let high = high.0;
                     Self(array::from_fn(|i| {
                         match i < <$wide_ty as Lanes>::LANES {
                             true => f(low[i]),
                             false => f(high[i]),
                         }
                     }))
                 }
+
+                fn from_low_or(
+                    low: $wide_ty,
+                    high: impl Fn() -> Self::Item,
+                    f: impl Fn(<$wide_ty as Lanes>::Item) -> Self::Item,
+                ) -> Self {
+                    let low = low.0;
+                    Self(array::from_fn(|i| {
+                        match i < <$wide_ty as Lanes>::LANES {
+                            true => f(low[i]),
+                            false => high(),
+                        }
+                    }))
+                }
             }
         )*
     };
 }
 impl_from_wide_for! {
+    impl FromWide<F64x2> for I32x4;
+    impl FromWide<F64x2> for U32x4;
+    impl FromWide<F64x2> for F32x4;
     impl FromWide<I32x4> for I16x8;
     impl FromWide<U32x4> for U16x8;
     impl FromWide<I16x8> for I8x16;
@@ -483,14 +507,14 @@
 macro_rules! impl_reinterpret_as_for {
     ( $ty0:ty, $ty1:ty ) => {
         impl ReinterpretAs<$ty0> for $ty1 {
             fn reinterpret_as(self) -> $ty0 {
                 <$ty0>::from_ne_bytes(self.to_ne_bytes())
             }
         }
 
         impl ReinterpretAs<$ty1> for $ty0 {
             fn reinterpret_as(self) -> $ty1 {
                 <$ty1>::from_ne_bytes(self.to_ne_bytes())
             }
         }
     };
@@ -507,60 +531,60 @@
     }
 
     /// 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 unary cast methods.
     fn lanewise_unary_cast<T: IntoLanes, U>(self, f: impl Fn(T) -> U) -> Self
     where
         U: ReinterpretAs<T>,
     {
         <<T as IntoLanes>::Lanes>::from_v128(self)
             .lanewise_unary(|v| f(v).reinterpret_as())
             .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 reduce methods.
     fn lanewise_reduce<T: IntoLanes, V>(self, acc: V, f: impl Fn(T, V) -> V) -> V {
         self.lanewise_reduce_enumerate::<T, V>(acc, |_, v: T, acc: V| f(v, acc))
     }
 
     /// Convenience method to help implement lanewise reduce methods with a loop-index.
     fn lanewise_reduce_enumerate<T: IntoLanes, V>(self, acc: V, f: impl Fn(u8, T, V) -> V) -> V {
         <<T as IntoLanes>::Lanes>::from_v128(self).lanewise_reduce(acc, f)
     }
 
     /// Convenience method to help implement pairwise unary methods.
     fn pairwise_unary<Narrow: IntoLanes, Wide: IntoLanes>(
         self,
         f: impl Fn(Narrow, Narrow) -> Wide,
     ) -> Self
@@ -568,8 +592,8 @@
         <Wide as IntoLanes>::Lanes: FromNarrow<<Narrow as IntoLanes>::Lanes>,
     {
         <<Wide as IntoLanes>::Lanes as FromNarrow<<Narrow as IntoLanes>::Lanes>>::from_pairwise_unary(
             <<Narrow as IntoLanes>::Lanes>::from_v128(self),
             f,
         )
         .into_v128()
     }
@@ -592,31 +616,31 @@
     }
 
     /// Convenience method to help implement extend-low unary methods.
     fn from_low_unary<Narrow: IntoLanes, Wide: IntoLanes>(self, f: impl Fn(Narrow) -> Wide) -> Self
     where
         <Wide as IntoLanes>::Lanes: FromNarrow<<Narrow as IntoLanes>::Lanes>,
     {
         <<Wide as IntoLanes>::Lanes as FromNarrow<<Narrow as IntoLanes>::Lanes>>::from_low_unary(
             <<Narrow as IntoLanes>::Lanes>::from_v128(self),
             f,
         )
         .into_v128()
     }
 
     /// Convenience method to help implement extend-high unary methods.
     fn from_high_unary<Narrow: IntoLanes, Wide: IntoLanes>(self, f: impl Fn(Narrow) -> Wide) -> Self
     where
         <Wide as IntoLanes>::Lanes: FromNarrow<<Narrow as IntoLanes>::Lanes>,
     {
         <<Wide as IntoLanes>::Lanes as FromNarrow<<Narrow as IntoLanes>::Lanes>>::from_high_unary(
             <<Narrow as IntoLanes>::Lanes>::from_v128(self),
             f,
         )
         .into_v128()
     }
 
     /// Convenience method to help implement extend-low binary methods.
     fn from_low_binary<Narrow: IntoLanes, Wide: IntoLanes>(
         lhs: Self,
         rhs: Self,
         f: impl Fn(Narrow, Narrow) -> Wide,
@@ -625,15 +649,15 @@
         <Wide as IntoLanes>::Lanes: FromNarrow<<Narrow as IntoLanes>::Lanes>,
     {
         <<Wide as IntoLanes>::Lanes as FromNarrow<<Narrow as IntoLanes>::Lanes>>::from_low_binary(
             <<Narrow as IntoLanes>::Lanes>::from_v128(lhs),
             <<Narrow as IntoLanes>::Lanes>::from_v128(rhs),
             f,
         )
         .into_v128()
     }
 
     /// Convenience method to help implement extend-high binary methods.
     fn from_high_binary<Narrow: IntoLanes, Wide: IntoLanes>(
         lhs: Self,
         rhs: Self,
         f: impl Fn(Narrow, Narrow) -> Wide,
@@ -642,15 +666,15 @@
         <Wide as IntoLanes>::Lanes: FromNarrow<<Narrow as IntoLanes>::Lanes>,
     {
         <<Wide as IntoLanes>::Lanes as FromNarrow<<Narrow as IntoLanes>::Lanes>>::from_high_binary(
             <<Narrow as IntoLanes>::Lanes>::from_v128(lhs),
             <<Narrow as IntoLanes>::Lanes>::from_v128(rhs),
             f,
         )
         .into_v128()
     }
 
     /// Convenience method to help implement narrowing low-high methods.
     fn from_low_high<Narrow: IntoLanes, Wide: IntoLanes>(
         lhs: Self,
         rhs: Self,
         f: impl Fn(Wide) -> Narrow,
@@ -659,25 +683,42 @@
         <Narrow as IntoLanes>::Lanes: FromWide<<Wide as IntoLanes>::Lanes>,
     {
         <<Narrow as IntoLanes>::Lanes as FromWide<<Wide as IntoLanes>::Lanes>>::from_low_high(
             <<Wide as IntoLanes>::Lanes>::from_v128(lhs),
             <<Wide as IntoLanes>::Lanes>::from_v128(rhs),
             f,
         )
         .into_v128()
     }
+
+    /// Convenience method to help implement narrowing low-or methods.
+    fn from_low_or<Narrow: IntoLanes, Wide: IntoLanes>(
+        self,
+        high: impl Fn() -> Narrow,
+        f: impl Fn(Wide) -> Narrow,
+    ) -> Self
+    where
+        <Narrow as IntoLanes>::Lanes: FromWide<<Wide as IntoLanes>::Lanes>,
+    {
+        <<Narrow as IntoLanes>::Lanes as FromWide<<Wide as IntoLanes>::Lanes>>::from_low_or(
+            <<Wide as IntoLanes>::Lanes>::from_v128(self),
+            high,
+            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)
             }
         )*
     };
@@ -697,8 +738,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))
             }
         )*
     };
@@ -720,8 +761,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)
             }
         )*
     };
@@ -741,8 +782,8 @@
     ( $( 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)
             }
         )*
     };
@@ -752,24 +793,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_cast(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)
             }
         )*
     };
@@ -815,13 +856,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;
 
         fn f32x4_min(lhs: Self, rhs: Self) -> Self = wasm::f32_min;
         fn f64x2_min(lhs: Self, rhs: Self) -> Self = wasm::f64_min;
@@ -854,7 +895,7 @@
 
         fn v128_not(self) -> Self = <i64 as Not>::not;
 
         fn i8x16_popcnt(self) -> Self = |v: u8| v.count_ones() as u8;
 
         fn f32x4_neg(self) -> Self = <f32 as Neg>::neg;
         fn f64x2_neg(self) -> Self = <f64 as Neg>::neg;
@@ -884,8 +925,8 @@
     ( $( 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_comparison(lhs, rhs, $lanewise_expr)
             }
         )*
     };
@@ -954,8 +995,8 @@
     ) => {
         $(
             #[doc = concat!("Executes a Wasm `", stringify!($name), "` instruction.")]
             pub fn $name(self) -> Self {
                 self.from_low_unary($convert)
             }
         )*
     };
@@ -981,8 +1022,8 @@
     ) => {
         $(
             #[doc = concat!("Executes a Wasm `", stringify!($name), "` instruction.")]
             pub fn $name(self) -> Self {
                 self.from_high_unary($convert)
             }
         )*
     };
@@ -1010,23 +1051,23 @@
     ) => {
         $(
             #[doc = concat!("Executes a Wasm `", stringify!($extmul_low), "` instruction.")]
             pub fn $extmul_low(lhs: Self, rhs: Self) -> Self {
                 fn extmul_low(a: $narrow, b: $narrow) -> $wide {
                     let a = <$wide>::from(a);
                     let b = <$wide>::from(b);
                     a.wrapping_mul(b)
                 }
                 Self::from_low_binary(lhs, rhs, extmul_low)
             }
 
             #[doc = concat!("Executes a Wasm `", stringify!($extmul_high), "` instruction.")]
             pub fn $extmul_high(lhs: Self, rhs: Self) -> Self {
                 fn extmul_high(a: $narrow, b: $narrow) -> $wide {
                     let a = <$wide>::from(a);
                     let b = <$wide>::from(b);
                     a.wrapping_mul(b)
                 }
                 Self::from_high_binary(lhs, rhs, extmul_high)
             }
         )*
     };
@@ -1072,13 +1113,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.pairwise_unary(extadd_pairwise)
             }
         )*
     };
@@ -1098,8 +1139,8 @@
     ) => {
         $(
             #[doc = concat!("Executes a Wasm `", stringify!($name), "` instruction.")]
             pub fn $name(self, rhs: u32) -> Self {
                 self.lanewise_unary(|v| $lanewise_expr(v, rhs))
             }
         )*
     };
@@ -1127,29 +1168,49 @@
     ) => {
         $(
             #[doc = concat!("Executes a Wasm `", stringify!($name), "` instruction.")]
             pub fn $name(low: Self, high: Self) -> Self {
                 Self::from_low_high(low, high, $f)
             }
         )*
     };
 }
 impl V128 {
     impl_narrowing_low_high_ops! {
         fn i8x16_narrow_i16x8_s(low: Self, high: Self) -> Self = |v: i16| v as i8;
         fn i8x16_narrow_i16x8_u(low: Self, high: Self) -> Self = |v: u16| v as u8;
         fn i16x8_narrow_i32x4_s(low: Self, high: Self) -> Self = |v: i32| v as i16;
         fn i16x8_narrow_i32x4_u(low: Self, high: Self) -> Self = |v: u32| v as u16;
     }
 }
 
+macro_rules! impl_narrowing_low_high_ops {
+    (
+        $( fn $name:ident(self) -> Self = (high: $high:expr, f: $f:expr); )*
+    ) => {
+        $(
+            #[doc = concat!("Executes a Wasm `", stringify!($name), "` instruction.")]
+            pub fn $name(low: Self) -> Self {
+                Self::from_low_or(low, $high, $f)
+            }
+        )*
+    };
+}
+impl V128 {
+    impl_narrowing_low_high_ops! {
+        fn i32x4_trunc_sat_f64x2_s_zero(self) -> Self = (high: || 0, f: wasm::i32_trunc_sat_f64_s);
+        fn i32x4_trunc_sat_f64x2_u_zero(self) -> Self = (high: || 0, f: wasm::i32_trunc_sat_f64_u);
+        fn f32x4_demote_f64x2_zero(self) -> Self = (high: || 0.0, f: wasm::f32_demote_f64);
+    }
+}
+
 macro_rules! impl_reduce_ops {
     (
         $( fn $name:ident(self) -> bool = all_true($item_ty:ty); )*
     ) => {
         $(
             #[doc = concat!("Executes a Wasm `", stringify!($name), "` instruction.")]
             pub fn $name(self) -> bool {
                 self.lanewise_reduce(true, |v: $item_ty, acc| acc & (v != 0))
             }
         )*
     };
@@ -1158,18 +1219,18 @@
     ) => {
         $(
             #[doc = concat!("Executes a Wasm `", stringify!($name), "` instruction.")]
             pub fn $name(self) -> u32 {
                 self.lanewise_reduce_enumerate(0_i32, |n, v: $item_ty, acc| {
                     acc | (i32::from(v < 0).wrapping_shl(u32::from(n)))
                 }) as _
             }
         )*
     };
 }
 impl V128 {
     /// Executes a Wasm `v128.any_true` instruction.
     pub fn v128_any_true(self) -> bool {
         self.to_i128() != 0
     }
 
     impl_reduce_ops! {
@@ -1200,8 +1261,8 @@
     }
 
     /// 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))
     }
 }