[wasm] Several unrelated cleanups

src/compiler/wasm-compiler.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/compiler/wasm-compiler.h"
 
 #include <memory>
 
 #include "src/assembler-inl.h"
 #include "src/base/platform/elapsed-timer.h"
@@ skipping 161 matching lines @@
     return builder_->Control();
   }
 
   // Add a check that traps if {node} is zero.
   Node* ZeroCheck64(wasm::TrapReason reason, Node* node,
                     wasm::WasmCodePosition position) {
     return TrapIfEq64(reason, node, 0, position);
   }
 
   Builtins::Name GetBuiltinIdForTrap(wasm::TrapReason reason) {
-    if (builder_->module_ && !builder_->module_->instance->context.is_null()) {
-      switch (reason) {
-#define TRAPREASON_TO_MESSAGE(name) \
-  case wasm::k##name:               \
-    return Builtins::kThrowWasm##name;
-        FOREACH_WASM_TRAPREASON(TRAPREASON_TO_MESSAGE)
-#undef TRAPREASON_TO_MESSAGE
-        default:
-          UNREACHABLE();
-          return Builtins::builtin_count;
-      }
-    } else {
-      // We use Runtime::kNumFunctions as a marker to tell the code generator
+    bool in_cctest =
+        !builder_->module_ || builder_->module_->instance->context.is_null();
+    if (in_cctest) {
+      // We use Builtins::builtin_count as a marker to tell the code generator
       // to generate a call to a testing c-function instead of a runtime
       // function. This code should only be called from a cctest.
       return Builtins::builtin_count;
     }
+
+    switch (reason) {
+#define TRAPREASON_TO_MESSAGE(name) \
+  case wasm::k##name:               \
+    return Builtins::kThrowWasm##name;
+      FOREACH_WASM_TRAPREASON(TRAPREASON_TO_MESSAGE)
+#undef TRAPREASON_TO_MESSAGE
+      default:
+        UNREACHABLE();
+        return Builtins::builtin_count;
+    }
   }
 
 #if V8_TARGET_ARCH_X64 || V8_TARGET_ARCH_IA32 || V8_TARGET_ARCH_ARM ||      \
     V8_TARGET_ARCH_ARM64 || V8_TARGET_ARCH_MIPS || V8_TARGET_ARCH_MIPS64 || \
     V8_TARGET_ARCH_PPC || V8_TARGET_ARCH_PPC64 || V8_TARGET_ARCH_S390 ||    \
     V8_TARGET_ARCH_S390X || V8_TARGET_ARCH_X87
 #define WASM_TRAP_IF_SUPPORTED
 #endif
 
   // Add a trap if {cond} is true.
@@ skipping 151 matching lines @@
       jsgraph_(jsgraph),
       module_(module_env),
       signature_tables_(zone),
       function_tables_(zone),
       function_table_sizes_(zone),
       cur_buffer_(def_buffer_),
       cur_bufsize_(kDefaultBufferSize),
       trap_(new (zone) WasmTrapHelper(this)),
       sig_(sig),
       source_position_table_(source_position_table) {
-  for (size_t i = 0; i < sig->parameter_count(); i++) {
+  for (size_t i = 0, e = sig->parameter_count(); i < e && !has_simd_; ++i) {

[titzer, 2017/02/28 15:15:07]

You could also just iterate from sig->parameter_count() and iterate until
wraparound.

[Clemens Hammacher, 2017/03/01 16:41:11]

Done (iterate while > 0 and use "i-1" in the body, since i is unsigned).

     if (sig->GetParam(i) == wasm::kWasmS128) has_simd_ = true;

[titzer, 2017/02/28 15:15:07]

And could also just break if found, instead of checking every iteration.

[Clemens Hammacher, 2017/03/01 16:41:11]

I expect this to be eliminated by the compiler (SSA & jump threading). Adding an
explicit break would add three lines two times :(

   }
-  for (size_t i = 0; i < sig->return_count(); i++) {
+  for (size_t i = 0, e = sig->return_count(); i < e && !has_simd_; ++i) {
     if (sig->GetReturn(i) == wasm::kWasmS128) has_simd_ = true;
   }
   DCHECK_NOT_NULL(jsgraph_);
 }
 
 Node* WasmGraphBuilder::Error() { return jsgraph()->Dead(); }
 
 Node* WasmGraphBuilder::Start(unsigned params) {
   Node* start = graph()->NewNode(jsgraph()->common()->Start(params));
   graph()->SetStart(start);
@@ skipping 2659 matching lines @@
         RelocInfo::WASM_MEMORY_REFERENCE);
   }
 }
 
 Node* WasmGraphBuilder::CurrentMemoryPages() {
   Runtime::FunctionId function_id = Runtime::kWasmMemorySize;
   const Runtime::Function* function = Runtime::FunctionForId(function_id);
   CallDescriptor* desc = Linkage::GetRuntimeCallDescriptor(
       jsgraph()->zone(), function_id, function->nargs, Operator::kNoThrow,
       CallDescriptor::kNoFlags);
-  wasm::ModuleEnv* module = module_;
   Node* inputs[] = {
       jsgraph()->CEntryStubConstant(function->result_size),  // C entry
       jsgraph()->ExternalConstant(
           ExternalReference(function_id, jsgraph()->isolate())),  // ref
       jsgraph()->Int32Constant(function->nargs),                  // arity
-      jsgraph()->HeapConstant(module->instance->context),         // context
+      jsgraph()->HeapConstant(module_->instance->context),        // context
       *effect_,
       *control_};
   Node* call = graph()->NewNode(jsgraph()->common()->Call(desc),
                                 static_cast<int>(arraysize(inputs)), inputs);
 
   Node* result = BuildChangeSmiToInt32(call);
 
   *effect_ = call;
   return result;
 }
@@ skipping 1060 matching lines @@
            function_->code_end_offset - function_->code_start_offset,
            codegen_ms);
   }
 
   return code;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8