Subzero. Fixes a bug in the register allocator range eviction.

src/IceRegAlloc.cpp

 //===- subzero/src/IceRegAlloc.cpp - Linear-scan implementation -----------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 634 matching lines @@
     if (Iter.Cur->mustHaveReg()) {
       if (Kind == RAK_Phi)
         addSpillFill(Iter);
       else
         Func->setError("Unable to find a physical register for an "
                        "infinite-weight live range");
     }
   } else {
     // Evict all live ranges in Active that register number MinWeightIndex is
     // assigned to.
+    const llvm::SmallBitVector &Aliases = *RegAliases[MinWeightIndex];
     for (SizeT I = Active.size(); I > 0; --I) {
       const SizeT Index = I - 1;
       Variable *Item = Active[Index];
-      if (Item->getRegNumTmp() == MinWeightIndex) {
-        dumpLiveRangeTrace("Evicting     ", Item);
-        const llvm::SmallBitVector &Aliases = *RegAliases[MinWeightIndex];
-        for (int32_t RegAlias = Aliases.find_first(); RegAlias >= 0;
-             RegAlias = Aliases.find_next(RegAlias)) {
-          --RegUses[RegAlias];
-          assert(RegUses[RegAlias] >= 0);
-        }
+      int32_t RegNum = Item->getRegNumTmp();
+      if (Aliases[RegNum]) {
+        dumpLiveRangeTrace("Evicting A   ", Item);
+        --RegUses[RegNum];
+        assert(RegUses[RegNum] >= 0);
         Item->setRegNumTmp(Variable::NoRegister);
         moveItem(Active, Index, Handled);
       }
     }
     // Do the same for Inactive.
     for (SizeT I = Inactive.size(); I > 0; --I) {
       const SizeT Index = I - 1;
       Variable *Item = Inactive[Index];
       // Note: The Item->rangeOverlaps(Cur) clause is not part of the
       // description of AssignMemLoc() in the original paper. But there doesn't
       // seem to be any need to evict an inactive live range that doesn't
       // overlap with the live range currently being considered. It's
       // especially bad if we would end up evicting an infinite-weight but
       // currently-inactive live range. The most common situation for this
       // would be a scratch register kill set for call instructions.
-      if (Item->getRegNumTmp() == MinWeightIndex &&
-          Item->rangeOverlaps(Iter.Cur)) {
-        dumpLiveRangeTrace("Evicting     ", Item);
+      if (Aliases[Item->getRegNumTmp()] && Item->rangeOverlaps(Iter.Cur)) {
+        dumpLiveRangeTrace("Evicting I   ", Item);
         Item->setRegNumTmp(Variable::NoRegister);
         moveItem(Inactive, Index, Handled);
       }
     }
     // Assign the register to Cur.
     Iter.Cur->setRegNumTmp(MinWeightIndex);
-    const llvm::SmallBitVector &Aliases = *RegAliases[MinWeightIndex];
     for (int32_t RegAlias = Aliases.find_first(); RegAlias >= 0;
          RegAlias = Aliases.find_next(RegAlias)) {
       assert(RegUses[RegAlias] >= 0);
       ++RegUses[RegAlias];
     }
     Active.push_back(Iter.Cur);
     dumpLiveRangeTrace("Allocating   ", Iter.Cur);
   }
 }
 
@@ skipping 243 matching lines @@
     Str << "\n";
   }
   Str << "++++++ Inactive:\n";
   for (const Variable *Item : Inactive) {
     dumpLiveRange(Item, Func);
     Str << "\n";
   }
 }
 
 } // end of namespace Ice