[wasm] Fix MSAN failures for some WASM tests.

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 53 matching lines @@
 class TestingModule : public ModuleEnv {
  public:
   TestingModule() : mem_size(0), global_offset(0) {
     globals_area = 0;
     mem_start = 0;
     mem_end = 0;
     module = nullptr;
     linker = nullptr;
     function_code = nullptr;
     asm_js = false;
+    memset(global_data, 0, sizeof(global_data));
   }
 
   ~TestingModule() {
     if (mem_start) {
       free(raw_mem_start<byte>());
     }
     if (function_code) delete function_code;
     if (module) delete module;
   }
 
@@ skipping 2034 matching lines @@
   BUILD(r, kExprBlock, 2, kExprLoop, 1, kExprIf, kExprGetLocal, 0, kExprBr, 0,
         kExprIfElse, kExprI32LoadMem, 0, kExprGetLocal, 0, kExprBr, 2,
         kExprI8Const, 255, kExprSetLocal, 0, kExprI32Sub, kExprGetLocal, 0,
         kExprI8Const, 4, kExprI8Const, 0);
 
   module.BlankMemory();
   CHECK_EQ(0, r.Call((kNumElems - 1) * 4));
 }
 
 
-// TODO(titzer): Fix for msan and re-enable.
-#if 0
-
 TEST(Run_Wasm_MemF32_Sum) {
   WasmRunner<int32_t> r(MachineType::Int32());
   const byte kSum = r.AllocateLocal(kAstF32);
-  ModuleEnv module;
   const int kSize = 5;
-  float buffer[kSize] = {-99.25, -888.25, -77.25, 66666.25, 5555.25};
-  module.mem_start = reinterpret_cast<uintptr_t>(&buffer);
-  module.mem_end = reinterpret_cast<uintptr_t>(&buffer[kSize]);
+  TestingModule module;
+  module.AddMemoryElems<float>(kSize);
+  float* buffer = module.raw_mem_start<float>();
+  buffer[0] = -99.25;
+  buffer[1] = -888.25;
+  buffer[2] = -77.25;
+  buffer[3] = 66666.25;
+  buffer[4] = 5555.25;
   r.env()->module = &module;
 
   BUILD(r, WASM_BLOCK(
                3, WASM_WHILE(
                       WASM_GET_LOCAL(0),
                       WASM_BLOCK(
                           2, WASM_SET_LOCAL(
                                  kSum, WASM_F32_ADD(
                                            WASM_GET_LOCAL(kSum),
                                            WASM_LOAD_MEM(MachineType::Float32(),
                                                          WASM_GET_LOCAL(0)))),
                           WASM_SET_LOCAL(
                               0, WASM_I32_SUB(WASM_GET_LOCAL(0), WASM_I8(4))))),
                WASM_STORE_MEM(MachineType::Float32(), WASM_ZERO,
                               WASM_GET_LOCAL(kSum)),
                WASM_GET_LOCAL(0)));
 
   CHECK_EQ(0, r.Call(4 * (kSize - 1)));
   CHECK_NE(-99.25, buffer[0]);
   CHECK_EQ(71256.0f, buffer[0]);
 }
 
-#endif
-
 
 #if WASM_64
 TEST(Run_Wasm_MemI64_Sum) {
   WasmRunner<uint64_t> r(MachineType::Int32());
   const int kNumElems = 20;
   const byte kSum = r.AllocateLocal(kAstI64);
   TestingModule module;
   uint64_t* memory = module.AddMemoryElems<uint64_t>(kNumElems);
   r.env()->module = &module;
 
@@ skipping 17 matching lines @@
     for (size_t j = kNumElems - 1; j > 0; j--) {
       expected += memory[j];
     }
     uint64_t result = r.Call(8 * (kNumElems - 1));
     CHECK_EQ(expected, result);
   }
 }
 #endif
 
 
-// TODO(titzer): Fix for msan and re-enable.
-#if 0
-
 template <typename T>
-void GenerateAndRunFold(WasmOpcode binop, T* buffer, size_t size,
-                        LocalType astType, MachineType memType) {
+T GenerateAndRunFold(WasmOpcode binop, T* buffer, size_t size,
+                     LocalType astType, MachineType memType) {
   WasmRunner<int32_t> r(MachineType::Int32());
   const byte kAccum = r.AllocateLocal(astType);
-  ModuleEnv module;
-  module.mem_start = reinterpret_cast<uintptr_t>(buffer);
-  module.mem_end = reinterpret_cast<uintptr_t>(buffer + size);
+  TestingModule module;
+  module.AddMemoryElems<T>(size);
+  for (size_t i = 0; i < size; i++) {
+    module.raw_mem_start<T>()[i] = buffer[i];
+  }
   r.env()->module = &module;
 
   BUILD(
       r,
       WASM_BLOCK(
           4, WASM_SET_LOCAL(kAccum, WASM_LOAD_MEM(memType, WASM_ZERO)),
           WASM_WHILE(
               WASM_GET_LOCAL(0),
               WASM_BLOCK(
                   2, WASM_SET_LOCAL(
                          kAccum,
                          WASM_BINOP(binop, WASM_GET_LOCAL(kAccum),
                                     WASM_LOAD_MEM(memType, WASM_GET_LOCAL(0)))),
                   WASM_SET_LOCAL(
                       0, WASM_I32_SUB(WASM_GET_LOCAL(0), WASM_I8(sizeof(T)))))),
           WASM_STORE_MEM(memType, WASM_ZERO, WASM_GET_LOCAL(kAccum)),
           WASM_GET_LOCAL(0)));
   r.Call(static_cast<int>(sizeof(T) * (size - 1)));
+  return module.raw_mem_at<double>(0);
 }
 
 
 TEST(Run_Wasm_MemF64_Mul) {
   const size_t kSize = 6;
   double buffer[kSize] = {1, 2, 2, 2, 2, 2};
-  GenerateAndRunFold<double>(kExprF64Mul, buffer, kSize, kAstF64,
-                             MachineType::Float64());
-  CHECK_EQ(32, buffer[0]);
+  double result = GenerateAndRunFold<double>(kExprF64Mul, buffer, kSize,
+                                             kAstF64, MachineType::Float64());
+  CHECK_EQ(32, result);
 }
 
-#endif
-
 
 TEST(Build_Wasm_Infinite_Loop) {
   WasmRunner<int32_t> r(MachineType::Int32());
   // Only build the graph and compile, don't run.
   BUILD(r, WASM_INFINITE_LOOP);
 }
 
 
 TEST(Build_Wasm_Infinite_Loop_effect) {
   WasmRunner<int32_t> r(MachineType::Int32());
@@ skipping 207 matching lines @@
 
   *global = 116;
   for (int i = 9; i < 444444; i += 111111) {
     int32_t expected = *global + i;
     r.Call(i);
     CHECK_EQ(expected, *global);
   }
 }
 
 
-// TODO(titzer): Fix for msan and re-enable.
-#if 0
-
 TEST(Run_WasmInt32Globals_DontAlias) {
   const int kNumGlobals = 3;
   TestingModule module;
   int32_t* globals[] = {module.AddGlobal<int32_t>(MachineType::Int32()),
                         module.AddGlobal<int32_t>(MachineType::Int32()),
                         module.AddGlobal<int32_t>(MachineType::Int32())};
 
   for (int g = 0; g < kNumGlobals; g++) {
     // global = global + p0
     WasmRunner<int32_t> r(MachineType::Int32());
     r.env()->module = &module;
     BUILD(r, WASM_STORE_GLOBAL(
                  g, WASM_I32_ADD(WASM_LOAD_GLOBAL(g), WASM_GET_LOCAL(0))));
 
     // Check that reading/writing global number {g} doesn't alter the others.
     *globals[g] = 116 * g;
     int32_t before[kNumGlobals];
     for (int i = 9; i < 444444; i += 111113) {
       int32_t sum = *globals[g] + i;
       for (int j = 0; j < kNumGlobals; j++) before[j] = *globals[j];
       r.Call(i);
       for (int j = 0; j < kNumGlobals; j++) {
         int32_t expected = j == g ? sum : before[j];
         CHECK_EQ(expected, *globals[j]);
       }
     }
   }
 }
 
-#endif
-
 
 #if WASM_64
 TEST(Run_WasmInt64Global) {
   TestingModule module;
   int64_t* global = module.AddGlobal<int64_t>(MachineType::Int64());
   WasmRunner<int32_t> r(MachineType::Int32());
   r.env()->module = &module;
   // global = global + p0
   BUILD(r, WASM_BLOCK(2, WASM_STORE_GLOBAL(
                              0, WASM_I64_ADD(
@@ skipping 1103 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