Add do-while and conditional and mark non asm nodes as unreachable

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 167 matching lines @@
       current_function_builder_->Emit(kExprReturn);
     } else {
       marking_exported = true;
     }
     RECURSE(Visit(stmt->expression()));
     if (!in_function_) {
       marking_exported = false;
     }
   }
 
-  void VisitWithStatement(WithStatement* stmt) {
-    RECURSE(stmt->expression());
-    RECURSE(stmt->statement());
-  }
+  void VisitWithStatement(WithStatement* stmt) { UNREACHABLE(); }
 
   void VisitSwitchStatement(SwitchStatement* stmt) {
     RECURSE(Visit(stmt->tag()));
 
     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));
       }
       ZoneList<Statement*>* stmts = clause->statements();
       RECURSE(VisitStatements(stmts));
     }
   }
 
   void VisitCaseClause(CaseClause* clause) { UNREACHABLE(); }
 
   void VisitDoWhileStatement(DoWhileStatement* stmt) {
+    DCHECK(in_function_);
+    current_function_builder_->Emit(kExprLoop);
+    uint32_t index = current_function_builder_->EmitEditableImmediate(0);
+    int prev_block_size = block_size_;
+    block_size_ = 0;
+    breakable_blocks_.push_back(
+        std::make_pair(stmt->AsBreakableStatement(), true));
+    block_size_++;
     RECURSE(Visit(stmt->body()));
+    block_size_++;
+    current_function_builder_->Emit(kExprIf);
     RECURSE(Visit(stmt->cond()));
+    current_function_builder_->EmitWithU8(kExprBr, 0);
+    current_function_builder_->Emit(kExprNop);
+    current_function_builder_->EditImmediate(index, block_size_);
+    block_size_ = prev_block_size;
+    breakable_blocks_.pop_back();
   }
 
   void VisitWhileStatement(WhileStatement* stmt) {
     DCHECK(in_function_);
     current_function_builder_->EmitWithU8(kExprLoop, 1);
     breakable_blocks_.push_back(
         std::make_pair(stmt->AsBreakableStatement(), true));
     current_function_builder_->Emit(kExprIf);
     RECURSE(Visit(stmt->cond()));
     current_function_builder_->EmitWithU8(kExprBr, 0);
@@ skipping 30 matching lines @@
       RECURSE(Visit(stmt->next()));
     }
     block_size_++;
     current_function_builder_->EmitWithU8(kExprBr, 0);
     current_function_builder_->Emit(kExprNop);
     current_function_builder_->EditImmediate(index, block_size_);
     block_size_ = prev_block_size;
     breakable_blocks_.pop_back();
   }
 
-  void VisitForInStatement(ForInStatement* stmt) {
-    RECURSE(Visit(stmt->enumerable()));
-    RECURSE(Visit(stmt->body()));
-  }
+  void VisitForInStatement(ForInStatement* stmt) { UNREACHABLE(); }
 
-  void VisitForOfStatement(ForOfStatement* stmt) {
-    RECURSE(Visit(stmt->iterable()));
-    RECURSE(Visit(stmt->body()));
-  }
+  void VisitForOfStatement(ForOfStatement* stmt) { UNREACHABLE(); }
 
-  void VisitTryCatchStatement(TryCatchStatement* stmt) {
-    RECURSE(Visit(stmt->try_block()));
-    RECURSE(Visit(stmt->catch_block()));
-  }
+  void VisitTryCatchStatement(TryCatchStatement* stmt) { UNREACHABLE(); }
 
-  void VisitTryFinallyStatement(TryFinallyStatement* stmt) {
-    RECURSE(Visit(stmt->try_block()));
-    RECURSE(Visit(stmt->finally_block()));
-  }
+  void VisitTryFinallyStatement(TryFinallyStatement* stmt) { UNREACHABLE(); }
 
-  void VisitDebuggerStatement(DebuggerStatement* stmt) {}
+  void VisitDebuggerStatement(DebuggerStatement* stmt) { UNREACHABLE(); }
 
   void VisitFunctionLiteral(FunctionLiteral* expr) {
     Scope* scope = expr->scope();
     if (in_function_) {
       if (expr->bounds().lower->IsFunction()) {
         Type::FunctionType* func_type = expr->bounds().lower->AsFunction();
         LocalType return_type = TypeFrom(func_type->Result());
         current_function_builder_->ReturnType(return_type);
         for (int i = 0; i < expr->parameter_count(); i++) {
           LocalType type = TypeFrom(func_type->Parameter(i));
           DCHECK(type != kAstStmt);
           LookupOrInsertLocal(scope->parameter(i), type);
         }
       } else {
         UNREACHABLE();
       }
     }
     RECURSE(VisitDeclarations(scope->declarations()));
     RECURSE(VisitStatements(expr->body()));
   }
 
-  void VisitNativeFunctionLiteral(NativeFunctionLiteral* expr) {}
+  void VisitNativeFunctionLiteral(NativeFunctionLiteral* expr) {
+    UNREACHABLE();
+  }
 
   void VisitConditional(Conditional* expr) {
+    DCHECK(in_function_);
+    current_function_builder_->Emit(kExprIfElse);
     RECURSE(Visit(expr->condition()));
     RECURSE(Visit(expr->then_expression()));
     RECURSE(Visit(expr->else_expression()));
   }
 
   void VisitVariableProxy(VariableProxy* expr) {
     if (in_function_) {
       Variable* var = expr->var();
       if (var->is_function()) {
         DCHECK(!is_set_op_);
@@ skipping 56 matching lines @@
             current_function_builder_->EmitCode(code, sizeof(code));
             break;
           }
           default:
             UNREACHABLE();
         }
       }
     }
   }
 
-  void VisitRegExpLiteral(RegExpLiteral* expr) {}
+  void VisitRegExpLiteral(RegExpLiteral* expr) { UNREACHABLE(); }
 
   void VisitObjectLiteral(ObjectLiteral* expr) {
     ZoneList<ObjectLiteralProperty*>* props = expr->properties();
     for (int i = 0; i < props->length(); ++i) {
       ObjectLiteralProperty* prop = props->at(i);
       RECURSE(Visit(prop->value()));
     }
   }
 
-  void VisitArrayLiteral(ArrayLiteral* expr) {
-    ZoneList<Expression*>* values = expr->values();
-    for (int i = 0; i < values->length(); ++i) {
-      Expression* value = values->at(i);
-      RECURSE(Visit(value));
-    }
-  }
+  void VisitArrayLiteral(ArrayLiteral* expr) { UNREACHABLE(); }
 
   void LoadInitFunction() {
     if (!init_function_initialized) {
       init_function_initialized = true;
       unsigned char init[] = "__init__";
       init_function_index = builder_->AddFunction(init, 8);
       current_function_builder_ = builder_->FunctionAt(init_function_index);
       current_function_builder_->ReturnType(kAstStmt);
       current_function_builder_->Exported(1);
       in_function_ = true;
@@ skipping 31 matching lines @@
     }
     is_set_op_ = true;
     RECURSE(Visit(expr->target()));
     DCHECK(!is_set_op_);
     RECURSE(Visit(expr->value()));
     if (in_init) {
       UnLoadInitFunction();
     }
   }
 
-  void VisitYield(Yield* expr) {
-    RECURSE(Visit(expr->generator_object()));
-    RECURSE(Visit(expr->expression()));
-  }
+  void VisitYield(Yield* expr) { UNREACHABLE(); }
 
-  void VisitThrow(Throw* expr) { RECURSE(Visit(expr->exception())); }
+  void VisitThrow(Throw* expr) { UNREACHABLE(); }
 
   void VisitProperty(Property* expr) {
     Expression* obj = expr->obj();
     DCHECK(obj->bounds().lower == obj->bounds().upper);
     TypeImpl<ZoneTypeConfig>* type = obj->bounds().lower;
     MachineType mtype;
     int size;
     if (type->Is(cache_.kUint8Array)) {
       mtype = MachineType::Uint8();
       size = 1;
@@ skipping 84 matching lines @@
         DCHECK(TypeOf(expr->expression()) == kAstI32);
         current_function_builder_->Emit(kExprBoolNot);
         break;
       }
       default:
         UNREACHABLE();
     }
     RECURSE(Visit(expr->expression()));
   }
 
-  void VisitCountOperation(CountOperation* expr) {
-    RECURSE(Visit(expr->expression()));
-  }
+  void VisitCountOperation(CountOperation* expr) { UNREACHABLE(); }
 
   bool MatchIntBinaryOperation(BinaryOperation* expr, Token::Value op,
                                int32_t val) {
     DCHECK(expr->right() != NULL);
     if (expr->op() == op && expr->right()->IsLiteral() &&
         TypeOf(expr) == kAstI32) {
       Literal* right = expr->right()->AsLiteral();
       DCHECK(right->raw_value()->IsNumber());
       if (static_cast<int32_t>(right->raw_value()->AsNumber()) == val) {
         return true;
@@ skipping 282 matching lines @@
       UNREACHABLE();
       return kInt32;
     }
   }
 
 #undef CASE
 #undef NON_SIGNED_INT
 #undef SIGNED
 #undef NON_SIGNED
 
-  void VisitThisFunction(ThisFunction* expr) {}
+  void VisitThisFunction(ThisFunction* expr) { UNREACHABLE(); }
 
   void VisitDeclarations(ZoneList<Declaration*>* decls) {
     for (int i = 0; i < decls->length(); ++i) {
       Declaration* decl = decls->at(i);
       RECURSE(Visit(decl));
     }
   }
 
-  void VisitClassLiteral(ClassLiteral* expr) {}
+  void VisitClassLiteral(ClassLiteral* expr) { UNREACHABLE(); }
 
-  void VisitSpread(Spread* expr) {}
+  void VisitSpread(Spread* expr) { UNREACHABLE(); }
 
-  void VisitSuperPropertyReference(SuperPropertyReference* expr) {}
+  void VisitSuperPropertyReference(SuperPropertyReference* expr) {
+    UNREACHABLE();
+  }
 
-  void VisitSuperCallReference(SuperCallReference* expr) {}
+  void VisitSuperCallReference(SuperCallReference* expr) { UNREACHABLE(); }
 
-  void VisitSloppyBlockFunctionStatement(SloppyBlockFunctionStatement* expr) {}
+  void VisitSloppyBlockFunctionStatement(SloppyBlockFunctionStatement* expr) {
+    UNREACHABLE();
+  }
 
-  void VisitDoExpression(DoExpression* expr) {}
+  void VisitDoExpression(DoExpression* expr) { UNREACHABLE(); }
 
   void VisitRewritableAssignmentExpression(
-      RewritableAssignmentExpression* expr) {}
+      RewritableAssignmentExpression* expr) {
+    UNREACHABLE();
+  }
 
   struct IndexContainer : public ZoneObject {
     uint16_t index;
   };
 
   uint16_t LookupOrInsertLocal(Variable* v, LocalType type) {
     DCHECK(current_function_builder_ != NULL);
     ZoneHashMap::Entry* entry =
         local_variables_.Lookup(v, ComputePointerHash(v));
     if (entry == NULL) {
@@ skipping 92 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