[CodeGen] Use MCRegister::id() to avoid implicit conversions to unsigned. NFC (#159965)

Author: topperc

llvm/lib/CodeGen/AggressiveAntiDepBreaker.cpp

@@ -68,7 +68,7 @@ AggressiveAntiDepState::AggressiveAntiDepState(const unsigned TargetRegs,
 }
 
 unsigned AggressiveAntiDepState::GetGroup(MCRegister Reg) {
-  unsigned Node = GroupNodeIndices[Reg];
+  unsigned Node = GroupNodeIndices[Reg.id()];
   while (GroupNodes[Node] != Node)
     Node = GroupNodes[Node];
 
@@ -106,14 +106,14 @@ unsigned AggressiveAntiDepState::LeaveGroup(MCRegister Reg) {
   // it.
   unsigned idx = GroupNodes.size();
   GroupNodes.push_back(idx);
-  GroupNodeIndices[Reg] = idx;
+  GroupNodeIndices[Reg.id()] = idx;
   return idx;
 }
 
 bool AggressiveAntiDepState::IsLive(MCRegister Reg) {
   // KillIndex must be defined and DefIndex not defined for a register
   // to be live.
-  return((KillIndices[Reg] != ~0u) && (DefIndices[Reg] == ~0u));
+  return ((KillIndices[Reg.id()] != ~0u) && (DefIndices[Reg.id()] == ~0u));
 }
 
 AggressiveAntiDepBreaker::AggressiveAntiDepBreaker(
@@ -154,10 +154,10 @@ void AggressiveAntiDepBreaker::StartBlock(MachineBasicBlock *BB) {
   for (MachineBasicBlock *Succ : BB->successors())
     for (const auto &LI : Succ->liveins()) {
       for (MCRegAliasIterator AI(LI.PhysReg, TRI, true); AI.isValid(); ++AI) {
-        unsigned Reg = *AI;
+        MCRegister Reg = *AI;
         State->UnionGroups(Reg, 0);
-        KillIndices[Reg] = BB->size();
-        DefIndices[Reg] = ~0u;
+        KillIndices[Reg.id()] = BB->size();
+        DefIndices[Reg.id()] = ~0u;
       }
     }
 
@@ -174,8 +174,8 @@ void AggressiveAntiDepBreaker::StartBlock(MachineBasicBlock *BB) {
     for (MCRegAliasIterator AI(Reg, TRI, true); AI.isValid(); ++AI) {
       MCRegister AliasReg = *AI;
       State->UnionGroups(AliasReg, 0);
-      KillIndices[AliasReg] = BB->size();
-      DefIndices[AliasReg] = ~0u;
+      KillIndices[AliasReg.id()] = BB->size();
+      DefIndices[AliasReg.id()] = ~0u;
     }
   }
 }
@@ -307,8 +307,8 @@ void AggressiveAntiDepBreaker::HandleLastUse(MCRegister Reg, unsigned KillIdx,
     }
 
   if (!State->IsLive(Reg)) {
-    KillIndices[Reg] = KillIdx;
-    DefIndices[Reg] = ~0u;
+    KillIndices[Reg.id()] = KillIdx;
+    DefIndices[Reg.id()] = ~0u;
     RegRefs.erase(Reg);
     State->LeaveGroup(Reg);
     LLVM_DEBUG(if (header) {
@@ -651,7 +651,7 @@ bool AggressiveAntiDepBreaker::FindSuitableFreeRegisters(
       LLVM_DEBUG(dbgs() << " " << printReg(NewReg, TRI));
 
       // Check if Reg can be renamed to NewReg.
-      if (!RenameRegisterMap[Reg].test(NewReg)) {
+      if (!RenameRegisterMap[Reg].test(NewReg.id())) {
         LLVM_DEBUG(dbgs() << "(no rename)");
         goto next_super_reg;
       }
@@ -660,15 +660,16 @@ bool AggressiveAntiDepBreaker::FindSuitableFreeRegisters(
       // Regs's kill, it's safe to replace Reg with NewReg. We
       // must also check all aliases of NewReg, because we can't define a
       // register when any sub or super is already live.
-      if (State->IsLive(NewReg) || (KillIndices[Reg] > DefIndices[NewReg])) {
+      if (State->IsLive(NewReg) ||
+          (KillIndices[Reg.id()] > DefIndices[NewReg.id()])) {
         LLVM_DEBUG(dbgs() << "(live)");
         goto next_super_reg;
       } else {
         bool found = false;
         for (MCRegAliasIterator AI(NewReg, TRI, false); AI.isValid(); ++AI) {
           MCRegister AliasReg = *AI;
           if (State->IsLive(AliasReg) ||
-              (KillIndices[Reg] > DefIndices[AliasReg])) {
+              (KillIndices[Reg.id()] > DefIndices[AliasReg.id()])) {
             LLVM_DEBUG(dbgs()
                        << "(alias " << printReg(AliasReg, TRI) << " live)");
             found = true;
@@ -940,15 +941,15 @@ unsigned AggressiveAntiDepBreaker::BreakAntiDependencies(
             // the state as if it were dead.
             State->UnionGroups(NewReg, 0);
             RegRefs.erase(NewReg);
-            DefIndices[NewReg] = DefIndices[CurrReg];
-            KillIndices[NewReg] = KillIndices[CurrReg];
+            DefIndices[NewReg.id()] = DefIndices[CurrReg.id()];
+            KillIndices[NewReg.id()] = KillIndices[CurrReg.id()];
 
             State->UnionGroups(CurrReg, 0);
             RegRefs.erase(CurrReg);
-            DefIndices[CurrReg] = KillIndices[CurrReg];
-            KillIndices[CurrReg] = ~0u;
-            assert(((KillIndices[CurrReg] == ~0u) !=
-                    (DefIndices[CurrReg] == ~0u)) &&
+            DefIndices[CurrReg.id()] = KillIndices[CurrReg.id()];
+            KillIndices[CurrReg.id()] = ~0u;
+            assert(((KillIndices[CurrReg.id()] == ~0u) !=
+                    (DefIndices[CurrReg.id()] == ~0u)) &&
                    "Kill and Def maps aren't consistent for AntiDepReg!");
           }
 

llvm/lib/CodeGen/CriticalAntiDepBreaker.cpp

@@ -70,7 +70,7 @@ void CriticalAntiDepBreaker::StartBlock(MachineBasicBlock *BB) {
         MCRegister Reg = *AI;
         Classes[Reg.id()] = reinterpret_cast<TargetRegisterClass *>(-1);
         KillIndices[Reg.id()] = BBSize;
-        DefIndices[Reg] = ~0u;
+        DefIndices[Reg.id()] = ~0u;
       }
     }
 
@@ -412,11 +412,12 @@ MCRegister CriticalAntiDepBreaker::findSuitableFreeRegister(
     assert(((KillIndices[AntiDepReg.id()] == ~0u) !=
             (DefIndices[AntiDepReg.id()] == ~0u)) &&
            "Kill and Def maps aren't consistent for AntiDepReg!");
-    assert(((KillIndices[NewReg] == ~0u) != (DefIndices[NewReg] == ~0u))
-           && "Kill and Def maps aren't consistent for NewReg!");
-    if (KillIndices[NewReg] != ~0u ||
-        Classes[NewReg] == reinterpret_cast<TargetRegisterClass *>(-1) ||
-        KillIndices[AntiDepReg.id()] > DefIndices[NewReg])
+    assert(((KillIndices[NewReg.id()] == ~0u) !=
+            (DefIndices[NewReg.id()] == ~0u)) &&
+           "Kill and Def maps aren't consistent for NewReg!");
+    if (KillIndices[NewReg.id()] != ~0u ||
+        Classes[NewReg.id()] == reinterpret_cast<TargetRegisterClass *>(-1) ||
+        KillIndices[AntiDepReg.id()] > DefIndices[NewReg.id()])
       continue;
     // If NewReg overlaps any of the forbidden registers, we can't use it.
     bool Forbidden = false;
@@ -641,8 +642,8 @@ BreakAntiDependencies(const std::vector<SUnit> &SUnits,
                 std::multimap<MCRegister, MachineOperand *>::iterator>
           Range = RegRefs.equal_range(AntiDepReg);
       if (MCRegister NewReg = findSuitableFreeRegister(
-              Range.first, Range.second, AntiDepReg, LastNewReg[AntiDepReg], RC,
-              ForbidRegs)) {
+              Range.first, Range.second, AntiDepReg,
+              LastNewReg[AntiDepReg.id()], RC, ForbidRegs)) {
         LLVM_DEBUG(dbgs() << "Breaking anti-dependence edge on "
                           << printReg(AntiDepReg, TRI) << " with "
                           << RegRefs.count(AntiDepReg) << " references"

llvm/lib/CodeGen/ExecutionDomainFix.cpp

@@ -18,7 +18,7 @@ using namespace llvm;
 iterator_range<SmallVectorImpl<int>::const_iterator>
 ExecutionDomainFix::regIndices(MCRegister Reg) const {
   assert(Reg < AliasMap.size() && "Invalid register");
-  const auto &Entry = AliasMap[Reg];
+  const auto &Entry = AliasMap[Reg.id()];
   return make_range(Entry.begin(), Entry.end());
 }