Separate module compile counter for asm and wasm.

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 <memory>
 
 #include "src/assembler-inl.h"
 #include "src/base/adapters.h"
 #include "src/base/atomic-utils.h"
 #include "src/code-stubs.h"
@@ skipping 496 matching lines @@
     Handle<FixedArray> signature_tables =
         factory->NewFixedArray(function_table_count, TENURED);
     for (int i = 0; i < function_table_count; ++i) {
       temp_instance.function_tables[i] = factory->NewFixedArray(1, TENURED);
       temp_instance.signature_tables[i] = factory->NewFixedArray(1, TENURED);
       function_tables->set(i, *temp_instance.function_tables[i]);
       signature_tables->set(i, *temp_instance.signature_tables[i]);
     }
 
     HistogramTimerScope wasm_compile_module_time_scope(
-        isolate_->counters()->wasm_compile_module_time());
+        module_->origin == ModuleOrigin::kWasmOrigin

[bbudge, 2017/03/24 19:19:01]

Since we'll be doing this check all over the place, it's probably worth
pre-computing this boolean in the constructor and keeping it as an instance
field. You can add a DCHECK that it's either kWasmOrigin or kAsmJsOrigin to
prevent breakage, something like:

is_wasm_origin_ = module_->origin == ModuleOrigin::kWasmOrigin;
DCHECK_IMPLIES(!is_wasm_origin_, module_origin == ModuleOrigin::kAsmJsOrigin);

Then just use the instance field everywhere you need to switch between counters.

[Karl, 2017/03/24 21:19:58]

Part of the problem is that the origin field is NOT set in the constructor.
However, we should still use accessors like is_wasm() and is_asm_js() (as well
as get_origin() and set_origin()). This would allow us to cache a boolean
without having to change any code other than for the class definition. I'll do
that.

+            ? isolate_->counters()->wasm_compile_wasm_module_time()
+            : isolate_->counters()->wasm_compile_asm_module_time());
 
     ModuleBytesEnv module_env(module_, &temp_instance, wire_bytes);
 
     // The {code_table} array contains import wrappers and functions (which
     // are both included in {functions.size()}, and export wrappers.
     int code_table_size = static_cast<int>(module_->functions.size() +
                                            module_->num_exported_functions);
     Handle<FixedArray> code_table =
         factory->NewFixedArray(static_cast<int>(code_table_size), TENURED);
 
@@ skipping 2681 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);
 }