[wasm] wasm-compiler: Remove unused parameter on MemSize method

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 <memory>
 
 #include "src/assembler-inl.h"
 #include "src/base/platform/elapsed-timer.h"
@@ skipping 3050 matching lines @@
       *control_};
   Node* call = graph()->NewNode(jsgraph()->common()->Call(desc),
                                 static_cast<int>(arraysize(inputs)), inputs);
 
   Node* result = BuildChangeSmiToInt32(call);
 
   *effect_ = call;
   return result;
 }
 
-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()->RelocatableInt32Constant(
-          size, RelocInfo::WASM_MEMORY_SIZE_REFERENCE);
-    return mem_size_;
-  } else {
-    return jsgraph()->RelocatableInt32Constant(
-        size + offset, RelocInfo::WASM_MEMORY_SIZE_REFERENCE);
-  }
+Node* WasmGraphBuilder::MemSize() {
+  DCHECK_NOT_NULL(module_);
+  if (mem_size_) return mem_size_;
+  uint32_t size = module_->instance ? module_->instance->mem_size : 0;
+  mem_size_ = jsgraph()->RelocatableInt32Constant(
+      size, RelocInfo::WASM_MEMORY_SIZE_REFERENCE);
+  return mem_size_;
 }
 
 void WasmGraphBuilder::EnsureFunctionTableNodes() {
   if (function_tables_.size() > 0) return;
   size_t tables_size = module_->instance->function_tables.size();
   DCHECK(tables_size == module_->instance->signature_tables.size());
   for (size_t i = 0; i < tables_size; ++i) {
     auto function_handle = module_->instance->function_tables[i];
     auto signature_handle = module_->instance->signature_tables[i];
     DCHECK(!function_handle.is_null() && !signature_handle.is_null());
@@ skipping 187 matching lines @@
 
   *effect_ = store;
 
   return store;
 }
 
 Node* WasmGraphBuilder::BuildAsmjsLoadMem(MachineType type, Node* index) {
   // TODO(turbofan): fold bounds checks for constant asm.js loads.
   // asm.js semantics use CheckedLoad (i.e. OOB reads return 0ish).
   const Operator* op = jsgraph()->machine()->CheckedLoad(type);
-  Node* load = graph()->NewNode(op, MemBuffer(0), index, MemSize(0), *effect_,
-                                *control_);
+  Node* load =
+      graph()->NewNode(op, MemBuffer(0), index, MemSize(), *effect_, *control_);
   *effect_ = load;
   return load;
 }
 
 Node* WasmGraphBuilder::BuildAsmjsStoreMem(MachineType type, Node* index,
                                            Node* val) {
   // TODO(turbofan): fold bounds checks for constant asm.js stores.
   // asm.js semantics use CheckedStore (i.e. ignore OOB writes).
   const Operator* op =
       jsgraph()->machine()->CheckedStore(type.representation());
-  Node* store = graph()->NewNode(op, MemBuffer(0), index, MemSize(0), val,
+  Node* store = graph()->NewNode(op, MemBuffer(0), index, MemSize(), val,
                                  *effect_, *control_);
   *effect_ = store;
   return val;
 }
 
 void WasmGraphBuilder::PrintDebugName(Node* node) {
   PrintF("#%d:%s", node->id(), node->op()->mnemonic());
 }
 
 Node* WasmGraphBuilder::String(const char* string) {
@@ skipping 822 matching lines @@
            function_->code_end_offset - function_->code_start_offset,
            codegen_ms);
   }
 
   return code;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8