[turbofan] Propagate "deferredness" to dominated basic blocks.

src/compiler/scheduler.cc

Index: src/compiler/scheduler.cc
diff --git a/src/compiler/scheduler.cc b/src/compiler/scheduler.cc
index 1599152f95f47dfa557882b735e0d0357044a0c0..72b0c61dfca06ab401fc5116b4e8048558c10a51 100644
--- a/src/compiler/scheduler.cc
+++ b/src/compiler/scheduler.cc
@@ -422,8 +422,6 @@ class CFGBuilder {
                            IrOpcode::kIfFalse);
 
     // Consider branch hints.
-    // TODO(turbofan): Propagate the deferred flag to all blocks dominated by
-    // this IfTrue/IfFalse later.
     switch (BranchHintOf(branch->op())) {
       case BranchHint::kNone:
         break;
@@ -534,6 +532,18 @@ class SpecialRPONumberer {
   SpecialRPONumberer(Zone* zone, Schedule* schedule)
       : zone_(zone), schedule_(schedule) {}
 
+  void ComputeAssemblyOrder() {

[Michael Starzinger, 2014/11/05 10:06:09]

There is a call to this method missing for the normal scheduler pipeline, the
two calls below only cover the side-channel for the raw machine assembler and
the floating control fusion.

+    // Compute the assembly order (non-deferred code first, deferred code
+    // afterwards).
+    int32_t number = 0;
+    for (auto const block : *schedule_->rpo_order()) {
+      if (!block->deferred()) block->set_ao_number(number++);
+    }
+    for (auto const block : *schedule_->rpo_order()) {
+      if (block->deferred()) block->set_ao_number(number++);
+    }
+  }
+
   void ComputeSpecialRPO() {
     // RPO should not have been computed for this schedule yet.
     CHECK_EQ(kBlockUnvisited1, schedule_->start()->rpo_number());
@@ -723,18 +733,6 @@ class SpecialRPONumberer {
       }
     }
 
-    // Compute the assembly order (non-deferred code first, deferred code
-    // afterwards).
-    int32_t number = 0;
-    for (auto block : *final_order) {
-      if (block->deferred()) continue;
-      block->set_ao_number(number++);
-    }
-    for (auto block : *final_order) {
-      if (!block->deferred()) continue;
-      block->set_ao_number(number++);
-    }
-
 #if DEBUG
     if (FLAG_trace_turbo_scheduler) PrintRPO(num_loops, loops, final_order);
     VerifySpecialRPO(num_loops, loops, final_order);
@@ -768,6 +766,7 @@ class SpecialRPONumberer {
     void Serialize(BasicBlockVector* final_order) {
       for (BlockList* l = this; l != NULL; l = l->next) {
         l->block->set_rpo_number(static_cast<int>(final_order->size()));
+        l->block->set_ao_number(static_cast<int>(final_order->size()));

[Michael Starzinger, 2014/11/05 10:06:09]

This gives you the RPO numbers, not the AO numbers.

         final_order->push_back(l->block);
       }
     }
@@ -958,6 +957,7 @@ BasicBlockVector* Scheduler::ComputeSpecialRPO(ZonePool* zone_pool,
 
   SpecialRPONumberer numberer(zone, schedule);
   numberer.ComputeSpecialRPO();
+  numberer.ComputeAssemblyOrder();
   return schedule->rpo_order();
 }
 
@@ -998,6 +998,8 @@ void Scheduler::GenerateImmediateDominatorTree() {
       current_rpo->set_dominator(dominator);
       Trace("Block %d's idom is %d\n", current_rpo->id().ToInt(),
             dominator->id().ToInt());
+      // Propagate "deferredness" of the dominator.
+      if (dominator->deferred()) current_rpo->set_deferred(true);
     }
   }
 }
@@ -1344,6 +1346,7 @@ void Scheduler::FuseFloatingControl(BasicBlock* block, Node* node) {
   BasicBlockVector* rpo = schedule_->rpo_order();
   for (BasicBlockVectorIter i = rpo->begin(); i != rpo->end(); ++i) {
     BasicBlock* block = *i;
+    block->set_ao_number(-1);
     block->set_rpo_number(-1);
     block->set_loop_header(NULL);
     block->set_loop_depth(0);
@@ -1353,6 +1356,7 @@ void Scheduler::FuseFloatingControl(BasicBlock* block, Node* node) {
   SpecialRPONumberer numberer(zone_, schedule_);
   numberer.ComputeSpecialRPO();
   GenerateImmediateDominatorTree();
+  numberer.ComputeAssemblyOrder();
   scheduled_nodes_.resize(schedule_->BasicBlockCount(), NodeVector(zone_));
 
   // Move previously planned nodes.