Run ControlReducer early after graph building, then again later.

src/compiler/scheduler.cc

 // Copyright 2013 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 <deque>
 #include <queue>
 
 #include "src/compiler/scheduler.h"
 
 #include "src/compiler/graph.h"
@@ skipping 221 matching lines @@
       control_.push_back(node);
       data->is_connected_control_ = true;
     }
   }
 
 
   void BuildBlocks(Node* node) {
     switch (node->opcode()) {
       case IrOpcode::kLoop:
       case IrOpcode::kMerge:
-      case IrOpcode::kTerminate:
         BuildBlockForNode(node);
         break;
+      case IrOpcode::kTerminate: {
+        // Put Terminate in the loop to which it refers.
+        Node* loop = NodeProperties::GetControlInput(node);
+        BuildBlockForNode(loop);
+        BasicBlock* block = schedule_->block(loop);

[Michael Starzinger, 2014/10/29 12:14:02]

nit: This probably should use the return value of BuildBlockForNode.

[titzer, 2014/10/29 15:17:09]

Done. While doing this I noticed a bug and had to fix the glitch. PTAL.

+        FixNode(block, node);
+        break;
+      }
       case IrOpcode::kBranch:
         BuildBlocksForSuccessors(node, IrOpcode::kIfTrue, IrOpcode::kIfFalse);
         break;
       default:
         break;
     }
   }
 
   void ConnectBlocks(Node* node) {
     switch (node->opcode()) {
       case IrOpcode::kLoop:
       case IrOpcode::kMerge:
         ConnectMerge(node);
         break;
       case IrOpcode::kBranch:
         scheduler_->schedule_root_nodes_.push_back(node);
         ConnectBranch(node);
         break;
       case IrOpcode::kReturn:
         scheduler_->schedule_root_nodes_.push_back(node);
         ConnectReturn(node);
         break;
       default:
         break;
     }
   }
 
-  void BuildBlockForNode(Node* node) {
-    if (schedule_->block(node) == NULL) {
-      BasicBlock* block = schedule_->NewBasicBlock();
+  BasicBlock* BuildBlockForNode(Node* node) {
+    BasicBlock* block = schedule_->block(node);
+    if (block == NULL) {
+      block = schedule_->NewBasicBlock();
       Trace("Create block B%d for #%d:%s\n", block->id().ToInt(), node->id(),
             node->op()->mnemonic());
       FixNode(block, node);
     }
+    return block;
   }
 
   void BuildBlocksForSuccessors(Node* node, IrOpcode::Value a,
                                 IrOpcode::Value b) {
     Node* successors[2];
     CollectSuccessorProjections(node, successors, a, b);
     BuildBlockForNode(successors[0]);
     BuildBlockForNode(successors[1]);
   }
 
@@ skipping 1014 matching lines @@
   start->ReplaceInput(NodeProperties::FirstControlIndex(start), block_start);
 
   Trace("  Connecting floating control start %d:%s to %d:%s\n", start->id(),
         start->op()->mnemonic(), block_start->id(),
         block_start->op()->mnemonic());
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8