[ARM] Implement irregular vector shuffles for SIMD.

test/cctest/wasm/test-run-wasm-simd.cc

 // Copyright 2016 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/assembler-inl.h"
 #include "test/cctest/cctest.h"
 #include "test/cctest/compiler/value-helper.h"
 #include "test/cctest/wasm/wasm-run-utils.h"
 #include "test/common/wasm/wasm-macro-gen.h"
 
@@ skipping 1692 matching lines @@
 WASM_EXEC_COMPILED_TEST(S32x4TransposeRight) {
   RunBinaryLaneOpTest<int32_t>(kExprS32x4Shuffle, {{1, 5, 3, 7}});
   RunBinaryLaneOpTest<int32_t>(kExprS32x4Shuffle, {{1, 1, 3, 3}});
 }
 
 // Reverses are only unary.
 WASM_EXEC_COMPILED_TEST(S32x2Reverse) {
   RunBinaryLaneOpTest<int32_t>(kExprS32x4Shuffle, {{1, 0, 3, 2}});
 }
 
+// Test irregular shuffle.
+WASM_EXEC_COMPILED_TEST(S32x4Irregular) {
+  RunBinaryLaneOpTest<int32_t>(kExprS32x4Shuffle, {{0, 4, 4, 5}});
+  RunBinaryLaneOpTest<int32_t>(kExprS32x4Shuffle, {{0, 0, 0, 1}});
+}
+
 WASM_EXEC_COMPILED_TEST(S16x8ZipLeft) {
   RunBinaryLaneOpTest<int16_t>(kExprS16x8Shuffle, {{0, 8, 1, 9, 2, 10, 3, 11}});
   RunBinaryLaneOpTest<int16_t>(kExprS16x8Shuffle, {{0, 0, 1, 1, 2, 2, 3, 3}});
 }
 
 WASM_EXEC_COMPILED_TEST(S16x8ZipRight) {
   RunBinaryLaneOpTest<int16_t>(kExprS16x8Shuffle,
                                {{4, 12, 5, 13, 6, 14, 7, 15}});
   RunBinaryLaneOpTest<int16_t>(kExprS16x8Shuffle, {{4, 4, 5, 5, 6, 6, 7, 7}});
 }
@@ skipping 23 matching lines @@
 }
 
 WASM_EXEC_COMPILED_TEST(S16x4Reverse) {
   RunBinaryLaneOpTest<int16_t>(kExprS16x8Shuffle, {{3, 2, 1, 0, 7, 6, 5, 4}});
 }
 
 WASM_EXEC_COMPILED_TEST(S16x2Reverse) {
   RunBinaryLaneOpTest<int16_t>(kExprS16x8Shuffle, {{1, 0, 3, 2, 5, 4, 7, 6}});
 }
 
+WASM_EXEC_COMPILED_TEST(S16x8Irregular) {
+  RunBinaryLaneOpTest<int16_t>(kExprS16x8Shuffle, {{0, 8, 8, 0, 2, 10, 3, 11}});
+  RunBinaryLaneOpTest<int16_t>(kExprS16x8Shuffle, {{0, 0, 0, 0, 2, 2, 3, 3}});
+}
+
 WASM_EXEC_COMPILED_TEST(S8x16ZipLeft) {
   RunBinaryLaneOpTest<int8_t>(
       kExprS8x16Shuffle,
       {{0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23}});
   RunBinaryLaneOpTest<int8_t>(
       kExprS8x16Shuffle, {{0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7}});
 }
 
 WASM_EXEC_COMPILED_TEST(S8x16ZipRight) {
   RunBinaryLaneOpTest<int8_t>(
@@ skipping 44 matching lines @@
 WASM_EXEC_COMPILED_TEST(S8x4Reverse) {
   RunBinaryLaneOpTest<int8_t>(kExprS8x16Shuffle, {{3, 2, 1, 0, 7, 6, 5, 4, 11,
                                                    10, 9, 8, 15, 14, 13, 12}});
 }
 
 WASM_EXEC_COMPILED_TEST(S8x2Reverse) {
   RunBinaryLaneOpTest<int8_t>(kExprS8x16Shuffle, {{1, 0, 3, 2, 5, 4, 7, 6, 9, 8,
                                                    11, 10, 13, 12, 15, 14}});
 }
 
+WASM_EXEC_COMPILED_TEST(S8x16Irregular) {
+  RunBinaryLaneOpTest<int8_t>(
+      kExprS8x16Shuffle,
+      {{0, 16, 0, 16, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23}});
+  RunBinaryLaneOpTest<int8_t>(
+      kExprS8x16Shuffle, {{0, 0, 0, 0, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7}});
+}
+
 // Test shuffles that concatenate the two vectors.
 template <typename T>
 void RunConcatOpTest(WasmOpcode simd_op) {
   static const int kLanes = kSimd128Size / sizeof(T);
   std::array<T, kLanes> expected;
   for (int bias = 1; bias < kLanes; bias++) {
     int i = 0;
     // last kLanes - bias bytes of first vector.
     for (int j = bias; j < kLanes; j++) {
       expected[i++] = j;
@@ skipping 448 matching lines @@
         WASM_SIMD_I32x4_EXTRACT_LANE(
             0, WASM_LOAD_MEM(MachineType::Simd128(), WASM_ZERO)));
 
   FOR_INT32_INPUTS(i) {
     int32_t expected = *i;
     r.module().WriteMemory(&memory[0], expected);
     CHECK_EQ(expected, r.Call());
   }
 }
 #endif  // V8_TARGET_ARCH_ARM || SIMD_LOWERING_TARGET || V8_TARGET_ARCH_X64