[wasm] Cleaning up code

src/wasm/ast-decoder.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/signature.h"
 
 #include "src/bit-vector.h"
 #include "src/flags.h"
 #include "src/handles.h"
 #include "src/zone-containers.h"
@@ skipping 231 matching lines @@
     return false;
   }
 
   bool Validate(const byte* pc, BranchTableOperand& operand,
                 size_t block_depth) {
     if (operand.arity > 1) {
       error(pc, pc + 1, "invalid arity for break");
       return false;
     }
     // Verify table.
-    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(this, i);
       if (target >= block_depth) {
         error(operand.table + i * 2, "improper branch in br_table");
         return false;
       }
     }
     return true;
   }
 
   int OpcodeArity(const byte* pc) {
@@ skipping 295 matching lines @@
         return builder_->Float64Constant(0);
       default:
         UNREACHABLE();
         return nullptr;
     }
   }
 
   char* indentation() {
     static const int kMaxIndent = 64;
     static char bytes[kMaxIndent + 1];
-    for (int i = 0; i < kMaxIndent; i++) bytes[i] = ' ';
+    for (int i = 0; i < kMaxIndent; ++i) bytes[i] = ' ';
     bytes[kMaxIndent] = 0;
     if (stack_.size() < kMaxIndent / 2) {
       bytes[stack_.size() * 2] = 0;
     }
     return bytes;
   }
 
   // Decodes the locals declarations, if any, populating {local_type_vec_}.
   void DecodeLocalDecls() {
     DCHECK_EQ(0, local_type_vec_.size());
     // Initialize {local_type_vec} from signature.
     if (sig_) {
       local_type_vec_.reserve(sig_->parameter_count());
-      for (size_t i = 0; i < sig_->parameter_count(); i++) {
+      for (size_t i = 0; i < sig_->parameter_count(); ++i) {
         local_type_vec_.push_back(sig_->GetParam(i));
       }
     }
     // Decode local declarations, if any.
     int length;
     uint32_t entries = consume_u32v(&length, "local decls count");
     while (entries-- > 0 && pc_ < limit_) {
       uint32_t count = consume_u32v(&length, "local count");
       byte code = consume_u8("local type");
       LocalType type;
@@ skipping 214 matching lines @@
               if (operand.arity == 1) val = Pop();
               if (failed()) break;
 
               SsaEnv* break_env = ssa_env_;
               if (operand.table_count > 0) {
                 // Build branches to the various blocks based on the table.
                 TFNode* sw = BUILD(Switch, operand.table_count + 1, key.node);
 
                 SsaEnv* copy = Steal(break_env);
                 ssa_env_ = copy;
-                for (uint32_t i = 0; i < operand.table_count + 1; i++) {
+                for (uint32_t i = 0; i < operand.table_count + 1; ++i) {
                   uint16_t target = operand.read_entry(this, i);
                   ssa_env_ = Split(copy);
                   ssa_env_->control = (i == operand.table_count)
                                           ? BUILD(IfDefault, sw)
                                           : BUILD(IfValue, i, sw);
                   int depth = target;
                   Control* c = &control_[control_.size() - depth - 1];
                   MergeInto(c->end_env, &c->node, &c->type, val);
                 }
               } else {
@@ skipping 210 matching lines @@
             break;
           }
           default:
             error("Invalid opcode");
             return;
         }
       }  // end complex bytecode
 
 #if DEBUG
       if (FLAG_trace_wasm_decoder) {
-        for (size_t i = 0; i < stack_.size(); i++) {
+        for (size_t i = 0; i < stack_.size(); ++i) {
           Value& val = stack_[i];
           WasmOpcode opcode = static_cast<WasmOpcode>(*val.pc);
           PrintF(" %c@%d:%s", WasmOpcodes::ShortNameOf(val.type),
                  static_cast<int>(val.pc - start_),
                  WasmOpcodes::ShortOpcodeName(opcode));
           switch (opcode) {
             case kExprI32Const: {
               ImmI32Operand operand(this, val.pc);
               PrintF("[%d]", operand.value);
               break;
@@ skipping 462 matching lines @@
   return decoder.toResult<Tree*>(nullptr);
 }
 
 std::ostream& operator<<(std::ostream& os, const Tree& tree) {
   if (tree.pc == nullptr) {
     os << "null";
     return os;
   }
   PrintF("%s", WasmOpcodes::OpcodeName(tree.opcode()));
   if (tree.count > 0) os << "(";
-  for (uint32_t i = 0; i < tree.count; i++) {
+  for (uint32_t i = 0; i < tree.count; ++i) {
     if (i > 0) os << ", ";
     os << *tree.children[i];
   }
   if (tree.count > 0) os << ")";
   return os;
 }
 
 int OpcodeLength(const byte* pc, const byte* end) {
   WasmDecoder decoder(nullptr, nullptr, pc, end);
   return decoder.OpcodeLength(pc);
@@ skipping 57 matching lines @@
       offset_table->push_back(
           std::make_tuple(pc - body.start, line_nr, num_whitespaces));
     }
 
     // 64 whitespaces
     const char* padding =
         "                                                                ";
     os.write(padding, num_whitespaces);
     os << "k" << WasmOpcodes::OpcodeName(opcode) << ",";
 
-    for (size_t i = 1; i < length; i++) {
+    for (size_t i = 1; i < length; ++i) {
       os << " " << AsHex(pc[i], 2) << ",";
     }
 
     switch (opcode) {
       case kExprIf:
       case kExprElse:
       case kExprLoop:
       case kExprBlock:
         os << "   // @" << static_cast<int>(pc - body.start);
         control_depth++;
@@ skipping 65 matching lines @@
 BitVector* AnalyzeLoopAssignmentForTesting(Zone* zone, size_t num_locals,
                                            const byte* start, const byte* end) {
   FunctionBody body = {nullptr, nullptr, nullptr, start, end};
   SR_WasmDecoder decoder(zone, nullptr, body);
   return decoder.AnalyzeLoopAssignmentForTesting(start, num_locals);
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8