Add support for emitting code with a single return at the end. (#153)

This also enables testing of the wasmtests tests.

This also updates for wabt updating to the official "wat" filename
extension, as opposed to "wast".

lib/wasm/Cargo.toml

@@ -14,3 +14,6 @@ name = "cton_wasm"
 wasmparser = "0.10.0"
 cretonne = { path = "../cretonne" }
 cretonne-frontend = { path = "../frontend" }
+
+[dev-dependencies]
+tempdir = "0.3.5"

lib/wasm/src/code_translator.rs

@@ -329,8 +329,20 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
             }
         }
         Operator::Return => {
-            let return_count = state.control_stack[0].return_values().len();
-            builder.ins().return_(state.peekn(return_count));
+            let (return_count, br_destination) = {
+                let frame = &mut state.control_stack[0];
+                frame.set_reachable();
+                let return_count = frame.return_values().len();
+                (return_count, frame.br_destination())
+            };
+            {
+                let args = state.peekn(return_count);
+                if environ.flags().return_at_end() {
+                    builder.ins().jump(br_destination, args);
+                } else {
+                    builder.ins().return_(args);
+                }
+            }
             state.popn(return_count);
             state.real_unreachable_stack_depth = 1;
         }

lib/wasm/src/func_translator.rs

@@ -237,7 +237,7 @@ mod tests {
         ];
 
         let mut trans = FuncTranslator::new();
-        let mut runtime = DummyRuntime::new();
+        let mut runtime = DummyRuntime::default();
         let mut ctx = Context::new();
 
         ctx.func.name = ir::FunctionName::new("small1");
@@ -271,7 +271,7 @@ mod tests {
         ];
 
         let mut trans = FuncTranslator::new();
-        let mut runtime = DummyRuntime::new();
+        let mut runtime = DummyRuntime::default();
         let mut ctx = Context::new();
 
         ctx.func.name = ir::FunctionName::new("small2");
@@ -314,7 +314,7 @@ mod tests {
         ];
 
         let mut trans = FuncTranslator::new();
-        let mut runtime = DummyRuntime::new();
+        let mut runtime = DummyRuntime::default();
         let mut ctx = Context::new();
 
         ctx.func.name = ir::FunctionName::new("infloop");

lib/wasm/src/runtime/dummy.rs

@@ -4,6 +4,7 @@ use translation_utils::{Global, Memory, Table, GlobalIndex, TableIndex, Signatur
 use cretonne::ir::{self, InstBuilder};
 use cretonne::ir::types::*;
 use cretonne::cursor::FuncCursor;
+use cretonne::settings;
 
 /// This runtime implementation is a "naïve" one, doing essentially nothing and emitting
 /// placeholders when forced to. Don't try to execute code translated with this runtime, it is
@@ -18,23 +19,32 @@ pub struct DummyRuntime {
 
     // Names of imported functions.
     imported_funcs: Vec<ir::FunctionName>,
+
+    // Compilation setting flags.
+    flags: settings::Flags,
 }
 
 impl DummyRuntime {
-    /// Allocates the runtime data structures.
-    pub fn new() -> Self {
+    /// Allocates the runtime data structures with default flags.
+    pub fn default() -> Self {
+        Self::with_flags(settings::Flags::new(&settings::builder()))
+    }
+
+    /// Allocates the runtime data structures with the given flags.
+    pub fn with_flags(flags: settings::Flags) -> Self {
         Self {
             signatures: Vec::new(),
             globals: Vec::new(),
             func_types: Vec::new(),
             imported_funcs: Vec::new(),
+            flags,
         }
     }
 }
 
 impl FuncEnvironment for DummyRuntime {
-    fn native_pointer(&self) -> ir::Type {
-        ir::types::I64
+    fn flags(&self) -> &settings::Flags {
+        &self.flags
     }
 
     fn make_global(&self, func: &mut ir::Function, index: GlobalIndex) -> GlobalValue {

lib/wasm/src/runtime/spec.rs

@@ -2,6 +2,7 @@
 //! trait `WasmRuntime`.
 use cretonne::ir::{self, InstBuilder};
 use cretonne::cursor::FuncCursor;
+use cretonne::settings::Flags;
 use translation_utils::{SignatureIndex, FunctionIndex, TableIndex, GlobalIndex, MemoryIndex,
                         Global, Table, Memory};
 
@@ -26,10 +27,19 @@ pub enum GlobalValue {
 /// IL. The function environment provides information about the WebAssembly module as well as the
 /// runtime environment.
 pub trait FuncEnvironment {
+    /// Get the flags for the current compilation.
+    fn flags(&self) -> &Flags;
+
     /// Get the Cretonne integer type to use for native pointers.
     ///
-    /// This should be `I64` for 64-bit architectures and `I32` for 32-bit architectures.
-    fn native_pointer(&self) -> ir::Type;
+    /// This returns `I64` for 64-bit architectures and `I32` for 32-bit architectures.
+    fn native_pointer(&self) -> ir::Type {
+        if self.flags().is_64bit() {
+            ir::types::I64
+        } else {
+            ir::types::I32
+        }
+    }
 
     /// Set up the necessary preamble definitions in `func` to access the global variable
     /// identified by `index`.
@@ -138,7 +148,7 @@ pub trait FuncEnvironment {
 
 /// An object satisfyng the `WasmRuntime` trait can be passed as argument to the
 /// [`translate_module`](fn.translate_module.html) function. These methods should not be called
-/// by the user, they are only for the `wasm2cretonne` internal use.
+/// by the user, they are only for `cretonne-wasm` internal use.
 pub trait WasmRuntime: FuncEnvironment {
     /// Declares a function signature to the runtime.
     fn declare_signature(&mut self, sig: &ir::Signature);

lib/wasm/tests/testsuite.rs

@@ -1,18 +1,24 @@
 extern crate cton_wasm;
 extern crate cretonne;
+extern crate tempdir;
 
 use cton_wasm::{translate_module, DummyRuntime, WasmRuntime};
 use std::path::PathBuf;
+use std::borrow::Borrow;
 use std::fs::File;
 use std::error::Error;
 use std::io;
+use std::str;
 use std::io::BufReader;
 use std::io::prelude::*;
+use std::process::Command;
 use std::fs;
 use cretonne::ir;
 use cretonne::ir::entities::AnyEntity;
-use cretonne::isa::TargetIsa;
+use cretonne::isa::{self, TargetIsa};
+use cretonne::settings::{self, Configurable};
 use cretonne::verifier;
+use tempdir::TempDir;
 
 #[test]
 fn testsuite() {
@@ -23,13 +29,29 @@ fn testsuite() {
     paths.sort_by_key(|dir| dir.path());
     for path in paths {
         let path = path.path();
-        match handle_module(path) {
-            Ok(()) => (),
-            Err(message) => println!("{}", message),
-        };
+        handle_module(path, None);
     }
 }
 
+#[test]
+fn return_at_end() {
+    let mut flag_builder = settings::builder();
+    flag_builder.enable("return_at_end").unwrap();
+    let flags = settings::Flags::new(&flag_builder);
+    // We don't care about the target itself here, so just pick one arbitrarily.
+    let isa = match isa::lookup("riscv") {
+        Err(_) => {
+            println!("riscv target not found; disabled test return_at_end.wat");
+            return;
+        }
+        Ok(isa_builder) => isa_builder.finish(flags),
+    };
+    handle_module(
+        PathBuf::from("../../wasmtests/return_at_end.wat"),
+        Some(isa.borrow()),
+    );
+}
+
 fn read_wasm_file(path: PathBuf) -> Result<Vec<u8>, io::Error> {
     let mut buf: Vec<u8> = Vec::new();
     let file = File::open(path)?;
@@ -38,44 +60,80 @@ fn read_wasm_file(path: PathBuf) -> Result<Vec<u8>, io::Error> {
     Ok(buf)
 }
 
-fn handle_module(path: PathBuf) -> Result<(), String> {
+fn handle_module(path: PathBuf, isa: Option<&TargetIsa>) {
     let data = match path.extension() {
         None => {
-            return Err(String::from("the file extension is not wasm or wast"));
+            panic!("the file extension is not wasm or wat");
         }
         Some(ext) => {
             match ext.to_str() {
                 Some("wasm") => {
                     match read_wasm_file(path.clone()) {
+                        Ok(data) => data,
+                        Err(err) => panic!("error reading wasm file: {}", err.description()),
+                    }
+                }
+                Some("wat") => {
+                    let tmp_dir = TempDir::new("cretonne-wasm").unwrap();
+                    let file_path = tmp_dir.path().join("module.wasm");
+                    File::create(file_path.clone()).unwrap();
+                    let result_output = Command::new("wat2wasm")
+                        .arg(path.clone())
+                        .arg("-o")
+                        .arg(file_path.to_str().unwrap())
+                        .output();
+                    match result_output {
+                        Err(e) => {
+                            if e.kind() == io::ErrorKind::NotFound {
+                                println!(
+                                    "wat2wasm not found; disabled test {}",
+                                    path.to_str().unwrap()
+                                );
+                                return;
+                            }
+                            panic!("error convering wat file: {}", e.description());
+                        }
+                        Ok(output) => {
+                            if !output.status.success() {
+                                panic!(
+                                    "error running wat2wasm: {}",
+                                    str::from_utf8(&output.stderr).expect(
+                                        "wat2wasm's error message should be valid UTF-8",
+                                    )
+                                );
+                            }
+                        }
+                    }
+                    match read_wasm_file(file_path) {
                         Ok(data) => data,
                         Err(err) => {
-                            return Err(String::from(err.description()));
+                            panic!("error reading converted wasm file: {}", err.description());
                         }
                     }
                 }
-                None | Some(&_) => {
-                    return Err(String::from("the file extension is not wasm or wast"));
-                }
+                None | Some(&_) => panic!("the file extension is not wasm or wat"),
             }
         }
     };
-    let mut dummy_runtime = DummyRuntime::new();
+    let mut dummy_runtime = match isa {
+        Some(isa) => DummyRuntime::with_flags(isa.flags().clone()),
+        None => DummyRuntime::default(),
+    };
     let translation = {
         let runtime: &mut WasmRuntime = &mut dummy_runtime;
         match translate_module(&data, runtime) {
             Ok(x) => x,
             Err(string) => {
-                return Err(string);
+                panic!(string);
             }
         }
     };
     for func in &translation.functions {
-        match verifier::verify_function(func, None) {
+        match verifier::verify_function(func, isa) {
             Ok(()) => (),
-            Err(err) => return Err(pretty_verifier_error(func, None, err)),
+            Err(err) => panic!(pretty_verifier_error(func, isa, err)),
         }
     }
-    Ok(())
 }