Change the translation of break/continue into Hydrogen.

src/hydrogen.h

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 178 matching lines @@
   HBasicBlock* loop_header_;
   ZoneList<HBasicBlock*> blocks_;
 };
 
 
 class HSubgraph: public ZoneObject {
  public:
   explicit HSubgraph(HGraph* graph)
       : graph_(graph),
         entry_block_(NULL),
-        exit_block_(NULL),
-        break_continue_info_(4) {
+        exit_block_(NULL) {
   }
 
   HGraph* graph() const { return graph_; }
   HEnvironment* environment() const {
     ASSERT(HasExit());
     return exit_block_->last_environment();
   }
 
   bool HasExit() const { return exit_block_ != NULL; }
 
   void PreProcessOsrEntry(IterationStatement* statement);
 
   void AppendJoin(HSubgraph* then_graph, HSubgraph* else_graph, AstNode* node);
   void AppendWhile(HSubgraph* condition,
                    HSubgraph* body,
                    IterationStatement* statement,
                    HSubgraph* continue_subgraph,
-                   HSubgraph* exit);
+                   HSubgraph* exit,
+                   HBasicBlock* break_block);
   void AppendDoWhile(HSubgraph* body,
                      IterationStatement* statement,
                      HSubgraph* go_back,
-                     HSubgraph* exit);
-  void AppendEndless(HSubgraph* body, IterationStatement* statement);
-  void Append(HSubgraph* next, BreakableStatement* statement);
-  void ResolveContinue(IterationStatement* statement);
-  HBasicBlock* BundleBreak(BreakableStatement* statement);
-  HBasicBlock* BundleContinue(IterationStatement* statement);
-  HBasicBlock* BundleBreakContinue(BreakableStatement* statement,
-                                   bool is_continue,
-                                   int join_id);
+                     HSubgraph* exit,
+                     HBasicBlock* break_block);
+  void AppendEndless(HSubgraph* body,
+                     IterationStatement* statement,
+                     HBasicBlock* break_block);
+  void Append(HSubgraph* next,
+              BreakableStatement* stmt,
+              HBasicBlock* break_block);
+  void ResolveContinue(IterationStatement* statement,
+                       HBasicBlock* continue_block);
   HBasicBlock* JoinBlocks(HBasicBlock* a, HBasicBlock* b, int id);
 
   void FinishExit(HControlInstruction* instruction);
-  void FinishBreakContinue(BreakableStatement* target, bool is_continue);
   void Initialize(HBasicBlock* block) {
     ASSERT(entry_block_ == NULL);
     entry_block_ = block;
     exit_block_ = block;
   }
   HBasicBlock* entry_block() const { return entry_block_; }
   HBasicBlock* exit_block() const { return exit_block_; }
   void set_exit_block(HBasicBlock* block) {
     exit_block_ = block;
   }
 
   void ConnectExitTo(HBasicBlock* other, bool include_stack_check = false) {
     if (HasExit()) {
       exit_block()->Goto(other, include_stack_check);
     }
   }
 
-  void AddBreakContinueInfo(HSubgraph* other) {
-    break_continue_info_.AddAll(other->break_continue_info_);
-  }
-
  protected:
-  class BreakContinueInfo: public ZoneObject {
-   public:
-    BreakContinueInfo(BreakableStatement* target, HBasicBlock* block,
-                      bool is_continue)
-      : target_(target), block_(block), continue_(is_continue) {}
-    BreakableStatement* target() const { return target_; }
-    HBasicBlock* block() const { return block_; }
-    bool is_continue() const { return continue_; }
-    bool IsResolved() const { return block_ == NULL; }
-    void Resolve() { block_ = NULL; }
-
-   private:
-    BreakableStatement* target_;
-    HBasicBlock* block_;
-    bool continue_;
-  };
-
-  const ZoneList<BreakContinueInfo*>* break_continue_info() const {
-    return &break_continue_info_;
-  }
-
   HGraph* graph_;  // The graph this is a subgraph of.
   HBasicBlock* entry_block_;
   HBasicBlock* exit_block_;
-
- private:
-  ZoneList<BreakContinueInfo*> break_continue_info_;
 };
 
 
 class HGraph: public HSubgraph {
  public:
   explicit HGraph(CompilationInfo* info);
 
   CompilationInfo* info() const { return info_; }
 
   bool AllowCodeMotion() const;
@@ skipping 317 matching lines @@
   // control flow.
   void BuildBranch(HValue* value);
 
   HBasicBlock* if_true_;
   HBasicBlock* if_false_;
 };
 
 
 class HGraphBuilder: public AstVisitor {
  public:
+  enum BreakType { BREAK, CONTINUE };
+
+  // A (lazily-allocated) break and continue block for a breakable
+  // statement.
+  class BreakAndContinueInfo BASE_EMBEDDED {
+   public:
+    explicit BreakAndContinueInfo(BreakableStatement* target)
+      : target_(target), break_block_(NULL), continue_block_(NULL) {
+    }
+
+    BreakableStatement* target() { return target_; }
+    HBasicBlock* break_block() { return break_block_; }
+    void set_break_block(HBasicBlock* block) { break_block_ = block; }
+    HBasicBlock* continue_block() { return continue_block_; }
+    void set_continue_block(HBasicBlock* block) { continue_block_ = block; }
+
+   private:
+    BreakableStatement* target_;
+    HBasicBlock* break_block_;
+    HBasicBlock* continue_block_;
+  };
+
+  // A helper class to maintain a stack of current BreakAndContinueInfo
+  // structures mirroring BreakableStatement nesting.
+  class BreakStackEntry BASE_EMBEDDED {

[Mads Ager (chromium), 2011/02/22 08:18:58]

Why is the stack separate from the BreakAndContinueInfo? Can't the break and
continue infos themselves form the stack instead of having an extra structure
for that? When we use these scoping structures elsewhere in the VM we call the
SomethingOrOtherScope. We could call this a BreakAndContinueScope.

+   public:
+    BreakStackEntry(BreakAndContinueInfo* info, HGraphBuilder* owner)
+        : info_(info), owner_(owner), next_(owner->break_stack()) {
+      owner->set_break_stack(this);
+    }
+
+    ~BreakStackEntry() { owner_->set_break_stack(next_); }
+
+    BreakAndContinueInfo* info() { return info_; }
+    HGraphBuilder* owner() { return owner_; }
+    BreakStackEntry* next() { return next_; }
+
+    // Search the break stack for a break or continue target.
+    HBasicBlock* Get(BreakableStatement* stmt, BreakType type);
+
+   private:
+    BreakAndContinueInfo* info_;
+    HGraphBuilder* owner_;
+    BreakStackEntry* next_;
+  };
+
   explicit HGraphBuilder(TypeFeedbackOracle* oracle)
       : oracle_(oracle),
         graph_(NULL),
         current_subgraph_(NULL),
         peeled_statement_(NULL),
         ast_context_(NULL),
         call_context_(NULL),
         function_return_(NULL),
-        inlined_count_(0) { }
+        inlined_count_(0),
+        break_stack_(NULL) {
+  }
 
   HGraph* CreateGraph(CompilationInfo* info);
 
   // Simple accessors.
   HGraph* graph() const { return graph_; }
   HSubgraph* subgraph() const { return current_subgraph_; }
+  BreakStackEntry* break_stack() const { return break_stack_; }
+  void set_break_stack(BreakStackEntry* head) { break_stack_ = head; }
 
   HEnvironment* environment() const { return subgraph()->environment(); }
   HBasicBlock* CurrentBlock() const { return subgraph()->exit_block(); }
 
   // Adding instructions.
   HInstruction* AddInstruction(HInstruction* instr);
   void AddSimulate(int id);
 
   // Bailout environment manipulation.
   void Push(HValue* value) { environment()->Push(value); }
@@ skipping 30 matching lines @@
 
   INLINE_FUNCTION_LIST(INLINE_FUNCTION_GENERATOR_DECLARATION)
   INLINE_RUNTIME_FUNCTION_LIST(INLINE_FUNCTION_GENERATOR_DECLARATION)
 #undef INLINE_FUNCTION_GENERATOR_DECLARATION
 
   void Bailout(const char* reason);
 
   void AppendPeeledWhile(IterationStatement* stmt,
                          HSubgraph* cond_graph,
                          HSubgraph* body_graph,
-                         HSubgraph* exit_graph);
+                         HSubgraph* exit_graph,
+                         HBasicBlock* break_block);
 
   void AddToSubgraph(HSubgraph* graph, ZoneList<Statement*>* stmts);
   void AddToSubgraph(HSubgraph* graph, Statement* stmt);
   void AddToSubgraph(HSubgraph* graph, Expression* expr);
 
   HValue* Top() const { return environment()->Top(); }
   void Drop(int n) { environment()->Drop(n); }
   void Bind(Variable* var, HValue* value) { environment()->Bind(var, value); }
 
   void VisitForValue(Expression* expr);
@@ skipping 151 matching lines @@
   // inlined. NULL when not inlining.
   AstContext* call_context_;
 
   // When inlining a call in an effect or value context, the return
   // block. NULL otherwise. When inlining a call in a test context, there
   // are a pair of target blocks in the call context.
   HBasicBlock* function_return_;
 
   int inlined_count_;
 
+  BreakStackEntry* break_stack_;
+
   friend class AstContext;  // Pushes and pops the AST context stack.
 
   DISALLOW_COPY_AND_ASSIGN(HGraphBuilder);
 };
 
 
 class HValueMap: public ZoneObject {
  public:
   HValueMap()
       : array_size_(0),
@@ skipping 200 matching lines @@
   const char* filename_;
   HeapStringAllocator string_allocator_;
   StringStream trace_;
   int indent_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_H_