[wasm] Implement 128-bit endian swap for simd type

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 1946 matching lines @@
 WASM_EXEC_COMPILED_TEST(S1x8Xor) { RunS1x8BinOpTest(kExprS1x8Xor, Xor); }
 
 WASM_EXEC_COMPILED_TEST(S1x16And) { RunS1x16BinOpTest(kExprS1x16And, And); }
 
 WASM_EXEC_COMPILED_TEST(S1x16Or) { RunS1x16BinOpTest(kExprS1x16Or, Or); }
 
 WASM_EXEC_COMPILED_TEST(S1x16Xor) { RunS1x16BinOpTest(kExprS1x16Xor, Xor); }
 #endif  // !V8_TARGET_ARCH_ARM
 
 #if V8_TARGET_ARCH_ARM || SIMD_LOWERING_TARGET
+
+template <typename T, int maxLanes = 4>
+void SetVectorByLanes(T* v, ...) {
+  va_list vl;
+  va_start(vl, v);
+#if defined(V8_TARGET_BIG_ENDIAN)
+  for (int lane = maxLanes - 1; lane >= 0; lane--) {
+    v[lane] = static_cast<T>(va_arg(vl, T));
+  }
+#else
+  for (int lane = 0; lane < maxLanes; lane++) {
+    v[lane] = static_cast<T>(va_arg(vl, T));
+  }
+#endif
+  va_end(vl);
+}
+
+// has to specialize float to get rid of error
+template <>
+void SetVectorByLanes<float>(float* v, ...) {
+  va_list vl;
+  va_start(vl, v);
+  const int maxLanes = 4;
+#if defined(V8_TARGET_BIG_ENDIAN)
+  for (int lane = maxLanes - 1; lane >= 0; lane--) {
+    v[lane] = static_cast<float>(va_arg(vl, double));
+  }
+#else
+  for (int lane = 0; lane < maxLanes; lane++) {
+    v[lane] = static_cast<float>(va_arg(vl, double));
+  }
+#endif
+  va_end(vl);
+}
+
+template <int vSize = 16, typename T>
+T GetScalarByLanes(T* v, int lane) {
+#if defined(V8_TARGET_BIG_ENDIAN)
+  const int kElems = vSize / sizeof(T);

[Clemens Hammacher, 2017/04/28 09:45:48]

You can make this (and the others) constexpr, move {kElems} above the "#if", and
reuse it in the DCHECK.

+  const int index = kElems - 1 - lane;
+#else
+  const int index = lane;
+#endif
+  DCHECK(index >= 0 && index < static_cast<int>(vSize / sizeof(T)));
+  return v[index];
+}
+
 WASM_EXEC_COMPILED_TEST(SimdI32x4ExtractWithF32x4) {
   FLAG_wasm_simd_prototype = true;
   WasmRunner<int32_t> r(kExecuteCompiled);
   BUILD(r, WASM_IF_ELSE_I(
                WASM_I32_EQ(WASM_SIMD_I32x4_EXTRACT_LANE(
                                0, WASM_SIMD_F32x4_SPLAT(WASM_F32(30.5))),
                            WASM_I32_REINTERPRET_F32(WASM_F32(30.5))),
                WASM_I32V(1), WASM_I32V(0)));
   CHECK_EQ(1, r.Call());
 }
@@ skipping 124 matching lines @@
                             WASM_F32(25.5)),
                 WASM_SET_LOCAL(0, WASM_I32V(0))),
         WASM_GET_LOCAL(0));
   CHECK_EQ(1, r.Call());
 }
 
 WASM_EXEC_COMPILED_TEST(SimdI32x4GetGlobal) {
   FLAG_wasm_simd_prototype = true;
   WasmRunner<int32_t, int32_t> r(kExecuteCompiled);
   int32_t* global = r.module().AddGlobal<int32_t>(kWasmS128);
-  *(global) = 0;
-  *(global + 1) = 1;
-  *(global + 2) = 2;
-  *(global + 3) = 3;
+  SetVectorByLanes(global, 0, 1, 2, 3);
   r.AllocateLocal(kWasmI32);
   BUILD(
       r, WASM_SET_LOCAL(1, WASM_I32V(1)),
       WASM_IF(WASM_I32_NE(WASM_I32V(0),
                           WASM_SIMD_I32x4_EXTRACT_LANE(0, WASM_GET_GLOBAL(0))),
               WASM_SET_LOCAL(1, WASM_I32V(0))),
       WASM_IF(WASM_I32_NE(WASM_I32V(1),
                           WASM_SIMD_I32x4_EXTRACT_LANE(1, WASM_GET_GLOBAL(0))),
               WASM_SET_LOCAL(1, WASM_I32V(0))),
       WASM_IF(WASM_I32_NE(WASM_I32V(2),
@@ skipping 12 matching lines @@
   int32_t* global = r.module().AddGlobal<int32_t>(kWasmS128);
   BUILD(r, WASM_SET_GLOBAL(0, WASM_SIMD_I32x4_SPLAT(WASM_I32V(23))),
         WASM_SET_GLOBAL(0, WASM_SIMD_I32x4_REPLACE_LANE(1, WASM_GET_GLOBAL(0),
                                                         WASM_I32V(34))),
         WASM_SET_GLOBAL(0, WASM_SIMD_I32x4_REPLACE_LANE(2, WASM_GET_GLOBAL(0),
                                                         WASM_I32V(45))),
         WASM_SET_GLOBAL(0, WASM_SIMD_I32x4_REPLACE_LANE(3, WASM_GET_GLOBAL(0),
                                                         WASM_I32V(56))),
         WASM_I32V(1));
   CHECK_EQ(1, r.Call(0));
-  CHECK_EQ(*global, 23);
-  CHECK_EQ(*(global + 1), 34);
-  CHECK_EQ(*(global + 2), 45);
-  CHECK_EQ(*(global + 3), 56);
+  CHECK_EQ(GetScalarByLanes(global, 0), 23);
+  CHECK_EQ(GetScalarByLanes(global, 1), 34);
+  CHECK_EQ(GetScalarByLanes(global, 2), 45);
+  CHECK_EQ(GetScalarByLanes(global, 3), 56);
 }
 
 WASM_EXEC_COMPILED_TEST(SimdF32x4GetGlobal) {
   FLAG_wasm_simd_prototype = true;
   WasmRunner<int32_t, int32_t> r(kExecuteCompiled);
   float* global = r.module().AddGlobal<float>(kWasmS128);
-  *(global) = 0.0;
-  *(global + 1) = 1.5;
-  *(global + 2) = 2.25;
-  *(global + 3) = 3.5;
+  SetVectorByLanes<float>(global, 0.0, 1.5, 2.25, 3.5);
   r.AllocateLocal(kWasmI32);
   BUILD(
       r, WASM_SET_LOCAL(1, WASM_I32V(1)),
       WASM_IF(WASM_F32_NE(WASM_F32(0.0),
                           WASM_SIMD_F32x4_EXTRACT_LANE(0, WASM_GET_GLOBAL(0))),
               WASM_SET_LOCAL(1, WASM_I32V(0))),
       WASM_IF(WASM_F32_NE(WASM_F32(1.5),
                           WASM_SIMD_F32x4_EXTRACT_LANE(1, WASM_GET_GLOBAL(0))),
               WASM_SET_LOCAL(1, WASM_I32V(0))),
       WASM_IF(WASM_F32_NE(WASM_F32(2.25),
@@ skipping 12 matching lines @@
   float* global = r.module().AddGlobal<float>(kWasmS128);
   BUILD(r, WASM_SET_GLOBAL(0, WASM_SIMD_F32x4_SPLAT(WASM_F32(13.5))),
         WASM_SET_GLOBAL(0, WASM_SIMD_F32x4_REPLACE_LANE(1, WASM_GET_GLOBAL(0),
                                                         WASM_F32(45.5))),
         WASM_SET_GLOBAL(0, WASM_SIMD_F32x4_REPLACE_LANE(2, WASM_GET_GLOBAL(0),
                                                         WASM_F32(32.25))),
         WASM_SET_GLOBAL(0, WASM_SIMD_F32x4_REPLACE_LANE(3, WASM_GET_GLOBAL(0),
                                                         WASM_F32(65.0))),
         WASM_I32V(1));
   CHECK_EQ(1, r.Call(0));
-  CHECK_EQ(*global, 13.5);
-  CHECK_EQ(*(global + 1), 45.5);
-  CHECK_EQ(*(global + 2), 32.25);
-  CHECK_EQ(*(global + 3), 65.0);
+  CHECK_EQ(GetScalarByLanes(global, 0), 13.5f);
+  CHECK_EQ(GetScalarByLanes(global, 1), 45.5f);
+  CHECK_EQ(GetScalarByLanes(global, 2), 32.25f);
+  CHECK_EQ(GetScalarByLanes(global, 3), 65.0f);
 }
 
 WASM_EXEC_COMPILED_TEST(SimdLoadStoreLoad) {
   FLAG_wasm_simd_prototype = true;
   WasmRunner<int32_t> r(kExecuteCompiled);
   int32_t* memory = r.module().AddMemoryElems<int32_t>(4);
 
   BUILD(r,
         WASM_STORE_MEM(MachineType::Simd128(), WASM_ZERO,
                        WASM_LOAD_MEM(MachineType::Simd128(), WASM_ZERO)),
         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