[wasm] OOB test should pass on all architectures.

test/cctest/wasm/test-run-wasm.cc

 // Copyright 2015 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 <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "src/base/utils/random-number-generator.h"
 
@@ skipping 1893 matching lines @@
     memory[3] = 99999999;
     CHECK_EQ(kWritten, r.Call(i * 4));
     CHECK_EQ(66666666, memory[0]);
     CHECK_EQ(i == 0 ? kWritten : 77777777, memory[1]);
     CHECK_EQ(i == 1 ? kWritten : 88888888, memory[2]);
     CHECK_EQ(i == 2 ? kWritten : 99999999, memory[3]);
   }
 }
 
 
-#if WASM_64
-// TODO(titzer): Figure out why this fails on 32-bit architectures.
 TEST(Run_Wasm_StoreMem_offset_oob) {
   TestingModule module;
   byte* memory = module.AddMemoryElems<byte>(32);
 
 #if WASM_64
   static const MachineType machineTypes[] = {
       MachineType::Int8(),   MachineType::Uint8(),  MachineType::Int16(),
       MachineType::Uint16(), MachineType::Int32(),  MachineType::Uint32(),
       MachineType::Int64(),  MachineType::Uint64(), MachineType::Float32(),
       MachineType::Float64()};
@@ skipping 16 matching lines @@
     byte memsize = WasmOpcodes::MemSize(machineTypes[m]);
     uint32_t boundary = 24 - memsize;
     CHECK_EQ(0, r.Call(boundary));  // in bounds.
     CHECK_EQ(0, memcmp(&memory[0], &memory[8 + boundary], memsize));
 
     for (uint32_t offset = boundary + 1; offset < boundary + 19; offset++) {
       CHECK_TRAP(r.Call(offset));  // out of bounds.
     }
   }
 }
-#endif
 
 
 #if WASM_64
 TEST(Run_Wasm_F64ReinterpretI64) {
   WasmRunner<int64_t> r;
   TestingModule module;
   int64_t* memory = module.AddMemoryElems<int64_t>(8);
   r.env()->module = &module;
 
   BUILD(r, WASM_I64_REINTERPRET_F64(
@@ skipping 1604 matching lines @@
 TEST(Run_Wasm_F32CopySign) {
   WasmRunner<float> r(MachineType::Float32(), MachineType::Float32());
   BUILD(r, WASM_F32_COPYSIGN(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
 
   FOR_FLOAT32_INPUTS(i) {
     FOR_FLOAT32_INPUTS(j) { CheckFloatEq(copysign(*i, *j), r.Call(*i, *j)); }
   }
 }
 
 #endif