Subzero: Register allocator performance improvements and simplifications.

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.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares the Operand class and its target-independent
@@ skipping 394 matching lines @@
     RegNum = NewRegNum;
   }
   bool hasRegTmp() const { return getRegNumTmp() != NoRegister; }
   int32_t getRegNumTmp() const { return RegNumTmp; }
   void setRegNumTmp(int32_t NewRegNum) { RegNumTmp = NewRegNum; }
 
   RegWeight getWeight() const { return Weight; }
   void setWeight(uint32_t NewWeight) { Weight = NewWeight; }
   void setWeightInfinite() { Weight = RegWeight::Inf; }
 
+  LiveRange &getLiveRange() { return Live; }

[jvoung (off chromium), 2014/10/15 16:42:36]

There's also the const LiveRange &getLiveRange() const below. Can that be used
instead?

[Jim Stichnoth, 2014/10/15 16:47:41]

Unfortunately, at least one caller needs the const version and at least one
needs the non-const version...

   const LiveRange &getLiveRange() const { return Live; }
   void setLiveRange(const LiveRange &Range) { Live = Range; }
   void resetLiveRange() { Live.reset(); }
   void addLiveRange(InstNumberT Start, InstNumberT End, uint32_t WeightDelta) {
     assert(WeightDelta != RegWeight::Inf);
     Live.addSegment(Start, End);
     if (Weight.isInf())
       Live.setWeight(RegWeight::Inf);
     else
       Live.addWeight(WeightDelta * Weight.getWeight());
   }
   void setLiveRangeInfiniteWeight() { Live.setWeight(RegWeight::Inf); }
   void trimLiveRange(InstNumberT Start) { Live.trim(Start); }
   void untrimLiveRange() { Live.untrim(); }
+  bool rangeEndsBefore(const Variable *Other) const {
+    return Live.endsBefore(Other->Live);
+  }
+  bool rangeOverlaps(const Variable *Other) const {
+    const bool UseTrimmed = true;
+    return Live.overlaps(Other->Live, UseTrimmed);
+  }
+  bool rangeOverlapsStart(const Variable *Other) const {
+    const bool UseTrimmed = true;
+    return Live.overlapsInst(Other->Live.getStart(), UseTrimmed);
+  }
 
   Variable *getLo() const { return LoVar; }
   Variable *getHi() const { return HiVar; }
   void setLoHi(Variable *Lo, Variable *Hi) {
     assert(LoVar == NULL);
     assert(HiVar == NULL);
     LoVar = Lo;
     HiVar = Hi;
   }
   // Creates a temporary copy of the variable with a different type.
@@ skipping 151 matching lines @@
   const Cfg *Func;
   std::vector<VariableTracking> Metadata;
   const static InstDefList NoDefinitions;
   VariablesMetadata(const VariablesMetadata &) = delete;
   VariablesMetadata &operator=(const VariablesMetadata &) = delete;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEOPERAND_H