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->nodes_.size()) - 1;
     if (node == block->control_input_) return true;
   }
   return false;
 }
 
 
+static bool Dominates(Schedule* schedule, Node* dominator, Node* dominee) {

[titzer, 2014/09/25 12:19:24]

You should walk up the dominator tree and very the dominator is in that chain.
It's not enough to just have an RPO number that is lower.

[titzer, 2014/09/26 10:44:38]

BTW can you split this check out into a separate CL and land it? It'd be nice to
have right away.

[sigurds, 2014/09/26 11:35:24]

Done.

+  return schedule->block(dominator)->rpo_number_ <=
+         schedule->block(dominee)->rpo_number_;
+}
+
+
 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->nodes_.size()) - 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(), j, input->id(),
                input->op()->mnemonic());
     }
   }
+  if (OperatorProperties::GetControlInputCount(node->op()) == 1) {
+    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 int count = schedule->BasicBlockCount();
   Zone tmp_zone(schedule->zone()->isolate());
   Zone* zone = &tmp_zone;
   BasicBlock* start = schedule->start();
   BasicBlockVector* rpo_order = schedule->rpo_order();
 
@@ skipping 144 matching lines @@
     // Check inputs for all nodes in the block.
     for (size_t i = 0; i < block->nodes_.size(); i++) {
       Node* node = block->nodes_[i];
       CheckInputsDominate(schedule, block, node, static_cast<int>(i) - 1);
     }
   }
 }
 }
 }
 }  // namespace v8::internal::compiler