Subzero: Cleanly implement register allocation after phi lowering.

src/IceOperand.h

 //===- subzero/src/IceOperand.h - High-level operands -----------*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 359 matching lines @@
   void addSegment(InstNumberT Start, InstNumberT End);
 
   bool endsBefore(const LiveRange &Other) const;
   bool overlaps(const LiveRange &Other, bool UseTrimmed = false) const;
   bool overlapsInst(InstNumberT OtherBegin, bool UseTrimmed = false) const;
   bool containsValue(InstNumberT Value, bool IsDest) const;
   bool isEmpty() const { return Range.empty(); }
   InstNumberT getStart() const {
     return Range.empty() ? -1 : Range.begin()->first;
   }
+  InstNumberT getEnd() const {
+    return Range.empty() ? -1 : Range.rbegin()->second;
+  }
 
   void untrim() { TrimmedBegin = Range.begin(); }
   void trim(InstNumberT Lower);
 
   RegWeight getWeight() const { return Weight; }
   void setWeight(const RegWeight &NewWeight) { Weight = NewWeight; }
   void addWeight(uint32_t Delta) { Weight.addWeight(Delta); }
   void dump(Ostream &Str) const;
 
 private:
@@ skipping 180 matching lines @@
     MDS_MultiDefMultiBlock
   };
   enum MultiBlockState { MBS_Unknown, MBS_SingleBlock, MBS_MultiBlock };
   VariableTracking() = default;
   VariableTracking(const VariableTracking &) = default;
   MultiDefState getMultiDef() const { return MultiDef; }
   MultiBlockState getMultiBlock() const { return MultiBlock; }
   const Inst *getFirstDefinition() const;
   const Inst *getSingleDefinition() const;
   const InstDefList &getLatterDefinitions() const { return Definitions; }
-  const CfgNode *getNode() const { return SingleUseNode; }
-  void markUse(MetadataKind TrackingKind, const Inst *Instr,
-               const CfgNode *Node, bool IsFromDef, bool IsImplicit);
-  void markDef(MetadataKind TrackingKind, const Inst *Instr,
-               const CfgNode *Node);
+  CfgNode *getNode() const { return SingleUseNode; }
+  void markUse(MetadataKind TrackingKind, const Inst *Instr, CfgNode *Node,
+               bool IsImplicit);
+  void markDef(MetadataKind TrackingKind, const Inst *Instr, CfgNode *Node);
 
 private:
   MultiDefState MultiDef = MDS_Unknown;
   MultiBlockState MultiBlock = MBS_Unknown;
-  const CfgNode *SingleUseNode = nullptr;
-  const CfgNode *SingleDefNode = nullptr;
+  CfgNode *SingleUseNode = nullptr;
+  CfgNode *SingleDefNode = nullptr;
   /// All definitions of the variable are collected here, in increasing
   /// order of instruction number.
   InstDefList Definitions; /// Only used if Kind==VMK_All
   const Inst *FirstOrSingleDefinition =
       nullptr; /// Is a copy of Definitions[0] if Kind==VMK_All
 };
 
 /// VariablesMetadata analyzes and summarizes the metadata for the
 /// complete set of Variables.
 class VariablesMetadata {
@@ skipping 37 matching lines @@
   /// Returns whether the given Variable is live across multiple
   /// blocks.  Mainly, this is used to partition Variables into
   /// single-block versus multi-block sets for leveraging sparsity in
   /// liveness analysis, and for implementing simple stack slot
   /// coalescing.  As a special case, function arguments are always
   /// considered multi-block because they are live coming into the
   /// entry block.
   bool isMultiBlock(const Variable *Var) const;
   /// Returns the node that the given Variable is used in, assuming
   /// isMultiBlock() returns false.  Otherwise, nullptr is returned.
-  const CfgNode *getLocalUseNode(const Variable *Var) const;
+  CfgNode *getLocalUseNode(const Variable *Var) const;
 
 private:
   const Cfg *Func;
   MetadataKind Kind;
   std::vector<VariableTracking> Metadata;
   const static InstDefList NoDefinitions;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEOPERAND_H