540 lines
22 KiB
Rust
540 lines
22 KiB
Rust
use cranelift_codegen::isa;
|
|
use 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 wasmparser::{validate, OperatorValidatorConfig, ValidatingParserConfig};
|
|
use wasmtime_execute::{
|
|
ActionError, ActionOutcome, InstancePlus, InstancePlusIndex, JITCode, Namespace, RuntimeValue,
|
|
};
|
|
|
|
/// 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()),
|
|
}
|
|
}
|
|
|
|
/// Indicates an unknown instance was specified.
|
|
#[derive(Fail, Debug)]
|
|
pub struct UnknownInstance {
|
|
instance: Option<String>,
|
|
}
|
|
|
|
impl fmt::Display for UnknownInstance {
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
match self.instance {
|
|
None => write!(f, "no default instance present"),
|
|
Some(ref name) => write!(f, "no instance {} present", name),
|
|
}
|
|
}
|
|
}
|
|
|
|
/// 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),
|
|
/// 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 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::Action(ref error) => error.fmt(f),
|
|
WastError::Trap(ref message) => write!(f, "trap: {}", message),
|
|
WastError::Type(ref message) => write!(f, "type 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 {
|
|
/// A namespace of wasm modules, keyed by an optional name.
|
|
current: Option<InstancePlusIndex>,
|
|
namespace: Namespace,
|
|
jit_code: JITCode,
|
|
}
|
|
|
|
impl WastContext {
|
|
/// Construct a new instance of `WastContext`.
|
|
pub fn new() -> Self {
|
|
Self {
|
|
current: None,
|
|
namespace: Namespace::new(),
|
|
jit_code: JITCode::new(),
|
|
}
|
|
}
|
|
|
|
fn validate(&mut self, data: &[u8]) -> Result<(), ActionError> {
|
|
let config = ValidatingParserConfig {
|
|
operator_config: OperatorValidatorConfig {
|
|
enable_threads: false,
|
|
enable_reference_types: false,
|
|
},
|
|
mutable_global_imports: true,
|
|
};
|
|
|
|
// TODO: Fix Cranelift to be able to perform validation itself, rather
|
|
// than calling into wasmparser ourselves here.
|
|
if validate(data, Some(config)) {
|
|
Ok(())
|
|
} else {
|
|
// TODO: Work with wasmparser to get better error messages.
|
|
Err(ActionError::Validate("module did not validate".to_owned()))
|
|
}
|
|
}
|
|
|
|
fn instantiate(
|
|
&mut self,
|
|
isa: &isa::TargetIsa,
|
|
module: ModuleBinary,
|
|
) -> Result<InstancePlus, ActionError> {
|
|
let data = module.into_vec();
|
|
|
|
self.validate(&data)?;
|
|
|
|
InstancePlus::new(&mut self.jit_code, isa, &data, &mut self.namespace)
|
|
}
|
|
|
|
fn get_index(
|
|
&mut self,
|
|
instance_name: &Option<String>,
|
|
) -> Result<InstancePlusIndex, WastError> {
|
|
let index = *if let Some(instance_name) = instance_name {
|
|
self.namespace
|
|
.get_instance_index(instance_name)
|
|
.ok_or_else(|| {
|
|
WastError::Instance(UnknownInstance {
|
|
instance: Some(instance_name.to_string()),
|
|
})
|
|
})
|
|
} else {
|
|
self.current
|
|
.as_mut()
|
|
.ok_or_else(|| WastError::Instance(UnknownInstance { instance: None }))
|
|
}?;
|
|
|
|
Ok(index)
|
|
}
|
|
|
|
/// Register "spectest" which is used by the spec testsuite.
|
|
pub fn register_spectest(&mut self) -> Result<(), ActionError> {
|
|
let instance = instantiate_spectest()?;
|
|
self.namespace.instance(Some("spectest"), instance);
|
|
Ok(())
|
|
}
|
|
|
|
/// Perform the action portion of a command.
|
|
fn perform_action(
|
|
&mut self,
|
|
isa: &isa::TargetIsa,
|
|
action: Action,
|
|
) -> Result<ActionOutcome, WastError> {
|
|
match action {
|
|
Action::Invoke {
|
|
module: instance_name,
|
|
field,
|
|
args,
|
|
} => self.invoke(isa, 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,
|
|
isa: &isa::TargetIsa,
|
|
instance_name: Option<String>,
|
|
module: ModuleBinary,
|
|
) -> Result<(), ActionError> {
|
|
let instance = self.instantiate(isa, module)?;
|
|
let index = self
|
|
.namespace
|
|
.instance(instance_name.as_ref().map(String::as_str), instance);
|
|
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 index = self.get_index(&name)?;
|
|
self.namespace.register(as_name, index);
|
|
Ok(())
|
|
}
|
|
|
|
/// Invoke an exported function from an instance.
|
|
fn invoke(
|
|
&mut self,
|
|
isa: &isa::TargetIsa,
|
|
instance_name: Option<String>,
|
|
field: &str,
|
|
args: &[Value],
|
|
) -> Result<ActionOutcome, WastError> {
|
|
let value_args = args
|
|
.iter()
|
|
.map(|arg| runtime_value(*arg))
|
|
.collect::<Vec<_>>();
|
|
let index = self.get_index(&instance_name)?;
|
|
self.namespace
|
|
.invoke(&mut self.jit_code, isa, index, &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 index = self.get_index(&instance_name)?;
|
|
let value = self
|
|
.namespace
|
|
.get(index, field)
|
|
.map_err(WastError::Action)?;
|
|
Ok(ActionOutcome::Returned {
|
|
values: vec![value],
|
|
})
|
|
}
|
|
|
|
/// Perform the action of a `PerformAction`.
|
|
fn perform_action_command(
|
|
&mut self,
|
|
isa: &isa::TargetIsa,
|
|
action: Action,
|
|
) -> Result<(), WastError> {
|
|
match self.perform_action(isa, 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,
|
|
isa: &isa::TargetIsa,
|
|
filename: &str,
|
|
wast: &[u8],
|
|
) -> Result<(), WastFileError> {
|
|
let mut parser = ScriptParser::from_str(str::from_utf8(wast).unwrap()).unwrap();
|
|
|
|
while let Some(Command { kind, line }) = parser.next().expect("parser") {
|
|
match kind {
|
|
CommandKind::Module {
|
|
module: instance_name,
|
|
name,
|
|
} => {
|
|
self.module(isa, 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(isa, action)
|
|
.map_err(|error| WastFileError {
|
|
filename: filename.to_string(),
|
|
line,
|
|
error,
|
|
})?;
|
|
}
|
|
CommandKind::AssertReturn { action, expected } => {
|
|
match self
|
|
.perform_action(isa, 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(isa, 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(isa, 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(isa, 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(isa, 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(isa, 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(isa, 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(isa, 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(isa, 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, isa: &isa::TargetIsa, 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(isa, &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)
|
|
}
|