Implement WASM big-endian support

src/utils.h

 // Copyright 2012 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 V8_UTILS_H_
 #define V8_UTILS_H_
 
 #include <limits.h>
 #include <stdlib.h>
 #include <string.h>
@@ skipping 1530 matching lines @@
 }
 
 static inline uint32_t ReadUnalignedUInt32(const void* p) {
   return ReadUnalignedValue<uint32_t>(p);
 }
 
 static inline void WriteUnalignedUInt32(void* p, uint32_t value) {
   WriteUnalignedValue(p, value);
 }
 
+template <typename V>
+static inline V ReadLittleEndianValue(const void* p) {

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

Is it possible to unify these routines with those in wasm/decoder.h and
wasm/encoder.h?

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

I suggest we keep ReadLittleEndianValue and WriteLittleEndianValue, and modify
read_ and write methods in encoder.h and decoder.h to use  them. 

+#if defined(V8_TARGET_LITTLE_ENDIAN)
+  return ReadUnalignedValue(p);
+#elif defined(V8_TARGET_BIG_ENDIAN)
+  V ret = 0;
+  const byte* src = reinterpret_cast<const byte*>(p);
+  byte* dst = reinterpret_cast<byte*>(&ret);

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

That kind of type punning is undefined behavior in C++, so it will unfortunately
break one day. A memmove will work.

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

For big-endian implementation, we need to swap bytes within word. memmove
doesn't do this. We could implement the same using byte reading and shifting,
but this doesn't works for floats. At the end, we need to convert the void *
pointer to byte * pointer, I don't see any other way to do this so it works with
both integers and floats

+  for (size_t i = 0; i < sizeof(V); i++) {
+    dst[i] = src[sizeof(V) - i - 1];
+  }
+  return ret;
+#endif  // V8_TARGET_LITTLE_ENDIAN
+}
+
+template <typename V>
+static inline void WriteLittleEndianValue(void* p, V value) {
+#if defined(V8_TARGET_LITTLE_ENDIAN)
+  WriteUnalignedValue(p, value);
+#elif defined(V8_TARGET_BIG_ENDIAN)
+  byte* src = reinterpret_cast<byte*>(&value);
+  byte* dst = reinterpret_cast<byte*>(p);
+  for (size_t i = 0; i < sizeof(V); i++) {
+    dst[i] = src[sizeof(V) - i - 1];
+  }
+#endif  // V8_TARGET_LITTLE_ENDIAN
+}
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_UTILS_H_