[turbofan] Cleanup register allocator a little after split.

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 120 matching lines @@
 
 // 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());
   }
 
   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.
   void 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();
     return LifetimePosition::Invalid();
   }
 
   bool Contains(LifetimePosition point) const {
     return start_.Value() <= point.Value() && point.Value() < end_.Value();
   }
 
-  void set_start(LifetimePosition start) { start_ = start; }
-  void set_next(UseInterval* next) { next_ = next; }
-
+ private:
   LifetimePosition start_;
   LifetimePosition end_;
   UseInterval* next_;
 
- private:
   DISALLOW_COPY_AND_ASSIGN(UseInterval);
 };
 
 
 enum class UsePositionType : uint8_t { kAny, kRequiresRegister, kRequiresSlot };
 
 
 // Representation of a use position.
 class UsePosition final : public ZoneObject {
  public:
   UsePosition(LifetimePosition pos, InstructionOperand* operand,
               InstructionOperand* hint);
 
   InstructionOperand* operand() const { return operand_; }
   bool HasOperand() const { return operand_ != nullptr; }
 
   InstructionOperand* hint() const { return hint_; }
   bool HasHint() const;
   bool RegisterIsBeneficial() const {
     return RegisterBeneficialField::decode(flags_);
   }
   UsePositionType type() const { return TypeField::decode(flags_); }
 
   LifetimePosition pos() const { return pos_; }
   UsePosition* next() const { return next_; }
 
   void set_next(UsePosition* next) { next_ = next; }
   void set_type(UsePositionType type, bool register_beneficial);
 
+ private:
+  typedef BitField8<UsePositionType, 0, 2> TypeField;
+  typedef BitField8<bool, 2, 1> RegisterBeneficialField;
+
   InstructionOperand* const operand_;
   InstructionOperand* const hint_;
   LifetimePosition const pos_;
   UsePosition* next_;
-
- private:
-  typedef BitField8<UsePositionType, 0, 2> TypeField;
-  typedef BitField8<bool, 2, 1> RegisterBeneficialField;
   uint8_t flags_;
 
   DISALLOW_COPY_AND_ASSIGN(UsePosition);
 };
 
 class SpillRange;
 
 
 // Representation of SSA values' live ranges as a collection of (continuous)
 // intervals over the instruction ordering.
 class LiveRange final : public ZoneObject {
  public:
   static const int kInvalidAssignment = 0x7fffffff;
 
-  LiveRange(int id, Zone* zone);
+  explicit LiveRange(int id);
 
   UseInterval* first_interval() const { return first_interval_; }
   UsePosition* first_pos() const { return first_pos_; }
   LiveRange* parent() const { return parent_; }
   LiveRange* TopLevel() { return (parent_ == nullptr) ? this : parent_; }
   const LiveRange* TopLevel() const {
     return (parent_ == nullptr) ? this : parent_;
   }
   LiveRange* next() const { return next_; }
   bool IsChild() const { return parent() != nullptr; }
@@ skipping 65 matching lines @@
   }
 
   LifetimePosition End() const {
     DCHECK(!IsEmpty());
     return last_interval_->end();
   }
 
   enum class SpillType { kNoSpillType, kSpillOperand, kSpillRange };
   SpillType spill_type() const { return spill_type_; }
   InstructionOperand* GetSpillOperand() const {
-    return spill_type_ == SpillType::kSpillOperand ? spill_operand_ : nullptr;
+    DCHECK(spill_type_ == SpillType::kSpillOperand);
+    return spill_operand_;
   }
   SpillRange* GetSpillRange() const {
-    return spill_type_ == SpillType::kSpillRange ? spill_range_ : nullptr;
+    DCHECK(spill_type_ == SpillType::kSpillRange);
+    return spill_range_;
   }
   bool HasNoSpillType() const { return spill_type_ == SpillType::kNoSpillType; }
   bool HasSpillOperand() const {
     return spill_type_ == SpillType::kSpillOperand;
   }
   bool HasSpillRange() const { return spill_type_ == SpillType::kSpillRange; }
 
   void SpillAtDefinition(Zone* zone, int gap_index,
                          InstructionOperand* operand);
   void SetSpillOperand(InstructionOperand* operand);
@@ skipping 135 matching lines @@
   // allocation.
   Zone* code_zone() const { return code()->zone(); }
   const PhiMap& phi_map() const { return phi_map_; }
   PhiMap& phi_map() { return phi_map_; }
   Frame* frame() const { return frame_; }
   const char* debug_name() const { return debug_name_; }
   const RegisterConfiguration* config() const { return config_; }
 
   void SetLiveRangeAssignedRegister(LiveRange* range, int reg);
   LiveRange* LiveRangeFor(int index);
-  Instruction* InstructionAt(int index) { return code()->InstructionAt(index); }
+  Instruction* InstructionAt(int index) const {
+    return code()->InstructionAt(index);
+  }
 
   void AssignPhiInput(LiveRange* range, const InstructionOperand& assignment);
   SpillRange* AssignSpillRangeToLiveRange(LiveRange* range);
 
   MoveOperands* AddGapMove(int index, Instruction::GapPosition position,
                            const InstructionOperand& from,
                            const InstructionOperand& to);
 
-  bool IsBlockBoundary(LifetimePosition pos) {
-    return pos.IsFullStart() &&
-           code()
-                   ->GetInstructionBlock(pos.ToInstructionIndex())
-                   ->code_start() == pos.ToInstructionIndex();
-  }
-
-  const InstructionBlock* GetInstructionBlock(LifetimePosition pos) const {
-    return code()->GetInstructionBlock(pos.ToInstructionIndex());
-  }
-
   bool IsReference(int virtual_register) const {
     return code()->IsReference(virtual_register);
   }
 
   bool ExistsUseWithoutDefinition();
 
   // Creates a new live range.
   LiveRange* NewLiveRange(int index);
 
  private:
@@ skipping 88 matching lines @@
            InstructionOperand* operand, InstructionOperand* hint);
 
   RegisterAllocationData* const data_;
 
   DISALLOW_COPY_AND_ASSIGN(LiveRangeBuilder);
 };
 
 
 class LinearScanAllocator final : public ZoneObject {
  public:
-  explicit LinearScanAllocator(RegisterAllocationData* data, RegisterKind kind);
+  LinearScanAllocator(RegisterAllocationData* data, RegisterKind kind,
+                      Zone* local_zone);
 
   // Phase 4: compute register assignments.
   void AllocateRegisters();
 
  private:
   RegisterAllocationData* data() const { return data_; }
   InstructionSequence* code() const { return data()->code(); }
   Zone* allocation_zone() const { return data()->allocation_zone(); }
   Zone* code_zone() const { return code()->zone(); }
   const RegisterConfiguration* config() const { return data()->config(); }
+  int num_registers() const { return num_registers_; }
+  const char* RegisterName(int allocation_index) const;
+
+  ZoneVector<LiveRange*>& live_ranges() { return data()->live_ranges(); }
+  ZoneVector<LiveRange*>& unhandled_live_ranges() {
+    return unhandled_live_ranges_;
+  }
+  ZoneVector<LiveRange*>& active_live_ranges() { return active_live_ranges_; }
+  ZoneVector<LiveRange*>& inactive_live_ranges() {
+    return inactive_live_ranges_;
+  }
+  ZoneVector<SpillRange*>& spill_ranges() { return data()->spill_ranges(); }
+  RegisterAllocationData::PhiMap& phi_map() { return data()->phi_map(); }
 
   Instruction* InstructionAt(int index) { return code()->InstructionAt(index); }
-
-  int GetVirtualRegister() { return code()->NextVirtualRegister(); }
-
   bool IsReference(int virtual_register) const {
     return data()->IsReference(virtual_register);
   }
-
   LiveRange* LiveRangeFor(int index) { return data()->LiveRangeFor(index); }
 
   // Helper methods for updating the life range lists.
   void AddToActive(LiveRange* range);
   void AddToInactive(LiveRange* range);
   void AddToUnhandledSorted(LiveRange* range);
   void AddToUnhandledUnsorted(LiveRange* range);
   void SortUnhandled();
   bool UnhandledIsSorted();
   void ActiveToHandled(LiveRange* range);
@@ skipping 19 matching lines @@
   // Split the given range in a position from the interval [start, end].
   LiveRange* SplitBetween(LiveRange* range, LifetimePosition start,
                           LifetimePosition end);
 
   // Find a lifetime position in the interval [start, end] which
   // is optimal for splitting: it is either header of the outermost
   // loop covered by this interval or the latest possible position.
   LifetimePosition FindOptimalSplitPos(LifetimePosition start,
                                        LifetimePosition end);
 
+  void Spill(LiveRange* range);
+
   // Spill the given life range after position pos.
   void SpillAfter(LiveRange* range, LifetimePosition pos);
 
   // Spill the given life range after position [start] and up to position [end].
   void SpillBetween(LiveRange* range, LifetimePosition start,
                     LifetimePosition end);
 
   // Spill the given life range after position [start] and up to position [end].
   // Range is guaranteed to be spilled at least until position [until].
   void SpillBetweenUntil(LiveRange* range, LifetimePosition start,
                          LifetimePosition until, LifetimePosition end);
 
   void SplitAndSpillIntersecting(LiveRange* range);
 
   // If we are trying to spill a range inside the loop try to
   // hoist spill position out to the point just before the loop.
   LifetimePosition FindOptimalSpillingPos(LiveRange* range,
                                           LifetimePosition pos);
 
-  void Spill(LiveRange* range);
-
-  // Return the block which contains give lifetime position.
-  const InstructionBlock* GetInstructionBlock(LifetimePosition pos) const {
-    return data()->GetInstructionBlock(pos);
-  }
-
-  void SetLiveRangeAssignedRegister(LiveRange* range, int reg) {
-    data()->SetLiveRangeAssignedRegister(range, reg);
-  }
-
-  // Helper methods for the fixed registers.
-  int RegisterCount() const { return num_registers_; }
-  const char* RegisterName(int allocation_index);
-
-  ZoneVector<LiveRange*>& live_ranges() { return data()->live_ranges(); }
-  ZoneVector<LiveRange*>& fixed_live_ranges() {
-    return data()->fixed_live_ranges();
-  }
-  ZoneVector<LiveRange*>& fixed_double_live_ranges() {
-    return data()->fixed_double_live_ranges();
-  }
-  ZoneVector<LiveRange*>& unhandled_live_ranges() {
-    return unhandled_live_ranges_;
-  }
-  ZoneVector<LiveRange*>& active_live_ranges() { return active_live_ranges_; }
-  ZoneVector<LiveRange*>& inactive_live_ranges() {
-    return inactive_live_ranges_;
-  }
-  ZoneVector<SpillRange*>& spill_ranges() { return data()->spill_ranges(); }
-  RegisterAllocationData::PhiMap& phi_map() { return data()->phi_map(); }
-
   RegisterAllocationData* const data_;
   const RegisterKind mode_;
   const int num_registers_;
 
   ZoneVector<LiveRange*> unhandled_live_ranges_;
   ZoneVector<LiveRange*> active_live_ranges_;
   ZoneVector<LiveRange*> inactive_live_ranges_;
 
 #ifdef DEBUG
   LifetimePosition allocation_finger_;
@@ skipping 42 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(ReferenceMapPopulator);
 };
 
 
 class LiveRangeConnector final : public ZoneObject {
  public:
   explicit LiveRangeConnector(RegisterAllocationData* data);
 
   // Phase 8: reconnect split ranges with moves.
-  void ConnectRanges(Zone* temp_zone);
+  void ConnectRanges(Zone* local_zone);
 
   // Phase 9: insert moves to connect ranges across basic blocks.
-  void ResolveControlFlow();
+  void ResolveControlFlow(Zone* local_zone);
 
  private:
-  const InstructionBlock* GetInstructionBlock(LifetimePosition pos) const {
-    return data()->GetInstructionBlock(pos);
-  }
   bool CanEagerlyResolveControlFlow(const InstructionBlock* block) const;
   void ResolveControlFlow(const InstructionBlock* block,
                           const InstructionOperand& cur_op,
                           const InstructionBlock* pred,
                           const InstructionOperand& pred_op);
   InstructionSequence* code() const { return data()->code(); }
   Zone* code_zone() const { return code()->zone(); }
   RegisterAllocationData* data() const { return data_; }
 
   RegisterAllocationData* const data_;
 
   DISALLOW_COPY_AND_ASSIGN(LiveRangeConnector);
 };
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_REGISTER_ALLOCATOR_H_