OLD | NEW |
---|---|
1 // Copyright 2016 the V8 project authors. All rights reserved. | 1 // Copyright 2016 the V8 project authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "src/assembler-inl.h" | 5 #include "src/assembler-inl.h" |
6 #include "src/wasm/wasm-macro-gen.h" | 6 #include "src/wasm/wasm-macro-gen.h" |
7 #include "test/cctest/cctest.h" | 7 #include "test/cctest/cctest.h" |
8 #include "test/cctest/compiler/value-helper.h" | 8 #include "test/cctest/compiler/value-helper.h" |
9 #include "test/cctest/wasm/wasm-run-utils.h" | 9 #include "test/cctest/wasm/wasm-run-utils.h" |
10 | 10 |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
50 T Sub(T a, T b) { | 50 T Sub(T a, T b) { |
51 return a - b; | 51 return a - b; |
52 } | 52 } |
53 | 53 |
54 template <typename T> | 54 template <typename T> |
55 T Mul(T a, T b) { | 55 T Mul(T a, T b) { |
56 return a * b; | 56 return a * b; |
57 } | 57 } |
58 | 58 |
59 template <typename T> | 59 template <typename T> |
60 T Div(T a, T b) { | |
61 return a / b; | |
62 } | |
63 | |
64 template <typename T> | |
60 T Minimum(T a, T b) { | 65 T Minimum(T a, T b) { |
61 return a <= b ? a : b; | 66 return a <= b ? a : b; |
62 } | 67 } |
63 | 68 |
64 template <typename T> | 69 template <typename T> |
65 T Maximum(T a, T b) { | 70 T Maximum(T a, T b) { |
66 return a >= b ? a : b; | 71 return a >= b ? a : b; |
67 } | 72 } |
68 | 73 |
69 template <typename T> | 74 template <typename T> |
(...skipping 132 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
202 return a ^ b; | 207 return a ^ b; |
203 } | 208 } |
204 | 209 |
205 template <typename T> | 210 template <typename T> |
206 T Not(T a) { | 211 T Not(T a) { |
207 return ~a; | 212 return ~a; |
208 } | 213 } |
209 | 214 |
210 } // namespace | 215 } // namespace |
211 | 216 |
217 #if !V8_TARGET_ARCH_ARM && !V8_TARGET_ARCH_X64 | |
218 #define SIMD_LOWERING_TARGET 1 | |
219 #else | |
220 #define SIMD_LOWERING_TARGET 0 | |
221 #endif // !V8_TARGET_ARCH_ARM && !V8_TARGET_ARCH_X64 | |
222 | |
212 // TODO(gdeepti): These are tests using sample values to verify functional | 223 // TODO(gdeepti): These are tests using sample values to verify functional |
213 // correctness of opcodes, add more tests for a range of values and macroize | 224 // correctness of opcodes, add more tests for a range of values and macroize |
214 // tests. | 225 // tests. |
215 | 226 |
216 // TODO(bbudge) Figure out how to compare floats in Wasm code that can handle | 227 // TODO(bbudge) Figure out how to compare floats in Wasm code that can handle |
217 // NaNs. For now, our tests avoid using NaNs. | 228 // NaNs. For now, our tests avoid using NaNs. |
229 | |
230 #define WASM_SIMD_F32x4_SPLAT(x) \ | |
231 x, kSimdPrefix, static_cast<byte>(kExprF32x4Splat) | |
bbudge
2017/02/27 18:26:15
These can be defined as WASM_SIMD_UNOP( op, x) if
aseemgarg
2017/02/27 22:09:46
Got rid of add macros and moved down others.
| |
232 | |
233 #define WASM_SIMD_F32x4_EXTRACT_LANE(lane, x) \ | |
234 x, kSimdPrefix, static_cast<byte>(kExprF32x4ExtractLane), \ | |
235 static_cast<byte>(lane) | |
236 | |
237 #define WASM_SIMD_F32x4_REPLACE_LANE(lane, x, y) \ | |
238 x, y, kSimdPrefix, static_cast<byte>(kExprF32x4ReplaceLane), \ | |
239 static_cast<byte>(lane) | |
240 | |
241 #define WASM_SIMD_F32x4_ADD(x, y) \ | |
242 x, y, kSimdPrefix, static_cast<byte>(kExprF32x4Add) | |
243 | |
244 #define WASM_SIMD_I32x4_SPLAT(x) \ | |
245 x, kSimdPrefix, static_cast<byte>(kExprI32x4Splat) | |
246 | |
247 #define WASM_SIMD_I32x4_EXTRACT_LANE(lane, x) \ | |
248 x, kSimdPrefix, static_cast<byte>(kExprI32x4ExtractLane), \ | |
249 static_cast<byte>(lane) | |
250 | |
251 #define WASM_SIMD_I32x4_REPLACE_LANE(lane, x, y) \ | |
252 x, y, kSimdPrefix, static_cast<byte>(kExprI32x4ReplaceLane), \ | |
253 static_cast<byte>(lane) | |
254 | |
255 #define WASM_SIMD_I32x4_ADD(x, y) \ | |
256 x, y, kSimdPrefix, static_cast<byte>(kExprI32x4Add) | |
257 | |
218 #define WASM_SIMD_CHECK_LANE(TYPE, value, LANE_TYPE, lane_value, lane_index) \ | 258 #define WASM_SIMD_CHECK_LANE(TYPE, value, LANE_TYPE, lane_value, lane_index) \ |
219 WASM_IF(WASM_##LANE_TYPE##_NE(WASM_GET_LOCAL(lane_value), \ | 259 WASM_IF(WASM_##LANE_TYPE##_NE(WASM_GET_LOCAL(lane_value), \ |
220 WASM_SIMD_##TYPE##_EXTRACT_LANE( \ | 260 WASM_SIMD_##TYPE##_EXTRACT_LANE( \ |
221 lane_index, WASM_GET_LOCAL(value))), \ | 261 lane_index, WASM_GET_LOCAL(value))), \ |
222 WASM_RETURN1(WASM_ZERO)) | 262 WASM_RETURN1(WASM_ZERO)) |
223 | 263 |
224 #define WASM_SIMD_CHECK4(TYPE, value, LANE_TYPE, lv0, lv1, lv2, lv3) \ | 264 #define WASM_SIMD_CHECK4(TYPE, value, LANE_TYPE, lv0, lv1, lv2, lv3) \ |
225 WASM_SIMD_CHECK_LANE(TYPE, value, LANE_TYPE, lv0, 0) \ | 265 WASM_SIMD_CHECK_LANE(TYPE, value, LANE_TYPE, lv0, 0) \ |
226 , WASM_SIMD_CHECK_LANE(TYPE, value, LANE_TYPE, lv1, 1), \ | 266 , WASM_SIMD_CHECK_LANE(TYPE, value, LANE_TYPE, lv1, 1), \ |
227 WASM_SIMD_CHECK_LANE(TYPE, value, LANE_TYPE, lv2, 2), \ | 267 WASM_SIMD_CHECK_LANE(TYPE, value, LANE_TYPE, lv2, 2), \ |
(...skipping 80 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
308 #define WASM_SIMD_I8x16_EXTRACT_LANE(lane, x) \ | 348 #define WASM_SIMD_I8x16_EXTRACT_LANE(lane, x) \ |
309 x, WASM_SIMD_OP(kExprI8x16ExtractLane), TO_BYTE(lane) | 349 x, WASM_SIMD_OP(kExprI8x16ExtractLane), TO_BYTE(lane) |
310 #define WASM_SIMD_I8x16_REPLACE_LANE(lane, x, y) \ | 350 #define WASM_SIMD_I8x16_REPLACE_LANE(lane, x, y) \ |
311 x, y, WASM_SIMD_OP(kExprI8x16ReplaceLane), TO_BYTE(lane) | 351 x, y, WASM_SIMD_OP(kExprI8x16ReplaceLane), TO_BYTE(lane) |
312 | 352 |
313 #define WASM_SIMD_F32x4_FROM_I32x4(x) x, WASM_SIMD_OP(kExprF32x4SConvertI32x4) | 353 #define WASM_SIMD_F32x4_FROM_I32x4(x) x, WASM_SIMD_OP(kExprF32x4SConvertI32x4) |
314 #define WASM_SIMD_F32x4_FROM_U32x4(x) x, WASM_SIMD_OP(kExprF32x4UConvertI32x4) | 354 #define WASM_SIMD_F32x4_FROM_U32x4(x) x, WASM_SIMD_OP(kExprF32x4UConvertI32x4) |
315 #define WASM_SIMD_I32x4_FROM_F32x4(x) x, WASM_SIMD_OP(kExprI32x4SConvertF32x4) | 355 #define WASM_SIMD_I32x4_FROM_F32x4(x) x, WASM_SIMD_OP(kExprI32x4SConvertF32x4) |
316 #define WASM_SIMD_U32x4_FROM_F32x4(x) x, WASM_SIMD_OP(kExprI32x4UConvertF32x4) | 356 #define WASM_SIMD_U32x4_FROM_F32x4(x) x, WASM_SIMD_OP(kExprI32x4UConvertF32x4) |
317 | 357 |
318 #if V8_TARGET_ARCH_ARM | 358 #if V8_TARGET_ARCH_ARM || SIMD_LOWERING_TARGET |
319 WASM_EXEC_TEST(F32x4Splat) { | 359 WASM_EXEC_COMPILED_TEST(F32x4Splat) { |
320 FLAG_wasm_simd_prototype = true; | 360 FLAG_wasm_simd_prototype = true; |
321 | 361 |
322 WasmRunner<int32_t, float> r(kExecuteCompiled); | 362 WasmRunner<int32_t, float> r(kExecuteCompiled); |
323 byte lane_val = 0; | 363 byte lane_val = 0; |
324 byte simd = r.AllocateLocal(kWasmS128); | 364 byte simd = r.AllocateLocal(kWasmS128); |
325 BUILD(r, | 365 BUILD(r, |
326 WASM_SET_LOCAL(simd, WASM_SIMD_F32x4_SPLAT(WASM_GET_LOCAL(lane_val))), | 366 WASM_SET_LOCAL(simd, WASM_SIMD_F32x4_SPLAT(WASM_GET_LOCAL(lane_val))), |
327 WASM_SIMD_CHECK_SPLAT4_F32(F32x4, simd, lane_val), WASM_ONE); | 367 WASM_SIMD_CHECK_SPLAT4_F32(F32x4, simd, lane_val), WASM_ONE); |
328 | 368 |
329 FOR_FLOAT32_INPUTS(i) { CHECK_EQ(1, r.Call(*i)); } | 369 FOR_FLOAT32_INPUTS(i) { CHECK_EQ(1, r.Call(*i)); } |
330 } | 370 } |
331 | 371 |
332 WASM_EXEC_TEST(F32x4ReplaceLane) { | 372 WASM_EXEC_COMPILED_TEST(F32x4ReplaceLane) { |
333 FLAG_wasm_simd_prototype = true; | 373 FLAG_wasm_simd_prototype = true; |
334 WasmRunner<int32_t, float, float> r(kExecuteCompiled); | 374 WasmRunner<int32_t, float, float> r(kExecuteCompiled); |
335 byte old_val = 0; | 375 byte old_val = 0; |
336 byte new_val = 1; | 376 byte new_val = 1; |
337 byte simd = r.AllocateLocal(kWasmS128); | 377 byte simd = r.AllocateLocal(kWasmS128); |
338 BUILD(r, WASM_SET_LOCAL(simd, WASM_SIMD_F32x4_SPLAT(WASM_GET_LOCAL(old_val))), | 378 BUILD(r, WASM_SET_LOCAL(simd, WASM_SIMD_F32x4_SPLAT(WASM_GET_LOCAL(old_val))), |
339 WASM_SET_LOCAL(simd, | 379 WASM_SET_LOCAL(simd, |
340 WASM_SIMD_F32x4_REPLACE_LANE(0, WASM_GET_LOCAL(simd), | 380 WASM_SIMD_F32x4_REPLACE_LANE(0, WASM_GET_LOCAL(simd), |
341 WASM_GET_LOCAL(new_val))), | 381 WASM_GET_LOCAL(new_val))), |
342 WASM_SIMD_CHECK4(F32x4, simd, F32, new_val, old_val, old_val, old_val), | 382 WASM_SIMD_CHECK4(F32x4, simd, F32, new_val, old_val, old_val, old_val), |
343 WASM_SET_LOCAL(simd, | 383 WASM_SET_LOCAL(simd, |
344 WASM_SIMD_F32x4_REPLACE_LANE(1, WASM_GET_LOCAL(simd), | 384 WASM_SIMD_F32x4_REPLACE_LANE(1, WASM_GET_LOCAL(simd), |
345 WASM_GET_LOCAL(new_val))), | 385 WASM_GET_LOCAL(new_val))), |
346 WASM_SIMD_CHECK4(F32x4, simd, F32, new_val, new_val, old_val, old_val), | 386 WASM_SIMD_CHECK4(F32x4, simd, F32, new_val, new_val, old_val, old_val), |
347 WASM_SET_LOCAL(simd, | 387 WASM_SET_LOCAL(simd, |
348 WASM_SIMD_F32x4_REPLACE_LANE(2, WASM_GET_LOCAL(simd), | 388 WASM_SIMD_F32x4_REPLACE_LANE(2, WASM_GET_LOCAL(simd), |
349 WASM_GET_LOCAL(new_val))), | 389 WASM_GET_LOCAL(new_val))), |
350 WASM_SIMD_CHECK4(F32x4, simd, F32, new_val, new_val, new_val, old_val), | 390 WASM_SIMD_CHECK4(F32x4, simd, F32, new_val, new_val, new_val, old_val), |
351 WASM_SET_LOCAL(simd, | 391 WASM_SET_LOCAL(simd, |
352 WASM_SIMD_F32x4_REPLACE_LANE(3, WASM_GET_LOCAL(simd), | 392 WASM_SIMD_F32x4_REPLACE_LANE(3, WASM_GET_LOCAL(simd), |
353 WASM_GET_LOCAL(new_val))), | 393 WASM_GET_LOCAL(new_val))), |
354 WASM_SIMD_CHECK_SPLAT4(F32x4, simd, F32, new_val), WASM_ONE); | 394 WASM_SIMD_CHECK_SPLAT4(F32x4, simd, F32, new_val), WASM_ONE); |
355 | 395 |
356 CHECK_EQ(1, r.Call(3.14159, -1.5)); | 396 CHECK_EQ(1, r.Call(3.14159f, -1.5f)); |
357 } | 397 } |
398 #endif // V8_TARGET_ARCH_ARM || SIMD_LOWERING_TARGET | |
358 | 399 |
400 #if V8_TARGET_ARCH_ARM | |
359 // Tests both signed and unsigned conversion. | 401 // Tests both signed and unsigned conversion. |
360 WASM_EXEC_TEST(F32x4FromInt32x4) { | 402 WASM_EXEC_COMPILED_TEST(F32x4FromInt32x4) { |
361 FLAG_wasm_simd_prototype = true; | 403 FLAG_wasm_simd_prototype = true; |
362 WasmRunner<int32_t, int32_t, float, float> r(kExecuteCompiled); | 404 WasmRunner<int32_t, int32_t, float, float> r(kExecuteCompiled); |
363 byte a = 0; | 405 byte a = 0; |
364 byte expected_signed = 1; | 406 byte expected_signed = 1; |
365 byte expected_unsigned = 2; | 407 byte expected_unsigned = 2; |
366 byte simd0 = r.AllocateLocal(kWasmS128); | 408 byte simd0 = r.AllocateLocal(kWasmS128); |
367 byte simd1 = r.AllocateLocal(kWasmS128); | 409 byte simd1 = r.AllocateLocal(kWasmS128); |
368 byte simd2 = r.AllocateLocal(kWasmS128); | 410 byte simd2 = r.AllocateLocal(kWasmS128); |
369 BUILD( | 411 BUILD( |
370 r, WASM_SET_LOCAL(simd0, WASM_SIMD_I32x4_SPLAT(WASM_GET_LOCAL(a))), | 412 r, WASM_SET_LOCAL(simd0, WASM_SIMD_I32x4_SPLAT(WASM_GET_LOCAL(a))), |
(...skipping 17 matching lines...) Expand all Loading... | |
388 BUILD(r, WASM_SET_LOCAL(simd, WASM_SIMD_F32x4_SPLAT(WASM_GET_LOCAL(a))), | 430 BUILD(r, WASM_SET_LOCAL(simd, WASM_SIMD_F32x4_SPLAT(WASM_GET_LOCAL(a))), |
389 WASM_SET_LOCAL(simd, WASM_SIMD_UNOP(simd_op, WASM_GET_LOCAL(simd))), | 431 WASM_SET_LOCAL(simd, WASM_SIMD_UNOP(simd_op, WASM_GET_LOCAL(simd))), |
390 WASM_SIMD_CHECK_SPLAT4_F32(F32x4, simd, expected), WASM_ONE); | 432 WASM_SIMD_CHECK_SPLAT4_F32(F32x4, simd, expected), WASM_ONE); |
391 | 433 |
392 FOR_FLOAT32_INPUTS(i) { | 434 FOR_FLOAT32_INPUTS(i) { |
393 if (std::isnan(*i)) continue; | 435 if (std::isnan(*i)) continue; |
394 CHECK_EQ(1, r.Call(*i, expected_op(*i))); | 436 CHECK_EQ(1, r.Call(*i, expected_op(*i))); |
395 } | 437 } |
396 } | 438 } |
397 | 439 |
398 WASM_EXEC_TEST(F32x4Abs) { RunF32x4UnOpTest(kExprF32x4Abs, std::abs); } | 440 WASM_EXEC_COMPILED_TEST(F32x4Abs) { RunF32x4UnOpTest(kExprF32x4Abs, std::abs); } |
399 WASM_EXEC_TEST(F32x4Neg) { RunF32x4UnOpTest(kExprF32x4Neg, Negate); } | 441 WASM_EXEC_COMPILED_TEST(F32x4Neg) { RunF32x4UnOpTest(kExprF32x4Neg, Negate); } |
442 #endif // V8_TARGET_ARCH_ARM | |
400 | 443 |
401 void RunF32x4BinOpTest(WasmOpcode simd_op, FloatBinOp expected_op) { | 444 #if V8_TARGET_ARCH_ARM || SIMD_LOWERING_TARGET |
445 void RunF32x4BinOpTest(WasmOpcode simd_op, FloatBinOp expected_op, | |
446 bool skip_zero_inputs = false) { | |
402 FLAG_wasm_simd_prototype = true; | 447 FLAG_wasm_simd_prototype = true; |
403 WasmRunner<int32_t, float, float, float> r(kExecuteCompiled); | 448 WasmRunner<int32_t, float, float, float> r(kExecuteCompiled); |
404 byte a = 0; | 449 byte a = 0; |
405 byte b = 1; | 450 byte b = 1; |
406 byte expected = 2; | 451 byte expected = 2; |
407 byte simd0 = r.AllocateLocal(kWasmS128); | 452 byte simd0 = r.AllocateLocal(kWasmS128); |
408 byte simd1 = r.AllocateLocal(kWasmS128); | 453 byte simd1 = r.AllocateLocal(kWasmS128); |
409 BUILD(r, WASM_SET_LOCAL(simd0, WASM_SIMD_F32x4_SPLAT(WASM_GET_LOCAL(a))), | 454 BUILD(r, WASM_SET_LOCAL(simd0, WASM_SIMD_F32x4_SPLAT(WASM_GET_LOCAL(a))), |
410 WASM_SET_LOCAL(simd1, WASM_SIMD_F32x4_SPLAT(WASM_GET_LOCAL(b))), | 455 WASM_SET_LOCAL(simd1, WASM_SIMD_F32x4_SPLAT(WASM_GET_LOCAL(b))), |
411 WASM_SET_LOCAL(simd1, WASM_SIMD_BINOP(simd_op, WASM_GET_LOCAL(simd0), | 456 WASM_SET_LOCAL(simd1, WASM_SIMD_BINOP(simd_op, WASM_GET_LOCAL(simd0), |
412 WASM_GET_LOCAL(simd1))), | 457 WASM_GET_LOCAL(simd1))), |
413 WASM_SIMD_CHECK_SPLAT4_F32(F32x4, simd1, expected), WASM_ONE); | 458 WASM_SIMD_CHECK_SPLAT4_F32(F32x4, simd1, expected), WASM_ONE); |
414 | 459 |
415 FOR_FLOAT32_INPUTS(i) { | 460 FOR_FLOAT32_INPUTS(i) { |
416 if (std::isnan(*i)) continue; | 461 if (std::isnan(*i)) continue; |
417 FOR_FLOAT32_INPUTS(j) { | 462 FOR_FLOAT32_INPUTS(j) { |
418 if (std::isnan(*j)) continue; | 463 if (std::isnan(*j)) continue; |
464 if (skip_zero_inputs && std::fpclassify(*i) == FP_ZERO && | |
465 std::fpclassify(*j) == FP_ZERO) | |
466 continue; | |
419 float expected = expected_op(*i, *j); | 467 float expected = expected_op(*i, *j); |
420 // SIMD on some platforms may handle denormalized numbers differently. | 468 // SIMD on some platforms may handle denormalized numbers differently. |
421 // TODO(bbudge) On platforms that flush denorms to zero, test with | 469 // TODO(bbudge) On platforms that flush denorms to zero, test with |
422 // expected == 0. | 470 // expected == 0. |
423 if (std::fpclassify(expected) == FP_SUBNORMAL) continue; | 471 if (std::fpclassify(expected) == FP_SUBNORMAL) continue; |
472 if (std::isnan(expected)) continue; | |
424 CHECK_EQ(1, r.Call(*i, *j, expected)); | 473 CHECK_EQ(1, r.Call(*i, *j, expected)); |
425 } | 474 } |
426 } | 475 } |
427 } | 476 } |
428 | 477 |
429 WASM_EXEC_TEST(F32x4Add) { RunF32x4BinOpTest(kExprF32x4Add, Add); } | 478 WASM_EXEC_COMPILED_TEST(F32x4Add) { RunF32x4BinOpTest(kExprF32x4Add, Add); } |
430 WASM_EXEC_TEST(F32x4Sub) { RunF32x4BinOpTest(kExprF32x4Sub, Sub); } | 479 WASM_EXEC_COMPILED_TEST(F32x4Sub) { RunF32x4BinOpTest(kExprF32x4Sub, Sub); } |
480 #endif // V8_TARGET_ARCH_ARM || SIMD_LOWERING_TARGET | |
431 | 481 |
482 #if SIMD_LOWERING_TARGET | |
483 WASM_EXEC_COMPILED_TEST(F32x4Mul) { RunF32x4BinOpTest(kExprF32x4Mul, Mul); } | |
484 WASM_EXEC_COMPILED_TEST(F32x4Div) { RunF32x4BinOpTest(kExprF32x4Div, Div); } | |
485 WASM_EXEC_COMPILED_TEST(Simd_F32x4_Min) { | |
486 RunF32x4BinOpTest(kExprF32x4Min, Minimum, true); | |
487 } | |
488 WASM_EXEC_COMPILED_TEST(Simd_F32x4_Max) { | |
489 RunF32x4BinOpTest(kExprF32x4Max, Maximum, true); | |
490 } | |
491 #endif // SIMD_LOWERING_TARGET | |
492 | |
493 #if V8_TARGET_ARCH_ARM | |
432 void RunF32x4CompareOpTest(WasmOpcode simd_op, FloatCompareOp expected_op) { | 494 void RunF32x4CompareOpTest(WasmOpcode simd_op, FloatCompareOp expected_op) { |
433 FLAG_wasm_simd_prototype = true; | 495 FLAG_wasm_simd_prototype = true; |
434 WasmRunner<int32_t, float, float, int32_t> r(kExecuteCompiled); | 496 WasmRunner<int32_t, float, float, int32_t> r(kExecuteCompiled); |
435 byte a = 0; | 497 byte a = 0; |
436 byte b = 1; | 498 byte b = 1; |
437 byte expected = 2; | 499 byte expected = 2; |
438 byte simd0 = r.AllocateLocal(kWasmS128); | 500 byte simd0 = r.AllocateLocal(kWasmS128); |
439 byte simd1 = r.AllocateLocal(kWasmS128); | 501 byte simd1 = r.AllocateLocal(kWasmS128); |
440 BUILD(r, WASM_SET_LOCAL(simd0, WASM_SIMD_F32x4_SPLAT(WASM_GET_LOCAL(a))), | 502 BUILD(r, WASM_SET_LOCAL(simd0, WASM_SIMD_F32x4_SPLAT(WASM_GET_LOCAL(a))), |
441 WASM_SET_LOCAL(simd1, WASM_SIMD_F32x4_SPLAT(WASM_GET_LOCAL(b))), | 503 WASM_SET_LOCAL(simd1, WASM_SIMD_F32x4_SPLAT(WASM_GET_LOCAL(b))), |
442 WASM_SET_LOCAL(simd1, | 504 WASM_SET_LOCAL(simd1, |
443 WASM_SIMD_MATERIALIZE_BOOLS( | 505 WASM_SIMD_MATERIALIZE_BOOLS( |
444 32x4, WASM_SIMD_BINOP(simd_op, WASM_GET_LOCAL(simd0), | 506 32x4, WASM_SIMD_BINOP(simd_op, WASM_GET_LOCAL(simd0), |
445 WASM_GET_LOCAL(simd1)))), | 507 WASM_GET_LOCAL(simd1)))), |
446 WASM_SIMD_CHECK_SPLAT4(I32x4, simd1, I32, expected), WASM_ONE); | 508 WASM_SIMD_CHECK_SPLAT4(I32x4, simd1, I32, expected), WASM_ONE); |
447 | 509 |
448 FOR_FLOAT32_INPUTS(i) { | 510 FOR_FLOAT32_INPUTS(i) { |
449 if (std::isnan(*i)) continue; | 511 if (std::isnan(*i)) continue; |
450 FOR_FLOAT32_INPUTS(j) { | 512 FOR_FLOAT32_INPUTS(j) { |
451 if (std::isnan(*j)) continue; | 513 if (std::isnan(*j)) continue; |
452 // SIMD on some platforms may handle denormalized numbers differently. | 514 // SIMD on some platforms may handle denormalized numbers differently. |
453 // Check for number pairs that are very close together. | 515 // Check for number pairs that are very close together. |
454 if (std::fpclassify(*i - *j) == FP_SUBNORMAL) continue; | 516 if (std::fpclassify(*i - *j) == FP_SUBNORMAL) continue; |
455 CHECK_EQ(1, r.Call(*i, *j, expected_op(*i, *j))); | 517 CHECK_EQ(1, r.Call(*i, *j, expected_op(*i, *j))); |
456 } | 518 } |
457 } | 519 } |
458 } | 520 } |
459 | 521 |
460 WASM_EXEC_TEST(F32x4Equal) { RunF32x4CompareOpTest(kExprF32x4Eq, Equal); } | 522 WASM_EXEC_COMPILED_TEST(F32x4Equal) { |
461 WASM_EXEC_TEST(F32x4NotEqual) { RunF32x4CompareOpTest(kExprF32x4Ne, NotEqual); } | 523 RunF32x4CompareOpTest(kExprF32x4Eq, Equal); |
524 } | |
525 | |
526 WASM_EXEC_COMPILED_TEST(F32x4NotEqual) { | |
527 RunF32x4CompareOpTest(kExprF32x4Ne, NotEqual); | |
528 } | |
462 #endif // V8_TARGET_ARCH_ARM | 529 #endif // V8_TARGET_ARCH_ARM |
463 | 530 |
464 WASM_EXEC_TEST(I32x4Splat) { | 531 WASM_EXEC_COMPILED_TEST(I32x4Splat) { |
465 FLAG_wasm_simd_prototype = true; | 532 FLAG_wasm_simd_prototype = true; |
466 | 533 |
467 // Store SIMD value in a local variable, use extract lane to check lane values | 534 // Store SIMD value in a local variable, use extract lane to check lane values |
468 // This test is not a test for ExtractLane as Splat does not create | 535 // This test is not a test for ExtractLane as Splat does not create |
469 // interesting SIMD values. | 536 // interesting SIMD values. |
470 // | 537 // |
471 // SetLocal(1, I32x4Splat(Local(0))); | 538 // SetLocal(1, I32x4Splat(Local(0))); |
472 // For each lane index | 539 // For each lane index |
473 // if(Local(0) != I32x4ExtractLane(Local(1), index) | 540 // if(Local(0) != I32x4ExtractLane(Local(1), index) |
474 // return 0 | 541 // return 0 |
475 // | 542 // |
476 // return 1 | 543 // return 1 |
477 WasmRunner<int32_t, int32_t> r(kExecuteCompiled); | 544 WasmRunner<int32_t, int32_t> r(kExecuteCompiled); |
478 byte lane_val = 0; | 545 byte lane_val = 0; |
479 byte simd = r.AllocateLocal(kWasmS128); | 546 byte simd = r.AllocateLocal(kWasmS128); |
480 BUILD(r, | 547 BUILD(r, |
481 WASM_SET_LOCAL(simd, WASM_SIMD_I32x4_SPLAT(WASM_GET_LOCAL(lane_val))), | 548 WASM_SET_LOCAL(simd, WASM_SIMD_I32x4_SPLAT(WASM_GET_LOCAL(lane_val))), |
482 WASM_SIMD_CHECK_SPLAT4(I32x4, simd, I32, lane_val), WASM_ONE); | 549 WASM_SIMD_CHECK_SPLAT4(I32x4, simd, I32, lane_val), WASM_ONE); |
483 | 550 |
484 FOR_INT32_INPUTS(i) { CHECK_EQ(1, r.Call(*i)); } | 551 FOR_INT32_INPUTS(i) { CHECK_EQ(1, r.Call(*i)); } |
485 } | 552 } |
486 | 553 |
487 WASM_EXEC_TEST(I32x4ReplaceLane) { | 554 WASM_EXEC_COMPILED_TEST(I32x4ReplaceLane) { |
488 FLAG_wasm_simd_prototype = true; | 555 FLAG_wasm_simd_prototype = true; |
489 WasmRunner<int32_t, int32_t, int32_t> r(kExecuteCompiled); | 556 WasmRunner<int32_t, int32_t, int32_t> r(kExecuteCompiled); |
490 byte old_val = 0; | 557 byte old_val = 0; |
491 byte new_val = 1; | 558 byte new_val = 1; |
492 byte simd = r.AllocateLocal(kWasmS128); | 559 byte simd = r.AllocateLocal(kWasmS128); |
493 BUILD(r, WASM_SET_LOCAL(simd, WASM_SIMD_I32x4_SPLAT(WASM_GET_LOCAL(old_val))), | 560 BUILD(r, WASM_SET_LOCAL(simd, WASM_SIMD_I32x4_SPLAT(WASM_GET_LOCAL(old_val))), |
494 WASM_SET_LOCAL(simd, | 561 WASM_SET_LOCAL(simd, |
495 WASM_SIMD_I32x4_REPLACE_LANE(0, WASM_GET_LOCAL(simd), | 562 WASM_SIMD_I32x4_REPLACE_LANE(0, WASM_GET_LOCAL(simd), |
496 WASM_GET_LOCAL(new_val))), | 563 WASM_GET_LOCAL(new_val))), |
497 WASM_SIMD_CHECK4(I32x4, simd, I32, new_val, old_val, old_val, old_val), | 564 WASM_SIMD_CHECK4(I32x4, simd, I32, new_val, old_val, old_val, old_val), |
498 WASM_SET_LOCAL(simd, | 565 WASM_SET_LOCAL(simd, |
499 WASM_SIMD_I32x4_REPLACE_LANE(1, WASM_GET_LOCAL(simd), | 566 WASM_SIMD_I32x4_REPLACE_LANE(1, WASM_GET_LOCAL(simd), |
500 WASM_GET_LOCAL(new_val))), | 567 WASM_GET_LOCAL(new_val))), |
501 WASM_SIMD_CHECK4(I32x4, simd, I32, new_val, new_val, old_val, old_val), | 568 WASM_SIMD_CHECK4(I32x4, simd, I32, new_val, new_val, old_val, old_val), |
502 WASM_SET_LOCAL(simd, | 569 WASM_SET_LOCAL(simd, |
503 WASM_SIMD_I32x4_REPLACE_LANE(2, WASM_GET_LOCAL(simd), | 570 WASM_SIMD_I32x4_REPLACE_LANE(2, WASM_GET_LOCAL(simd), |
504 WASM_GET_LOCAL(new_val))), | 571 WASM_GET_LOCAL(new_val))), |
505 WASM_SIMD_CHECK4(I32x4, simd, I32, new_val, new_val, new_val, old_val), | 572 WASM_SIMD_CHECK4(I32x4, simd, I32, new_val, new_val, new_val, old_val), |
506 WASM_SET_LOCAL(simd, | 573 WASM_SET_LOCAL(simd, |
507 WASM_SIMD_I32x4_REPLACE_LANE(3, WASM_GET_LOCAL(simd), | 574 WASM_SIMD_I32x4_REPLACE_LANE(3, WASM_GET_LOCAL(simd), |
508 WASM_GET_LOCAL(new_val))), | 575 WASM_GET_LOCAL(new_val))), |
509 WASM_SIMD_CHECK_SPLAT4(I32x4, simd, I32, new_val), WASM_ONE); | 576 WASM_SIMD_CHECK_SPLAT4(I32x4, simd, I32, new_val), WASM_ONE); |
510 | 577 |
511 CHECK_EQ(1, r.Call(1, 2)); | 578 CHECK_EQ(1, r.Call(1, 2)); |
512 } | 579 } |
513 | 580 |
514 #if V8_TARGET_ARCH_ARM | 581 #if V8_TARGET_ARCH_ARM |
515 | 582 |
516 WASM_EXEC_TEST(I16x8Splat) { | 583 WASM_EXEC_COMPILED_TEST(I16x8Splat) { |
517 FLAG_wasm_simd_prototype = true; | 584 FLAG_wasm_simd_prototype = true; |
518 | 585 |
519 WasmRunner<int32_t, int32_t> r(kExecuteCompiled); | 586 WasmRunner<int32_t, int32_t> r(kExecuteCompiled); |
520 byte lane_val = 0; | 587 byte lane_val = 0; |
521 byte simd = r.AllocateLocal(kWasmS128); | 588 byte simd = r.AllocateLocal(kWasmS128); |
522 BUILD(r, | 589 BUILD(r, |
523 WASM_SET_LOCAL(simd, WASM_SIMD_I16x8_SPLAT(WASM_GET_LOCAL(lane_val))), | 590 WASM_SET_LOCAL(simd, WASM_SIMD_I16x8_SPLAT(WASM_GET_LOCAL(lane_val))), |
524 WASM_SIMD_CHECK_SPLAT8(I16x8, simd, I32, lane_val), WASM_ONE); | 591 WASM_SIMD_CHECK_SPLAT8(I16x8, simd, I32, lane_val), WASM_ONE); |
525 | 592 |
526 FOR_INT16_INPUTS(i) { CHECK_EQ(1, r.Call(*i)); } | 593 FOR_INT16_INPUTS(i) { CHECK_EQ(1, r.Call(*i)); } |
527 } | 594 } |
528 | 595 |
529 WASM_EXEC_TEST(I16x8ReplaceLane) { | 596 WASM_EXEC_COMPILED_TEST(I16x8ReplaceLane) { |
530 FLAG_wasm_simd_prototype = true; | 597 FLAG_wasm_simd_prototype = true; |
531 WasmRunner<int32_t, int32_t, int32_t> r(kExecuteCompiled); | 598 WasmRunner<int32_t, int32_t, int32_t> r(kExecuteCompiled); |
532 byte old_val = 0; | 599 byte old_val = 0; |
533 byte new_val = 1; | 600 byte new_val = 1; |
534 byte simd = r.AllocateLocal(kWasmS128); | 601 byte simd = r.AllocateLocal(kWasmS128); |
535 BUILD(r, WASM_SET_LOCAL(simd, WASM_SIMD_I16x8_SPLAT(WASM_GET_LOCAL(old_val))), | 602 BUILD(r, WASM_SET_LOCAL(simd, WASM_SIMD_I16x8_SPLAT(WASM_GET_LOCAL(old_val))), |
536 WASM_SET_LOCAL(simd, | 603 WASM_SET_LOCAL(simd, |
537 WASM_SIMD_I16x8_REPLACE_LANE(0, WASM_GET_LOCAL(simd), | 604 WASM_SIMD_I16x8_REPLACE_LANE(0, WASM_GET_LOCAL(simd), |
538 WASM_GET_LOCAL(new_val))), | 605 WASM_GET_LOCAL(new_val))), |
539 WASM_SIMD_CHECK8(I16x8, simd, I32, new_val, old_val, old_val, old_val, | 606 WASM_SIMD_CHECK8(I16x8, simd, I32, new_val, old_val, old_val, old_val, |
(...skipping 29 matching lines...) Expand all Loading... | |
569 WASM_SIMD_CHECK8(I16x8, simd, I32, new_val, new_val, new_val, new_val, | 636 WASM_SIMD_CHECK8(I16x8, simd, I32, new_val, new_val, new_val, new_val, |
570 new_val, new_val, new_val, old_val), | 637 new_val, new_val, new_val, old_val), |
571 WASM_SET_LOCAL(simd, | 638 WASM_SET_LOCAL(simd, |
572 WASM_SIMD_I16x8_REPLACE_LANE(7, WASM_GET_LOCAL(simd), | 639 WASM_SIMD_I16x8_REPLACE_LANE(7, WASM_GET_LOCAL(simd), |
573 WASM_GET_LOCAL(new_val))), | 640 WASM_GET_LOCAL(new_val))), |
574 WASM_SIMD_CHECK_SPLAT8(I16x8, simd, I32, new_val), WASM_ONE); | 641 WASM_SIMD_CHECK_SPLAT8(I16x8, simd, I32, new_val), WASM_ONE); |
575 | 642 |
576 CHECK_EQ(1, r.Call(1, 2)); | 643 CHECK_EQ(1, r.Call(1, 2)); |
577 } | 644 } |
578 | 645 |
579 WASM_EXEC_TEST(I8x16Splat) { | 646 WASM_EXEC_COMPILED_TEST(I8x16Splat) { |
580 FLAG_wasm_simd_prototype = true; | 647 FLAG_wasm_simd_prototype = true; |
581 | 648 |
582 WasmRunner<int32_t, int32_t> r(kExecuteCompiled); | 649 WasmRunner<int32_t, int32_t> r(kExecuteCompiled); |
583 byte lane_val = 0; | 650 byte lane_val = 0; |
584 byte simd = r.AllocateLocal(kWasmS128); | 651 byte simd = r.AllocateLocal(kWasmS128); |
585 BUILD(r, | 652 BUILD(r, |
586 WASM_SET_LOCAL(simd, WASM_SIMD_I8x16_SPLAT(WASM_GET_LOCAL(lane_val))), | 653 WASM_SET_LOCAL(simd, WASM_SIMD_I8x16_SPLAT(WASM_GET_LOCAL(lane_val))), |
587 WASM_SIMD_CHECK_SPLAT8(I8x16, simd, I32, lane_val), WASM_ONE); | 654 WASM_SIMD_CHECK_SPLAT8(I8x16, simd, I32, lane_val), WASM_ONE); |
588 | 655 |
589 FOR_INT8_INPUTS(i) { CHECK_EQ(1, r.Call(*i)); } | 656 FOR_INT8_INPUTS(i) { CHECK_EQ(1, r.Call(*i)); } |
590 } | 657 } |
591 | 658 |
592 WASM_EXEC_TEST(I8x16ReplaceLane) { | 659 WASM_EXEC_COMPILED_TEST(I8x16ReplaceLane) { |
593 FLAG_wasm_simd_prototype = true; | 660 FLAG_wasm_simd_prototype = true; |
594 WasmRunner<int32_t, int32_t, int32_t> r(kExecuteCompiled); | 661 WasmRunner<int32_t, int32_t, int32_t> r(kExecuteCompiled); |
595 byte old_val = 0; | 662 byte old_val = 0; |
596 byte new_val = 1; | 663 byte new_val = 1; |
597 byte simd = r.AllocateLocal(kWasmS128); | 664 byte simd = r.AllocateLocal(kWasmS128); |
598 BUILD(r, WASM_SET_LOCAL(simd, WASM_SIMD_I8x16_SPLAT(WASM_GET_LOCAL(old_val))), | 665 BUILD(r, WASM_SET_LOCAL(simd, WASM_SIMD_I8x16_SPLAT(WASM_GET_LOCAL(old_val))), |
599 WASM_SET_LOCAL(simd, | 666 WASM_SET_LOCAL(simd, |
600 WASM_SIMD_I8x16_REPLACE_LANE(0, WASM_GET_LOCAL(simd), | 667 WASM_SIMD_I8x16_REPLACE_LANE(0, WASM_GET_LOCAL(simd), |
601 WASM_GET_LOCAL(new_val))), | 668 WASM_GET_LOCAL(new_val))), |
602 WASM_SIMD_CHECK16(I8x16, simd, I32, new_val, old_val, old_val, old_val, | 669 WASM_SIMD_CHECK16(I8x16, simd, I32, new_val, old_val, old_val, old_val, |
(...skipping 125 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
728 int32_t result = | 795 int32_t result = |
729 unsigned_integer ? static_cast<uint32_t>(val) : static_cast<int32_t>(val); | 796 unsigned_integer ? static_cast<uint32_t>(val) : static_cast<int32_t>(val); |
730 | 797 |
731 if (!CanRoundToZeroAndConvert(val, unsigned_integer)) { | 798 if (!CanRoundToZeroAndConvert(val, unsigned_integer)) { |
732 result = ConvertInvalidValue(val, unsigned_integer); | 799 result = ConvertInvalidValue(val, unsigned_integer); |
733 } | 800 } |
734 return result; | 801 return result; |
735 } | 802 } |
736 | 803 |
737 // Tests both signed and unsigned conversion. | 804 // Tests both signed and unsigned conversion. |
738 WASM_EXEC_TEST(I32x4FromFloat32x4) { | 805 WASM_EXEC_COMPILED_TEST(I32x4FromFloat32x4) { |
739 FLAG_wasm_simd_prototype = true; | 806 FLAG_wasm_simd_prototype = true; |
740 WasmRunner<int32_t, float, int32_t, int32_t> r(kExecuteCompiled); | 807 WasmRunner<int32_t, float, int32_t, int32_t> r(kExecuteCompiled); |
741 byte a = 0; | 808 byte a = 0; |
742 byte expected_signed = 1; | 809 byte expected_signed = 1; |
743 byte expected_unsigned = 2; | 810 byte expected_unsigned = 2; |
744 byte simd0 = r.AllocateLocal(kWasmS128); | 811 byte simd0 = r.AllocateLocal(kWasmS128); |
745 byte simd1 = r.AllocateLocal(kWasmS128); | 812 byte simd1 = r.AllocateLocal(kWasmS128); |
746 byte simd2 = r.AllocateLocal(kWasmS128); | 813 byte simd2 = r.AllocateLocal(kWasmS128); |
747 BUILD( | 814 BUILD( |
748 r, WASM_SET_LOCAL(simd0, WASM_SIMD_F32x4_SPLAT(WASM_GET_LOCAL(a))), | 815 r, WASM_SET_LOCAL(simd0, WASM_SIMD_F32x4_SPLAT(WASM_GET_LOCAL(a))), |
(...skipping 15 matching lines...) Expand all Loading... | |
764 byte a = 0; | 831 byte a = 0; |
765 byte expected = 1; | 832 byte expected = 1; |
766 byte simd = r.AllocateLocal(kWasmS128); | 833 byte simd = r.AllocateLocal(kWasmS128); |
767 BUILD(r, WASM_SET_LOCAL(simd, WASM_SIMD_I32x4_SPLAT(WASM_GET_LOCAL(a))), | 834 BUILD(r, WASM_SET_LOCAL(simd, WASM_SIMD_I32x4_SPLAT(WASM_GET_LOCAL(a))), |
768 WASM_SET_LOCAL(simd, WASM_SIMD_UNOP(simd_op, WASM_GET_LOCAL(simd))), | 835 WASM_SET_LOCAL(simd, WASM_SIMD_UNOP(simd_op, WASM_GET_LOCAL(simd))), |
769 WASM_SIMD_CHECK_SPLAT4(I32x4, simd, I32, expected), WASM_ONE); | 836 WASM_SIMD_CHECK_SPLAT4(I32x4, simd, I32, expected), WASM_ONE); |
770 | 837 |
771 FOR_INT32_INPUTS(i) { CHECK_EQ(1, r.Call(*i, expected_op(*i))); } | 838 FOR_INT32_INPUTS(i) { CHECK_EQ(1, r.Call(*i, expected_op(*i))); } |
772 } | 839 } |
773 | 840 |
774 WASM_EXEC_TEST(I32x4Neg) { RunI32x4UnOpTest(kExprI32x4Neg, Negate); } | 841 WASM_EXEC_COMPILED_TEST(I32x4Neg) { RunI32x4UnOpTest(kExprI32x4Neg, Negate); } |
775 | 842 |
776 WASM_EXEC_TEST(S128Not) { RunI32x4UnOpTest(kExprS128Not, Not); } | 843 WASM_EXEC_COMPILED_TEST(S128Not) { RunI32x4UnOpTest(kExprS128Not, Not); } |
777 #endif // V8_TARGET_ARCH_ARM | 844 #endif // V8_TARGET_ARCH_ARM |
778 | 845 |
779 void RunI32x4BinOpTest(WasmOpcode simd_op, Int32BinOp expected_op) { | 846 void RunI32x4BinOpTest(WasmOpcode simd_op, Int32BinOp expected_op) { |
780 FLAG_wasm_simd_prototype = true; | 847 FLAG_wasm_simd_prototype = true; |
781 WasmRunner<int32_t, int32_t, int32_t, int32_t> r(kExecuteCompiled); | 848 WasmRunner<int32_t, int32_t, int32_t, int32_t> r(kExecuteCompiled); |
782 byte a = 0; | 849 byte a = 0; |
783 byte b = 1; | 850 byte b = 1; |
784 byte expected = 2; | 851 byte expected = 2; |
785 byte simd0 = r.AllocateLocal(kWasmS128); | 852 byte simd0 = r.AllocateLocal(kWasmS128); |
786 byte simd1 = r.AllocateLocal(kWasmS128); | 853 byte simd1 = r.AllocateLocal(kWasmS128); |
787 BUILD(r, WASM_SET_LOCAL(simd0, WASM_SIMD_I32x4_SPLAT(WASM_GET_LOCAL(a))), | 854 BUILD(r, WASM_SET_LOCAL(simd0, WASM_SIMD_I32x4_SPLAT(WASM_GET_LOCAL(a))), |
788 WASM_SET_LOCAL(simd1, WASM_SIMD_I32x4_SPLAT(WASM_GET_LOCAL(b))), | 855 WASM_SET_LOCAL(simd1, WASM_SIMD_I32x4_SPLAT(WASM_GET_LOCAL(b))), |
789 WASM_SET_LOCAL(simd1, WASM_SIMD_BINOP(simd_op, WASM_GET_LOCAL(simd0), | 856 WASM_SET_LOCAL(simd1, WASM_SIMD_BINOP(simd_op, WASM_GET_LOCAL(simd0), |
790 WASM_GET_LOCAL(simd1))), | 857 WASM_GET_LOCAL(simd1))), |
791 WASM_SIMD_CHECK_SPLAT4(I32x4, simd1, I32, expected), WASM_ONE); | 858 WASM_SIMD_CHECK_SPLAT4(I32x4, simd1, I32, expected), WASM_ONE); |
792 | 859 |
793 FOR_INT32_INPUTS(i) { | 860 FOR_INT32_INPUTS(i) { |
794 FOR_INT32_INPUTS(j) { CHECK_EQ(1, r.Call(*i, *j, expected_op(*i, *j))); } | 861 FOR_INT32_INPUTS(j) { CHECK_EQ(1, r.Call(*i, *j, expected_op(*i, *j))); } |
795 } | 862 } |
796 } | 863 } |
797 | 864 |
798 WASM_EXEC_TEST(I32x4Add) { RunI32x4BinOpTest(kExprI32x4Add, Add); } | 865 WASM_EXEC_COMPILED_TEST(I32x4Add) { RunI32x4BinOpTest(kExprI32x4Add, Add); } |
799 | 866 |
800 WASM_EXEC_TEST(I32x4Sub) { RunI32x4BinOpTest(kExprI32x4Sub, Sub); } | 867 WASM_EXEC_COMPILED_TEST(I32x4Sub) { RunI32x4BinOpTest(kExprI32x4Sub, Sub); } |
868 | |
869 #if V8_TARGET_ARCH_ARM || SIMD_LOWERING_TARGET | |
870 WASM_EXEC_COMPILED_TEST(I32x4Mul) { RunI32x4BinOpTest(kExprI32x4Mul, Mul); } | |
871 | |
872 WASM_EXEC_COMPILED_TEST(S128And) { RunI32x4BinOpTest(kExprS128And, And); } | |
873 | |
874 WASM_EXEC_COMPILED_TEST(S128Or) { RunI32x4BinOpTest(kExprS128Or, Or); } | |
875 | |
876 WASM_EXEC_COMPILED_TEST(S128Xor) { RunI32x4BinOpTest(kExprS128Xor, Xor); } | |
877 #endif // V8_TARGET_ARCH_ARM || SIMD_LOWERING_TARGET | |
801 | 878 |
802 #if V8_TARGET_ARCH_ARM | 879 #if V8_TARGET_ARCH_ARM |
803 WASM_EXEC_TEST(I32x4Mul) { RunI32x4BinOpTest(kExprI32x4Mul, Mul); } | 880 WASM_EXEC_COMPILED_TEST(I32x4Min) { |
881 RunI32x4BinOpTest(kExprI32x4MinS, Minimum); | |
882 } | |
804 | 883 |
805 WASM_EXEC_TEST(I32x4Min) { RunI32x4BinOpTest(kExprI32x4MinS, Minimum); } | 884 WASM_EXEC_COMPILED_TEST(I32x4Max) { |
885 RunI32x4BinOpTest(kExprI32x4MaxS, Maximum); | |
886 } | |
806 | 887 |
807 WASM_EXEC_TEST(I32x4Max) { RunI32x4BinOpTest(kExprI32x4MaxS, Maximum); } | 888 WASM_EXEC_COMPILED_TEST(Ui32x4Min) { |
808 | |
809 WASM_EXEC_TEST(Ui32x4Min) { | |
810 RunI32x4BinOpTest(kExprI32x4MinU, UnsignedMinimum); | 889 RunI32x4BinOpTest(kExprI32x4MinU, UnsignedMinimum); |
811 } | 890 } |
812 | 891 |
813 WASM_EXEC_TEST(Ui32x4Max) { | 892 WASM_EXEC_COMPILED_TEST(Ui32x4Max) { |
814 RunI32x4BinOpTest(kExprI32x4MaxU, UnsignedMaximum); | 893 RunI32x4BinOpTest(kExprI32x4MaxU, UnsignedMaximum); |
815 } | 894 } |
816 | 895 |
817 WASM_EXEC_TEST(S128And) { RunI32x4BinOpTest(kExprS128And, And); } | |
818 | 896 |
819 WASM_EXEC_TEST(S128Or) { RunI32x4BinOpTest(kExprS128Or, Or); } | |
820 | |
821 WASM_EXEC_TEST(S128Xor) { RunI32x4BinOpTest(kExprS128Xor, Xor); } | |
822 | 897 |
823 void RunI32x4CompareOpTest(WasmOpcode simd_op, Int32BinOp expected_op) { | 898 void RunI32x4CompareOpTest(WasmOpcode simd_op, Int32BinOp expected_op) { |
824 FLAG_wasm_simd_prototype = true; | 899 FLAG_wasm_simd_prototype = true; |
825 WasmRunner<int32_t, int32_t, int32_t, int32_t> r(kExecuteCompiled); | 900 WasmRunner<int32_t, int32_t, int32_t, int32_t> r(kExecuteCompiled); |
826 byte a = 0; | 901 byte a = 0; |
827 byte b = 1; | 902 byte b = 1; |
828 byte expected = 2; | 903 byte expected = 2; |
829 byte simd0 = r.AllocateLocal(kWasmS128); | 904 byte simd0 = r.AllocateLocal(kWasmS128); |
830 byte simd1 = r.AllocateLocal(kWasmS128); | 905 byte simd1 = r.AllocateLocal(kWasmS128); |
831 BUILD(r, WASM_SET_LOCAL(simd0, WASM_SIMD_I32x4_SPLAT(WASM_GET_LOCAL(a))), | 906 BUILD(r, WASM_SET_LOCAL(simd0, WASM_SIMD_I32x4_SPLAT(WASM_GET_LOCAL(a))), |
832 WASM_SET_LOCAL(simd1, WASM_SIMD_I32x4_SPLAT(WASM_GET_LOCAL(b))), | 907 WASM_SET_LOCAL(simd1, WASM_SIMD_I32x4_SPLAT(WASM_GET_LOCAL(b))), |
833 WASM_SET_LOCAL(simd1, | 908 WASM_SET_LOCAL(simd1, |
834 WASM_SIMD_MATERIALIZE_BOOLS( | 909 WASM_SIMD_MATERIALIZE_BOOLS( |
835 32x4, WASM_SIMD_BINOP(simd_op, WASM_GET_LOCAL(simd0), | 910 32x4, WASM_SIMD_BINOP(simd_op, WASM_GET_LOCAL(simd0), |
836 WASM_GET_LOCAL(simd1)))), | 911 WASM_GET_LOCAL(simd1)))), |
837 WASM_SIMD_CHECK_SPLAT4(I32x4, simd1, I32, expected), WASM_ONE); | 912 WASM_SIMD_CHECK_SPLAT4(I32x4, simd1, I32, expected), WASM_ONE); |
838 | 913 |
839 FOR_INT32_INPUTS(i) { | 914 FOR_INT32_INPUTS(i) { |
840 FOR_INT32_INPUTS(j) { CHECK_EQ(1, r.Call(*i, *j, expected_op(*i, *j))); } | 915 FOR_INT32_INPUTS(j) { CHECK_EQ(1, r.Call(*i, *j, expected_op(*i, *j))); } |
841 } | 916 } |
842 } | 917 } |
843 | 918 |
844 WASM_EXEC_TEST(I32x4Equal) { RunI32x4CompareOpTest(kExprI32x4Eq, Equal); } | 919 WASM_EXEC_COMPILED_TEST(I32x4Equal) { |
920 RunI32x4CompareOpTest(kExprI32x4Eq, Equal); | |
921 } | |
845 | 922 |
846 WASM_EXEC_TEST(I32x4NotEqual) { RunI32x4CompareOpTest(kExprI32x4Ne, NotEqual); } | 923 WASM_EXEC_COMPILED_TEST(I32x4NotEqual) { |
924 RunI32x4CompareOpTest(kExprI32x4Ne, NotEqual); | |
925 } | |
847 | 926 |
848 WASM_EXEC_TEST(I32x4Greater) { RunI32x4CompareOpTest(kExprI32x4GtS, Greater); } | 927 WASM_EXEC_COMPILED_TEST(I32x4Greater) { |
928 RunI32x4CompareOpTest(kExprI32x4GtS, Greater); | |
929 } | |
849 | 930 |
850 WASM_EXEC_TEST(I32x4GreaterEqual) { | 931 WASM_EXEC_COMPILED_TEST(I32x4GreaterEqual) { |
851 RunI32x4CompareOpTest(kExprI32x4GeS, GreaterEqual); | 932 RunI32x4CompareOpTest(kExprI32x4GeS, GreaterEqual); |
852 } | 933 } |
853 | 934 |
854 WASM_EXEC_TEST(I32x4Less) { RunI32x4CompareOpTest(kExprI32x4LtS, Less); } | 935 WASM_EXEC_COMPILED_TEST(I32x4Less) { |
936 RunI32x4CompareOpTest(kExprI32x4LtS, Less); | |
937 } | |
855 | 938 |
856 WASM_EXEC_TEST(I32x4LessEqual) { | 939 WASM_EXEC_COMPILED_TEST(I32x4LessEqual) { |
857 RunI32x4CompareOpTest(kExprI32x4LeS, LessEqual); | 940 RunI32x4CompareOpTest(kExprI32x4LeS, LessEqual); |
858 } | 941 } |
859 | 942 |
860 WASM_EXEC_TEST(Ui32x4Greater) { | 943 WASM_EXEC_COMPILED_TEST(Ui32x4Greater) { |
861 RunI32x4CompareOpTest(kExprI32x4GtU, UnsignedGreater); | 944 RunI32x4CompareOpTest(kExprI32x4GtU, UnsignedGreater); |
862 } | 945 } |
863 | 946 |
864 WASM_EXEC_TEST(Ui32x4GreaterEqual) { | 947 WASM_EXEC_COMPILED_TEST(Ui32x4GreaterEqual) { |
865 RunI32x4CompareOpTest(kExprI32x4GeU, UnsignedGreaterEqual); | 948 RunI32x4CompareOpTest(kExprI32x4GeU, UnsignedGreaterEqual); |
866 } | 949 } |
867 | 950 |
868 WASM_EXEC_TEST(Ui32x4Less) { | 951 WASM_EXEC_COMPILED_TEST(Ui32x4Less) { |
869 RunI32x4CompareOpTest(kExprI32x4LtU, UnsignedLess); | 952 RunI32x4CompareOpTest(kExprI32x4LtU, UnsignedLess); |
870 } | 953 } |
871 | 954 |
872 WASM_EXEC_TEST(Ui32x4LessEqual) { | 955 WASM_EXEC_COMPILED_TEST(Ui32x4LessEqual) { |
873 RunI32x4CompareOpTest(kExprI32x4LeU, UnsignedLessEqual); | 956 RunI32x4CompareOpTest(kExprI32x4LeU, UnsignedLessEqual); |
874 } | 957 } |
875 | 958 |
876 void RunI32x4ShiftOpTest(WasmOpcode simd_op, Int32ShiftOp expected_op, | 959 void RunI32x4ShiftOpTest(WasmOpcode simd_op, Int32ShiftOp expected_op, |
877 int shift) { | 960 int shift) { |
878 FLAG_wasm_simd_prototype = true; | 961 FLAG_wasm_simd_prototype = true; |
879 WasmRunner<int32_t, int32_t, int32_t> r(kExecuteCompiled); | 962 WasmRunner<int32_t, int32_t, int32_t> r(kExecuteCompiled); |
880 byte a = 0; | 963 byte a = 0; |
881 byte expected = 1; | 964 byte expected = 1; |
882 byte simd = r.AllocateLocal(kWasmS128); | 965 byte simd = r.AllocateLocal(kWasmS128); |
883 BUILD(r, WASM_SET_LOCAL(simd, WASM_SIMD_I32x4_SPLAT(WASM_GET_LOCAL(a))), | 966 BUILD(r, WASM_SET_LOCAL(simd, WASM_SIMD_I32x4_SPLAT(WASM_GET_LOCAL(a))), |
884 WASM_SET_LOCAL( | 967 WASM_SET_LOCAL( |
885 simd, WASM_SIMD_SHIFT_OP(simd_op, shift, WASM_GET_LOCAL(simd))), | 968 simd, WASM_SIMD_SHIFT_OP(simd_op, shift, WASM_GET_LOCAL(simd))), |
886 WASM_SIMD_CHECK_SPLAT4(I32x4, simd, I32, expected), WASM_ONE); | 969 WASM_SIMD_CHECK_SPLAT4(I32x4, simd, I32, expected), WASM_ONE); |
887 | 970 |
888 FOR_INT32_INPUTS(i) { CHECK_EQ(1, r.Call(*i, expected_op(*i, shift))); } | 971 FOR_INT32_INPUTS(i) { CHECK_EQ(1, r.Call(*i, expected_op(*i, shift))); } |
889 } | 972 } |
890 | 973 |
891 WASM_EXEC_TEST(I32x4Shl) { | 974 WASM_EXEC_COMPILED_TEST(I32x4Shl) { |
892 RunI32x4ShiftOpTest(kExprI32x4Shl, LogicalShiftLeft, 1); | 975 RunI32x4ShiftOpTest(kExprI32x4Shl, LogicalShiftLeft, 1); |
893 } | 976 } |
894 | 977 |
895 WASM_EXEC_TEST(I32x4ShrS) { | 978 WASM_EXEC_COMPILED_TEST(I32x4ShrS) { |
896 RunI32x4ShiftOpTest(kExprI32x4ShrS, ArithmeticShiftRight, 1); | 979 RunI32x4ShiftOpTest(kExprI32x4ShrS, ArithmeticShiftRight, 1); |
897 } | 980 } |
898 | 981 |
899 WASM_EXEC_TEST(I32x4ShrU) { | 982 WASM_EXEC_COMPILED_TEST(I32x4ShrU) { |
900 RunI32x4ShiftOpTest(kExprI32x4ShrU, LogicalShiftRight, 1); | 983 RunI32x4ShiftOpTest(kExprI32x4ShrU, LogicalShiftRight, 1); |
901 } | 984 } |
902 | 985 |
903 void RunI16x8UnOpTest(WasmOpcode simd_op, Int16UnOp expected_op) { | 986 void RunI16x8UnOpTest(WasmOpcode simd_op, Int16UnOp expected_op) { |
904 FLAG_wasm_simd_prototype = true; | 987 FLAG_wasm_simd_prototype = true; |
905 WasmRunner<int32_t, int32_t, int32_t> r(kExecuteCompiled); | 988 WasmRunner<int32_t, int32_t, int32_t> r(kExecuteCompiled); |
906 byte a = 0; | 989 byte a = 0; |
907 byte expected = 1; | 990 byte expected = 1; |
908 byte simd = r.AllocateLocal(kWasmS128); | 991 byte simd = r.AllocateLocal(kWasmS128); |
909 BUILD(r, WASM_SET_LOCAL(simd, WASM_SIMD_I16x8_SPLAT(WASM_GET_LOCAL(a))), | 992 BUILD(r, WASM_SET_LOCAL(simd, WASM_SIMD_I16x8_SPLAT(WASM_GET_LOCAL(a))), |
910 WASM_SET_LOCAL(simd, WASM_SIMD_UNOP(simd_op, WASM_GET_LOCAL(simd))), | 993 WASM_SET_LOCAL(simd, WASM_SIMD_UNOP(simd_op, WASM_GET_LOCAL(simd))), |
911 WASM_SIMD_CHECK_SPLAT8(I16x8, simd, I32, expected), WASM_ONE); | 994 WASM_SIMD_CHECK_SPLAT8(I16x8, simd, I32, expected), WASM_ONE); |
912 | 995 |
913 FOR_INT16_INPUTS(i) { CHECK_EQ(1, r.Call(*i, expected_op(*i))); } | 996 FOR_INT16_INPUTS(i) { CHECK_EQ(1, r.Call(*i, expected_op(*i))); } |
914 } | 997 } |
915 | 998 |
916 WASM_EXEC_TEST(I16x8Neg) { RunI16x8UnOpTest(kExprI16x8Neg, Negate); } | 999 WASM_EXEC_COMPILED_TEST(I16x8Neg) { RunI16x8UnOpTest(kExprI16x8Neg, Negate); } |
917 | 1000 |
918 void RunI16x8BinOpTest(WasmOpcode simd_op, Int16BinOp expected_op) { | 1001 void RunI16x8BinOpTest(WasmOpcode simd_op, Int16BinOp expected_op) { |
919 FLAG_wasm_simd_prototype = true; | 1002 FLAG_wasm_simd_prototype = true; |
920 WasmRunner<int32_t, int32_t, int32_t, int32_t> r(kExecuteCompiled); | 1003 WasmRunner<int32_t, int32_t, int32_t, int32_t> r(kExecuteCompiled); |
921 byte a = 0; | 1004 byte a = 0; |
922 byte b = 1; | 1005 byte b = 1; |
923 byte expected = 2; | 1006 byte expected = 2; |
924 byte simd0 = r.AllocateLocal(kWasmS128); | 1007 byte simd0 = r.AllocateLocal(kWasmS128); |
925 byte simd1 = r.AllocateLocal(kWasmS128); | 1008 byte simd1 = r.AllocateLocal(kWasmS128); |
926 BUILD(r, WASM_SET_LOCAL(simd0, WASM_SIMD_I16x8_SPLAT(WASM_GET_LOCAL(a))), | 1009 BUILD(r, WASM_SET_LOCAL(simd0, WASM_SIMD_I16x8_SPLAT(WASM_GET_LOCAL(a))), |
927 WASM_SET_LOCAL(simd1, WASM_SIMD_I16x8_SPLAT(WASM_GET_LOCAL(b))), | 1010 WASM_SET_LOCAL(simd1, WASM_SIMD_I16x8_SPLAT(WASM_GET_LOCAL(b))), |
928 WASM_SET_LOCAL(simd1, WASM_SIMD_BINOP(simd_op, WASM_GET_LOCAL(simd0), | 1011 WASM_SET_LOCAL(simd1, WASM_SIMD_BINOP(simd_op, WASM_GET_LOCAL(simd0), |
929 WASM_GET_LOCAL(simd1))), | 1012 WASM_GET_LOCAL(simd1))), |
930 WASM_SIMD_CHECK_SPLAT8(I16x8, simd1, I32, expected), WASM_ONE); | 1013 WASM_SIMD_CHECK_SPLAT8(I16x8, simd1, I32, expected), WASM_ONE); |
931 | 1014 |
932 FOR_INT16_INPUTS(i) { | 1015 FOR_INT16_INPUTS(i) { |
933 FOR_INT16_INPUTS(j) { CHECK_EQ(1, r.Call(*i, *j, expected_op(*i, *j))); } | 1016 FOR_INT16_INPUTS(j) { CHECK_EQ(1, r.Call(*i, *j, expected_op(*i, *j))); } |
934 } | 1017 } |
935 } | 1018 } |
936 | 1019 |
937 WASM_EXEC_TEST(I16x8Add) { RunI16x8BinOpTest(kExprI16x8Add, Add); } | 1020 WASM_EXEC_COMPILED_TEST(I16x8Add) { RunI16x8BinOpTest(kExprI16x8Add, Add); } |
938 | 1021 |
939 WASM_EXEC_TEST(I16x8AddSaturate) { | 1022 WASM_EXEC_COMPILED_TEST(I16x8AddSaturate) { |
940 RunI16x8BinOpTest(kExprI16x8AddSaturateS, AddSaturate); | 1023 RunI16x8BinOpTest(kExprI16x8AddSaturateS, AddSaturate); |
941 } | 1024 } |
942 | 1025 |
943 WASM_EXEC_TEST(I16x8Sub) { RunI16x8BinOpTest(kExprI16x8Sub, Sub); } | 1026 WASM_EXEC_COMPILED_TEST(I16x8Sub) { RunI16x8BinOpTest(kExprI16x8Sub, Sub); } |
944 | 1027 |
945 WASM_EXEC_TEST(I16x8SubSaturate) { | 1028 WASM_EXEC_COMPILED_TEST(I16x8SubSaturate) { |
946 RunI16x8BinOpTest(kExprI16x8SubSaturateS, SubSaturate); | 1029 RunI16x8BinOpTest(kExprI16x8SubSaturateS, SubSaturate); |
947 } | 1030 } |
948 | 1031 |
949 WASM_EXEC_TEST(I16x8Mul) { RunI16x8BinOpTest(kExprI16x8Mul, Mul); } | 1032 WASM_EXEC_COMPILED_TEST(I16x8Mul) { RunI16x8BinOpTest(kExprI16x8Mul, Mul); } |
950 | 1033 |
951 WASM_EXEC_TEST(I16x8Min) { RunI16x8BinOpTest(kExprI16x8MinS, Minimum); } | 1034 WASM_EXEC_COMPILED_TEST(I16x8Min) { |
1035 RunI16x8BinOpTest(kExprI16x8MinS, Minimum); | |
1036 } | |
952 | 1037 |
953 WASM_EXEC_TEST(I16x8Max) { RunI16x8BinOpTest(kExprI16x8MaxS, Maximum); } | 1038 WASM_EXEC_COMPILED_TEST(I16x8Max) { |
1039 RunI16x8BinOpTest(kExprI16x8MaxS, Maximum); | |
1040 } | |
954 | 1041 |
955 WASM_EXEC_TEST(Ui16x8AddSaturate) { | 1042 WASM_EXEC_COMPILED_TEST(Ui16x8AddSaturate) { |
956 RunI16x8BinOpTest(kExprI16x8AddSaturateU, UnsignedAddSaturate); | 1043 RunI16x8BinOpTest(kExprI16x8AddSaturateU, UnsignedAddSaturate); |
957 } | 1044 } |
958 | 1045 |
959 WASM_EXEC_TEST(Ui16x8SubSaturate) { | 1046 WASM_EXEC_COMPILED_TEST(Ui16x8SubSaturate) { |
960 RunI16x8BinOpTest(kExprI16x8SubSaturateU, UnsignedSubSaturate); | 1047 RunI16x8BinOpTest(kExprI16x8SubSaturateU, UnsignedSubSaturate); |
961 } | 1048 } |
962 | 1049 |
963 WASM_EXEC_TEST(Ui16x8Min) { | 1050 WASM_EXEC_COMPILED_TEST(Ui16x8Min) { |
964 RunI16x8BinOpTest(kExprI16x8MinU, UnsignedMinimum); | 1051 RunI16x8BinOpTest(kExprI16x8MinU, UnsignedMinimum); |
965 } | 1052 } |
966 | 1053 |
967 WASM_EXEC_TEST(Ui16x8Max) { | 1054 WASM_EXEC_COMPILED_TEST(Ui16x8Max) { |
968 RunI16x8BinOpTest(kExprI16x8MaxU, UnsignedMaximum); | 1055 RunI16x8BinOpTest(kExprI16x8MaxU, UnsignedMaximum); |
969 } | 1056 } |
970 | 1057 |
971 void RunI16x8CompareOpTest(WasmOpcode simd_op, Int16BinOp expected_op) { | 1058 void RunI16x8CompareOpTest(WasmOpcode simd_op, Int16BinOp expected_op) { |
972 FLAG_wasm_simd_prototype = true; | 1059 FLAG_wasm_simd_prototype = true; |
973 WasmRunner<int32_t, int32_t, int32_t, int32_t> r(kExecuteCompiled); | 1060 WasmRunner<int32_t, int32_t, int32_t, int32_t> r(kExecuteCompiled); |
974 byte a = 0; | 1061 byte a = 0; |
975 byte b = 1; | 1062 byte b = 1; |
976 byte expected = 2; | 1063 byte expected = 2; |
977 byte simd0 = r.AllocateLocal(kWasmS128); | 1064 byte simd0 = r.AllocateLocal(kWasmS128); |
978 byte simd1 = r.AllocateLocal(kWasmS128); | 1065 byte simd1 = r.AllocateLocal(kWasmS128); |
979 BUILD(r, WASM_SET_LOCAL(simd0, WASM_SIMD_I16x8_SPLAT(WASM_GET_LOCAL(a))), | 1066 BUILD(r, WASM_SET_LOCAL(simd0, WASM_SIMD_I16x8_SPLAT(WASM_GET_LOCAL(a))), |
980 WASM_SET_LOCAL(simd1, WASM_SIMD_I16x8_SPLAT(WASM_GET_LOCAL(b))), | 1067 WASM_SET_LOCAL(simd1, WASM_SIMD_I16x8_SPLAT(WASM_GET_LOCAL(b))), |
981 WASM_SET_LOCAL(simd1, | 1068 WASM_SET_LOCAL(simd1, |
982 WASM_SIMD_MATERIALIZE_BOOLS( | 1069 WASM_SIMD_MATERIALIZE_BOOLS( |
983 16x8, WASM_SIMD_BINOP(simd_op, WASM_GET_LOCAL(simd0), | 1070 16x8, WASM_SIMD_BINOP(simd_op, WASM_GET_LOCAL(simd0), |
984 WASM_GET_LOCAL(simd1)))), | 1071 WASM_GET_LOCAL(simd1)))), |
985 WASM_SIMD_CHECK_SPLAT8(I16x8, simd1, I32, expected), WASM_ONE); | 1072 WASM_SIMD_CHECK_SPLAT8(I16x8, simd1, I32, expected), WASM_ONE); |
986 | 1073 |
987 FOR_INT16_INPUTS(i) { | 1074 FOR_INT16_INPUTS(i) { |
988 FOR_INT16_INPUTS(j) { CHECK_EQ(1, r.Call(*i, *j, expected_op(*i, *j))); } | 1075 FOR_INT16_INPUTS(j) { CHECK_EQ(1, r.Call(*i, *j, expected_op(*i, *j))); } |
989 } | 1076 } |
990 } | 1077 } |
991 | 1078 |
992 WASM_EXEC_TEST(I16x8Equal) { RunI16x8CompareOpTest(kExprI16x8Eq, Equal); } | 1079 WASM_EXEC_COMPILED_TEST(I16x8Equal) { |
1080 RunI16x8CompareOpTest(kExprI16x8Eq, Equal); | |
1081 } | |
993 | 1082 |
994 WASM_EXEC_TEST(I16x8NotEqual) { RunI16x8CompareOpTest(kExprI16x8Ne, NotEqual); } | 1083 WASM_EXEC_COMPILED_TEST(I16x8NotEqual) { |
1084 RunI16x8CompareOpTest(kExprI16x8Ne, NotEqual); | |
1085 } | |
995 | 1086 |
996 WASM_EXEC_TEST(I16x8Greater) { RunI16x8CompareOpTest(kExprI16x8GtS, Greater); } | 1087 WASM_EXEC_COMPILED_TEST(I16x8Greater) { |
1088 RunI16x8CompareOpTest(kExprI16x8GtS, Greater); | |
1089 } | |
997 | 1090 |
998 WASM_EXEC_TEST(I16x8GreaterEqual) { | 1091 WASM_EXEC_COMPILED_TEST(I16x8GreaterEqual) { |
999 RunI16x8CompareOpTest(kExprI16x8GeS, GreaterEqual); | 1092 RunI16x8CompareOpTest(kExprI16x8GeS, GreaterEqual); |
1000 } | 1093 } |
1001 | 1094 |
1002 WASM_EXEC_TEST(I16x8Less) { RunI16x8CompareOpTest(kExprI16x8LtS, Less); } | 1095 WASM_EXEC_COMPILED_TEST(I16x8Less) { |
1096 RunI16x8CompareOpTest(kExprI16x8LtS, Less); | |
1097 } | |
1003 | 1098 |
1004 WASM_EXEC_TEST(I16x8LessEqual) { | 1099 WASM_EXEC_COMPILED_TEST(I16x8LessEqual) { |
1005 RunI16x8CompareOpTest(kExprI16x8LeS, LessEqual); | 1100 RunI16x8CompareOpTest(kExprI16x8LeS, LessEqual); |
1006 } | 1101 } |
1007 | 1102 |
1008 WASM_EXEC_TEST(Ui16x8Greater) { | 1103 WASM_EXEC_COMPILED_TEST(Ui16x8Greater) { |
1009 RunI16x8CompareOpTest(kExprI16x8GtU, UnsignedGreater); | 1104 RunI16x8CompareOpTest(kExprI16x8GtU, UnsignedGreater); |
1010 } | 1105 } |
1011 | 1106 |
1012 WASM_EXEC_TEST(Ui16x8GreaterEqual) { | 1107 WASM_EXEC_COMPILED_TEST(Ui16x8GreaterEqual) { |
1013 RunI16x8CompareOpTest(kExprI16x8GeU, UnsignedGreaterEqual); | 1108 RunI16x8CompareOpTest(kExprI16x8GeU, UnsignedGreaterEqual); |
1014 } | 1109 } |
1015 | 1110 |
1016 WASM_EXEC_TEST(Ui16x8Less) { | 1111 WASM_EXEC_COMPILED_TEST(Ui16x8Less) { |
1017 RunI16x8CompareOpTest(kExprI16x8LtU, UnsignedLess); | 1112 RunI16x8CompareOpTest(kExprI16x8LtU, UnsignedLess); |
1018 } | 1113 } |
1019 | 1114 |
1020 WASM_EXEC_TEST(Ui16x8LessEqual) { | 1115 WASM_EXEC_COMPILED_TEST(Ui16x8LessEqual) { |
1021 RunI16x8CompareOpTest(kExprI16x8LeU, UnsignedLessEqual); | 1116 RunI16x8CompareOpTest(kExprI16x8LeU, UnsignedLessEqual); |
1022 } | 1117 } |
1023 | 1118 |
1024 void RunI16x8ShiftOpTest(WasmOpcode simd_op, Int16ShiftOp expected_op, | 1119 void RunI16x8ShiftOpTest(WasmOpcode simd_op, Int16ShiftOp expected_op, |
1025 int shift) { | 1120 int shift) { |
1026 FLAG_wasm_simd_prototype = true; | 1121 FLAG_wasm_simd_prototype = true; |
1027 WasmRunner<int32_t, int32_t, int32_t> r(kExecuteCompiled); | 1122 WasmRunner<int32_t, int32_t, int32_t> r(kExecuteCompiled); |
1028 byte a = 0; | 1123 byte a = 0; |
1029 byte expected = 1; | 1124 byte expected = 1; |
1030 byte simd = r.AllocateLocal(kWasmS128); | 1125 byte simd = r.AllocateLocal(kWasmS128); |
1031 BUILD(r, WASM_SET_LOCAL(simd, WASM_SIMD_I16x8_SPLAT(WASM_GET_LOCAL(a))), | 1126 BUILD(r, WASM_SET_LOCAL(simd, WASM_SIMD_I16x8_SPLAT(WASM_GET_LOCAL(a))), |
1032 WASM_SET_LOCAL( | 1127 WASM_SET_LOCAL( |
1033 simd, WASM_SIMD_SHIFT_OP(simd_op, shift, WASM_GET_LOCAL(simd))), | 1128 simd, WASM_SIMD_SHIFT_OP(simd_op, shift, WASM_GET_LOCAL(simd))), |
1034 WASM_SIMD_CHECK_SPLAT8(I16x8, simd, I32, expected), WASM_ONE); | 1129 WASM_SIMD_CHECK_SPLAT8(I16x8, simd, I32, expected), WASM_ONE); |
1035 | 1130 |
1036 FOR_INT16_INPUTS(i) { CHECK_EQ(1, r.Call(*i, expected_op(*i, shift))); } | 1131 FOR_INT16_INPUTS(i) { CHECK_EQ(1, r.Call(*i, expected_op(*i, shift))); } |
1037 } | 1132 } |
1038 | 1133 |
1039 WASM_EXEC_TEST(I16x8Shl) { | 1134 WASM_EXEC_COMPILED_TEST(I16x8Shl) { |
1040 RunI16x8ShiftOpTest(kExprI16x8Shl, LogicalShiftLeft, 1); | 1135 RunI16x8ShiftOpTest(kExprI16x8Shl, LogicalShiftLeft, 1); |
1041 } | 1136 } |
1042 | 1137 |
1043 WASM_EXEC_TEST(I16x8ShrS) { | 1138 WASM_EXEC_COMPILED_TEST(I16x8ShrS) { |
1044 RunI16x8ShiftOpTest(kExprI16x8ShrS, ArithmeticShiftRight, 1); | 1139 RunI16x8ShiftOpTest(kExprI16x8ShrS, ArithmeticShiftRight, 1); |
1045 } | 1140 } |
1046 | 1141 |
1047 WASM_EXEC_TEST(I16x8ShrU) { | 1142 WASM_EXEC_COMPILED_TEST(I16x8ShrU) { |
1048 RunI16x8ShiftOpTest(kExprI16x8ShrU, LogicalShiftRight, 1); | 1143 RunI16x8ShiftOpTest(kExprI16x8ShrU, LogicalShiftRight, 1); |
1049 } | 1144 } |
1050 | 1145 |
1051 void RunI8x16UnOpTest(WasmOpcode simd_op, Int8UnOp expected_op) { | 1146 void RunI8x16UnOpTest(WasmOpcode simd_op, Int8UnOp expected_op) { |
1052 FLAG_wasm_simd_prototype = true; | 1147 FLAG_wasm_simd_prototype = true; |
1053 WasmRunner<int32_t, int32_t, int32_t> r(kExecuteCompiled); | 1148 WasmRunner<int32_t, int32_t, int32_t> r(kExecuteCompiled); |
1054 byte a = 0; | 1149 byte a = 0; |
1055 byte expected = 1; | 1150 byte expected = 1; |
1056 byte simd = r.AllocateLocal(kWasmS128); | 1151 byte simd = r.AllocateLocal(kWasmS128); |
1057 BUILD(r, WASM_SET_LOCAL(simd, WASM_SIMD_I8x16_SPLAT(WASM_GET_LOCAL(a))), | 1152 BUILD(r, WASM_SET_LOCAL(simd, WASM_SIMD_I8x16_SPLAT(WASM_GET_LOCAL(a))), |
1058 WASM_SET_LOCAL(simd, WASM_SIMD_UNOP(simd_op, WASM_GET_LOCAL(simd))), | 1153 WASM_SET_LOCAL(simd, WASM_SIMD_UNOP(simd_op, WASM_GET_LOCAL(simd))), |
1059 WASM_SIMD_CHECK_SPLAT16(I8x16, simd, I32, expected), WASM_ONE); | 1154 WASM_SIMD_CHECK_SPLAT16(I8x16, simd, I32, expected), WASM_ONE); |
1060 | 1155 |
1061 FOR_INT8_INPUTS(i) { CHECK_EQ(1, r.Call(*i, expected_op(*i))); } | 1156 FOR_INT8_INPUTS(i) { CHECK_EQ(1, r.Call(*i, expected_op(*i))); } |
1062 } | 1157 } |
1063 | 1158 |
1064 WASM_EXEC_TEST(I8x16Neg) { RunI8x16UnOpTest(kExprI8x16Neg, Negate); } | 1159 WASM_EXEC_COMPILED_TEST(I8x16Neg) { RunI8x16UnOpTest(kExprI8x16Neg, Negate); } |
1065 | 1160 |
1066 void RunI8x16BinOpTest(WasmOpcode simd_op, Int8BinOp expected_op) { | 1161 void RunI8x16BinOpTest(WasmOpcode simd_op, Int8BinOp expected_op) { |
1067 FLAG_wasm_simd_prototype = true; | 1162 FLAG_wasm_simd_prototype = true; |
1068 WasmRunner<int32_t, int32_t, int32_t, int32_t> r(kExecuteCompiled); | 1163 WasmRunner<int32_t, int32_t, int32_t, int32_t> r(kExecuteCompiled); |
1069 byte a = 0; | 1164 byte a = 0; |
1070 byte b = 1; | 1165 byte b = 1; |
1071 byte expected = 2; | 1166 byte expected = 2; |
1072 byte simd0 = r.AllocateLocal(kWasmS128); | 1167 byte simd0 = r.AllocateLocal(kWasmS128); |
1073 byte simd1 = r.AllocateLocal(kWasmS128); | 1168 byte simd1 = r.AllocateLocal(kWasmS128); |
1074 BUILD(r, WASM_SET_LOCAL(simd0, WASM_SIMD_I8x16_SPLAT(WASM_GET_LOCAL(a))), | 1169 BUILD(r, WASM_SET_LOCAL(simd0, WASM_SIMD_I8x16_SPLAT(WASM_GET_LOCAL(a))), |
1075 WASM_SET_LOCAL(simd1, WASM_SIMD_I8x16_SPLAT(WASM_GET_LOCAL(b))), | 1170 WASM_SET_LOCAL(simd1, WASM_SIMD_I8x16_SPLAT(WASM_GET_LOCAL(b))), |
1076 WASM_SET_LOCAL(simd1, WASM_SIMD_BINOP(simd_op, WASM_GET_LOCAL(simd0), | 1171 WASM_SET_LOCAL(simd1, WASM_SIMD_BINOP(simd_op, WASM_GET_LOCAL(simd0), |
1077 WASM_GET_LOCAL(simd1))), | 1172 WASM_GET_LOCAL(simd1))), |
1078 WASM_SIMD_CHECK_SPLAT16(I8x16, simd1, I32, expected), WASM_ONE); | 1173 WASM_SIMD_CHECK_SPLAT16(I8x16, simd1, I32, expected), WASM_ONE); |
1079 | 1174 |
1080 FOR_INT8_INPUTS(i) { | 1175 FOR_INT8_INPUTS(i) { |
1081 FOR_INT8_INPUTS(j) { CHECK_EQ(1, r.Call(*i, *j, expected_op(*i, *j))); } | 1176 FOR_INT8_INPUTS(j) { CHECK_EQ(1, r.Call(*i, *j, expected_op(*i, *j))); } |
1082 } | 1177 } |
1083 } | 1178 } |
1084 | 1179 |
1085 WASM_EXEC_TEST(I8x16Add) { RunI8x16BinOpTest(kExprI8x16Add, Add); } | 1180 WASM_EXEC_COMPILED_TEST(I8x16Add) { RunI8x16BinOpTest(kExprI8x16Add, Add); } |
1086 | 1181 |
1087 WASM_EXEC_TEST(I8x16AddSaturate) { | 1182 WASM_EXEC_COMPILED_TEST(I8x16AddSaturate) { |
1088 RunI8x16BinOpTest(kExprI8x16AddSaturateS, AddSaturate); | 1183 RunI8x16BinOpTest(kExprI8x16AddSaturateS, AddSaturate); |
1089 } | 1184 } |
1090 | 1185 |
1091 WASM_EXEC_TEST(I8x16Sub) { RunI8x16BinOpTest(kExprI8x16Sub, Sub); } | 1186 WASM_EXEC_COMPILED_TEST(I8x16Sub) { RunI8x16BinOpTest(kExprI8x16Sub, Sub); } |
1092 | 1187 |
1093 WASM_EXEC_TEST(I8x16SubSaturate) { | 1188 WASM_EXEC_COMPILED_TEST(I8x16SubSaturate) { |
1094 RunI8x16BinOpTest(kExprI8x16SubSaturateS, SubSaturate); | 1189 RunI8x16BinOpTest(kExprI8x16SubSaturateS, SubSaturate); |
1095 } | 1190 } |
1096 | 1191 |
1097 WASM_EXEC_TEST(I8x16Mul) { RunI8x16BinOpTest(kExprI8x16Mul, Mul); } | 1192 WASM_EXEC_COMPILED_TEST(I8x16Mul) { RunI8x16BinOpTest(kExprI8x16Mul, Mul); } |
1098 | 1193 |
1099 WASM_EXEC_TEST(I8x16Min) { RunI8x16BinOpTest(kExprI8x16MinS, Minimum); } | 1194 WASM_EXEC_COMPILED_TEST(I8x16Min) { |
1195 RunI8x16BinOpTest(kExprI8x16MinS, Minimum); | |
1196 } | |
1100 | 1197 |
1101 WASM_EXEC_TEST(I8x16Max) { RunI8x16BinOpTest(kExprI8x16MaxS, Maximum); } | 1198 WASM_EXEC_COMPILED_TEST(I8x16Max) { |
1199 RunI8x16BinOpTest(kExprI8x16MaxS, Maximum); | |
1200 } | |
1102 | 1201 |
1103 WASM_EXEC_TEST(Ui8x16AddSaturate) { | 1202 WASM_EXEC_COMPILED_TEST(Ui8x16AddSaturate) { |
1104 RunI8x16BinOpTest(kExprI8x16AddSaturateU, UnsignedAddSaturate); | 1203 RunI8x16BinOpTest(kExprI8x16AddSaturateU, UnsignedAddSaturate); |
1105 } | 1204 } |
1106 | 1205 |
1107 WASM_EXEC_TEST(Ui8x16SubSaturate) { | 1206 WASM_EXEC_COMPILED_TEST(Ui8x16SubSaturate) { |
1108 RunI8x16BinOpTest(kExprI8x16SubSaturateU, UnsignedSubSaturate); | 1207 RunI8x16BinOpTest(kExprI8x16SubSaturateU, UnsignedSubSaturate); |
1109 } | 1208 } |
1110 | 1209 |
1111 WASM_EXEC_TEST(Ui8x16Min) { | 1210 WASM_EXEC_COMPILED_TEST(Ui8x16Min) { |
1112 RunI8x16BinOpTest(kExprI8x16MinU, UnsignedMinimum); | 1211 RunI8x16BinOpTest(kExprI8x16MinU, UnsignedMinimum); |
1113 } | 1212 } |
1114 | 1213 |
1115 WASM_EXEC_TEST(Ui8x16Max) { | 1214 WASM_EXEC_COMPILED_TEST(Ui8x16Max) { |
1116 RunI8x16BinOpTest(kExprI8x16MaxU, UnsignedMaximum); | 1215 RunI8x16BinOpTest(kExprI8x16MaxU, UnsignedMaximum); |
1117 } | 1216 } |
1118 | 1217 |
1119 void RunI8x16CompareOpTest(WasmOpcode simd_op, Int8BinOp expected_op) { | 1218 void RunI8x16CompareOpTest(WasmOpcode simd_op, Int8BinOp expected_op) { |
1120 FLAG_wasm_simd_prototype = true; | 1219 FLAG_wasm_simd_prototype = true; |
1121 WasmRunner<int32_t, int32_t, int32_t, int32_t> r(kExecuteCompiled); | 1220 WasmRunner<int32_t, int32_t, int32_t, int32_t> r(kExecuteCompiled); |
1122 byte a = 0; | 1221 byte a = 0; |
1123 byte b = 1; | 1222 byte b = 1; |
1124 byte expected = 2; | 1223 byte expected = 2; |
1125 byte simd0 = r.AllocateLocal(kWasmS128); | 1224 byte simd0 = r.AllocateLocal(kWasmS128); |
1126 byte simd1 = r.AllocateLocal(kWasmS128); | 1225 byte simd1 = r.AllocateLocal(kWasmS128); |
1127 BUILD(r, WASM_SET_LOCAL(simd0, WASM_SIMD_I8x16_SPLAT(WASM_GET_LOCAL(a))), | 1226 BUILD(r, WASM_SET_LOCAL(simd0, WASM_SIMD_I8x16_SPLAT(WASM_GET_LOCAL(a))), |
1128 WASM_SET_LOCAL(simd1, WASM_SIMD_I8x16_SPLAT(WASM_GET_LOCAL(b))), | 1227 WASM_SET_LOCAL(simd1, WASM_SIMD_I8x16_SPLAT(WASM_GET_LOCAL(b))), |
1129 WASM_SET_LOCAL(simd1, | 1228 WASM_SET_LOCAL(simd1, |
1130 WASM_SIMD_MATERIALIZE_BOOLS( | 1229 WASM_SIMD_MATERIALIZE_BOOLS( |
1131 8x16, WASM_SIMD_BINOP(simd_op, WASM_GET_LOCAL(simd0), | 1230 8x16, WASM_SIMD_BINOP(simd_op, WASM_GET_LOCAL(simd0), |
1132 WASM_GET_LOCAL(simd1)))), | 1231 WASM_GET_LOCAL(simd1)))), |
1133 WASM_SIMD_CHECK_SPLAT16(I8x16, simd1, I32, expected), WASM_ONE); | 1232 WASM_SIMD_CHECK_SPLAT16(I8x16, simd1, I32, expected), WASM_ONE); |
1134 | 1233 |
1135 FOR_INT8_INPUTS(i) { | 1234 FOR_INT8_INPUTS(i) { |
1136 FOR_INT8_INPUTS(j) { CHECK_EQ(1, r.Call(*i, *j, expected_op(*i, *j))); } | 1235 FOR_INT8_INPUTS(j) { CHECK_EQ(1, r.Call(*i, *j, expected_op(*i, *j))); } |
1137 } | 1236 } |
1138 } | 1237 } |
1139 | 1238 |
1140 WASM_EXEC_TEST(I8x16Equal) { RunI8x16CompareOpTest(kExprI8x16Eq, Equal); } | 1239 WASM_EXEC_COMPILED_TEST(I8x16Equal) { |
1240 RunI8x16CompareOpTest(kExprI8x16Eq, Equal); | |
1241 } | |
1141 | 1242 |
1142 WASM_EXEC_TEST(I8x16NotEqual) { RunI8x16CompareOpTest(kExprI8x16Ne, NotEqual); } | 1243 WASM_EXEC_COMPILED_TEST(I8x16NotEqual) { |
1244 RunI8x16CompareOpTest(kExprI8x16Ne, NotEqual); | |
1245 } | |
1143 | 1246 |
1144 WASM_EXEC_TEST(I8x16Greater) { RunI8x16CompareOpTest(kExprI8x16GtS, Greater); } | 1247 WASM_EXEC_COMPILED_TEST(I8x16Greater) { |
1248 RunI8x16CompareOpTest(kExprI8x16GtS, Greater); | |
1249 } | |
1145 | 1250 |
1146 WASM_EXEC_TEST(I8x16GreaterEqual) { | 1251 WASM_EXEC_COMPILED_TEST(I8x16GreaterEqual) { |
1147 RunI8x16CompareOpTest(kExprI8x16GeS, GreaterEqual); | 1252 RunI8x16CompareOpTest(kExprI8x16GeS, GreaterEqual); |
1148 } | 1253 } |
1149 | 1254 |
1150 WASM_EXEC_TEST(I8x16Less) { RunI8x16CompareOpTest(kExprI8x16LtS, Less); } | 1255 WASM_EXEC_COMPILED_TEST(I8x16Less) { |
1256 RunI8x16CompareOpTest(kExprI8x16LtS, Less); | |
1257 } | |
1151 | 1258 |
1152 WASM_EXEC_TEST(I8x16LessEqual) { | 1259 WASM_EXEC_COMPILED_TEST(I8x16LessEqual) { |
1153 RunI8x16CompareOpTest(kExprI8x16LeS, LessEqual); | 1260 RunI8x16CompareOpTest(kExprI8x16LeS, LessEqual); |
1154 } | 1261 } |
1155 | 1262 |
1156 WASM_EXEC_TEST(Ui8x16Greater) { | 1263 WASM_EXEC_COMPILED_TEST(Ui8x16Greater) { |
1157 RunI8x16CompareOpTest(kExprI8x16GtU, UnsignedGreater); | 1264 RunI8x16CompareOpTest(kExprI8x16GtU, UnsignedGreater); |
1158 } | 1265 } |
1159 | 1266 |
1160 WASM_EXEC_TEST(Ui8x16GreaterEqual) { | 1267 WASM_EXEC_COMPILED_TEST(Ui8x16GreaterEqual) { |
1161 RunI8x16CompareOpTest(kExprI8x16GeU, UnsignedGreaterEqual); | 1268 RunI8x16CompareOpTest(kExprI8x16GeU, UnsignedGreaterEqual); |
1162 } | 1269 } |
1163 | 1270 |
1164 WASM_EXEC_TEST(Ui8x16Less) { | 1271 WASM_EXEC_COMPILED_TEST(Ui8x16Less) { |
1165 RunI8x16CompareOpTest(kExprI8x16LtU, UnsignedLess); | 1272 RunI8x16CompareOpTest(kExprI8x16LtU, UnsignedLess); |
1166 } | 1273 } |
1167 | 1274 |
1168 WASM_EXEC_TEST(Ui8x16LessEqual) { | 1275 WASM_EXEC_COMPILED_TEST(Ui8x16LessEqual) { |
1169 RunI8x16CompareOpTest(kExprI8x16LeU, UnsignedLessEqual); | 1276 RunI8x16CompareOpTest(kExprI8x16LeU, UnsignedLessEqual); |
1170 } | 1277 } |
1171 | 1278 |
1172 void RunI8x16ShiftOpTest(WasmOpcode simd_op, Int8ShiftOp expected_op, | 1279 void RunI8x16ShiftOpTest(WasmOpcode simd_op, Int8ShiftOp expected_op, |
1173 int shift) { | 1280 int shift) { |
1174 FLAG_wasm_simd_prototype = true; | 1281 FLAG_wasm_simd_prototype = true; |
1175 WasmRunner<int32_t, int32_t, int32_t> r(kExecuteCompiled); | 1282 WasmRunner<int32_t, int32_t, int32_t> r(kExecuteCompiled); |
1176 byte a = 0; | 1283 byte a = 0; |
1177 byte expected = 1; | 1284 byte expected = 1; |
1178 byte simd = r.AllocateLocal(kWasmS128); | 1285 byte simd = r.AllocateLocal(kWasmS128); |
1179 BUILD(r, WASM_SET_LOCAL(simd, WASM_SIMD_I8x16_SPLAT(WASM_GET_LOCAL(a))), | 1286 BUILD(r, WASM_SET_LOCAL(simd, WASM_SIMD_I8x16_SPLAT(WASM_GET_LOCAL(a))), |
1180 WASM_SET_LOCAL( | 1287 WASM_SET_LOCAL( |
1181 simd, WASM_SIMD_SHIFT_OP(simd_op, shift, WASM_GET_LOCAL(simd))), | 1288 simd, WASM_SIMD_SHIFT_OP(simd_op, shift, WASM_GET_LOCAL(simd))), |
1182 WASM_SIMD_CHECK_SPLAT16(I8x16, simd, I32, expected), WASM_ONE); | 1289 WASM_SIMD_CHECK_SPLAT16(I8x16, simd, I32, expected), WASM_ONE); |
1183 | 1290 |
1184 FOR_INT8_INPUTS(i) { CHECK_EQ(1, r.Call(*i, expected_op(*i, shift))); } | 1291 FOR_INT8_INPUTS(i) { CHECK_EQ(1, r.Call(*i, expected_op(*i, shift))); } |
1185 } | 1292 } |
1186 | 1293 |
1187 WASM_EXEC_TEST(I8x16Shl) { | 1294 WASM_EXEC_COMPILED_TEST(I8x16Shl) { |
1188 RunI8x16ShiftOpTest(kExprI8x16Shl, LogicalShiftLeft, 1); | 1295 RunI8x16ShiftOpTest(kExprI8x16Shl, LogicalShiftLeft, 1); |
1189 } | 1296 } |
1190 | 1297 |
1191 WASM_EXEC_TEST(I8x16ShrS) { | 1298 WASM_EXEC_COMPILED_TEST(I8x16ShrS) { |
1192 RunI8x16ShiftOpTest(kExprI8x16ShrS, ArithmeticShiftRight, 1); | 1299 RunI8x16ShiftOpTest(kExprI8x16ShrS, ArithmeticShiftRight, 1); |
1193 } | 1300 } |
1194 | 1301 |
1195 WASM_EXEC_TEST(I8x16ShrU) { | 1302 WASM_EXEC_COMPILED_TEST(I8x16ShrU) { |
1196 RunI8x16ShiftOpTest(kExprI8x16ShrU, LogicalShiftRight, 1); | 1303 RunI8x16ShiftOpTest(kExprI8x16ShrU, LogicalShiftRight, 1); |
1197 } | 1304 } |
1198 | 1305 |
1199 // Test Select by making a mask where the first two lanes are true and the rest | 1306 // Test Select by making a mask where the first two lanes are true and the rest |
1200 // false, and comparing for non-equality with zero to materialize a bool vector. | 1307 // false, and comparing for non-equality with zero to materialize a bool vector. |
1201 #define WASM_SIMD_SELECT_TEST(format) \ | 1308 #define WASM_SIMD_SELECT_TEST(format) \ |
1202 WASM_EXEC_TEST(S##format##Select) { \ | 1309 WASM_EXEC_COMPILED_TEST(S##format##Select) { \ |
1203 FLAG_wasm_simd_prototype = true; \ | 1310 FLAG_wasm_simd_prototype = true; \ |
1204 WasmRunner<int32_t, int32_t, int32_t> r(kExecuteCompiled); \ | 1311 WasmRunner<int32_t, int32_t, int32_t> r(kExecuteCompiled); \ |
1205 byte val1 = 0; \ | 1312 byte val1 = 0; \ |
1206 byte val2 = 1; \ | 1313 byte val2 = 1; \ |
1207 byte src1 = r.AllocateLocal(kWasmS128); \ | 1314 byte src1 = r.AllocateLocal(kWasmS128); \ |
1208 byte src2 = r.AllocateLocal(kWasmS128); \ | 1315 byte src2 = r.AllocateLocal(kWasmS128); \ |
1209 byte zero = r.AllocateLocal(kWasmS128); \ | 1316 byte zero = r.AllocateLocal(kWasmS128); \ |
1210 byte mask = r.AllocateLocal(kWasmS128); \ | 1317 byte mask = r.AllocateLocal(kWasmS128); \ |
1211 BUILD(r, WASM_SET_LOCAL( \ | 1318 BUILD(r, WASM_SET_LOCAL( \ |
1212 src1, WASM_SIMD_I##format##_SPLAT(WASM_GET_LOCAL(val1))), \ | 1319 src1, WASM_SIMD_I##format##_SPLAT(WASM_GET_LOCAL(val1))), \ |
(...skipping 15 matching lines...) Expand all Loading... | |
1228 WASM_SIMD_CHECK_LANE(I##format, mask, I32, val1, 2), \ | 1335 WASM_SIMD_CHECK_LANE(I##format, mask, I32, val1, 2), \ |
1229 WASM_SIMD_CHECK_LANE(I##format, mask, I32, val2, 3), WASM_ONE); \ | 1336 WASM_SIMD_CHECK_LANE(I##format, mask, I32, val2, 3), WASM_ONE); \ |
1230 \ | 1337 \ |
1231 CHECK_EQ(1, r.Call(0x12, 0x34)); \ | 1338 CHECK_EQ(1, r.Call(0x12, 0x34)); \ |
1232 } | 1339 } |
1233 | 1340 |
1234 WASM_SIMD_SELECT_TEST(32x4) | 1341 WASM_SIMD_SELECT_TEST(32x4) |
1235 WASM_SIMD_SELECT_TEST(16x8) | 1342 WASM_SIMD_SELECT_TEST(16x8) |
1236 WASM_SIMD_SELECT_TEST(8x16) | 1343 WASM_SIMD_SELECT_TEST(8x16) |
1237 #endif // V8_TARGET_ARCH_ARM | 1344 #endif // V8_TARGET_ARCH_ARM |
1345 | |
1346 #if V8_TARGET_ARCH_ARM || SIMD_LOWERING_TARGET | |
1347 WASM_EXEC_COMPILED_TEST(SimdI32x4ExtractWithF32x4) { | |
1348 FLAG_wasm_simd_prototype = true; | |
1349 WasmRunner<int32_t> r(kExecuteCompiled); | |
1350 BUILD(r, WASM_IF_ELSE_I( | |
1351 WASM_I32_EQ(WASM_SIMD_I32x4_EXTRACT_LANE( | |
1352 0, WASM_SIMD_F32x4_SPLAT(WASM_F32(30.5))), | |
1353 WASM_I32_REINTERPRET_F32(WASM_F32(30.5))), | |
1354 WASM_I32V(1), WASM_I32V(0))); | |
1355 FOR_INT32_INPUTS(i) { CHECK_EQ(1, r.Call()); } | |
1356 } | |
1357 | |
1358 WASM_EXEC_COMPILED_TEST(SimdF32x4ExtractWithI32x4) { | |
1359 FLAG_wasm_simd_prototype = true; | |
1360 WasmRunner<int32_t> r(kExecuteCompiled); | |
1361 BUILD(r, | |
1362 WASM_IF_ELSE_I(WASM_F32_EQ(WASM_SIMD_F32x4_EXTRACT_LANE( | |
1363 0, WASM_SIMD_I32x4_SPLAT(WASM_I32V(15))), | |
1364 WASM_F32_REINTERPRET_I32(WASM_I32V(15))), | |
1365 WASM_I32V(1), WASM_I32V(0))); | |
1366 FOR_INT32_INPUTS(i) { CHECK_EQ(1, r.Call()); } | |
1367 } | |
1368 | |
1369 WASM_EXEC_COMPILED_TEST(SimdF32x4AddWithI32x4) { | |
1370 FLAG_wasm_simd_prototype = true; | |
1371 WasmRunner<int32_t> r(kExecuteCompiled); | |
1372 BUILD(r, | |
1373 WASM_IF_ELSE_I( | |
1374 WASM_F32_EQ(WASM_SIMD_F32x4_EXTRACT_LANE( | |
1375 0, WASM_SIMD_F32x4_ADD( | |
1376 WASM_SIMD_I32x4_SPLAT(WASM_I32V(32)), | |
1377 WASM_SIMD_I32x4_SPLAT(WASM_I32V(19)))), | |
1378 WASM_F32_ADD(WASM_F32_REINTERPRET_I32(WASM_I32V(32)), | |
1379 WASM_F32_REINTERPRET_I32(WASM_I32V(19)))), | |
1380 WASM_I32V(1), WASM_I32V(0))); | |
1381 FOR_INT32_INPUTS(i) { CHECK_EQ(1, r.Call()); } | |
1382 } | |
1383 | |
1384 WASM_EXEC_COMPILED_TEST(SimdI32x4AddWithF32x4) { | |
1385 FLAG_wasm_simd_prototype = true; | |
1386 WasmRunner<int32_t> r(kExecuteCompiled); | |
1387 BUILD(r, | |
1388 WASM_IF_ELSE_I( | |
1389 WASM_I32_EQ(WASM_SIMD_I32x4_EXTRACT_LANE( | |
1390 0, WASM_SIMD_I32x4_ADD( | |
1391 WASM_SIMD_F32x4_SPLAT(WASM_F32(21.25)), | |
1392 WASM_SIMD_F32x4_SPLAT(WASM_F32(31.5)))), | |
1393 WASM_I32_ADD(WASM_I32_REINTERPRET_F32(WASM_F32(21.25)), | |
1394 WASM_I32_REINTERPRET_F32(WASM_F32(31.5)))), | |
1395 WASM_I32V(1), WASM_I32V(0))); | |
1396 FOR_INT32_INPUTS(i) { CHECK_EQ(1, r.Call()); } | |
1397 } | |
1398 | |
1399 WASM_EXEC_COMPILED_TEST(SimdI32x4Local) { | |
1400 FLAG_wasm_simd_prototype = true; | |
1401 WasmRunner<int32_t> r(kExecuteCompiled); | |
1402 r.AllocateLocal(kWasmS128); | |
1403 BUILD(r, WASM_SET_LOCAL(0, WASM_SIMD_I32x4_SPLAT(WASM_I32V(31))), | |
1404 | |
1405 WASM_SIMD_I32x4_EXTRACT_LANE(0, WASM_GET_LOCAL(0))); | |
1406 FOR_INT32_INPUTS(i) { CHECK_EQ(31, r.Call()); } | |
1407 } | |
1408 | |
1409 WASM_EXEC_COMPILED_TEST(SimdI32x4SplatFromExtract) { | |
1410 FLAG_wasm_simd_prototype = true; | |
1411 WasmRunner<int32_t> r(kExecuteCompiled); | |
1412 r.AllocateLocal(kWasmI32); | |
1413 r.AllocateLocal(kWasmS128); | |
1414 BUILD(r, WASM_SET_LOCAL(0, WASM_SIMD_I32x4_EXTRACT_LANE( | |
1415 0, WASM_SIMD_I32x4_SPLAT(WASM_I32V(76)))), | |
1416 WASM_SET_LOCAL(1, WASM_SIMD_I32x4_SPLAT(WASM_GET_LOCAL(0))), | |
1417 WASM_SIMD_I32x4_EXTRACT_LANE(1, WASM_GET_LOCAL(1))); | |
1418 FOR_INT32_INPUTS(i) { CHECK_EQ(76, r.Call()); } | |
1419 } | |
1420 | |
1421 WASM_EXEC_COMPILED_TEST(SimdI32x4For) { | |
1422 FLAG_wasm_simd_prototype = true; | |
1423 WasmRunner<int32_t> r(kExecuteCompiled); | |
1424 r.AllocateLocal(kWasmI32); | |
1425 r.AllocateLocal(kWasmS128); | |
1426 BUILD(r, | |
1427 | |
1428 WASM_SET_LOCAL(1, WASM_SIMD_I32x4_SPLAT(WASM_I32V(31))), | |
1429 WASM_SET_LOCAL(1, WASM_SIMD_I32x4_REPLACE_LANE(1, WASM_GET_LOCAL(1), | |
1430 WASM_I32V(53))), | |
1431 WASM_SET_LOCAL(1, WASM_SIMD_I32x4_REPLACE_LANE(2, WASM_GET_LOCAL(1), | |
1432 WASM_I32V(23))), | |
1433 WASM_SET_LOCAL(0, WASM_I32V(0)), | |
1434 WASM_LOOP( | |
1435 WASM_SET_LOCAL( | |
1436 1, WASM_SIMD_I32x4_ADD(WASM_GET_LOCAL(1), | |
1437 WASM_SIMD_I32x4_SPLAT(WASM_I32V(1)))), | |
1438 WASM_IF(WASM_I32_NE(WASM_INC_LOCAL(0), WASM_I32V(5)), WASM_BR(1))), | |
1439 WASM_SET_LOCAL(0, WASM_I32V(1)), | |
1440 WASM_IF(WASM_I32_NE(WASM_SIMD_I32x4_EXTRACT_LANE(0, WASM_GET_LOCAL(1)), | |
1441 WASM_I32V(36)), | |
1442 WASM_SET_LOCAL(0, WASM_I32V(0))), | |
1443 WASM_IF(WASM_I32_NE(WASM_SIMD_I32x4_EXTRACT_LANE(1, WASM_GET_LOCAL(1)), | |
1444 WASM_I32V(58)), | |
1445 WASM_SET_LOCAL(0, WASM_I32V(0))), | |
1446 WASM_IF(WASM_I32_NE(WASM_SIMD_I32x4_EXTRACT_LANE(2, WASM_GET_LOCAL(1)), | |
1447 WASM_I32V(28)), | |
1448 WASM_SET_LOCAL(0, WASM_I32V(0))), | |
1449 WASM_IF(WASM_I32_NE(WASM_SIMD_I32x4_EXTRACT_LANE(3, WASM_GET_LOCAL(1)), | |
1450 WASM_I32V(36)), | |
1451 WASM_SET_LOCAL(0, WASM_I32V(0))), | |
1452 WASM_GET_LOCAL(0)); | |
1453 FOR_INT32_INPUTS(i) { CHECK_EQ(1, r.Call()); } | |
1454 } | |
1455 | |
1456 WASM_EXEC_COMPILED_TEST(SimdF32x4For) { | |
1457 FLAG_wasm_simd_prototype = true; | |
1458 WasmRunner<int32_t> r(kExecuteCompiled); | |
1459 r.AllocateLocal(kWasmI32); | |
1460 r.AllocateLocal(kWasmS128); | |
1461 BUILD(r, WASM_SET_LOCAL(1, WASM_SIMD_F32x4_SPLAT(WASM_F32(21.25))), | |
1462 WASM_SET_LOCAL(1, WASM_SIMD_F32x4_REPLACE_LANE(3, WASM_GET_LOCAL(1), | |
1463 WASM_F32(19.5))), | |
1464 WASM_SET_LOCAL(0, WASM_I32V(0)), | |
1465 WASM_LOOP( | |
1466 WASM_SET_LOCAL( | |
1467 1, WASM_SIMD_F32x4_ADD(WASM_GET_LOCAL(1), | |
1468 WASM_SIMD_F32x4_SPLAT(WASM_F32(2.0)))), | |
1469 WASM_IF(WASM_I32_NE(WASM_INC_LOCAL(0), WASM_I32V(3)), WASM_BR(1))), | |
1470 WASM_SET_LOCAL(0, WASM_I32V(1)), | |
1471 WASM_IF(WASM_F32_NE(WASM_SIMD_F32x4_EXTRACT_LANE(0, WASM_GET_LOCAL(1)), | |
1472 WASM_F32(27.25)), | |
1473 WASM_SET_LOCAL(0, WASM_I32V(0))), | |
1474 WASM_IF(WASM_F32_NE(WASM_SIMD_F32x4_EXTRACT_LANE(3, WASM_GET_LOCAL(1)), | |
1475 WASM_F32(25.5)), | |
1476 WASM_SET_LOCAL(0, WASM_I32V(0))), | |
1477 WASM_GET_LOCAL(0)); | |
1478 FOR_INT32_INPUTS(i) { CHECK_EQ(1, r.Call()); } | |
1479 } | |
1480 #endif // V8_TARGET_ARCH_ARM || SIMD_LOWERING_TARGET | |
1481 | |
1482 #if SIMD_LOWERING_TARGET | |
1483 WASM_EXEC_COMPILED_TEST(SimdI32x4GetGlobal) { | |
1484 FLAG_wasm_simd_prototype = true; | |
1485 WasmRunner<int32_t, int32_t> r(kExecuteCompiled); | |
1486 int32_t* global = r.module().AddGlobal<int32_t>(kWasmS128); | |
1487 *(global) = 0; | |
1488 *(global + 1) = 1; | |
1489 *(global + 2) = 2; | |
1490 *(global + 3) = 3; | |
1491 r.AllocateLocal(kWasmI32); | |
1492 BUILD( | |
1493 r, WASM_SET_LOCAL(1, WASM_I32V(1)), | |
1494 WASM_IF(WASM_I32_NE(WASM_I32V(0), | |
1495 WASM_SIMD_I32x4_EXTRACT_LANE(0, WASM_GET_GLOBAL(0))), | |
1496 WASM_SET_LOCAL(1, WASM_I32V(0))), | |
1497 WASM_IF(WASM_I32_NE(WASM_I32V(1), | |
1498 WASM_SIMD_I32x4_EXTRACT_LANE(1, WASM_GET_GLOBAL(0))), | |
1499 WASM_SET_LOCAL(1, WASM_I32V(0))), | |
1500 WASM_IF(WASM_I32_NE(WASM_I32V(2), | |
1501 WASM_SIMD_I32x4_EXTRACT_LANE(2, WASM_GET_GLOBAL(0))), | |
1502 WASM_SET_LOCAL(1, WASM_I32V(0))), | |
1503 WASM_IF(WASM_I32_NE(WASM_I32V(3), | |
1504 WASM_SIMD_I32x4_EXTRACT_LANE(3, WASM_GET_GLOBAL(0))), | |
1505 WASM_SET_LOCAL(1, WASM_I32V(0))), | |
1506 WASM_GET_LOCAL(1)); | |
1507 FOR_INT32_INPUTS(i) { CHECK_EQ(1, r.Call(0)); } | |
1508 } | |
1509 | |
1510 WASM_EXEC_COMPILED_TEST(SimdI32x4SetGlobal) { | |
1511 FLAG_wasm_simd_prototype = true; | |
1512 WasmRunner<int32_t, int32_t> r(kExecuteCompiled); | |
1513 int32_t* global = r.module().AddGlobal<int32_t>(kWasmS128); | |
1514 BUILD(r, WASM_SET_GLOBAL(0, WASM_SIMD_I32x4_SPLAT(WASM_I32V(23))), | |
1515 WASM_SET_GLOBAL(0, WASM_SIMD_I32x4_REPLACE_LANE(1, WASM_GET_GLOBAL(0), | |
1516 WASM_I32V(34))), | |
1517 WASM_SET_GLOBAL(0, WASM_SIMD_I32x4_REPLACE_LANE(2, WASM_GET_GLOBAL(0), | |
1518 WASM_I32V(45))), | |
1519 WASM_SET_GLOBAL(0, WASM_SIMD_I32x4_REPLACE_LANE(3, WASM_GET_GLOBAL(0), | |
1520 WASM_I32V(56))), | |
1521 WASM_I32V(1)); | |
1522 FOR_INT32_INPUTS(i) { CHECK_EQ(1, r.Call(0)); } | |
1523 CHECK_EQ(*global, 23); | |
1524 CHECK_EQ(*(global + 1), 34); | |
1525 CHECK_EQ(*(global + 2), 45); | |
1526 CHECK_EQ(*(global + 3), 56); | |
1527 } | |
1528 | |
1529 WASM_EXEC_COMPILED_TEST(SimdF32x4GetGlobal) { | |
1530 FLAG_wasm_simd_prototype = true; | |
1531 WasmRunner<int32_t, int32_t> r(kExecuteCompiled); | |
1532 float* global = r.module().AddGlobal<float>(kWasmS128); | |
1533 *(global) = 0.0; | |
1534 *(global + 1) = 1.5; | |
1535 *(global + 2) = 2.25; | |
1536 *(global + 3) = 3.5; | |
1537 r.AllocateLocal(kWasmI32); | |
1538 BUILD( | |
1539 r, WASM_SET_LOCAL(1, WASM_I32V(1)), | |
1540 WASM_IF(WASM_F32_NE(WASM_F32(0.0), | |
1541 WASM_SIMD_F32x4_EXTRACT_LANE(0, WASM_GET_GLOBAL(0))), | |
1542 WASM_SET_LOCAL(1, WASM_I32V(0))), | |
1543 WASM_IF(WASM_F32_NE(WASM_F32(1.5), | |
1544 WASM_SIMD_F32x4_EXTRACT_LANE(1, WASM_GET_GLOBAL(0))), | |
1545 WASM_SET_LOCAL(1, WASM_I32V(0))), | |
1546 WASM_IF(WASM_F32_NE(WASM_F32(2.25), | |
1547 WASM_SIMD_F32x4_EXTRACT_LANE(2, WASM_GET_GLOBAL(0))), | |
1548 WASM_SET_LOCAL(1, WASM_I32V(0))), | |
1549 WASM_IF(WASM_F32_NE(WASM_F32(3.5), | |
1550 WASM_SIMD_F32x4_EXTRACT_LANE(3, WASM_GET_GLOBAL(0))), | |
1551 WASM_SET_LOCAL(1, WASM_I32V(0))), | |
1552 WASM_GET_LOCAL(1)); | |
1553 FOR_INT32_INPUTS(i) { CHECK_EQ(1, r.Call(0)); } | |
1554 } | |
1555 | |
1556 WASM_EXEC_COMPILED_TEST(SimdF32x4SetGlobal) { | |
1557 FLAG_wasm_simd_prototype = true; | |
1558 WasmRunner<int32_t, int32_t> r(kExecuteCompiled); | |
1559 float* global = r.module().AddGlobal<float>(kWasmS128); | |
1560 BUILD(r, WASM_SET_GLOBAL(0, WASM_SIMD_F32x4_SPLAT(WASM_F32(13.5))), | |
1561 WASM_SET_GLOBAL(0, WASM_SIMD_F32x4_REPLACE_LANE(1, WASM_GET_GLOBAL(0), | |
1562 WASM_F32(45.5))), | |
1563 WASM_SET_GLOBAL(0, WASM_SIMD_F32x4_REPLACE_LANE(2, WASM_GET_GLOBAL(0), | |
1564 WASM_F32(32.25))), | |
1565 WASM_SET_GLOBAL(0, WASM_SIMD_F32x4_REPLACE_LANE(3, WASM_GET_GLOBAL(0), | |
1566 WASM_F32(65.0))), | |
1567 WASM_I32V(1)); | |
1568 FOR_INT32_INPUTS(i) { CHECK_EQ(1, r.Call(0)); } | |
1569 CHECK_EQ(*global, 13.5); | |
1570 CHECK_EQ(*(global + 1), 45.5); | |
1571 CHECK_EQ(*(global + 2), 32.25); | |
1572 CHECK_EQ(*(global + 3), 65.0); | |
1573 } | |
1574 #endif // SIMD_LOWERING_TARGET | |
OLD | NEW |