Subzero: Prototype to make use of RegNumT::No Register more concise

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 484 matching lines @@
 // the current Variable has an unambiguous "first" definition. The preference is
 // some source Variable of the defining instruction that either is assigned a
 // register that is currently free, or that is assigned a register that is not
 // free but overlap is allowed. Overlap is allowed when the Variable under
 // consideration is single-definition, and its definition is a simple assignment
 // - i.e., the register gets copied/aliased but is never modified.  Furthermore,
 // overlap is only allowed when preferred Variable definition instructions do
 // not appear within the current Variable's live range.
 void LinearScan::findRegisterPreference(IterationState &Iter) {
   Iter.Prefer = nullptr;
-  Iter.PreferReg = RegNumT::NoRegister;
+  Iter.PreferReg = RegNumT();
   Iter.AllowOverlap = false;
 
   if (!FindPreference)
     return;
 
   VariablesMetadata *VMetadata = Func->getVMetadata();
   const Inst *DefInst = VMetadata->getFirstDefinitionSingleBlock(Iter.Cur);
   if (DefInst == nullptr)
     return;
 
@@ skipping 215 matching lines @@
     const SizeT Index = I - 1;
     Variable *Item = Active[Index];
     const auto RegNum = Item->getRegNumTmp();
     if (Aliases[RegNum]) {
       dumpLiveRangeTrace("Evicting A   ", Item);
       const llvm::SmallBitVector &Aliases = *RegAliases[RegNum];
       for (RegNumT RegAlias : RegNumBVIter(Aliases)) {
         --RegUses[RegAlias];
         assert(RegUses[RegAlias] >= 0);
       }
-      Item->setRegNumTmp(RegNumT::NoRegister);
+      Item->setRegNumTmp(RegNumT());
       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 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 (Aliases[Item->getRegNumTmp()] && Item->rangeOverlaps(Iter.Cur)) {
       dumpLiveRangeTrace("Evicting I   ", Item);
-      Item->setRegNumTmp(RegNumT::NoRegister);
+      Item->setRegNumTmp(RegNumT());
       moveItem(Inactive, Index, Handled);
       Evicted.push_back(Item);
     }
   }
   // Assign the register to Cur.
   Iter.Cur->setRegNumTmp(RegNumT::fromInt(MinWeightIndex));
   for (RegNumT RegAlias : RegNumBVIter(Aliases)) {
     assert(RegUses[RegAlias] >= 0);
     ++RegUses[RegAlias];
   }
@@ skipping 241 matching lines @@
     Str << "\n";
   }
   Str << "++++++ Inactive:\n";
   for (const Variable *Item : Inactive) {
     dumpLiveRange(Item, Func);
     Str << "\n";
   }
 }
 
 } // end of namespace Ice