fix no_std building

* Avoid temporary allocation when push locals during function invocation.

* Extend value stack for all locals at once.

.travis.yml

@@ -40,7 +40,17 @@ after_success: |
   ghp-import -n target/doc &&
   git push -fq https://${GH_TOKEN}@github.com/${TRAVIS_REPO_SLUG}.git gh-pages
 
-cache: cargo
+cache:
+  # Don't use `cache: cargo` since it adds the `target` directory and that can be huge.
+  # Saving and loading this directory dwarfes actual compilation and test times. But what is more
+  # important, is that travis timeouts the build since the job doesn't produce any output for more
+  # than 10 minutes.
+  #
+  # So we just cache ~/.cargo directory
+  directories:
+    - /home/travis/.cargo
 before_cache:
   # Travis can't cache files that are not readable by "others"
   - chmod -R a+r $HOME/.cargo
+  # According to the Travis CI docs for building Rust project this is done by,
+  - rm -rf /home/travis/.cargo/registry

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "wasmi"
-version = "0.5.0"
+version = "0.5.1"
 authors = ["Nikolay Volf <nikvolf@gmail.com>", "Svyatoslav Nikolsky <svyatonik@yandex.ru>", "Sergey Pepyakin <s.pepyakin@gmail.com>"]
 license = "MIT/Apache-2.0"
 readme = "README.md"
@@ -11,18 +11,17 @@ keywords = ["wasm", "webassembly", "bytecode", "interpreter"]
 exclude = [ "/res/*", "/tests/*", "/fuzz/*", "/benches/*" ]
 
 [dependencies]
-wasmi-validation = { version = "0.1", path = "validation", default-features = false }
-parity-wasm = { version = "0.31", default-features = false }
+wasmi-validation = { version = "0.2", path = "validation", default-features = false }
+parity-wasm = { version = "0.40.1", default-features = false }
 memory_units = "0.3.0"
 libm = { version = "0.1.2", optional = true }
-num-rational = "0.2.2"
-num-traits = "0.2.8"
-libc = "0.2.58"
+num-rational = { version = "0.2.2", default-features = false }
+num-traits = { version = "0.2.8", default-features = false }
 
 [dev-dependencies]
 assert_matches = "1.1"
 rand = "0.4.2"
-wabt = "0.6"
+wabt = "0.9"
 
 [features]
 default = ["std"]
@@ -31,6 +30,7 @@ std = [
     "parity-wasm/std",
     "wasmi-validation/std",
     "num-rational/std",
+    "num-rational/bigint-std",
     "num-traits/std"
 ]
 # Enable for no_std support

README.md

@@ -26,8 +26,8 @@ This crate supports `no_std` environments.
 Enable the `core` feature and disable default features:
 ```toml
 [dependencies]
-parity-wasm = {
-	version = "0.31",
+wasmi = {
+	version = "*",
 	default-features = false,
 	features = "core"
 }

benches/Cargo.toml

@@ -6,7 +6,7 @@ authors = ["Sergey Pepyakin <s.pepyakin@gmail.com>"]
 [dependencies]
 wasmi = { path = ".." }
 assert_matches = "1.2"
-wabt = "0.6"
+wabt = "0.9"
 
 [profile.bench]
 debug = true

benches/wasm-kernel/src/lib.rs

@@ -33,7 +33,7 @@ pub extern "C" fn prepare_tiny_keccak() -> *const TinyKeccakTestData {
 }
 
 #[no_mangle]
-pub extern "C" fn bench_tiny_keccak(test_data: *const TinyKeccakTestData) {
+pub extern "C" fn bench_tiny_keccak(test_data: *mut TinyKeccakTestData) {
 	unsafe {
 		let mut keccak = Keccak::new_keccak256();
 		keccak.update((*test_data).data);

fuzz/Cargo.toml

@@ -10,7 +10,7 @@ cargo-fuzz = true
 
 [dependencies]
 wasmi = { path = ".." }
-wabt = "0.6.0"
+wabt = "0.9"
 wasmparser = "0.14.1"
 tempdir = "0.3.6"
 

hfuzz/Cargo.toml

@@ -7,4 +7,4 @@ authors = ["Sergey Pepyakin <s.pepyakin@gmail.com>"]
 honggfuzz = "=0.5.9" # Strict equal since hfuzz requires dep and cmd versions to match.
 wasmi = { path = ".." }
 tempdir = "0.3.6"
-wabt = "0.6.0"
+wabt = "0.9"

src/func.rs

@@ -1,4 +1,5 @@
 use alloc::{
+    borrow::Cow,
     rc::{Rc, Weak},
     vec::Vec,
 };
@@ -195,12 +196,13 @@ impl FuncInstance {
     /// [`resume_execution`]: struct.FuncInvocation.html#method.resume_execution
     pub fn invoke_resumable<'args>(
         func: &FuncRef,
-        args: &'args [RuntimeValue],
+        args: impl Into<Cow<'args, [RuntimeValue]>>,
     ) -> Result<FuncInvocation<'args>, Trap> {
+        let args = args.into();
         check_function_args(func.signature(), &args)?;
         match *func.as_internal() {
             FuncInstanceInternal::Internal { .. } => {
-                let interpreter = Interpreter::new(func, args, None)?;
+                let interpreter = Interpreter::new(func, &*args, None)?;
                 Ok(FuncInvocation {
                     kind: FuncInvocationKind::Internal(interpreter),
                 })
@@ -257,7 +259,7 @@ pub struct FuncInvocation<'args> {
 enum FuncInvocationKind<'args> {
     Internal(Interpreter),
     Host {
-        args: &'args [RuntimeValue],
+        args: Cow<'args, [RuntimeValue]>,
         host_func_index: usize,
         finished: bool,
     },
@@ -304,7 +306,7 @@ impl<'args> FuncInvocation<'args> {
                     return Err(ResumableError::AlreadyStarted);
                 }
                 *finished = true;
-                Ok(externals.invoke_index(*host_func_index, args.clone().into())?)
+                Ok(externals.invoke_index(*host_func_index, args.as_ref().into())?)
             }
         }
     }

src/lib.rs

@@ -404,7 +404,7 @@ pub use self::func::{FuncInstance, FuncInvocation, FuncRef, ResumableError};
 pub use self::global::{GlobalInstance, GlobalRef};
 pub use self::host::{Externals, HostError, NopExternals, RuntimeArgs};
 pub use self::imports::{ImportResolver, ImportsBuilder, ModuleImportResolver};
-pub use self::memory::{MemoryBackend, ByteBuf, MemoryInstance, MemoryRef, LINEAR_MEMORY_PAGE_SIZE};
+pub use self::memory::{MemoryInstance, MemoryRef, LINEAR_MEMORY_PAGE_SIZE};
 pub use self::module::{ExternVal, ModuleInstance, ModuleRef, NotStartedModuleRef};
 pub use self::runner::{StackRecycler, DEFAULT_CALL_STACK_LIMIT, DEFAULT_VALUE_STACK_LIMIT};
 pub use self::table::{TableInstance, TableRef};

src/memory/mmap_bytebuf.rs

@@ -7,7 +7,6 @@
 
 use std::ptr::{self, NonNull};
 use std::slice;
-use super::{MemoryBackend, ByteBuf};
 
 struct Mmap {
     /// The pointer that points to the start of the mapping.
@@ -112,15 +111,11 @@ impl Drop for Mmap {
     }
 }
 
-pub struct MmapByteBuf {
+pub struct ByteBuf {
     mmap: Option<Mmap>,
 }
 
-impl MmapByteBuf {
-    pub fn empty() -> Self {
-        MmapByteBuf { mmap: None }
-    }
-
+impl ByteBuf {
     pub fn new(len: usize) -> Result<Self, &'static str> {
         let mmap = if len == 0 {
             None
@@ -129,14 +124,8 @@ impl MmapByteBuf {
         };
         Ok(Self { mmap })
     }
-}
 
-impl MemoryBackend for MmapByteBuf {
-    fn alloc(&mut self, initial: usize, _maximum: Option<usize>) -> Result<ByteBuf, &'static str> {
-        self.realloc(initial)
-    }
-
-    fn realloc(&mut self, new_len: usize) -> Result<ByteBuf, &'static str> {
+    pub fn realloc(&mut self, new_len: usize) -> Result<(), &'static str> {
         let new_mmap = if new_len == 0 {
             None
         } else {
@@ -150,16 +139,27 @@ impl MemoryBackend for MmapByteBuf {
             Some(new_mmap)
         };
 
-        let bytebuf = ByteBuf {
-            ptr: new_mmap.as_ref().map(|m| m.ptr.as_ptr()).unwrap_or(NonNull::dangling().as_ptr()),
-            len: new_mmap.as_ref().map(|m| m.len).unwrap_or(0),
-        };
         self.mmap = new_mmap;
-        Ok(bytebuf)
+        Ok(())
     }
 
-    fn erase(&mut self) -> Result<(), &'static str> {
-        let len = self.mmap.as_ref().map(|m| m.len).unwrap_or(0);
+    pub fn len(&self) -> usize {
+        self.mmap.as_ref().map(|m| m.len).unwrap_or(0)
+    }
+
+    pub fn as_slice(&self) -> &[u8] {
+        self.mmap.as_ref().map(|m| m.as_slice()).unwrap_or(&[])
+    }
+
+    pub fn as_slice_mut(&mut self) -> &mut [u8] {
+        self.mmap
+            .as_mut()
+            .map(|m| m.as_slice_mut())
+            .unwrap_or(&mut [])
+    }
+
+    pub fn erase(&mut self) -> Result<(), &'static str> {
+        let len = self.len();
         if len > 0 {
             // The order is important.
             //
@@ -176,14 +176,14 @@ impl MemoryBackend for MmapByteBuf {
 
 #[cfg(test)]
 mod tests {
-    use super::{MmapByteBuf, MemoryBackend};
+    use super::ByteBuf;
 
     const PAGE_SIZE: usize = 4096;
 
     // This is not required since wasm memories can only grow but nice to have.
     #[test]
     fn byte_buf_shrink() {
-        let mut byte_buf = MmapByteBuf::new(PAGE_SIZE * 3).unwrap();
+        let mut byte_buf = ByteBuf::new(PAGE_SIZE * 3).unwrap();
         byte_buf.realloc(PAGE_SIZE * 2).unwrap();
     }
 }

src/memory/mod.rs

@@ -3,7 +3,6 @@ use core::{
     cell::{Cell, RefCell},
     cmp, fmt,
     ops::Range,
-    slice,
     u32,
 };
 use memory_units::{Bytes, Pages, RoundUpTo};
@@ -12,14 +11,14 @@ use value::LittleEndianConvert;
 use Error;
 
 #[cfg(all(unix, not(feature = "vec_memory")))]
-#[path="mmap_bytebuf.rs"]
-mod mmap_bytebuf;
+#[path = "mmap_bytebuf.rs"]
+mod bytebuf;
 
-#[cfg(all(unix, not(feature = "vec_memory")))]
-use self::mmap_bytebuf::MmapByteBuf;
+#[cfg(any(not(unix), feature = "vec_memory"))]
+#[path = "vec_bytebuf.rs"]
+mod bytebuf;
 
-// #[cfg(any(not(unix), feature = "vec_memory"))]
-// mod bytebuf;
+use self::bytebuf::ByteBuf;
 
 /// Size of a page of [linear memory][`MemoryInstance`] - 64KiB.
 ///
@@ -44,35 +43,6 @@ impl ::core::ops::Deref for MemoryRef {
     }
 }
 
-pub struct ByteBuf {
-    pub ptr: *mut u8,
-    pub len: usize,
-}
-
-impl ByteBuf {
-    pub fn as_slice(&self) -> &[u8] {
-        unsafe {
-            slice::from_raw_parts(self.ptr, self.len)
-        }
-    }
-
-    pub fn as_slice_mut(&mut self) -> &mut [u8] {
-        unsafe {
-            slice::from_raw_parts_mut(self.ptr, self.len)
-        }
-    }
-
-    pub fn len(&self) -> usize {
-        self.len
-    }
-}
-
-pub trait MemoryBackend {
-    fn alloc(&mut self, initial: usize, maximum: Option<usize>) -> Result<ByteBuf, &'static str>;
-    fn realloc(&mut self, new_len: usize) -> Result<ByteBuf, &'static str>;
-    fn erase(&mut self) -> Result<(), &'static str>;
-}
-
 /// Runtime representation of a linear memory (or `memory` for short).
 ///
 /// A memory is a contiguous, mutable array of raw bytes. Wasm code can load and store values
@@ -90,8 +60,7 @@ pub struct MemoryInstance {
     /// Memory limits.
     limits: ResizableLimits,
     /// Linear memory buffer with lazy allocation.
-    backend: RefCell<Box<dyn MemoryBackend>>,
-    bytebuf: RefCell<ByteBuf>,
+    buffer: RefCell<ByteBuf>,
     initial: Pages,
     current_size: Cell<usize>,
     maximum: Option<Pages>,
@@ -101,7 +70,7 @@ impl fmt::Debug for MemoryInstance {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.debug_struct("MemoryInstance")
             .field("limits", &self.limits)
-            .field("buffer.len", &self.bytebuf.borrow().len())
+            .field("buffer.len", &self.buffer.borrow().len())
             .field("maximum", &self.maximum)
             .field("initial", &self.initial)
             .finish()
@@ -173,35 +142,17 @@ impl MemoryInstance {
         let limits = ResizableLimits::new(initial.0 as u32, maximum.map(|p| p.0 as u32));
 
         let initial_size: Bytes = initial.into();
-        let maximum_size: Option<Bytes> = maximum.map(|m| m.into());
-        let mut backend = MmapByteBuf::new(initial_size.0).map_err(|err| Error::Memory(err.to_string()))?;
-        let bytebuf = backend.alloc(
-            initial_size.0,
-            maximum_size.map(|m| m.0),
-        ).map_err(|err| Error::Memory(err.to_string()))?;
-
         Ok(MemoryInstance {
             limits: limits,
-            backend: RefCell::new(Box::new(backend)),
-            bytebuf: RefCell::new(bytebuf),
+            buffer: RefCell::new(
+                ByteBuf::new(initial_size.0).map_err(|err| Error::Memory(err.to_string()))?,
+            ),
             initial: initial,
             current_size: Cell::new(initial_size.0),
             maximum: maximum,
         })
     }
 
-    pub fn set_backend(&self, mut backend: Box<dyn MemoryBackend>) {
-        let initial_size: Bytes = self.initial.into();
-        let maximum_size: Option<Bytes> = self.maximum.map(|m| m.into());
-
-        let bytebuf = backend.alloc(
-            initial_size.0,
-            maximum_size.map(|m| m.0),
-        ).unwrap();
-        *self.backend.borrow_mut() = backend;
-        *self.bytebuf.borrow_mut() = bytebuf;
-    }
-
     /// Return linear memory limits.
     pub(crate) fn limits(&self) -> &ResizableLimits {
         &self.limits
@@ -240,12 +191,12 @@ impl MemoryInstance {
     /// );
     /// ```
     pub fn current_size(&self) -> Pages {
-        Bytes(self.bytebuf.borrow().len()).round_up_to()
+        Bytes(self.buffer.borrow().len()).round_up_to()
     }
 
     /// Get value from memory at given offset.
     pub fn get_value<T: LittleEndianConvert>(&self, offset: u32) -> Result<T, Error> {
-        let mut buffer = self.bytebuf.borrow_mut();
+        let mut buffer = self.buffer.borrow_mut();
         let region =
             self.checked_region(&mut buffer, offset as usize, ::core::mem::size_of::<T>())?;
         Ok(
@@ -261,7 +212,7 @@ impl MemoryInstance {
     ///
     /// [`get_into`]: #method.get_into
     pub fn get(&self, offset: u32, size: usize) -> Result<Vec<u8>, Error> {
-        let mut buffer = self.bytebuf.borrow_mut();
+        let mut buffer = self.buffer.borrow_mut();
         let region = self.checked_region(&mut buffer, offset as usize, size)?;
 
         Ok(buffer.as_slice_mut()[region.range()].to_vec())
@@ -273,7 +224,7 @@ impl MemoryInstance {
     ///
     /// Returns `Err` if the specified region is out of bounds.
     pub fn get_into(&self, offset: u32, target: &mut [u8]) -> Result<(), Error> {
-        let mut buffer = self.bytebuf.borrow_mut();
+        let mut buffer = self.buffer.borrow_mut();
         let region = self.checked_region(&mut buffer, offset as usize, target.len())?;
 
         target.copy_from_slice(&buffer.as_slice_mut()[region.range()]);
@@ -283,7 +234,7 @@ impl MemoryInstance {
 
     /// Copy data in the memory at given offset.
     pub fn set(&self, offset: u32, value: &[u8]) -> Result<(), Error> {
-        let mut buffer = self.bytebuf.borrow_mut();
+        let mut buffer = self.buffer.borrow_mut();
         let range = self
             .checked_region(&mut buffer, offset as usize, value.len())?
             .range();
@@ -295,7 +246,7 @@ impl MemoryInstance {
 
     /// Copy value in the memory at given offset.
     pub fn set_value<T: LittleEndianConvert>(&self, offset: u32, value: T) -> Result<(), Error> {
-        let mut buffer = self.bytebuf.borrow_mut();
+        let mut buffer = self.buffer.borrow_mut();
         let range = self
             .checked_region(&mut buffer, offset as usize, ::core::mem::size_of::<T>())?
             .range();
@@ -333,11 +284,10 @@ impl MemoryInstance {
         }
 
         let new_buffer_length: Bytes = new_size.into();
-        let bytebuf = self.backend
+        self.buffer
             .borrow_mut()
             .realloc(new_buffer_length.0)
             .map_err(|err| Error::Memory(err.to_string()))?;
-        *self.bytebuf.borrow_mut() = bytebuf;
 
         self.current_size.set(new_buffer_length.0);
 
@@ -432,7 +382,7 @@ impl MemoryInstance {
     ///
     /// Returns `Err` if either of specified regions is out of bounds.
     pub fn copy(&self, src_offset: usize, dst_offset: usize, len: usize) -> Result<(), Error> {
-        let mut buffer = self.bytebuf.borrow_mut();
+        let mut buffer = self.buffer.borrow_mut();
 
         let (read_region, write_region) =
             self.checked_region_pair(&mut buffer, src_offset, len, dst_offset, len)?;
@@ -465,7 +415,7 @@ impl MemoryInstance {
         dst_offset: usize,
         len: usize,
     ) -> Result<(), Error> {
-        let mut buffer = self.bytebuf.borrow_mut();
+        let mut buffer = self.buffer.borrow_mut();
 
         let (read_region, write_region) =
             self.checked_region_pair(&mut buffer, src_offset, len, dst_offset, len)?;
@@ -505,8 +455,8 @@ impl MemoryInstance {
 
         // Because memory references point to different memory instances, it is safe to `borrow_mut`
         // both buffers at once (modulo `with_direct_access_mut`).
-        let mut src_buffer = src.bytebuf.borrow_mut();
-        let mut dst_buffer = dst.bytebuf.borrow_mut();
+        let mut src_buffer = src.buffer.borrow_mut();
+        let mut dst_buffer = dst.buffer.borrow_mut();
 
         let src_range = src
             .checked_region(&mut src_buffer, src_offset, len)?
@@ -528,7 +478,7 @@ impl MemoryInstance {
     ///
     /// Returns `Err` if the specified region is out of bounds.
     pub fn clear(&self, offset: usize, new_val: u8, len: usize) -> Result<(), Error> {
-        let mut buffer = self.bytebuf.borrow_mut();
+        let mut buffer = self.buffer.borrow_mut();
 
         let range = self.checked_region(&mut buffer, offset, len)?.range();
 
@@ -551,7 +501,7 @@ impl MemoryInstance {
     ///
     /// Might be useful for some optimization shenanigans.
     pub fn erase(&self) -> Result<(), Error> {
-        self.backend
+        self.buffer
             .borrow_mut()
             .erase()
             .map_err(|err| Error::Memory(err.to_string()))
@@ -567,7 +517,7 @@ impl MemoryInstance {
     /// [`set`]: #method.get
     /// [`clear`]: #method.set
     pub fn with_direct_access<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
-        let buf = self.bytebuf.borrow();
+        let buf = self.buffer.borrow();
         f(buf.as_slice())
     }
 
@@ -581,7 +531,7 @@ impl MemoryInstance {
     /// [`get`]: #method.get
     /// [`set`]: #method.set
     pub fn with_direct_access_mut<R, F: FnOnce(&mut [u8]) -> R>(&self, f: F) -> R {
-        let mut buf = self.bytebuf.borrow_mut();
+        let mut buf = self.buffer.borrow_mut();
         f(buf.as_slice_mut())
     }
 }

src/memory/raw_bytebuf.rs

@@ -1,71 +0,0 @@
-//! An implementation of `ByteBuf` based on a plain `Vec`.
-
-use alloc::vec::Vec;
-use std::{
-    slice,
-    mem,
-};
-use super::MemoryBackend;
-
-pub struct RawByteBuf {
-    ptr: *mut u8,
-    len: usize,
-    cap: usize,
-}
-
-impl RawByteBuf {
-    pub fn from_raw_parts(ptr: *mut u8, len: usize, cap: usize) -> Self {
-        Self {
-            ptr,
-            len,
-            cap,
-        }
-    }
-
-    pub fn new(len: usize) -> Result<Self, &'static str> {
-        let mut v = vec![0u8; len];
-        let cap = len;
-        let ptr = v.as_mut_ptr();
-        mem::forget(v);
-
-        Ok(Self {
-            ptr,
-            len,
-            cap,
-        })
-    }
-}
-
-impl MemoryBackend for RawByteBuf {
-
-    pub fn realloc(&mut self, new_len: usize) -> Result<(), &'static str> {
-        if new_len > self.cap {
-            return Err("exceeds cap");
-        }
-        self.len = new_len;
-        Ok(())
-    }
-
-    pub fn len(&self) -> usize {
-        self.len
-    }
-
-    pub fn as_slice(&self) -> &[u8] {
-        unsafe {
-            slice::from_raw_parts(self.ptr, self.len)
-        }
-    }
-
-    pub fn as_slice_mut(&mut self) -> &mut [u8] {
-        unsafe {
-            slice::from_raw_parts_mut(self.ptr, self.len)
-        }
-    }
-
-    pub fn erase(&mut self) -> Result<(), &'static str> {
-        for v in self.as_slice_mut() {
-            *v = 0;
-        }
-        Ok(())
-    }
-}

src/module.rs

@@ -421,7 +421,11 @@ impl ModuleInstance {
             .map(|es| es.entries())
             .unwrap_or(&[])
         {
-            let offset_val = match eval_init_expr(element_segment.offset(), &module_ref) {
+            let offset = element_segment
+                .offset()
+                .as_ref()
+                .expect("passive segments are rejected due to validation");
+            let offset_val = match eval_init_expr(offset, &module_ref) {
                 RuntimeValue::I32(v) => v as u32,
                 _ => panic!("Due to validation elem segment offset should evaluate to i32"),
             };
@@ -450,7 +454,11 @@ impl ModuleInstance {
         }
 
         for data_segment in module.data_section().map(|ds| ds.entries()).unwrap_or(&[]) {
-            let offset_val = match eval_init_expr(data_segment.offset(), &module_ref) {
+            let offset = data_segment
+                .offset()
+                .as_ref()
+                .expect("passive segments are rejected due to validation");
+            let offset_val = match eval_init_expr(offset, &module_ref) {
                 RuntimeValue::I32(v) => v as u32,
                 _ => panic!("Due to validation data segment offset should evaluate to i32"),
             };

src/nan_preserving_float.rs

@@ -1,5 +1,8 @@
 #![allow(missing_docs)]
 
+#[cfg(not(feature = "std"))]
+use libm::{F32Ext, F64Ext};
+
 use core::cmp::{Ordering, PartialEq, PartialOrd};
 use core::ops::{Add, Div, Mul, Neg, Rem, Sub};
 

src/prepare/compile.rs

@@ -251,13 +251,14 @@ impl Compiler {
                 );
                 self.sink.emit_br_nez(target);
             }
-            BrTable(ref table, default) => {
+            BrTable(ref br_table_data) => {
                 // At this point, the condition value is at the top of the stack.
                 // But at the point of actual jump the condition will already be
                 // popped off.
                 let value_stack_height = context.value_stack.len().saturating_sub(1);
 
-                let targets = table
+                let targets = br_table_data
+                    .table
                     .iter()
                     .map(|depth| {
                         require_target(
@@ -269,7 +270,7 @@ impl Compiler {
                     })
                     .collect::<Result<Vec<_>, _>>();
                 let default_target = require_target(
-                    default,
+                    br_table_data.default,
                     value_stack_height,
                     &context.frame_stack,
                     &self.label_stack,

src/runner.rs

@@ -1289,11 +1289,8 @@ impl FunctionContext {
         debug_assert!(!self.is_initialized);
 
         let num_locals = locals.iter().map(|l| l.count() as usize).sum();
-        for _ in 0..num_locals {
-            value_stack
-                .push(Default::default())
-                .map_err(|_| TrapKind::StackOverflow)?;
-        }
+
+        value_stack.extend(num_locals)?;
 
         self.is_initialized = true;
         Ok(())
@@ -1439,6 +1436,18 @@ impl ValueStack {
         Ok(())
     }
 
+    fn extend(&mut self, len: usize) -> Result<(), TrapKind> {
+        let cells = self
+            .buf
+            .get_mut(self.sp..self.sp + len)
+            .ok_or_else(|| TrapKind::StackOverflow)?;
+        for cell in cells {
+            *cell = Default::default();
+        }
+        self.sp += len;
+        Ok(())
+    }
+
     #[inline]
     fn len(&self) -> usize {
         self.sp

src/tests/host.rs

@@ -285,7 +285,7 @@ fn resume_call_host_func() {
     let export = instance.export_by_name("test").unwrap();
     let func_instance = export.as_func().unwrap();
 
-    let mut invocation = FuncInstance::invoke_resumable(&func_instance, &[]).unwrap();
+    let mut invocation = FuncInstance::invoke_resumable(&func_instance, &[][..]).unwrap();
     let result = invocation.start_execution(&mut env);
     match result {
         Err(ResumableError::Trap(_)) => {}
@@ -330,7 +330,7 @@ fn resume_call_host_func_type_mismatch() {
         let export = instance.export_by_name("test").unwrap();
         let func_instance = export.as_func().unwrap();
 
-        let mut invocation = FuncInstance::invoke_resumable(&func_instance, &[]).unwrap();
+        let mut invocation = FuncInstance::invoke_resumable(&func_instance, &[][..]).unwrap();
         let result = invocation.start_execution(&mut env);
         match result {
             Err(ResumableError::Trap(_)) => {}

src/value.rs

@@ -368,6 +368,7 @@ impl WrapInto<F32> for F64 {
 macro_rules! impl_try_truncate_into {
     (@primitive $from: ident, $into: ident, $to_primitive:path) => {
         impl TryTruncateInto<$into, TrapKind> for $from {
+            #[cfg(feature = "std")]
             fn try_truncate_into(self) -> Result<$into, TrapKind> {
                 // Casting from a float to an integer will round the float towards zero
                 num_rational::BigRational::from_float(self)
@@ -375,6 +376,23 @@ macro_rules! impl_try_truncate_into {
                     .and_then(|val| $to_primitive(&val))
                     .ok_or(TrapKind::InvalidConversionToInt)
             }
+            #[cfg(not(feature = "std"))]
+            fn try_truncate_into(self) -> Result<$into, TrapKind> {
+                // Casting from a float to an integer will round the float towards zero
+                // NOTE: currently this will cause Undefined Behavior if the rounded value cannot be represented by the
+                // target integer type. This includes Inf and NaN. This is a bug and will be fixed.
+                if self.is_nan() || self.is_infinite() {
+                    return Err(TrapKind::InvalidConversionToInt);
+                }
+
+                // range check
+                let result = self as $into;
+                if result as $from != self.trunc() {
+                    return Err(TrapKind::InvalidConversionToInt);
+                }
+
+                Ok(self as $into)
+            }
         }
     };
     (@wrapped $from:ident, $intermediate:ident, $into:ident) => {
@@ -819,15 +837,6 @@ impl_integer!(u32);
 impl_integer!(i64);
 impl_integer!(u64);
 
-// Use std float functions in std environment.
-// And libm's implementation in no_std
-#[cfg(feature = "std")]
-macro_rules! call_math {
-    ($op:ident, $e:expr, $fXX:ident, $FXXExt:ident) => {
-        $fXX::$op($e)
-    };
-}
-#[cfg(not(feature = "std"))]
 macro_rules! call_math {
     ($op:ident, $e:expr, $fXX:ident, $FXXExt:ident) => {
         ::libm::$FXXExt::$op($e)

tests/spec/run.rs

@@ -18,6 +18,7 @@ fn spec_to_runtime_value(val: Value<u32, u64>) -> RuntimeValue {
         Value::I64(v) => RuntimeValue::I64(v),
         Value::F32(v) => RuntimeValue::F32(v.into()),
         Value::F64(v) => RuntimeValue::F64(v.into()),
+        Value::V128(_) => panic!("v128 is not supported"),
     }
 }
 

validation/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "wasmi-validation"
-version = "0.1.0"
+version = "0.2.0"
 authors = ["Parity Technologies <admin@parity.io>"]
 edition = "2018"
 license = "MIT/Apache-2.0"
@@ -8,7 +8,7 @@ repository = "https://github.com/paritytech/wasmi"
 description = "Wasm code validator"
 
 [dependencies]
-parity-wasm = { version = "0.31", default-features = false }
+parity-wasm = { version = "0.40.1", default-features = false }
 
 [dev-dependencies]
 assert_matches = "1.1"

validation/src/func.rs

@@ -266,8 +266,8 @@ impl<'a> FunctionValidationContext<'a> {
             BrIf(depth) => {
                 self.validate_br_if(depth)?;
             }
-            BrTable(ref table, default) => {
-                self.validate_br_table(table, default)?;
+            BrTable(ref br_table_data) => {
+                self.validate_br_table(&*br_table_data.table, br_table_data.default)?;
                 make_top_frame_polymorphic(&mut self.value_stack, &mut self.frame_stack);
             }
             Return => {

validation/src/lib.rs

@@ -319,7 +319,11 @@ pub fn validate_module<V: Validator>(module: &Module) -> Result<V::Output, Error
     if let Some(data_section) = module.data_section() {
         for data_segment in data_section.entries() {
             context.require_memory(data_segment.index())?;
-            let init_ty = expr_const_type(data_segment.offset(), context.globals())?;
+            let offset = data_segment
+                .offset()
+                .as_ref()
+                .ok_or_else(|| Error("passive memory segments are not supported".into()))?;
+            let init_ty = expr_const_type(&offset, context.globals())?;
             if init_ty != ValueType::I32 {
                 return Err(Error("segment offset should return I32".into()));
             }
@@ -330,8 +334,11 @@ pub fn validate_module<V: Validator>(module: &Module) -> Result<V::Output, Error
     if let Some(element_section) = module.elements_section() {
         for element_segment in element_section.entries() {
             context.require_table(element_segment.index())?;
-
-            let init_ty = expr_const_type(element_segment.offset(), context.globals())?;
+            let offset = element_segment
+                .offset()
+                .as_ref()
+                .ok_or_else(|| Error("passive element segments are not supported".into()))?;
+            let init_ty = expr_const_type(&offset, context.globals())?;
             if init_ty != ValueType::I32 {
                 return Err(Error("segment offset should return I32".into()));
             }