Add new relocation type WASM_MEMORY_SIZE_REFERENCE, use relocatable pointers to update wasm memory …

src/compiler/wasm-compiler.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 "src/compiler/wasm-compiler.h"
 
 #include "src/isolate-inl.h"
 
 #include "src/base/platform/elapsed-timer.h"
 #include "src/base/platform/platform.h"
@@ skipping 2494 matching lines @@
         reinterpret_cast<uintptr_t>(module_->instance->mem_start + offset),
         RelocInfo::WASM_MEMORY_REFERENCE);
   }
 }
 
 
 Node* WasmGraphBuilder::MemSize(uint32_t offset) {
   DCHECK(module_ && module_->instance);
   uint32_t size = static_cast<uint32_t>(module_->instance->mem_size);
   if (offset == 0) {
-    if (!mem_size_) mem_size_ = jsgraph()->Int32Constant(size);
+    if (!mem_size_)
+      mem_size_ = jsgraph()->RelocatableInt32Constant(
+          size, RelocInfo::WASM_MEMORY_SIZE_REFERENCE);
     return mem_size_;
   } else {
-    return jsgraph()->Int32Constant(size + offset);
+    return jsgraph()->RelocatableInt32Constant(
+        size + offset, RelocInfo::WASM_MEMORY_SIZE_REFERENCE);
   }
 }
 
 
 Node* WasmGraphBuilder::FunctionTable() {
   DCHECK(module_ && module_->instance &&
          !module_->instance->function_table.is_null());
   if (!function_table_) {
     function_table_ = jsgraph()->Constant(module_->instance->function_table);
   }
@@ skipping 37 matching lines @@
   size_t size = module_->instance->mem_size;
   byte memsize = wasm::WasmOpcodes::MemSize(memtype);
   Node* cond;
   if (offset >= size || (static_cast<uint64_t>(offset) + memsize) > size) {
     // The access will always throw.
     cond = jsgraph()->Int32Constant(0);
   } else {
     // Check against the limit.
     size_t limit = size - offset - memsize;
     CHECK(limit <= kMaxUInt32);
-    cond = graph()->NewNode(
-        jsgraph()->machine()->Uint32LessThanOrEqual(), index,
-        jsgraph()->Int32Constant(static_cast<uint32_t>(limit)));
+    cond = graph()->NewNode(jsgraph()->machine()->Uint32LessThanOrEqual(),
+                            index, jsgraph()->RelocatableInt32Constant(
+                                       static_cast<uint32_t>(limit),
+                                       RelocInfo::WASM_MEMORY_SIZE_REFERENCE));
   }
 
   trap_->AddTrapIfFalse(wasm::kTrapMemOutOfBounds, cond);
 }
 
 
 Node* WasmGraphBuilder::LoadMem(wasm::LocalType type, MachineType memtype,
                                 Node* index, uint32_t offset) {
   Node* load;
 
@@ skipping 375 matching lines @@
   // TODO(bradnelson): Improve histogram handling of size_t.
   isolate->counters()->wasm_compile_function_peak_memory_bytes()->AddSample(
       static_cast<int>(zone.allocation_size()));
   return code;
 }
 
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8