Merge branch 'master' into instr_validation

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "parity-wasm"
-version = "0.8.3"
+version = "0.8.4"
 authors = ["NikVolf <nikvolf@gmail.com>"]
 license = "MIT/Apache-2.0"
 readme = "README.md"

spec/src/fixtures.rs

@@ -1,4 +1,10 @@
 macro_rules! run_test {
+    ($label: expr, $test_name: ident, fail) => (
+        #[test]
+        fn $test_name() {
+            ::run::failing_spec($label)
+        }
+    );
     ($label: expr, $test_name: ident) => (
         #[test]
         fn $test_name() {
@@ -8,6 +14,8 @@ macro_rules! run_test {
 }
 
 run_test!("address", wasm_address);
+run_test!("address-offset-range.fail", wasm_address_offset_range_fail, fail);
+run_test!("binary", wasm_binary);
 run_test!("endianness", wasm_endianness);
 run_test!("f32", wasm_f32);
 run_test!("f32_bitwise", wasm_f32_bitwise);

spec/src/run.rs

@@ -83,7 +83,12 @@ fn run_action(module: &ModuleInstance, action: &test::Action)
     }
 }
 
-pub fn spec(name: &str) {
+pub struct FixtureParams {
+    failing: bool,
+    json: String,
+}
+
+pub fn run_wast2wasm(name: &str) -> FixtureParams {
     let outdir = env::var("OUT_DIR").unwrap();
 
     let mut wast2wasm_path = PathBuf::from(outdir.clone());
@@ -101,15 +106,38 @@ pub fn spec(name: &str) {
         .output()
         .expect("Failed to execute process");
 
-    if !wast2wasm_output.status.success() {
+    FixtureParams {
-        println!("wasm2wast error code: {}", wast2wasm_output.status);
+        json: json_spec_path.to_str().unwrap().to_owned(),
-        println!("wasm2wast stdout: {}", String::from_utf8_lossy(&wast2wasm_output.stdout));
+        failing: {
-        println!("wasm2wast stderr: {}", String::from_utf8_lossy(&wast2wasm_output.stderr));
+            if !wast2wasm_output.status.success() {
-        panic!("wasm2wast exited with status {}", wast2wasm_output.status);
+                println!("wasm2wast error code: {}", wast2wasm_output.status);
+                println!("wasm2wast stdout: {}", String::from_utf8_lossy(&wast2wasm_output.stdout));
+                println!("wasm2wast stderr: {}", String::from_utf8_lossy(&wast2wasm_output.stderr));
+                true
+            } else {
+                false
+            }     
+        }
+    }
+}
+
+pub fn failing_spec(name: &str) {
+    let fixture = run_wast2wasm(name);
+    if !fixture.failing {
+         panic!("wasm2wast expected to fail, but terminated normally");
+    }
+}
+
+pub fn spec(name: &str) {
+    let outdir = env::var("OUT_DIR").unwrap();
+
+    let fixture = run_wast2wasm(name);
+    if fixture.failing {
+         panic!("wasm2wast terminated abnormally, expected to success");        
     }
 
-    let mut f = File::open(&json_spec_path)
+    let mut f = File::open(&fixture.json)
-        .expect(&format!("Failed to load json file {}", &json_spec_path.to_string_lossy()));
+        .expect(&format!("Failed to load json file {}", &fixture.json));
     let spec: test::Spec = serde_json::from_reader(&mut f).expect("Failed to deserialize JSON file");
 
     let first_command = &spec.commands[0];
@@ -186,7 +214,9 @@ pub fn spec(name: &str) {
                     }
                 }
             },
-            &test::Command::AssertInvalid { line, ref filename, .. } => {
+            &test::Command::AssertInvalid { line, ref filename, .. }
+            | &test::Command::AssertMalformed { line, ref filename, .. }
+                => {
                 let module_load = try_load(&outdir, filename);
                 match module_load {
                     Ok(_) => {

spec/src/test.rs

@@ -47,6 +47,12 @@ pub enum Command {
         filename: String,
         text: String,
     },
+    #[serde(rename = "assert_malformed")]
+    AssertMalformed {
+        line: u64,
+        filename: String,
+        text: String,
+    },
     #[serde(rename = "action")]
     Action {
         line: u64,

spec/wabt

@@ -1 +1 @@
-Subproject commit 7425bcc31e6516375391d18a62daee4c9f3502de
+Subproject commit 1e5b546c65e8fef609431e77b1b2434dbf162e6c

src/elements/mod.rs

@@ -52,6 +52,10 @@ pub trait Serialize {
 pub enum Error {
     /// Unexpected end of input
     UnexpectedEof,
+    /// Invalid magic
+    InvalidMagic,
+    /// Unsupported version
+    UnsupportedVersion(u32),
     /// Inconsistence between declared and actual length
     InconsistentLength { 
         /// Expected length of the definition

src/elements/module.rs

@@ -1,10 +1,14 @@
 use std::io;
+use byteorder::{LittleEndian, ByteOrder};
+
 use super::{Deserialize, Serialize, Error, Uint32};
 use super::section::{
     Section, CodeSection, TypeSection, ImportSection, ExportSection, FunctionSection,
     GlobalSection, TableSection, ElementSection, DataSection, MemorySection
 };
 
+const WASM_MAGIC_NUMBER: [u8; 4] = [0x00, 0x61, 0x73, 0x6d];
+
 /// WebAssembly module
 pub struct Module {
     magic: u32,
@@ -144,8 +148,18 @@ impl Deserialize for Module {
 
     fn deserialize<R: io::Read>(reader: &mut R) -> Result<Self, Self::Error> {
         let mut sections = Vec::new();
-        let magic = Uint32::deserialize(reader)?;
+
-        let version = Uint32::deserialize(reader)?;
+        let mut magic = [0u8; 4];
+        reader.read(&mut magic)?;
+        if magic != WASM_MAGIC_NUMBER {
+            return Err(Error::InvalidMagic);
+        }
+
+        let version: u32 = Uint32::deserialize(reader)?.into();
+
+        if version != 1 {
+            return Err(Error::UnsupportedVersion(version));
+        }
 
         loop {
             match Section::deserialize(reader) {
@@ -156,8 +170,8 @@ impl Deserialize for Module {
         }
 
         Ok(Module { 
-            magic: magic.into(),
+            magic: LittleEndian::read_u32(&magic),
-            version: version.into(),
+            version: version,
             sections: sections,
         })
     }