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

src/compiler/schedule.h

 // 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.
 
 #ifndef V8_COMPILER_SCHEDULE_H_
 #define V8_COMPILER_SCHEDULE_H_
 
 #include <vector>
 
 #include "src/v8.h"
@@ skipping 145 matching lines @@
 // by the graph's dependencies. A schedule is required to generate code.
 class Schedule : public GenericGraph<BasicBlock> {
  public:
   explicit Schedule(Zone* zone)
       : GenericGraph<BasicBlock>(zone),
         zone_(zone),
         all_blocks_(BasicBlockVector::allocator_type(zone)),
         nodeid_to_block_(BasicBlockVector::allocator_type(zone)),
         rpo_order_(BasicBlockVector::allocator_type(zone)),
         immediate_dominator_(BasicBlockVector::allocator_type(zone)) {
-    NewBasicBlock();  // entry.
-    NewBasicBlock();  // exit.
-    SetStart(entry());
-    SetEnd(exit());
+    SetStart(NewBasicBlock());  // entry.
+    SetEnd(NewBasicBlock());    // exit.
   }
 
-  // TODO(titzer): rewrite users of these methods to use start() and end().
-  BasicBlock* entry() const { return all_blocks_[0]; }  // Return entry block.
-  BasicBlock* exit() const { return all_blocks_[1]; }   // Return exit block.
-
   // Return the block which contains {node}, if any.
   BasicBlock* block(Node* node) const {
     if (node->id() < static_cast<NodeId>(nodeid_to_block_.size())) {
       return nodeid_to_block_[node->id()];
     }
     return NULL;
   }
 
   BasicBlock* dominator(BasicBlock* block) {
     return immediate_dominator_[block->id()];
@@ skipping 80 matching lines @@
     AddSuccessor(block, fblock);
     SetControlInput(block, branch);
   }
 
   // BasicBlock building: add a return at the end of {block}.
   void AddReturn(BasicBlock* block, Node* input) {
     // TODO(titzer): require a Return node here.
     DCHECK(block->control_ == BasicBlock::kNone);
     block->control_ = BasicBlock::kReturn;
     SetControlInput(block, input);
-    if (block != exit()) AddSuccessor(block, exit());
+    if (block != end()) AddSuccessor(block, end());
   }
 
   // BasicBlock building: add a throw at the end of {block}.
   void AddThrow(BasicBlock* block, Node* input) {
     DCHECK(block->control_ == BasicBlock::kNone);
     block->control_ = BasicBlock::kThrow;
     SetControlInput(block, input);
-    if (block != exit()) AddSuccessor(block, exit());
+    if (block != end()) AddSuccessor(block, end());
   }
 
   // BasicBlock building: add a deopt at the end of {block}.
   void AddDeoptimize(BasicBlock* block, Node* state) {
     DCHECK(block->control_ == BasicBlock::kNone);
     block->control_ = BasicBlock::kDeoptimize;
     SetControlInput(block, state);
     block->deferred_ = true;  // By default, consider deopts the slow path.
-    if (block != exit()) AddSuccessor(block, exit());
+    if (block != end()) AddSuccessor(block, end());
   }
 
   friend class Scheduler;
   friend class CodeGenerator;
 
   void AddSuccessor(BasicBlock* block, BasicBlock* succ) {
     succ->AppendInput(zone_, block);
   }
 
   BasicBlockVector* rpo_order() { return &rpo_order_; }
@@ skipping 22 matching lines @@
                                           // dominator, indexed by block
                                           // id.
 };
 
 OStream& operator<<(OStream& os, const Schedule& s);
 }
 }
 }  // namespace v8::internal::compiler
 
 #endif  // V8_COMPILER_SCHEDULE_H_