chore: parse element sections, improve contributing.md

Signed-off-by: Henry <[email protected]>

Author: explodingcamera

CONTRIBUTING.md

@@ -1,17 +1,21 @@
-# Common Commands
+# Scripts and Commands
 
-> To improve the development experience, a number of aliases have been added to the `.cargo/config.toml` file. These can be run using `cargo <command>`.
+> To improve the development experience, a number of custom commands and aliases have been added to the `.cargo/config.toml` file. These can be run using `cargo <command>`.
 
-- **`cargo dev`**\
+- **`cargo dev [args]`**\
   e.g. `cargo dev -f check ./examples/wasm/call.wat -a i32:0`\
-  Run the development version of the tinywasm-cli. This is the main command used for developing new features.
+  Run the development version of the tinywasm-cli. This is the main command used for developing new features.\
+  See [tinywasm-cli](./crates/cli) for more information.
 
 - **`cargo generate-charts`**\
-  Generate test result charts
+  Generate test result charts from the previous test runs. This is used to generate the charts in the [README](./README.md).
 
 - **`cargo test-mvp`**\
   Run the WebAssembly MVP (1.0) test suite. Be sure to cloned this repo with `--recursive` or initialize the submodules with `git submodule update --init --recursive`
 
+- **`cargo test-wast <path>`**\
+  Run a single WAST test file. e.g. `cargo test-wast ./examples/wast/i32.wast`
+
 - **`cargo version-dev`**\
   Bump the version to the next dev version. This should be used after a release so test results are not overwritten. Does not create a new github release.
 

crates/parser/src/conversion.rs

@@ -1,13 +1,62 @@
 use alloc::{boxed::Box, format, string::ToString, vec::Vec};
 use log::info;
 use tinywasm_types::{
-    BlockArgs, ConstInstruction, Export, ExternalKind, FuncType, Global, GlobalType, Import, ImportKind, Instruction,
-    MemArg, MemoryArch, MemoryType, TableType, ValType,
+    BlockArgs, ConstInstruction, ElementItem, Export, ExternalKind, FuncType, Global, GlobalType, Import, ImportKind,
+    Instruction, MemArg, MemoryArch, MemoryType, TableType, ValType,
 };
 use wasmparser::{FuncValidator, OperatorsReader, ValidatorResources};
 
 use crate::{module::CodeSection, Result};
 
+pub(crate) fn convert_module_elements<'a, T: IntoIterator<Item = wasmparser::Result<wasmparser::Element<'a>>>>(
+    elements: T,
+) -> Result<Vec<tinywasm_types::Element>> {
+    let elements = elements
+        .into_iter()
+        .map(|element| convert_module_element(element?))
+        .collect::<Result<Vec<_>>>()?;
+    Ok(elements)
+}
+
+pub(crate) fn convert_module_element(element: wasmparser::Element<'_>) -> Result<tinywasm_types::Element> {
+    let kind = match element.kind {
+        wasmparser::ElementKind::Active {
+            table_index,
+            offset_expr,
+        } => tinywasm_types::ElementKind::Active {
+            table: table_index,
+            offset: process_const_operators(offset_expr.get_operators_reader())?,
+        },
+        wasmparser::ElementKind::Passive => tinywasm_types::ElementKind::Passive,
+        wasmparser::ElementKind::Declared => tinywasm_types::ElementKind::Declared,
+    };
+
+    let items = match element.items {
+        wasmparser::ElementItems::Functions(funcs) => funcs
+            .into_iter()
+            .map(|func| Ok(ElementItem::Func(func?)))
+            .collect::<Result<Vec<_>>>()?
+            .into_boxed_slice(),
+
+        wasmparser::ElementItems::Expressions(exprs) => exprs
+            .into_iter()
+            .map(|expr| {
+                Ok(ElementItem::Expr(process_const_operators(
+                    expr?.get_operators_reader(),
+                )?))
+            })
+            .collect::<Result<Vec<_>>>()?
+            .into_boxed_slice(),
+    };
+
+    Ok(tinywasm_types::Element {
+        kind,
+        items,
+        ty: convert_valtype(&element.ty),
+        range: element.range,
+    })
+}
+
 pub(crate) fn convert_module_data_sections<'a, T: IntoIterator<Item = wasmparser::Result<wasmparser::Data<'a>>>>(
     data_sections: T,
 ) -> Result<Vec<tinywasm_types::Data>> {

crates/parser/src/lib.rs

@@ -128,6 +128,7 @@ impl TryFrom<ModuleReader> for TinyWasmModule {
             memory_types: reader.memory_types.into_boxed_slice(),
             imports: reader.imports.into_boxed_slice(),
             data: reader.data.into_boxed_slice(),
+            elements: reader.elements.into_boxed_slice(),
         })
     }
 }

crates/parser/src/module.rs

@@ -2,7 +2,7 @@ use crate::log::debug;
 use crate::{conversion, ParseError, Result};
 use alloc::{boxed::Box, format, vec::Vec};
 use core::fmt::Debug;
-use tinywasm_types::{Data, Export, FuncType, Global, Import, Instruction, MemoryType, TableType, ValType};
+use tinywasm_types::{Data, Element, Export, FuncType, Global, Import, Instruction, MemoryType, TableType, ValType};
 use wasmparser::{Payload, Validator};
 
 #[derive(Debug, Clone, PartialEq)]
@@ -25,6 +25,7 @@ pub struct ModuleReader {
     pub memory_types: Vec<MemoryType>,
     pub imports: Vec<Import>,
     pub data: Vec<Data>,
+    pub elements: Vec<Element>,
 
     // pub element_section: Option<ElementSectionReader<'a>>,
     pub end_reached: bool,
@@ -122,11 +123,10 @@ impl ModuleReader {
                 validator.memory_section(&reader)?;
                 self.memory_types = conversion::convert_module_memories(reader)?;
             }
-            ElementSection(_reader) => {
-                return Err(ParseError::UnsupportedSection("Element section".into()));
-                // debug!("Found element section");
-                // validator.element_section(&reader)?;
-                // self.element_section = Some(reader);
+            ElementSection(reader) => {
+                debug!("Found element section");
+                validator.element_section(&reader)?;
+                self.elements = conversion::convert_module_elements(reader)?;
             }
             DataSection(reader) => {
                 if !self.data.is_empty() {

crates/tinywasm/tests/generated/mvp.csv

@@ -67,7 +67,9 @@ pub struct TinyWasmModule {
 
     /// Data segments of the WebAssembly module.
     pub data: Box<[Data]>,
-    // pub elements: Option<ElementSectionReader<'a>>,
+
+    /// Element segments of the WebAssembly module.
+    pub elements: Box<[Element]>,
 }
 
 /// A WebAssembly value.
@@ -366,3 +368,24 @@ pub enum DataKind {
     Active { mem: MemAddr, offset: ConstInstruction },
     Passive,
 }
+
+#[derive(Debug, Clone)]
+pub struct Element {
+    pub kind: ElementKind,
+    pub items: Box<[ElementItem]>,
+    pub range: Range<usize>,
+    pub ty: ValType,
+}
+
+#[derive(Debug, Clone)]
+pub enum ElementKind {
+    Passive,
+    Active { table: TableAddr, offset: ConstInstruction },
+    Declared,
+}
+
+#[derive(Debug, Clone)]
+pub enum ElementItem {
+    Func(FuncAddr),
+    Expr(ConstInstruction),
+}