[Interpreter] Add support for break statements in labelled blocks.

src/interpreter/bytecode-generator.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/interpreter/bytecode-generator.h"
 
 #include "src/ast/scopes.h"
 #include "src/compiler.h"
 #include "src/interpreter/control-flow-builders.h"
 #include "src/objects.h"
@@ skipping 86 matching lines @@
   ControlScope* outer() const { return outer_; }
 
  private:
   BytecodeGenerator* generator_;
   ControlScope* outer_;
 
   DISALLOW_COPY_AND_ASSIGN(ControlScope);
 };
 
 
+// Scoped class for enabling break inside blocks and switch blocks.
+class BytecodeGenerator::ControlScopeForBreakable final
+    : public BytecodeGenerator::ControlScope {
+ public:
+  ControlScopeForBreakable(BytecodeGenerator* generator,
+                           BreakableStatement* statement,
+                           BreakableControlFlowBuilder* control_builder)
+      : ControlScope(generator),
+        statement_(statement),
+        control_builder_(control_builder) {}
+
+ protected:
+  virtual bool Execute(Command command, Statement* statement) {
+    if (statement != statement_) return false;
+    switch (command) {
+      case CMD_BREAK:
+        control_builder_->Break();
+        return true;
+      case CMD_CONTINUE:
+        break;
+    }
+    return false;
+  }
+
+ private:
+  Statement* statement_;
+  BreakableControlFlowBuilder* control_builder_;
+};
+
+
 // Scoped class for enabling 'break' and 'continue' in iteration
 // constructs, e.g. do...while, while..., for...
-class BytecodeGenerator::ControlScopeForIteration
+class BytecodeGenerator::ControlScopeForIteration final
     : public BytecodeGenerator::ControlScope {
  public:
   ControlScopeForIteration(BytecodeGenerator* generator,
                            IterationStatement* statement,
                            LoopBuilder* loop_builder)
       : ControlScope(generator),
         statement_(statement),
         loop_builder_(loop_builder) {}
 
  protected:
   virtual bool Execute(Command command, Statement* statement) {
     if (statement != statement_) return false;
     switch (command) {
       case CMD_BREAK:
         loop_builder_->Break();
         return true;
       case CMD_CONTINUE:
         loop_builder_->Continue();
         return true;
     }
     return false;
   }
 
  private:
   Statement* statement_;
   LoopBuilder* loop_builder_;
 };
 
 
-// Scoped class for enabling 'break' in switch statements.
-class BytecodeGenerator::ControlScopeForSwitch
-    : public BytecodeGenerator::ControlScope {
- public:
-  ControlScopeForSwitch(BytecodeGenerator* generator,
-                        SwitchStatement* statement,
-                        SwitchBuilder* switch_builder)
-      : ControlScope(generator),
-        statement_(statement),
-        switch_builder_(switch_builder) {}
-
- protected:
-  virtual bool Execute(Command command, Statement* statement) {
-    if (statement != statement_) return false;
-    switch (command) {
-      case CMD_BREAK:
-        switch_builder_->Break();
-        return true;
-      case CMD_CONTINUE:
-        break;
-    }
-    return false;
-  }
-
- private:
-  Statement* statement_;
-  SwitchBuilder* switch_builder_;
-};
-
-
 void BytecodeGenerator::ControlScope::PerformCommand(Command command,
                                                      Statement* statement) {
   ControlScope* current = this;
   do {
     if (current->Execute(command, statement)) return;
     current = current->outer();
   } while (current != nullptr);
   UNREACHABLE();
 }
 
@@ skipping 298 matching lines @@
 
   // Visit declarations within the function scope.
   VisitDeclarations(scope()->declarations());
 
   // Visit statements in the function body.
   VisitStatements(info()->literal()->body());
 }
 
 
 void BytecodeGenerator::VisitBlock(Block* stmt) {
+  BlockBuilder block_builder(this->builder());
+  ControlScopeForBreakable execution_control(this, stmt, &block_builder);
+
   if (stmt->scope() == NULL) {
     // Visit statements in the same scope, no declarations.
     VisitStatements(stmt->statements());
   } else {
     // Visit declarations and statements in a block scope.
     if (stmt->scope()->NeedsContext()) {
       VisitNewLocalBlockContext(stmt->scope());
       ContextScope scope(this, stmt->scope());
       VisitDeclarations(stmt->scope()->declarations());
       VisitStatements(stmt->statements());
     } else {
       VisitDeclarations(stmt->scope()->declarations());
       VisitStatements(stmt->statements());
     }
   }
+  if (stmt->labels() != nullptr) block_builder.EndBlock();
 }
 
 
 void BytecodeGenerator::VisitVariableDeclaration(VariableDeclaration* decl) {
   Variable* variable = decl->proxy()->var();
   VariableMode mode = decl->mode();
   // Const and let variables are initialized with the hole so that we can
   // check that they are only assigned once.
   bool hole_init = mode == CONST || mode == CONST_LEGACY || mode == LET;
   switch (variable->location()) {
@@ skipping 166 matching lines @@
 
 
 void BytecodeGenerator::VisitWithStatement(WithStatement* stmt) {
   UNIMPLEMENTED();
 }
 
 
 void BytecodeGenerator::VisitSwitchStatement(SwitchStatement* stmt) {
   ZoneList<CaseClause*>* clauses = stmt->cases();
   SwitchBuilder switch_builder(builder(), clauses->length());
-  ControlScopeForSwitch scope(this, stmt, &switch_builder);
+  ControlScopeForBreakable scope(this, stmt, &switch_builder);
   int default_index = -1;
 
   // Keep the switch value in a register until a case matches.
   Register tag = VisitForRegisterValue(stmt->tag());
 
   // Iterate over all cases and create nodes for label comparison.
   BytecodeLabel done_label;
   for (int i = 0; i < clauses->length(); i++) {
     CaseClause* clause = clauses->at(i);
 
@@ skipping 47 matching lines @@
   } else if (stmt->cond()->ToBooleanIsTrue()) {
     loop_builder.Condition();
     Visit(stmt->body());
     loop_builder.JumpToHeader();
   } else {
     Visit(stmt->body());
     loop_builder.Condition();
     VisitForAccumulatorValue(stmt->cond());
     loop_builder.JumpToHeaderIfTrue();
   }
-  loop_builder.LoopEnd();
+  loop_builder.EndLoop();
 }
 
 
 void BytecodeGenerator::VisitWhileStatement(WhileStatement* stmt) {
   if (stmt->cond()->ToBooleanIsFalse()) {
     // If the condition is false there is no need to generate the loop.
     return;
   }
 
   LoopBuilder loop_builder(builder());
   ControlScopeForIteration execution_control(this, stmt, &loop_builder);
   loop_builder.LoopHeader();
   loop_builder.Condition();
   if (!stmt->cond()->ToBooleanIsTrue()) {
     VisitForAccumulatorValue(stmt->cond());
     loop_builder.BreakIfFalse();
   }
   Visit(stmt->body());
   loop_builder.JumpToHeader();
-  loop_builder.LoopEnd();
+  loop_builder.EndLoop();
 }
 
 
 void BytecodeGenerator::VisitForStatement(ForStatement* stmt) {
   if (stmt->init() != nullptr) {
     Visit(stmt->init());
   }
   if (stmt->cond() && stmt->cond()->ToBooleanIsFalse()) {
     // If the condition is known to be false there is no need to generate
     // body, next or condition blocks. Init block should be generated.
     return;
   }
 
   LoopBuilder loop_builder(builder());
   ControlScopeForIteration execution_control(this, stmt, &loop_builder);
 
   loop_builder.LoopHeader();
   loop_builder.Condition();
   if (stmt->cond() && !stmt->cond()->ToBooleanIsTrue()) {
     VisitForAccumulatorValue(stmt->cond());
     loop_builder.BreakIfFalse();
   }
   Visit(stmt->body());
   if (stmt->next() != nullptr) {
     loop_builder.Next();
     Visit(stmt->next());
   }
   loop_builder.JumpToHeader();
-  loop_builder.LoopEnd();
+  loop_builder.EndLoop();
 }
 
 
 void BytecodeGenerator::VisitForInAssignment(Expression* expr,
                                              FeedbackVectorSlot slot) {
   DCHECK(expr->IsValidReferenceExpression());
 
   // Evaluate assignment starting with the value to be stored in the
   // accumulator.
   Property* property = expr->AsProperty();
@@ skipping 71 matching lines @@
   loop_builder.ContinueIfUndefined();
 
   VisitForInAssignment(stmt->each(), stmt->EachFeedbackSlot());
   Visit(stmt->body());
 
   // TODO(oth): replace CountOperation here with ForInStep.
   loop_builder.Next();
   builder()->LoadAccumulatorWithRegister(index).CountOperation(
       Token::Value::ADD, language_mode_strength());
   loop_builder.JumpToHeader();
-  loop_builder.LoopEnd();
+  loop_builder.EndLoop();
 }
 
 
 void BytecodeGenerator::VisitForOfStatement(ForOfStatement* stmt) {
   UNIMPLEMENTED();
 }
 
 
 void BytecodeGenerator::VisitTryCatchStatement(TryCatchStatement* stmt) {
   if (FLAG_ignition_fake_try_catch) {
@@ skipping 1290 matching lines @@
 }
 
 
 int BytecodeGenerator::feedback_index(FeedbackVectorSlot slot) const {
   return info()->feedback_vector()->GetIndex(slot);
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8