Clean up issues raised on previous CL.

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 <functional>
 #include <memory>
 
 #include "src/asmjs/asm-js.h"
 #include "src/assembler-inl.h"
 #include "src/base/atomic-utils.h"
@@ skipping 315 matching lines @@
   // The compilation helper takes ownership of the {WasmModule}.
   // In {CompileToModuleObject}, it will transfer ownership to the generated
   // {WasmModuleWrapper}. If this method is not called, ownership may be
   // reclaimed by explicitely releasing the {module_} field.
   CompilationHelper(Isolate* isolate, std::unique_ptr<WasmModule> module,
                     bool is_sync)
       : isolate_(isolate),
         module_(std::move(module)),
         counters_shared_(isolate->counters_shared()),
         is_sync_(is_sync),
-        executed_units_(isolate->random_number_generator()) {
-    counters_ = counters_shared_.get();
-  }
+        executed_units_(isolate->random_number_generator()) {}
 
   // The actual runnable task that performs compilations in the background.
   class CompilationTask : public CancelableTask {
    public:
     CompilationHelper* helper_;
     explicit CompilationTask(CompilationHelper* helper)
         : CancelableTask(helper->isolate_), helper_(helper) {}
 
     void RunInternal() override {
       while (helper_->FetchAndExecuteCompilationUnit()) {
       }
       helper_->module_->pending_tasks.get()->Signal();
     }
   };
 
   Isolate* isolate_;
   std::unique_ptr<WasmModule> module_;
   std::shared_ptr<Counters> counters_shared_;
-  Counters* counters_;
   bool is_sync_;
   std::vector<std::unique_ptr<compiler::WasmCompilationUnit>>
       compilation_units_;
   CodeGenerationSchedule executed_units_;
   base::Mutex result_mutex_;
   base::AtomicNumber<size_t> next_unit_;
   size_t num_background_tasks_ = 0;
   // This flag should only be set while holding result_mutex_.
   bool finisher_is_running_ = false;
 
@@ skipping 316 matching lines @@
       // (lazy) compilation time.
       ValidateSequentially(&module_env, thrower);
     }
     if (thrower->error()) return {};
 
     // At this point, compilation has completed. Update the code table.
     for (size_t i = FLAG_skip_compiling_wasm_funcs;
          i < temp_instance->function_code.size(); ++i) {
       Code* code = *temp_instance->function_code[i];
       code_table->set(static_cast<int>(i), code);
-      RecordStats(code, counters_);
+      RecordStats(code, counters_shared_.get());
     }
 
     // Create heap objects for script, module bytes and asm.js offset table to
     // be stored in the shared module data.
     Handle<Script> script;
     Handle<ByteArray> asm_js_offset_table;
     if (asm_js_script.is_null()) {
       script = CreateWasmScript(isolate_, wire_bytes);
     } else {
       script = asm_js_script;
@@ skipping 47 matching lines @@
     for (auto exp : module->export_table) {
       if (exp.kind != kExternalFunction) continue;
       Handle<Code> wasm_code = EnsureExportedLazyDeoptData(
           isolate_, Handle<WasmInstanceObject>::null(), code_table, exp.index);
       Handle<Code> wrapper_code =
           js_to_wasm_cache.CloneOrCompileJSToWasmWrapper(isolate_, module,
                                                          wasm_code, exp.index);
       int export_index =
           static_cast<int>(module->functions.size() + func_index);
       code_table->set(export_index, *wrapper_code);
-      RecordStats(*wrapper_code, counters_);
+      RecordStats(*wrapper_code, counters_shared_.get());
       func_index++;
     }
 
     return WasmModuleObject::New(isolate_, compiled_module);
   }
 };
 
 static void MemoryInstanceFinalizer(Isolate* isolate,
                                     WasmInstanceObject* instance) {
   DisallowHeapAllocation no_gc;
@@ skipping 377 matching lines @@
                       MaybeHandle<JSReceiver> ffi,
                       MaybeHandle<JSArrayBuffer> memory)
       : isolate_(isolate),
         module_(module_object->compiled_module()->module()),
         counters_shared_(isolate->counters_shared()),
         thrower_(thrower),
         module_object_(module_object),
         ffi_(ffi.is_null() ? Handle<JSReceiver>::null()
                            : ffi.ToHandleChecked()),
         memory_(memory.is_null() ? Handle<JSArrayBuffer>::null()
-                                 : memory.ToHandleChecked()) {
-    counters_ = counters_shared_.get();
-  }
+                                 : memory.ToHandleChecked()) {}
 
   // Build an instance, in all of its glory.
   MaybeHandle<WasmInstanceObject> Build() {
     // Check that an imports argument was provided, if the module requires it.
     // No point in continuing otherwise.
     if (!module_->import_table.empty() && ffi_.is_null()) {
       thrower_->TypeError(
           "Imports argument must be present and must be an object");
       return {};
     }
@@ skipping 69 matching lines @@
             case Code::JS_TO_WASM_FUNCTION:
             case Code::WASM_FUNCTION: {
               Handle<Code> code = factory->CopyCode(orig_code);
               code_table->set(i, *code);
               break;
             }
             default:
               UNREACHABLE();
           }
         }
-        RecordStats(code_table, counters_);
+        RecordStats(code_table, counters_shared_.get());
       } else {
         // There was no owner, so we can reuse the original.
         compiled_module_ = original;
         old_code_table =
             factory->CopyFixedArray(compiled_module_->code_table());
         code_table = compiled_module_->code_table();
         TRACE("Reusing existing instance %d\n",
               compiled_module_->instance_id());
       }
       compiled_module_->set_native_context(isolate_->native_context());
@@ skipping 262 matching lines @@
       int start_index = module_->start_function_index;
       Handle<Code> startup_code = EnsureExportedLazyDeoptData(
           isolate_, instance, code_table, start_index);
       FunctionSig* sig = module_->functions[start_index].sig;
       Handle<Code> wrapper_code =
           js_to_wasm_cache_.CloneOrCompileJSToWasmWrapper(
               isolate_, module_, startup_code, start_index);
       Handle<WasmExportedFunction> startup_fct = WasmExportedFunction::New(
           isolate_, instance, MaybeHandle<String>(), start_index,
           static_cast<int>(sig->parameter_count()), wrapper_code);
-      RecordStats(*startup_code, counters_);
+      RecordStats(*startup_code, counters_shared_.get());
       // Call the JS function.
       Handle<Object> undefined = factory->undefined_value();
       MaybeHandle<Object> retval =
           Execution::Call(isolate_, startup_fct, undefined, 0, nullptr);
 
       if (retval.is_null()) {
         DCHECK(isolate_->has_pending_exception());
         isolate_->OptionalRescheduleException(false);
         // It's unfortunate that the new instance is already linked in the
         // chain. However, we need to set up everything before executing the
@@ skipping 14 matching lines @@
   struct TableInstance {
     Handle<WasmTableObject> table_object;    // WebAssembly.Table instance
     Handle<FixedArray> js_wrappers;          // JSFunctions exported
     Handle<FixedArray> function_table;       // internal code array
     Handle<FixedArray> signature_table;      // internal sig array
   };
 
   Isolate* isolate_;
   WasmModule* const module_;
   std::shared_ptr<Counters> counters_shared_;
-  Counters* counters_;
   ErrorThrower* thrower_;
   Handle<WasmModuleObject> module_object_;
   Handle<JSReceiver> ffi_;        // TODO(titzer): Use MaybeHandle
   Handle<JSArrayBuffer> memory_;  // TODO(titzer): Use MaybeHandle
   Handle<JSArrayBuffer> globals_;
   Handle<WasmCompiledModule> compiled_module_;
   std::vector<TableInstance> table_instances_;
   std::vector<Handle<JSFunction>> js_wrappers_;
   JSToWasmWrapperCache js_to_wasm_cache_;
 
@@ skipping 189 matching lines @@
               isolate_, index, module_->functions[import.index].sig,
               Handle<JSReceiver>::cast(value), module_name, import_name,
               module_->get_origin());
           if (import_wrapper.is_null()) {
             ReportLinkError(
                 "imported function does not match the expected type", index,
                 module_name, import_name);
             return -1;
           }
           code_table->set(num_imported_functions, *import_wrapper);
-          RecordStats(*import_wrapper, counters_);
+          RecordStats(*import_wrapper, counters_shared_.get());
           num_imported_functions++;
           break;
         }
         case kExternalTable: {
           if (!WasmJs::IsWasmTableObject(isolate_, value)) {
             ReportLinkError("table import requires a WebAssembly.Table", index,
                             module_name, import_name);
             return -1;
           }
           WasmIndirectFunctionTable& table =
@@ skipping 956 matching lines @@
                            Handle<JSPromise> promise)
       : isolate_(isolate),
         counters_shared_(isolate->counters_shared()),
         bytes_copy_(std::move(bytes_copy)),
         wire_bytes_(bytes_copy_.get(), bytes_copy_.get() + length) {
     // The handles for the context and promise must be deferred.
     DeferredHandleScope deferred(isolate);
     context_ = Handle<Context>(*context);
     module_promise_ = Handle<JSPromise>(*promise);
     deferred_handles_.push_back(deferred.Detach());
-    counters_ = counters_shared_.get();
   }
 
   void Start() {
     DoAsync<DecodeModule>();  // --
   }
 
   ~AsyncCompileJob() {
     for (auto d : deferred_handles_) delete d;
   }
 
  private:
   Isolate* isolate_;
   std::shared_ptr<Counters> counters_shared_;
-  Counters* counters_;
   std::unique_ptr<byte[]> bytes_copy_;
   ModuleWireBytes wire_bytes_;
   Handle<Context> context_;
   Handle<JSPromise> module_promise_;
   std::unique_ptr<CompilationHelper> helper_;
   std::unique_ptr<ModuleBytesEnv> module_bytes_env_;
 
   bool failed_ = false;
   std::vector<DeferredHandles*> deferred_handles_;
   Handle<WasmModuleObject> module_object_;
@@ skipping 344 matching lines @@
   // Step 5b (sync): Finish heap-allocated data structures.
   //==========================================================================
   class FinishCompile : public SyncCompileTask {
     void RunImpl() override {
       TRACE_COMPILE("(5b) Finish compile...\n");
       HandleScope scope(job_->isolate_);
       // At this point, compilation has completed. Update the code table.
       for (size_t i = FLAG_skip_compiling_wasm_funcs;
            i < job_->temp_instance_->function_code.size(); ++i) {
         Code* code = Code::cast(job_->code_table_->get(static_cast<int>(i)));
-        RecordStats(code, job_->counters_);
+        RecordStats(code, job_->counters_shared_.get());
       }
 
       // Create heap objects for script and module bytes to be stored in the
       // shared module data. Asm.js is not compiled asynchronously.
       Handle<Script> script =
           CreateWasmScript(job_->isolate_, job_->wire_bytes_);
       Handle<ByteArray> asm_js_offset_table;
       // TODO(wasm): Improve efficiency of storing module wire bytes.
       //   1. Only store relevant sections, not function bodies
       //   2. Don't make a second copy of the bytes here; reuse the copy made
@@ skipping 56 matching lines @@
       for (auto exp : module->export_table) {
         if (exp.kind != kExternalFunction) continue;
         Handle<Code> wasm_code(Code::cast(job_->code_table_->get(exp.index)),
                                job_->isolate_);
         Handle<Code> wrapper_code =
             js_to_wasm_cache.CloneOrCompileJSToWasmWrapper(
                 job_->isolate_, module, wasm_code, exp.index);
         int export_index =
             static_cast<int>(module->functions.size() + func_index);
         job_->code_table_->set(export_index, *wrapper_code);
-        RecordStats(*wrapper_code, job_->counters_);
+        RecordStats(*wrapper_code, job_->counters_shared_.get());
         func_index++;
       }
 
       job_->DoSync<FinishModule>();
     }
   };
 
   //==========================================================================
   // Step 7 (sync): Finish the module and resolve the promise.
   //==========================================================================
@@ skipping 201 matching lines @@
 }
 
 Handle<Code> LazyCompilationOrchestrator::CompileLazy(
     Isolate* isolate, Handle<WasmInstanceObject> instance, Handle<Code> caller,
     int call_offset, int exported_func_index, bool patch_caller) {
   struct NonCompiledFunction {
     int offset;
     int func_index;
   };
   std::shared_ptr<Counters> counters_shared = isolate->counters_shared();
-  Counters* counters = counters_shared.get();
   std::vector<NonCompiledFunction> non_compiled_functions;
   int func_to_return_idx = exported_func_index;
   wasm::Decoder decoder(nullptr, nullptr);
   bool is_js_to_wasm = caller->kind() == Code::JS_TO_WASM_FUNCTION;
   Handle<WasmCompiledModule> compiled_module(instance->compiled_module(),
                                              isolate);
 
   if (is_js_to_wasm) {
     non_compiled_functions.push_back({0, exported_func_index});
   } else if (patch_caller) {
@@ skipping 24 matching lines @@
           ExtractDirectCallIndex(decoder, func_bytes + byte_pos);
       non_compiled_functions.push_back({offset, called_func_index});
       // Call offset one instruction after the call. Remember the last called
       // function before that offset.
       if (offset < call_offset) func_to_return_idx = called_func_index;
     }
   }
 
   // TODO(clemensh): compile all functions in non_compiled_functions in
   // background, wait for func_to_return_idx.
-  CompileFunction(isolate, instance, func_to_return_idx, counters);
+  CompileFunction(isolate, instance, func_to_return_idx, counters_shared.get());
 
   if (is_js_to_wasm || patch_caller) {
     DisallowHeapAllocation no_gc;
     // Now patch the code object with all functions which are now compiled.
     int idx = 0;
     for (RelocIterator it(*caller, RelocInfo::kCodeTargetMask); !it.done();
          it.next()) {
       Code* callee =
           Code::GetCodeFromTargetAddress(it.rinfo()->target_address());
       if (callee->builtin_index() != Builtins::kWasmCompileLazy) continue;
@@ skipping 22 matching lines @@
                                      callee_compiled->instruction_start());
     }
     DCHECK_EQ(non_compiled_functions.size(), idx);
   }
 
   Code* ret =
       Code::cast(compiled_module->code_table()->get(func_to_return_idx));
   DCHECK_EQ(Code::WASM_FUNCTION, ret->kind());
   return handle(ret, isolate);
 }