Revert "Remove workaround for successors on end block from scheduler."

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/bit-vector.h"
@@ skipping 509 matching lines @@
 // 2. All loops are contiguous in the order (i.e. no intervening blocks that
 //    do not belong to the loop.)
 // Note a simple RPO traversal satisfies (1) but not (2).
 class SpecialRPONumberer : public ZoneObject {
  public:
   SpecialRPONumberer(Zone* zone, Schedule* schedule)
       : zone_(zone),
         schedule_(schedule),
         order_(NULL),
         loops_(zone),
+        beyond_end_(NULL),
         backedges_(1, zone),
         stack_(zone),
         previous_block_count_(0) {}
 
   // Computes the special reverse-post-order for the main control flow graph,
   // that is for the graph spanned between the schedule's start and end blocks.
   void ComputeSpecialRPO() {
-    DCHECK(schedule_->end()->SuccessorCount() == 0);
     DCHECK_EQ(NULL, order_);  // Main order does not exist yet.
-    ComputeAndInsertSpecialRPO(schedule_->start(), schedule_->end());
+    // TODO(mstarzinger): Should use Schedule::end() after tests are fixed.
+    ComputeAndInsertSpecialRPO(schedule_->start(), NULL);
   }
 
   // Computes the special reverse-post-order for a partial control flow graph,
   // that is for the graph spanned between the given {entry} and {end} blocks,
   // then updates the existing ordering with this new information.
   void UpdateSpecialRPO(BasicBlock* entry, BasicBlock* end) {
     DCHECK_NE(NULL, order_);  // Main order to be updated is present.
     ComputeAndInsertSpecialRPO(entry, end);
   }
 
@@ skipping 12 matching lines @@
   }
 
   // Serialize the previously computed order as a special reverse-post-order
   // numbering for basic blocks into the final schedule.
   void SerializeRPOIntoSchedule() {
     int32_t number = 0;
     for (BlockList* l = order_; l != NULL; l = l->next) {
       l->block->set_rpo_number(number++);
       schedule_->rpo_order()->push_back(l->block);
     }
-    if (schedule_->end()->rpo_number() < 0) {
-      schedule_->end()->set_rpo_number(number);
-    }
+    BeyondEndSentinel()->set_rpo_number(number);
   }
 
   // Print and verify the special reverse-post-order.
   void PrintAndVerifySpecialRPO() {
 #if DEBUG
     if (FLAG_trace_turbo_scheduler) PrintRPO();
     VerifySpecialRPO();
 #endif
   }
 
@@ skipping 64 matching lines @@
   // We are hijacking the {ao_number} to enumerate loops temporarily. Note that
   // these numbers are only valid within this class.
   static int GetLoopNumber(BasicBlock* block) { return block->ao_number(); }
   static void SetLoopNumber(BasicBlock* block, int loop_number) {
     return block->set_ao_number(loop_number);
   }
   static bool HasLoopNumber(BasicBlock* block) {
     return block->ao_number() >= 0;
   }
 
+  // TODO(mstarzinger): We only need this special sentinel because some tests
+  // use the schedule's end block in actual control flow (e.g. with end having
+  // successors). Once this has been cleaned up we can use the end block here.
+  BasicBlock* BeyondEndSentinel() {
+    if (beyond_end_ == NULL) {
+      BasicBlock::Id id = BasicBlock::Id::FromInt(-1);
+      beyond_end_ = new (schedule_->zone()) BasicBlock(schedule_->zone(), id);
+    }
+    return beyond_end_;
+  }
+
   // Compute special RPO for the control flow graph between {entry} and {end},
   // mutating any existing order so that the result is still valid.
   void ComputeAndInsertSpecialRPO(BasicBlock* entry, BasicBlock* end) {
     // RPO should not have been serialized for this schedule yet.
     CHECK_EQ(kBlockUnvisited1, schedule_->start()->ao_number());
     CHECK_EQ(kBlockUnvisited1, schedule_->start()->rpo_number());
     CHECK_EQ(0, static_cast<int>(schedule_->rpo_order()->size()));
 
     // Find correct insertion point within existing order.
     BlockList* insert_before = order_->FindForBlock(entry);
@@ skipping 162 matching lines @@
         current_header = current_loop == NULL ? NULL : current_loop->header;
         --loop_depth;
       }
       current->set_loop_header(current_header);
 
       // Push a new loop onto the stack if this loop is a loop header.
       if (HasLoopNumber(current)) {
         ++loop_depth;
         current_loop = &loops_[GetLoopNumber(current)];
         BlockList* end = current_loop->end;
-        current->set_loop_end(end == NULL ? schedule_->end() : end->block);
+        current->set_loop_end(end == NULL ? BeyondEndSentinel() : end->block);
         current_header = current_loop->header;
         Trace("B%d is a loop header, increment loop depth to %d\n",
               current->id().ToInt(), loop_depth);
       }
 
       current->set_loop_depth(loop_depth);
 
       if (current->loop_header() == NULL) {
         Trace("B%d is not in a loop (depth == %d)\n", current->id().ToInt(),
               current->loop_depth());
@@ skipping 149 matching lines @@
       }
       DCHECK(links == count);
     }
   }
 #endif  // DEBUG
 
   Zone* zone_;
   Schedule* schedule_;
   BlockList* order_;
   ZoneVector<LoopInfo> loops_;
+  BasicBlock* beyond_end_;
   ZoneList<Backedge> backedges_;
   ZoneVector<SpecialRPOStackFrame> stack_;
   size_t previous_block_count_;
 };
 
 
 BasicBlockVector* Scheduler::ComputeSpecialRPO(ZonePool* zone_pool,
                                                Schedule* schedule) {
   ZonePool::Scope zone_scope(zone_pool);
   Zone* zone = zone_scope.zone();
@@ skipping 442 matching lines @@
   for (NodeVectorIter i = nodes->begin(); i != nodes->end(); ++i) {
     schedule_->SetBlockForNode(to, *i);
     scheduled_nodes_[to->id().ToSize()].push_back(*i);
   }
   nodes->clear();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8