[wasm] globals size is not a per-instance property.

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/base/atomic-utils.h"
 #include "src/macro-assembler.h"
 #include "src/objects.h"
 #include "src/property-descriptor.h"
 #include "src/v8.h"
 
@@ skipping 124 matching lines @@
     }
     return function_code_[index];
   }
 
   void Finish(uint32_t index, Handle<Code> code) {
     DCHECK(index < function_code_.size());
     function_code_[index] = code;
   }
 
   void Link(Handle<FixedArray> function_table,
-            std::vector<uint16_t>& functions) {
+            const std::vector<uint16_t>& functions) {
     for (size_t i = 0; i < function_code_.size(); i++) {
       LinkFunction(function_code_[i]);
     }
     if (!function_table.is_null()) {
       int table_size = static_cast<int>(functions.size());
       DCHECK_EQ(function_table->length(), table_size * 2);
       for (int i = 0; i < table_size; i++) {
         function_table->set(i + table_size, *function_code_[functions[i]]);
       }
     }
@@ skipping 40 matching lines @@
 
 namespace {
 // Internal constants for the layout of the module object.
 const int kWasmModuleInternalFieldCount = 5;
 const int kWasmModuleFunctionTable = 0;
 const int kWasmModuleCodeTable = 1;
 const int kWasmMemArrayBuffer = 2;
 const int kWasmGlobalsArrayBuffer = 3;
 const int kWasmFunctionNamesArray = 4;
 
-size_t AllocateGlobalsOffsets(std::vector<WasmGlobal>& globals) {
-  uint32_t offset = 0;
-  if (globals.size() == 0) return 0;
-  for (WasmGlobal& global : globals) {
-    byte size = WasmOpcodes::MemSize(global.type);
-    offset = (offset + size - 1) & ~(size - 1);  // align
-    global.offset = offset;
-    offset += size;
-  }
-  return offset;
-}
-
-void LoadDataSegments(WasmModule* module, byte* mem_addr, size_t mem_size) {
+void LoadDataSegments(const 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) {
+Handle<FixedArray> BuildFunctionTable(Isolate* isolate,
+                                      const 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]];
+    const 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 > (WasmModule::kMaxMemPages * WasmModule::kPageSize)) {
     // TODO(titzer): lift restriction on maximum memory allocated here.
     *backing_store = nullptr;
@@ skipping 46 matching lines @@
   if (!instance->mem_start) {
     thrower->Error("Out of memory: wasm memory");
     instance->mem_size = 0;
     return false;
   }
   return true;
 }
 
 bool AllocateGlobals(ErrorThrower* thrower, Isolate* isolate,
                      WasmModuleInstance* instance) {
-  instance->globals_size = AllocateGlobalsOffsets(instance->module->globals);
-
-  if (instance->globals_size > 0) {
-    instance->globals_buffer = NewArrayBuffer(isolate, instance->globals_size,
-                                              &instance->globals_start);
+  uint32_t globals_size = instance->module->globals_size;
+  if (globals_size > 0) {
+    instance->globals_buffer =
+        NewArrayBuffer(isolate, globals_size, &instance->globals_start);
     if (!instance->globals_start) {
       // Not enough space for backing store of globals.
       thrower->Error("Out of memory: wasm globals");
       return false;
     }
   }
   return true;
 }
 }  // namespace
 
@@ skipping 130 matching lines @@
   base::Mutex* result_mutex_;
   base::AtomicNumber<size_t>* next_unit_;
 };
 
 void record_code_size(uint32_t& total_code_size, Code* code) {
   if (FLAG_print_wasm_code_size) {
     total_code_size += code->body_size() + code->relocation_info()->length();
   }
 }
 
-bool CompileWrappersToImportedFunctions(Isolate* isolate, WasmModule* module,
-                                        const Handle<JSReceiver> ffi,
-                                        WasmModuleInstance* instance,
-                                        ErrorThrower* thrower, Factory* factory,
-                                        ModuleEnv* module_env,
-                                        uint32_t& total_code_size) {
+bool CompileWrappersToImportedFunctions(
+    Isolate* isolate, const WasmModule* module, const Handle<JSReceiver> ffi,
+    WasmModuleInstance* instance, ErrorThrower* thrower, Factory* factory,
+    ModuleEnv* module_env, uint32_t& total_code_size) {
   uint32_t index = 0;
   if (module->import_table.size() > 0) {
     instance->import_code.reserve(module->import_table.size());
     for (const WasmImport& import : module->import_table) {
       WasmName module_name = module->GetNameOrNull(import.module_name_offset,
                                                    import.module_name_length);
       WasmName function_name = module->GetNameOrNull(
           import.function_name_offset, import.function_name_length);
       MaybeHandle<JSFunction> function = LookupFunction(
           *thrower, factory, ffi, index, module_name, function_name);
       if (function.is_null()) return false;
 
       Handle<Code> code = compiler::CompileWasmToJSWrapper(
           isolate, module_env, function.ToHandleChecked(), import.sig,
           module_name, function_name);
       instance->import_code.push_back(code);
       record_code_size(total_code_size, *code);
       index++;
     }
   }
   return true;
 }
 
 void InitializeParallelCompilation(
-    Isolate* isolate, std::vector<WasmFunction>& functions,
+    Isolate* isolate, const std::vector<WasmFunction>& functions,
     std::vector<compiler::WasmCompilationUnit*>& compilation_units,
     ModuleEnv& module_env, ErrorThrower& thrower) {
   // Create a placeholder code object for all functions.
   // TODO(ahaas): Maybe we could skip this for external functions.
   for (uint32_t i = 0; i < functions.size(); i++) {
     module_env.linker->GetFunctionCode(i);
   }
 
   for (uint32_t i = FLAG_skip_compiling_wasm_funcs; i < functions.size(); i++) {
     compilation_units[i] = new compiler::WasmCompilationUnit(
@@ skipping 31 matching lines @@
   for (size_t i = 0; i < num_tasks; i++) {
     // If the task has not started yet, then we abort it. Otherwise we wait for
     // it to finish.
     if (!isolate->cancelable_task_manager()->TryAbort(task_ids[i])) {
       pending_tasks->Wait();
     }
   }
 }
 
 void FinishCompilationUnits(
-    WasmModule* module,
     std::queue<compiler::WasmCompilationUnit*>& executed_units,
     std::vector<Handle<Code>>& results, base::Mutex& result_mutex) {
   while (true) {
     compiler::WasmCompilationUnit* unit = nullptr;
     {
       base::LockGuard<base::Mutex> guard(&result_mutex);
       if (executed_units.empty()) {
         break;
       }
       unit = executed_units.front();
       executed_units.pop();
     }
     int j = unit->index();
     results[j] = unit->FinishCompilation();
     delete unit;
   }
 }
 
-bool FinishCompilation(Isolate* isolate, WasmModule* module,
+bool FinishCompilation(Isolate* isolate, const WasmModule* module,
                        const Handle<JSReceiver> ffi,
                        const std::vector<Handle<Code>>& results,
                        const WasmModuleInstance& instance,
                        const Handle<FixedArray>& code_table,
                        ErrorThrower& thrower, Factory* factory,
                        ModuleEnv& module_env, uint32_t& total_code_size,
                        PropertyDescriptor& desc) {
   for (uint32_t i = FLAG_skip_compiling_wasm_funcs;
        i < module->functions.size(); i++) {
     const WasmFunction& func = module->functions[i];
@@ skipping 41 matching lines @@
   }
   return true;
 }
 }  // namespace
 
 // Instantiates a wasm module as a JSObject.
 //  * allocates a backing store of {mem_size} bytes.
 //  * installs a named property "memory" for that buffer if exported
 //  * installs named properties on the object for exported functions
 //  * compiles wasm code to machine code
-MaybeHandle<JSObject> WasmModule::Instantiate(Isolate* isolate,
-                                              Handle<JSReceiver> ffi,
-                                              Handle<JSArrayBuffer> memory) {
+MaybeHandle<JSObject> WasmModule::Instantiate(
+    Isolate* isolate, Handle<JSReceiver> ffi,
+    Handle<JSArrayBuffer> memory) const {
   HistogramTimerScope wasm_instantiate_module_time_scope(
       isolate->counters()->wasm_instantiate_module_time());
   ErrorThrower thrower(isolate, "WasmModule::Instantiate()");
   Factory* factory = isolate->factory();
 
   PropertyDescriptor desc;
   desc.set_writable(false);
 
   // If FLAG_print_wasm_code_size is set, this aggregates the sum of all code
   // objects created for this module.
@@ skipping 116 matching lines @@
       //      unit at a time and execute the parallel phase of the compilation
       //      unit. After finishing the execution of the parallel phase, the
       //      result is enqueued in {executed_units}.
       while (FetchAndExecuteCompilationUnit(isolate, &compilation_units,
                                             &executed_units, &result_mutex,
                                             &next_unit)) {
         // 3.b) If {executed_units} contains a compilation unit, the main thread
         //      dequeues it and finishes the compilation unit. Compilation units
         //      are finished concurrently to the background threads to save
         //      memory.
-        FinishCompilationUnits(this, executed_units, results, result_mutex);
+        FinishCompilationUnits(executed_units, results, result_mutex);
       }
       // 4) After the parallel phase of all compilation units has started, the
       //    main thread waits for all {WasmCompilationTask} instances to finish.
       WaitForCompilationTasks(isolate, task_ids.get(), pending_tasks);
       // Finish the compilation of the remaining compilation units.
-      FinishCompilationUnits(this, executed_units, results, result_mutex);
+      FinishCompilationUnits(executed_units, results, result_mutex);
     }
     // 5) The main thread finishes the compilation.
     if (!FinishCompilation(isolate, this, ffi, results, instance, code_table,
                            thrower, factory, module_env, total_code_size,
                            desc)) {
       instance.js_object = Handle<JSObject>::null();
     }
 
     // Patch all direct call sites.
     linker.Link(instance.function_table, this->function_table);
@@ skipping 81 matching lines @@
 Handle<Code> ModuleEnv::GetImportCode(uint32_t index) {
   DCHECK(IsValidImport(index));
   return instance ? instance->import_code[index] : Handle<Code>::null();
 }
 
 compiler::CallDescriptor* ModuleEnv::GetCallDescriptor(Zone* zone,
                                                        uint32_t index) {
   DCHECK(IsValidFunction(index));
   // Always make a direct call to whatever is in the table at that location.
   // A wrapper will be generated for FFI calls.
-  WasmFunction* function = &module->functions[index];
+  const WasmFunction* function = &module->functions[index];
   return GetWasmCallDescriptor(zone, function->sig);
 }
 
 int32_t CompileAndRunWasmModule(Isolate* isolate, const byte* module_start,
                                 const byte* module_end, bool asm_js) {
   HandleScope scope(isolate);
   Zone zone(isolate->allocator());
   // Decode the module, but don't verify function bodies, since we'll
   // be compiling them anyway.
   ModuleResult result = DecodeWasmModule(isolate, &zone, module_start,
                                          module_end, false, kWasmOrigin);
   if (result.failed()) {
     if (result.val) {
       delete result.val;
     }
     // Module verification failed. throw.
     std::ostringstream str;
     str << "WASM.compileRun() failed: " << result;
     isolate->Throw(
         *isolate->factory()->NewStringFromAsciiChecked(str.str().c_str()));
     return -1;
   }
 
   int32_t retval = CompileAndRunWasmModule(isolate, result.val);
   delete result.val;
   return retval;
 }
 
-int32_t CompileAndRunWasmModule(Isolate* isolate, WasmModule* module) {
+int32_t CompileAndRunWasmModule(Isolate* isolate, const WasmModule* module) {
   ErrorThrower thrower(isolate, "CompileAndRunWasmModule");
   WasmModuleInstance instance(module);
 
   // Allocate and initialize the linear memory.
   if (!AllocateMemory(&thrower, isolate, &instance)) {
     return -1;
   }
   LoadDataSegments(module, instance.mem_start, instance.mem_size);
 
   // Allocate the globals area if necessary.
@@ skipping 70 matching lines @@
                                         uint32_t func_index) {
   Object* func_names_arr_obj = wasm->GetInternalField(kWasmFunctionNamesArray);
   if (func_names_arr_obj->IsUndefined()) return Handle<String>::null();
   return GetWasmFunctionNameFromTable(
       handle(ByteArray::cast(func_names_arr_obj)), func_index);
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8