Move the wasmtime crate directories form lib/* to wasmtime-*.

This follows a similar change to Cranelift made here:

https://github.com/CraneStation/cranelift/pull/660

wasmtime-wast/src/lib.rs

@@ -0,0 +1,35 @@
+//! JIT-style runtime for WebAssembly using Cranelift.
+
+#![deny(missing_docs, trivial_numeric_casts, unused_extern_crates)]
+#![warn(unused_import_braces)]
+#![deny(unstable_features)]
+#![cfg_attr(feature = "clippy", plugin(clippy(conf_file = "../../clippy.toml")))]
+#![cfg_attr(
+    feature = "cargo-clippy",
+    allow(clippy::new_without_default, clippy::new_without_default_derive)
+)]
+#![cfg_attr(
+    feature = "cargo-clippy",
+    warn(
+        clippy::float_arithmetic,
+        clippy::mut_mut,
+        clippy::nonminimal_bool,
+        clippy::option_map_unwrap_or,
+        clippy::option_map_unwrap_or_else,
+        clippy::print_stdout,
+        clippy::unicode_not_nfc,
+        clippy::use_self
+    )
+)]
+
+#[macro_use]
+extern crate failure_derive;
+
+mod spectest;
+mod wast;
+
+pub use crate::spectest::instantiate_spectest;
+pub use crate::wast::{WastContext, WastError};
+
+/// Version number of this crate.
+pub const VERSION: &str = env!("CARGO_PKG_VERSION");

wasmtime-wast/src/spectest.rs

@@ -0,0 +1,229 @@
+use cranelift_codegen::ir::types;
+use cranelift_codegen::{ir, isa};
+use cranelift_entity::PrimaryMap;
+use cranelift_wasm::{DefinedFuncIndex, Global, GlobalInit, Memory, Table, TableElementType};
+use std::cell::RefCell;
+use std::collections::HashMap;
+use std::rc::Rc;
+use target_lexicon::HOST;
+use wasmtime_environ::{translate_signature, Export, MemoryPlan, Module, TablePlan};
+use wasmtime_jit::target_tunables;
+use wasmtime_runtime::{Imports, InstanceHandle, InstantiationError, VMContext, VMFunctionBody};
+
+extern "C" fn spectest_print() {}
+
+#[allow(clippy::print_stdout)]
+extern "C" fn spectest_print_i32(_vmctx: &mut VMContext, x: i32) {
+    println!("{}: i32", x);
+}
+
+#[allow(clippy::print_stdout)]
+extern "C" fn spectest_print_i64(_vmctx: &mut VMContext, x: i64) {
+    println!("{}: i64", x);
+}
+
+#[allow(clippy::print_stdout)]
+extern "C" fn spectest_print_f32(_vmctx: &mut VMContext, x: f32) {
+    println!("{}: f32", x);
+}
+
+#[allow(clippy::print_stdout)]
+extern "C" fn spectest_print_f64(_vmctx: &mut VMContext, x: f64) {
+    println!("{}: f64", x);
+}
+
+#[allow(clippy::print_stdout)]
+extern "C" fn spectest_print_i32_f32(_vmctx: &mut VMContext, x: i32, y: f32) {
+    println!("{}: i32", x);
+    println!("{}: f32", y);
+}
+
+#[allow(clippy::print_stdout)]
+extern "C" fn spectest_print_f64_f64(_vmctx: &mut VMContext, x: f64, y: f64) {
+    println!("{}: f64", x);
+    println!("{}: f64", y);
+}
+
+/// Return an instance implementing the "spectest" interface used in the
+/// spec testsuite.
+pub fn instantiate_spectest() -> Result<InstanceHandle, InstantiationError> {
+    let call_conv = isa::CallConv::triple_default(&HOST);
+    let pointer_type = types::Type::triple_pointer_type(&HOST);
+    let mut module = Module::new();
+    let mut finished_functions: PrimaryMap<DefinedFuncIndex, *const VMFunctionBody> =
+        PrimaryMap::new();
+
+    let sig = module.signatures.push(translate_signature(
+        ir::Signature {
+            params: vec![],
+            returns: vec![],
+            call_conv,
+        },
+        pointer_type,
+    ));
+    let func = module.functions.push(sig);
+    module
+        .exports
+        .insert("print".to_owned(), Export::Function(func));
+    finished_functions.push(spectest_print as *const VMFunctionBody);
+
+    let sig = module.signatures.push(translate_signature(
+        ir::Signature {
+            params: vec![ir::AbiParam::new(types::I32)],
+            returns: vec![],
+            call_conv,
+        },
+        pointer_type,
+    ));
+    let func = module.functions.push(sig);
+    module
+        .exports
+        .insert("print_i32".to_owned(), Export::Function(func));
+    finished_functions.push(spectest_print_i32 as *const VMFunctionBody);
+
+    let sig = module.signatures.push(translate_signature(
+        ir::Signature {
+            params: vec![ir::AbiParam::new(types::I64)],
+            returns: vec![],
+            call_conv,
+        },
+        pointer_type,
+    ));
+    let func = module.functions.push(sig);
+    module
+        .exports
+        .insert("print_i64".to_owned(), Export::Function(func));
+    finished_functions.push(spectest_print_i64 as *const VMFunctionBody);
+
+    let sig = module.signatures.push(translate_signature(
+        ir::Signature {
+            params: vec![ir::AbiParam::new(types::F32)],
+            returns: vec![],
+            call_conv,
+        },
+        pointer_type,
+    ));
+    let func = module.functions.push(sig);
+    module
+        .exports
+        .insert("print_f32".to_owned(), Export::Function(func));
+    finished_functions.push(spectest_print_f32 as *const VMFunctionBody);
+
+    let sig = module.signatures.push(translate_signature(
+        ir::Signature {
+            params: vec![ir::AbiParam::new(types::F64)],
+            returns: vec![],
+            call_conv,
+        },
+        pointer_type,
+    ));
+    let func = module.functions.push(sig);
+    module
+        .exports
+        .insert("print_f64".to_owned(), Export::Function(func));
+    finished_functions.push(spectest_print_f64 as *const VMFunctionBody);
+
+    let sig = module.signatures.push(translate_signature(
+        ir::Signature {
+            params: vec![ir::AbiParam::new(types::I32), ir::AbiParam::new(types::F32)],
+            returns: vec![],
+            call_conv,
+        },
+        pointer_type,
+    ));
+    let func = module.functions.push(sig);
+    module
+        .exports
+        .insert("print_i32_f32".to_owned(), Export::Function(func));
+    finished_functions.push(spectest_print_i32_f32 as *const VMFunctionBody);
+
+    let sig = module.signatures.push(translate_signature(
+        ir::Signature {
+            params: vec![ir::AbiParam::new(types::F64), ir::AbiParam::new(types::F64)],
+            returns: vec![],
+            call_conv,
+        },
+        pointer_type,
+    ));
+    let func = module.functions.push(sig);
+    module
+        .exports
+        .insert("print_f64_f64".to_owned(), Export::Function(func));
+    finished_functions.push(spectest_print_f64_f64 as *const VMFunctionBody);
+
+    let global = module.globals.push(Global {
+        ty: types::I32,
+        mutability: false,
+        initializer: GlobalInit::I32Const(666),
+    });
+    module
+        .exports
+        .insert("global_i32".to_owned(), Export::Global(global));
+
+    let global = module.globals.push(Global {
+        ty: types::I64,
+        mutability: false,
+        initializer: GlobalInit::I64Const(666),
+    });
+    module
+        .exports
+        .insert("global_i64".to_owned(), Export::Global(global));
+
+    let global = module.globals.push(Global {
+        ty: types::F32,
+        mutability: false,
+        initializer: GlobalInit::F32Const(0x44268000),
+    });
+    module
+        .exports
+        .insert("global_f32".to_owned(), Export::Global(global));
+
+    let global = module.globals.push(Global {
+        ty: types::F64,
+        mutability: false,
+        initializer: GlobalInit::F64Const(0x4084d00000000000),
+    });
+    module
+        .exports
+        .insert("global_f64".to_owned(), Export::Global(global));
+
+    let tunables = target_tunables(&HOST);
+    let table = module.table_plans.push(TablePlan::for_table(
+        Table {
+            ty: TableElementType::Func,
+            minimum: 10,
+            maximum: Some(20),
+        },
+        &tunables,
+    ));
+    module
+        .exports
+        .insert("table".to_owned(), Export::Table(table));
+
+    let memory = module.memory_plans.push(MemoryPlan::for_memory(
+        Memory {
+            minimum: 1,
+            maximum: Some(2),
+            shared: false,
+        },
+        &tunables,
+    ));
+    module
+        .exports
+        .insert("memory".to_owned(), Export::Memory(memory));
+
+    let imports = Imports::none();
+    let data_initializers = Vec::new();
+    let signatures = PrimaryMap::new();
+
+    InstanceHandle::new(
+        Rc::new(module),
+        Rc::new(RefCell::new(HashMap::new())),
+        finished_functions.into_boxed_slice(),
+        imports,
+        &data_initializers,
+        signatures.into_boxed_slice(),
+        None,
+        Box::new(()),
+    )
+}

wasmtime-wast/src/wast.rs

@@ -0,0 +1,481 @@
+use crate::spectest::instantiate_spectest;
+use std::io::Read;
+use std::path::Path;
+use std::{fmt, fs, io, str};
+use wabt::script::{Action, Command, CommandKind, ModuleBinary, ScriptParser, Value};
+use wasmtime_jit::{
+    ActionError, ActionOutcome, Compiler, Context, InstanceHandle, InstantiationError,
+    RuntimeValue, UnknownInstance,
+};
+
+/// Translate from a `script::Value` to a `RuntimeValue`.
+fn runtime_value(v: Value) -> RuntimeValue {
+    match v {
+        Value::I32(x) => RuntimeValue::I32(x),
+        Value::I64(x) => RuntimeValue::I64(x),
+        Value::F32(x) => RuntimeValue::F32(x.to_bits()),
+        Value::F64(x) => RuntimeValue::F64(x.to_bits()),
+    }
+}
+
+/// Error message used by `WastContext`.
+#[derive(Fail, Debug)]
+pub enum WastError {
+    /// An assert command was not satisfied.
+    Assert(String),
+    /// An unknown instance name was used.
+    Instance(UnknownInstance),
+    /// No default instance has been registered yet.
+    NoDefaultInstance,
+    /// An error occured while performing an action.
+    Action(ActionError),
+    /// An action trapped.
+    Trap(String),
+    /// There was a type error in inputs or outputs of an action.
+    Type(String),
+    /// The was a syntax error while parsing the wast script.
+    Syntax(wabt::script::Error),
+    /// The was a character encoding error while parsing the wast script.
+    Utf8(str::Utf8Error),
+    /// The was an I/O error while reading the wast file.
+    IO(io::Error),
+}
+
+impl fmt::Display for WastError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {
+            WastError::Assert(ref message) => write!(f, "Assert command failed: {}", message),
+            WastError::Instance(ref error) => error.fmt(f),
+            WastError::NoDefaultInstance => write!(f, "no default instance defined yet"),
+            WastError::Action(ref error) => error.fmt(f),
+            WastError::Trap(ref message) => write!(f, "trap: {}", message),
+            WastError::Type(ref message) => write!(f, "type error: {}", message),
+            WastError::Syntax(ref message) => write!(f, "syntax error: {}", message),
+            WastError::Utf8(ref message) => write!(f, "UTF-8 decoding error: {}", message),
+            WastError::IO(ref error) => write!(f, "I/O error: {}", error),
+        }
+    }
+}
+
+/// Error message with a source file and line number.
+#[derive(Fail, Debug)]
+#[fail(display = "{}:{}: {}", filename, line, error)]
+pub struct WastFileError {
+    filename: String,
+    line: u64,
+    error: WastError,
+}
+
+/// The wast test script language allows modules to be defined and actions
+/// to be performed on them.
+pub struct WastContext {
+    /// Wast files have a concept of a "current" module, which is the most
+    /// recently defined.
+    current: Option<InstanceHandle>,
+
+    context: Context,
+}
+
+impl WastContext {
+    /// Construct a new instance of `WastContext`.
+    pub fn new(compiler: Box<Compiler>) -> Self {
+        Self {
+            current: None,
+            context: Context::new(compiler),
+        }
+    }
+
+    fn get_instance(
+        &mut self,
+        instance_name: Option<&str>,
+    ) -> Result<&mut InstanceHandle, WastError> {
+        let instance = if let Some(instance_name) = instance_name {
+            self.context
+                .get_instance(instance_name)
+                .map_err(WastError::Instance)
+        } else {
+            self.current
+                .as_mut()
+                .ok_or_else(|| WastError::NoDefaultInstance)
+        }?;
+
+        Ok(instance)
+    }
+
+    /// Register "spectest" which is used by the spec testsuite.
+    pub fn register_spectest(&mut self) -> Result<(), InstantiationError> {
+        let instance = instantiate_spectest()?;
+        self.context.name_instance("spectest".to_owned(), instance);
+        Ok(())
+    }
+
+    /// Perform the action portion of a command.
+    fn perform_action(&mut self, action: Action) -> Result<ActionOutcome, WastError> {
+        match action {
+            Action::Invoke {
+                module: instance_name,
+                field,
+                args,
+            } => self.invoke(instance_name, &field, &args),
+            Action::Get {
+                module: instance_name,
+                field,
+            } => self.get(instance_name, &field),
+        }
+    }
+
+    /// Define a module and register it.
+    fn module(
+        &mut self,
+        instance_name: Option<String>,
+        module: ModuleBinary,
+    ) -> Result<(), ActionError> {
+        let index = self
+            .context
+            .instantiate_module(instance_name, &module.into_vec())?;
+        self.current = Some(index);
+        Ok(())
+    }
+
+    /// Register an instance to make it available for performing actions.
+    fn register(&mut self, name: Option<String>, as_name: String) -> Result<(), WastError> {
+        let instance = self.get_instance(name.as_ref().map(|x| &**x))?.clone();
+        self.context.name_instance(as_name, instance);
+        Ok(())
+    }
+
+    /// Invoke an exported function from an instance.
+    fn invoke(
+        &mut self,
+        instance_name: Option<String>,
+        field: &str,
+        args: &[Value],
+    ) -> Result<ActionOutcome, WastError> {
+        let value_args = args
+            .iter()
+            .map(|arg| runtime_value(*arg))
+            .collect::<Vec<_>>();
+        let mut instance = self
+            .get_instance(instance_name.as_ref().map(|x| &**x))?
+            .clone();
+        self.context
+            .invoke(&mut instance, field, &value_args)
+            .map_err(WastError::Action)
+    }
+
+    /// Get the value of an exported global from an instance.
+    fn get(
+        &mut self,
+        instance_name: Option<String>,
+        field: &str,
+    ) -> Result<ActionOutcome, WastError> {
+        let instance = self
+            .get_instance(instance_name.as_ref().map(|x| &**x))?
+            .clone();
+        self.context
+            .get(&instance, field)
+            .map_err(WastError::Action)
+    }
+
+    /// Perform the action of a `PerformAction`.
+    fn perform_action_command(&mut self, action: Action) -> Result<(), WastError> {
+        match self.perform_action(action)? {
+            ActionOutcome::Returned { .. } => Ok(()),
+            ActionOutcome::Trapped { message } => Err(WastError::Trap(message)),
+        }
+    }
+
+    /// Run a wast script from a byte buffer.
+    pub fn run_buffer(&mut self, filename: &str, wast: &[u8]) -> Result<(), WastFileError> {
+        let mut parser =
+            ScriptParser::from_str(str::from_utf8(wast).map_err(|error| WastFileError {
+                filename: filename.to_string(),
+                line: 0,
+                error: WastError::Utf8(error),
+            })?)
+            .map_err(|error| WastFileError {
+                filename: filename.to_string(),
+                line: 0,
+                error: WastError::Syntax(error),
+            })?;
+
+        while let Some(Command { kind, line }) = parser.next().expect("parser") {
+            match kind {
+                CommandKind::Module {
+                    module: instance_name,
+                    name,
+                } => {
+                    self.module(name, instance_name)
+                        .map_err(|error| WastFileError {
+                            filename: filename.to_string(),
+                            line,
+                            error: WastError::Action(error),
+                        })?;
+                }
+                CommandKind::Register { name, as_name } => {
+                    self.register(name, as_name)
+                        .map_err(|error| WastFileError {
+                            filename: filename.to_string(),
+                            line,
+                            error,
+                        })?;
+                }
+                CommandKind::PerformAction(action) => {
+                    self.perform_action_command(action)
+                        .map_err(|error| WastFileError {
+                            filename: filename.to_string(),
+                            line,
+                            error,
+                        })?;
+                }
+                CommandKind::AssertReturn { action, expected } => {
+                    match self.perform_action(action).map_err(|error| WastFileError {
+                        filename: filename.to_string(),
+                        line,
+                        error,
+                    })? {
+                        ActionOutcome::Returned { values } => {
+                            for (v, e) in values
+                                .iter()
+                                .cloned()
+                                .zip(expected.iter().cloned().map(runtime_value))
+                            {
+                                if v != e {
+                                    return Err(WastFileError {
+                                        filename: filename.to_string(),
+                                        line,
+                                        error: WastError::Assert(format!(
+                                            "expected {}, got {}",
+                                            e, v
+                                        )),
+                                    });
+                                }
+                            }
+                        }
+                        ActionOutcome::Trapped { message } => {
+                            return Err(WastFileError {
+                                filename: filename.to_string(),
+                                line,
+                                error: WastError::Assert(format!("unexpected trap: {}", message)),
+                            });
+                        }
+                    }
+                }
+                CommandKind::AssertTrap { action, message } => {
+                    match self.perform_action(action).map_err(|error| WastFileError {
+                        filename: filename.to_string(),
+                        line,
+                        error,
+                    })? {
+                        ActionOutcome::Returned { values } => {
+                            return Err(WastFileError {
+                                filename: filename.to_string(),
+                                line,
+                                error: WastError::Assert(format!(
+                                    "expected trap, but invoke returned with {:?}",
+                                    values
+                                )),
+                            });
+                        }
+                        ActionOutcome::Trapped {
+                            message: trap_message,
+                        } => {
+                            println!(
+                                "{}:{}: TODO: Check the assert_trap message: expected {}, got {}",
+                                filename, line, message, trap_message
+                            );
+                        }
+                    }
+                }
+                CommandKind::AssertExhaustion { action } => {
+                    match self.perform_action(action).map_err(|error| WastFileError {
+                        filename: filename.to_string(),
+                        line,
+                        error,
+                    })? {
+                        ActionOutcome::Returned { values } => {
+                            return Err(WastFileError {
+                                filename: filename.to_string(),
+                                line,
+                                error: WastError::Assert(format!(
+                                    "expected callstack exhaustion, but invoke returned with {:?}",
+                                    values
+                                )),
+                            });
+                        }
+                        ActionOutcome::Trapped { message } => {
+                            println!(
+                                "{}:{}: TODO: Check the assert_exhaustion message: {}",
+                                filename, line, message
+                            );
+                        }
+                    }
+                }
+                CommandKind::AssertReturnCanonicalNan { action } => {
+                    match self.perform_action(action).map_err(|error| WastFileError {
+                        filename: filename.to_string(),
+                        line,
+                        error,
+                    })? {
+                        ActionOutcome::Returned { values } => {
+                            for v in values.iter() {
+                                match v {
+                                    RuntimeValue::I32(_) | RuntimeValue::I64(_) => {
+                                        return Err(WastFileError {
+                                            filename: filename.to_string(),
+                                            line,
+                                            error: WastError::Type(format!(
+                                                "unexpected integer type in NaN test"
+                                            )),
+                                        });
+                                    }
+                                    RuntimeValue::F32(x) => {
+                                        if (x & 0x7fffffff) != 0x7fc00000 {
+                                            return Err(WastFileError {
+                                                filename: filename.to_string(),
+                                                line,
+                                                error: WastError::Assert(format!(
+                                                    "expected canonical NaN"
+                                                )),
+                                            });
+                                        }
+                                    }
+                                    RuntimeValue::F64(x) => {
+                                        if (x & 0x7fffffffffffffff) != 0x7ff8000000000000 {
+                                            return Err(WastFileError {
+                                                filename: filename.to_string(),
+                                                line,
+                                                error: WastError::Assert(format!(
+                                                    "expected canonical NaN"
+                                                )),
+                                            });
+                                        }
+                                    }
+                                };
+                            }
+                        }
+                        ActionOutcome::Trapped { message } => {
+                            return Err(WastFileError {
+                                filename: filename.to_string(),
+                                line,
+                                error: WastError::Assert(format!("unexpected trap: {}", message)),
+                            });
+                        }
+                    }
+                }
+                CommandKind::AssertReturnArithmeticNan { action } => {
+                    match self.perform_action(action).map_err(|error| WastFileError {
+                        filename: filename.to_string(),
+                        line,
+                        error,
+                    })? {
+                        ActionOutcome::Returned { values } => {
+                            for v in values.iter() {
+                                match v {
+                                    RuntimeValue::I32(_) | RuntimeValue::I64(_) => {
+                                        return Err(WastFileError {
+                                            filename: filename.to_string(),
+                                            line,
+                                            error: WastError::Type(format!(
+                                                "unexpected integer type in NaN test",
+                                            )),
+                                        });
+                                    }
+                                    RuntimeValue::F32(x) => {
+                                        if (x & 0x00400000) != 0x00400000 {
+                                            return Err(WastFileError {
+                                                filename: filename.to_string(),
+                                                line,
+                                                error: WastError::Assert(format!(
+                                                    "expected arithmetic NaN"
+                                                )),
+                                            });
+                                        }
+                                    }
+                                    RuntimeValue::F64(x) => {
+                                        if (x & 0x0008000000000000) != 0x0008000000000000 {
+                                            return Err(WastFileError {
+                                                filename: filename.to_string(),
+                                                line,
+                                                error: WastError::Assert(format!(
+                                                    "expected arithmetic NaN"
+                                                )),
+                                            });
+                                        }
+                                    }
+                                };
+                            }
+                        }
+                        ActionOutcome::Trapped { message } => {
+                            return Err(WastFileError {
+                                filename: filename.to_string(),
+                                line,
+                                error: WastError::Assert(format!("unexpected trap: {}", message)),
+                            });
+                        }
+                    }
+                }
+                CommandKind::AssertInvalid { module, message } => {
+                    self.module(None, module).expect_err(&format!(
+                        "{}:{}: invalid module was successfully instantiated",
+                        filename, line
+                    ));
+                    println!(
+                        "{}:{}: TODO: Check the assert_invalid message: {}",
+                        filename, line, message
+                    );
+                }
+                CommandKind::AssertMalformed { module, message } => {
+                    self.module(None, module).expect_err(&format!(
+                        "{}:{}: malformed module was successfully instantiated",
+                        filename, line
+                    ));
+                    println!(
+                        "{}:{}: TODO: Check the assert_malformed message: {}",
+                        filename, line, message
+                    );
+                }
+                CommandKind::AssertUninstantiable { module, message } => {
+                    let _err = self.module(None, module).expect_err(&format!(
+                        "{}:{}: uninstantiable module was successfully instantiated",
+                        filename, line
+                    ));
+                    println!(
+                        "{}:{}: TODO: Check the assert_uninstantiable message: {}",
+                        filename, line, message
+                    );
+                }
+                CommandKind::AssertUnlinkable { module, message } => {
+                    let _err = self.module(None, module).expect_err(&format!(
+                        "{}:{}: unlinkable module was successfully linked",
+                        filename, line
+                    ));
+                    println!(
+                        "{}:{}: TODO: Check the assert_unlinkable message: {}",
+                        filename, line, message
+                    );
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Run a wast script from a file.
+    pub fn run_file(&mut self, path: &Path) -> Result<(), WastFileError> {
+        let filename = path.display().to_string();
+        let buffer = read_to_end(path).map_err(|e| WastFileError {
+            filename,
+            line: 0,
+            error: WastError::IO(e),
+        })?;
+        self.run_buffer(&path.display().to_string(), &buffer)
+    }
+}
+
+fn read_to_end(path: &Path) -> Result<Vec<u8>, io::Error> {
+    let mut buf: Vec<u8> = Vec::new();
+    let mut file = fs::File::open(path)?;
+    file.read_to_end(&mut buf)?;
+    Ok(buf)
+}