Source code
Revision control
Copy as Markdown
Other Tools
// |jit-test| skip-if: !wasmSimdEnabled()
function testValid(code) {
assertEq(WebAssembly.validate(wasmTextToBinary(code)), true);
}
function testInvalid(code) {
assertEq(WebAssembly.validate(wasmTextToBinary(code)), false);
}
// v128 -> v128
for (let op of [
'i8x16.neg',
'i8x16.abs',
'i16x8.neg',
'i16x8.abs',
'i16x8.extend_low_i8x16_s',
'i16x8.extend_high_i8x16_s',
'i16x8.extend_low_i8x16_u',
'i16x8.extend_high_i8x16_u',
'i32x4.neg',
'i32x4.abs',
'i32x4.extend_low_i16x8_s',
'i32x4.extend_high_i16x8_s',
'i32x4.extend_low_i16x8_u',
'i32x4.extend_high_i16x8_u',
'i32x4.trunc_sat_f32x4_s',
'i32x4.trunc_sat_f32x4_u',
'i64x2.neg',
'f32x4.abs',
'f32x4.neg',
'f32x4.sqrt',
'f32x4.convert_i32x4_s',
'f32x4.convert_i32x4_s',
'f64x2.abs',
'f64x2.neg',
'f64x2.sqrt',
'v128.not'])
{
testValid(`(module
(func (param v128) (result v128)
(${op} (local.get 0))))`);
}
for (let [prefix, result, suffix] of [['i8x16', 'i32', '_s'],
['i8x16', 'i32', '_u'],
['i16x8', 'i32', '_s'],
['i16x8', 'i32', '_u'],
['i32x4', 'i32', ''],
['i64x2', 'i64', ''],
['f32x4', 'f32', ''],
['f64x2', 'f64', '']])
{
testValid(`(module
(func (param v128) (result ${result})
(${prefix}.extract_lane${suffix} 1 (local.get 0))))`);
}
// The wat parser accepts small out-of-range lane indices, but they must be
// caught in validation.
testInvalid(
`(module
(func (param v128) (result i32)
(i8x16.extract_lane_u 16 (local.get 0))))`);
// (v128, v128) -> v128
for (let op of [
'i8x16.eq',
'i8x16.ne',
'i8x16.lt_s',
'i8x16.lt_u',
'i8x16.gt_s',
'i8x16.gt_u',
'i8x16.le_s',
'i8x16.le_u',
'i8x16.ge_s',
'i8x16.ge_u',
'i16x8.eq',
'i16x8.ne',
'i16x8.lt_s',
'i16x8.lt_u',
'i16x8.gt_s',
'i16x8.gt_u',
'i16x8.le_s',
'i16x8.le_u',
'i16x8.ge_s',
'i16x8.ge_u',
'i32x4.eq',
'i32x4.ne',
'i32x4.lt_s',
'i32x4.lt_u',
'i32x4.gt_s',
'i32x4.gt_u',
'i32x4.le_s',
'i32x4.le_u',
'i32x4.ge_s',
'i32x4.ge_u',
'f32x4.eq',
'f32x4.ne',
'f32x4.lt',
'f32x4.gt',
'f32x4.le',
'f32x4.ge',
'f64x2.eq',
'f64x2.ne',
'f64x2.lt',
'f64x2.gt',
'f64x2.le',
'f64x2.ge',
'v128.and',
'v128.or',
'v128.xor',
'v128.andnot',
'i8x16.avgr_u',
'i16x8.avgr_u',
'i8x16.add',
'i8x16.add_sat_s',
'i8x16.add_sat_u',
'i8x16.sub',
'i8x16.sub_sat_s',
'i8x16.sub_sat_u',
'i8x16.min_s',
'i8x16.max_s',
'i8x16.min_u',
'i8x16.max_u',
'i16x8.add',
'i16x8.add_sat_s',
'i16x8.add_sat_u',
'i16x8.sub',
'i16x8.sub_sat_s',
'i16x8.sub_sat_u',
'i16x8.mul',
'i16x8.min_s',
'i16x8.max_s',
'i16x8.min_u',
'i16x8.max_u',
'i32x4.add',
'i32x4.sub',
'i32x4.mul',
'i32x4.min_s',
'i32x4.max_s',
'i32x4.min_u',
'i32x4.max_u',
'i64x2.add',
'i64x2.sub',
'i64x2.mul',
'f32x4.add',
'f32x4.sub',
'f32x4.mul',
'f32x4.div',
'f32x4.min',
'f32x4.max',
'f64x2.add',
'f64x2.sub',
'f64x2.mul',
'f64x2.div',
'f64x2.min',
'f64x2.max',
'i8x16.narrow_i16x8_s',
'i8x16.narrow_i16x8_u',
'i16x8.narrow_i32x4_s',
'i16x8.narrow_i32x4_u',
'i8x16.swizzle'])
{
testValid(`(module
(func (param v128) (param v128) (result v128)
(${op} (local.get 0) (local.get 1))))`);
}
testValid(`(module
(func (param v128) (param v128) (result v128)
(i8x16.shuffle 0 16 1 17 2 18 3 19 4 20 5 21 6 22 7 23 (local.get 0) (local.get 1))))`);
assertErrorMessage(() => testValid(
`(module
(func (param v128) (param v128) (result v128)
(i8x16.shuffle 0 16 1 17 2 18 3 19 4 20 5 21 6 22 7 (local.get 0) (local.get 1))))`),
SyntaxError,
/expected a u8/);
// (v128, i32) -> v128
for (let op of [
'i8x16.shl',
'i8x16.shr_s',
'i8x16.shr_u',
'i16x8.shl',
'i16x8.shr_s',
'i16x8.shr_u',
'i32x4.shl',
'i32x4.shr_s',
'i32x4.shr_u',
'i64x2.shl',
'i64x2.shr_s',
'i64x2.shr_u'])
{
testValid(`(module
(func (param v128) (param i32) (result v128)
(${op} (local.get 0) (local.get 1))))`);
}
// v128 -> i32
for (let op of [
'v128.any_true',
'i8x16.all_true',
'i16x8.all_true',
'i32x4.all_true',
'i8x16.bitmask',
'i16x8.bitmask',
'i32x4.bitmask'])
{
testValid(`(module
(func (param v128) (result i32)
(${op} (local.get 0))))`);
}
// T -> V128
for (let [op, input] of [
['i8x16.splat', 'i32'],
['i16x8.splat', 'i32'],
['i32x4.splat', 'i32'],
['i64x2.splat', 'i64'],
['f32x4.splat', 'f32'],
['f64x2.splat', 'f64']])
{
testValid(`(module
(func (param ${input}) (result v128)
(${op} (local.get 0))))`);
}
// i32 -> v128
for (let op of [
'v128.load',
'v128.load8_splat',
'v128.load16_splat',
'v128.load32_splat',
'v128.load64_splat',
'v128.load8x8_s',
'v128.load8x8_u',
'v128.load16x4_s',
'v128.load16x4_u',
'v128.load32x2_s',
'v128.load32x2_u'])
{
testValid(`(module
(memory 1 1)
(func (param i32) (result v128)
(${op} (local.get 0))))`);
}
testValid(`(module
(func (result v128)
(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
(func (result v128)
(v128.const i16x8 0 1 2 3 4 5 6 7))
(func (result v128)
(v128.const i32x4 0 1 2 3))
(func (result v128)
(v128.const i64x2 0 1))
(func (result v128)
(v128.const f32x4 0 1 2 3))
(func (result v128)
(v128.const f32x4 0.5 1.5 2.5 3.5))
(func (result v128)
(v128.const f64x2 0 1))
(func (result v128)
(v128.const f64x2 0.5 1.5)))`);
assertErrorMessage(() => testValid(
`(module
(func (result v128)
(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14)))`),
SyntaxError,
/expected a i8/);
assertErrorMessage(() => testValid(
`(module
(func (result v128)
(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 256 15)))`),
SyntaxError,
/invalid i8 number/);
assertErrorMessage(() => testValid(
`(module
(func (result v128)
(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 3.14 15)))`),
SyntaxError,
/expected a i8/);
assertErrorMessage(() => testValid(
`(module
(func (result v128)
(v128.const f32x4 0.5 1.5 2.5))`),
SyntaxError,
/expected a float/);
assertErrorMessage(() => testValid(
`(module
(func (result v128)
(v128.const i8x8 0 1 2 3 4 5 6 7)))`),
SyntaxError,
/expected one of/);
// v128 -> ()
testValid(`(module
(memory 1 1)
(func (param i32) (param v128)
(v128.store (local.get 0) (local.get 1))))`);
// (v128, v128, v128) -> v128
testValid(`(module
(func (param v128) (param v128) (param v128) (result v128)
(v128.bitselect (local.get 0) (local.get 1) (local.get 2))))`);
// (v128, t) -> v128
for (let [prefix, input] of [['i8x16', 'i32'],
['i16x8', 'i32'],
['i32x4', 'i32'],
['i64x2', 'i64'],
['f32x4', 'f32'],
['f64x2', 'f64']])
{
testValid(`(module
(func (param v128) (param ${input}) (result v128)
(${prefix}.replace_lane 1 (local.get 0) (local.get 1))))`);
}
testInvalid(
`(module
(func (param v128) (param i32) (result v128)
(i8x16.replace_lane 16 (local.get 0) (local.get 1))))`);
// Global variables
testValid(`(module
(global $g (mut v128) (v128.const f32x4 1 2 3 4)))`);
testValid(`(module
(global $g (import "m" "g") v128)
(global $h (mut v128) (global.get $g)))`);
testValid(`(module
(global $g (export "g") v128 (v128.const f32x4 1 2 3 4)))`);
testValid(`(module
(global $g (export "g") (mut v128) (v128.const f32x4 1 2 3 4)))`);
// Imports, exports, calls
testValid(`(module
(import "m" "g" (func (param v128) (result v128)))
(func (export "f") (param v128) (result v128)
(f64x2.add (local.get 0) (v128.const f64x2 1 2))))`);
testValid(`(module
(func $f (param v128) (result v128)
(i8x16.neg (local.get 0)))
(func $g (export "g") (param v128) (result v128)
(call $f (local.get 0))))`);