Add *.wast support for invoking components (#4526)
This commit builds on bytecodealliance/wasm-tools#690 to add support to testing of the component model to execute functions when running `*.wast` files. This support is all built on #4442 as functions are invoked through a "dynamic" API. Right now the testing and integration is fairly crude but I'm hoping that we can try to improve it over time as necessary. For now this should provide a hopefully more convenient syntax for unit tests and the like.
This commit is contained in:
Alex Crichton
@@ -1,51 +1,28 @@
|
||||
#[cfg(feature = "component-model")]
|
||||
use crate::component;
|
||||
use crate::core;
|
||||
use crate::spectest::*;
|
||||
use anyhow::{anyhow, bail, Context as _, Result};
|
||||
use std::fmt::{Display, LowerHex};
|
||||
use std::path::Path;
|
||||
use std::str;
|
||||
use wasmtime::*;
|
||||
use wast::core::{Expression, HeapType};
|
||||
use wast::lexer::Lexer;
|
||||
use wast::parser::{self, ParseBuffer};
|
||||
use wast::token::{Float32, Float64};
|
||||
use wast::{
|
||||
AssertExpression, NanPattern, QuoteWat, V128Pattern, Wast, WastDirective, WastExecute,
|
||||
WastInvoke, Wat,
|
||||
};
|
||||
|
||||
/// Translate from a `script::Value` to a `RuntimeValue`.
|
||||
fn runtime_value(v: &Expression<'_>) -> Result<Val> {
|
||||
use wast::core::Instruction::*;
|
||||
|
||||
if v.instrs.len() != 1 {
|
||||
bail!("too many instructions in {:?}", v);
|
||||
}
|
||||
Ok(match &v.instrs[0] {
|
||||
I32Const(x) => Val::I32(*x),
|
||||
I64Const(x) => Val::I64(*x),
|
||||
F32Const(x) => Val::F32(x.bits),
|
||||
F64Const(x) => Val::F64(x.bits),
|
||||
V128Const(x) => Val::V128(u128::from_le_bytes(x.to_le_bytes())),
|
||||
RefNull(HeapType::Extern) => Val::ExternRef(None),
|
||||
RefNull(HeapType::Func) => Val::FuncRef(None),
|
||||
RefExtern(x) => Val::ExternRef(Some(ExternRef::new(*x))),
|
||||
other => bail!("couldn't convert {:?} to a runtime value", other),
|
||||
})
|
||||
}
|
||||
use wast::{QuoteWat, Wast, WastArg, WastDirective, WastExecute, WastInvoke, WastRet, Wat};
|
||||
|
||||
/// The wast test script language allows modules to be defined and actions
|
||||
/// to be performed on them.
|
||||
pub struct WastContext<T> {
|
||||
/// Wast files have a concept of a "current" module, which is the most
|
||||
/// recently defined.
|
||||
current: Option<Instance>,
|
||||
current: Option<InstanceKind>,
|
||||
core_linker: Linker<T>,
|
||||
#[cfg(feature = "component-model")]
|
||||
component_linker: component::Linker<T>,
|
||||
store: Store<T>,
|
||||
}
|
||||
|
||||
enum Outcome<T = Vec<Val>> {
|
||||
enum Outcome<T = Results> {
|
||||
Ok(T),
|
||||
Trap(Trap),
|
||||
}
|
||||
@@ -66,6 +43,25 @@ impl<T> Outcome<T> {
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
enum Results {
|
||||
Core(Vec<Val>),
|
||||
#[cfg(feature = "component-model")]
|
||||
Component(component::Val),
|
||||
}
|
||||
|
||||
enum InstanceKind {
|
||||
Core(Instance),
|
||||
#[cfg(feature = "component-model")]
|
||||
Component(component::Instance),
|
||||
}
|
||||
|
||||
enum Export {
|
||||
Core(Extern),
|
||||
#[cfg(feature = "component-model")]
|
||||
Component(component::Func),
|
||||
}
|
||||
|
||||
impl<T> WastContext<T> {
|
||||
/// Construct a new instance of `WastContext`.
|
||||
pub fn new(store: Store<T>) -> Self {
|
||||
@@ -87,19 +83,30 @@ impl<T> WastContext<T> {
|
||||
}
|
||||
}
|
||||
|
||||
fn get_export(&mut self, module: Option<&str>, name: &str) -> Result<Extern> {
|
||||
match module {
|
||||
Some(module) => self
|
||||
.core_linker
|
||||
.get(&mut self.store, module, name)
|
||||
.ok_or_else(|| anyhow!("no item named `{}::{}` found", module, name)),
|
||||
None => self
|
||||
.current
|
||||
.as_ref()
|
||||
.ok_or_else(|| anyhow!("no previous instance found"))?
|
||||
.get_export(&mut self.store, name)
|
||||
.ok_or_else(|| anyhow!("no item named `{}` found", name)),
|
||||
fn get_export(&mut self, module: Option<&str>, name: &str) -> Result<Export> {
|
||||
if let Some(module) = module {
|
||||
return Ok(Export::Core(
|
||||
self.core_linker
|
||||
.get(&mut self.store, module, name)
|
||||
.ok_or_else(|| anyhow!("no item named `{}::{}` found", module, name))?,
|
||||
));
|
||||
}
|
||||
|
||||
let cur = self
|
||||
.current
|
||||
.as_ref()
|
||||
.ok_or_else(|| anyhow!("no previous instance found"))?;
|
||||
Ok(match cur {
|
||||
InstanceKind::Core(i) => Export::Core(
|
||||
i.get_export(&mut self.store, name)
|
||||
.ok_or_else(|| anyhow!("no item named `{}` found", name))?,
|
||||
),
|
||||
#[cfg(feature = "component-model")]
|
||||
InstanceKind::Component(i) => Export::Component(
|
||||
i.get_func(&mut self.store, name)
|
||||
.ok_or_else(|| anyhow!("no func named `{}` found", name))?,
|
||||
),
|
||||
})
|
||||
}
|
||||
|
||||
fn instantiate_module(&mut self, module: &[u8]) -> Result<Outcome<Instance>> {
|
||||
@@ -134,30 +141,67 @@ impl<T> WastContext<T> {
|
||||
fn perform_execute(&mut self, exec: WastExecute<'_>) -> Result<Outcome> {
|
||||
match exec {
|
||||
WastExecute::Invoke(invoke) => self.perform_invoke(invoke),
|
||||
WastExecute::Wat(mut module) => {
|
||||
let result = match &mut module {
|
||||
Wat::Module(m) => self.instantiate_module(&m.encode()?)?.map(|_| ()),
|
||||
#[cfg(feature = "component-model")]
|
||||
Wat::Component(m) => self.instantiate_component(&m.encode()?)?.map(|_| ()),
|
||||
#[cfg(not(feature = "component-model"))]
|
||||
Wat::Component(_) => bail!("component-model support not enabled"),
|
||||
};
|
||||
Ok(match result {
|
||||
Outcome::Ok(_) => Outcome::Ok(Vec::new()),
|
||||
Outcome::Trap(e) => Outcome::Trap(e),
|
||||
})
|
||||
}
|
||||
WastExecute::Wat(mut module) => Ok(match &mut module {
|
||||
Wat::Module(m) => self
|
||||
.instantiate_module(&m.encode()?)?
|
||||
.map(|_| Results::Core(Vec::new())),
|
||||
#[cfg(feature = "component-model")]
|
||||
Wat::Component(m) => self
|
||||
.instantiate_component(&m.encode()?)?
|
||||
.map(|_| Results::Component(component::Val::Unit)),
|
||||
#[cfg(not(feature = "component-model"))]
|
||||
Wat::Component(_) => bail!("component-model support not enabled"),
|
||||
}),
|
||||
WastExecute::Get { module, global } => self.get(module.map(|s| s.name()), global),
|
||||
}
|
||||
}
|
||||
|
||||
fn perform_invoke(&mut self, exec: WastInvoke<'_>) -> Result<Outcome> {
|
||||
let values = exec
|
||||
.args
|
||||
.iter()
|
||||
.map(|v| runtime_value(v))
|
||||
.collect::<Result<Vec<_>>>()?;
|
||||
self.invoke(exec.module.map(|i| i.name()), exec.name, &values)
|
||||
match self.get_export(exec.module.map(|i| i.name()), exec.name)? {
|
||||
Export::Core(export) => {
|
||||
let func = export
|
||||
.into_func()
|
||||
.ok_or_else(|| anyhow!("no function named `{}`", exec.name))?;
|
||||
let values = exec
|
||||
.args
|
||||
.iter()
|
||||
.map(|v| match v {
|
||||
WastArg::Core(v) => core::val(v),
|
||||
WastArg::Component(_) => bail!("expected component function, found core"),
|
||||
})
|
||||
.collect::<Result<Vec<_>>>()?;
|
||||
|
||||
let mut results = vec![Val::null(); func.ty(&self.store).results().len()];
|
||||
Ok(match func.call(&mut self.store, &values, &mut results) {
|
||||
Ok(()) => Outcome::Ok(Results::Core(results.into())),
|
||||
Err(e) => Outcome::Trap(e.downcast()?),
|
||||
})
|
||||
}
|
||||
#[cfg(feature = "component-model")]
|
||||
Export::Component(func) => {
|
||||
let params = func.params(&self.store);
|
||||
if exec.args.len() != params.len() {
|
||||
bail!("mismatched number of parameters")
|
||||
}
|
||||
let values = exec
|
||||
.args
|
||||
.iter()
|
||||
.zip(params.iter())
|
||||
.map(|(v, t)| match v {
|
||||
WastArg::Component(v) => component::val(v, t),
|
||||
WastArg::Core(_) => bail!("expected core function, found component"),
|
||||
})
|
||||
.collect::<Result<Vec<_>>>()?;
|
||||
|
||||
Ok(match func.call(&mut self.store, &values) {
|
||||
Ok(results) => {
|
||||
func.post_return(&mut self.store)?;
|
||||
Outcome::Ok(Results::Component(results.into()))
|
||||
}
|
||||
Err(e) => Outcome::Trap(e.downcast()?),
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Define a module and register it.
|
||||
@@ -178,7 +222,7 @@ impl<T> WastContext<T> {
|
||||
self.core_linker
|
||||
.instance(&mut self.store, name.name(), instance)?;
|
||||
}
|
||||
self.current = Some(instance);
|
||||
self.current = Some(InstanceKind::Core(instance));
|
||||
} else {
|
||||
#[cfg(feature = "component-model")]
|
||||
{
|
||||
@@ -197,6 +241,7 @@ impl<T> WastContext<T> {
|
||||
linker.module(name, module)?;
|
||||
}
|
||||
}
|
||||
self.current = Some(InstanceKind::Component(instance));
|
||||
}
|
||||
#[cfg(not(feature = "component-model"))]
|
||||
bail!("component-model support not enabled");
|
||||
@@ -209,49 +254,65 @@ impl<T> WastContext<T> {
|
||||
match name {
|
||||
Some(name) => self.core_linker.alias_module(name, as_name),
|
||||
None => {
|
||||
let current = *self
|
||||
let current = self
|
||||
.current
|
||||
.as_ref()
|
||||
.ok_or(anyhow!("no previous instance"))?;
|
||||
self.core_linker
|
||||
.instance(&mut self.store, as_name, current)?;
|
||||
match current {
|
||||
InstanceKind::Core(current) => {
|
||||
self.core_linker
|
||||
.instance(&mut self.store, as_name, *current)?;
|
||||
}
|
||||
#[cfg(feature = "component-model")]
|
||||
InstanceKind::Component(_) => {
|
||||
bail!("register not implemented for components");
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Invoke an exported function from an instance.
|
||||
fn invoke(
|
||||
&mut self,
|
||||
instance_name: Option<&str>,
|
||||
field: &str,
|
||||
args: &[Val],
|
||||
) -> Result<Outcome> {
|
||||
let func = self
|
||||
.get_export(instance_name, field)?
|
||||
.into_func()
|
||||
.ok_or_else(|| anyhow!("no function named `{}`", field))?;
|
||||
|
||||
let mut results = vec![Val::null(); func.ty(&self.store).results().len()];
|
||||
Ok(match func.call(&mut self.store, args, &mut results) {
|
||||
Ok(()) => Outcome::Ok(results.into()),
|
||||
Err(e) => Outcome::Trap(e.downcast()?),
|
||||
})
|
||||
}
|
||||
|
||||
/// Get the value of an exported global from an instance.
|
||||
fn get(&mut self, instance_name: Option<&str>, field: &str) -> Result<Outcome> {
|
||||
let global = self
|
||||
.get_export(instance_name, field)?
|
||||
.into_global()
|
||||
.ok_or_else(|| anyhow!("no global named `{}`", field))?;
|
||||
Ok(Outcome::Ok(vec![global.get(&mut self.store)]))
|
||||
let global = match self.get_export(instance_name, field)? {
|
||||
Export::Core(e) => e
|
||||
.into_global()
|
||||
.ok_or_else(|| anyhow!("no global named `{field}`"))?,
|
||||
#[cfg(feature = "component-model")]
|
||||
Export::Component(_) => bail!("no global named `{field}`"),
|
||||
};
|
||||
Ok(Outcome::Ok(Results::Core(
|
||||
vec![global.get(&mut self.store)],
|
||||
)))
|
||||
}
|
||||
|
||||
fn assert_return(&self, result: Outcome, results: &[AssertExpression]) -> Result<()> {
|
||||
let values = result.into_result()?;
|
||||
for (i, (v, e)) in values.iter().zip(results).enumerate() {
|
||||
match_val(v, e).with_context(|| format!("result {} didn't match", i))?;
|
||||
fn assert_return(&self, result: Outcome, results: &[WastRet<'_>]) -> Result<()> {
|
||||
match result.into_result()? {
|
||||
Results::Core(values) => {
|
||||
for (i, (v, e)) in values.iter().zip(results).enumerate() {
|
||||
let e = match e {
|
||||
WastRet::Core(core) => core,
|
||||
WastRet::Component(_) => {
|
||||
bail!("expected component value found core value")
|
||||
}
|
||||
};
|
||||
core::match_val(v, e).with_context(|| format!("result {} didn't match", i))?;
|
||||
}
|
||||
}
|
||||
#[cfg(feature = "component-model")]
|
||||
Results::Component(value) => {
|
||||
if results.len() != 1 {
|
||||
bail!("expected one result value assertion");
|
||||
}
|
||||
let result = match &results[0] {
|
||||
WastRet::Component(ret) => ret,
|
||||
WastRet::Core(_) => {
|
||||
bail!("expected core value found component value")
|
||||
}
|
||||
};
|
||||
component::match_val(&result, &value)?;
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
@@ -414,327 +475,3 @@ fn is_matching_assert_invalid_error_message(expected: &str, actual: &str) -> boo
|
||||
// the memory64 tests to pass.
|
||||
|| (expected.contains("memory size must be at most 65536 pages") && actual.contains("invalid u32 number"))
|
||||
}
|
||||
|
||||
fn extract_lane_as_i8(bytes: u128, lane: usize) -> i8 {
|
||||
(bytes >> (lane * 8)) as i8
|
||||
}
|
||||
|
||||
fn extract_lane_as_i16(bytes: u128, lane: usize) -> i16 {
|
||||
(bytes >> (lane * 16)) as i16
|
||||
}
|
||||
|
||||
fn extract_lane_as_i32(bytes: u128, lane: usize) -> i32 {
|
||||
(bytes >> (lane * 32)) as i32
|
||||
}
|
||||
|
||||
fn extract_lane_as_i64(bytes: u128, lane: usize) -> i64 {
|
||||
(bytes >> (lane * 64)) as i64
|
||||
}
|
||||
|
||||
fn match_val(actual: &Val, expected: &AssertExpression) -> Result<()> {
|
||||
match (actual, expected) {
|
||||
(Val::I32(a), AssertExpression::I32(b)) => match_int(a, b),
|
||||
(Val::I64(a), AssertExpression::I64(b)) => match_int(a, b),
|
||||
// Note that these float comparisons are comparing bits, not float
|
||||
// values, so we're testing for bit-for-bit equivalence
|
||||
(Val::F32(a), AssertExpression::F32(b)) => match_f32(*a, b),
|
||||
(Val::F64(a), AssertExpression::F64(b)) => match_f64(*a, b),
|
||||
(Val::V128(a), AssertExpression::V128(b)) => match_v128(*a, b),
|
||||
(Val::ExternRef(x), AssertExpression::RefNull(Some(HeapType::Extern))) => {
|
||||
if let Some(x) = x {
|
||||
let x = x
|
||||
.data()
|
||||
.downcast_ref::<u32>()
|
||||
.expect("only u32 externrefs created in wast test suites");
|
||||
bail!("expected null externref, found {}", x);
|
||||
} else {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
(Val::ExternRef(x), AssertExpression::RefExtern(y)) => {
|
||||
if let Some(x) = x {
|
||||
let x = x
|
||||
.data()
|
||||
.downcast_ref::<u32>()
|
||||
.expect("only u32 externrefs created in wast test suites");
|
||||
if x == y {
|
||||
Ok(())
|
||||
} else {
|
||||
bail!("expected {} found {}", y, x);
|
||||
}
|
||||
} else {
|
||||
bail!("expected non-null externref, found null")
|
||||
}
|
||||
}
|
||||
(Val::FuncRef(x), AssertExpression::RefNull(_)) => {
|
||||
if x.is_none() {
|
||||
Ok(())
|
||||
} else {
|
||||
bail!("expected null funcref, found non-null")
|
||||
}
|
||||
}
|
||||
_ => bail!(
|
||||
"don't know how to compare {:?} and {:?} yet",
|
||||
actual,
|
||||
expected
|
||||
),
|
||||
}
|
||||
}
|
||||
|
||||
fn match_int<T>(actual: &T, expected: &T) -> Result<()>
|
||||
where
|
||||
T: Eq + Display + LowerHex,
|
||||
{
|
||||
if actual == expected {
|
||||
Ok(())
|
||||
} else {
|
||||
bail!(
|
||||
"expected {:18} / {0:#018x}\n\
|
||||
actual {:18} / {1:#018x}",
|
||||
expected,
|
||||
actual
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
fn match_f32(actual: u32, expected: &NanPattern<Float32>) -> Result<()> {
|
||||
match expected {
|
||||
// Check if an f32 (as u32 bits to avoid possible quieting when moving values in registers, e.g.
|
||||
// https://developer.arm.com/documentation/ddi0344/i/neon-and-vfp-programmers-model/modes-of-operation/default-nan-mode?lang=en)
|
||||
// is a canonical NaN:
|
||||
// - the sign bit is unspecified,
|
||||
// - the 8-bit exponent is set to all 1s
|
||||
// - the MSB of the payload is set to 1 (a quieted NaN) and all others to 0.
|
||||
// See https://webassembly.github.io/spec/core/syntax/values.html#floating-point.
|
||||
NanPattern::CanonicalNan => {
|
||||
let canon_nan = 0x7fc0_0000;
|
||||
if (actual & 0x7fff_ffff) == canon_nan {
|
||||
Ok(())
|
||||
} else {
|
||||
bail!(
|
||||
"expected {:10} / {:#010x}\n\
|
||||
actual {:10} / {:#010x}",
|
||||
"canon-nan",
|
||||
canon_nan,
|
||||
f32::from_bits(actual),
|
||||
actual,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
// Check if an f32 (as u32, see comments above) is an arithmetic NaN.
|
||||
// This is the same as a canonical NaN including that the payload MSB is
|
||||
// set to 1, but one or more of the remaining payload bits MAY BE set to
|
||||
// 1 (a canonical NaN specifies all 0s). See
|
||||
// https://webassembly.github.io/spec/core/syntax/values.html#floating-point.
|
||||
NanPattern::ArithmeticNan => {
|
||||
const AF32_NAN: u32 = 0x7f80_0000;
|
||||
let is_nan = actual & AF32_NAN == AF32_NAN;
|
||||
const AF32_PAYLOAD_MSB: u32 = 0x0040_0000;
|
||||
let is_msb_set = actual & AF32_PAYLOAD_MSB == AF32_PAYLOAD_MSB;
|
||||
if is_nan && is_msb_set {
|
||||
Ok(())
|
||||
} else {
|
||||
bail!(
|
||||
"expected {:>10} / {:>10}\n\
|
||||
actual {:10} / {:#010x}",
|
||||
"arith-nan",
|
||||
"0x7fc*****",
|
||||
f32::from_bits(actual),
|
||||
actual,
|
||||
)
|
||||
}
|
||||
}
|
||||
NanPattern::Value(expected_value) => {
|
||||
if actual == expected_value.bits {
|
||||
Ok(())
|
||||
} else {
|
||||
bail!(
|
||||
"expected {:10} / {:#010x}\n\
|
||||
actual {:10} / {:#010x}",
|
||||
f32::from_bits(expected_value.bits),
|
||||
expected_value.bits,
|
||||
f32::from_bits(actual),
|
||||
actual,
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn match_f64(actual: u64, expected: &NanPattern<Float64>) -> Result<()> {
|
||||
match expected {
|
||||
// Check if an f64 (as u64 bits to avoid possible quieting when moving values in registers, e.g.
|
||||
// https://developer.arm.com/documentation/ddi0344/i/neon-and-vfp-programmers-model/modes-of-operation/default-nan-mode?lang=en)
|
||||
// is a canonical NaN:
|
||||
// - the sign bit is unspecified,
|
||||
// - the 11-bit exponent is set to all 1s
|
||||
// - the MSB of the payload is set to 1 (a quieted NaN) and all others to 0.
|
||||
// See https://webassembly.github.io/spec/core/syntax/values.html#floating-point.
|
||||
NanPattern::CanonicalNan => {
|
||||
let canon_nan = 0x7ff8_0000_0000_0000;
|
||||
if (actual & 0x7fff_ffff_ffff_ffff) == canon_nan {
|
||||
Ok(())
|
||||
} else {
|
||||
bail!(
|
||||
"expected {:18} / {:#018x}\n\
|
||||
actual {:18} / {:#018x}",
|
||||
"canon-nan",
|
||||
canon_nan,
|
||||
f64::from_bits(actual),
|
||||
actual,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
// Check if an f64 (as u64, see comments above) is an arithmetic NaN. This is the same as a
|
||||
// canonical NaN including that the payload MSB is set to 1, but one or more of the remaining
|
||||
// payload bits MAY BE set to 1 (a canonical NaN specifies all 0s). See
|
||||
// https://webassembly.github.io/spec/core/syntax/values.html#floating-point.
|
||||
NanPattern::ArithmeticNan => {
|
||||
const AF64_NAN: u64 = 0x7ff0_0000_0000_0000;
|
||||
let is_nan = actual & AF64_NAN == AF64_NAN;
|
||||
const AF64_PAYLOAD_MSB: u64 = 0x0008_0000_0000_0000;
|
||||
let is_msb_set = actual & AF64_PAYLOAD_MSB == AF64_PAYLOAD_MSB;
|
||||
if is_nan && is_msb_set {
|
||||
Ok(())
|
||||
} else {
|
||||
bail!(
|
||||
"expected {:>18} / {:>18}\n\
|
||||
actual {:18} / {:#018x}",
|
||||
"arith-nan",
|
||||
"0x7ff8************",
|
||||
f64::from_bits(actual),
|
||||
actual,
|
||||
)
|
||||
}
|
||||
}
|
||||
NanPattern::Value(expected_value) => {
|
||||
if actual == expected_value.bits {
|
||||
Ok(())
|
||||
} else {
|
||||
bail!(
|
||||
"expected {:18} / {:#018x}\n\
|
||||
actual {:18} / {:#018x}",
|
||||
f64::from_bits(expected_value.bits),
|
||||
expected_value.bits,
|
||||
f64::from_bits(actual),
|
||||
actual,
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn match_v128(actual: u128, expected: &V128Pattern) -> Result<()> {
|
||||
match expected {
|
||||
V128Pattern::I8x16(expected) => {
|
||||
let actual = [
|
||||
extract_lane_as_i8(actual, 0),
|
||||
extract_lane_as_i8(actual, 1),
|
||||
extract_lane_as_i8(actual, 2),
|
||||
extract_lane_as_i8(actual, 3),
|
||||
extract_lane_as_i8(actual, 4),
|
||||
extract_lane_as_i8(actual, 5),
|
||||
extract_lane_as_i8(actual, 6),
|
||||
extract_lane_as_i8(actual, 7),
|
||||
extract_lane_as_i8(actual, 8),
|
||||
extract_lane_as_i8(actual, 9),
|
||||
extract_lane_as_i8(actual, 10),
|
||||
extract_lane_as_i8(actual, 11),
|
||||
extract_lane_as_i8(actual, 12),
|
||||
extract_lane_as_i8(actual, 13),
|
||||
extract_lane_as_i8(actual, 14),
|
||||
extract_lane_as_i8(actual, 15),
|
||||
];
|
||||
if actual == *expected {
|
||||
return Ok(());
|
||||
}
|
||||
bail!(
|
||||
"expected {:4?}\n\
|
||||
actual {:4?}\n\
|
||||
\n\
|
||||
expected (hex) {0:02x?}\n\
|
||||
actual (hex) {1:02x?}",
|
||||
expected,
|
||||
actual,
|
||||
)
|
||||
}
|
||||
V128Pattern::I16x8(expected) => {
|
||||
let actual = [
|
||||
extract_lane_as_i16(actual, 0),
|
||||
extract_lane_as_i16(actual, 1),
|
||||
extract_lane_as_i16(actual, 2),
|
||||
extract_lane_as_i16(actual, 3),
|
||||
extract_lane_as_i16(actual, 4),
|
||||
extract_lane_as_i16(actual, 5),
|
||||
extract_lane_as_i16(actual, 6),
|
||||
extract_lane_as_i16(actual, 7),
|
||||
];
|
||||
if actual == *expected {
|
||||
return Ok(());
|
||||
}
|
||||
bail!(
|
||||
"expected {:6?}\n\
|
||||
actual {:6?}\n\
|
||||
\n\
|
||||
expected (hex) {0:04x?}\n\
|
||||
actual (hex) {1:04x?}",
|
||||
expected,
|
||||
actual,
|
||||
)
|
||||
}
|
||||
V128Pattern::I32x4(expected) => {
|
||||
let actual = [
|
||||
extract_lane_as_i32(actual, 0),
|
||||
extract_lane_as_i32(actual, 1),
|
||||
extract_lane_as_i32(actual, 2),
|
||||
extract_lane_as_i32(actual, 3),
|
||||
];
|
||||
if actual == *expected {
|
||||
return Ok(());
|
||||
}
|
||||
bail!(
|
||||
"expected {:11?}\n\
|
||||
actual {:11?}\n\
|
||||
\n\
|
||||
expected (hex) {0:08x?}\n\
|
||||
actual (hex) {1:08x?}",
|
||||
expected,
|
||||
actual,
|
||||
)
|
||||
}
|
||||
V128Pattern::I64x2(expected) => {
|
||||
let actual = [
|
||||
extract_lane_as_i64(actual, 0),
|
||||
extract_lane_as_i64(actual, 1),
|
||||
];
|
||||
if actual == *expected {
|
||||
return Ok(());
|
||||
}
|
||||
bail!(
|
||||
"expected {:20?}\n\
|
||||
actual {:20?}\n\
|
||||
\n\
|
||||
expected (hex) {0:016x?}\n\
|
||||
actual (hex) {1:016x?}",
|
||||
expected,
|
||||
actual,
|
||||
)
|
||||
}
|
||||
V128Pattern::F32x4(expected) => {
|
||||
for (i, expected) in expected.iter().enumerate() {
|
||||
let a = extract_lane_as_i32(actual, i) as u32;
|
||||
match_f32(a, expected).with_context(|| format!("difference in lane {}", i))?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
V128Pattern::F64x2(expected) => {
|
||||
for (i, expected) in expected.iter().enumerate() {
|
||||
let a = extract_lane_as_i64(actual, i) as u64;
|
||||
match_f64(a, expected).with_context(|| format!("difference in lane {}", i))?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user