[wasm] Validate the alignment of load and store instructions.

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/utils.h"
 #include "src/wasm/ast-decoder.h"
 #include "src/wasm/decoder.h"
 #include "src/wasm/wasm-external-refs.h"
@@ skipping 1426 matching lines @@
           } else {
             UNREACHABLE();
           }
           Push(pc, val);
           len = 1 + operand.length;
           break;
         }
 
 #define LOAD_CASE(name, ctype, mtype)                                       \
   case kExpr##name: {                                                       \
-    MemoryAccessOperand operand(&decoder, code->at(pc));                    \
+    MemoryAccessOperand operand(&decoder, code->at(pc), sizeof(ctype));     \
     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;            \
     WasmVal result(static_cast<ctype>(ReadLittleEndianValue<mtype>(addr))); \
     Push(pc, result);                                                       \
     len = 1 + operand.length;                                               \
@@ skipping 11 matching lines @@
           LOAD_CASE(I64LoadMem32S, int64_t, int32_t);
           LOAD_CASE(I64LoadMem32U, int64_t, uint32_t);
           LOAD_CASE(I32LoadMem, int32_t, int32_t);
           LOAD_CASE(I64LoadMem, int64_t, int64_t);
           LOAD_CASE(F32LoadMem, float, float);
           LOAD_CASE(F64LoadMem, double, double);
 #undef LOAD_CASE
 
 #define STORE_CASE(name, ctype, mtype)                                        \
   case kExpr##name: {                                                         \
-    MemoryAccessOperand operand(&decoder, code->at(pc));                      \
+    MemoryAccessOperand operand(&decoder, code->at(pc), sizeof(ctype));       \
     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;              \
     WriteLittleEndianValue<mtype>(addr, static_cast<mtype>(val.to<ctype>())); \
     Push(pc, val);                                                            \
@@ skipping 314 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