Add parsing methods (#1627)

Co-authored-by: Alex Crichton <[email protected]>

crates/wasm-encoder/Cargo.toml

@@ -13,6 +13,9 @@ A low-level WebAssembly encoder.
 """
 rust-version.workspace = true
 
+[package.metadata.docs.rs]
+all-features = true
+
 [lints]
 workspace = true
 

crates/wasm-encoder/src/core/code.rs

@@ -103,6 +103,30 @@ impl CodeSection {
  self.num_added += 1;
  self
  }
+
+ /// Parses the input `section` given from the `wasmparser` crate and adds
+ /// all the code to this section.
+ #[cfg(feature = "wasmparser")]
+ pub fn parse_section(
+ &mut self,
+ section: wasmparser::CodeSectionReader<'_>,
+ ) -> wasmparser::Result<&mut Self> {
+ for code in section {
+ self.parse(code?)?;
+ }
+ Ok(self)
+ }
+
+ /// Parses a single [`wasmparser::Code`] and adds it to this section.
+ #[cfg(feature = "wasmparser")]
+ pub fn parse(&mut self, func: wasmparser::FunctionBody<'_>) -> wasmparser::Result<&mut Self> {
+ let mut f = Function::new_parsed_locals(&func)?;
+ let mut reader = func.get_operators_reader()?;
+ while !reader.eof() {
+ f.parse(&mut reader)?;
+ }
+ Ok(self.function(&f))
+ }
 }
 
 impl Encode for CodeSection {
@@ -214,6 +238,18 @@ impl Function {
  Function::new(locals_collected)
  }
 
+ /// Create a new [`Function`] by parsing the locals declarations from the
+ /// provided [`wasmparser::FunctionBody`].
+ #[cfg(feature = "wasmparser")]
+ pub fn new_parsed_locals(func: &wasmparser::FunctionBody<'_>) -> wasmparser::Result<Self> {
+ let mut locals = Vec::new();
+ for pair in func.get_locals_reader()? {
+ let (cnt, ty) = pair?;
+ locals.push((cnt, ty.try_into().unwrap()));
+ }
+ Ok(Function::new(locals))
+ }
+
  /// Write an instruction into this function body.
  pub fn instruction(&mut self, instruction: &Instruction) -> &mut Self {
  instruction.encode(&mut self.bytes);
@@ -237,6 +273,15 @@ impl Function {
  pub fn byte_len(&self) -> usize {
  self.bytes.len()
  }
+
+ /// Parses a single instruction from `reader` and adds it to `self`.
+ #[cfg(feature = "wasmparser")]
+ pub fn parse(
+ &mut self,
+ reader: &mut wasmparser::OperatorsReader<'_>,
+ ) -> wasmparser::Result<&mut Self> {
+ Ok(self.instruction(&reader.read()?.try_into().unwrap()))
+ }
 }
 
 impl Encode for Function {
@@ -276,6 +321,17 @@ impl Encode for MemArg {
  }
 }
 
+#[cfg(feature = "wasmparser")]
+impl From<wasmparser::MemArg> for MemArg {
+ fn from(arg: wasmparser::MemArg) -> MemArg {
+ MemArg {
+ offset: arg.offset,
+ align: arg.align.into(),
+ memory_index: arg.memory,
+ }
+ }
+}
+
 /// The memory ordering for atomic instructions.
 ///
 /// For an in-depth explanation of memory orderings, see the C++ documentation
@@ -304,6 +360,16 @@ impl Encode for Ordering {
  }
 }
 
+#[cfg(feature = "wasmparser")]
+impl From<wasmparser::Ordering> for Ordering {
+ fn from(arg: wasmparser::Ordering) -> Ordering {
+ match arg {
+ wasmparser::Ordering::SeqCst => Ordering::SeqCst,
+ wasmparser::Ordering::AcqRel => Ordering::AcqRel,
+ }
+ }
+}
+
 /// Describe an unchecked SIMD lane index.
 pub type Lane = u8;
 
@@ -328,6 +394,18 @@ impl Encode for BlockType {
  }
 }
 
+#[cfg(feature = "wasmparser")]
+impl TryFrom<wasmparser::BlockType> for BlockType {
+ type Error = ();
+ fn try_from(arg: wasmparser::BlockType) -> Result<BlockType, ()> {
+ match arg {
+ wasmparser::BlockType::Empty => Ok(BlockType::Empty),
+ wasmparser::BlockType::FuncType(n) => Ok(BlockType::FunctionType(n)),
+ wasmparser::BlockType::Type(t) => Ok(BlockType::Result(t.try_into()?)),
+ }
+ }
+}
+
 /// WebAssembly instructions.
 #[derive(Clone, Debug)]
 #[non_exhaustive]
@@ -350,14 +428,14 @@ pub enum Instruction<'a> {
  Call(u32),
  CallRef(u32),
  CallIndirect {
- ty: u32,
- table: u32,
+ type_index: u32,
+ table_index: u32,
  },
  ReturnCallRef(u32),
  ReturnCall(u32),
  ReturnCallIndirect {
- ty: u32,
- table: u32,
+ type_index: u32,
+ table_index: u32,
  },
  TryTable(BlockType, Cow<'a, [Catch]>),
  Throw(u32),
@@ -1119,10 +1197,13 @@ impl Encode for Instruction<'_> {
  sink.push(0x14);
  ty.encode(sink);
  }
- Instruction::CallIndirect { ty, table } => {
+ Instruction::CallIndirect {
+ type_index,
+ table_index,
+ } => {
  sink.push(0x11);
- ty.encode(sink);
- table.encode(sink);
+ type_index.encode(sink);
+ table_index.encode(sink);
  }
  Instruction::ReturnCallRef(ty) => {
  sink.push(0x15);
@@ -1133,10 +1214,13 @@ impl Encode for Instruction<'_> {
  sink.push(0x12);
  f.encode(sink);
  }
- Instruction::ReturnCallIndirect { ty, table } => {
+ Instruction::ReturnCallIndirect {
+ type_index,
+ table_index,
+ } => {
  sink.push(0x13);
- ty.encode(sink);
- table.encode(sink);
+ type_index.encode(sink);
+ table_index.encode(sink);
  }
  Instruction::Delegate(l) => {
  sink.push(0x18);
@@ -3278,6 +3362,64 @@ impl Encode for Instruction<'_> {
  }
 }
 
+#[cfg(feature = "wasmparser")]
+impl TryFrom<wasmparser::Operator<'_>> for Instruction<'_> {
+ type Error = ();
+
+ fn try_from(arg: wasmparser::Operator<'_>) -> Result<Self, ()> {
+ use Instruction::*;
+
+ macro_rules! define_match {
+ ($(@$p:ident $op:ident $({ $($arg:ident: $argty:ty),* })? => $visit:ident)*) => {
+ match arg {
+ $(
+ wasmparser::Operator::$op $({ $($arg),* })? => {
+ $(
+ $(let $arg = define_match!(map $arg $arg);)*
+ )?
+ Ok(define_match!(mk $op $($($arg)*)?))
+ }
+ )*
+ }
+ };
+
+ // No-payload instructions are named the same in wasmparser as they are in
+ // wasm-encoder
+ (mk $op:ident) => ($op);
+
+ // Instructions which need "special care" to map from wasmparser to
+ // wasm-encoder
+ (mk BrTable $arg:ident) => ({BrTable($arg.0, $arg.1)});
+ (mk TryTable $arg:ident) => ({TryTable($arg.0, $arg.1)});
+
+ // Catch-all for the translation of one payload argument which is typically
+ // represented as a tuple-enum in wasm-encoder.
+ (mk $op:ident $arg:ident) => ($op($arg));
+
+ // Catch-all of everything else where the wasmparser fields are simply
+ // translated to wasm-encoder fields.
+ (mk $op:ident $($arg:ident)*) => ($op { $($arg),* });
+
+ // Special-case BrTable/TryTable conversion of arguments.
+ (map $arg:ident targets) => ((
+ $arg.targets().map(|i| i.unwrap()).collect::<Vec<_>>().into(),
+ $arg.default(),
+ ));
+ (map $arg:ident try_table) => ((
+ $arg.ty.try_into().unwrap(),
+ $arg.catches.into_iter().map(|i| i.into()).collect::<Vec<_>>().into(),
+ ));
+
+ // Everything else is converted with `TryFrom`/`From`. Note that the
+ // fallibility here has to do with how indexes are represented in
+ // `wasmparser` which we know when reading directly we'll never hit the
+ // erroneous cases here, hence the unwrap.
+ (map $arg:ident $other:ident) => {$other.try_into().unwrap()};
+ }
+ wasmparser::for_each_operator!(define_match)
+ }
+}
+
 #[derive(Clone, Debug)]
 #[allow(missing_docs)]
 pub enum Catch {
@@ -3312,6 +3454,18 @@ impl Encode for Catch {
  }
 }
 
+#[cfg(feature = "wasmparser")]
+impl From<wasmparser::Catch> for Catch {
+ fn from(arg: wasmparser::Catch) -> Catch {
+ match arg {
+ wasmparser::Catch::One { tag, label } => Catch::One { tag, label },
+ wasmparser::Catch::OneRef { tag, label } => Catch::OneRef { tag, label },
+ wasmparser::Catch::All { label } => Catch::All { label },
+ wasmparser::Catch::AllRef { label } => Catch::AllRef { label },
+ }
+ }
+}
+
 /// A constant expression.
 ///
 /// Usable in contexts such as offsets or initializers.
@@ -3494,6 +3648,13 @@ pub enum ConstExprConversionError {
  CanonicalizedTypeReference,
 }
 
+#[cfg(feature = "wasmparser")]
+impl From<wasmparser::BinaryReaderError> for ConstExprConversionError {
+ fn from(err: wasmparser::BinaryReaderError) -> ConstExprConversionError {
+ ConstExprConversionError::ParseError(err)
+ }
+}
+
 #[cfg(feature = "wasmparser")]
 impl std::fmt::Display for ConstExprConversionError {
  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

crates/wasm-encoder/src/core/custom.rs

@@ -44,6 +44,16 @@ impl Section for RawCustomSection<'_> {
  }
 }
 
+#[cfg(feature = "wasmparser")]
+impl<'a> From<wasmparser::CustomSectionReader<'a>> for CustomSection<'a> {
+ fn from(section: wasmparser::CustomSectionReader<'a>) -> Self {
+ CustomSection {
+ data: section.data().into(),
+ name: section.name().into(),
+ }
+ }
+}
+
 #[cfg(test)]
 mod tests {
  use super::*;

crates/wasm-encoder/src/core/data.rs

@@ -151,6 +151,38 @@ impl DataSection {
  self.num_added += 1;
  self
  }
+
+ /// Parses the input `section` given from the `wasmparser` crate and adds
+ /// all the data to this section.
+ #[cfg(feature = "wasmparser")]
+ pub fn parse_section(
+ &mut self,
+ section: wasmparser::DataSectionReader<'_>,
+ ) -> Result<&mut Self, crate::ConstExprConversionError> {
+ for data in section {
+ self.parse(data?)?;
+ }
+ Ok(self)
+ }
+
+ /// Parses a single [`wasmparser::Data`] and adds it to this section.
+ #[cfg(feature = "wasmparser")]
+ pub fn parse(
+ &mut self,
+ data: wasmparser::Data<'_>,
+ ) -> Result<&mut Self, crate::ConstExprConversionError> {
+ match data.kind {
+ wasmparser::DataKind::Active {
+ memory_index,
+ offset_expr,
+ } => Ok(self.active(
+ memory_index,
+ &ConstExpr::try_from(offset_expr)?,
+ data.data.iter().copied(),
+ )),
+ wasmparser::DataKind::Passive => Ok(self.passive(data.data.iter().copied())),
+ }
+ }
 }
 
 impl Encode for DataSection {

crates/wasm-encoder/src/core/elements.rs

@@ -206,6 +206,54 @@ impl ElementSection {
  self.num_added += 1;
  self
  }
+
+ /// Parses the input `section` given from the `wasmparser` crate and adds
+ /// all the elements to this section.
+ #[cfg(feature = "wasmparser")]
+ pub fn parse_section(
+ &mut self,
+ section: wasmparser::ElementSectionReader<'_>,
+ ) -> Result<&mut Self, crate::ConstExprConversionError> {
+ for element in section {
+ self.parse(element?)?;
+ }
+ Ok(self)
+ }
+
+ /// Parses the single [`wasmparser::Element`] provided and adds it to this
+ /// section.
+ #[cfg(feature = "wasmparser")]
+ pub fn parse(
+ &mut self,
+ element: wasmparser::Element<'_>,
+ ) -> Result<&mut Self, crate::ConstExprConversionError> {
+ let mut funcs;
+ let mut exprs;
+ let elements = match element.items {
+ wasmparser::ElementItems::Functions(f) => {
+ funcs = Vec::new();
+ for func in f {
+ funcs.push(func?);
+ }
+ Elements::Functions(&funcs)
+ }
+ wasmparser::ElementItems::Expressions(ty, e) => {
+ exprs = Vec::new();
+ for expr in e {
+ exprs.push(ConstExpr::try_from(expr?)?);
+ }
+ Elements::Expressions(ty.try_into().unwrap(), &exprs)
+ }
+ };
+ match element.kind {
+ wasmparser::ElementKind::Active {
+ table_index,
+ offset_expr,
+ } => Ok(self.active(table_index, &ConstExpr::try_from(offset_expr)?, elements)),
+ wasmparser::ElementKind::Passive => Ok(self.passive(elements)),
+ wasmparser::ElementKind::Declared => Ok(self.declared(elements)),
+ }
+ }
 }
 
 impl Encode for ElementSection {