// |jit-test| skip-if: !wasmSimdEnabled()
/* Copyright 2021 Mozilla Foundation
*
* Licensed under the Apache License , Version 2 . 0 ( the " License " ) ;
* you may not use this file except in compliance with the License .
* You may obtain a copy of the License at
*
* http : //www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing , software
* distributed under the License is distributed on an " AS IS " BASIS ,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND , either express or implied .
* See the License for the specific language governing permissions and
* limitations under the License .
*/
// ./test/core/simd/simd_lane.wast
// ./test/core/simd/simd_lane.wast:4
let $0 = instantiate(`(module
(func (export "i8x16_extract_lane_s-first" ) (param v128) (result i32)
(i8x16.extract_lane_s 0 (local.get 0 )))
(func (export "i8x16_extract_lane_s-last" ) (param v128) (result i32)
(i8x16.extract_lane_s 15 (local.get 0 )))
(func (export "i8x16_extract_lane_u-first" ) (param v128) (result i32)
(i8x16.extract_lane_u 0 (local.get 0 )))
(func (export "i8x16_extract_lane_u-last" ) (param v128) (result i32)
(i8x16.extract_lane_u 15 (local.get 0 )))
(func (export "i16x8_extract_lane_s-first" ) (param v128) (result i32)
(i16x8.extract_lane_s 0 (local.get 0 )))
(func (export "i16x8_extract_lane_s-last" ) (param v128) (result i32)
(i16x8.extract_lane_s 7 (local.get 0 )))
(func (export "i16x8_extract_lane_u-first" ) (param v128) (result i32)
(i16x8.extract_lane_u 0 (local.get 0 )))
(func (export "i16x8_extract_lane_u-last" ) (param v128) (result i32)
(i16x8.extract_lane_u 7 (local.get 0 )))
(func (export "i32x4_extract_lane-first" ) (param v128) (result i32)
(i32x4.extract_lane 0 (local.get 0 )))
(func (export "i32x4_extract_lane-last" ) (param v128) (result i32)
(i32x4.extract_lane 3 (local.get 0 )))
(func (export "f32x4_extract_lane-first" ) (param v128) (result f32)
(f32x4.extract_lane 0 (local.get 0 )))
(func (export "f32x4_extract_lane-last" ) (param v128) (result f32)
(f32x4.extract_lane 3 (local.get 0 )))
(func (export "i8x16_replace_lane-first" ) (param v128 i32) (result v128)
(i8x16.replace_lane 0 (local.get 0 ) (local.get 1 )))
(func (export "i8x16_replace_lane-last" ) (param v128 i32) (result v128)
(i8x16.replace_lane 15 (local.get 0 ) (local.get 1 )))
(func (export "i16x8_replace_lane-first" ) (param v128 i32) (result v128)
(i16x8.replace_lane 0 (local.get 0 ) (local.get 1 )))
(func (export "i16x8_replace_lane-last" ) (param v128 i32) (result v128)
(i16x8.replace_lane 7 (local.get 0 ) (local.get 1 )))
(func (export "i32x4_replace_lane-first" ) (param v128 i32) (result v128)
(i32x4.replace_lane 0 (local.get 0 ) (local.get 1 )))
(func (export "i32x4_replace_lane-last" ) (param v128 i32) (result v128)
(i32x4.replace_lane 3 (local.get 0 ) (local.get 1 )))
(func (export "f32x4_replace_lane-first" ) (param v128 f32) (result v128)
(f32x4.replace_lane 0 (local.get 0 ) (local.get 1 )))
(func (export "f32x4_replace_lane-last" ) (param v128 f32) (result v128)
(f32x4.replace_lane 3 (local.get 0 ) (local.get 1 )))
(func (export "i64x2_extract_lane-first" ) (param v128) (result i64)
(i64x2.extract_lane 0 (local.get 0 )))
(func (export "i64x2_extract_lane-last" ) (param v128) (result i64)
(i64x2.extract_lane 1 (local.get 0 )))
(func (export "f64x2_extract_lane-first" ) (param v128) (result f64)
(f64x2.extract_lane 0 (local.get 0 )))
(func (export "f64x2_extract_lane-last" ) (param v128) (result f64)
(f64x2.extract_lane 1 (local.get 0 )))
(func (export "i64x2_replace_lane-first" ) (param v128 i64) (result v128)
(i64x2.replace_lane 0 (local.get 0 ) (local.get 1 )))
(func (export "i64x2_replace_lane-last" ) (param v128 i64) (result v128)
(i64x2.replace_lane 1 (local.get 0 ) (local.get 1 )))
(func (export "f64x2_replace_lane-first" ) (param v128 f64) (result v128)
(f64x2.replace_lane 0 (local.get 0 ) (local.get 1 )))
(func (export "f64x2_replace_lane-last" ) (param v128 f64) (result v128)
(f64x2.replace_lane 1 (local.get 0 ) (local.get 1 )))
;; Swizzle and shuffle
(func (export "v8x16_swizzle" ) (param v128 v128) (result v128)
(i8x16.swizzle (local.get 0 ) (local.get 1 )))
(func (export "v8x16_shuffle-1" ) (param v128 v128) (result v128)
(i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 (local.get 0 ) (local.get 1 )))
(func (export "v8x16_shuffle-2" ) (param v128 v128) (result v128)
(i8x16.shuffle 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 (local.get 0 ) (local.get 1 )))
(func (export "v8x16_shuffle-3" ) (param v128 v128) (result v128)
(i8x16.shuffle 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 (local.get 0 ) (local.get 1 )))
(func (export "v8x16_shuffle-4" ) (param v128 v128) (result v128)
(i8x16.shuffle 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 (local.get 0 ) (local.get 1 )))
(func (export "v8x16_shuffle-5" ) (param v128 v128) (result v128)
(i8x16.shuffle 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 (local.get 0 ) (local.get 1 )))
(func (export "v8x16_shuffle-6" ) (param v128 v128) (result v128)
(i8x16.shuffle 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 (local.get 0 ) (local.get 1 )))
(func (export "v8x16_shuffle-7" ) (param v128 v128) (result v128)
(i8x16.shuffle 0 0 0 0 0 0 0 0 16 16 16 16 16 16 16 16 (local.get 0 ) (local.get 1 )))
)`);
// ./test/core/simd/simd_lane.wast:81
assert_return(
() => invoke($0 , `i8x16_extract_lane_s-first`, [
i8x16([0 x7f, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
]),
[value("i32" , 127 )],
);
// ./test/core/simd/simd_lane.wast:82
assert_return(
() => invoke($0 , `i8x16_extract_lane_s-first`, [
i8x16([0 x7f, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
]),
[value("i32" , 127 )],
);
// ./test/core/simd/simd_lane.wast:83
assert_return(
() => invoke($0 , `i8x16_extract_lane_s-first`, [
i8x16([0 xff, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
]),
[value("i32" , -1 )],
);
// ./test/core/simd/simd_lane.wast:84
assert_return(
() => invoke($0 , `i8x16_extract_lane_s-first`, [
i8x16([0 xff, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
]),
[value("i32" , -1 )],
);
// ./test/core/simd/simd_lane.wast:85
assert_return(
() => invoke($0 , `i8x16_extract_lane_u-first`, [
i8x16([0 xff, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
]),
[value("i32" , 255 )],
);
// ./test/core/simd/simd_lane.wast:86
assert_return(
() => invoke($0 , `i8x16_extract_lane_u-first`, [
i8x16([0 xff, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
]),
[value("i32" , 255 )],
);
// ./test/core/simd/simd_lane.wast:87
assert_return(
() => invoke($0 , `i8x16_extract_lane_s-last`, [
i8x16([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x80]),
]),
[value("i32" , -128 )],
);
// ./test/core/simd/simd_lane.wast:88
assert_return(
() => invoke($0 , `i8x16_extract_lane_s-last`, [
i8x16([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x80]),
]),
[value("i32" , -128 )],
);
// ./test/core/simd/simd_lane.wast:89
assert_return(
() => invoke($0 , `i8x16_extract_lane_u-last`, [
i8x16([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 xff]),
]),
[value("i32" , 255 )],
);
// ./test/core/simd/simd_lane.wast:90
assert_return(
() => invoke($0 , `i8x16_extract_lane_u-last`, [
i8x16([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 xff]),
]),
[value("i32" , 255 )],
);
// ./test/core/simd/simd_lane.wast:91
assert_return(
() => invoke($0 , `i8x16_extract_lane_u-last`, [
i8x16([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x80]),
]),
[value("i32" , 128 )],
);
// ./test/core/simd/simd_lane.wast:92
assert_return(
() => invoke($0 , `i8x16_extract_lane_u-last`, [
i8x16([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x80]),
]),
[value("i32" , 128 )],
);
// ./test/core/simd/simd_lane.wast:94
assert_return(
() => invoke($0 , `i16x8_extract_lane_s-first`, [
i16x8([0 x7fff, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
]),
[value("i32" , 32767 )],
);
// ./test/core/simd/simd_lane.wast:95
assert_return(
() => invoke($0 , `i16x8_extract_lane_s-first`, [
i16x8([0 x7fff, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
]),
[value("i32" , 32767 )],
);
// ./test/core/simd/simd_lane.wast:96
assert_return(
() => invoke($0 , `i16x8_extract_lane_s-first`, [
i16x8([0 xffff, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
]),
[value("i32" , -1 )],
);
// ./test/core/simd/simd_lane.wast:97
assert_return(
() => invoke($0 , `i16x8_extract_lane_s-first`, [
i16x8([0 xffff, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
]),
[value("i32" , -1 )],
);
// ./test/core/simd/simd_lane.wast:98
assert_return(
() => invoke($0 , `i16x8_extract_lane_s-first`, [
i16x8([0 x3039, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
]),
[value("i32" , 12345 )],
);
// ./test/core/simd/simd_lane.wast:99
assert_return(
() => invoke($0 , `i16x8_extract_lane_s-first`, [
i16x8([0 xedcc, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
]),
[value("i32" , -4660 )],
);
// ./test/core/simd/simd_lane.wast:100
assert_return(
() => invoke($0 , `i16x8_extract_lane_u-first`, [
i16x8([0 xffff, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
]),
[value("i32" , 65535 )],
);
// ./test/core/simd/simd_lane.wast:101
assert_return(
() => invoke($0 , `i16x8_extract_lane_u-first`, [
i16x8([0 xffff, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
]),
[value("i32" , 65535 )],
);
// ./test/core/simd/simd_lane.wast:102
assert_return(
() => invoke($0 , `i16x8_extract_lane_u-first`, [
i16x8([0 x3039, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
]),
[value("i32" , 12345 )],
);
// ./test/core/simd/simd_lane.wast:103
assert_return(
() => invoke($0 , `i16x8_extract_lane_u-first`, [
i16x8([0 xedcc, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
]),
[value("i32" , 60876 )],
);
// ./test/core/simd/simd_lane.wast:104
assert_return(
() => invoke($0 , `i16x8_extract_lane_s-last`, [
i16x8([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x8000]),
]),
[value("i32" , -32768 )],
);
// ./test/core/simd/simd_lane.wast:105
assert_return(
() => invoke($0 , `i16x8_extract_lane_s-last`, [
i16x8([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x8000]),
]),
[value("i32" , -32768 )],
);
// ./test/core/simd/simd_lane.wast:106
assert_return(
() => invoke($0 , `i16x8_extract_lane_s-last`, [
i16x8([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x1a85]),
]),
[value("i32" , 6789 )],
);
// ./test/core/simd/simd_lane.wast:107
assert_return(
() => invoke($0 , `i16x8_extract_lane_s-last`, [
i16x8([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x9877]),
]),
[value("i32" , -26505 )],
);
// ./test/core/simd/simd_lane.wast:108
assert_return(
() => invoke($0 , `i16x8_extract_lane_u-last`, [
i16x8([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 xffff]),
]),
[value("i32" , 65535 )],
);
// ./test/core/simd/simd_lane.wast:109
assert_return(
() => invoke($0 , `i16x8_extract_lane_u-last`, [
i16x8([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 xffff]),
]),
[value("i32" , 65535 )],
);
// ./test/core/simd/simd_lane.wast:110
assert_return(
() => invoke($0 , `i16x8_extract_lane_u-last`, [
i16x8([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x8000]),
]),
[value("i32" , 32768 )],
);
// ./test/core/simd/simd_lane.wast:111
assert_return(
() => invoke($0 , `i16x8_extract_lane_u-last`, [
i16x8([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x8000]),
]),
[value("i32" , 32768 )],
);
// ./test/core/simd/simd_lane.wast:112
assert_return(
() => invoke($0 , `i16x8_extract_lane_u-last`, [
i16x8([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x1a85]),
]),
[value("i32" , 6789 )],
);
// ./test/core/simd/simd_lane.wast:113
assert_return(
() => invoke($0 , `i16x8_extract_lane_u-last`, [
i16x8([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x9877]),
]),
[value("i32" , 39031 )],
);
// ./test/core/simd/simd_lane.wast:115
assert_return(
() => invoke($0 , `i32x4_extract_lane-first`, [i32x4([0 x7fffffff, 0 x0, 0 x0, 0 x0])]),
[value("i32" , 2147483647 )],
);
// ./test/core/simd/simd_lane.wast:116
assert_return(
() => invoke($0 , `i32x4_extract_lane-first`, [i32x4([0 x7fffffff, 0 x0, 0 x0, 0 x0])]),
[value("i32" , 2147483647 )],
);
// ./test/core/simd/simd_lane.wast:117
assert_return(
() => invoke($0 , `i32x4_extract_lane-first`, [i32x4([0 xffffffff, 0 x0, 0 x0, 0 x0])]),
[value("i32" , -1 )],
);
// ./test/core/simd/simd_lane.wast:118
assert_return(
() => invoke($0 , `i32x4_extract_lane-first`, [i32x4([0 xffffffff, 0 x0, 0 x0, 0 x0])]),
[value("i32" , -1 )],
);
// ./test/core/simd/simd_lane.wast:119
assert_return(
() => invoke($0 , `i32x4_extract_lane-first`, [i32x4([0 x499602d2, 0 x0, 0 x0, 0 x0])]),
[value("i32" , 1234567890 )],
);
// ./test/core/simd/simd_lane.wast:120
assert_return(
() => invoke($0 , `i32x4_extract_lane-first`, [i32x4([0 xedcba988, 0 x0, 0 x0, 0 x0])]),
[value("i32" , -305419896 )],
);
// ./test/core/simd/simd_lane.wast:121
assert_return(
() => invoke($0 , `i32x4_extract_lane-last`, [i32x4([0 x0, 0 x0, 0 x0, 0 x80000000])]),
[value("i32" , -2147483648 )],
);
// ./test/core/simd/simd_lane.wast:122
assert_return(
() => invoke($0 , `i32x4_extract_lane-last`, [i32x4([0 x0, 0 x0, 0 x0, 0 x80000000])]),
[value("i32" , -2147483648 )],
);
// ./test/core/simd/simd_lane.wast:123
assert_return(
() => invoke($0 , `i32x4_extract_lane-last`, [i32x4([0 x0, 0 x0, 0 x0, 0 xffffffff])]),
[value("i32" , -1 )],
);
// ./test/core/simd/simd_lane.wast:124
assert_return(
() => invoke($0 , `i32x4_extract_lane-last`, [i32x4([0 x0, 0 x0, 0 x0, 0 xffffffff])]),
[value("i32" , -1 )],
);
// ./test/core/simd/simd_lane.wast:125
assert_return(
() => invoke($0 , `i32x4_extract_lane-last`, [i32x4([0 x0, 0 x0, 0 x0, 0 x3ade68b1])]),
[value("i32" , 987654321 )],
);
// ./test/core/simd/simd_lane.wast:126
assert_return(
() => invoke($0 , `i32x4_extract_lane-last`, [i32x4([0 x0, 0 x0, 0 x0, 0 xedcba988])]),
[value("i32" , -305419896 )],
);
// ./test/core/simd/simd_lane.wast:128
assert_return(
() => invoke($0 , `i64x2_extract_lane-first`, [i64x2([0 x7fffffffffffffffn, 0 x0n])]),
[value("i64" , 9223372036854775807 n)],
);
// ./test/core/simd/simd_lane.wast:129
assert_return(
() => invoke($0 , `i64x2_extract_lane-first`, [i64x2([0 x7ffffffffffffffen, 0 x0n])]),
[value("i64" , 9223372036854775806 n)],
);
// ./test/core/simd/simd_lane.wast:130
assert_return(
() => invoke($0 , `i64x2_extract_lane-first`, [i64x2([0 xffffffffffffffffn, 0 x0n])]),
[value("i64" , -1 n)],
);
// ./test/core/simd/simd_lane.wast:131
assert_return(
() => invoke($0 , `i64x2_extract_lane-first`, [i64x2([0 xffffffffffffffffn, 0 x0n])]),
[value("i64" , -1 n)],
);
// ./test/core/simd/simd_lane.wast:132
assert_return(
() => invoke($0 , `i64x2_extract_lane-first`, [i64x2([0 x112210f47de98115n, 0 x0n])]),
[value("i64" , 1234567890123456789 n)],
);
// ./test/core/simd/simd_lane.wast:133
assert_return(
() => invoke($0 , `i64x2_extract_lane-first`, [i64x2([0 x1234567890abcdefn, 0 x0n])]),
[value("i64" , 1311768467294899695 n)],
);
// ./test/core/simd/simd_lane.wast:134
assert_return(
() => invoke($0 , `i64x2_extract_lane-last`, [i64x2([0 x0n, 0 x8000000000000000n])]),
[value("i64" , -9223372036854775808 n)],
);
// ./test/core/simd/simd_lane.wast:135
assert_return(
() => invoke($0 , `i64x2_extract_lane-last`, [i64x2([0 x0n, 0 x8000000000000000n])]),
[value("i64" , -9223372036854775808 n)],
);
// ./test/core/simd/simd_lane.wast:136
assert_return(
() => invoke($0 , `i64x2_extract_lane-last`, [i64x2([0 x0n, 0 x8000000000000000n])]),
[value("i64" , -9223372036854775808 n)],
);
// ./test/core/simd/simd_lane.wast:137
assert_return(
() => invoke($0 , `i64x2_extract_lane-last`, [
i8x16([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 xff, 0 xff, 0 xff, 0 xff, 0 xff, 0 xff, 0 xff, 0 x7f]),
]),
[value("i64" , 9223372036854775807 n)],
);
// ./test/core/simd/simd_lane.wast:138
assert_return(
() => invoke($0 , `i64x2_extract_lane-last`, [
i16x8([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x8000]),
]),
[value("i64" , -9223372036854775808 n)],
);
// ./test/core/simd/simd_lane.wast:139
assert_return(
() => invoke($0 , `i64x2_extract_lane-last`, [
i32x4([0 x0, 0 x0, 0 xffffffff, 0 x7fffffff]),
]),
[value("i64" , 9223372036854775807 n)],
);
// ./test/core/simd/simd_lane.wast:140
assert_return(
() => invoke($0 , `i64x2_extract_lane-last`, [f64x2([-Infinity, Infinity])]),
[value("i64" , 9218868437227405312 n)],
);
// ./test/core/simd/simd_lane.wast:141
assert_return(
() => invoke($0 , `i64x2_extract_lane-last`, [i64x2([0 x0n, 0 x112210f47de98115n])]),
[value("i64" , 1234567890123456789 n)],
);
// ./test/core/simd/simd_lane.wast:142
assert_return(
() => invoke($0 , `i64x2_extract_lane-last`, [i64x2([0 x0n, 0 x1234567890abcdefn])]),
[value("i64" , 1311768467294899695 n)],
);
// ./test/core/simd/simd_lane.wast:144
assert_return(() => invoke($0 , `f32x4_extract_lane-first`, [f32x4([-5 , 0 , 0 , 0 ])]), [value("f32" , -5 )]);
// ./test/core/simd/simd_lane.wast:145
assert_return(
() => invoke($0 , `f32x4_extract_lane-first`, [
f32x4([100000000000000000000000000000000000000 , 0 , 0 , 0 ]),
]),
[value("f32" , 100000000000000000000000000000000000000 )],
);
// ./test/core/simd/simd_lane.wast:146
assert_return(
() => invoke($0 , `f32x4_extract_lane-first`, [
f32x4([340282350000000000000000000000000000000 , 0 , 0 , 0 ]),
]),
[value("f32" , 340282350000000000000000000000000000000 )],
);
// ./test/core/simd/simd_lane.wast:147
assert_return(
() => invoke($0 , `f32x4_extract_lane-first`, [
f32x4([170141180000000000000000000000000000000 , 0 , 0 , 0 ]),
]),
[value("f32" , 170141180000000000000000000000000000000 )],
);
// ./test/core/simd/simd_lane.wast:148
assert_return(
() => invoke($0 , `f32x4_extract_lane-first`, [f32x4([Infinity, 0 , 0 , 0 ])]),
[value("f32" , Infinity)],
);
// ./test/core/simd/simd_lane.wast:149
assert_return(
() => invoke($0 , `f32x4_extract_lane-first`, [
bytes('v128' , [
0 x0,
0 x0,
0 xc0,
0 x7f,
0 x0,
0 x0,
0 x80,
0 x7f,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
]),
]),
[bytes("f32" , [0 x0, 0 x0, 0 xc0, 0 x7f])],
);
// ./test/core/simd/simd_lane.wast:150
assert_return(
() => invoke($0 , `f32x4_extract_lane-first`, [
f32x4([1234567900000000000000000000 , 0 , 0 , 0 ]),
]),
[value("f32" , 1234567900000000000000000000 )],
);
// ./test/core/simd/simd_lane.wast:151
assert_return(
() => invoke($0 , `f32x4_extract_lane-first`, [f32x4([156374990000 , 0 , 0 , 0 ])]),
[value("f32" , 156374990000 )],
);
// ./test/core/simd/simd_lane.wast:152
assert_return(
() => invoke($0 , `f32x4_extract_lane-last`, [
f32x4([0 , 0 , 0 , -100000000000000000000000000000000000000 ]),
]),
[value("f32" , -100000000000000000000000000000000000000 )],
);
// ./test/core/simd/simd_lane.wast:153
assert_return(
() => invoke($0 , `f32x4_extract_lane-last`, [
f32x4([0 , 0 , 0 , -340282350000000000000000000000000000000 ]),
]),
[value("f32" , -340282350000000000000000000000000000000 )],
);
// ./test/core/simd/simd_lane.wast:154
assert_return(
() => invoke($0 , `f32x4_extract_lane-last`, [
f32x4([0 , 0 , 0 , -170141180000000000000000000000000000000 ]),
]),
[value("f32" , -170141180000000000000000000000000000000 )],
);
// ./test/core/simd/simd_lane.wast:155
assert_return(
() => invoke($0 , `f32x4_extract_lane-last`, [f32x4([0 , 0 , 0 , -Infinity])]),
[value("f32" , -Infinity)],
);
// ./test/core/simd/simd_lane.wast:156
assert_return(
() => invoke($0 , `f32x4_extract_lane-last`, [
bytes('v128' , [
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x80,
0 xff,
0 x0,
0 x0,
0 xc0,
0 x7f,
]),
]),
[bytes("f32" , [0 x0, 0 x0, 0 xc0, 0 x7f])],
);
// ./test/core/simd/simd_lane.wast:157
assert_return(
() => invoke($0 , `f32x4_extract_lane-last`, [f32x4([0 , 0 , 0 , 123456790 ])]),
[value("f32" , 123456790 )],
);
// ./test/core/simd/simd_lane.wast:158
assert_return(
() => invoke($0 , `f32x4_extract_lane-last`, [f32x4([0 , 0 , 0 , 81985530000000000 ])]),
[value("f32" , 81985530000000000 )],
);
// ./test/core/simd/simd_lane.wast:160
assert_return(() => invoke($0 , `f64x2_extract_lane-first`, [f64x2([-1 .5 , 0 ])]), [value("f64" , -1 .5 )]);
// ./test/core/simd/simd_lane.wast:161
assert_return(() => invoke($0 , `f64x2_extract_lane-first`, [f64x2([1 .5 , 0 ])]), [value("f64" , 1 .5 )]);
// ./test/core/simd/simd_lane.wast:162
assert_return(
() => invoke($0 , `f64x2_extract_lane-first`, [
f64x2([
-0 .000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017976931348623155 ,
0 ,
]),
]),
[
value("f64" , -0 .000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017976931348623155 ),
],
);
// ./test/core/simd/simd_lane.wast:163
assert_return(
() => invoke($0 , `f64x2_extract_lane-first`, [
f64x2([
0 .000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017976931348623155 ,
0 ,
]),
]),
[
value("f64" , 0 .000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017976931348623155 ),
],
);
// ./test/core/simd/simd_lane.wast:164
assert_return(
() => invoke($0 , `f64x2_extract_lane-first`, [
f64x2([
-0 .000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014 ,
0 ,
]),
]),
[
value("f64" , -0 .000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014 ),
],
);
// ./test/core/simd/simd_lane.wast:165
assert_return(
() => invoke($0 , `f64x2_extract_lane-first`, [
f64x2([
0 .000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014 ,
0 ,
]),
]),
[
value("f64" , 0 .000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014 ),
],
);
// ./test/core/simd/simd_lane.wast:166
assert_return(
() => invoke($0 , `f64x2_extract_lane-first`, [f64x2([-Infinity, 0 ])]),
[value("f64" , -Infinity)],
);
// ./test/core/simd/simd_lane.wast:167
assert_return(
() => invoke($0 , `f64x2_extract_lane-first`, [f64x2([Infinity, 0 ])]),
[value("f64" , Infinity)],
);
// ./test/core/simd/simd_lane.wast:168
assert_return(
() => invoke($0 , `f64x2_extract_lane-first`, [
bytes('v128' , [
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 xf8,
0 xff,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x80,
]),
]),
[bytes("f64" , [0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 xf8, 0 xff])],
);
// ./test/core/simd/simd_lane.wast:169
assert_return(
() => invoke($0 , `f64x2_extract_lane-first`, [
bytes('v128' , [
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 xf8,
0 x7f,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
]),
]),
[bytes("f64" , [0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 xf8, 0 x7f])],
);
// ./test/core/simd/simd_lane.wast:170
assert_return(
() => invoke($0 , `f64x2_extract_lane-first`, [
f64x2([1234567890123456900000000000 , 0 ]),
]),
[value("f64" , 1234567890123456900000000000 )],
);
// ./test/core/simd/simd_lane.wast:171
assert_return(
() => invoke($0 , `f64x2_extract_lane-first`, [f64x2([2623536934927580700 , 0 ])]),
[value("f64" , 2623536934927580700 )],
);
// ./test/core/simd/simd_lane.wast:172
assert_return(() => invoke($0 , `f64x2_extract_lane-last`, [f64x2([0 , 2 .25 ])]), [value("f64" , 2 .25 )]);
// ./test/core/simd/simd_lane.wast:173
assert_return(() => invoke($0 , `f64x2_extract_lane-last`, [f64x2([0 , -2 .25 ])]), [value("f64" , -2 .25 )]);
// ./test/core/simd/simd_lane.wast:174
assert_return(
() => invoke($0 , `f64x2_extract_lane-last`, [
f64x2([
0 ,
-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 ,
]),
]),
[
value("f64" , -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 ),
],
);
// ./test/core/simd/simd_lane.wast:175
assert_return(
() => invoke($0 , `f64x2_extract_lane-last`, [
f64x2([
0 ,
179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 ,
]),
]),
[
value("f64" , 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 ),
],
);
// ./test/core/simd/simd_lane.wast:176
assert_return(
() => invoke($0 , `f64x2_extract_lane-last`, [
f64x2([
0 ,
-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 ,
]),
]),
[
value("f64" , -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 ),
],
);
// ./test/core/simd/simd_lane.wast:177
assert_return(
() => invoke($0 , `f64x2_extract_lane-last`, [
f64x2([
0 ,
179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 ,
]),
]),
[
value("f64" , 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 ),
],
);
// ./test/core/simd/simd_lane.wast:178
assert_return(
() => invoke($0 , `f64x2_extract_lane-last`, [f64x2([-0 , -Infinity])]),
[value("f64" , -Infinity)],
);
// ./test/core/simd/simd_lane.wast:179
assert_return(
() => invoke($0 , `f64x2_extract_lane-last`, [f64x2([0 , Infinity])]),
[value("f64" , Infinity)],
);
// ./test/core/simd/simd_lane.wast:180
assert_return(
() => invoke($0 , `f64x2_extract_lane-last`, [
bytes('v128' , [
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x80,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 xf8,
0 xff,
]),
]),
[bytes("f64" , [0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 xf8, 0 xff])],
);
// ./test/core/simd/simd_lane.wast:181
assert_return(
() => invoke($0 , `f64x2_extract_lane-last`, [
bytes('v128' , [
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 xf8,
0 x7f,
]),
]),
[bytes("f64" , [0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 xf8, 0 x7f])],
);
// ./test/core/simd/simd_lane.wast:182
assert_return(
() => invoke($0 , `f64x2_extract_lane-last`, [f64x2([0 , 123456789 ])]),
[value("f64" , 123456789 )],
);
// ./test/core/simd/simd_lane.wast:183
assert_return(
() => invoke($0 , `f64x2_extract_lane-last`, [f64x2([0 , 1375488932539311400000000 ])]),
[value("f64" , 1375488932539311400000000 )],
);
// ./test/core/simd/simd_lane.wast:185
assert_return(
() => invoke($0 , `f64x2_extract_lane-last`, [
i8x16([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
]),
[value("f64" , 0 )],
);
// ./test/core/simd/simd_lane.wast:186
assert_return(
() => invoke($0 , `f64x2_extract_lane-last`, [
i8x16([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x80]),
]),
[value("f64" , -0 )],
);
// ./test/core/simd/simd_lane.wast:187
assert_return(
() => invoke($0 , `f64x2_extract_lane-last`, [
i16x8([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x4000]),
]),
[value("f64" , 2 )],
);
// ./test/core/simd/simd_lane.wast:188
assert_return(
() => invoke($0 , `f64x2_extract_lane-last`, [
i16x8([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 xc000]),
]),
[value("f64" , -2 )],
);
// ./test/core/simd/simd_lane.wast:189
assert_return(
() => invoke($0 , `f64x2_extract_lane-last`, [
i32x4([0 x0, 0 x0, 0 xffffffff, 0 x7fefffff]),
]),
[
value("f64" , 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 ),
],
);
// ./test/core/simd/simd_lane.wast:190
assert_return(
() => invoke($0 , `f64x2_extract_lane-last`, [i32x4([0 x0, 0 x0, 0 x0, 0 x100000])]),
[
value("f64" , 0 .000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014 ),
],
);
// ./test/core/simd/simd_lane.wast:191
assert_return(
() => invoke($0 , `f64x2_extract_lane-last`, [i32x4([0 x0, 0 x0, 0 xffffffff, 0 xfffff])]),
[
value("f64" , 0 .00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201 ),
],
);
// ./test/core/simd/simd_lane.wast:192
assert_return(
() => invoke($0 , `f64x2_extract_lane-last`, [i32x4([0 x0, 0 x0, 0 x1, 0 x0])]),
[
value("f64" , 0 .000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005 ),
],
);
// ./test/core/simd/simd_lane.wast:194
assert_return(
() => invoke($0 , `i8x16_replace_lane-first`, [
i8x16([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
127 ,
]),
[
i8x16([0 x7f, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
],
);
// ./test/core/simd/simd_lane.wast:195
assert_return(
() => invoke($0 , `i8x16_replace_lane-first`, [
i8x16([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
128 ,
]),
[
i8x16([0 x80, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
],
);
// ./test/core/simd/simd_lane.wast:196
assert_return(
() => invoke($0 , `i8x16_replace_lane-first`, [
i8x16([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
255 ,
]),
[
i8x16([0 xff, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
],
);
// ./test/core/simd/simd_lane.wast:197
assert_return(
() => invoke($0 , `i8x16_replace_lane-first`, [
i8x16([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
256 ,
]),
[
i8x16([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
],
);
// ./test/core/simd/simd_lane.wast:198
assert_return(
() => invoke($0 , `i8x16_replace_lane-last`, [
i8x16([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
-128 ,
]),
[
i8x16([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x80]),
],
);
// ./test/core/simd/simd_lane.wast:199
assert_return(
() => invoke($0 , `i8x16_replace_lane-last`, [
i8x16([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
-129 ,
]),
[
i8x16([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x7f]),
],
);
// ./test/core/simd/simd_lane.wast:200
assert_return(
() => invoke($0 , `i8x16_replace_lane-last`, [
i8x16([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
32767 ,
]),
[
i8x16([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 xff]),
],
);
// ./test/core/simd/simd_lane.wast:201
assert_return(
() => invoke($0 , `i8x16_replace_lane-last`, [
i8x16([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
-32768 ,
]),
[
i8x16([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
],
);
// ./test/core/simd/simd_lane.wast:203
assert_return(
() => invoke($0 , `i16x8_replace_lane-first`, [
i16x8([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
32767 ,
]),
[i16x8([0 x7fff, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0])],
);
// ./test/core/simd/simd_lane.wast:204
assert_return(
() => invoke($0 , `i16x8_replace_lane-first`, [
i16x8([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
32768 ,
]),
[i16x8([0 x8000, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0])],
);
// ./test/core/simd/simd_lane.wast:205
assert_return(
() => invoke($0 , `i16x8_replace_lane-first`, [
i16x8([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
65535 ,
]),
[i16x8([0 xffff, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0])],
);
// ./test/core/simd/simd_lane.wast:206
assert_return(
() => invoke($0 , `i16x8_replace_lane-first`, [
i16x8([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
65536 ,
]),
[i16x8([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0])],
);
// ./test/core/simd/simd_lane.wast:207
assert_return(
() => invoke($0 , `i16x8_replace_lane-first`, [
i16x8([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
12345 ,
]),
[i16x8([0 x3039, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0])],
);
// ./test/core/simd/simd_lane.wast:208
assert_return(
() => invoke($0 , `i16x8_replace_lane-first`, [
i16x8([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
-4660 ,
]),
[i16x8([0 xedcc, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0])],
);
// ./test/core/simd/simd_lane.wast:209
assert_return(
() => invoke($0 , `i16x8_replace_lane-last`, [
i16x8([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
-32768 ,
]),
[i16x8([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x8000])],
);
// ./test/core/simd/simd_lane.wast:210
assert_return(
() => invoke($0 , `i16x8_replace_lane-last`, [
i16x8([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
-32769 ,
]),
[i16x8([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x7fff])],
);
// ./test/core/simd/simd_lane.wast:211
assert_return(
() => invoke($0 , `i16x8_replace_lane-last`, [
i16x8([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
2147483647 ,
]),
[i16x8([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 xffff])],
);
// ./test/core/simd/simd_lane.wast:212
assert_return(
() => invoke($0 , `i16x8_replace_lane-last`, [
i16x8([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
-2147483648 ,
]),
[i16x8([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0])],
);
// ./test/core/simd/simd_lane.wast:213
assert_return(
() => invoke($0 , `i16x8_replace_lane-last`, [
i16x8([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
54321 ,
]),
[i16x8([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 xd431])],
);
// ./test/core/simd/simd_lane.wast:214
assert_return(
() => invoke($0 , `i16x8_replace_lane-last`, [
i16x8([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
-17185 ,
]),
[i16x8([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 xbcdf])],
);
// ./test/core/simd/simd_lane.wast:216
assert_return(
() => invoke($0 , `i32x4_replace_lane-first`, [
i32x4([0 x0, 0 x0, 0 x0, 0 x0]),
2147483647 ,
]),
[i32x4([0 x7fffffff, 0 x0, 0 x0, 0 x0])],
);
// ./test/core/simd/simd_lane.wast:217
assert_return(
() => invoke($0 , `i32x4_replace_lane-first`, [i32x4([0 x0, 0 x0, 0 x0, 0 x0]), -1 ]),
[i32x4([0 xffffffff, 0 x0, 0 x0, 0 x0])],
);
// ./test/core/simd/simd_lane.wast:218
assert_return(
() => invoke($0 , `i32x4_replace_lane-first`, [
i32x4([0 x0, 0 x0, 0 x0, 0 x0]),
1234567890 ,
]),
[i32x4([0 x499602d2, 0 x0, 0 x0, 0 x0])],
);
// ./test/core/simd/simd_lane.wast:219
assert_return(
() => invoke($0 , `i32x4_replace_lane-first`, [
i32x4([0 x0, 0 x0, 0 x0, 0 x0]),
-305419896 ,
]),
[i32x4([0 xedcba988, 0 x0, 0 x0, 0 x0])],
);
// ./test/core/simd/simd_lane.wast:220
assert_return(
() => invoke($0 , `i32x4_replace_lane-last`, [
i32x4([0 x0, 0 x0, 0 x0, 0 x0]),
-2147483648 ,
]),
[i32x4([0 x0, 0 x0, 0 x0, 0 x80000000])],
);
// ./test/core/simd/simd_lane.wast:221
assert_return(
() => invoke($0 , `i32x4_replace_lane-last`, [
i32x4([0 x0, 0 x0, 0 x0, 0 x0]),
-2147483648 ,
]),
[i32x4([0 x0, 0 x0, 0 x0, 0 x80000000])],
);
// ./test/core/simd/simd_lane.wast:222
assert_return(
() => invoke($0 , `i32x4_replace_lane-last`, [i32x4([0 x0, 0 x0, 0 x0, 0 x0]), 1234567890 ]),
[i32x4([0 x0, 0 x0, 0 x0, 0 x499602d2])],
);
// ./test/core/simd/simd_lane.wast:223
assert_return(
() => invoke($0 , `i32x4_replace_lane-last`, [i32x4([0 x0, 0 x0, 0 x0, 0 x0]), -305419896 ]),
[i32x4([0 x0, 0 x0, 0 x0, 0 xedcba988])],
);
// ./test/core/simd/simd_lane.wast:225
assert_return(
() => invoke($0 , `f32x4_replace_lane-first`, [f32x4([0 , 0 , 0 , 0 ]), value("f32" , 53 )]),
[
new F32x4Pattern(
value("f32" , 53 ),
value("f32" , 0 ),
value("f32" , 0 ),
value("f32" , 0 ),
),
],
);
// ./test/core/simd/simd_lane.wast:226
assert_return(
() => invoke($0 , `f32x4_replace_lane-first`, [
i32x4([0 x0, 0 x0, 0 x0, 0 x0]),
value("f32" , 53 ),
]),
[
new F32x4Pattern(
value("f32" , 53 ),
value("f32" , 0 ),
value("f32" , 0 ),
value("f32" , 0 ),
),
],
);
// ./test/core/simd/simd_lane.wast:227
assert_return(
() => invoke($0 , `f32x4_replace_lane-first`, [
f32x4([0 , 0 , 0 , 0 ]),
bytes("f32" , [0 x0, 0 x0, 0 xc0, 0 x7f]),
]),
[
new F32x4Pattern(
bytes("f32" , [0 x0, 0 x0, 0 xc0, 0 x7f]),
value("f32" , 0 ),
value("f32" , 0 ),
value("f32" , 0 ),
),
],
);
// ./test/core/simd/simd_lane.wast:228
assert_return(
() => invoke($0 , `f32x4_replace_lane-first`, [
f32x4([0 , 0 , 0 , 0 ]),
value("f32" , Infinity),
]),
[
new F32x4Pattern(
value("f32" , Infinity),
value("f32" , 0 ),
value("f32" , 0 ),
value("f32" , 0 ),
),
],
);
// ./test/core/simd/simd_lane.wast:229
assert_return(
() => invoke($0 , `f32x4_replace_lane-first`, [
bytes('v128' , [
0 x0,
0 x0,
0 xc0,
0 x7f,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
]),
value("f32" , 3 .14 ),
]),
[
new F32x4Pattern(
value("f32" , 3 .14 ),
value("f32" , 0 ),
value("f32" , 0 ),
value("f32" , 0 ),
),
],
);
// ./test/core/simd/simd_lane.wast:230
assert_return(
() => invoke($0 , `f32x4_replace_lane-first`, [
f32x4([Infinity, 0 , 0 , 0 ]),
value("f32" , 100000000000000000000000000000000000000 ),
]),
[
new F32x4Pattern(
value("f32" , 100000000000000000000000000000000000000 ),
value("f32" , 0 ),
value("f32" , 0 ),
value("f32" , 0 ),
),
],
);
// ./test/core/simd/simd_lane.wast:231
assert_return(
() => invoke($0 , `f32x4_replace_lane-first`, [
f32x4([Infinity, 0 , 0 , 0 ]),
value("f32" , 340282350000000000000000000000000000000 ),
]),
[
new F32x4Pattern(
value("f32" , 340282350000000000000000000000000000000 ),
value("f32" , 0 ),
value("f32" , 0 ),
value("f32" , 0 ),
),
],
);
// ./test/core/simd/simd_lane.wast:232
assert_return(
() => invoke($0 , `f32x4_replace_lane-first`, [
f32x4([Infinity, 0 , 0 , 0 ]),
value("f32" , 170141180000000000000000000000000000000 ),
]),
[
new F32x4Pattern(
value("f32" , 170141180000000000000000000000000000000 ),
value("f32" , 0 ),
value("f32" , 0 ),
value("f32" , 0 ),
),
],
);
// ./test/core/simd/simd_lane.wast:233
assert_return(
() => invoke($0 , `f32x4_replace_lane-first`, [
f32x4([0 , 0 , 0 , 0 ]),
value("f32" , 123456790 ),
]),
[
new F32x4Pattern(
value("f32" , 123456790 ),
value("f32" , 0 ),
value("f32" , 0 ),
value("f32" , 0 ),
),
],
);
// ./test/core/simd/simd_lane.wast:234
assert_return(
() => invoke($0 , `f32x4_replace_lane-first`, [
f32x4([0 , 0 , 0 , 0 ]),
value("f32" , 123456790 ),
]),
[
new F32x4Pattern(
value("f32" , 123456790 ),
value("f32" , 0 ),
value("f32" , 0 ),
value("f32" , 0 ),
),
],
);
// ./test/core/simd/simd_lane.wast:235
assert_return(
() => invoke($0 , `f32x4_replace_lane-first`, [
f32x4([0 , 0 , 0 , 0 ]),
value("f32" , 81985530000000000 ),
]),
[
new F32x4Pattern(
value("f32" , 81985530000000000 ),
value("f32" , 0 ),
value("f32" , 0 ),
value("f32" , 0 ),
),
],
);
// ./test/core/simd/simd_lane.wast:236
assert_return(
() => invoke($0 , `f32x4_replace_lane-first`, [
f32x4([0 , 0 , 0 , 0 ]),
value("f32" , 81985530000000000 ),
]),
[
new F32x4Pattern(
value("f32" , 81985530000000000 ),
value("f32" , 0 ),
value("f32" , 0 ),
value("f32" , 0 ),
),
],
);
// ./test/core/simd/simd_lane.wast:237
assert_return(
() => invoke($0 , `f32x4_replace_lane-last`, [f32x4([0 , 0 , 0 , 0 ]), value("f32" , -53 )]),
[
new F32x4Pattern(
value("f32" , 0 ),
value("f32" , 0 ),
value("f32" , 0 ),
value("f32" , -53 ),
),
],
);
// ./test/core/simd/simd_lane.wast:238
assert_return(
() => invoke($0 , `f32x4_replace_lane-last`, [
i32x4([0 x0, 0 x0, 0 x0, 0 x0]),
value("f32" , -53 ),
]),
[
new F32x4Pattern(
value("f32" , 0 ),
value("f32" , 0 ),
value("f32" , 0 ),
value("f32" , -53 ),
),
],
);
// ./test/core/simd/simd_lane.wast:239
assert_return(
() => invoke($0 , `f32x4_replace_lane-last`, [
f32x4([0 , 0 , 0 , 0 ]),
bytes("f32" , [0 x0, 0 x0, 0 xc0, 0 x7f]),
]),
[
new F32x4Pattern(
value("f32" , 0 ),
value("f32" , 0 ),
value("f32" , 0 ),
bytes("f32" , [0 x0, 0 x0, 0 xc0, 0 x7f]),
),
],
);
// ./test/core/simd/simd_lane.wast:240
assert_return(
() => invoke($0 , `f32x4_replace_lane-last`, [
f32x4([0 , 0 , 0 , 0 ]),
value("f32" , -Infinity),
]),
[
new F32x4Pattern(
value("f32" , 0 ),
value("f32" , 0 ),
value("f32" , 0 ),
value("f32" , -Infinity),
),
],
);
// ./test/core/simd/simd_lane.wast:241
assert_return(
() => invoke($0 , `f32x4_replace_lane-last`, [
bytes('v128' , [
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 xc0,
0 x7f,
]),
value("f32" , 3 .14 ),
]),
[
new F32x4Pattern(
value("f32" , 0 ),
value("f32" , 0 ),
value("f32" , 0 ),
value("f32" , 3 .14 ),
),
],
);
// ./test/core/simd/simd_lane.wast:242
assert_return(
() => invoke($0 , `f32x4_replace_lane-last`, [
f32x4([0 , 0 , 0 , -Infinity]),
value("f32" , -100000000000000000000000000000000000000 ),
]),
[
new F32x4Pattern(
value("f32" , 0 ),
value("f32" , 0 ),
value("f32" , 0 ),
value("f32" , -100000000000000000000000000000000000000 ),
),
],
);
// ./test/core/simd/simd_lane.wast:243
assert_return(
() => invoke($0 , `f32x4_replace_lane-last`, [
f32x4([0 , 0 , 0 , -Infinity]),
value("f32" , -340282350000000000000000000000000000000 ),
]),
[
new F32x4Pattern(
value("f32" , 0 ),
value("f32" , 0 ),
value("f32" , 0 ),
value("f32" , -340282350000000000000000000000000000000 ),
),
],
);
// ./test/core/simd/simd_lane.wast:244
assert_return(
() => invoke($0 , `f32x4_replace_lane-last`, [
f32x4([0 , 0 , 0 , -Infinity]),
value("f32" , -170141180000000000000000000000000000000 ),
]),
[
new F32x4Pattern(
value("f32" , 0 ),
value("f32" , 0 ),
value("f32" , 0 ),
value("f32" , -170141180000000000000000000000000000000 ),
),
],
);
// ./test/core/simd/simd_lane.wast:245
assert_return(
() => invoke($0 , `f32x4_replace_lane-last`, [
f32x4([0 , 0 , 0 , 0 ]),
value("f32" , 1234567900000000000000000000 ),
]),
[
new F32x4Pattern(
value("f32" , 0 ),
value("f32" , 0 ),
value("f32" , 0 ),
value("f32" , 1234567900000000000000000000 ),
),
],
);
// ./test/core/simd/simd_lane.wast:246
assert_return(
() => invoke($0 , `f32x4_replace_lane-last`, [
f32x4([0 , 0 , 0 , 0 ]),
value("f32" , 1234567900000000000000000000 ),
]),
[
new F32x4Pattern(
value("f32" , 0 ),
value("f32" , 0 ),
value("f32" , 0 ),
value("f32" , 1234567900000000000000000000 ),
),
],
);
// ./test/core/simd/simd_lane.wast:247
assert_return(
() => invoke($0 , `f32x4_replace_lane-last`, [
f32x4([0 , 0 , 0 , 0 ]),
value("f32" , 42984030000000000000000 ),
]),
[
new F32x4Pattern(
value("f32" , 0 ),
value("f32" , 0 ),
value("f32" , 0 ),
value("f32" , 42984030000000000000000 ),
),
],
);
// ./test/core/simd/simd_lane.wast:248
assert_return(
() => invoke($0 , `f32x4_replace_lane-last`, [
f32x4([0 , 0 , 0 , 0 ]),
value("f32" , 156374990000 ),
]),
[
new F32x4Pattern(
value("f32" , 0 ),
value("f32" , 0 ),
value("f32" , 0 ),
value("f32" , 156374990000 ),
),
],
);
// ./test/core/simd/simd_lane.wast:250
assert_return(
() => invoke($0 , `i64x2_replace_lane-first`, [
i64x2([0 x0n, 0 x0n]),
9223372036854775807 n,
]),
[i64x2([0 x7fffffffffffffffn, 0 x0n])],
);
// ./test/core/simd/simd_lane.wast:251
assert_return(
() => invoke($0 , `i64x2_replace_lane-first`, [i64x2([0 x0n, 0 x0n]), -1 n]),
[i64x2([0 xffffffffffffffffn, 0 x0n])],
);
// ./test/core/simd/simd_lane.wast:252
assert_return(
() => invoke($0 , `i64x2_replace_lane-first`, [
i64x2([0 x0n, 0 x0n]),
1234567890123456789 n,
]),
[i64x2([0 x112210f47de98115n, 0 x0n])],
);
// ./test/core/simd/simd_lane.wast:253
assert_return(
() => invoke($0 , `i64x2_replace_lane-first`, [
i64x2([0 x0n, 0 x0n]),
1311768467294899695 n,
]),
[i64x2([0 x1234567890abcdefn, 0 x0n])],
);
// ./test/core/simd/simd_lane.wast:254
assert_return(
() => invoke($0 , `i64x2_replace_lane-last`, [
i64x2([0 x0n, 0 x0n]),
-9223372036854775808 n,
]),
[i64x2([0 x0n, 0 x8000000000000000n])],
);
// ./test/core/simd/simd_lane.wast:255
assert_return(
() => invoke($0 , `i64x2_replace_lane-last`, [
i64x2([0 x0n, 0 x0n]),
-9223372036854775808 n,
]),
[i64x2([0 x0n, 0 x8000000000000000n])],
);
// ./test/core/simd/simd_lane.wast:256
assert_return(
() => invoke($0 , `i64x2_replace_lane-last`, [
i64x2([0 x0n, 0 x0n]),
1234567890123456789 n,
]),
[i64x2([0 x0n, 0 x112210f47de98115n])],
);
// ./test/core/simd/simd_lane.wast:257
assert_return(
() => invoke($0 , `i64x2_replace_lane-last`, [
i64x2([0 x0n, 0 x0n]),
1311768467294899695 n,
]),
[i64x2([0 x0n, 0 x1234567890abcdefn])],
);
// ./test/core/simd/simd_lane.wast:259
assert_return(
() => invoke($0 , `f64x2_replace_lane-first`, [f64x2([1 , 1 ]), value("f64" , 0 )]),
[new F64x2Pattern(value("f64" , 0 ), value("f64" , 1 ))],
);
// ./test/core/simd/simd_lane.wast:260
assert_return(
() => invoke($0 , `f64x2_replace_lane-first`, [f64x2([-1 , -1 ]), value("f64" , -0 )]),
[new F64x2Pattern(value("f64" , -0 ), value("f64" , -1 ))],
);
// ./test/core/simd/simd_lane.wast:261
assert_return(
() => invoke($0 , `f64x2_replace_lane-first`, [f64x2([0 , 0 ]), value("f64" , 1 .25 )]),
[new F64x2Pattern(value("f64" , 1 .25 ), value("f64" , 0 ))],
);
// ./test/core/simd/simd_lane.wast:262
assert_return(
() => invoke($0 , `f64x2_replace_lane-first`, [f64x2([0 , 0 ]), value("f64" , -1 .25 )]),
[new F64x2Pattern(value("f64" , -1 .25 ), value("f64" , 0 ))],
);
// ./test/core/simd/simd_lane.wast:263
assert_return(
() => invoke($0 , `f64x2_replace_lane-first`, [
bytes('v128' , [
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 xf8,
0 xff,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
]),
value("f64" , -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 ),
]),
[
new F64x2Pattern(
value("f64" , -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 ),
value("f64" , 0 ),
),
],
);
// ./test/core/simd/simd_lane.wast:264
assert_return(
() => invoke($0 , `f64x2_replace_lane-first`, [
bytes('v128' , [
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 xf8,
0 x7f,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
]),
value("f64" , 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 ),
]),
[
new F64x2Pattern(
value("f64" , 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 ),
value("f64" , 0 ),
),
],
);
// ./test/core/simd/simd_lane.wast:265
assert_return(
() => invoke($0 , `f64x2_replace_lane-first`, [
f64x2([-Infinity, 0 ]),
value("f64" , -0 .000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014 ),
]),
[
new F64x2Pattern(
value("f64" , -0 .000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014 ),
value("f64" , 0 ),
),
],
);
// ./test/core/simd/simd_lane.wast:266
assert_return(
() => invoke($0 , `f64x2_replace_lane-first`, [
f64x2([Infinity, 0 ]),
value("f64" , 0 .000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014 ),
]),
[
new F64x2Pattern(
value("f64" , 0 .000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014 ),
value("f64" , 0 ),
),
],
);
// ./test/core/simd/simd_lane.wast:267
assert_return(
() => invoke($0 , `f64x2_replace_lane-first`, [
f64x2([0 , 0 ]),
bytes("f64" , [0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 xf8, 0 xff]),
]),
[
new F64x2Pattern(
bytes("f64" , [0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 xf8, 0 xff]),
value("f64" , 0 ),
),
],
);
// ./test/core/simd/simd_lane.wast:268
assert_return(
() => invoke($0 , `f64x2_replace_lane-first`, [
f64x2([0 , 0 ]),
bytes("f64" , [0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 xf8, 0 x7f]),
]),
[
new F64x2Pattern(
bytes("f64" , [0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 xf8, 0 x7f]),
value("f64" , 0 ),
),
],
);
// ./test/core/simd/simd_lane.wast:269
assert_return(
() => invoke($0 , `f64x2_replace_lane-first`, [f64x2([0 , 0 ]), value("f64" , -Infinity)]),
[new F64x2Pattern(value("f64" , -Infinity), value("f64" , 0 ))],
);
// ./test/core/simd/simd_lane.wast:270
assert_return(
() => invoke($0 , `f64x2_replace_lane-first`, [f64x2([0 , 0 ]), value("f64" , Infinity)]),
[new F64x2Pattern(value("f64" , Infinity), value("f64" , 0 ))],
);
// ./test/core/simd/simd_lane.wast:271
assert_return(
() => invoke($0 , `f64x2_replace_lane-first`, [f64x2([0 , 0 ]), value("f64" , 123456789 )]),
[new F64x2Pattern(value("f64" , 123456789 ), value("f64" , 0 ))],
);
// ./test/core/simd/simd_lane.wast:272
assert_return(
() => invoke($0 , `f64x2_replace_lane-first`, [f64x2([0 , 0 ]), value("f64" , 123456789 )]),
[new F64x2Pattern(value("f64" , 123456789 ), value("f64" , 0 ))],
);
// ./test/core/simd/simd_lane.wast:273
assert_return(
() => invoke($0 , `f64x2_replace_lane-first`, [
f64x2([0 , 0 ]),
value("f64" , 1375488932539311400000000 ),
]),
[new F64x2Pattern(value("f64" , 1375488932539311400000000 ), value("f64" , 0 ))],
);
// ./test/core/simd/simd_lane.wast:274
assert_return(
() => invoke($0 , `f64x2_replace_lane-first`, [
f64x2([0 , 0 ]),
value("f64" , 1375488932539311400000000 ),
]),
[new F64x2Pattern(value("f64" , 1375488932539311400000000 ), value("f64" , 0 ))],
);
// ./test/core/simd/simd_lane.wast:275
assert_return(
() => invoke($0 , `f64x2_replace_lane-last`, [f64x2([2 , 2 ]), value("f64" , 0 )]),
[new F64x2Pattern(value("f64" , 2 ), value("f64" , 0 ))],
);
// ./test/core/simd/simd_lane.wast:276
assert_return(
() => invoke($0 , `f64x2_replace_lane-last`, [f64x2([-2 , -2 ]), value("f64" , -0 )]),
[new F64x2Pattern(value("f64" , -2 ), value("f64" , -0 ))],
);
// ./test/core/simd/simd_lane.wast:277
assert_return(
() => invoke($0 , `f64x2_replace_lane-last`, [f64x2([0 , 0 ]), value("f64" , 2 .25 )]),
[new F64x2Pattern(value("f64" , 0 ), value("f64" , 2 .25 ))],
);
// ./test/core/simd/simd_lane.wast:278
assert_return(
() => invoke($0 , `f64x2_replace_lane-last`, [f64x2([0 , 0 ]), value("f64" , -2 .25 )]),
[new F64x2Pattern(value("f64" , 0 ), value("f64" , -2 .25 ))],
);
// ./test/core/simd/simd_lane.wast:279
assert_return(
() => invoke($0 , `f64x2_replace_lane-last`, [
bytes('v128' , [
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 xf8,
0 xff,
]),
value("f64" , -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 ),
]),
[
new F64x2Pattern(
value("f64" , 0 ),
value("f64" , -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 ),
),
],
);
// ./test/core/simd/simd_lane.wast:280
assert_return(
() => invoke($0 , `f64x2_replace_lane-last`, [
bytes('v128' , [
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 xf8,
0 x7f,
]),
value("f64" , 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 ),
]),
[
new F64x2Pattern(
value("f64" , 0 ),
value("f64" , 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 ),
),
],
);
// ./test/core/simd/simd_lane.wast:281
assert_return(
() => invoke($0 , `f64x2_replace_lane-last`, [
f64x2([0 , -Infinity]),
value("f64" , -0 .000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014 ),
]),
[
new F64x2Pattern(
value("f64" , 0 ),
value("f64" , -0 .000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014 ),
),
],
);
// ./test/core/simd/simd_lane.wast:282
assert_return(
() => invoke($0 , `f64x2_replace_lane-last`, [
f64x2([0 , Infinity]),
value("f64" , 0 .000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014 ),
]),
[
new F64x2Pattern(
value("f64" , 0 ),
value("f64" , 0 .000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014 ),
),
],
);
// ./test/core/simd/simd_lane.wast:283
assert_return(
() => invoke($0 , `f64x2_replace_lane-last`, [
f64x2([0 , 0 ]),
bytes("f64" , [0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 xf8, 0 xff]),
]),
[
new F64x2Pattern(
value("f64" , 0 ),
bytes("f64" , [0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 xf8, 0 xff]),
),
],
);
// ./test/core/simd/simd_lane.wast:284
assert_return(
() => invoke($0 , `f64x2_replace_lane-last`, [
f64x2([0 , 0 ]),
bytes("f64" , [0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 xf8, 0 x7f]),
]),
[
new F64x2Pattern(
value("f64" , 0 ),
bytes("f64" , [0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 xf8, 0 x7f]),
),
],
);
// ./test/core/simd/simd_lane.wast:285
assert_return(
() => invoke($0 , `f64x2_replace_lane-last`, [f64x2([0 , 0 ]), value("f64" , -Infinity)]),
[new F64x2Pattern(value("f64" , 0 ), value("f64" , -Infinity))],
);
// ./test/core/simd/simd_lane.wast:286
assert_return(
() => invoke($0 , `f64x2_replace_lane-last`, [f64x2([0 , 0 ]), value("f64" , Infinity)]),
[new F64x2Pattern(value("f64" , 0 ), value("f64" , Infinity))],
);
// ./test/core/simd/simd_lane.wast:287
assert_return(
() => invoke($0 , `f64x2_replace_lane-last`, [
f64x2([0 , 0 ]),
value("f64" , 1234567890000000000000000000 ),
]),
[
new F64x2Pattern(value("f64" , 0 ), value("f64" , 1234567890000000000000000000 )),
],
);
// ./test/core/simd/simd_lane.wast:288
assert_return(
() => invoke($0 , `f64x2_replace_lane-last`, [
f64x2([0 , 0 ]),
value("f64" , 1234567890000000000000000000 ),
]),
[
new F64x2Pattern(value("f64" , 0 ), value("f64" , 1234567890000000000000000000 )),
],
);
// ./test/core/simd/simd_lane.wast:289
assert_return(
() => invoke($0 , `f64x2_replace_lane-last`, [
f64x2([0 , 0 ]),
value("f64" , 1234567890000000000000000000 ),
]),
[
new F64x2Pattern(value("f64" , 0 ), value("f64" , 1234567890000000000000000000 )),
],
);
// ./test/core/simd/simd_lane.wast:290
assert_return(
() => invoke($0 , `f64x2_replace_lane-last`, [
f64x2([0 , 0 ]),
value("f64" , 0 .0000000000123456789 ),
]),
[new F64x2Pattern(value("f64" , 0 ), value("f64" , 0 .0000000000123456789 ))],
);
// ./test/core/simd/simd_lane.wast:292
assert_return(
() => invoke($0 , `v8x16_swizzle`, [
i8x16([0 x10, 0 x11, 0 x12, 0 x13, 0 x14, 0 x15, 0 x16, 0 x17, 0 x18, 0 x19, 0 x1a, 0 x1b, 0 x1c, 0 x1d, 0 x1e, 0 x1f]),
i8x16([0 x0, 0 x1, 0 x2, 0 x3, 0 x4, 0 x5, 0 x6, 0 x7, 0 x8, 0 x9, 0 xa, 0 xb, 0 xc, 0 xd, 0 xe, 0 xf]),
]),
[
i8x16([0 x10, 0 x11, 0 x12, 0 x13, 0 x14, 0 x15, 0 x16, 0 x17, 0 x18, 0 x19, 0 x1a, 0 x1b, 0 x1c, 0 x1d, 0 x1e, 0 x1f]),
],
);
// ./test/core/simd/simd_lane.wast:296
assert_return(
() => invoke($0 , `v8x16_swizzle`, [
i8x16([0 xf0, 0 xf1, 0 xf2, 0 xf3, 0 xf4, 0 xf5, 0 xf6, 0 xf7, 0 xf8, 0 xf9, 0 xfa, 0 xfb, 0 xfc, 0 xfd, 0 xfe, 0 xff]),
i8x16([0 xf8, 0 xf9, 0 xfa, 0 xfb, 0 xfc, 0 xfd, 0 xfe, 0 xff, 0 x10, 0 x11, 0 x12, 0 x13, 0 x14, 0 x15, 0 x16, 0 x17]),
]),
[
i8x16([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
],
);
// ./test/core/simd/simd_lane.wast:300
assert_return(
() => invoke($0 , `v8x16_swizzle`, [
i8x16([0 x64, 0 x65, 0 x66, 0 x67, 0 x68, 0 x69, 0 x6a, 0 x6b, 0 x6c, 0 x6d, 0 x6e, 0 x6f, 0 x70, 0 x71, 0 x72, 0 x73]),
i8x16([0 xf, 0 xe, 0 xd, 0 xc, 0 xb, 0 xa, 0 x9, 0 x8, 0 x7, 0 x6, 0 x5, 0 x4, 0 x3, 0 x2, 0 x1, 0 x0]),
]),
[
i8x16([0 x73, 0 x72, 0 x71, 0 x70, 0 x6f, 0 x6e, 0 x6d, 0 x6c, 0 x6b, 0 x6a, 0 x69, 0 x68, 0 x67, 0 x66, 0 x65, 0 x64]),
],
);
// ./test/core/simd/simd_lane.wast:304
assert_return(
() => invoke($0 , `v8x16_swizzle`, [
i8x16([0 x64, 0 x65, 0 x66, 0 x67, 0 x68, 0 x69, 0 x6a, 0 x6b, 0 x6c, 0 x6d, 0 x6e, 0 x6f, 0 x70, 0 x71, 0 x72, 0 x73]),
i8x16([0 xff, 0 x1, 0 xfe, 0 x2, 0 xfd, 0 x3, 0 xfc, 0 x4, 0 xfb, 0 x5, 0 xfa, 0 x6, 0 xf9, 0 x7, 0 xf8, 0 x8]),
]),
[
i8x16([0 x0, 0 x65, 0 x0, 0 x66, 0 x0, 0 x67, 0 x0, 0 x68, 0 x0, 0 x69, 0 x0, 0 x6a, 0 x0, 0 x6b, 0 x0, 0 x6c]),
],
);
// ./test/core/simd/simd_lane.wast:308
assert_return(
() => invoke($0 , `v8x16_swizzle`, [
i8x16([0 x64, 0 x65, 0 x66, 0 x67, 0 x68, 0 x69, 0 x6a, 0 x6b, 0 x6c, 0 x6d, 0 x6e, 0 x6f, 0 x70, 0 x71, 0 x72, 0 x73]),
i8x16([0 x9, 0 x10, 0 xa, 0 x11, 0 xb, 0 x12, 0 xc, 0 x13, 0 xd, 0 x14, 0 xe, 0 x15, 0 xf, 0 x16, 0 x10, 0 x17]),
]),
[
i8x16([0 x6d, 0 x0, 0 x6e, 0 x0, 0 x6f, 0 x0, 0 x70, 0 x0, 0 x71, 0 x0, 0 x72, 0 x0, 0 x73, 0 x0, 0 x0, 0 x0]),
],
);
// ./test/core/simd/simd_lane.wast:312
assert_return(
() => invoke($0 , `v8x16_swizzle`, [
i8x16([0 x64, 0 x65, 0 x66, 0 x67, 0 x68, 0 x69, 0 x6a, 0 x6b, 0 x6c, 0 x6d, 0 x6e, 0 x6f, 0 x70, 0 x71, 0 x72, 0 x73]),
i8x16([0 x9, 0 x10, 0 xa, 0 x11, 0 xb, 0 x12, 0 xc, 0 x13, 0 xd, 0 x14, 0 xe, 0 x15, 0 xf, 0 x16, 0 x10, 0 x17]),
]),
[
i8x16([0 x6d, 0 x0, 0 x6e, 0 x0, 0 x6f, 0 x0, 0 x70, 0 x0, 0 x71, 0 x0, 0 x72, 0 x0, 0 x73, 0 x0, 0 x0, 0 x0]),
],
);
// ./test/core/simd/simd_lane.wast:316
assert_return(
() => invoke($0 , `v8x16_swizzle`, [
i16x8([0 x6465, 0 x6667, 0 x6869, 0 x6a6b, 0 x6c6d, 0 x6e6f, 0 x7071, 0 x7273]),
i8x16([0 x0, 0 x1, 0 x2, 0 x3, 0 x4, 0 x5, 0 x6, 0 x7, 0 x8, 0 x9, 0 xa, 0 xb, 0 xc, 0 xd, 0 xe, 0 xf]),
]),
[i16x8([0 x6465, 0 x6667, 0 x6869, 0 x6a6b, 0 x6c6d, 0 x6e6f, 0 x7071, 0 x7273])],
);
// ./test/core/simd/simd_lane.wast:320
assert_return(
() => invoke($0 , `v8x16_swizzle`, [
i32x4([0 x64656667, 0 x68696a6b, 0 x6c6d6e6f, 0 x70717273]),
i8x16([0 xf, 0 xe, 0 xd, 0 xc, 0 xb, 0 xa, 0 x9, 0 x8, 0 x7, 0 x6, 0 x5, 0 x4, 0 x3, 0 x2, 0 x1, 0 x0]),
]),
[i32x4([0 x73727170, 0 x6f6e6d6c, 0 x6b6a6968, 0 x67666564])],
);
// ./test/core/simd/simd_lane.wast:324
assert_return(
() => invoke($0 , `v8x16_swizzle`, [
bytes('v128' , [
0 x0,
0 x0,
0 xc0,
0 x7f,
0 x0,
0 x0,
0 xc0,
0 xff,
0 x0,
0 x0,
0 x80,
0 x7f,
0 x0,
0 x0,
0 x80,
0 xff,
]),
i8x16([0 x0, 0 x1, 0 x2, 0 x3, 0 x4, 0 x5, 0 x6, 0 x7, 0 x8, 0 x9, 0 xa, 0 xb, 0 xc, 0 xd, 0 xe, 0 xf]),
]),
[i32x4([0 x7fc00000, 0 xffc00000, 0 x7f800000, 0 xff800000])],
);
// ./test/core/simd/simd_lane.wast:328
assert_return(
() => invoke($0 , `v8x16_swizzle`, [
i32x4([0 x67666564, 0 x6b6a6968, 0 x6f6e6d5c, 0 x73727170]),
f32x4([0 , -0 , Infinity, -Infinity]),
]),
[i32x4([0 x64646464, 0 x646464, 0 x6464, 0 x6464])],
);
// ./test/core/simd/simd_lane.wast:333
assert_return(
() => invoke($0 , `v8x16_shuffle-1 `, [
i8x16([0 x0, 0 x1, 0 x2, 0 x3, 0 x4, 0 x5, 0 x6, 0 x7, 0 x8, 0 x9, 0 xa, 0 xb, 0 xc, 0 xd, 0 xe, 0 xf]),
i8x16([0 x10, 0 x11, 0 x12, 0 x13, 0 x14, 0 x15, 0 x16, 0 x17, 0 x18, 0 x19, 0 x1a, 0 x1b, 0 x1c, 0 x1d, 0 x1e, 0 x1f]),
]),
[
i8x16([0 x0, 0 x1, 0 x2, 0 x3, 0 x4, 0 x5, 0 x6, 0 x7, 0 x8, 0 x9, 0 xa, 0 xb, 0 xc, 0 xd, 0 xe, 0 xf]),
],
);
// ./test/core/simd/simd_lane.wast:337
assert_return(
() => invoke($0 , `v8x16_shuffle-2 `, [
i8x16([0 x0, 0 x1, 0 x2, 0 x3, 0 x4, 0 x5, 0 x6, 0 x7, 0 x8, 0 x9, 0 xa, 0 xb, 0 xc, 0 xd, 0 xe, 0 xf]),
i8x16([0 xf0, 0 xf1, 0 xf2, 0 xf3, 0 xf4, 0 xf5, 0 xf6, 0 xf7, 0 xf8, 0 xf9, 0 xfa, 0 xfb, 0 xfc, 0 xfd, 0 xfe, 0 xff]),
]),
[
i8x16([0 xf0, 0 xf1, 0 xf2, 0 xf3, 0 xf4, 0 xf5, 0 xf6, 0 xf7, 0 xf8, 0 xf9, 0 xfa, 0 xfb, 0 xfc, 0 xfd, 0 xfe, 0 xff]),
],
);
// ./test/core/simd/simd_lane.wast:341
assert_return(
() => invoke($0 , `v8x16_shuffle-3 `, [
i8x16([0 x0, 0 x1, 0 x2, 0 x3, 0 x4, 0 x5, 0 x6, 0 x7, 0 x8, 0 x9, 0 xa, 0 xb, 0 xc, 0 xd, 0 xe, 0 xf]),
i8x16([0 xf0, 0 xf1, 0 xf2, 0 xf3, 0 xf4, 0 xf5, 0 xf6, 0 xf7, 0 xf8, 0 xf9, 0 xfa, 0 xfb, 0 xfc, 0 xfd, 0 xfe, 0 xff]),
]),
[
i8x16([0 xff, 0 xfe, 0 xfd, 0 xfc, 0 xfb, 0 xfa, 0 xf9, 0 xf8, 0 xf7, 0 xf6, 0 xf5, 0 xf4, 0 xf3, 0 xf2, 0 xf1, 0 xf0]),
],
);
// ./test/core/simd/simd_lane.wast:345
assert_return(
() => invoke($0 , `v8x16_shuffle-4 `, [
i8x16([0 x0, 0 x1, 0 x2, 0 x3, 0 x4, 0 x5, 0 x6, 0 x7, 0 x8, 0 x9, 0 xa, 0 xb, 0 xc, 0 xd, 0 xe, 0 xf]),
i8x16([0 xf0, 0 xf1, 0 xf2, 0 xf3, 0 xf4, 0 xf5, 0 xf6, 0 xf7, 0 xf8, 0 xf9, 0 xfa, 0 xfb, 0 xfc, 0 xfd, 0 xfe, 0 xff]),
]),
[
i8x16([0 xf, 0 xe, 0 xd, 0 xc, 0 xb, 0 xa, 0 x9, 0 x8, 0 x7, 0 x6, 0 x5, 0 x4, 0 x3, 0 x2, 0 x1, 0 x0]),
],
);
// ./test/core/simd/simd_lane.wast:349
assert_return(
() => invoke($0 , `v8x16_shuffle-5 `, [
i8x16([0 x0, 0 x1, 0 x2, 0 x3, 0 x4, 0 x5, 0 x6, 0 x7, 0 x8, 0 x9, 0 xa, 0 xb, 0 xc, 0 xd, 0 xe, 0 xf]),
i8x16([0 xf0, 0 xf1, 0 xf2, 0 xf3, 0 xf4, 0 xf5, 0 xf6, 0 xf7, 0 xf8, 0 xf9, 0 xfa, 0 xfb, 0 xfc, 0 xfd, 0 xfe, 0 xff]),
]),
[
i8x16([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
],
);
// ./test/core/simd/simd_lane.wast:353
assert_return(
() => invoke($0 , `v8x16_shuffle-6 `, [
i8x16([0 x0, 0 x1, 0 x2, 0 x3, 0 x4, 0 x5, 0 x6, 0 x7, 0 x8, 0 x9, 0 xa, 0 xb, 0 xc, 0 xd, 0 xe, 0 xf]),
i8x16([0 xf0, 0 xf1, 0 xf2, 0 xf3, 0 xf4, 0 xf5, 0 xf6, 0 xf7, 0 xf8, 0 xf9, 0 xfa, 0 xfb, 0 xfc, 0 xfd, 0 xfe, 0 xff]),
]),
[
i8x16([0 xf0, 0 xf0, 0 xf0, 0 xf0, 0 xf0, 0 xf0, 0 xf0, 0 xf0, 0 xf0, 0 xf0, 0 xf0, 0 xf0, 0 xf0, 0 xf0, 0 xf0, 0 xf0]),
],
);
// ./test/core/simd/simd_lane.wast:357
assert_return(
() => invoke($0 , `v8x16_shuffle-7 `, [
i8x16([0 x0, 0 x1, 0 x2, 0 x3, 0 x4, 0 x5, 0 x6, 0 x7, 0 x8, 0 x9, 0 xa, 0 xb, 0 xc, 0 xd, 0 xe, 0 xf]),
i8x16([0 xf0, 0 xf1, 0 xf2, 0 xf3, 0 xf4, 0 xf5, 0 xf6, 0 xf7, 0 xf8, 0 xf9, 0 xfa, 0 xfb, 0 xfc, 0 xfd, 0 xfe, 0 xff]),
]),
[
i8x16([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 xf0, 0 xf0, 0 xf0, 0 xf0, 0 xf0, 0 xf0, 0 xf0, 0 xf0]),
],
);
// ./test/core/simd/simd_lane.wast:361
assert_return(
() => invoke($0 , `v8x16_shuffle-1 `, [
i8x16([0 x64, 0 x65, 0 x66, 0 x67, 0 x68, 0 x69, 0 x6a, 0 x6b, 0 x6c, 0 x6d, 0 x6e, 0 x6f, 0 x70, 0 x71, 0 x72, 0 x73]),
i8x16([0 xf0, 0 xf1, 0 xf2, 0 xf3, 0 xf4, 0 xf5, 0 xf6, 0 xf7, 0 xf8, 0 xf9, 0 xfa, 0 xfb, 0 xfc, 0 xfd, 0 xfe, 0 xff]),
]),
[
i8x16([0 x64, 0 x65, 0 x66, 0 x67, 0 x68, 0 x69, 0 x6a, 0 x6b, 0 x6c, 0 x6d, 0 x6e, 0 x6f, 0 x70, 0 x71, 0 x72, 0 x73]),
],
);
// ./test/core/simd/simd_lane.wast:365
assert_return(
() => invoke($0 , `v8x16_shuffle-1 `, [
i16x8([0 x100, 0 x302, 0 x504, 0 x706, 0 x908, 0 xb0a, 0 xd0c, 0 xf0e]),
i8x16([0 xf0, 0 xf1, 0 xf2, 0 xf3, 0 xf4, 0 xf5, 0 xf6, 0 xf7, 0 xf8, 0 xf9, 0 xfa, 0 xfb, 0 xfc, 0 xfd, 0 xfe, 0 xff]),
]),
[i16x8([0 x100, 0 x302, 0 x504, 0 x706, 0 x908, 0 xb0a, 0 xd0c, 0 xf0e])],
);
// ./test/core/simd/simd_lane.wast:369
assert_return(
() => invoke($0 , `v8x16_shuffle-2 `, [
i8x16([0 x0, 0 x1, 0 x2, 0 x3, 0 x4, 0 x5, 0 x6, 0 x7, 0 x8, 0 x9, 0 xa, 0 xb, 0 xc, 0 xd, 0 xe, 0 xf]),
i32x4([0 xf3f2f1f0, 0 xf7f6f5f4, 0 xfbfaf9f8, 0 xfffefdfc]),
]),
[i32x4([0 xf3f2f1f0, 0 xf7f6f5f4, 0 xfbfaf9f8, 0 xfffefdfc])],
);
// ./test/core/simd/simd_lane.wast:373
assert_return(
() => invoke($0 , `v8x16_shuffle-1 `, [
i32x4([0 x10203, 0 x4050607, 0 x8090a0b, 0 xc0d0e0f]),
i8x16([0 x0, 0 x1, 0 x2, 0 x3, 0 x4, 0 x5, 0 x6, 0 x7, 0 x8, 0 x9, 0 xa, 0 xb, 0 xc, 0 xd, 0 xe, 0 xf]),
]),
[i32x4([0 x10203, 0 x4050607, 0 x8090a0b, 0 xc0d0e0f])],
);
// ./test/core/simd/simd_lane.wast:377
assert_return(
() => invoke($0 , `v8x16_shuffle-1 `, [
bytes('v128' , [
0 x0,
0 x0,
0 x80,
0 x3f,
0 x0,
0 x0,
0 xc0,
0 x7f,
0 x0,
0 x0,
0 x80,
0 x7f,
0 x0,
0 x0,
0 x80,
0 xff,
]),
i8x16([0 x0, 0 x1, 0 x2, 0 x3, 0 x4, 0 x5, 0 x6, 0 x7, 0 x8, 0 x9, 0 xa, 0 xb, 0 xc, 0 xd, 0 xe, 0 xf]),
]),
[i32x4([0 x3f800000, 0 x7fc00000, 0 x7f800000, 0 xff800000])],
);
// ./test/core/simd/simd_lane.wast:381
assert_return(
() => invoke($0 , `v8x16_shuffle-1 `, [
i32x4([0 x10203, 0 x4050607, 0 x8090a0b, 0 xc0d0e0f]),
bytes('v128' , [
0 x0,
0 x0,
0 x0,
0 x80,
0 x0,
0 x0,
0 xc0,
0 x7f,
0 x0,
0 x0,
0 x80,
0 x7f,
0 x0,
0 x0,
0 x80,
0 xff,
]),
]),
[i32x4([0 x10203, 0 x4050607, 0 x8090a0b, 0 xc0d0e0f])],
);
// ./test/core/simd/simd_lane.wast:387
assert_return(
() => invoke($0 , `v8x16_swizzle`, [
i32x4([0 x499602d2, 0 x12345678, 0 x499602d2, 0 x12345678]),
i8x16([0 x0, 0 x1, 0 x2, 0 x3, 0 x4, 0 x5, 0 x6, 0 x7, 0 x8, 0 x9, 0 xa, 0 xb, 0 xc, 0 xd, 0 xe, 0 xf]),
]),
[i32x4([0 x499602d2, 0 x12345678, 0 x499602d2, 0 x12345678])],
);
// ./test/core/simd/simd_lane.wast:391
assert_return(
() => invoke($0 , `v8x16_shuffle-1 `, [
i64x2([0 xab54a98ceb1f0ad2n, 0 x1234567890abcdefn]),
i64x2([0 xab54a98ceb1f0ad2n, 0 x1234567890abcdefn]),
]),
[i32x4([0 xeb1f0ad2, 0 xab54a98c, 0 x90abcdef, 0 x12345678])],
);
// ./test/core/simd/simd_lane.wast:398
assert_malformed(
() => instantiate(`(func (result i32) (i8x16.extract_lane_s -1 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ))) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:399
assert_malformed(
() => instantiate(`(func (result i32) (i8x16.extract_lane_u -1 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ))) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:400
assert_malformed(
() => instantiate(`(func (result i32) (i16x8.extract_lane_s -1 (v128.const i16x8 0 0 0 0 0 0 0 0 ))) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:401
assert_malformed(
() => instantiate(`(func (result i32) (i16x8.extract_lane_u -1 (v128.const i16x8 0 0 0 0 0 0 0 0 ))) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:402
assert_malformed(
() => instantiate(`(func (result i32) (i32x4.extract_lane -1 (v128.const i32x4 0 0 0 0 ))) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:403
assert_malformed(
() => instantiate(`(func (result f32) (f32x4.extract_lane -1 (v128.const f32x4 0 0 0 0 ))) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:404
assert_malformed(
() => instantiate(`(func (result v128) (i8x16.replace_lane -1 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ) (i32.const 1 ))) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:405
assert_malformed(
() => instantiate(`(func (result v128) (i16x8.replace_lane -1 (v128.const i16x8 0 0 0 0 0 0 0 0 ) (i32.const 1 ))) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:406
assert_malformed(
() => instantiate(`(func (result v128) (i32x4.replace_lane -1 (v128.const i32x4 0 0 0 0 ) (i32.const 1 ))) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:407
assert_malformed(
() => instantiate(`(func (result v128) (f32x4.replace_lane -1 (v128.const f32x4 0 0 0 0 ) (i32.const 1 ))) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:408
assert_malformed(
() => instantiate(`(func (result i64) (i64x2.extract_lane -1 (v128.const i64x2 0 0 ))) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:409
assert_malformed(
() => instantiate(`(func (result f64) (f64x2.extract_lane -1 (v128.const f64x2 0 0 ))) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:410
assert_malformed(
() => instantiate(`(func (result v128) (i64x2.replace_lane -1 (v128.const i64x2 0 0 ) (i64.const 1 ))) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:411
assert_malformed(
() => instantiate(`(func (result v128) (f64x2.replace_lane -1 (v128.const f64x2 0 0 ) (f64.const 1 ))) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:415
assert_malformed(
() => instantiate(`(func (result i32) (i8x16.extract_lane_s 256 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ))) `),
`malformed lane index`,
);
// ./test/core/simd/simd_lane.wast:416
assert_malformed(
() => instantiate(`(func (result i32) (i8x16.extract_lane_u 256 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ))) `),
`malformed lane index`,
);
// ./test/core/simd/simd_lane.wast:417
assert_malformed(
() => instantiate(`(func (result i32) (i16x8.extract_lane_s 256 (v128.const i16x8 0 0 0 0 0 0 0 0 ))) `),
`malformed lane index`,
);
// ./test/core/simd/simd_lane.wast:418
assert_malformed(
() => instantiate(`(func (result i32) (i16x8.extract_lane_u 256 (v128.const i16x8 0 0 0 0 0 0 0 0 ))) `),
`malformed lane index`,
);
// ./test/core/simd/simd_lane.wast:419
assert_malformed(
() => instantiate(`(func (result i32) (i32x4.extract_lane 256 (v128.const i32x4 0 0 0 0 ))) `),
`malformed lane index`,
);
// ./test/core/simd/simd_lane.wast:420
assert_malformed(
() => instantiate(`(func (result f32) (f32x4.extract_lane 256 (v128.const f32x4 0 0 0 0 ))) `),
`malformed lane index`,
);
// ./test/core/simd/simd_lane.wast:421
assert_malformed(
() => instantiate(`(func (result v128) (i8x16.replace_lane 256 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ) (i32.const 1 ))) `),
`malformed lane index`,
);
// ./test/core/simd/simd_lane.wast:422
assert_malformed(
() => instantiate(`(func (result v128) (i16x8.replace_lane 256 (v128.const i16x8 0 0 0 0 0 0 0 0 ) (i32.const 1 ))) `),
`malformed lane index`,
);
// ./test/core/simd/simd_lane.wast:423
assert_malformed(
() => instantiate(`(func (result v128) (i32x4.replace_lane 256 (v128.const i32x4 0 0 0 0 ) (i32.const 1 ))) `),
`malformed lane index`,
);
// ./test/core/simd/simd_lane.wast:424
assert_malformed(
() => instantiate(`(func (result v128) (f32x4.replace_lane 256 (v128.const f32x4 0 0 0 0 ) (i32.const 1 ))) `),
`malformed lane index`,
);
// ./test/core/simd/simd_lane.wast:425
assert_malformed(
() => instantiate(`(func (result i64) (i64x2.extract_lane 256 (v128.const i64x2 0 0 ))) `),
`malformed lane index`,
);
// ./test/core/simd/simd_lane.wast:426
assert_malformed(
() => instantiate(`(func (result f64) (f64x2.extract_lane 256 (v128.const f64x2 0 0 ))) `),
`malformed lane index`,
);
// ./test/core/simd/simd_lane.wast:427
assert_malformed(
() => instantiate(`(func (result v128) (i64x2.replace_lane 256 (v128.const i64x2 0 0 ) (i64.const 1 ))) `),
`malformed lane index`,
);
// ./test/core/simd/simd_lane.wast:428
assert_malformed(
() => instantiate(`(func (result v128) (f64x2.replace_lane 256 (v128.const f64x2 0 0 ) (f64.const 1 ))) `),
`malformed lane index`,
);
// ./test/core/simd/simd_lane.wast:432
assert_invalid(
() => instantiate(`(module (func (result i32) (i8x16.extract_lane_s 16 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ))))`),
`invalid lane index`,
);
// ./test/core/simd/simd_lane.wast:433
assert_invalid(
() => instantiate(`(module (func (result i32) (i8x16.extract_lane_s 255 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ))))`),
`invalid lane index`,
);
// ./test/core/simd/simd_lane.wast:434
assert_invalid(
() => instantiate(`(module (func (result i32) (i8x16.extract_lane_u 16 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ))))`),
`invalid lane index`,
);
// ./test/core/simd/simd_lane.wast:435
assert_invalid(
() => instantiate(`(module (func (result i32) (i8x16.extract_lane_u 255 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ))))`),
`invalid lane index`,
);
// ./test/core/simd/simd_lane.wast:436
assert_invalid(
() => instantiate(`(module (func (result i32) (i16x8.extract_lane_s 8 (v128.const i16x8 0 0 0 0 0 0 0 0 ))))`),
`invalid lane index`,
);
// ./test/core/simd/simd_lane.wast:437
assert_invalid(
() => instantiate(`(module (func (result i32) (i16x8.extract_lane_s 255 (v128.const i16x8 0 0 0 0 0 0 0 0 ))))`),
`invalid lane index`,
);
// ./test/core/simd/simd_lane.wast:438
assert_invalid(
() => instantiate(`(module (func (result i32) (i16x8.extract_lane_u 8 (v128.const i16x8 0 0 0 0 0 0 0 0 ))))`),
`invalid lane index`,
);
// ./test/core/simd/simd_lane.wast:439
assert_invalid(
() => instantiate(`(module (func (result i32) (i16x8.extract_lane_u 255 (v128.const i16x8 0 0 0 0 0 0 0 0 ))))`),
`invalid lane index`,
);
// ./test/core/simd/simd_lane.wast:440
assert_invalid(
() => instantiate(`(module (func (result i32) (i32x4.extract_lane 4 (v128.const i32x4 0 0 0 0 ))))`),
`invalid lane index`,
);
// ./test/core/simd/simd_lane.wast:441
assert_invalid(
() => instantiate(`(module (func (result i32) (i32x4.extract_lane 255 (v128.const i32x4 0 0 0 0 ))))`),
`invalid lane index`,
);
// ./test/core/simd/simd_lane.wast:442
assert_invalid(
() => instantiate(`(module (func (result f32) (f32x4.extract_lane 4 (v128.const f32x4 0 0 0 0 ))))`),
`invalid lane index`,
);
// ./test/core/simd/simd_lane.wast:443
assert_invalid(
() => instantiate(`(module (func (result f32) (f32x4.extract_lane 255 (v128.const f32x4 0 0 0 0 ))))`),
`invalid lane index`,
);
// ./test/core/simd/simd_lane.wast:444
assert_invalid(
() => instantiate(`(module (func (result v128) (i8x16.replace_lane 16 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ) (i32.const 1 ))))`),
`invalid lane index`,
);
// ./test/core/simd/simd_lane.wast:445
assert_invalid(
() => instantiate(`(module (func (result v128) (i8x16.replace_lane 255 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ) (i32.const 1 ))))`),
`invalid lane index`,
);
// ./test/core/simd/simd_lane.wast:446
assert_invalid(
() => instantiate(`(module (func (result v128) (i16x8.replace_lane 16 (v128.const i16x8 0 0 0 0 0 0 0 0 ) (i32.const 1 ))))`),
`invalid lane index`,
);
// ./test/core/simd/simd_lane.wast:447
assert_invalid(
() => instantiate(`(module (func (result v128) (i16x8.replace_lane 255 (v128.const i16x8 0 0 0 0 0 0 0 0 ) (i32.const 1 ))))`),
`invalid lane index`,
);
// ./test/core/simd/simd_lane.wast:448
assert_invalid(
() => instantiate(`(module (func (result v128) (i32x4.replace_lane 4 (v128.const i32x4 0 0 0 0 ) (i32.const 1 ))))`),
`invalid lane index`,
);
// ./test/core/simd/simd_lane.wast:449
assert_invalid(
() => instantiate(`(module (func (result v128) (i32x4.replace_lane 255 (v128.const i32x4 0 0 0 0 ) (i32.const 1 ))))`),
`invalid lane index`,
);
// ./test/core/simd/simd_lane.wast:450
assert_invalid(
() => instantiate(`(module (func (result v128) (f32x4.replace_lane 4 (v128.const f32x4 0 0 0 0 ) (f32.const 1 ))))`),
`invalid lane index`,
);
// ./test/core/simd/simd_lane.wast:451
assert_invalid(
() => instantiate(`(module (func (result v128) (f32x4.replace_lane 255 (v128.const f32x4 0 0 0 0 ) (f32.const 1 ))))`),
`invalid lane index`,
);
// ./test/core/simd/simd_lane.wast:452
assert_invalid(
() => instantiate(`(module (func (result i64) (i64x2.extract_lane 2 (v128.const i64x2 0 0 ))))`),
`invalid lane index`,
);
// ./test/core/simd/simd_lane.wast:453
assert_invalid(
() => instantiate(`(module (func (result i64) (i64x2.extract_lane 255 (v128.const i64x2 0 0 ))))`),
`invalid lane index`,
);
// ./test/core/simd/simd_lane.wast:454
assert_invalid(
() => instantiate(`(module (func (result f64) (f64x2.extract_lane 2 (v128.const f64x2 0 0 ))))`),
`invalid lane index`,
);
// ./test/core/simd/simd_lane.wast:455
assert_invalid(
() => instantiate(`(module (func (result f64) (f64x2.extract_lane 255 (v128.const f64x2 0 0 ))))`),
`invalid lane index`,
);
// ./test/core/simd/simd_lane.wast:456
assert_invalid(
() => instantiate(`(module (func (result v128) (i64x2.replace_lane 2 (v128.const i64x2 0 0 ) (i64.const 1 ))))`),
`invalid lane index`,
);
// ./test/core/simd/simd_lane.wast:457
assert_invalid(
() => instantiate(`(module (func (result v128) (i64x2.replace_lane 255 (v128.const i64x2 0 0 ) (i64.const 1 ))))`),
`invalid lane index`,
);
// ./test/core/simd/simd_lane.wast:458
assert_invalid(
() => instantiate(`(module (func (result v128) (f64x2.replace_lane 2 (v128.const f64x2 0 0 ) (f64.const 1 ))))`),
`invalid lane index`,
);
// ./test/core/simd/simd_lane.wast:459
assert_invalid(
() => instantiate(`(module (func (result v128) (f64x2.replace_lane 255 (v128.const f64x2 0 0 ) (f64.const 1 .0 ))))`),
`invalid lane index`,
);
// ./test/core/simd/simd_lane.wast:463
assert_invalid(
() => instantiate(`(module (func (result i32) (i16x8.extract_lane_s 8 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ))))`),
`invalid lane index`,
);
// ./test/core/simd/simd_lane.wast:464
assert_invalid(
() => instantiate(`(module (func (result i32) (i16x8.extract_lane_u 8 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ))))`),
`invalid lane index`,
);
// ./test/core/simd/simd_lane.wast:465
assert_invalid(
() => instantiate(`(module (func (result i32) (i32x4.extract_lane 4 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ))))`),
`invalid lane index`,
);
// ./test/core/simd/simd_lane.wast:466
assert_invalid(
() => instantiate(`(module (func (result i32) (f32x4.extract_lane 4 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ))))`),
`invalid lane index`,
);
// ./test/core/simd/simd_lane.wast:467
assert_invalid(
() => instantiate(`(module (func (result v128) (i16x8.replace_lane 8 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ) (i32.const 1 ))))`),
`invalid lane index`,
);
// ./test/core/simd/simd_lane.wast:468
assert_invalid(
() => instantiate(`(module (func (result v128) (i32x4.replace_lane 4 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ) (i32.const 1 ))))`),
`invalid lane index`,
);
// ./test/core/simd/simd_lane.wast:469
assert_invalid(
() => instantiate(`(module (func (result v128) (f32x4.replace_lane 4 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ) (f32.const 1 ))))`),
`invalid lane index`,
);
// ./test/core/simd/simd_lane.wast:470
assert_invalid(
() => instantiate(`(module (func (result i64) (i64x2.extract_lane 2 (v128.const i64x2 0 0 ))))`),
`invalid lane index`,
);
// ./test/core/simd/simd_lane.wast:471
assert_invalid(
() => instantiate(`(module (func (result f64) (f64x2.extract_lane 2 (v128.const f64x2 0 0 ))))`),
`invalid lane index`,
);
// ./test/core/simd/simd_lane.wast:472
assert_invalid(
() => instantiate(`(module (func (result v128) (i64x2.replace_lane 2 (v128.const i64x2 0 0 ) (i64.const 1 ))))`),
`invalid lane index`,
);
// ./test/core/simd/simd_lane.wast:473
assert_invalid(
() => instantiate(`(module (func (result v128) (f64x2.replace_lane 2 (v128.const f64x2 0 0 ) (f64.const 1 .0 ))))`),
`invalid lane index`,
);
// ./test/core/simd/simd_lane.wast:477
assert_invalid(
() => instantiate(`(module (func (result i32) (i8x16.extract_lane_s 0 (i32.const 0 ))))`),
`type mismatch`,
);
// ./test/core/simd/simd_lane.wast:478
assert_invalid(
() => instantiate(`(module (func (result i32) (i8x16.extract_lane_u 0 (i64.const 0 ))))`),
`type mismatch`,
);
// ./test/core/simd/simd_lane.wast:479
assert_invalid(
() => instantiate(`(module (func (result i32) (i8x16.extract_lane_s 0 (f32.const 0 .0 ))))`),
`type mismatch`,
);
// ./test/core/simd/simd_lane.wast:480
assert_invalid(
() => instantiate(`(module (func (result i32) (i8x16.extract_lane_u 0 (f64.const 0 .0 ))))`),
`type mismatch`,
);
// ./test/core/simd/simd_lane.wast:481
assert_invalid(
() => instantiate(`(module (func (result i32) (i32x4.extract_lane 0 (i32.const 0 ))))`),
`type mismatch`,
);
// ./test/core/simd/simd_lane.wast:482
assert_invalid(
() => instantiate(`(module (func (result f32) (f32x4.extract_lane 0 (f32.const 0 .0 ))))`),
`type mismatch`,
);
// ./test/core/simd/simd_lane.wast:483
assert_invalid(
() => instantiate(`(module (func (result v128) (i8x16.replace_lane 0 (i32.const 0 ) (i32.const 1 ))))`),
`type mismatch`,
);
// ./test/core/simd/simd_lane.wast:484
assert_invalid(
() => instantiate(`(module (func (result v128) (i16x8.replace_lane 0 (i64.const 0 ) (i32.const 1 ))))`),
`type mismatch`,
);
// ./test/core/simd/simd_lane.wast:485
assert_invalid(
() => instantiate(`(module (func (result v128) (i32x4.replace_lane 0 (i32.const 0 ) (i32.const 1 ))))`),
`type mismatch`,
);
// ./test/core/simd/simd_lane.wast:486
assert_invalid(
() => instantiate(`(module (func (result v128) (f32x4.replace_lane 0 (f32.const 0 .0 ) (i32.const 1 ))))`),
`type mismatch`,
);
// ./test/core/simd/simd_lane.wast:487
assert_invalid(
() => instantiate(`(module (func (result i64) (i64x2.extract_lane 0 (i64.const 0 ))))`),
`type mismatch`,
);
// ./test/core/simd/simd_lane.wast:488
assert_invalid(
() => instantiate(`(module (func (result f64) (f64x2.extract_lane 0 (f64.const 0 .0 ))))`),
`type mismatch`,
);
// ./test/core/simd/simd_lane.wast:489
assert_invalid(
() => instantiate(`(module (func (result v128) (i32x4.replace_lane 0 (i32.const 0 ) (i32.const 1 ))))`),
`type mismatch`,
);
// ./test/core/simd/simd_lane.wast:490
assert_invalid(
() => instantiate(`(module (func (result v128) (f32x4.replace_lane 0 (f32.const 0 .0 ) (i32.const 1 ))))`),
`type mismatch`,
);
// ./test/core/simd/simd_lane.wast:494
assert_invalid(
() => instantiate(`(module (func (result v128) (i8x16.replace_lane 0 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ) (f32.const 1 .0 ))))`),
`type mismatch`,
);
// ./test/core/simd/simd_lane.wast:495
assert_invalid(
() => instantiate(`(module (func (result v128) (i16x8.replace_lane 0 (v128.const i16x8 0 0 0 0 0 0 0 0 ) (f64.const 1 .0 ))))`),
`type mismatch`,
);
// ./test/core/simd/simd_lane.wast:496
assert_invalid(
() => instantiate(`(module (func (result v128) (i32x4.replace_lane 0 (v128.const i32x4 0 0 0 0 ) (f32.const 1 .0 ))))`),
`type mismatch`,
);
// ./test/core/simd/simd_lane.wast:497
assert_invalid(
() => instantiate(`(module (func (result v128) (f32x4.replace_lane 0 (v128.const f32x4 0 0 0 0 ) (i32.const 1 ))))`),
`type mismatch`,
);
// ./test/core/simd/simd_lane.wast:499
assert_invalid(
() => instantiate(`(module (func (result v128) (i64x2.replace_lane 0 (v128.const i64x2 0 0 ) (f64.const 1 .0 ))))`),
`type mismatch`,
);
// ./test/core/simd/simd_lane.wast:500
assert_invalid(
() => instantiate(`(module (func (result v128) (f64x2.replace_lane 0 (v128.const f64x2 0 0 ) (i64.const 1 ))))`),
`type mismatch`,
);
// ./test/core/simd/simd_lane.wast:503
assert_invalid(
() => instantiate(`(module (func (result v128)
(i8x16.swizzle (i32.const 1 ) (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 ))))`),
`type mismatch`,
);
// ./test/core/simd/simd_lane.wast:505
assert_invalid(
() => instantiate(`(module (func (result v128)
(i8x16.swizzle (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 ) (i32.const 2 ))))`),
`type mismatch`,
);
// ./test/core/simd/simd_lane.wast:507
assert_invalid(
() => instantiate(`(module (func (result v128)
(i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 (f32.const 3 .0 )
(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 ))))`),
`type mismatch`,
);
// ./test/core/simd/simd_lane.wast:510
assert_invalid(
() => instantiate(`(module (func (result v128)
(i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 ) (f32.const 4 .0 ))))`),
`type mismatch`,
);
// ./test/core/simd/simd_lane.wast:515
assert_malformed(
() => instantiate(`(func (param v128) (result v128) (i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 (local.get 0 ) (local.get 0 ))) `),
`invalid lane length`,
);
// ./test/core/simd/simd_lane.wast:518
assert_malformed(
() => instantiate(`(func (param v128) (result v128) (i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 (local.get 0 ) (local.get 0 ))) `),
`invalid lane length`,
);
// ./test/core/simd/simd_lane.wast:521
assert_malformed(
() => instantiate(`(func (result v128) (i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 -1 (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 ) (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 ))) `),
`malformed lane index`,
);
// ./test/core/simd/simd_lane.wast:525
assert_malformed(
() => instantiate(`(func (result v128) (i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 256 (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 ) (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 ))) `),
`malformed lane index`,
);
// ./test/core/simd/simd_lane.wast:529
assert_invalid(
() => instantiate(`(module (func (result v128)
(i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 255
(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 )
(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 ))))`),
`invalid lane index`,
);
// ./test/core/simd/simd_lane.wast:536
assert_malformed(
() => instantiate(`(func (result i32) (i8x16.extract_lane 0 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ))) `),
`unknown operator`,
);
// ./test/core/simd/simd_lane.wast:537
assert_malformed(
() => instantiate(`(func (result i32) (i16x8.extract_lane 0 (v128.const i16x8 0 0 0 0 0 0 0 0 ))) `),
`unknown operator`,
);
// ./test/core/simd/simd_lane.wast:538
assert_malformed(
() => instantiate(`(func (result i32) (i32x4.extract_lane_s 0 (v128.const i32x4 0 0 0 0 ))) `),
`unknown operator`,
);
// ./test/core/simd/simd_lane.wast:539
assert_malformed(
() => instantiate(`(func (result i32) (i32x4.extract_lane_u 0 (v128.const i32x4 0 0 0 0 ))) `),
`unknown operator`,
);
// ./test/core/simd/simd_lane.wast:540
assert_malformed(
() => instantiate(`(func (result i32) (i64x2.extract_lane_s 0 (v128.const i64x2 0 0 ))) `),
`unknown operator`,
);
// ./test/core/simd/simd_lane.wast:541
assert_malformed(
() => instantiate(`(func (result i32) (i64x2.extract_lane_u 0 (v128.const i64x2 0 0 ))) `),
`unknown operator`,
);
// ./test/core/simd/simd_lane.wast:545
assert_malformed(
() => instantiate(`(func (result v128) (i8x16.shuffle1 (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 ) (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 ))) `),
`unknown operator`,
);
// ./test/core/simd/simd_lane.wast:549
assert_malformed(
() => instantiate(`(func (result v128) (i8x16.shuffle2_imm 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 ) (v128.const i8x16 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 ))) `),
`unknown operator`,
);
// ./test/core/simd/simd_lane.wast:555
assert_malformed(
() => instantiate(`(func (result v128) (v8x16.swizzle (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 ) (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 ))) `),
`unknown operator`,
);
// ./test/core/simd/simd_lane.wast:559
assert_malformed(
() => instantiate(`(func (result v128) (v8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 ) (v128.const i8x16 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 ))) `),
`unknown operator`,
);
// ./test/core/simd/simd_lane.wast:570
assert_malformed(
() => instantiate(`(func (param i32) (result i32) (i8x16.extract_lane_s (local.get 0 ) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ))) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:571
assert_malformed(
() => instantiate(`(func (param i32) (result i32) (i8x16.extract_lane_u (local.get 0 ) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ))) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:572
assert_malformed(
() => instantiate(`(func (param i32) (result i32) (i16x8.extract_lane_s (local.get 0 ) (v128.const i16x8 0 0 0 0 0 0 0 0 ))) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:573
assert_malformed(
() => instantiate(`(func (param i32) (result i32) (i16x8.extract_lane_u (local.get 0 ) (v128.const i16x8 0 0 0 0 0 0 0 0 ))) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:574
assert_malformed(
() => instantiate(`(func (param i32) (result i32) (i32x4.extract_lane (local.get 0 ) (v128.const i32x4 0 0 0 0 ))) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:575
assert_malformed(
() => instantiate(`(func (param i32) (result f32) (f32x4.extract_lane (local.get 0 ) (v128.const f32x4 0 0 0 0 ))) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:576
assert_malformed(
() => instantiate(`(func (param i32) (result v128) (i8x16.replace_lane (local.get 0 ) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ) (i32.const 1 ))) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:577
assert_malformed(
() => instantiate(`(func (param i32) (result v128) (i16x8.replace_lane (local.get 0 ) (v128.const i16x8 0 0 0 0 0 0 0 0 ) (i32.const 1 ))) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:578
assert_malformed(
() => instantiate(`(func (param i32) (result v128) (i32x4.replace_lane (local.get 0 ) (v128.const i32x4 0 0 0 0 ) (i32.const 1 ))) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:579
assert_malformed(
() => instantiate(`(func (param i32) (result v128) (f32x4.replace_lane (local.get 0 ) (v128.const f32x4 0 0 0 0 ) (f32.const 1 .0 ))) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:581
assert_malformed(
() => instantiate(`(func (param i32) (result i64) (i64x2.extract_lane (local.get 0 ) (v128.const i64x2 0 0 ))) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:582
assert_malformed(
() => instantiate(`(func (param i32) (result f64) (f64x2.extract_lane (local.get 0 ) (v128.const f64x2 0 0 ))) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:583
assert_malformed(
() => instantiate(`(func (param i32) (result v128) (i64x2.replace_lane (local.get 0 ) (v128.const i64x2 0 0 ) (i64.const 1 ))) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:584
assert_malformed(
() => instantiate(`(func (param i32) (result v128) (f64x2.replace_lane (local.get 0 ) (v128.const f64x2 0 0 ) (f64.const 1 .0 ))) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:588
assert_malformed(
() => instantiate(`(func (result i32) (i8x16.extract_lane_s 1 .5 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ))) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:589
assert_malformed(
() => instantiate(`(func (result i32) (i8x16.extract_lane_u nan (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ))) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:590
assert_malformed(
() => instantiate(`(func (result i32) (i16x8.extract_lane_s inf (v128.const i16x8 0 0 0 0 0 0 0 0 ))) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:591
assert_malformed(
() => instantiate(`(func (result i32) (i16x8.extract_lane_u -inf (v128.const i16x8 0 0 0 0 0 0 0 0 ))) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:592
assert_malformed(
() => instantiate(`(func (result i32) (i32x4.extract_lane nan (v128.const i32x4 0 0 0 0 ))) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:593
assert_malformed(
() => instantiate(`(func (result f32) (f32x4.extract_lane nan (v128.const f32x4 0 0 0 0 ))) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:594
assert_malformed(
() => instantiate(`(func (result v128) (i8x16.replace_lane -2 .5 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ) (i32.const 1 ))) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:595
assert_malformed(
() => instantiate(`(func (result v128) (i16x8.replace_lane nan (v128.const i16x8 0 0 0 0 0 0 0 0 ) (i32.const 1 ))) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:596
assert_malformed(
() => instantiate(`(func (result v128) (i32x4.replace_lane inf (v128.const i32x4 0 0 0 0 ) (i32.const 1 ))) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:597
assert_malformed(
() => instantiate(`(func (result v128) (f32x4.replace_lane -inf (v128.const f32x4 0 0 0 0 ) (f32.const 1 .1 ))) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:600
assert_malformed(
() => instantiate(`(func (result v128) (i8x16.shuffle (v128.const i8x16 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 ) (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 ) (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 ))) `),
`invalid lane length`,
);
// ./test/core/simd/simd_lane.wast:604
assert_malformed(
() => instantiate(`(func (result v128) (i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 .0 (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 ) (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 ))) `),
`malformed lane index`,
);
// ./test/core/simd/simd_lane.wast:608
assert_malformed(
() => instantiate(`(func (result v128) (i8x16.shuffle 0 .5 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 ) (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 ))) `),
`malformed lane index`,
);
// ./test/core/simd/simd_lane.wast:612
assert_malformed(
() => instantiate(`(func (result v128) (i8x16.shuffle -inf 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 ) (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 ))) `),
`malformed lane index`,
);
// ./test/core/simd/simd_lane.wast:616
assert_malformed(
() => instantiate(`(func (result v128) (i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 inf (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 ) (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 ))) `),
`malformed lane index`,
);
// ./test/core/simd/simd_lane.wast:620
assert_malformed(
() => instantiate(`(func (result v128) (i8x16.shuffle nan 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 ) (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 ))) `),
`malformed lane index`,
);
// ./test/core/simd/simd_lane.wast:628
let $1 = instantiate(`(module
;; as *.replace_lane's operand
(func (export "i8x16_extract_lane_s" ) (param v128 v128) (result v128)
(i8x16.replace_lane 0 (local.get 0 ) (i8x16.extract_lane_s 0 (local.get 1 ))))
(func (export "i8x16_extract_lane_u" ) (param v128 v128) (result v128)
(i8x16.replace_lane 0 (local.get 0 ) (i8x16.extract_lane_u 0 (local.get 1 ))))
(func (export "i16x8_extract_lane_s" ) (param v128 v128) (result v128)
(i16x8.replace_lane 0 (local.get 0 ) (i16x8.extract_lane_s 0 (local.get 1 ))))
(func (export "i16x8_extract_lane_u" ) (param v128 v128) (result v128)
(i16x8.replace_lane 0 (local.get 0 ) (i16x8.extract_lane_u 0 (local.get 1 ))))
(func (export "i32x4_extract_lane" ) (param v128 v128) (result v128)
(i32x4.replace_lane 0 (local.get 0 ) (i32x4.extract_lane 0 (local.get 1 ))))
(func (export "f32x4_extract_lane" ) (param v128 v128) (result v128)
(i32x4.replace_lane 0 (local.get 0 ) (i32x4.extract_lane 0 (local.get 1 ))))
(func (export "i64x2_extract_lane" ) (param v128 v128) (result v128)
(i64x2.replace_lane 0 (local.get 0 ) (i64x2.extract_lane 0 (local.get 1 ))))
(func (export "f64x2_extract_lane" ) (param v128 v128) (result v128)
(f64x2.replace_lane 0 (local.get 0 ) (f64x2.extract_lane 0 (local.get 1 ))))
;; as *.extract_lane's operand
(func (export "i8x16_replace_lane-s" ) (param v128 i32) (result i32)
(i8x16.extract_lane_s 15 (i8x16.replace_lane 15 (local.get 0 ) (local.get 1 ))))
(func (export "i8x16_replace_lane-u" ) (param v128 i32) (result i32)
(i8x16.extract_lane_u 15 (i8x16.replace_lane 15 (local.get 0 ) (local.get 1 ))))
(func (export "i16x8_replace_lane-s" ) (param v128 i32) (result i32)
(i16x8.extract_lane_s 7 (i16x8.replace_lane 7 (local.get 0 ) (local.get 1 ))))
(func (export "i16x8_replace_lane-u" ) (param v128 i32) (result i32)
(i16x8.extract_lane_u 7 (i16x8.replace_lane 7 (local.get 0 ) (local.get 1 ))))
(func (export "i32x4_replace_lane" ) (param v128 i32) (result i32)
(i32x4.extract_lane 3 (i32x4.replace_lane 3 (local.get 0 ) (local.get 1 ))))
(func (export "f32x4_replace_lane" ) (param v128 f32) (result f32)
(f32x4.extract_lane 3 (f32x4.replace_lane 3 (local.get 0 ) (local.get 1 ))))
(func (export "i64x2_replace_lane" ) (param v128 i64) (result i64)
(i64x2.extract_lane 1 (i64x2.replace_lane 1 (local.get 0 ) (local.get 1 ))))
(func (export "f64x2_replace_lane" ) (param v128 f64) (result f64)
(f64x2.extract_lane 1 (f64x2.replace_lane 1 (local.get 0 ) (local.get 1 ))))
;; i8x16.replace outputs as shuffle operand
(func (export "as-v8x16_swizzle-operand" ) (param v128 i32 v128) (result v128)
(i8x16.swizzle (i8x16.replace_lane 0 (local.get 0 ) (local.get 1 )) (local.get 2 )))
(func (export "as-v8x16_shuffle-operands" ) (param v128 i32 v128 i32) (result v128)
(i8x16.shuffle 16 1 18 3 20 5 22 7 24 9 26 11 28 13 30 15
(i8x16.replace_lane 0 (local.get 0 ) (local.get 1 ))
(i8x16.replace_lane 15 (local.get 2 ) (local.get 3 ))))
)`);
// ./test/core/simd/simd_lane.wast:674
assert_return(
() => invoke($1 , `i8x16_extract_lane_s`, [
i8x16([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
i8x16([0 xff, 0 xff, 0 xff, 0 xff, 0 xff, 0 xff, 0 xff, 0 xff, 0 xff, 0 xff, 0 xff, 0 xff, 0 xff, 0 xff, 0 xff, 0 xff]),
]),
[
i8x16([0 xff, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
],
);
// ./test/core/simd/simd_lane.wast:675
assert_return(
() => invoke($1 , `i8x16_extract_lane_u`, [
i8x16([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
i8x16([0 xff, 0 xff, 0 xff, 0 xff, 0 xff, 0 xff, 0 xff, 0 xff, 0 xff, 0 xff, 0 xff, 0 xff, 0 xff, 0 xff, 0 xff, 0 xff]),
]),
[
i8x16([0 xff, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
],
);
// ./test/core/simd/simd_lane.wast:676
assert_return(
() => invoke($1 , `i16x8_extract_lane_s`, [
i16x8([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
i16x8([0 xffff, 0 xffff, 0 xffff, 0 xffff, 0 xffff, 0 xffff, 0 xffff, 0 xffff]),
]),
[i16x8([0 xffff, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0])],
);
// ./test/core/simd/simd_lane.wast:677
assert_return(
() => invoke($1 , `i16x8_extract_lane_u`, [
i16x8([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
i16x8([0 xffff, 0 xffff, 0 xffff, 0 xffff, 0 xffff, 0 xffff, 0 xffff, 0 xffff]),
]),
[i16x8([0 xffff, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0])],
);
// ./test/core/simd/simd_lane.wast:678
assert_return(
() => invoke($1 , `i32x4_extract_lane`, [
i32x4([0 x0, 0 x0, 0 x0, 0 x0]),
i32x4([0 x10000, 0 xffffffff, 0 xffffffff, 0 xffffffff]),
]),
[i32x4([0 x10000, 0 x0, 0 x0, 0 x0])],
);
// ./test/core/simd/simd_lane.wast:679
assert_return(
() => invoke($1 , `f32x4_extract_lane`, [
f32x4([0 , 0 , 0 , 0 ]),
bytes('v128' , [
0 x99,
0 x76,
0 x96,
0 x7e,
0 x0,
0 x0,
0 xc0,
0 x7f,
0 x0,
0 x0,
0 xc0,
0 x7f,
0 x0,
0 x0,
0 xc0,
0 x7f,
]),
]),
[
new F32x4Pattern(
value("f32" , 100000000000000000000000000000000000000 ),
value("f32" , 0 ),
value("f32" , 0 ),
value("f32" , 0 ),
),
],
);
// ./test/core/simd/simd_lane.wast:680
assert_return(
() => invoke($1 , `i8x16_replace_lane-s`, [
i8x16([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
255 ,
]),
[value("i32" , -1 )],
);
// ./test/core/simd/simd_lane.wast:681
assert_return(
() => invoke($1 , `i8x16_replace_lane-u`, [
i8x16([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
255 ,
]),
[value("i32" , 255 )],
);
// ./test/core/simd/simd_lane.wast:682
assert_return(
() => invoke($1 , `i16x8_replace_lane-s`, [
i16x8([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
65535 ,
]),
[value("i32" , -1 )],
);
// ./test/core/simd/simd_lane.wast:683
assert_return(
() => invoke($1 , `i16x8_replace_lane-u`, [
i16x8([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
65535 ,
]),
[value("i32" , 65535 )],
);
// ./test/core/simd/simd_lane.wast:684
assert_return(
() => invoke($1 , `i32x4_replace_lane`, [i32x4([0 x0, 0 x0, 0 x0, 0 x0]), -1 ]),
[value("i32" , -1 )],
);
// ./test/core/simd/simd_lane.wast:685
assert_return(
() => invoke($1 , `f32x4_replace_lane`, [f32x4([0 , 0 , 0 , 0 ]), value("f32" , 1 .25 )]),
[value("f32" , 1 .25 )],
);
// ./test/core/simd/simd_lane.wast:687
assert_return(
() => invoke($1 , `i64x2_extract_lane`, [
i64x2([0 x0n, 0 x0n]),
i64x2([0 xffffffffffffffffn, 0 xffffffffffffffffn]),
]),
[i64x2([0 xffffffffffffffffn, 0 x0n])],
);
// ./test/core/simd/simd_lane.wast:688
assert_return(
() => invoke($1 , `f64x2_extract_lane`, [
f64x2([0 , 0 ]),
bytes('v128' , [
0 xa0,
0 xc8,
0 xeb,
0 x85,
0 xf3,
0 xcc,
0 xe1,
0 x7f,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 xf8,
0 x7f,
]),
]),
[
new F64x2Pattern(
value("f64" , 100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 ),
value("f64" , 0 ),
),
],
);
// ./test/core/simd/simd_lane.wast:689
assert_return(() => invoke($1 , `i64x2_replace_lane`, [i64x2([0 x0n, 0 x0n]), -1 n]), [value("i64" , -1 n)]);
// ./test/core/simd/simd_lane.wast:690
assert_return(
() => invoke($1 , `f64x2_replace_lane`, [f64x2([0 , 0 ]), value("f64" , 2 .5 )]),
[value("f64" , 2 .5 )],
);
// ./test/core/simd/simd_lane.wast:692
assert_return(
() => invoke($1 , `as-v8x16_swizzle-operand`, [
i8x16([0 x0, 0 x1, 0 x2, 0 x3, 0 x4, 0 x5, 0 x6, 0 x7, 0 x8, 0 x9, 0 xa, 0 xb, 0 xc, 0 xd, 0 xe, 0 xf]),
255 ,
i8x16([0 xff, 0 xf, 0 xe, 0 xd, 0 xc, 0 xb, 0 xa, 0 x9, 0 x8, 0 x7, 0 x6, 0 x5, 0 x4, 0 x3, 0 x2, 0 x1]),
]),
[
i8x16([0 x0, 0 xf, 0 xe, 0 xd, 0 xc, 0 xb, 0 xa, 0 x9, 0 x8, 0 x7, 0 x6, 0 x5, 0 x4, 0 x3, 0 x2, 0 x1]),
],
);
// ./test/core/simd/simd_lane.wast:696
assert_return(
() => invoke($1 , `as-v8x16_shuffle-operands`, [
i8x16([0 x0, 0 xff, 0 x0, 0 xff, 0 xf, 0 xff, 0 x0, 0 xff, 0 xff, 0 xff, 0 x0, 0 xff, 0 x7f, 0 xff, 0 x0, 0 xff]),
1 ,
i8x16([0 x55, 0 x0, 0 x55, 0 x0, 0 x55, 0 x0, 0 x55, 0 x0, 0 x55, 0 x0, 0 x55, 0 x0, 0 x55, 0 x1, 0 x55, 0 xff]),
0 ,
]),
[
i8x16([0 x55, 0 xff, 0 x55, 0 xff, 0 x55, 0 xff, 0 x55, 0 xff, 0 x55, 0 xff, 0 x55, 0 xff, 0 x55, 0 xff, 0 x55, 0 xff]),
],
);
// ./test/core/simd/simd_lane.wast:703
let $2 = instantiate(`(module
;; Constructing SIMD values
(func (export "as-i8x16_splat-operand" ) (param v128) (result v128)
(i8x16.splat (i8x16.extract_lane_s 0 (local.get 0 ))))
(func (export "as-i16x8_splat-operand" ) (param v128) (result v128)
(i16x8.splat (i16x8.extract_lane_u 0 (local.get 0 ))))
(func (export "as-i32x4_splat-operand" ) (param v128) (result v128)
(i32x4.splat (i32x4.extract_lane 0 (local.get 0 ))))
(func (export "as-f32x4_splat-operand" ) (param v128) (result v128)
(f32x4.splat (f32x4.extract_lane 0 (local.get 0 ))))
(func (export "as-i64x2_splat-operand" ) (param v128) (result v128)
(i64x2.splat (i64x2.extract_lane 0 (local.get 0 ))))
(func (export "as-f64x2_splat-operand" ) (param v128) (result v128)
(f64x2.splat (f64x2.extract_lane 0 (local.get 0 ))))
;; Integer arithmetic
(func (export "as-i8x16_add-operands" ) (param v128 i32 v128 i32) (result v128)
(i8x16.add (i8x16.replace_lane 0 (local.get 0 ) (local.get 1 )) (i8x16.replace_lane 15 (local.get 2 ) (local.get 3 ))))
(func (export "as-i16x8_add-operands" ) (param v128 i32 v128 i32) (result v128)
(i16x8.add (i16x8.replace_lane 0 (local.get 0 ) (local.get 1 )) (i16x8.replace_lane 7 (local.get 2 ) (local.get 3 ))))
(func (export "as-i32x4_add-operands" ) (param v128 i32 v128 i32) (result v128)
(i32x4.add (i32x4.replace_lane 0 (local.get 0 ) (local.get 1 )) (i32x4.replace_lane 3 (local.get 2 ) (local.get 3 ))))
(func (export "as-i64x2_add-operands" ) (param v128 i64 v128 i64) (result v128)
(i64x2.add (i64x2.replace_lane 0 (local.get 0 ) (local.get 1 )) (i64x2.replace_lane 1 (local.get 2 ) (local.get 3 ))))
(func (export "swizzle-as-i8x16_add-operands" ) (param v128 v128 v128 v128) (result v128)
(i8x16.add (i8x16.swizzle (local.get 0 ) (local.get 1 )) (i8x16.swizzle (local.get 2 ) (local.get 3 ))))
(func (export "shuffle-as-i8x16_sub-operands" ) (param v128 v128 v128 v128) (result v128)
(i8x16.sub (i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 (local.get 0 ) (local.get 1 ))
(i8x16.shuffle 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 (local.get 2 ) (local.get 3 ))))
;; Boolean horizontal reductions
(func (export "as-i8x16_any_true-operand" ) (param v128 i32) (result i32)
(v128.any_true (i8x16.replace_lane 0 (local.get 0 ) (local.get 1 ))))
(func (export "as-i16x8_any_true-operand" ) (param v128 i32) (result i32)
(v128.any_true (i16x8.replace_lane 0 (local.get 0 ) (local.get 1 ))))
(func (export "as-i32x4_any_true-operand1" ) (param v128 i32) (result i32)
(v128.any_true (i32x4.replace_lane 0 (local.get 0 ) (local.get 1 ))))
(func (export "as-i32x4_any_true-operand2" ) (param v128 i64) (result i32)
(v128.any_true (i64x2.replace_lane 0 (local.get 0 ) (local.get 1 ))))
(func (export "swizzle-as-i8x16_all_true-operands" ) (param v128 v128) (result i32)
(i8x16.all_true (i8x16.swizzle (local.get 0 ) (local.get 1 ))))
(func (export "shuffle-as-i8x16_any_true-operands" ) (param v128 v128) (result i32)
(v128.any_true (i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 (local.get 0 ) (local.get 1 ))))
)`);
// ./test/core/simd/simd_lane.wast:750
assert_return(
() => invoke($2 , `as-i8x16_splat-operand`, [
i8x16([0 xff, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
]),
[
i8x16([0 xff, 0 xff, 0 xff, 0 xff, 0 xff, 0 xff, 0 xff, 0 xff, 0 xff, 0 xff, 0 xff, 0 xff, 0 xff, 0 xff, 0 xff, 0 xff]),
],
);
// ./test/core/simd/simd_lane.wast:751
assert_return(
() => invoke($2 , `as-i16x8_splat-operand`, [
i16x8([0 xffff, 0 xffff, 0 xffff, 0 xffff, 0 x0, 0 x0, 0 x0, 0 x0]),
]),
[i16x8([0 xffff, 0 xffff, 0 xffff, 0 xffff, 0 xffff, 0 xffff, 0 xffff, 0 xffff])],
);
// ./test/core/simd/simd_lane.wast:752
assert_return(
() => invoke($2 , `as-i32x4_splat-operand`, [i32x4([0 x10000, 0 x0, 0 x0, 0 x0])]),
[i32x4([0 x10000, 0 x10000, 0 x10000, 0 x10000])],
);
// ./test/core/simd/simd_lane.wast:753
assert_return(
() => invoke($2 , `as-f32x4_splat-operand`, [
bytes('v128' , [
0 xc3,
0 xf5,
0 x48,
0 x40,
0 x0,
0 x0,
0 xc0,
0 x7f,
0 x0,
0 x0,
0 xc0,
0 x7f,
0 x0,
0 x0,
0 xc0,
0 x7f,
]),
]),
[
new F32x4Pattern(
value("f32" , 3 .14 ),
value("f32" , 3 .14 ),
value("f32" , 3 .14 ),
value("f32" , 3 .14 ),
),
],
);
// ./test/core/simd/simd_lane.wast:754
assert_return(
() => invoke($2 , `as-i64x2_splat-operand`, [i64x2([0 xffffffffffffffffn, 0 x0n])]),
[i64x2([0 xffffffffffffffffn, 0 xffffffffffffffffn])],
);
// ./test/core/simd/simd_lane.wast:755
assert_return(
() => invoke($2 , `as-f64x2_splat-operand`, [
bytes('v128' , [
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 xf0,
0 x7f,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 x0,
0 xf8,
0 x7f,
]),
]),
[new F64x2Pattern(value("f64" , Infinity), value("f64" , Infinity))],
);
// ./test/core/simd/simd_lane.wast:756
assert_return(
() => invoke($2 , `as-i8x16_add-operands`, [
i8x16([0 xff, 0 x2, 0 x3, 0 x4, 0 x5, 0 x6, 0 x7, 0 x8, 0 x9, 0 xa, 0 xb, 0 xc, 0 xd, 0 xe, 0 xf, 0 x10]),
1 ,
i8x16([0 x10, 0 xf, 0 xe, 0 xd, 0 xc, 0 xb, 0 xa, 0 x9, 0 x8, 0 x7, 0 x6, 0 x5, 0 x4, 0 x3, 0 x2, 0 xff]),
1 ,
]),
[
i8x16([0 x11, 0 x11, 0 x11, 0 x11, 0 x11, 0 x11, 0 x11, 0 x11, 0 x11, 0 x11, 0 x11, 0 x11, 0 x11, 0 x11, 0 x11, 0 x11]),
],
);
// ./test/core/simd/simd_lane.wast:760
assert_return(
() => invoke($2 , `as-i16x8_add-operands`, [
i16x8([0 xffff, 0 x4, 0 x9, 0 x10, 0 x19, 0 x24, 0 x31, 0 x40]),
1 ,
i16x8([0 x40, 0 x31, 0 x24, 0 x19, 0 x10, 0 x9, 0 x4, 0 xffff]),
1 ,
]),
[i16x8([0 x41, 0 x35, 0 x2d, 0 x29, 0 x29, 0 x2d, 0 x35, 0 x41])],
);
// ./test/core/simd/simd_lane.wast:764
assert_return(
() => invoke($2 , `as-i32x4_add-operands`, [
i32x4([0 xffffffff, 0 x8, 0 x1b, 0 x40]),
1 ,
i32x4([0 x40, 0 x1b, 0 x8, 0 xffffffff]),
1 ,
]),
[i32x4([0 x41, 0 x23, 0 x23, 0 x41])],
);
// ./test/core/simd/simd_lane.wast:766
assert_return(
() => invoke($2 , `as-i64x2_add-operands`, [
i64x2([0 xffffffffffffffffn, 0 x8n]),
1 n,
i64x2([0 x40n, 0 x1bn]),
1 n,
]),
[i64x2([0 x41n, 0 x9n])],
);
// ./test/core/simd/simd_lane.wast:769
assert_return(
() => invoke($2 , `swizzle-as-i8x16_add-operands`, [
i8x16([0 xf0, 0 xf1, 0 xf2, 0 xf3, 0 xf4, 0 xf5, 0 xf6, 0 xf7, 0 xf8, 0 xf9, 0 xfa, 0 xfb, 0 xfc, 0 xfd, 0 xfe, 0 xff]),
i8x16([0 x0, 0 x1, 0 x2, 0 x3, 0 x4, 0 x5, 0 x6, 0 x7, 0 x8, 0 x9, 0 xa, 0 xb, 0 xc, 0 xd, 0 xe, 0 xf]),
i8x16([0 x0, 0 x1, 0 x2, 0 x3, 0 x4, 0 x5, 0 x6, 0 x7, 0 x8, 0 x9, 0 xa, 0 xb, 0 xc, 0 xd, 0 xe, 0 xf]),
i8x16([0 xf, 0 xe, 0 xd, 0 xc, 0 xb, 0 xa, 0 x9, 0 x8, 0 x7, 0 x6, 0 x5, 0 x4, 0 x3, 0 x2, 0 x1, 0 x0]),
]),
[
i8x16([0 xff, 0 xff, 0 xff, 0 xff, 0 xff, 0 xff, 0 xff, 0 xff, 0 xff, 0 xff, 0 xff, 0 xff, 0 xff, 0 xff, 0 xff, 0 xff]),
],
);
// ./test/core/simd/simd_lane.wast:775
assert_return(
() => invoke($2 , `shuffle-as-i8x16_sub-operands`, [
i8x16([0 x0, 0 x1, 0 x2, 0 x3, 0 x4, 0 x5, 0 x6, 0 x7, 0 x8, 0 x9, 0 xa, 0 xb, 0 xc, 0 xd, 0 xe, 0 xf]),
i8x16([0 xf, 0 xe, 0 xd, 0 xc, 0 xb, 0 xa, 0 x9, 0 x8, 0 x7, 0 x6, 0 x5, 0 x4, 0 x3, 0 x2, 0 x1, 0 x0]),
i8x16([0 xf0, 0 xf1, 0 xf2, 0 xf3, 0 xf4, 0 xf5, 0 xf6, 0 xf7, 0 xf8, 0 xf9, 0 xfa, 0 xfb, 0 xfc, 0 xfd, 0 xfe, 0 xff]),
i8x16([0 xf, 0 xe, 0 xd, 0 xc, 0 xb, 0 xa, 0 x9, 0 x8, 0 x7, 0 x6, 0 x5, 0 x4, 0 x3, 0 x2, 0 x1, 0 x0]),
]),
[
i8x16([0 xf1, 0 xf3, 0 xf5, 0 xf7, 0 xf9, 0 xfb, 0 xfd, 0 xff, 0 x1, 0 x3, 0 x5, 0 x7, 0 x9, 0 xb, 0 xd, 0 xf]),
],
);
// ./test/core/simd/simd_lane.wast:782
assert_return(
() => invoke($2 , `as-i8x16_any_true-operand`, [
i8x16([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
1 ,
]),
[value("i32" , 1 )],
);
// ./test/core/simd/simd_lane.wast:783
assert_return(
() => invoke($2 , `as-i16x8_any_true-operand`, [
i16x8([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
1 ,
]),
[value("i32" , 1 )],
);
// ./test/core/simd/simd_lane.wast:784
assert_return(
() => invoke($2 , `as-i32x4_any_true-operand1`, [i32x4([0 x1, 0 x0, 0 x0, 0 x0]), 0 ]),
[value("i32" , 0 )],
);
// ./test/core/simd/simd_lane.wast:785
assert_return(
() => invoke($2 , `as-i32x4_any_true-operand2`, [i64x2([0 x1n, 0 x0n]), 0 n]),
[value("i32" , 0 )],
);
// ./test/core/simd/simd_lane.wast:787
assert_return(
() => invoke($2 , `swizzle-as-i8x16_all_true-operands`, [
i8x16([0 x1, 0 x2, 0 x3, 0 x4, 0 x5, 0 x6, 0 x7, 0 x8, 0 x9, 0 xa, 0 xb, 0 xc, 0 xd, 0 xe, 0 xf, 0 x10]),
i8x16([0 x0, 0 x1, 0 x2, 0 x3, 0 x4, 0 x5, 0 x6, 0 x7, 0 x8, 0 x9, 0 xa, 0 xb, 0 xc, 0 xd, 0 xe, 0 xf]),
]),
[value("i32" , 1 )],
);
// ./test/core/simd/simd_lane.wast:790
assert_return(
() => invoke($2 , `swizzle-as-i8x16_all_true-operands`, [
i8x16([0 xf0, 0 xf1, 0 xf2, 0 xf3, 0 xf4, 0 xf5, 0 xf6, 0 xf7, 0 xf8, 0 xf9, 0 xfa, 0 xfb, 0 xfc, 0 xfd, 0 xfe, 0 xff]),
i8x16([0 x0, 0 x1, 0 x2, 0 x3, 0 x4, 0 x5, 0 x6, 0 x7, 0 x8, 0 x9, 0 xa, 0 xb, 0 xc, 0 xd, 0 xe, 0 x10]),
]),
[value("i32" , 0 )],
);
// ./test/core/simd/simd_lane.wast:793
assert_return(
() => invoke($2 , `shuffle-as-i8x16_any_true-operands`, [
i8x16([0 xf0, 0 xf1, 0 xf2, 0 xf3, 0 xf4, 0 xf5, 0 xf6, 0 xf7, 0 xf8, 0 xf9, 0 xfa, 0 xfb, 0 xfc, 0 xfd, 0 xfe, 0 xff]),
i8x16([0 x0, 0 x1, 0 x2, 0 x3, 0 x4, 0 x5, 0 x6, 0 x7, 0 x8, 0 x9, 0 xa, 0 xb, 0 xc, 0 xd, 0 xe, 0 xf]),
]),
[value("i32" , 1 )],
);
// ./test/core/simd/simd_lane.wast:799
let $3 = instantiate(`(module
(memory 1 )
(func (export "as-v128_store-operand-1" ) (param v128 i32) (result v128)
(v128.store (i32.const 0 ) (i8x16.replace_lane 0 (local.get 0 ) (local.get 1 )))
(v128.load (i32.const 0 )))
(func (export "as-v128_store-operand-2" ) (param v128 i32) (result v128)
(v128.store (i32.const 0 ) (i16x8.replace_lane 0 (local.get 0 ) (local.get 1 )))
(v128.load (i32.const 0 )))
(func (export "as-v128_store-operand-3" ) (param v128 i32) (result v128)
(v128.store (i32.const 0 ) (i32x4.replace_lane 0 (local.get 0 ) (local.get 1 )))
(v128.load (i32.const 0 )))
(func (export "as-v128_store-operand-4" ) (param v128 f32) (result v128)
(v128.store (i32.const 0 ) (f32x4.replace_lane 0 (local.get 0 ) (local.get 1 )))
(v128.load (i32.const 0 )))
(func (export "as-v128_store-operand-5" ) (param v128 i64) (result v128)
(v128.store (i32.const 0 ) (i64x2.replace_lane 0 (local.get 0 ) (local.get 1 )))
(v128.load (i32.const 0 )))
(func (export "as-v128_store-operand-6" ) (param v128 f64) (result v128)
(v128.store (i32.const 0 ) (f64x2.replace_lane 0 (local.get 0 ) (local.get 1 )))
(v128.load (i32.const 0 )))
)`);
// ./test/core/simd/simd_lane.wast:821
assert_return(
() => invoke($3 , `as-v128_store-operand-1 `, [
i8x16([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
1 ,
]),
[
i8x16([0 x1, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
],
);
// ./test/core/simd/simd_lane.wast:822
assert_return(
() => invoke($3 , `as-v128_store-operand-2 `, [
i16x8([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
256 ,
]),
[i16x8([0 x100, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0])],
);
// ./test/core/simd/simd_lane.wast:823
assert_return(
() => invoke($3 , `as-v128_store-operand-3 `, [i32x4([0 x0, 0 x0, 0 x0, 0 x0]), -1 ]),
[i32x4([0 xffffffff, 0 x0, 0 x0, 0 x0])],
);
// ./test/core/simd/simd_lane.wast:824
assert_return(
() => invoke($3 , `as-v128_store-operand-4 `, [f32x4([0 , 0 , 0 , 0 ]), value("f32" , 3 .14 )]),
[
new F32x4Pattern(
value("f32" , 3 .14 ),
value("f32" , 0 ),
value("f32" , 0 ),
value("f32" , 0 ),
),
],
);
// ./test/core/simd/simd_lane.wast:825
assert_return(
() => invoke($3 , `as-v128_store-operand-5 `, [i64x2([0 x0n, 0 x0n]), -1 n]),
[i64x2([0 xffffffffffffffffn, 0 x0n])],
);
// ./test/core/simd/simd_lane.wast:826
assert_return(
() => invoke($3 , `as-v128_store-operand-6 `, [f64x2([0 , 0 ]), value("f64" , 3 .14 )]),
[new F64x2Pattern(value("f64" , 3 .14 ), value("f64" , 0 ))],
);
// ./test/core/simd/simd_lane.wast:830
let $4 = instantiate(`(module
(global $$g (mut v128) (v128.const f32x4 0 .0 0 .0 0 .0 0 .0 ))
(global $$h (mut v128) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ))
(func (export "as-if-condition-value" ) (param v128) (result i32)
(if (result i32) (i8x16.extract_lane_s 0 (local.get 0 )) (then (i32.const 0 xff)) (else (i32.const 0 ))))
(func (export "as-return-value-1" ) (param v128 i32) (result v128)
(return (i16x8.replace_lane 0 (local.get 0 ) (local.get 1 ))))
(func (export "as-local_set-value" ) (param v128) (result i32) (local i32)
(local.set 1 (i32x4.extract_lane 0 (local.get 0 )))
(return (local.get 1 )))
(func (export "as-global_set-value-1" ) (param v128 f32) (result v128)
(global.set $$g (f32x4.replace_lane 0 (local.get 0 ) (local.get 1 )))
(return (global.get $$g)))
(func (export "as-return-value-2" ) (param v128 v128) (result v128)
(return (i8x16.swizzle (local.get 0 ) (local.get 1 ))))
(func (export "as-global_set-value-2" ) (param v128 v128) (result v128)
(global.set $$h (i8x16.shuffle 0 1 2 3 4 5 6 7 24 25 26 27 28 29 30 31 (local.get 0 ) (local.get 1 )))
(return (global.get $$h)))
(func (export "as-local_set-value-1" ) (param v128) (result i64) (local i64)
(local.set 1 (i64x2.extract_lane 0 (local.get 0 )))
(return (local.get 1 )))
(func (export "as-global_set-value-3" ) (param v128 f64) (result v128)
(global.set $$g (f64x2.replace_lane 0 (local.get 0 ) (local.get 1 )))
(return (global.get $$g)))
)`);
// ./test/core/simd/simd_lane.wast:858
assert_return(
() => invoke($4 , `as-if -condition-value`, [
i8x16([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
]),
[value("i32" , 0 )],
);
// ./test/core/simd/simd_lane.wast:859
assert_return(
() => invoke($4 , `as-return -value-1 `, [
i16x8([0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0]),
1 ,
]),
[i16x8([0 x1, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0, 0 x0])],
);
// ./test/core/simd/simd_lane.wast:860
assert_return(
() => invoke($4 , `as-local_set-value`, [
i32x4([0 xffffffff, 0 xffffffff, 0 xffffffff, 0 xffffffff]),
]),
[value("i32" , -1 )],
);
// ./test/core/simd/simd_lane.wast:861
assert_return(
() => invoke($4 , `as-global_set-value-1 `, [f32x4([0 , 0 , 0 , 0 ]), value("f32" , 3 .14 )]),
[
new F32x4Pattern(
value("f32" , 3 .14 ),
value("f32" , 0 ),
value("f32" , 0 ),
value("f32" , 0 ),
),
],
);
// ./test/core/simd/simd_lane.wast:863
assert_return(
() => invoke($4 , `as-return -value-2 `, [
i8x16([0 xf0, 0 xf1, 0 xf2, 0 xf3, 0 xf4, 0 xf5, 0 xf6, 0 xf7, 0 xf8, 0 xf9, 0 xfa, 0 xfb, 0 xfc, 0 xfd, 0 xfe, 0 xff]),
i8x16([0 xf, 0 xe, 0 xd, 0 xc, 0 xb, 0 xa, 0 x9, 0 x8, 0 x7, 0 x6, 0 x5, 0 x4, 0 x3, 0 x2, 0 x1, 0 x0]),
]),
[
i8x16([0 xff, 0 xfe, 0 xfd, 0 xfc, 0 xfb, 0 xfa, 0 xf9, 0 xf8, 0 xf7, 0 xf6, 0 xf5, 0 xf4, 0 xf3, 0 xf2, 0 xf1, 0 xf0]),
],
);
// ./test/core/simd/simd_lane.wast:867
assert_return(
() => invoke($4 , `as-global_set-value-2 `, [
i8x16([0 xf0, 0 xf1, 0 xf2, 0 xf3, 0 xf4, 0 xf5, 0 xf6, 0 xf7, 0 xf8, 0 xf9, 0 xfa, 0 xfb, 0 xfc, 0 xfd, 0 xfe, 0 xff]),
i8x16([0 x10, 0 xf, 0 xe, 0 xd, 0 xc, 0 xb, 0 xa, 0 x9, 0 x8, 0 x7, 0 x6, 0 x5, 0 x4, 0 x3, 0 x2, 0 x1]),
]),
[
i8x16([0 xf0, 0 xf1, 0 xf2, 0 xf3, 0 xf4, 0 xf5, 0 xf6, 0 xf7, 0 x8, 0 x7, 0 x6, 0 x5, 0 x4, 0 x3, 0 x2, 0 x1]),
],
);
// ./test/core/simd/simd_lane.wast:872
assert_return(
() => invoke($4 , `as-local_set-value-1 `, [
i64x2([0 xffffffffffffffffn, 0 xffffffffffffffffn]),
]),
[value("i64" , -1 n)],
);
// ./test/core/simd/simd_lane.wast:873
assert_return(
() => invoke($4 , `as-global_set-value-3 `, [f64x2([0 , 0 ]), value("f64" , 3 .14 )]),
[new F64x2Pattern(value("f64" , 3 .14 ), value("f64" , 0 ))],
);
// ./test/core/simd/simd_lane.wast:877
assert_malformed(
() => instantiate(`(func (result i32) (i8x16.extract_lane_u +0 x0f (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ))) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:878
assert_malformed(
() => instantiate(`(func (result f32) (f32x4.extract_lane +03 (v128.const f32x4 0 0 0 0 ))) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:879
assert_malformed(
() => instantiate(`(func (result i64) (i64x2.extract_lane +1 (v128.const i64x2 0 0 ))) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:880
assert_malformed(
() => instantiate(`(func (result v128) (i8x16.replace_lane +015 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ) (i32.const 1 ))) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:881
assert_malformed(
() => instantiate(`(func (result v128) (i16x8.replace_lane +0 x7 (v128.const i16x8 0 0 0 0 0 0 0 0 ) (i32.const 1 ))) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:882
assert_malformed(
() => instantiate(`(func (result v128) (i32x4.replace_lane +3 (v128.const i32x4 0 0 0 0 ) (i32.const 1 ))) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:883
assert_malformed(
() => instantiate(`(func (result v128) (f64x2.replace_lane +0 x01 (v128.const f64x2 0 0 ) (f64.const 1 .0 ))) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:887
let $5 = instantiate(`(module (func (result i32) (i8x16.extract_lane_s 0 x0f (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ))))`);
// ./test/core/simd/simd_lane.wast:888
let $6 = instantiate(`(module (func (result i32) (i16x8.extract_lane_s 0 x07 (v128.const i16x8 0 0 0 0 0 0 0 0 ))))`);
// ./test/core/simd/simd_lane.wast:889
let $7 = instantiate(`(module (func (result i32) (i16x8.extract_lane_u 0 x0_7 (v128.const i16x8 0 0 0 0 0 0 0 0 ))))`);
// ./test/core/simd/simd_lane.wast:890
let $8 = instantiate(`(module (func (result i32) (i32x4.extract_lane 03 (v128.const i32x4 0 0 0 0 ))))`);
// ./test/core/simd/simd_lane.wast:891
let $9 = instantiate(`(module (func (result f64) (f64x2.extract_lane 0 x1 (v128.const f64x2 0 0 ))))`);
// ./test/core/simd/simd_lane.wast:892
let $10 = instantiate(`(module (func (result v128) (f32x4.replace_lane 0 x3 (v128.const f32x4 0 0 0 0 ) (f32.const 1 .0 ))))`);
// ./test/core/simd/simd_lane.wast:893
let $11 = instantiate(`(module (func (result v128) (i64x2.replace_lane 01 (v128.const i64x2 0 0 ) (i64.const 1 ))))`);
// ./test/core/simd/simd_lane.wast:897
assert_malformed(
() => instantiate(`(func (result i32) (i8x16.extract_lane_s 1 .0 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ))) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:901
assert_malformed(
() => instantiate(`(func $$i8x16.extract_lane_s-1 st-arg-empty (result i32) (i8x16.extract_lane_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 )) ) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:909
assert_invalid(
() => instantiate(`(module
(func $$i8x16.extract_lane_s-2 nd-arg-empty (result i32)
(i8x16.extract_lane_s 0 )
)
)`),
`type mismatch`,
);
// ./test/core/simd/simd_lane.wast:917
assert_malformed(
() => instantiate(`(func $$i8x16.extract_lane_s-arg-empty (result i32) (i8x16.extract_lane_s) ) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:925
assert_malformed(
() => instantiate(`(func $$i16x8.extract_lane_u-1 st-arg-empty (result i32) (i16x8.extract_lane_u (v128.const i16x8 0 0 0 0 0 0 0 0 )) ) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:933
assert_invalid(
() => instantiate(`(module
(func $$i16x8.extract_lane_u-2 nd-arg-empty (result i32)
(i16x8.extract_lane_u 0 )
)
)`),
`type mismatch`,
);
// ./test/core/simd/simd_lane.wast:941
assert_malformed(
() => instantiate(`(func $$i16x8.extract_lane_u-arg-empty (result i32) (i16x8.extract_lane_u) ) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:949
assert_malformed(
() => instantiate(`(func $$i32x4.extract_lane-1 st-arg-empty (result i32) (i32x4.extract_lane (v128.const i32x4 0 0 0 0 )) ) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:957
assert_invalid(
() => instantiate(`(module
(func $$i32x4.extract_lane-2 nd-arg-empty (result i32)
(i32x4.extract_lane 0 )
)
)`),
`type mismatch`,
);
// ./test/core/simd/simd_lane.wast:965
assert_malformed(
() => instantiate(`(func $$i32x4.extract_lane-arg-empty (result i32) (i32x4.extract_lane) ) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:973
assert_malformed(
() => instantiate(`(func $$i64x2.extract_lane-1 st-arg-empty (result i64) (i64x2.extract_lane (v128.const i64x2 0 0 )) ) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:981
assert_invalid(
() => instantiate(`(module
(func $$i64x2.extract_lane-2 nd-arg-empty (result i64)
(i64x2.extract_lane 0 )
)
)`),
`type mismatch`,
);
// ./test/core/simd/simd_lane.wast:989
assert_malformed(
() => instantiate(`(func $$i64x2.extract_lane-arg-empty (result i64) (i64x2.extract_lane) ) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:997
assert_malformed(
() => instantiate(`(func $$f32x4.extract_lane-1 st-arg-empty (result f32) (f32x4.extract_lane (v128.const f32x4 0 0 0 0 )) ) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:1005
assert_invalid(
() => instantiate(`(module
(func $$f32x4.extract_lane-2 nd-arg-empty (result f32)
(f32x4.extract_lane 0 )
)
)`),
`type mismatch`,
);
// ./test/core/simd/simd_lane.wast:1013
assert_malformed(
() => instantiate(`(func $$f32x4.extract_lane-arg-empty (result f32) (f32x4.extract_lane) ) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:1021
assert_malformed(
() => instantiate(`(func $$f64x2.extract_lane-1 st-arg-empty (result f64) (f64x2.extract_lane (v128.const f64x2 0 0 )) ) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:1029
assert_invalid(
() => instantiate(`(module
(func $$f64x2.extract_lane-2 nd-arg-empty (result f64)
(f64x2.extract_lane 0 )
)
)`),
`type mismatch`,
);
// ./test/core/simd/simd_lane.wast:1037
assert_malformed(
() => instantiate(`(func $$f64x2.extract_lane-arg-empty (result f64) (f64x2.extract_lane) ) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:1045
assert_malformed(
() => instantiate(`(func $$i8x16.replace_lane-1 st-arg-empty (result v128) (i8x16.replace_lane (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ) (i32.const 1 )) ) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:1053
assert_invalid(
() => instantiate(`(module
(func $$i8x16.replace_lane-2 nd-arg-empty (result v128)
(i8x16.replace_lane 0 (i32.const 1 ))
)
)`),
`type mismatch`,
);
// ./test/core/simd/simd_lane.wast:1061
assert_invalid(
() => instantiate(`(module
(func $$i8x16.replace_lane-3 rd-arg-empty (result v128)
(i8x16.replace_lane 0 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ))
)
)`),
`type mismatch`,
);
// ./test/core/simd/simd_lane.wast:1069
assert_malformed(
() => instantiate(`(func $$i8x16.replace_lane-arg-empty (result v128) (i8x16.replace_lane) ) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:1077
assert_malformed(
() => instantiate(`(func $$i16x8.replace_lane-1 st-arg-empty (result v128) (i16x8.replace_lane (v128.const i16x8 0 0 0 0 0 0 0 0 ) (i32.const 1 )) ) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:1085
assert_invalid(
() => instantiate(`(module
(func $$i16x8.replace_lane-2 nd-arg-empty (result v128)
(i16x8.replace_lane 0 (i32.const 1 ))
)
)`),
`type mismatch`,
);
// ./test/core/simd/simd_lane.wast:1093
assert_invalid(
() => instantiate(`(module
(func $$i16x8.replace_lane-3 rd-arg-empty (result v128)
(i16x8.replace_lane 0 (v128.const i16x8 0 0 0 0 0 0 0 0 ))
)
)`),
`type mismatch`,
);
// ./test/core/simd/simd_lane.wast:1101
assert_malformed(
() => instantiate(`(func $$i16x8.replace_lane-arg-empty (result v128) (i16x8.replace_lane) ) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:1109
assert_malformed(
() => instantiate(`(func $$i32x4.replace_lane-1 st-arg-empty (result v128) (i32x4.replace_lane (v128.const i32x4 0 0 0 0 ) (i32.const 1 )) ) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:1117
assert_invalid(
() => instantiate(`(module
(func $$i32x4.replace_lane-2 nd-arg-empty (result v128)
(i32x4.replace_lane 0 (i32.const 1 ))
)
)`),
`type mismatch`,
);
// ./test/core/simd/simd_lane.wast:1125
assert_invalid(
() => instantiate(`(module
(func $$i32x4.replace_lane-3 rd-arg-empty (result v128)
(i32x4.replace_lane 0 (v128.const i32x4 0 0 0 0 ))
)
)`),
`type mismatch`,
);
// ./test/core/simd/simd_lane.wast:1133
assert_malformed(
() => instantiate(`(func $$i32x4.replace_lane-arg-empty (result v128) (i32x4.replace_lane) ) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:1141
assert_malformed(
() => instantiate(`(func $$f32x4.replace_lane-1 st-arg-empty (result v128) (f32x4.replace_lane (v128.const f32x4 0 0 0 0 ) (f32.const 1 .0 )) ) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:1149
assert_invalid(
() => instantiate(`(module
(func $$f32x4.replace_lane-2 nd-arg-empty (result v128)
(f32x4.replace_lane 0 (f32.const 1 .0 ))
)
)`),
`type mismatch`,
);
// ./test/core/simd/simd_lane.wast:1157
assert_invalid(
() => instantiate(`(module
(func $$f32x4.replace_lane-3 rd-arg-empty (result v128)
(f32x4.replace_lane 0 (v128.const f32x4 0 0 0 0 ))
)
)`),
`type mismatch`,
);
// ./test/core/simd/simd_lane.wast:1165
assert_malformed(
() => instantiate(`(func $$f32x4.replace_lane-arg-empty (result v128) (f32x4.replace_lane) ) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:1173
assert_malformed(
() => instantiate(`(func $$i64x2.replace_lane-1 st-arg-empty (result v128) (i64x2.replace_lane (v128.const i64x2 0 0 ) (i64.const 1 )) ) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:1181
assert_invalid(
() => instantiate(`(module
(func $$i64x2.replace_lane-2 nd-arg-empty (result v128)
(i64x2.replace_lane 0 (i64.const 1 ))
)
)`),
`type mismatch`,
);
// ./test/core/simd/simd_lane.wast:1189
assert_invalid(
() => instantiate(`(module
(func $$i64x2.replace_lane-3 rd-arg-empty (result v128)
(i64x2.replace_lane 0 (v128.const i64x2 0 0 ))
)
)`),
`type mismatch`,
);
// ./test/core/simd/simd_lane.wast:1197
assert_malformed(
() => instantiate(`(func $$i64x2.replace_lane-arg-empty (result v128) (i64x2.replace_lane) ) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:1205
assert_malformed(
() => instantiate(`(func $$f64x2.replace_lane-1 st-arg-empty (result v128) (f64x2.replace_lane (v128.const f64x2 0 0 ) (f64.const 1 .0 )) ) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:1213
assert_invalid(
() => instantiate(`(module
(func $$f64x2.replace_lane-2 nd-arg-empty (result v128)
(f64x2.replace_lane 0 (f64.const 1 .0 ))
)
)`),
`type mismatch`,
);
// ./test/core/simd/simd_lane.wast:1221
assert_invalid(
() => instantiate(`(module
(func $$f64x2.replace_lane-3 rd-arg-empty (result v128)
(f64x2.replace_lane 0 (v128.const f64x2 0 0 ))
)
)`),
`type mismatch`,
);
// ./test/core/simd/simd_lane.wast:1229
assert_malformed(
() => instantiate(`(func $$f64x2.replace_lane-arg-empty (result v128) (f64x2.replace_lane) ) `),
`unexpected token`,
);
// ./test/core/simd/simd_lane.wast:1237
assert_malformed(
() => instantiate(`(func $$i8x16.shuffle-1 st-arg-empty (result v128) (i8x16.shuffle (v128.const i8x16 0 1 2 3 5 6 6 7 8 9 10 11 12 13 14 15 ) (v128.const i8x16 1 2 3 5 6 6 7 8 9 10 11 12 13 14 15 16 ) ) ) `),
`invalid lane length`,
);
// ./test/core/simd/simd_lane.wast:1248
assert_invalid(
() => instantiate(`(module
(func $$i8x16.shuffle-2 nd-arg-empty (result v128)
(i8x16.shuffle 0 1 2 3 5 6 6 7 8 9 10 11 12 13 14 15
(v128.const i8x16 1 2 3 5 6 6 7 8 9 10 11 12 13 14 15 16 )
)
)
)`),
`type mismatch`,
);
// ./test/core/simd/simd_lane.wast:1258
assert_malformed(
() => instantiate(`(func $$i8x16.shuffle-arg-empty (result v128) (i8x16.shuffle) ) `),
`invalid lane length`,
);
Messung V0.5 in Prozent C=88 H=98 G=93
¤ Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.0.105Bemerkung:
(vorverarbeitet am 2026-06-11)
¤
*© Formatika GbR, Deutschland