Revert "Fix scheduler to correctly schedule nested diamonds."

src/compiler/verifier.cc

 // Copyright 2014 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/verifier.h"
 
 #include <deque>
 #include <queue>
 
 #include "src/compiler/generic-algorithm.h"
@@ skipping 253 matching lines @@
     }
     block = block->dominator();
     if (block == NULL) break;
     use_pos = static_cast<int>(block->NodeCount()) - 1;
     if (node == block->control_input()) return true;
   }
   return false;
 }
 
 
-static bool Dominates(Schedule* schedule, Node* dominator, Node* dominatee) {
-  BasicBlock* dom = schedule->block(dominator);
-  BasicBlock* sub = schedule->block(dominatee);
-  while (sub != NULL) {
-    if (sub == dom) {
-      return true;
-    }
-    sub = sub->dominator();
-  }
-  return false;
-}
-
-
 static void CheckInputsDominate(Schedule* schedule, BasicBlock* block,
                                 Node* node, int use_pos) {
   for (int j = OperatorProperties::GetValueInputCount(node->op()) - 1; j >= 0;
        j--) {
     BasicBlock* use_block = block;
     if (node->opcode() == IrOpcode::kPhi) {
       use_block = use_block->PredecessorAt(j);
       use_pos = static_cast<int>(use_block->NodeCount()) - 1;
     }
     Node* input = node->InputAt(j);
     if (!HasDominatingDef(schedule, node->InputAt(j), block, use_block,
                           use_pos)) {
       V8_Fatal(__FILE__, __LINE__,
                "Node #%d:%s in B%d is not dominated by input@%d #%d:%s",
                node->id(), node->op()->mnemonic(), block->id().ToInt(), j,
                input->id(), input->op()->mnemonic());
     }
   }
-  // Ensure that nodes are dominated by their control inputs;
-  // kEnd is an exception, as unreachable blocks resulting from kMerge
-  // are not in the RPO.
-  if (OperatorProperties::GetControlInputCount(node->op()) == 1 &&
-      node->opcode() != IrOpcode::kEnd) {
-    Node* ctl = NodeProperties::GetControlInput(node);
-    if (!Dominates(schedule, ctl, node)) {
-      V8_Fatal(__FILE__, __LINE__,
-               "Node #%d:%s in B%d is not dominated by control input #%d:%s",
-               node->id(), node->op()->mnemonic(), block->id(), ctl->id(),
-               ctl->op()->mnemonic());
-    }
-  }
 }
 
 
 void ScheduleVerifier::Run(Schedule* schedule) {
   const size_t count = schedule->BasicBlockCount();
   Zone tmp_zone(schedule->zone()->isolate());
   Zone* zone = &tmp_zone;
   BasicBlock* start = schedule->start();
   BasicBlockVector* rpo_order = schedule->rpo_order();
 
@@ skipping 146 matching lines @@
     // Check inputs for all nodes in the block.
     for (size_t i = 0; i < block->NodeCount(); i++) {
       Node* node = block->NodeAt(i);
       CheckInputsDominate(schedule, block, node, static_cast<int>(i) - 1);
     }
   }
 }
 }
 }
 }  // namespace v8::internal::compiler