[wasm] Prerequisites for WebAssembly Table.Grow

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"
@@ skipping 22 matching lines @@
                                                new_size);
       modified = true;
     }
   }
   if (modified) {
     Assembler::FlushICache(isolate, code->instruction_start(),
                            code->instruction_size());
   }
 }
 
+static void UpdateFunctionTableSizeReferences(Handle<Code> code,
+                                              uint32_t old_size,
+                                              uint32_t new_size) {
+  Isolate* isolate = CcTest::i_isolate();
+  bool modified = false;
+  int mode_mask =
+      RelocInfo::ModeMask(RelocInfo::WASM_FUNCTION_TABLE_SIZE_REFERENCE);
+  for (RelocIterator it(*code, mode_mask); !it.done(); it.next()) {
+    RelocInfo::Mode mode = it.rinfo()->rmode();
+    if (RelocInfo::IsWasmFunctionTableSizeReference(mode)) {
+      it.rinfo()->update_wasm_function_table_size_reference(old_size, new_size);
+      modified = true;
+    }
+  }
+  if (modified) {
+    Assembler::FlushICache(isolate, code->instruction_start(),
+                           code->instruction_size());
+  }
+}
+
 template <typename CType>
 static void RunLoadStoreRelocation(MachineType rep) {
   const int kNumElems = 2;
   CType buffer[kNumElems];
   CType new_buffer[kNumElems];
   byte* raw = reinterpret_cast<byte*>(buffer);
   byte* new_raw = reinterpret_cast<byte*>(new_buffer);
   for (size_t i = 0; i < sizeof(buffer); i++) {
     raw[i] = static_cast<byte>((i + sizeof(CType)) ^ 0xAA);
     new_raw[i] = static_cast<byte>((i + sizeof(CType)) ^ 0xAA);
@@ skipping 86 matching lines @@
   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) {
+TEST(Uint32LessThanMemoryRelocation) {
   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(0xacedu, m.Call());
 }
+
+TEST(Uint32LessThanFunctionTableRelocation) {
+  RawMachineAssemblerTester<uint32_t> m;
+  RawMachineLabel within_bounds, out_of_bounds;
+  Node* index = m.Int32Constant(0x200);
+  Node* limit = m.RelocatableInt32Constant(
+      0x200, RelocInfo::WASM_FUNCTION_TABLE_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();
+  UpdateFunctionTableSizeReferences(code, 0x200, 0x400);
+  // Check that after limit is increased, index is within bounds.
+  CHECK_EQ(0xaced, m.Call());
+}