[wasm] Add a flag to output the generated code size

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/property-descriptor.h"
 #include "src/v8.h"
 
 #include "src/simulator.h"
@@ skipping 395 matching lines @@
                                               Handle<JSArrayBuffer> memory) {
   HistogramTimerScope wasm_instantiate_module_time_scope(
       isolate->counters()->wasm_instantiate_module_time());
   this->shared_isolate = isolate;  // TODO(titzer): have a real shared isolate.
   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;
+  auto record_code_size = [&total_code_size](Code* code) {
+    if (FLAG_print_wasm_code_size)
+      total_code_size += code->body_size() + code->relocation_info()->length();
+  };
+
   //-------------------------------------------------------------------------
   // 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);
   Handle<FixedArray> code_table =
@@ skipping 51 matching lines @@
           GetNameOrNull(import.module_name_offset, import.module_name_length);
       WasmName function_name = 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 MaybeHandle<JSObject>();
       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(*code);
       index++;
     }
   }
 
   //-------------------------------------------------------------------------
   // Compile all functions in the module.
   //-------------------------------------------------------------------------
   {
     isolate->counters()->wasm_functions_per_module()->AddSample(
         static_cast<int>(functions.size()));
@@ skipping 52 matching lines @@
                                                &func);
         }
         if (code.is_null()) {
           thrower.Error("Compilation of #%d:%.*s failed.", i, str.length(),
                         str.start());
           return MaybeHandle<JSObject>();
         }
         if (func.exported) {
           function = compiler::CompileJSToWasmWrapper(
               isolate, &module_env, name, code, instance.js_object, i);
+          record_code_size(function->code());
         }
       }
       if (!code.is_null()) {
         // Install the code into the linker table.
         linker.Finish(i, code);
         code_table->set(i, *code);
+        record_code_size(*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, name, &desc, Object::THROW_ON_ERROR);
         if (!status.IsJust())
           thrower.Error("export of %.*s failed.", str.length(), str.start());
       }
@@ skipping 19 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(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);
       }
     }
   }
 
+  if (FLAG_print_wasm_code_size)
+    printf("Total generated wasm code: %u bytes\n", total_code_size);
+
   // 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);
 
     // Call the JS function.
@@ skipping 133 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