Add switch to asm to wasm

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 131 matching lines @@
     } else {
       current_function_builder_->Emit(kExprNop);
     }
     if (stmt->HasElseStatement()) {
       RECURSE(Visit(stmt->else_statement()));
     }
   }
 
   void VisitContinueStatement(ContinueStatement* stmt) {
     DCHECK(in_function_);
+    DCHECK(stmt->target() != NULL);

[bradnelson, 2016/01/12 01:06:43]

Is this actually guaranteed?

[aseemgarg, 2016/01/12 01:38:37]

yes

     int i = static_cast<int>(breakable_blocks_.size()) - 1;
     int block_distance = 0;
     for (; i >= 0; i--) {
       auto elem = breakable_blocks_.at(i);
       if (elem.first == stmt->target()) {
         DCHECK(elem.second);
         break;
       } else if (elem.second) {
         block_distance += 2;
       } else {
         block_distance += 1;
       }
     }
     DCHECK(i >= 0);
     current_function_builder_->EmitWithU8(kExprBr, block_distance);
     current_function_builder_->Emit(kExprNop);
   }
 
   void VisitBreakStatement(BreakStatement* stmt) {
     DCHECK(in_function_);
+    DCHECK(stmt->target() != NULL);
     int i = static_cast<int>(breakable_blocks_.size()) - 1;
     int block_distance = 0;
     for (; i >= 0; i--) {
       auto elem = breakable_blocks_.at(i);
       if (elem.first == stmt->target()) {
         if (elem.second) {
           block_distance++;
         }
         break;
       } else if (elem.second) {
@@ skipping 14 matching lines @@
       marking_exported = true;
     }
     RECURSE(Visit(stmt->expression()));
     if (!in_function_) {
       marking_exported = false;
     }
   }
 
   void VisitWithStatement(WithStatement* stmt) { UNREACHABLE(); }
 
+  void SetLocalTo(uint16_t index, int value) {
+    current_function_builder_->Emit(kExprSetLocal);
+    AddLeb128(index, true);
+    byte code[] = {WASM_I32(value)};
+    current_function_builder_->EmitCode(code, sizeof(code));
+    block_size_++;
+  }
+
+  void CompileCase(CaseClause* clause, uint16_t fall_through,
+                   VariableProxy* tag) {
+    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;
+    SetLocalTo(fall_through, 1);
+    ZoneList<Statement*>* stmts = clause->statements();
+    block_size_ += stmts->length();
+    RECURSE(VisitStatements(stmts));
+  }
+
   void VisitSwitchStatement(SwitchStatement* stmt) {
-    RECURSE(Visit(stmt->tag()));
+    VariableProxy* tag = stmt->tag()->AsVariableProxy();
+    DCHECK(tag != NULL);
+    BlockVisitor visitor(this, stmt->AsBreakableStatement(), kExprBlock, false);

[bradnelson, 2016/01/12 01:06:43]

I wonder if folding the block_size_ = 0 into the visitor would be more clear.
Everywhere else either does this or sets it explicitly to a count based on what
follows, which amounts to the same thing. (No need in this change).

[aseemgarg, 2016/01/12 01:38:37]

Will take care in next commit

+    block_size_ = 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()) {
-        Expression* label = clause->label();
-        RECURSE(Visit(label));
+        CompileCase(clause, fall_through, tag);
+      } else {
+        ZoneList<Statement*>* stmts = clause->statements();
+        block_size_ += stmts->length();
+        RECURSE(VisitStatements(stmts));
       }
-      ZoneList<Statement*>* stmts = clause->statements();
-      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;
     RECURSE(Visit(stmt->body()));
@@ skipping 769 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