Implement WASM big-endian support

test/cctest/wasm/wasm-run-utils.h

 // 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.
 
 #ifndef WASM_RUN_UTILS_H
 #define WASM_RUN_UTILS_H
 
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
@@ skipping 129 matching lines @@
 
   template <typename T>
   T* raw_mem_end() {
     DCHECK(instance->mem_start);
     return reinterpret_cast<T*>(instance->mem_start + instance->mem_size);
   }
 
   template <typename T>
   T raw_mem_at(int i) {
     DCHECK(instance->mem_start);
-    return reinterpret_cast<T*>(instance->mem_start)[i];
+    return ReadMemory(&(reinterpret_cast<T*>(instance->mem_start)[i]));
   }
 
   template <typename T>
   T raw_val_at(int i) {
-    T val;
-    memcpy(&val, reinterpret_cast<void*>(instance->mem_start + i), sizeof(T));
-    return val;
+    return ReadMemory(reinterpret_cast<T*>(instance->mem_start + i));
+  }
+
+  template <typename T>
+  void WriteMemory(T* p, T val) {

[titzer, 2016/06/06 07:44:00]

Can we unify these routines with the others?

[ivica.bogosavljevic, 2016/06/13 14:59:02]

We could use ReadLittleEndianValue and WriteLittleEndianValue, but please see
other comments first.

+#if defined(V8_TARGET_LITTLE_ENDIAN)
+    memcpy(p, &val, sizeof(T));
+#elif defined(V8_TARGET_BIG_ENDIAN)
+    byte* src = reinterpret_cast<byte*>(&val);
+    byte* dst = reinterpret_cast<byte*>(p);
+    for (int i = 0; i < sizeof(T); i++) {
+      dst[i] = src[sizeof(T) - i - 1];
+    }
+#else
+#error Unsupported endianness
+#endif

[ivica.bogosavljevic, 2016/06/13 14:59:02]

For myself: Commented code, needs to be removed

+    // byte * tmp = reinterpret_cast<byte*>(p);
+    // T v = val;
+    // for (int i = 0; i < sizeof(T); i++) {
+    //   tmp[i] = v & 0xff;
+    //   v = v >> 8;
+    // }
+  }
+
+  template <typename T>
+  T ReadMemory(T* p) {
+    T ret;
+#if defined(V8_TARGET_LITTLE_ENDIAN)
+    memcpy(&ret, p, sizeof(T));
+#elif defined(V8_TARGET_BIG_ENDIAN)
+    byte* src = reinterpret_cast<byte*>(p);
+    byte* dst = reinterpret_cast<byte*>(&ret);
+    for (int i = 0; i < sizeof(T); i++) {
+      dst[i] = src[sizeof(T) - i - 1];
+    }
+#else
+#error Unsupported endianness
+#endif
+    return ret;
+    // T val = 0;
+    // byte * tmp = reinterpret_cast<byte*>(p);
+    // for (int i = sizeof(T) - 1; i >= 0; i--) {
+    //   val = val << 8;
+    //   val = val | tmp[i];
+    // }
+    // return val;
   }
 
   // Zero-initialize the memory.
   void BlankMemory() {
     byte* raw = raw_mem_start<byte>();
     memset(raw, 0, instance->mem_size);
   }
 
   // Pseudo-randomly intialize the memory.
   void RandomizeMemory(unsigned int seed = 88) {
@@ skipping 594 matching lines @@
 // interpreter.
 #define WASM_EXEC_TEST(name)                                               \
   void RunWasm_##name(WasmExecutionMode execution_mode);                   \
   TEST(RunWasmCompiled_##name) { RunWasm_##name(kExecuteCompiled); }       \
   TEST(RunWasmInterpreted_##name) { RunWasm_##name(kExecuteInterpreted); } \
   void RunWasm_##name(WasmExecutionMode execution_mode)
 
 }  // namespace
 
 #endif