Subzero: Various fixes in preparation for x86-32 register aliasing.

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 483 matching lines @@
             VMetadata->getFirstDefinitionSingleBlock(Iter.Cur)) {
       assert(DefInst->getDest() == Iter.Cur);
       bool IsAssign = DefInst->isVarAssign();
       bool IsSingleDef = !VMetadata->isMultiDef(Iter.Cur);
       FOREACH_VAR_IN_INST(SrcVar, *DefInst) {
         // Only consider source variables that have (so far) been assigned a
         // register. That register must be one in the RegMask set, e.g. don't
         // try to prefer the stack pointer as a result of the stacksave
         // intrinsic.
         if (SrcVar->hasRegTmp()) {
-          const int32_t SrcReg = SrcVar->getRegNumTmp();
-          const bool IsAliasAvailable =
-              (Iter.RegMask & *RegAliases[SrcReg]).any();
+          const llvm::SmallBitVector &Aliases =
+              *RegAliases[SrcVar->getRegNumTmp()];
+          const int32_t SrcReg = (Iter.RegMask & Aliases).find_first();
+          const bool IsAliasAvailable = (SrcReg != -1);
           if (IsAliasAvailable) {
             if (FindOverlap && !Iter.Free[SrcReg]) {
               // Don't bother trying to enable AllowOverlap if the register is
               // already free.
               Iter.AllowOverlap = IsSingleDef && IsAssign &&
                                   !overlapsDefs(Func, Iter.Cur, SrcVar);
             }
             if (Iter.AllowOverlap || Iter.Free[SrcReg]) {
               Iter.Prefer = SrcVar;
               Iter.PreferReg = SrcReg;
@@ skipping 170 matching lines @@
   } 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];
       int32_t RegNum = Item->getRegNumTmp();
       if (Aliases[RegNum]) {
         dumpLiveRangeTrace("Evicting A   ", Item);
-        --RegUses[RegNum];
-        assert(RegUses[RegNum] >= 0);
+        const llvm::SmallBitVector &Aliases = *RegAliases[RegNum];
+        for (int32_t RegAlias = Aliases.find_first(); RegAlias >= 0;
+             RegAlias = Aliases.find_next(RegAlias)) {
+          --RegUses[RegAlias];
+          assert(RegUses[RegAlias] >= 0);
+        }
         Item->setRegNumTmp(Variable::NoRegister);
         moveItem(Active, Index, Handled);
         Evicted.push_back(Item);
       }
     }
     // 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
@@ skipping 270 matching lines @@
     Str << "\n";
   }
   Str << "++++++ Inactive:\n";
   for (const Variable *Item : Inactive) {
     dumpLiveRange(Item, Func);
     Str << "\n";
   }
 }
 
 } // end of namespace Ice