Finish TODO in Schedule. s/entry/start/g and s/exit/end/g to be more regular.

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/compiler/graph.h"
 #include "src/compiler/graph-inl.h"
 #include "src/compiler/node.h"
 #include "src/compiler/node-properties.h"
@@ skipping 114 matching lines @@
  private:
   Scheduler* scheduler_;
 };
 
 
 void Scheduler::CreateBlocks() {
   CreateBlockVisitor create_blocks(this);
   if (FLAG_trace_turbo_scheduler) {
     PrintF("---------------- CREATING BLOCKS ------------------\n");
   }
-  schedule_->AddNode(schedule_->entry(), graph_->start());
+  schedule_->AddNode(schedule_->start(), graph_->start());
   graph_->VisitNodeInputsFromEnd(&create_blocks);
 }
 
 
 void Scheduler::WireBlocks() {
   if (FLAG_trace_turbo_scheduler) {
     PrintF("----------------- WIRING BLOCKS -------------------\n");
   }
   AddSuccessorsForBranches();
   AddSuccessorsForReturns();
@@ skipping 179 matching lines @@
 
 
 void Scheduler::GenerateImmediateDominatorTree() {
   // Build the dominator graph.  TODO(danno): consider using Lengauer & Tarjan's
   // if this becomes really slow.
   if (FLAG_trace_turbo_scheduler) {
     PrintF("------------ IMMEDIATE BLOCK DOMINATORS -----------\n");
   }
   for (size_t i = 0; i < schedule_->rpo_order_.size(); i++) {
     BasicBlock* current_rpo = schedule_->rpo_order_[i];
-    if (current_rpo != schedule_->entry()) {
+    if (current_rpo != schedule_->start()) {
       BasicBlock::Predecessors::iterator current_pred =
           current_rpo->predecessors().begin();
       BasicBlock::Predecessors::iterator end =
           current_rpo->predecessors().end();
       DCHECK(current_pred != end);
       BasicBlock* dominator = *current_pred;
       ++current_pred;
       // For multiple predecessors, walk up the rpo ordering until a common
       // dominator is found.
       int current_rpo_pos = GetRPONumber(current_rpo);
@@ skipping 109 matching lines @@
     // to schedule them.
     if (!schedule_->IsScheduled(node) &&
         scheduler_->HasFixedSchedulePosition(node)) {
       if (FLAG_trace_turbo_scheduler) {
         PrintF("Fixed position node %d is unscheduled, scheduling now\n",
                node->id());
       }
       IrOpcode::Value opcode = node->opcode();
       BasicBlock* block =
           opcode == IrOpcode::kParameter
-              ? schedule_->entry()
+              ? schedule_->start()
               : schedule_->block(NodeProperties::GetControlInput(node));
       DCHECK(block != NULL);
       schedule_->AddNode(block, node);
     }
 
     if (scheduler_->IsScheduleRoot(node)) {
       scheduler_->schedule_root_nodes_.push_back(node);
     }
 
     return GenericGraphVisit::CONTINUE;
@@ skipping 386 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 (3).
 BasicBlockVector* Scheduler::ComputeSpecialRPO(Schedule* schedule) {
   Zone tmp_zone(schedule->zone()->isolate());
   Zone* zone = &tmp_zone;
   if (FLAG_trace_turbo_scheduler) {
     PrintF("------------- COMPUTING SPECIAL RPO ---------------\n");
   }
   // RPO should not have been computed for this schedule yet.
-  CHECK_EQ(kBlockUnvisited1, schedule->entry()->rpo_number_);
+  CHECK_EQ(kBlockUnvisited1, schedule->start()->rpo_number_);
   CHECK_EQ(0, static_cast<int>(schedule->rpo_order_.size()));
 
   // Perform an iterative RPO traversal using an explicit stack,
   // recording backedges that form cycles. O(|B|).
   ZoneList<std::pair<BasicBlock*, int> > backedges(1, zone);
   SpecialRPOStackFrame* stack =
       zone->NewArray<SpecialRPOStackFrame>(schedule->BasicBlockCount());
-  BasicBlock* entry = schedule->entry();
+  BasicBlock* entry = schedule->start();
   BlockList* order = NULL;
   int stack_depth = Push(stack, 0, entry, kBlockUnvisited1);
   int num_loops = 0;
 
   while (stack_depth > 0) {
     int current = stack_depth - 1;
     SpecialRPOStackFrame* frame = stack + current;
 
     if (frame->index < frame->block->SuccessorCount()) {
       // Process the next successor.
@@ skipping 165 matching lines @@
 
 #if DEBUG
   if (FLAG_trace_turbo_scheduler) PrintRPO(num_loops, loops, final_order);
   VerifySpecialRPO(num_loops, loops, final_order);
 #endif
   return final_order;
 }
 }
 }
 }  // namespace v8::internal::compiler