[turbofan] remove some of the dependency of Instruction on Schedule

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_;
   };
 
+  class RpoNumber {

[Benedikt Meurer, 2014/10/14 03:44:13]

Mark as FINAL.

[dcarney, 2014/10/14 08:14:37]

Done.

+   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));
+    }
+    static RpoNumber Invalid() { return RpoNumber(static_cast<size_t>(-1)); }
+
+    bool IsNext(const RpoNumber other) const {
+      return other.index_ == this->index_ + 1;
+    }
+
+   private:
+    explicit RpoNumber(size_t index) : index_(index) {}
+    size_t index_;
+  };
+
   BasicBlock(Zone* zone, Id id);
 
   Id id() const { return id_; }
 
-  // Instruction indexes (used by the register allocator).
-  int first_instruction_index() {
-    DCHECK(code_start_ >= 0);
-    DCHECK(code_end_ > 0);
-    DCHECK(code_end_ >= code_start_);
-    return code_start_;
-  }
-  int last_instruction_index() {
-    DCHECK(code_start_ >= 0);
-    DCHECK(code_end_ > 0);
-    DCHECK(code_end_ >= code_start_);
-    return code_end_ - 1;
-  }
-
   // Predecessors and successors.
   typedef ZoneVector<BasicBlock*> Predecessors;
   Predecessors::iterator predecessors_begin() { return predecessors_.begin(); }
   Predecessors::iterator predecessors_end() { 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;
@@ skipping 38 matching lines @@
 
   BasicBlock* loop_header() const { return loop_header_; }
   void set_loop_header(BasicBlock* loop_header);
 
   int32_t loop_depth() const { return loop_depth_; }
   void set_loop_depth(int32_t loop_depth);
 
   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);
 
-  int32_t code_start() const { return code_start_; }
-  void set_code_start(int32_t start);
-
-  int32_t code_end() const { return code_end_; }
-  void set_code_end(int32_t end);
-
-  bool deferred() const { return deferred_; }
-
   // 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.
-  int32_t code_start_;       // start index of arch-specific code.
-  int32_t code_end_;         // end index of arch-specific code.
-  bool deferred_;            // {true} if this block is considered the slow
-                             // path.
+
   Control control_;          // Control at the end of the block.
   Node* control_input_;      // Input value for control.
   NodeVector nodes_;         // nodes of this block in forward order.
 
   Successors successors_;
   Predecessors predecessors_;
   Id id_;
 
   DISALLOW_COPY_AND_ASSIGN(BasicBlock);
 };
@@ skipping 74 matching lines @@
   BasicBlock* end_;
 };
 
 std::ostream& operator<<(std::ostream& os, const Schedule& s);
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_SCHEDULE_H_