wasmparser: feature gate Wasm simd support

Cargo.toml

@@ -122,7 +122,7 @@ wat = { workspace = true, features = ['dwarf', 'component-model'] }
 termcolor = { workspace = true }
 
 # Dependencies of `validate`
-wasmparser = { workspace = true, optional = true, features = ['component-model'] }
+wasmparser = { workspace = true, optional = true, features = ['component-model', 'simd'] }
 rayon = { workspace = true, optional = true }
 bitflags = { workspace = true, optional = true }
 
@@ -203,6 +203,7 @@ default = [
   'compose',
   'demangle',
   'component',
+  'simd',
   'metadata',
   'wit-smith',
   'addr2line',
@@ -239,6 +240,11 @@ component = [
   'dep:wasmparser',
   'dep:serde_json',
 ]
+simd = [
+  'wasmparser/simd',
+  'wasmprinter/simd',
+  'wasm-encoder/simd',
+]
 metadata = ['dep:wasmparser', 'wasm-metadata', 'dep:serde_json']
 wit-smith = ['dep:wit-smith', 'arbitrary']
 addr2line = ['dep:addr2line', 'dep:gimli', 'dep:wasmparser']

crates/wasm-encoder/Cargo.toml

@@ -33,8 +33,10 @@ wasmparser = { path = "../wasmparser" }
 wasmprinter = { workspace = true }
 
 [features]
-default = ['component-model']
+default = ['component-model', 'simd']
 
 # On-by-default: conditional support for emitting components in addition to
 # core modules.
 component-model = ['wasmparser?/component-model']
+# On-by-default: conditional support for emitting SIMD wasm operators.
+simd = ['wasmparser?/simd']

crates/wasm-encoder/src/reencode.rs

@@ -601,6 +601,7 @@ impl Reencode for RoundtripReencoder {
 #[allow(missing_docs)] // FIXME
 pub mod utils {
     use super::{Error, Reencode};
+    use crate::Instruction;
     use crate::{CoreTypeEncoder, Encode};
     use std::ops::Range;
 
@@ -1546,98 +1547,128 @@ pub mod utils {
         }
     }
 
+    #[rustfmt::skip]
+    macro_rules! translate_map {
+        // This case is used to map, based on the name of the field, from the
+        // wasmparser payload type to the wasm-encoder payload type through
+        // `Translator` as applicable.
+        ($reencoder:ident $arg:ident tag_index) => ($reencoder.tag_index($arg));
+        ($reencoder:ident $arg:ident function_index) => ($reencoder.function_index($arg));
+        ($reencoder:ident $arg:ident table) => ($reencoder.table_index($arg));
+        ($reencoder:ident $arg:ident table_index) => ($reencoder.table_index($arg));
+        ($reencoder:ident $arg:ident dst_table) => ($reencoder.table_index($arg));
+        ($reencoder:ident $arg:ident src_table) => ($reencoder.table_index($arg));
+        ($reencoder:ident $arg:ident type_index) => ($reencoder.type_index($arg));
+        ($reencoder:ident $arg:ident array_type_index) => ($reencoder.type_index($arg));
+        ($reencoder:ident $arg:ident array_type_index_dst) => ($reencoder.type_index($arg));
+        ($reencoder:ident $arg:ident array_type_index_src) => ($reencoder.type_index($arg));
+        ($reencoder:ident $arg:ident struct_type_index) => ($reencoder.type_index($arg));
+        ($reencoder:ident $arg:ident global_index) => ($reencoder.global_index($arg));
+        ($reencoder:ident $arg:ident mem) => ($reencoder.memory_index($arg));
+        ($reencoder:ident $arg:ident src_mem) => ($reencoder.memory_index($arg));
+        ($reencoder:ident $arg:ident dst_mem) => ($reencoder.memory_index($arg));
+        ($reencoder:ident $arg:ident data_index) => ($reencoder.data_index($arg));
+        ($reencoder:ident $arg:ident elem_index) => ($reencoder.element_index($arg));
+        ($reencoder:ident $arg:ident array_data_index) => ($reencoder.data_index($arg));
+        ($reencoder:ident $arg:ident array_elem_index) => ($reencoder.element_index($arg));
+        ($reencoder:ident $arg:ident blockty) => ($reencoder.block_type($arg)?);
+        ($reencoder:ident $arg:ident relative_depth) => ($arg);
+        ($reencoder:ident $arg:ident targets) => ((
+            $arg
+                .targets()
+                .collect::<Result<Vec<_>, wasmparser::BinaryReaderError>>()?
+                .into(),
+            $arg.default(),
+        ));
+        ($reencoder:ident $arg:ident ty) => ($reencoder.val_type($arg)?);
+        ($reencoder:ident $arg:ident hty) => ($reencoder.heap_type($arg)?);
+        ($reencoder:ident $arg:ident from_ref_type) => ($reencoder.ref_type($arg)?);
+        ($reencoder:ident $arg:ident to_ref_type) => ($reencoder.ref_type($arg)?);
+        ($reencoder:ident $arg:ident memarg) => ($reencoder.mem_arg($arg));
+        ($reencoder:ident $arg:ident ordering) => ($reencoder.ordering($arg));
+        ($reencoder:ident $arg:ident local_index) => ($arg);
+        ($reencoder:ident $arg:ident value) => ($arg);
+        ($reencoder:ident $arg:ident lane) => ($arg);
+        ($reencoder:ident $arg:ident lanes) => ($arg);
+        ($reencoder:ident $arg:ident array_size) => ($arg);
+        ($reencoder:ident $arg:ident field_index) => ($arg);
+        ($reencoder:ident $arg:ident try_table) => ($arg);
+        ($reencoder:ident $arg:ident argument_index) => ($reencoder.type_index($arg));
+        ($reencoder:ident $arg:ident result_index) => ($reencoder.type_index($arg));
+        ($reencoder:ident $arg:ident cont_type_index) => ($reencoder.type_index($arg));
+        ($reencoder:ident $arg:ident resume_table) => ((
+            $arg.handlers.into_iter().map(|h| $reencoder.handle(h)).collect::<Vec<_>>().into()
+        ));
+    }
+
+    #[rustfmt::skip]
+    macro_rules! translate_build {
+        // This case takes the arguments of a wasmparser instruction and creates
+        // a wasm-encoder instruction. There are a few special cases for where
+        // the structure of a wasmparser instruction differs from that of
+        // wasm-encoder.
+        ($reencoder:ident $op:ident) => (Instruction::$op);
+        ($reencoder:ident BrTable $arg:ident) => (Instruction::BrTable($arg.0, $arg.1));
+        ($reencoder:ident I32Const $arg:ident) => (Instruction::I32Const($arg));
+        ($reencoder:ident I64Const $arg:ident) => (Instruction::I64Const($arg));
+        ($reencoder:ident F32Const $arg:ident) => (Instruction::F32Const(f32::from_bits($arg.bits())));
+        ($reencoder:ident F64Const $arg:ident) => (Instruction::F64Const(f64::from_bits($arg.bits())));
+        ($reencoder:ident V128Const $arg:ident) => (Instruction::V128Const($arg.i128()));
+        ($reencoder:ident TryTable $table:ident) => (Instruction::TryTable($reencoder.block_type($table.ty)?, {
+            $table.catches.into_iter().map(|c| $reencoder.catch(c)).collect::<Vec<_>>().into()
+        }));
+        ($reencoder:ident $op:ident $arg:ident) => (Instruction::$op($arg));
+        ($reencoder:ident $op:ident $($arg:ident)*) => (Instruction::$op { $($arg),* });
+    }
+
     pub fn instruction<'a, T: ?Sized + Reencode>(
         reencoder: &mut T,
         arg: wasmparser::Operator<'a>,
     ) -> Result<crate::Instruction<'a>, Error<T::Error>> {
-        use crate::Instruction;
-
         macro_rules! translate {
             ($( @$proposal:ident $op:ident $({ $($arg:ident: $argty:ty),* })? => $visit:ident ($($ann:tt)*))*) => {
                 Ok(match arg {
                     $(
                         wasmparser::Operator::$op $({ $($arg),* })? => {
                             $(
-                                $(let $arg = translate!(map $arg $arg);)*
+                                $(let $arg = translate_map!(reencoder $arg $arg);)*
                             )?
-                            translate!(build $op $($($arg)*)?)
+                            translate_build!(reencoder $op $($($arg)*)?)
                         }
                     )*
+                    #[cfg(feature = "simd")]
+                    wasmparser::Operator::Simd(simd_arg) => simd_instruction(reencoder, simd_arg)?,
+                    unexpected => unreachable!("encountered unexpected Wasm operator: {unexpected:?}"),
                 })
             };
-
-            // This case is used to map, based on the name of the field, from the
-            // wasmparser payload type to the wasm-encoder payload type through
-            // `Translator` as applicable.
-            (map $arg:ident tag_index) => (reencoder.tag_index($arg));
-            (map $arg:ident function_index) => (reencoder.function_index($arg));
-            (map $arg:ident table) => (reencoder.table_index($arg));
-            (map $arg:ident table_index) => (reencoder.table_index($arg));
-            (map $arg:ident dst_table) => (reencoder.table_index($arg));
-            (map $arg:ident src_table) => (reencoder.table_index($arg));
-            (map $arg:ident type_index) => (reencoder.type_index($arg));
-            (map $arg:ident array_type_index) => (reencoder.type_index($arg));
-            (map $arg:ident array_type_index_dst) => (reencoder.type_index($arg));
-            (map $arg:ident array_type_index_src) => (reencoder.type_index($arg));
-            (map $arg:ident struct_type_index) => (reencoder.type_index($arg));
-            (map $arg:ident global_index) => (reencoder.global_index($arg));
-            (map $arg:ident mem) => (reencoder.memory_index($arg));
-            (map $arg:ident src_mem) => (reencoder.memory_index($arg));
-            (map $arg:ident dst_mem) => (reencoder.memory_index($arg));
-            (map $arg:ident data_index) => (reencoder.data_index($arg));
-            (map $arg:ident elem_index) => (reencoder.element_index($arg));
-            (map $arg:ident array_data_index) => (reencoder.data_index($arg));
-            (map $arg:ident array_elem_index) => (reencoder.element_index($arg));
-            (map $arg:ident blockty) => (reencoder.block_type($arg)?);
-            (map $arg:ident relative_depth) => ($arg);
-            (map $arg:ident targets) => ((
-                $arg
-                    .targets()
-                    .collect::<Result<Vec<_>, wasmparser::BinaryReaderError>>()?
-                    .into(),
-                $arg.default(),
-            ));
-            (map $arg:ident ty) => (reencoder.val_type($arg)?);
-            (map $arg:ident hty) => (reencoder.heap_type($arg)?);
-            (map $arg:ident from_ref_type) => (reencoder.ref_type($arg)?);
-            (map $arg:ident to_ref_type) => (reencoder.ref_type($arg)?);
-            (map $arg:ident memarg) => (reencoder.mem_arg($arg));
-            (map $arg:ident ordering) => (reencoder.ordering($arg));
-            (map $arg:ident local_index) => ($arg);
-            (map $arg:ident value) => ($arg);
-            (map $arg:ident lane) => ($arg);
-            (map $arg:ident lanes) => ($arg);
-            (map $arg:ident array_size) => ($arg);
-            (map $arg:ident field_index) => ($arg);
-            (map $arg:ident try_table) => ($arg);
-            (map $arg:ident argument_index) => (reencoder.type_index($arg));
-            (map $arg:ident result_index) => (reencoder.type_index($arg));
-            (map $arg:ident cont_type_index) => (reencoder.type_index($arg));
-            (map $arg:ident resume_table) => ((
-                $arg.handlers.into_iter().map(|h| reencoder.handle(h)).collect::<Vec<_>>().into()
-            ));
-
-            // This case takes the arguments of a wasmparser instruction and creates
-            // a wasm-encoder instruction. There are a few special cases for where
-            // the structure of a wasmparser instruction differs from that of
-            // wasm-encoder.
-            (build $op:ident) => (Instruction::$op);
-            (build BrTable $arg:ident) => (Instruction::BrTable($arg.0, $arg.1));
-            (build I32Const $arg:ident) => (Instruction::I32Const($arg));
-            (build I64Const $arg:ident) => (Instruction::I64Const($arg));
-            (build F32Const $arg:ident) => (Instruction::F32Const(f32::from_bits($arg.bits())));
-            (build F64Const $arg:ident) => (Instruction::F64Const(f64::from_bits($arg.bits())));
-            (build V128Const $arg:ident) => (Instruction::V128Const($arg.i128()));
-            (build TryTable $table:ident) => (Instruction::TryTable(reencoder.block_type($table.ty)?, {
-                $table.catches.into_iter().map(|c| reencoder.catch(c)).collect::<Vec<_>>().into()
-            }));
-            (build $op:ident $arg:ident) => (Instruction::$op($arg));
-            (build $op:ident $($arg:ident)*) => (Instruction::$op { $($arg),* });
         }
 
         wasmparser::for_each_operator!(translate)
     }
 
+    #[cfg(feature = "simd")]
+    fn simd_instruction<'a, T: ?Sized + Reencode>(
+        reencoder: &mut T,
+        arg: wasmparser::SimdOperator,
+    ) -> Result<crate::Instruction<'a>, Error<T::Error>> {
+        macro_rules! translate_simd {
+            ($( @$proposal:ident $op:ident $({ $($arg:ident: $argty:ty),* })? => $visit:ident ($($ann:tt)*))*) => {
+                Ok(match arg {
+                    $(
+                        wasmparser::SimdOperator::$op $({ $($arg),* })? => {
+                            $(
+                                $(let $arg = translate_map!(reencoder $arg $arg);)*
+                            )?
+                            translate_build!(reencoder $op $($($arg)*)?)
+                        }
+                    )*
+                })
+            };
+        }
+
+        wasmparser::for_each_simd_operator!(translate_simd)
+    }
+
     /// Parses the input `section` given from the `wasmparser` crate and adds
     /// all the code to the `code` section.
     pub fn parse_code_section<T: ?Sized + Reencode>(

crates/wasm-mutate/Cargo.toml

@@ -13,8 +13,8 @@ workspace = true
 [dependencies]
 clap = { workspace = true, optional = true }
 thiserror = "1.0.28"
-wasmparser = { workspace = true }
-wasm-encoder = { workspace = true, features = ["wasmparser"] }
+wasmparser = { workspace = true, features = ['simd']}
+wasm-encoder = { workspace = true, features = ['wasmparser', 'simd'] }
 rand = { workspace = true }
 log = { workspace = true }
 egg = "0.6.0"
@@ -24,4 +24,4 @@ anyhow = { workspace = true }
 wat = { workspace = true }
 wasmprinter = { workspace = true }
 env_logger = { workspace = true }
-wasmparser = { workspace = true, features = ['validate', 'features'] }
+wasmparser = { workspace = true, features = ['validate', 'features', 'simd'] }

crates/wasm-mutate/src/mutators/modify_const_exprs.rs

@@ -5,7 +5,7 @@ use crate::{Error, Mutator, ReencodeResult};
 use rand::Rng;
 use wasm_encoder::reencode::{self, Reencode, RoundtripReencoder};
 use wasm_encoder::{ElementSection, GlobalSection};
-use wasmparser::{ConstExpr, ElementSectionReader, GlobalSectionReader};
+use wasmparser::{ConstExpr, ElementSectionReader, GlobalSectionReader, SimdOperator};
 
 #[derive(PartialEq, Copy, Clone)]
 pub enum ConstExpressionMutator {
@@ -76,7 +76,7 @@ impl<'cfg, 'wasm> Reencode for InitTranslator<'cfg, 'wasm> {
             O::RefNull { .. } | O::I32Const { value: 0 | 1 } | O::I64Const { value: 0 | 1 } => true,
             O::F32Const { value } => value.bits() == 0,
             O::F64Const { value } => value.bits() == 0,
-            O::V128Const { value } => value.i128() == 0,
+            O::Simd(SimdOperator::V128Const { value }) => value.i128() == 0,
             _ => false,
         };
         if is_simplest {
@@ -86,7 +86,7 @@ impl<'cfg, 'wasm> Reencode for InitTranslator<'cfg, 'wasm> {
         let ty = match op {
             O::I32Const { .. } => T::I32,
             O::I64Const { .. } => T::I64,
-            O::V128Const { .. } => T::V128,
+            O::Simd(SimdOperator::V128Const { .. }) => T::V128,
             O::F32Const { .. } => T::F32,
             O::F64Const { .. } => T::F64,
             O::RefFunc { .. }
@@ -131,7 +131,7 @@ impl<'cfg, 'wasm> Reencode for InitTranslator<'cfg, 'wasm> {
             } else {
                 self.config.rng().gen()
             }),
-            T::V128 => CE::v128_const(if let O::V128Const { value } = op {
+            T::V128 => CE::v128_const(if let O::Simd(SimdOperator::V128Const { value }) = op {
                 self.config.rng().gen_range(0..value.i128() as u128) as i128
             } else {
                 self.config.rng().gen()