feat: import section

Signed-off-by: Henry Gressmann <mail@henrygressmann.de>

Author: explodingcamera

crates/parser/src/conversion.rs

@@ -1,53 +1,87 @@
 use alloc::{boxed::Box, format, string::ToString, vec::Vec};
 use log::info;
 use tinywasm_types::{
-    BlockArgs, ConstInstruction, Export, ExternalKind, FuncType, Global, Instruction, MemArg, MemoryArch, MemoryType,
-    TableType, ValType,
+    BlockArgs, ConstInstruction, Export, ExternalKind, FuncType, Global, GlobalType, Import, ImportKind, Instruction,
+    MemArg, MemoryArch, MemoryType, TableType, ValType,
 };
 use wasmparser::{FuncValidator, ValidatorResources};
 
 use crate::{module::CodeSection, Result};
 
+pub(crate) fn convert_module_imports<'a, T: IntoIterator<Item = wasmparser::Result<wasmparser::Import<'a>>>>(
+    imports: T,
+) -> Result<Vec<Import>> {
+    let imports = imports
+        .into_iter()
+        .map(|import| convert_module_import(import?))
+        .collect::<Result<Vec<_>>>()?;
+    Ok(imports)
+}
+
+pub(crate) fn convert_module_import<'a>(import: wasmparser::Import<'a>) -> Result<Import> {
+    Ok(Import {
+        module: import.module.to_string(),
+        name: import.name.to_string(),
+        kind: match import.ty {
+            wasmparser::TypeRef::Func(ty) => ImportKind::Func(ty),
+            wasmparser::TypeRef::Table(ty) => ImportKind::Table(convert_module_table(ty)?),
+            wasmparser::TypeRef::Memory(ty) => ImportKind::Mem(convert_module_memory(ty)?),
+            wasmparser::TypeRef::Global(ty) => ImportKind::Global(GlobalType {
+                mutable: ty.mutable,
+                ty: convert_valtype(&ty.content_type),
+            }),
+            wasmparser::TypeRef::Tag(ty) => {
+                return Err(crate::ParseError::UnsupportedOperator(format!(
+                    "Unsupported import kind: {:?}",
+                    ty
+                )))
+            }
+        },
+    })
+}
+
 pub(crate) fn convert_module_memories<T: IntoIterator<Item = wasmparser::Result<wasmparser::MemoryType>>>(
     memory_types: T,
 ) -> Result<Vec<MemoryType>> {
     let memory_type = memory_types
         .into_iter()
-        .map(|memory| {
-            let memory = memory?;
-            Ok(MemoryType {
-                arch: match memory.memory64 {
-                    true => MemoryArch::I64,
-                    false => MemoryArch::I32,
-                },
-                page_count_initial: memory.initial,
-                page_count_max: memory.maximum,
-            })
-        })
+        .map(|memory| convert_module_memory(memory?))
         .collect::<Result<Vec<_>>>()?;
 
     Ok(memory_type)
 }
 
+pub(crate) fn convert_module_memory(memory: wasmparser::MemoryType) -> Result<MemoryType> {
+    Ok(MemoryType {
+        arch: match memory.memory64 {
+            true => MemoryArch::I64,
+            false => MemoryArch::I32,
+        },
+        page_count_initial: memory.initial,
+        page_count_max: memory.maximum,
+    })
+}
+
 pub(crate) fn convert_module_tables<T: IntoIterator<Item = wasmparser::Result<wasmparser::TableType>>>(
     table_types: T,
 ) -> Result<Vec<TableType>> {
     let table_type = table_types
         .into_iter()
-        .map(|table| {
-            let table = table?;
-            let ty = convert_valtype(&table.element_type);
-            Ok(TableType {
-                element_type: ty,
-                size_initial: table.initial,
-                size_max: table.maximum,
-            })
-        })
+        .map(|table| convert_module_table(table?))
         .collect::<Result<Vec<_>>>()?;
 
     Ok(table_type)
 }
 
+pub(crate) fn convert_module_table(table: wasmparser::TableType) -> Result<TableType> {
+    let ty = convert_valtype(&table.element_type);
+    Ok(TableType {
+        element_type: ty,
+        size_initial: table.initial,
+        size_max: table.maximum,
+    })
+}
+
 pub(crate) fn convert_module_globals<'a, T: IntoIterator<Item = wasmparser::Result<wasmparser::Global<'a>>>>(
     globals: T,
 ) -> Result<Vec<Global>> {
@@ -70,9 +104,11 @@ pub(crate) fn convert_module_globals<'a, T: IntoIterator<Item = wasmparser::Resu
             assert!(matches!(ops[ops.len() - 1], wasmparser::Operator::End));
 
             Ok(Global {
-                ty,
                 init: process_const_operator(ops[ops.len() - 2].clone())?,
-                mutable: global.ty.mutable,
+                ty: GlobalType {
+                    mutable: global.ty.mutable,
+                    ty,
+                },
             })
         })
         .collect::<Result<Vec<_>>>()?;

crates/parser/src/module.rs

@@ -1,7 +1,7 @@
 use crate::log::debug;
 use alloc::{boxed::Box, format, vec::Vec};
 use core::fmt::Debug;
-use tinywasm_types::{Export, FuncType, Global, Instruction, MemoryType, TableType, ValType};
+use tinywasm_types::{Export, FuncType, Global, Import, Instruction, MemoryType, TableType, ValType};
 use wasmparser::{Payload, Validator};
 
 use crate::{conversion, ParseError, Result};
@@ -24,10 +24,10 @@ pub struct ModuleReader {
     pub globals: Vec<Global>,
     pub table_types: Vec<TableType>,
     pub memory_types: Vec<MemoryType>,
+    pub imports: Vec<Import>,
 
     // pub element_section: Option<ElementSectionReader<'a>>,
     // pub data_section: Option<DataSectionReader<'a>>,
-    // pub import_section: Option<ImportSectionReader<'a>>,
     pub end_reached: bool,
 }
 
@@ -42,9 +42,9 @@ impl Debug for ModuleReader {
             .field("globals", &self.globals)
             .field("table_types", &self.table_types)
             .field("memory_types", &self.memory_types)
+            .field("import_section", &self.imports)
             // .field("element_section", &self.element_section)
             // .field("data_section", &self.data_section)
-            // .field("import_section", &self.import_section)
             .finish()
     }
 }
@@ -116,7 +116,6 @@ impl ModuleReader {
                 if !self.code.is_empty() {
                     return Err(ParseError::DuplicateSection("Code section".into()));
                 }
-
                 validator.code_section_start(count, &range)?;
             }
             CodeSectionEntry(function) => {
@@ -127,12 +126,13 @@ impl ModuleReader {
                 self.code
                     .push(conversion::convert_module_code(function, func_validator)?);
             }
-            ImportSection(_reader) => {
-                return Err(ParseError::UnsupportedSection("Import section".into()));
-
-                // debug!("Found import section");
-                // validator.import_section(&reader)?;
-                // self.import_section = Some(reader);
+            ImportSection(reader) => {
+                debug!("Found import section");
+                validator.import_section(&reader)?;
+                self.imports = reader
+                    .into_iter()
+                    .map(|i| conversion::convert_module_import(i?))
+                    .collect::<Result<Vec<_>>>()?;
             }
             ExportSection(reader) => {
                 debug!("Found export section");