[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 2172 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);

[john.yan, 2017/04/27 17:44:48]

I am not sure I am on the right tract. If global memory is BE, then these
CHECK_EQ should be in reversed order. If global memory has to be LE, there are a
lot of places need to update in test-run-wasm.cc

[Clemens Hammacher, 2017/04/27 17:48:33]

OK, let me correct myself: Tests are the only way to observe byte order of
stored globals :/
It would be OK for me to fix the tests in this case. But *only* for global
memory, not for the general memory, as byte order in general memory is
observable.

Bill, feel free to object :)

   CHECK_EQ(*(global + 1), 45.5);
   CHECK_EQ(*(global + 2), 32.25);
   CHECK_EQ(*(global + 3), 65.0);
 }
 
 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;
+#if defined(V8_TARGET_LITTLE_ENDIAN)
     r.module().WriteMemory(&memory[0], expected);
+#else
+    r.module().WriteMemory(&memory[3], expected);
+#endif
     CHECK_EQ(expected, r.Call());
   }
 }
 #endif  // V8_TARGET_ARCH_ARM || SIMD_LOWERING_TARGET