479 lines
20 KiB
Rust
479 lines
20 KiB
Rust
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, Instance, 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<Instance>,
|
|
|
|
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 Instance, 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)
|
|
}
|