refactor BlockVisitor in asm to wasm and fix tests

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"
 
 #include "src/wasm/asm-wasm-builder.h"
 #include "src/wasm/wasm-macro-gen.h"
 #include "src/wasm/wasm-opcodes.h"
 
@@ skipping 74 matching lines @@
       ExpressionStatement* expr =
           stmt->statements()->at(0)->AsExpressionStatement();
       if (expr != nullptr) {
         if (expr->expression()->IsAssignment()) {
           RECURSE(VisitExpressionStatement(expr));
           return;
         }
       }
     }
     DCHECK(in_function_);
-    BlockVisitor visitor(this, stmt->AsBreakableStatement(), kExprBlock, false);
-    block_size_ = static_cast<byte>(stmt->statements()->length());
+    BlockVisitor visitor(this, stmt->AsBreakableStatement(), kExprBlock, false,
+                         static_cast<byte>(stmt->statements()->length()));
     RECURSE(VisitStatements(stmt->statements()));
     DCHECK(block_size_ >= 0);
   }
 
   class BlockVisitor {
    private:
     int prev_block_size_;
     uint32_t index_;
     AsmWasmBuilderImpl* builder_;
 
    public:
     BlockVisitor(AsmWasmBuilderImpl* builder, BreakableStatement* stmt,
-                 WasmOpcode opcode, bool is_loop)
+                 WasmOpcode opcode, bool is_loop, int initial_block_size)
         : builder_(builder) {
       builder_->breakable_blocks_.push_back(std::make_pair(stmt, is_loop));
       builder_->current_function_builder_->Emit(opcode);
       index_ = builder_->current_function_builder_->EmitEditableImmediate(0);
       prev_block_size_ = builder_->block_size_;
+      builder_->block_size_ = initial_block_size;
     }
     ~BlockVisitor() {
       builder_->current_function_builder_->EditImmediate(index_,
                                                          builder_->block_size_);
       builder_->block_size_ = prev_block_size_;
       builder_->breakable_blocks_.pop_back();
     }
   };
 
   void VisitExpressionStatement(ExpressionStatement* stmt) {
@@ skipping 93 matching lines @@
     Literal* label = clause->label()->AsLiteral();
     DCHECK(label != nullptr);
     block_size_++;
     current_function_builder_->Emit(kExprIf);
     current_function_builder_->Emit(kExprI32Ior);
     current_function_builder_->Emit(kExprI32Eq);
     VisitVariableProxy(tag);
     VisitLiteral(label);
     current_function_builder_->Emit(kExprGetLocal);
     AddLeb128(fall_through, true);
-    BlockVisitor visitor(this, nullptr, kExprBlock, false);
-    block_size_ = 0;
+    BlockVisitor visitor(this, nullptr, kExprBlock, false, 0);
     SetLocalTo(fall_through, 1);
     ZoneList<Statement*>* stmts = clause->statements();
     block_size_ += stmts->length();
     RECURSE(VisitStatements(stmts));
   }
 
   void VisitSwitchStatement(SwitchStatement* stmt) {
     VariableProxy* tag = stmt->tag()->AsVariableProxy();
     DCHECK(tag != NULL);
-    BlockVisitor visitor(this, stmt->AsBreakableStatement(), kExprBlock, false);
-    block_size_ = 0;
+    BlockVisitor visitor(this, stmt->AsBreakableStatement(), kExprBlock, false,
+                         0);
     uint16_t fall_through = current_function_builder_->AddLocal(kAstI32);
     SetLocalTo(fall_through, 0);
 
     ZoneList<CaseClause*>* clauses = stmt->cases();
     for (int i = 0; i < clauses->length(); ++i) {
       CaseClause* clause = clauses->at(i);
       if (!clause->is_default()) {
         CompileCase(clause, fall_through, tag);
       } else {
         ZoneList<Statement*>* stmts = clause->statements();
         block_size_ += stmts->length();
         RECURSE(VisitStatements(stmts));
       }
     }
   }
 
   void VisitCaseClause(CaseClause* clause) { UNREACHABLE(); }
 
   void VisitDoWhileStatement(DoWhileStatement* stmt) {
     DCHECK(in_function_);
-    BlockVisitor visitor(this, stmt->AsBreakableStatement(), kExprLoop, true);
-    block_size_ = 2;
+    BlockVisitor visitor(this, stmt->AsBreakableStatement(), kExprLoop, true,
+                         2);
     RECURSE(Visit(stmt->body()));
     current_function_builder_->Emit(kExprIf);
     RECURSE(Visit(stmt->cond()));
     current_function_builder_->EmitWithU8(kExprBr, 0);
     current_function_builder_->Emit(kExprNop);
   }
 
   void VisitWhileStatement(WhileStatement* stmt) {
     DCHECK(in_function_);
-    BlockVisitor visitor(this, stmt->AsBreakableStatement(), kExprLoop, true);
-    block_size_ = 1;
+    BlockVisitor visitor(this, stmt->AsBreakableStatement(), kExprLoop, true,
+                         1);
     current_function_builder_->Emit(kExprIf);
     RECURSE(Visit(stmt->cond()));
     current_function_builder_->EmitWithU8(kExprBr, 0);
     RECURSE(Visit(stmt->body()));
   }
 
   void VisitForStatement(ForStatement* stmt) {
     DCHECK(in_function_);
     if (stmt->init() != nullptr) {
       block_size_++;
       RECURSE(Visit(stmt->init()));
     }
-    BlockVisitor visitor(this, stmt->AsBreakableStatement(), kExprLoop, true);
-    block_size_ = 0;
+    BlockVisitor visitor(this, stmt->AsBreakableStatement(), kExprLoop, true,
+                         0);
     if (stmt->cond() != nullptr) {
       block_size_++;
       current_function_builder_->Emit(kExprIf);
       current_function_builder_->Emit(kExprBoolNot);
       RECURSE(Visit(stmt->cond()));
       current_function_builder_->EmitWithU8(kExprBr, 1);
       current_function_builder_->Emit(kExprNop);
     }
     if (stmt->body() != nullptr) {
       block_size_++;
@@ skipping 732 matching lines @@
 // that zone in constructor may be thrown away once wasm module is written.
 WasmModuleIndex* AsmWasmBuilder::Run() {
   AsmWasmBuilderImpl impl(isolate_, zone_, literal_);
   impl.Compile();
   WasmModuleWriter* writer = impl.builder_->Build(zone_);
   return writer->WriteTo(zone_);
 }
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8