[turbofan] make LifetimePostion comparable

src/compiler/register-allocator.h

 // Copyright 2014 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_REGISTER_ALLOCATOR_H_
 #define V8_REGISTER_ALLOCATOR_H_
 
 #include "src/compiler/instruction.h"
 #include "src/zone-containers.h"
 
@@ skipping 28 matching lines @@
   static LifetimePosition GapFromInstructionIndex(int index) {
     return LifetimePosition(index * kStep);
   }
   // Return the lifetime position that corresponds to the beginning of
   // the instruction with the given index.
   static LifetimePosition InstructionFromInstructionIndex(int index) {
     return LifetimePosition(index * kStep + kHalfStep);
   }
 
   // Returns a numeric representation of this lifetime position.
-  int Value() const { return value_; }
+  int value() const { return value_; }
 
   // Returns the index of the instruction to which this lifetime position
   // corresponds.
   int ToInstructionIndex() const {
     DCHECK(IsValid());
     return value_ / kStep;
   }
 
   // Returns true if this lifetime position corresponds to a START value
   bool IsStart() const { return (value_ & (kHalfStep - 1)) == 0; }
@@ skipping 11 matching lines @@
 
   // Returns the lifetime position for the current gap START.
   LifetimePosition FullStart() const {
     DCHECK(IsValid());
     return LifetimePosition(value_ & ~(kStep - 1));
   }
 
   // Returns the lifetime position for the current END.
   LifetimePosition End() const {
     DCHECK(IsValid());
-    return LifetimePosition(Start().Value() + kHalfStep / 2);
+    return LifetimePosition(Start().value_ + kHalfStep / 2);
   }
 
   // Returns the lifetime position for the beginning of the next START.
   LifetimePosition NextStart() const {
     DCHECK(IsValid());
-    return LifetimePosition(Start().Value() + kHalfStep);
+    return LifetimePosition(Start().value_ + kHalfStep);
   }
 
   // Returns the lifetime position for the beginning of the next gap START.
   LifetimePosition NextFullStart() const {
     DCHECK(IsValid());
-    return LifetimePosition(FullStart().Value() + kStep);
+    return LifetimePosition(FullStart().value_ + kStep);
   }
 
   // Returns the lifetime position for the beginning of the previous START.
   LifetimePosition PrevStart() const {
     DCHECK(IsValid());
     DCHECK(value_ >= kHalfStep);
-    return LifetimePosition(Start().Value() - kHalfStep);
+    return LifetimePosition(Start().value_ - kHalfStep);
   }
 
   // Constructs the lifetime position which does not correspond to any
   // instruction.
   LifetimePosition() : value_(-1) {}
 
   // Returns true if this lifetime positions corrensponds to some
   // instruction.
   bool IsValid() const { return value_ != -1; }
 
+  bool operator<(const LifetimePosition& that) const {
+    return this->value_ < that.value_;
+  }
+
+  bool operator<=(const LifetimePosition& that) const {
+    return this->value_ <= that.value_;
+  }
+
+  bool operator==(const LifetimePosition& that) const {
+    return this->value_ == that.value_;
+  }
+
+  bool operator!=(const LifetimePosition& that) const {
+    return this->value_ != that.value_;
+  }
+
+  bool operator>(const LifetimePosition& that) const {
+    return this->value_ > that.value_;
+  }
+
+  bool operator>=(const LifetimePosition& that) const {
+    return this->value_ >= that.value_;
+  }
+
   static inline LifetimePosition Invalid() { return LifetimePosition(); }
 
   static inline LifetimePosition MaxPosition() {
     // We have to use this kind of getter instead of static member due to
     // crash bug in GDB.
     return LifetimePosition(kMaxInt);
   }
 
  private:
   static const int kHalfStep = 2;
   static const int kStep = 2 * kHalfStep;
 
   // Code relies on kStep and kHalfStep being a power of two.
   STATIC_ASSERT(IS_POWER_OF_TWO(kHalfStep));
 
   explicit LifetimePosition(int value) : value_(value) {}
 
   int value_;
 };
 
 
 // Representation of the non-empty interval [start,end[.
 class UseInterval final : public ZoneObject {
  public:
   UseInterval(LifetimePosition start, LifetimePosition end)
       : start_(start), end_(end), next_(nullptr) {
-    DCHECK(start.Value() < end.Value());
+    DCHECK(start < end);
   }
 
   LifetimePosition start() const { return start_; }
   void set_start(LifetimePosition start) { start_ = start; }
   LifetimePosition end() const { return end_; }
   void set_end(LifetimePosition end) { end_ = end; }
   UseInterval* next() const { return next_; }
   void set_next(UseInterval* next) { next_ = next; }
 
   // Split this interval at the given position without effecting the
   // live range that owns it. The interval must contain the position.
   UseInterval* SplitAt(LifetimePosition pos, Zone* zone);
 
   // If this interval intersects with other return smallest position
   // that belongs to both of them.
   LifetimePosition Intersect(const UseInterval* other) const {
-    if (other->start().Value() < start_.Value()) return other->Intersect(this);
-    if (other->start().Value() < end_.Value()) return other->start();
+    if (other->start() < start_) return other->Intersect(this);
+    if (other->start() < end_) return other->start();
     return LifetimePosition::Invalid();
   }
 
   bool Contains(LifetimePosition point) const {
-    return start_.Value() <= point.Value() && point.Value() < end_.Value();
+    return start_ <= point && point < end_;
   }
 
  private:
   LifetimePosition start_;
   LifetimePosition end_;
   UseInterval* next_;
 
   DISALLOW_COPY_AND_ASSIGN(UseInterval);
 };
 
@@ skipping 621 matching lines @@
   RegisterAllocationData* const data_;
 
   DISALLOW_COPY_AND_ASSIGN(LiveRangeConnector);
 };
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_REGISTER_ALLOCATOR_H_