[wasm] Consolidated code size reporting as instantiation concern.

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 458 matching lines @@
 };
 
 // Records statistics on the code generated by compiling WASM functions.
 struct CodeStats {
   size_t code_size;
   size_t reloc_size;
 
   inline CodeStats() : code_size(0), reloc_size(0) {}
 
   inline void Record(Code* code) {
-    if (FLAG_print_wasm_code_size) {
-      code_size += code->body_size();
-      reloc_size += code->relocation_info()->length();
-    }
+    code_size += code->body_size();
+    reloc_size += code->relocation_info()->length();
   }
 
   inline void Report() {
-    if (FLAG_print_wasm_code_size) {
-      PrintF("Total generated wasm code: %zu bytes\n", code_size);
-      PrintF("Total generated wasm reloc: %zu bytes\n", reloc_size);
-    }
+    PrintF("Total generated wasm code: %zu bytes\n", code_size);
+    PrintF("Total generated wasm reloc: %zu bytes\n", reloc_size);
   }
 };
 
-bool CompileWrappersToImportedFunctions(
-    Isolate* isolate, const WasmModule* module, const Handle<JSReceiver> ffi,
-    WasmModuleInstance* instance, ErrorThrower* thrower, Factory* factory,
-    ModuleEnv* module_env, CodeStats& code_stats) {
+bool CompileWrappersToImportedFunctions(Isolate* isolate,
+                                        const WasmModule* module,
+                                        const Handle<JSReceiver> ffi,
+                                        WasmModuleInstance* instance,
+                                        ErrorThrower* thrower, Factory* factory,
+                                        ModuleEnv* module_env) {
   if (module->import_table.size() > 0) {
     instance->import_code.reserve(module->import_table.size());
     for (uint32_t index = 0; index < module->import_table.size(); ++index) {
       const WasmImport& import = module->import_table[index];
       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[index] = code;
-      code_stats.Record(*code);
     }
   }
   return true;
 }
 
 void InitializeParallelCompilation(
     Isolate* isolate, const std::vector<WasmFunction>& functions,
     std::vector<compiler::WasmCompilationUnit*>& compilation_units,
     ModuleEnv& module_env, ErrorThrower& thrower) {
   for (uint32_t i = FLAG_skip_compiling_wasm_funcs; i < functions.size(); i++) {
@@ skipping 172 matching lines @@
     }
     deopt_data->set(1, Smi::FromInt(static_cast<int>(i)));
     deopt_data->set_length(2);
     code->set_deoptimization_data(*deopt_data);
   }
 }
 
 Handle<FixedArray> WasmModule::CompileFunctions(Isolate* isolate) const {
   Factory* factory = isolate->factory();
   ErrorThrower thrower(isolate, "WasmModule::CompileFunctions()");
-  CodeStats code_stats;
 
   WasmModuleInstance temp_instance_for_compilation(this);
   temp_instance_for_compilation.function_table =
       BuildFunctionTable(isolate, this);
   temp_instance_for_compilation.context = isolate->native_context();
   temp_instance_for_compilation.mem_size = GetMinModuleMemSize(this);
   temp_instance_for_compilation.mem_start = nullptr;
   temp_instance_for_compilation.globals_start = nullptr;
 
   ModuleEnv module_env;
@@ skipping 26 matching lines @@
   }
 
   LinkModuleFunctions(isolate, temp_instance_for_compilation.function_code);
 
   // At this point, compilation has completed. Update the code table
   // and record sizes.
   for (size_t i = FLAG_skip_compiling_wasm_funcs;
        i < temp_instance_for_compilation.function_code.size(); ++i) {
     Code* code = *temp_instance_for_compilation.function_code[i];
     ret->set(static_cast<int>(i), code);
-    code_stats.Record(code);
   }
 
   PopulateFunctionTable(&temp_instance_for_compilation);
 
   return ret;
 }
 
 // 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) const {
   HistogramTimerScope wasm_instantiate_module_time_scope(
       isolate->counters()->wasm_instantiate_module_time());
   ErrorThrower thrower(isolate, "WasmModule::Instantiate()");
   Factory* factory = isolate->factory();
 
-  // If FLAG_print_wasm_code_size is set, this aggregates the sum of all code
-  // objects created for this module.
-  // TODO(titzer): switch this to TRACE_EVENT
-  CodeStats code_stats;
-
   //-------------------------------------------------------------------------
   // Allocate the instance and its JS counterpart.
   //-------------------------------------------------------------------------
   Handle<Map> map = factory->NewMap(
       JS_OBJECT_TYPE,
       JSObject::kHeaderSize + kWasmModuleInternalFieldCount * kPointerSize);
   WasmModuleInstance instance(this);
   instance.context = isolate->native_context();
   instance.js_object = factory->NewJSObjectFromMap(map, TENURED);
 
@@ skipping 51 matching lines @@
 
   ModuleEnv module_env;
   module_env.module = this;
   module_env.instance = &instance;
   module_env.origin = origin;
 
   //-------------------------------------------------------------------------
   // Compile wrappers to imported functions.
   //-------------------------------------------------------------------------
   if (!CompileWrappersToImportedFunctions(isolate, this, ffi, &instance,
-                                          &thrower, factory, &module_env,
-                                          code_stats)) {
+                                          &thrower, factory, &module_env)) {
     return MaybeHandle<JSObject>();
   }
+
+  // If FLAG_print_wasm_code_size is set, this aggregates the sum of all code
+  // objects created for this module.
+  // TODO(titzer): switch this to TRACE_EVENT
+  CodeStats code_stats;
+  if (FLAG_print_wasm_code_size) {
+    for (Handle<Code> c : instance.function_code) code_stats.Record(*c);
+    for (Handle<Code> c : instance.import_code) code_stats.Record(*c);
+  }
+
   {
     instance.js_object->SetInternalField(kWasmModuleFunctionTable,
                                          Smi::FromInt(0));
     LinkImports(isolate, instance.function_code, instance.import_code);
 
     SetDeoptimizationData(factory, instance.js_object, instance.function_code);
 
     //-------------------------------------------------------------------------
     // Create and populate the exports object.
     //-------------------------------------------------------------------------
@@ skipping 17 matching lines @@
 
       // Compile wrappers and add them to the exports object.
       for (const WasmExport& exp : export_table) {
         if (thrower.error()) break;
         WasmName str = GetName(exp.name_offset, exp.name_length);
         Handle<String> name = factory->InternalizeUtf8String(str);
         Handle<Code> code = instance.function_code[exp.func_index];
         Handle<JSFunction> function = compiler::CompileJSToWasmWrapper(
             isolate, &module_env, name, code, instance.js_object,
             exp.func_index);
-        code_stats.Record(function->code());
+        if (FLAG_print_wasm_code_size) {
+          code_stats.Record(function->code());
+        }
         desc.set_value(function);
         Maybe<bool> status = JSReceiver::DefineOwnProperty(
             isolate, exports_object, name, &desc, Object::THROW_ON_ERROR);
         if (!status.IsJust()) {
           thrower.Error("export of %.*s failed.", str.length(), str.start());
           break;
         }
       }
 
       if (mem_export) {
         // Export the memory as a named property.
         Handle<String> name = factory->InternalizeUtf8String("memory");
         JSObject::AddProperty(exports_object, name, instance.mem_buffer,
                               READ_ONLY);
       }
     }
   }
 
+  if (FLAG_print_wasm_code_size) {
+    code_stats.Report();
+  }
   //-------------------------------------------------------------------------
   // Attach the function name table.
   //-------------------------------------------------------------------------
   Handle<ByteArray> function_name_table =
       BuildFunctionNamesTable(isolate, module_env.module);
   instance.js_object->SetInternalField(kWasmFunctionNamesArray,
                                        *function_name_table);
 
-  code_stats.Report();
-
   // Run the start function if one was specified.
   if (this->start_function_index >= 0) {
     HandleScope scope(isolate);
     uint32_t index = static_cast<uint32_t>(this->start_function_index);
     Handle<String> name = isolate->factory()->NewStringFromStaticChars("start");
     Handle<Code> code = instance.function_code[index];
     Handle<JSFunction> jsfunc = compiler::CompileJSToWasmWrapper(
         isolate, &module_env, name, code, instance.js_object, index);
 
     // Call the JS function.
@@ skipping 186 matching lines @@
   Object* info = wasm->GetInternalField(kWasmDebugInfo);
   if (!info->IsUndefined(wasm->GetIsolate())) return WasmDebugInfo::cast(info);
   Handle<WasmDebugInfo> new_info = WasmDebugInfo::New(handle(wasm));
   wasm->SetInternalField(kWasmDebugInfo, *new_info);
   return *new_info;
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8