[wasm] Separate reloc info stats from code size stats.

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 433 matching lines @@
   }
 
   Isolate* isolate_;
   std::vector<compiler::WasmCompilationUnit*>* compilation_units_;
   std::queue<compiler::WasmCompilationUnit*>* executed_units_;
   base::Semaphore* on_finished_;
   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();
+// 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();
+    }
   }
-}
+
+  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);
+    }
+  }
+};
 
 bool CompileWrappersToImportedFunctions(Isolate* isolate, WasmModule* module,
                                         const Handle<JSReceiver> ffi,
                                         WasmModuleInstance* instance,
                                         ErrorThrower* thrower, Factory* factory,
                                         ModuleEnv* module_env,
-                                        uint32_t& total_code_size) {
+                                        CodeStats& code_stats) {
   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);
+      code_stats.Record(*code);
       index++;
     }
   }
   return true;
 }
 
 void InitializeParallelCompilation(
     Isolate* isolate, std::vector<WasmFunction>& functions,
     std::vector<compiler::WasmCompilationUnit*>& compilation_units,
     ModuleEnv& module_env, ErrorThrower& thrower) {
@@ skipping 64 matching lines @@
     delete unit;
   }
 }
 
 bool FinishCompilation(Isolate* isolate, 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,
+                       ModuleEnv& module_env, CodeStats& code_stats,
                        PropertyDescriptor& desc) {
   for (uint32_t i = FLAG_skip_compiling_wasm_funcs;
        i < module->functions.size(); i++) {
     const WasmFunction& func = module->functions[i];
     if (thrower.error()) break;
 
     DCHECK_EQ(i, func.func_index);
     WasmName str = module->GetName(func.name_offset, func.name_length);
     Handle<Code> code = Handle<Code>::null();
     Handle<JSFunction> function = Handle<JSFunction>::null();
     Handle<String> function_name = Handle<String>::null();
     if (FLAG_wasm_num_compilation_tasks != 0) {
       code = results[i];
     } else {
       // Compile the function.
       code = compiler::WasmCompilationUnit::CompileWasmFunction(
           &thrower, isolate, &module_env, &func);
     }
     if (code.is_null()) {
       thrower.Error("Compilation of #%d:%.*s failed.", i, str.length(),
                     str.start());
       return false;
     }
     if (func.exported) {
       function_name = factory->InternalizeUtf8String(str);
       function = compiler::CompileJSToWasmWrapper(
           isolate, &module_env, function_name, code, instance.js_object, i);
-      record_code_size(total_code_size, function->code());
+      code_stats.Record(function->code());
     }
     if (!code.is_null()) {
       // Install the code into the linker table.
       module_env.linker->Finish(i, code);
       code_table->set(i, *code);
-      record_code_size(total_code_size, *code);
+      code_stats.Record(*code);
     }
     if (func.exported) {
       // Exported functions are installed as read-only properties on the
       // module.
       desc.set_value(function);
       Maybe<bool> status = JSReceiver::DefineOwnProperty(
           isolate, instance.js_object, function_name, &desc,
           Object::THROW_ON_ERROR);
       if (!status.IsJust())
         thrower.Error("export of %.*s failed.", str.length(), str.start());
@@ skipping 15 matching lines @@
       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.
   // TODO(titzer): switch this to TRACE_EVENT
-  uint32_t total_code_size = 0;
+  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 39 matching lines @@
   module_env.module = this;
   module_env.instance = &instance;
   module_env.linker = &linker;
   module_env.origin = origin;
 
   //-------------------------------------------------------------------------
   // Compile wrappers to imported functions.
   //-------------------------------------------------------------------------
   if (!CompileWrappersToImportedFunctions(isolate, this, ffi, &instance,
                                           &thrower, factory, &module_env,
-                                          total_code_size)) {
+                                          code_stats)) {
     return MaybeHandle<JSObject>();
   }
   //-------------------------------------------------------------------------
   // Compile all functions in the module.
   //-------------------------------------------------------------------------
   {
     isolate->counters()->wasm_functions_per_module()->AddSample(
         static_cast<int>(functions.size()));
 
     // Data structures for the parallel compilation.
@@ skipping 54 matching lines @@
         FinishCompilationUnits(this, 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);
     }
     // 5) The main thread finishes the compilation.
     if (!FinishCompilation(isolate, this, ffi, results, instance, code_table,
-                           thrower, factory, module_env, total_code_size,
-                           desc)) {
+                           thrower, factory, module_env, code_stats, desc)) {
       instance.js_object = Handle<JSObject>::null();
     }
 
     // Patch all direct call sites.
     linker.Link(instance.function_table, this->function_table);
     instance.js_object->SetInternalField(kWasmModuleFunctionTable,
                                          Smi::FromInt(0));
 
     //-------------------------------------------------------------------------
     // Create and populate the exports object.
@@ skipping 10 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 = linker.GetFunctionCode(exp.func_index);
         Handle<JSFunction> function = compiler::CompileJSToWasmWrapper(
             isolate, &module_env, name, code, instance.js_object,
             exp.func_index);
-        record_code_size(total_code_size, function->code());
+        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());
       }
 
       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);
       }
     }
   }
 
   //-------------------------------------------------------------------------
   // Attach an array with function names and an array with offsets into that
   // first array.
   //-------------------------------------------------------------------------
   {
     Handle<Object> arr = BuildFunctionNamesTable(isolate, module_env.module);
     instance.js_object->SetInternalField(kWasmFunctionNamesArray, *arr);
   }
 
-  if (FLAG_print_wasm_code_size)
-    printf("Total generated wasm code: %u bytes\n", total_code_size);
+  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 = linker.GetFunctionCode(index);
     Handle<JSFunction> jsfunc = compiler::CompileJSToWasmWrapper(
         isolate, &module_env, name, code, instance.js_object, index);
 
@@ skipping 138 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