[turbofan] Optimize certain chains of Branch into a Switch.

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 "src/compiler/scheduler.h"
 
 #include "src/bit-vector.h"
 #include "src/compiler/common-operator.h"
 #include "src/compiler/control-equivalence.h"
 #include "src/compiler/graph.h"
@@ skipping 355 matching lines @@
   void BuildBlocksForSuccessors(Node* node) {
     size_t const successor_count = node->op()->ControlOutputCount();
     Node** successors = zone_->NewArray<Node*>(successor_count);
     CollectSuccessorProjections(node, successors, successor_count);
     for (size_t index = 0; index < successor_count; ++index) {
       BuildBlockForNode(successors[index]);
     }
   }
 
   // Collect the branch-related projections from a node, such as IfTrue,
-  // IfFalse, and Case.
+  // IfFalse, Case and Default.
   void CollectSuccessorProjections(Node* node, Node** successors,
                                    size_t successor_count) {
 #ifdef DEBUG
     DCHECK_EQ(static_cast<int>(successor_count), node->UseCount());
     std::memset(successors, 0, sizeof(*successors) * successor_count);
 #endif
+    size_t const kDefaultIndex = successor_count - 1;
+    size_t const kIfFalseIndex = 1;

[Michael Starzinger, 2015/02/17 12:23:35]

Can we just inline these values below as it was before? IMHO that was more
readable.

[Benedikt Meurer, 2015/02/17 12:30:38]

Done.

+    size_t const kIfTrueIndex = 0;
+    size_t if_value_index = 0;
     for (Node* const use : node->uses()) {
       size_t index;
       switch (use->opcode()) {
         default:
           UNREACHABLE();
         // Fall through.
         case IrOpcode::kIfTrue:
           DCHECK_EQ(IrOpcode::kBranch, node->opcode());
-          index = 0;
+          index = kIfTrueIndex;
           break;
         case IrOpcode::kIfFalse:
           DCHECK_EQ(IrOpcode::kBranch, node->opcode());
-          index = 1;
+          index = kIfFalseIndex;
           break;
-        case IrOpcode::kCase:
+        case IrOpcode::kIfValue:
           DCHECK_EQ(IrOpcode::kSwitch, node->opcode());
-          index = CaseIndexOf(use->op());
+          DCHECK_LT(if_value_index, kDefaultIndex);
+          index = if_value_index++;
+          break;
+        case IrOpcode::kIfDefault:
+          DCHECK_EQ(IrOpcode::kSwitch, node->opcode());
+          index = kDefaultIndex;
           break;
       }
       DCHECK_LT(index, successor_count);
-      DCHECK(successors[index] == nullptr);
+      DCHECK_NULL(successors[index]);
       successors[index] = use;
     }
 #ifdef DEBUG
     for (size_t index = 0; index < successor_count; ++index) {
       DCHECK_NOT_NULL(successors[index]);
     }
 #endif
   }
 
   void CollectSuccessorBlocks(Node* node, BasicBlock** successor_blocks,
@@ skipping 1234 matching lines @@
   for (Node* const node : *nodes) {
     schedule_->SetBlockForNode(to, node);
     scheduled_nodes_[to->id().ToSize()].push_back(node);
   }
   nodes->clear();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8