[turbofan] decouple register allocation from schedule and graph

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 <iosfwd>
 #include <vector>
 
@@ skipping 32 matching lines @@
     int ToInt() const { return static_cast<int>(index_); }
     size_t ToSize() const { return index_; }
     static Id FromSize(size_t index) { return Id(index); }
     static Id FromInt(int index) { return Id(static_cast<size_t>(index)); }
 
    private:
     explicit Id(size_t index) : index_(index) {}
     size_t index_;
   };
 
+  static const int kInvalidRpoNumber = -1;
   class RpoNumber FINAL {
    public:
-    int ToInt() const { return static_cast<int>(index_); }
-    size_t ToSize() const { return index_; }
-    static RpoNumber FromInt(int index) {
-      return RpoNumber(static_cast<size_t>(index));
+    int ToInt() const {
+      DCHECK(IsValid());
+      return index_;
     }
-    static RpoNumber Invalid() { return RpoNumber(static_cast<size_t>(-1)); }
+    size_t ToSize() const {
+      DCHECK(IsValid());
+      return static_cast<size_t>(index_);
+    }
+    bool IsValid() const { return index_ != kInvalidRpoNumber; }
+    static RpoNumber FromInt(int index) { return RpoNumber(index); }
+    static RpoNumber Invalid() { return RpoNumber(kInvalidRpoNumber); }
 
     bool IsNext(const RpoNumber other) const {
+      DCHECK(IsValid());
       return other.index_ == this->index_ + 1;
     }
 
+    bool operator==(RpoNumber other) const {
+      return this->index_ == other.index_;
+    }
+
    private:
-    explicit RpoNumber(size_t index) : index_(index) {}
-    size_t index_;
+    explicit RpoNumber(int32_t index) : index_(index) {}
+    int32_t index_;
   };
 
   BasicBlock(Zone* zone, Id id);
 
   Id id() const { return id_; }
 
   // Predecessors and successors.
   typedef ZoneVector<BasicBlock*> Predecessors;
   Predecessors::iterator predecessors_begin() { return predecessors_.begin(); }
   Predecessors::iterator predecessors_end() { return predecessors_.end(); }
+  Predecessors::const_iterator predecessors_begin() const {
+    return predecessors_.begin();
+  }
+  Predecessors::const_iterator predecessors_end() const {
+    return predecessors_.end();
+  }
   size_t PredecessorCount() const { return predecessors_.size(); }
   BasicBlock* PredecessorAt(size_t index) { return predecessors_[index]; }
-  size_t PredecessorIndexOf(BasicBlock* predecessor);
   void AddPredecessor(BasicBlock* predecessor);
 
   typedef ZoneVector<BasicBlock*> Successors;
   Successors::iterator successors_begin() { return successors_.begin(); }
   Successors::iterator successors_end() { return successors_.end(); }
+  Successors::const_iterator successors_begin() const {
+    return successors_.begin();
+  }
+  Successors::const_iterator successors_end() const {
+    return successors_.end();
+  }
   size_t SuccessorCount() const { return successors_.size(); }
   BasicBlock* SuccessorAt(size_t index) { return successors_[index]; }
   void AddSuccessor(BasicBlock* successor);
 
   // Nodes in the basic block.
   Node* NodeAt(size_t index) { return nodes_[index]; }
   size_t NodeCount() const { return nodes_.size(); }
 
   typedef NodeVector::iterator iterator;
   iterator begin() { return nodes_.begin(); }
@@ skipping 33 matching lines @@
   int32_t loop_end() const { return loop_end_; }
   void set_loop_end(int32_t loop_end);
 
   RpoNumber GetRpoNumber() const { return RpoNumber::FromInt(rpo_number_); }
   int32_t rpo_number() const { return rpo_number_; }
   void set_rpo_number(int32_t rpo_number);
 
   // Loop membership helpers.
   inline bool IsLoopHeader() const { return loop_end_ >= 0; }
   bool LoopContains(BasicBlock* block) const;
-  BasicBlock* ContainingLoop();
 
  private:
   int32_t rpo_number_;       // special RPO number of the block.
   BasicBlock* dominator_;    // Immediate dominator of the block.
   BasicBlock* loop_header_;  // Pointer to dominating loop header basic block,
                              // NULL if none. For loop headers, this points to
                              // enclosing loop header.
   int32_t loop_depth_;       // loop nesting, 0 is top-level
   int32_t loop_end_;         // end of the loop, if this block is a loop header.
 
@@ skipping 85 matching lines @@
   BasicBlock* end_;
 };
 
 std::ostream& operator<<(std::ostream& os, const Schedule& s);
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_SCHEDULE_H_