wasm: change the module memory size to be multiples of the page size, 64k.

src/wasm/wasm-module.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/macro-assembler.h"
 #include "src/objects.h"
 #include "src/v8.h"
 
 #include "src/simulator.h"
 
 #include "src/wasm/ast-decoder.h"
 #include "src/wasm/module-decoder.h"
 #include "src/wasm/wasm-module.h"
 #include "src/wasm/wasm-result.h"
 
 #include "src/compiler/wasm-compiler.h"
 
 namespace v8 {
 namespace internal {
 namespace wasm {
 
 std::ostream& operator<<(std::ostream& os, const WasmModule& module) {
   os << "WASM module with ";
-  os << (1 << module.min_mem_size_log2) << " min mem";
-  os << (1 << module.max_mem_size_log2) << " max mem";
+  os << (module.min_mem_pages * module.kPageSize) << " min mem";
+  os << (module.max_mem_pages * module.kPageSize) << " max mem";
   os << module.functions.size() << " functions";
   os << module.functions.size() << " globals";
   os << module.functions.size() << " data segments";
   return os;
 }
 
 
 std::ostream& operator<<(std::ostream& os, const WasmFunction& function) {
   os << "WASM function with signature " << *function.sig;
 
@@ skipping 124 matching lines @@
     global.offset = offset;
     offset += size;
   }
   return offset;
 }
 
 
 void LoadDataSegments(WasmModule* module, byte* mem_addr, size_t mem_size) {
   for (const WasmDataSegment& segment : module->data_segments) {
     if (!segment.init) continue;
+    if (!segment.source_size) continue;
     CHECK_LT(segment.dest_addr, mem_size);
     CHECK_LE(segment.source_size, mem_size);
     CHECK_LE(segment.dest_addr + segment.source_size, mem_size);
     byte* addr = mem_addr + segment.dest_addr;
     memcpy(addr, module->module_start + segment.source_offset,
            segment.source_size);
   }
 }
 
 
 Handle<FixedArray> BuildFunctionTable(Isolate* isolate, WasmModule* module) {
   if (module->function_table.size() == 0) {
     return Handle<FixedArray>::null();
   }
   int table_size = static_cast<int>(module->function_table.size());
   Handle<FixedArray> fixed = isolate->factory()->NewFixedArray(2 * table_size);
   for (int i = 0; i < table_size; i++) {
     WasmFunction* function = &module->functions[module->function_table[i]];
     fixed->set(i, Smi::FromInt(function->sig_index));
   }
   return fixed;
 }
 
 Handle<JSArrayBuffer> NewArrayBuffer(Isolate* isolate, size_t size,
                                      byte** backing_store) {
-  if (size > (1 << WasmModule::kMaxMemSize)) {
+  if (size > (WasmModule::kMaxMemPages * WasmModule::kPageSize)) {
     // TODO(titzer): lift restriction on maximum memory allocated here.
     *backing_store = nullptr;
     return Handle<JSArrayBuffer>::null();
   }
   void* memory =
       isolate->array_buffer_allocator()->Allocate(static_cast<int>(size));
   if (!memory) {
     *backing_store = nullptr;
     return Handle<JSArrayBuffer>::null();
   }
@@ skipping 21 matching lines @@
   instance->mem_size = memory->byte_length()->Number();
   instance->mem_buffer = memory;
 }
 
 // Allocate memory for a module instance as a new JSArrayBuffer.
 bool AllocateMemory(ErrorThrower* thrower, Isolate* isolate,
                     WasmModuleInstance* instance) {
   DCHECK(instance->module);
   DCHECK(instance->mem_buffer.is_null());
 
-  if (instance->module->min_mem_size_log2 > WasmModule::kMaxMemSize) {
+  if (instance->module->min_mem_pages > WasmModule::kMaxMemPages) {
     thrower->Error("Out of memory: wasm memory too large");
     return false;
   }
-  instance->mem_size = static_cast<size_t>(1)
-                       << instance->module->min_mem_size_log2;
+  instance->mem_size = WasmModule::kPageSize * instance->module->min_mem_pages;
   instance->mem_buffer =
       NewArrayBuffer(isolate, instance->mem_size, &instance->mem_start);
   if (!instance->mem_start) {
     thrower->Error("Out of memory: wasm memory");
     instance->mem_size = 0;
     return false;
   }
   return true;
 }
 
@@ skipping 11 matching lines @@
     }
   }
   return true;
 }
 }  // namespace
 
 WasmModule::WasmModule()
     : shared_isolate(nullptr),
       module_start(nullptr),
       module_end(nullptr),
-      min_mem_size_log2(0),
-      max_mem_size_log2(0),
+      min_mem_pages(0),
+      max_mem_pages(0),
       mem_export(false),
       mem_external(false),
       start_function_index(-1),
       origin(kWasmOrigin) {}
 
 static MaybeHandle<JSFunction> LookupFunction(ErrorThrower& thrower,
                                               Handle<JSObject> ffi,
                                               uint32_t index,
                                               Handle<String> name,
                                               const char* cstr) {
@@ skipping 320 matching lines @@
   }
   if (result->IsHeapNumber()) {
     return static_cast<int32_t>(HeapNumber::cast(*result)->value());
   }
   thrower.Error("WASM.compileRun() failed: Return value should be number");
   return -1;
 }
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8