Subzero: Fix a bug in register allocator overlap computation.

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 606 matching lines @@
     MDS_Unknown,
     MDS_SingleDef,
     MDS_MultiDefSingleBlock,
     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 *getFirstDefinitionSingleBlock() const;
+  const Inst *getSingleDefinition() const;
   const Inst *getFirstDefinition() const;
-  const Inst *getSingleDefinition() const;
   const InstDefList &getLatterDefinitions() const { return Definitions; }
   CfgNode *getNode() const { return SingleUseNode; }
   RegWeight getUseWeight() const { return UseWeight; }
   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;
   CfgNode *SingleUseNode = nullptr;
   CfgNode *SingleDefNode = nullptr;
-  /// All definitions of the variable are collected here, in increasing
-  /// order of instruction number.
+  /// All definitions of the variable are collected in Definitions[] (except for
+  /// the earliest definition), 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
+  const Inst *FirstOrSingleDefinition = nullptr;
   RegWeight UseWeight;
 };
 
 /// VariablesMetadata analyzes and summarizes the metadata for the complete set
 /// of Variables.
 class VariablesMetadata {
   VariablesMetadata() = delete;
   VariablesMetadata(const VariablesMetadata &) = delete;
   VariablesMetadata &operator=(const VariablesMetadata &) = delete;
 
 public:
   explicit VariablesMetadata(const Cfg *Func) : Func(Func) {}
   /// Initialize the state by traversing all instructions/variables in the CFG.
   void init(MetadataKind TrackingKind);
   /// Add a single node. This is called by init(), and can be called
   /// incrementally from elsewhere, e.g. after edge-splitting.
   void addNode(CfgNode *Node);
+  MetadataKind getKind() const { return Kind; }
   /// Returns whether the given Variable is tracked in this object. It should
   /// only return false if changes were made to the CFG after running init(), in
   /// which case the state is stale and the results shouldn't be trusted (but it
   /// may be OK e.g. for dumping).
   bool isTracked(const Variable *Var) const {
     return Var->getIndex() < Metadata.size();
   }
 
   /// Returns whether the given Variable has multiple definitions.
   bool isMultiDef(const Variable *Var) const;
   /// Returns the first definition instruction of the given Variable. This is
   /// only valid for variables whose definitions are all within the same block,
   /// e.g. T after the lowered sequence "T=B; T+=C; A=T", for which
-  /// getFirstDefinition(T) would return the "T=B" instruction. For variables
-  /// with definitions span multiple blocks, nullptr is returned.
-  const Inst *getFirstDefinition(const Variable *Var) const;
+  /// getFirstDefinitionSingleBlock(T) would return the "T=B" instruction. For
+  /// variables with definitions span multiple blocks, nullptr is returned.
+  const Inst *getFirstDefinitionSingleBlock(const Variable *Var) const;
   /// Returns the definition instruction of the given Variable, when the
   /// variable has exactly one definition. Otherwise, nullptr is returned.
   const Inst *getSingleDefinition(const Variable *Var) const;
-  /// Returns the list of all definition instructions of the given Variable.
+  /// getFirstDefinition() and getLatterDefinitions() are used together to
+  /// return the complete set of instructions that define the given Variable,
+  /// regardless of whether the definitions are within the same block (in
+  /// contrast to getFirstDefinitionSingleBlock).
+  const Inst *getFirstDefinition(const Variable *Var) const;
   const InstDefList &getLatterDefinitions(const Variable *Var) const;
 
   /// 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.
   CfgNode *getLocalUseNode(const Variable *Var) const;
 
   /// Returns the total use weight computed as the sum of uses multiplied by a
   /// loop nest depth factor for each use.
   RegWeight getUseWeight(const Variable *Var) const;
 
 private:
   const Cfg *Func;
   MetadataKind Kind;
   CfgVector<VariableTracking> Metadata;
   const static InstDefList NoDefinitions;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEOPERAND_H