Add new relocation type WASM_MEMORY_SIZE_REFERENCE, use relocatable pointers to update wasm 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, size_t old_size,
-                                   size_t new_size) {
+                                   Address new_base, uint32_t old_size,
+                                   uint32_t new_size) {
   Isolate* isolate = CcTest::i_isolate();
   bool modified = false;
-  int mode_mask = (1 << RelocInfo::WASM_MEMORY_REFERENCE);
+  int mode_mask = RelocInfo::ModeMask(RelocInfo::WASM_MEMORY_REFERENCE) |
+                  RelocInfo::ModeMask(RelocInfo::WASM_MEMORY_SIZE_REFERENCE);
   for (RelocIterator it(*code, mode_mask); !it.done(); it.next()) {
     RelocInfo::Mode mode = it.rinfo()->rmode();
-    if (RelocInfo::IsWasmMemoryReference(mode)) {
+    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;
     }
   }
   if (modified) {
     Assembler::FlushICache(isolate, code->instruction_start(),
                            code->instruction_size());
   }
@@ skipping 97 matching lines @@
   RunLoadStoreRelocationOffset<int8_t>(MachineType::Int8());
   RunLoadStoreRelocationOffset<uint8_t>(MachineType::Uint8());
   RunLoadStoreRelocationOffset<int16_t>(MachineType::Int16());
   RunLoadStoreRelocationOffset<uint16_t>(MachineType::Uint16());
   RunLoadStoreRelocationOffset<int32_t>(MachineType::Int32());
   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* 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());
+}