[wasm] Cleaning up code

src/wasm/wasm-interpreter.cc

 // Copyright 2016 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/wasm/wasm-interpreter.h"
 #include "src/wasm/ast-decoder.h"
 #include "src/wasm/decoder.h"
 #include "src/wasm/wasm-external-refs.h"
 #include "src/wasm/wasm-module.h"
 
@@ skipping 804 matching lines @@
           control_stack[control_stack.size() - operand.depth - 1].Ref(
               &map_, start, pc, value_depth, operand.arity > 0);
           value_depth++;
           break;
         }
         case kExprBrTable: {
           BranchTableOperand operand(&decoder, pc);
           TRACE("control @%td $%zu: BrTable[arity=%u count=%u]\n", (pc - start),
                 value_depth, operand.arity, operand.table_count);
           value_depth -= (operand.arity + 1);
-          for (uint32_t i = 0; i < operand.table_count + 1; i++) {
+          for (uint32_t i = 0; i < operand.table_count + 1; ++i) {
             uint32_t target = operand.read_entry(&decoder, i);
             control_stack[control_stack.size() - target - 1].Ref(
                 &map_, start, pc + i, value_depth, operand.arity > 0);
           }
           value_depth++;
           break;
         }
         default: {
           value_depth = value_depth - OpcodeArity(pc, end) + 1;
           break;
@@ skipping 30 matching lines @@
 // metadata needed to execute each function.
 class CodeMap {
  public:
   Zone* zone_;
   const WasmModule* module_;
   ZoneVector<InterpreterCode> interpreter_code_;
 
   CodeMap(const WasmModule* module, Zone* zone)
       : zone_(zone), module_(module), interpreter_code_(zone) {
     if (module == nullptr) return;
-    for (size_t i = 0; i < module->functions.size(); i++) {
+    for (size_t i = 0; i < module->functions.size(); ++i) {
       const WasmFunction* function = &module->functions[i];
       const byte* code_start =
           module->module_start + function->code_start_offset;
       const byte* code_end = module->module_start + function->code_end_offset;
       AddFunction(function, code_start, code_end);
     }
   }
 
   InterpreterCode* FindCode(const WasmFunction* function) {
     if (function->func_index < interpreter_code_.size()) {
@@ skipping 70 matching lines @@
   //==========================================================================
   // Implementation of public interface for WasmInterpreter::Thread.
   //==========================================================================
 
   virtual WasmInterpreter::State state() { return state_; }
 
   virtual void PushFrame(const WasmFunction* function, WasmVal* args) {
     InterpreterCode* code = codemap()->FindCode(function);
     CHECK_NOT_NULL(code);
     frames_.push_back({code, 0, 0, stack_.size()});
-    for (size_t i = 0; i < function->sig->parameter_count(); i++) {
+    for (size_t i = 0; i < function->sig->parameter_count(); ++i) {
       stack_.push_back(args[i]);
     }
     frames_.back().ret_pc = InitLocals(code);
     TRACE("  => PushFrame(#%u @%zu)\n", code->function->func_index,
           frames_.back().ret_pc);
   }
 
   virtual WasmInterpreter::State Run() {
     do {
       TRACE("  => Run()\n");
@@ skipping 672 matching lines @@
       PrintF("\n");
     }
   }
 
   void TraceValueStack() {
     Frame* top = frames_.size() > 0 ? &frames_.back() : nullptr;
     sp_t sp = top ? top->sp : 0;
     sp_t plimit = top ? top->plimit() : 0;
     sp_t llimit = top ? top->llimit() : 0;
     if (FLAG_trace_wasm_interpreter) {
-      for (size_t i = sp; i < stack_.size(); i++) {
+      for (size_t i = sp; i < stack_.size(); ++i) {
         if (i < plimit)
           PrintF(" p%zu:", i);
         else if (i < llimit)
           PrintF(" l%zu:", i);
         else
           PrintF(" s%zu:", i);
         WasmVal val = stack_[i];
         switch (val.type) {
           case kAstI32:
             PrintF("i32:%d", val.to<int32_t>());
@@ skipping 150 matching lines @@
 
 ControlTransferMap WasmInterpreter::ComputeControlTransfersForTesting(
     Zone* zone, const byte* start, const byte* end) {
   ControlTransfers targets(zone, 0, start, end);
   return targets.map_;
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8