[turbofan] make live ranges stateless

this is necessary for the greedy allocator to use the relevant functions, as well as the sanity of someone looking at the code

BUG=

Review URL: https://codereview.chromium.org/1056063004

Cr-Commit-Position: refs/heads/master@{#28006}

src/compiler/register-allocator.cc

@@ -251,9 +251,11 @@ void LiveRange::CommitSpillOperand(AllocatedOperand* operand) {
 }
 
 
-UsePosition* LiveRange::NextUsePosition(LifetimePosition start) {
+UsePosition* LiveRange::NextUsePosition(LifetimePosition start) const {
   UsePosition* use_pos = last_processed_use_;
-  if (use_pos == nullptr) use_pos = first_pos();
+  if (use_pos == nullptr || use_pos->pos().Value() > start.Value()) {
+    use_pos = first_pos();
+  }
   while (use_pos != nullptr && use_pos->pos().Value() < start.Value()) {
     use_pos = use_pos->next();
   }
@@ -263,7 +265,7 @@ UsePosition* LiveRange::NextUsePosition(LifetimePosition start) {
 
 
 UsePosition* LiveRange::NextUsePositionRegisterIsBeneficial(
-    LifetimePosition start) {
+    LifetimePosition start) const {
   UsePosition* pos = NextUsePosition(start);
   while (pos != nullptr && !pos->RegisterIsBeneficial()) {
     pos = pos->next();
@@ -273,7 +275,7 @@ UsePosition* LiveRange::NextUsePositionRegisterIsBeneficial(
 
 
 UsePosition* LiveRange::PreviousUsePositionRegisterIsBeneficial(
-    LifetimePosition start) {
+    LifetimePosition start) const {
   auto pos = first_pos();
   UsePosition* prev = nullptr;
   while (pos != nullptr && pos->pos().Value() < start.Value()) {
@@ -284,7 +286,7 @@ UsePosition* LiveRange::PreviousUsePositionRegisterIsBeneficial(
 }
 
 
-UsePosition* LiveRange::NextRegisterPosition(LifetimePosition start) {
+UsePosition* LiveRange::NextRegisterPosition(LifetimePosition start) const {
   UsePosition* pos = NextUsePosition(start);
   while (pos != nullptr && pos->type() != UsePositionType::kRequiresRegister) {
     pos = pos->next();
@@ -293,7 +295,7 @@ UsePosition* LiveRange::NextRegisterPosition(LifetimePosition start) {
 }
 
 
-bool LiveRange::CanBeSpilled(LifetimePosition pos) {
+bool LiveRange::CanBeSpilled(LifetimePosition pos) const {
   // We cannot spill a live range that has a use requiring a register
   // at the current or the immediate next position.
   auto use_pos = NextRegisterPosition(pos);
@@ -571,7 +573,7 @@ bool LiveRange::CanCover(LifetimePosition position) const {
 }
 
 
-bool LiveRange::Covers(LifetimePosition position) {
+bool LiveRange::Covers(LifetimePosition position) const {
   if (!CanCover(position)) return false;
   auto start_search = FirstSearchIntervalForPosition(position);
   for (auto interval = start_search; interval != nullptr;
@@ -586,7 +588,7 @@ bool LiveRange::Covers(LifetimePosition position) {
 }
 
 
-LifetimePosition LiveRange::FirstIntersection(LiveRange* other) {
+LifetimePosition LiveRange::FirstIntersection(LiveRange* other) const {
   auto b = other->first_interval();
   if (b == nullptr) return LifetimePosition::Invalid();
   auto advance_last_processed_up_to = b->start();

src/compiler/register-allocator.h

@@ -246,25 +246,24 @@ class LiveRange final : public ZoneObject {
 
   // Returns use position in this live range that follows both start
   // and last processed use position.
-  // Modifies internal state of live range!
-  UsePosition* NextUsePosition(LifetimePosition start);
+  UsePosition* NextUsePosition(LifetimePosition start) const;
 
   // Returns use position for which register is required in this live
   // range and which follows both start and last processed use position
-  // Modifies internal state of live range!
-  UsePosition* NextRegisterPosition(LifetimePosition start);
+  UsePosition* NextRegisterPosition(LifetimePosition start) const;
 
   // Returns use position for which register is beneficial in this live
   // range and which follows both start and last processed use position
-  // Modifies internal state of live range!
-  UsePosition* NextUsePositionRegisterIsBeneficial(LifetimePosition start);
+  UsePosition* NextUsePositionRegisterIsBeneficial(
+      LifetimePosition start) const;
 
   // Returns use position for which register is beneficial in this live
   // range and which precedes start.
-  UsePosition* PreviousUsePositionRegisterIsBeneficial(LifetimePosition start);
+  UsePosition* PreviousUsePositionRegisterIsBeneficial(
+      LifetimePosition start) const;
 
   // Can this live range be spilled at this position.
-  bool CanBeSpilled(LifetimePosition pos);
+  bool CanBeSpilled(LifetimePosition pos) const;
 
   // Split this live range at the given position which must follow the start of
   // the range.
@@ -330,8 +329,8 @@ class LiveRange final : public ZoneObject {
 
   bool ShouldBeAllocatedBefore(const LiveRange* other) const;
   bool CanCover(LifetimePosition position) const;
-  bool Covers(LifetimePosition position);
-  LifetimePosition FirstIntersection(LiveRange* other);
+  bool Covers(LifetimePosition position) const;
+  LifetimePosition FirstIntersection(LiveRange* other) const;
 
   // Add a new interval or a new use position to this live range.
   void EnsureInterval(LifetimePosition start, LifetimePosition end, Zone* zone);
@@ -373,9 +372,10 @@ class LiveRange final : public ZoneObject {
   LiveRange* next_;
   // This is used as a cache, it doesn't affect correctness.
   mutable UseInterval* current_interval_;
-  UsePosition* last_processed_use_;
+  // This is used as a cache, it doesn't affect correctness.
+  mutable UsePosition* last_processed_use_;
   // This is used as a cache, it's invalid outside of BuildLiveRanges.
-  InstructionOperand* current_hint_operand_;
+  mutable InstructionOperand* current_hint_operand_;
   int spill_start_index_;
   SpillType spill_type_;
   union {