[wasm] Cleaning up code

src/wasm/asm-wasm-builder.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/v8.h"
 
 // Required to get M_E etc. in MSVC.
 #if defined(_WIN32)
 #define _USE_MATH_DEFINES
 #endif
@@ skipping 367 matching lines @@
       int default_block = has_default ? case_count - 1 : case_count;
       BlockVisitor switch_logic_block(this, nullptr, kExprBlock, false);
       CaseNode* root = OrderCases(&cases, zone_);
       HandleCase(root, case_to_block, tag, default_block, 0);
       if (root->left != nullptr || root->right != nullptr ||
           root->begin == root->end) {
         current_function_builder_->EmitWithU8(kExprBr, ARITY_0);
         current_function_builder_->EmitVarInt(default_block);
       }
     }
-    for (int i = 0; i < case_count; i++) {
+    for (int i = 0; i < case_count; ++i) {
       CaseClause* clause = clauses->at(i);
       RECURSE(VisitStatements(clause->statements()));
       BlockVisitor* v = blocks.at(case_count - i - 1);
       blocks.pop_back();
       delete v;
     }
   }
 
   void VisitCaseClause(CaseClause* clause) override { UNREACHABLE(); }
 
@@ skipping 62 matching lines @@
   void VisitFunctionLiteral(FunctionLiteral* expr) override {
     Scope* scope = expr->scope();
     if (scope_ == kFuncScope) {
       if (bounds_->get(expr).lower->IsFunction()) {
         // Build the signature for the function.
         FunctionType* func_type = bounds_->get(expr).lower->AsFunction();
         LocalType return_type = TypeFrom(func_type->Result());
         FunctionSig::Builder b(zone(), return_type == kAstStmt ? 0 : 1,
                                func_type->Arity());
         if (return_type != kAstStmt) b.AddReturn(return_type);
-        for (int i = 0; i < expr->parameter_count(); i++) {
+        for (int i = 0; i < expr->parameter_count(); ++i) {
           LocalType type = TypeFrom(func_type->Parameter(i));
           DCHECK_NE(kAstStmt, type);
           b.AddParam(type);
           InsertParameter(scope->parameter(i), type, i);
         }
         current_function_builder_->SetSignature(b.Build());
       } else {
         UNREACHABLE();
       }
     }
@@ skipping 156 matching lines @@
 
   void AddFunctionTable(VariableProxy* table, ArrayLiteral* funcs) {
     FunctionType* func_type =
         bounds_->get(funcs).lower->AsArray()->Element()->AsFunction();
     LocalType return_type = TypeFrom(func_type->Result());
     FunctionSig::Builder sig(zone(), return_type == kAstStmt ? 0 : 1,
                              func_type->Arity());
     if (return_type != kAstStmt) {
       sig.AddReturn(static_cast<LocalType>(return_type));
     }
-    for (int i = 0; i < func_type->Arity(); i++) {
+    for (int i = 0; i < func_type->Arity(); ++i) {
       sig.AddParam(TypeFrom(func_type->Parameter(i)));
     }
     uint32_t signature_index = builder_->AddSignature(sig.Build());
     InsertFunctionTable(table->var(), next_table_index_, signature_index);
     next_table_index_ += funcs->values()->length();
-    for (int i = 0; i < funcs->values()->length(); i++) {
+    for (int i = 0; i < funcs->values()->length(); ++i) {
       VariableProxy* func = funcs->values()->at(i)->AsVariableProxy();
       DCHECK_NOT_NULL(func);
       builder_->AddIndirectFunction(LookupOrInsertFunction(func->var()));
     }
   }
 
   struct FunctionTableIndices : public ZoneObject {
     uint32_t start_index;
     uint32_t signature_index;
   };
@@ skipping 614 matching lines @@
         VariableProxy* vp = expr->expression()->AsVariableProxy();
         if (vp != nullptr &&
             Type::Any()->Is(bounds_->get(vp).lower->AsFunction()->Result())) {
           LocalType return_type = TypeOf(expr);
           ZoneList<Expression*>* args = expr->arguments();
           FunctionSig::Builder sig(zone(), return_type == kAstStmt ? 0 : 1,
                                    args->length());
           if (return_type != kAstStmt) {
             sig.AddReturn(return_type);
           }
-          for (int i = 0; i < args->length(); i++) {
+          for (int i = 0; i < args->length(); ++i) {
             sig.AddParam(TypeOf(args->at(i)));
           }
           index =
               imported_function_table_.GetFunctionIndex(vp->var(), sig.Build());
           VisitCallArgs(expr);
           current_function_builder_->Emit(kExprCallImport);
           current_function_builder_->EmitVarInt(expr->arguments()->length());
           current_function_builder_->EmitVarInt(index);
         } else {
           index = LookupOrInsertFunction(vp->var());
@@ skipping 478 matching lines @@
   AsmWasmBuilderImpl impl(isolate_, zone_, literal_, typer_);
   impl.Build();
   *foreign_args = impl.GetForeignArgs();
   ZoneBuffer* buffer = new (zone_) ZoneBuffer(zone_);
   impl.builder_->WriteTo(*buffer);
   return buffer;
 }
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8