Fix failure in RunWasmInterpreted_LoadMemI32_const_oob_misaligned on architecures that don't suppor…

src/wasm/wasm-interpreter.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/wasm/wasm-interpreter.h"
 #include "src/wasm/ast-decoder.h"
 #include "src/wasm/decoder.h"
 #include "src/wasm/wasm-external-refs.h"
 #include "src/wasm/wasm-module.h"
 
@@ skipping 1429 matching lines @@
 #define LOAD_CASE(name, ctype, mtype)                                    \
   case kExpr##name: {                                                    \
     MemoryAccessOperand operand(&decoder, code->at(pc));                 \
     uint32_t index = Pop().to<uint32_t>();                               \
     size_t effective_mem_size = instance()->mem_size - sizeof(mtype);    \
     if (operand.offset > effective_mem_size ||                           \
         index > (effective_mem_size - operand.offset)) {                 \
       return DoTrap(kTrapMemOutOfBounds, pc);                            \
     }                                                                    \
     byte* addr = instance()->mem_start + operand.offset + index;         \
-    /* TODO(titzer): alignment, endianness for load mem */               \
-    WasmVal result(static_cast<ctype>(*reinterpret_cast<mtype*>(addr))); \
+    WasmVal result(static_cast<ctype>(ReadUnalignedValue<mtype>(addr))); \
     Push(pc, result);                                                    \
     len = 1 + operand.length;                                            \
     break;                                                               \
   }
 
           LOAD_CASE(I32LoadMem8S, int32_t, int8_t);
           LOAD_CASE(I32LoadMem8U, int32_t, uint8_t);
           LOAD_CASE(I32LoadMem16S, int32_t, int16_t);
           LOAD_CASE(I32LoadMem16U, int32_t, uint16_t);
           LOAD_CASE(I64LoadMem8S, int64_t, int8_t);
@@ skipping 12 matching lines @@
   case kExpr##name: {                                                      \
     MemoryAccessOperand operand(&decoder, code->at(pc));                   \
     WasmVal val = Pop();                                                   \
     uint32_t index = Pop().to<uint32_t>();                                 \
     size_t effective_mem_size = instance()->mem_size - sizeof(mtype);      \
     if (operand.offset > effective_mem_size ||                             \
         index > (effective_mem_size - operand.offset)) {                   \
       return DoTrap(kTrapMemOutOfBounds, pc);                              \
     }                                                                      \
     byte* addr = instance()->mem_start + operand.offset + index;           \
-    /* TODO(titzer): alignment, endianness for store mem */                \
-    *reinterpret_cast<mtype*>(addr) = static_cast<mtype>(val.to<ctype>()); \
+    WriteUnalignedValue<mtype>(addr, static_cast<mtype>(val.to<ctype>())); \
     Push(pc, val);                                                         \
     len = 1 + operand.length;                                              \
     break;                                                                 \
   }
 
           STORE_CASE(I32StoreMem8, int32_t, int8_t);
           STORE_CASE(I32StoreMem16, int32_t, int16_t);
           STORE_CASE(I64StoreMem8, int64_t, int8_t);
           STORE_CASE(I64StoreMem16, int64_t, int16_t);
           STORE_CASE(I64StoreMem32, int64_t, int32_t);
@@ skipping 299 matching lines @@
 
 ControlTransferMap WasmInterpreter::ComputeControlTransfersForTesting(
     Zone* zone, const byte* start, const byte* end) {
   ControlTransfers targets(zone, 0, start, end);
   return targets.map_;
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8