[wasm] Fix bounds check for zero initial memory.

test/cctest/compiler/test-run-wasm-machops.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 <cmath>
 #include <functional>
 #include <limits>
 
 #include "src/base/bits.h"
 #include "src/base/utils/random-number-generator.h"
 #include "src/codegen.h"
 #include "test/cctest/cctest.h"
 #include "test/cctest/compiler/codegen-tester.h"
 #include "test/cctest/compiler/graph-builder-tester.h"
 #include "test/cctest/compiler/value-helper.h"
 
 using namespace v8::internal;
 using namespace v8::internal::compiler;
 
 static void UpdateMemoryReferences(Handle<Code> code, Address old_base,
                                    Address new_base, uint32_t old_size,
                                    uint32_t new_size) {
   Isolate* isolate = CcTest::i_isolate();
   bool modified = false;
-  int mode_mask = RelocInfo::ModeMask(RelocInfo::WASM_MEMORY_REFERENCE) |
-                  RelocInfo::ModeMask(RelocInfo::WASM_MEMORY_SIZE_REFERENCE);
+  int mode_mask =
+      RelocInfo::ModeMask(RelocInfo::WASM_MEMORY_REFERENCE) |
+      RelocInfo::ModeMask(RelocInfo::WASM_MEMORY_DWORD_SIZE_REFERENCE);

[bradn, 2016/10/12 18:50:45]

Test all the sizes.

[gdeepti, 2016/10/13 08:43:00]

Got rid of additional RelocInfo modes, code removed in latest patch. 

   for (RelocIterator it(*code, mode_mask); !it.done(); it.next()) {
     RelocInfo::Mode mode = it.rinfo()->rmode();
     if (RelocInfo::IsWasmMemoryReference(mode) ||
         RelocInfo::IsWasmMemorySizeReference(mode)) {
       // Patch addresses with change in memory start address
       it.rinfo()->update_wasm_memory_reference(old_base, new_base, old_size,
                                                new_size);
       modified = true;
     }
   }
@@ skipping 106 matching lines @@
   RunLoadStoreRelocationOffset<uint32_t>(MachineType::Uint32());
   RunLoadStoreRelocationOffset<void*>(MachineType::AnyTagged());
   RunLoadStoreRelocationOffset<float>(MachineType::Float32());
   RunLoadStoreRelocationOffset<double>(MachineType::Float64());
 }
 
 TEST(Uint32LessThanRelocation) {
   RawMachineAssemblerTester<uint32_t> m;
   RawMachineLabel within_bounds, out_of_bounds;
   Node* index = m.Int32Constant(0x200);
-  Node* limit =
-      m.RelocatableInt32Constant(0x200, RelocInfo::WASM_MEMORY_SIZE_REFERENCE);
+  Node* limit = m.RelocatableInt32Constant(
+      0x200, RelocInfo::WASM_MEMORY_DWORD_SIZE_REFERENCE);
   Node* cond = m.AddNode(m.machine()->Uint32LessThan(), index, limit);
   m.Branch(cond, &within_bounds, &out_of_bounds);
   m.Bind(&within_bounds);
   m.Return(m.Int32Constant(0xaced));
   m.Bind(&out_of_bounds);
   m.Return(m.Int32Constant(0xdeadbeef));
   // Check that index is out of bounds with current size
   CHECK_EQ(0xdeadbeef, m.Call());
   m.GenerateCode();
 
   Handle<Code> code = m.GetCode();
   UpdateMemoryReferences(code, reinterpret_cast<Address>(1234),
                          reinterpret_cast<Address>(1234), 0x200, 0x400);
   // Check that after limit is increased, index is within bounds.
   CHECK_EQ(0xaced, m.Call());
 }