chore: cleanup, tweak api

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

Author: explodingcamera

crates/parser/src/visit.rs

@@ -527,10 +527,12 @@ macro_rules! atomic_visitors {
             let address = self.metadata.memory_size(memarg.memory)?;
             self.mark_memory(memarg.memory);
             let memory = self.push128(Operand128::<tinywasm_types::MemoryOperand>::new(memarg.offset, memarg.memory))?;
+            let is_64 = atomic_visitors!(@is64 [$($input),*] [$($output),*]);
+            let arg = AtomicArg::new(memory, AtomicWidth::from_bytes($width), is_64, AtomicOp::$op);
             self.emit(
                 &[$(atomic_visitors!(@size $input, address)),*],
                 &[$(atomic_visitors!(@size $output, address)),*],
-                Instruction::Atomic(AtomicArg::new(memory, AtomicWidth::from_bytes($width), atomic_visitors!(@is64 [$($input),*] [$($output),*]), AtomicOp::$op)),
+                Instruction::Atomic(arg),
             )
         }
     };

crates/tinywasm/src/imports.rs

@@ -237,23 +237,24 @@ impl ResolvedImports {
 
     fn compare_memory_types(
         import: &Import,
-        expected: &MemoryType,
         actual: &MemoryType,
+        expected: &MemoryType,
         real_size: usize,
     ) -> Result<()> {
         Self::compare_types(import, &expected.arch(), &actual.arch())?;
         Self::compare_types(import, &expected.shared(), &actual.shared())?;
 
-        if actual.page_count_initial() > expected.page_count_initial() && actual.page_count_initial() > real_size as u64
-        {
+        if (real_size as u64) < expected.page_count_initial() {
             return Err(LinkingError::incompatible_import_type(import).into());
         }
 
         if expected.page_size() != actual.page_size() {
             return Err(LinkingError::incompatible_import_type(import).into());
         }
 
-        if expected.page_count_max() > actual.page_count_max() {
+        if let Some(max) = expected.page_count_max_declared()
+            && actual.page_count_max_declared().is_none_or(|actual_max| actual_max > max)
+        {
             return Err(LinkingError::incompatible_import_type(import).into());
         }
 
@@ -364,20 +365,8 @@ impl ResolvedImports {
                     imports.tables.push(table_addr);
                 }
                 (ExternVal::Memory(memory_addr), ImportKind::Memory(ty)) => {
-                    #[cfg(feature = "std")]
-                    let (kind, pages) = if memory_addr & crate::store::SHARED_MEM_BIT != 0 {
-                        let memory =
-                            &store.state.shared_memories[(memory_addr & !crate::store::SHARED_MEM_BIT) as usize];
-                        (memory.ty(), memory.page_count())
-                    } else {
-                        let memory = store.state.get_mem(memory_addr);
-                        (memory.kind, memory.page_count)
-                    };
-                    #[cfg(not(feature = "std"))]
-                    let (kind, pages) = {
-                        let memory = store.state.get_mem(memory_addr);
-                        (memory.kind, memory.page_count)
-                    };
+                    let kind = store.state.memory_type(memory_addr);
+                    let (_, pages) = store.state.memory_size(memory_addr);
                     Self::compare_memory_types(import, &kind, ty, pages)?;
                     imports.memories.push(memory_addr);
                 }

crates/tinywasm/src/instance.rs

@@ -215,9 +215,9 @@ impl ModuleInstance {
         addrs.tags.extend(store.init_tags(&module.tags, &type_addrs));
         let limiter = store.engine.config().resource_limiter.clone();
         if !module.skip_local_memory_allocation {
-            addrs
-                .memories
-                .extend(store.init_memories(&module.memory_types, |ty| MemoryInstance::new(ty, limiter.as_deref()))?);
+            let memories =
+                store.init_memories(&module.memory_types, |ty| MemoryInstance::new(ty, limiter.as_deref()))?;
+            addrs.memories.extend(memories);
         }
 
         store.init_globals(&mut addrs.globals, &module.globals, &addrs.funcs, &type_addrs)?;
@@ -316,35 +316,15 @@ impl ModuleInstance {
     /// ```
     pub fn exports(&self) -> impl Iterator<Item = (&str, ExternItem)> + '_ {
         self.0.exports.iter().map(move |export| {
-            let item = match export.kind {
-                ExternalKind::Func => ExternItem::Func(Function {
-                    item: StoreItem::new(self.0.store_id, self.resolve_func_addr(export.index)),
-                    module_id: self.id(),
-                }),
-                ExternalKind::Table => {
-                    ExternItem::Table(Table(StoreItem::new(self.0.store_id, self.resolve_table_addr(export.index))))
-                }
-                ExternalKind::Memory => {
-                    let addr = self.resolve_mem_addr(export.index);
-                    #[cfg(feature = "std")]
-                    if addr & SHARED_MEM_BIT != 0 {
-                        ExternItem::MemoryShared(
-                            self.shared_backing(addr).expect("exported shared memory has a backing"),
-                        )
-                    } else {
-                        ExternItem::Memory(Memory(StoreItem::new(self.0.store_id, addr)))
-                    }
-                    #[cfg(not(feature = "std"))]
-                    ExternItem::Memory(Memory(StoreItem::new(self.0.store_id, addr)))
-                }
-                ExternalKind::Global => {
-                    ExternItem::Global(Global(StoreItem::new(self.0.store_id, self.resolve_global_addr(export.index))))
-                }
-                ExternalKind::Tag => {
-                    ExternItem::Tag(Tag(StoreItem::new(self.0.store_id, self.resolve_tag_addr(export.index))))
-                }
+            let addr = match export.kind {
+                ExternalKind::Func => self.resolve_func_addr(export.index),
+                ExternalKind::Table => self.resolve_table_addr(export.index),
+                ExternalKind::Memory => self.resolve_mem_addr(export.index),
+                ExternalKind::Global => self.resolve_global_addr(export.index),
+                ExternalKind::Tag => self.resolve_tag_addr(export.index),
             };
-
+            let value = ExternVal::new(export.kind, addr);
+            let item = self.resolve_extern(value).expect("exported extern has a backing");
             (export.name.as_ref(), item)
         })
     }
@@ -388,7 +368,11 @@ impl ModuleInstance {
     /// # }
     /// ```
     pub fn extern_item(&self, name: &str) -> Result<ExternItem> {
-        match self.require_export(name)? {
+        self.resolve_extern(self.require_export(name)?)
+    }
+
+    fn resolve_extern(&self, value: ExternVal) -> Result<ExternItem> {
+        match value {
             ExternVal::Func(addr) => {
                 Ok(ExternItem::Func(Function { item: StoreItem::new(self.0.store_id, addr), module_id: self.id() }))
             }

crates/tinywasm/src/interpreter/executor/mod.rs

@@ -866,18 +866,17 @@ impl<'store> Executor<'store> {
         let value = T::local_get(&self.store.value_stack, &self.cf, u16::from(value_local));
         let mem_addr = self.mem_addr(MemAddr::from(memarg.memory()));
         crate::store::with_memory!(self.store.state, mem_addr, |mem, kind| {
-            let addr = if kind.arch() == MemoryArch::I64 {
+            let base = if kind.arch() == MemoryArch::I64 {
                 let base = u64::local_get(&self.store.value_stack, &self.cf, u16::from(addr_local));
-                let base = cold_err!(usize::try_from(base).map_err(|_| Trap::MemoryOutOfBounds {
+                cold_err!(usize::try_from(base).map_err(|_| Trap::MemoryOutOfBounds {
                     offset: usize::MAX,
                     len: N,
                     max: mem.len(),
-                }))?;
-                cold_err!(mem.effective_addr::<N>(base, u64::from(memarg.offset())))?
+                }))?
             } else {
-                let base = u32::local_get(&self.store.value_stack, &self.cf, u16::from(addr_local));
-                cold_err!(mem.effective_addr::<N>(base as usize, u64::from(memarg.offset())))?
+                u32::local_get(&self.store.value_stack, &self.cf, u16::from(addr_local)) as usize
             };
+            let addr = cold_err!(mem.effective_addr::<N>(base, u64::from(memarg.offset())))?;
             value.store_at(&mut *mem, addr)
         })
     }
@@ -891,18 +890,17 @@ impl<'store> Executor<'store> {
         let memarg = index.resolve(&self.func.data);
         let mem_addr = self.mem_addr(MemAddr::from(memarg.memory()));
         crate::store::with_memory!(self.store.state, mem_addr, |mem, kind| {
-            let addr = if kind.arch() == MemoryArch::I64 {
+            let base = if kind.arch() == MemoryArch::I64 {
                 let base = i64::local_get(&self.store.value_stack, &self.cf, u16::from(addr_local)) as u64;
-                let base = cold_err!(usize::try_from(base).map_err(|_| Trap::MemoryOutOfBounds {
+                cold_err!(usize::try_from(base).map_err(|_| Trap::MemoryOutOfBounds {
                     offset: usize::MAX,
                     len: N,
                     max: mem.len(),
-                }))?;
-                cold_err!(mem.effective_addr::<N>(base, u64::from(memarg.offset())))?
+                }))?
             } else {
-                let base = u32::local_get(&self.store.value_stack, &self.cf, u16::from(addr_local));
-                cold_err!(mem.effective_addr::<N>(base as usize, u64::from(memarg.offset())))?
+                u32::local_get(&self.store.value_stack, &self.cf, u16::from(addr_local)) as usize
             };
+            let addr = cold_err!(mem.effective_addr::<N>(base, u64::from(memarg.offset())))?;
 
             let value = cold_err!(T::load_at(&*mem, addr))?;
             increment(value).store_at(&mut *mem, addr)
@@ -1343,28 +1341,19 @@ impl<'store> Executor<'store> {
         let dst = self.store.value_stack.pop_memory_operand(arch)?;
 
         let data = self.store.state.data[self.module.resolve_data_addr(data_index) as usize].data.clone();
+        // Dropped segments behave like empty segments, including valid zero-length copies.
+        let data = data.as_deref().unwrap_or_default();
+        let end = offset.checked_add(size).filter(|&end| end <= data.len()).ok_or(Trap::MemoryOutOfBounds {
+            offset,
+            len: size,
+            max: data.len(),
+        })?;
         crate::store::with_memory!(self.store.state, mem_addr, |mem, kind| {
-            let data_len = data.as_ref().map_or(0, |d| d.len());
-            let mem_len = mem.len();
-            if offset.checked_add(size).is_none_or(|end| end > data_len) {
-                return cold!(Err(Trap::MemoryOutOfBounds { offset, len: size, max: data_len }));
-            }
-            if dst.checked_add(size).is_none_or(|end| end > mem_len) {
-                return cold!(Err(Trap::MemoryOutOfBounds { offset: dst, len: size, max: mem_len }));
-            }
-
-            if size == 0 {
-                return Ok(());
-            }
-
-            let Some(data) = &data else {
-                return cold!(Err(Trap::MemoryOutOfBounds { offset: 0, len: 0, max: 0 }));
-            };
-
-            if mem.write_all(dst, &data[offset..offset + size]).is_none() {
-                return cold!(Err(Trap::MemoryOutOfBounds { offset: dst, len: size, max: mem_len }));
-            }
-            Ok(())
+            cold_err!(mem.write_all(dst, &data[offset..end]).ok_or_else(|| Trap::MemoryOutOfBounds {
+                offset: dst,
+                len: size,
+                max: mem.len(),
+            }))
         })
     }
 
@@ -1531,10 +1520,9 @@ impl<'store> Executor<'store> {
             }
 
             match arg.is_64() {
-                true => u64::stack_push(&mut self.store.value_stack, old)?,
-                false => u32::stack_push(&mut self.store.value_stack, old as u32)?,
+                true => u64::stack_push(&mut self.store.value_stack, old),
+                false => u32::stack_push(&mut self.store.value_stack, old as u32),
             }
-            Ok(())
         })
     }
 
@@ -1550,8 +1538,7 @@ impl<'store> Executor<'store> {
         crate::store::with_memory!(self.store.state, mem_addr, |mem, kind| {
             let base = self.store.value_stack.pop_memory_operand(kind.arch())?;
             let addr = cold_err!(mem.effective_addr::<N>(base, m.offset()))?;
-            cold_err!(val.store_at(&mut *mem, addr))?;
-            Ok(())
+            cold_err!(val.store_at(&mut *mem, addr))
         })
     }
 

crates/tinywasm/src/store/memory/instance.rs

@@ -23,16 +23,19 @@ impl core::fmt::Debug for MemoryInstance {
 }
 
 impl MemoryInstance {
+    /// Converts a page count to a byte length that fits the host address space.
     #[inline]
     pub(super) fn host_size(kind: MemoryType, pages: u64) -> Option<usize> {
         pages.checked_mul(kind.page_size()).and_then(|size| usize::try_from(size).ok())
     }
 
+    /// Returns the declared byte limit, saturating when it exceeds the host address space.
     #[inline]
-    fn maximum_size(kind: MemoryType) -> Option<usize> {
+    pub(super) fn maximum_size(kind: MemoryType) -> Option<usize> {
         kind.page_count_max_declared().map(|pages| Self::host_size(kind, pages).unwrap_or(usize::MAX))
     }
 
+    /// Applies the runtime's memory64 allocation cap to the declared page limit.
     #[inline]
     pub(super) fn page_count_max(kind: MemoryType) -> u64 {
         match kind.arch() {
@@ -101,6 +104,7 @@ impl MemoryInstance {
         Self::grow_storage(self.kind, &mut self.inner, &mut self.page_count, pages_delta, limiter)
     }
 
+    /// Grows exclusively borrowed storage after checking limits and the host limiter.
     pub(super) fn grow_storage(
         kind: MemoryType,
         inner: &mut MemoryStorage,