[Hexagon] Fixes -Wrange-loop-analysis warnings

[Mordante]

Summary

This avoids new warnings due to D68912 adds -Wrange-loop-analysis to -Wall.

[aaron.ballman]

LGTM with a request to drop top-level consts

llvm/lib/Target/Hexagon/HexagonLoopIdiomRecognition.cpp

2338

Drop top-level const?

llvm/lib/Target/Hexagon/BitTracker.cpp

for (unsigned i = 0, n = MI.getNumOperands(); i < n; ++i) {
       const MachineOperand &MO = MI.getOperand(i);
       if (!MO.isReg() || !MO.isUse())
         continue;
       RegisterRef RU(MO);
       dbgs() << "  input reg: " << printReg(RU.Reg, &ME.TRI, RU.Sub)
              << " cell: " << ME.getCell(RU, Map) << "\n";
     }
     dbgs() << "Outputs:\n";
-    for (const std::pair<unsigned, RegisterCell> &P : ResMap) {
+    for (const std::pair<const unsigned, RegisterCell> &P : ResMap) {
       RegisterRef RD(P.first);
       dbgs() << "  " << printReg(P.first, &ME.TRI) << " cell: "
              << ME.getCell(RD, ResMap) << "\n";
     }
   }
 
   // Iterate over all definitions of the instruction, and update the
   // cells accordingly.

llvm/lib/Target/Hexagon/HexagonConstExtenders.cpp

PrintIMap(const HCE::AssignmentMap &M, const HexagonRegisterInfo &I)
       : IMap(M), HRI(I) {}
     const HCE::AssignmentMap &IMap;
     const HexagonRegisterInfo &HRI;
   };
 
   LLVM_ATTRIBUTE_UNUSED
   raw_ostream &operator<< (raw_ostream &OS, const PrintIMap &P) {
     OS << "{\n";
-    for (const std::pair<HCE::ExtenderInit,HCE::IndexList> &Q : P.IMap) {
+    for (const std::pair<const HCE::ExtenderInit, HCE::IndexList> &Q : P.IMap) {
       OS << "  " << PrintInit(Q.first, P.HRI) << " -> {";
       for (unsigned I : Q.second)
         OS << ' ' << I;
       OS << " }\n";
     }
     OS << "}\n";
     return OS;
   }
bool HCE::replaceInstr(unsigned Idx, Register ExtR, const ExtenderInit &ExtI) {
 
   return Replaced;
 }
 
 bool HCE::replaceExtenders(const AssignmentMap &IMap) {
   LocDefList Defs;
   bool Changed = false;
 
-  for (const std::pair<ExtenderInit,IndexList> &P : IMap) {
+  for (const std::pair<const ExtenderInit, IndexList> &P : IMap) {
     const IndexList &Idxs = P.second;
     if (Idxs.size() < CountThreshold)
       continue;
 
     Defs.clear();
     calculatePlacement(P.first, Idxs, Defs);
     for (const std::pair<Loc,IndexList> &Q : Defs) {
       Register DefR = insertInitializer(Q.first, P.first);

llvm/lib/Target/Hexagon/HexagonLoopIdiomRecognition.cpp

bool HexagonLoopIdiomRecognize::coverLoop(Loop *L,
   // the loop has a side-effect visible outside of it, or there are
   // instructions in it that are not involved in the original set Insts.
   for (auto *B : L->blocks()) {
     for (auto &In : *B) {
       if (isa<BranchInst>(In) || isa<DbgInfoIntrinsic>(In))
         continue;
       if (!Worklist.count(&In) && In.mayHaveSideEffects())
         return false;
-      for (const auto &K : In.users()) {
+      for (const auto K : In.users()) {
         Instruction *UseI = dyn_cast<Instruction>(K);
         if (!UseI)
           continue;
         BasicBlock *UseB = UseI->getParent();
         if (LF->getLoopFor(UseB) != L)
           return false;
       }
     }

llvm/lib/Target/Hexagon/HexagonVLIWPacketizer.cpp

if (DepReg == HRI->getFrameRegister() || DepReg == HRI->getStackRegister())
       return true;
 
   // Call-like instructions can be packetized with preceding instructions
   // that define registers implicitly used or modified by the call. Explicit
   // uses are still prohibited, as in the case of indirect calls:
   //   r0 = ...
   //   J2_jumpr r0
   if (DepType == SDep::Data) {
-    for (const MachineOperand MO : MI.operands())
+    for (const MachineOperand &MO : MI.operands())
       if (MO.isReg() && MO.getReg() == DepReg && !MO.isImplicit())
         return true;
   }
 
   return false;
 }
 
 static bool isRegDependence(const SDep::Kind DepType) {

llvm/lib/Target/Hexagon/RDFLiveness.cpp

void Liveness::computePhiInfo() {
   for (unsigned i = 0; i < PhiUQ.size(); ++i) {
     auto PA = DFG.addr<PhiNode*>(PhiUQ[i]);
     NodeList PUs = PA.Addr->members_if(DFG.IsRef<NodeAttrs::Use>, DFG);
     RefMap &RUM = RealUseMap[PA.Id];
 
     for (NodeAddr<UseNode*> UA : PUs) {
       std::map<NodeId,RegisterAggr> &PUM = PhiUp[UA.Id];
       RegisterRef UR = PRI.normalize(UA.Addr->getRegRef(DFG));
-      for (const std::pair<NodeId,RegisterAggr> &P : PUM) {
+      for (const std::pair<const NodeId, RegisterAggr> &P : PUM) {
         bool Changed = false;
         const RegisterAggr &MidDefs = P.second;
 
         // Collect the set PropUp of uses that are reached by the current
         // phi PA, and are not covered by any intervening def between the
         // currently visited use UA and the upward phi P.
 
         if (MidDefs.hasCoverOf(UR))
           continue;
 
         // General algorithm:
         //   for each (R,U) : U is use node of R, U is reached by PA
         //     if MidDefs does not cover (R,U)
         //       then add (R-MidDefs,U) to RealUseMap[P]
         //
-        for (const std::pair<RegisterId,NodeRefSet> &T : RUM) {
+        for (const std::pair<const RegisterId, NodeRefSet> &T : RUM) {
           RegisterRef R(T.first);
           // The current phi (PA) could be a phi for a regmask. It could
           // reach a whole variety of uses that are not related to the
           // specific upward phi (P.first).
           const RegisterAggr &DRs = PhiDRs.at(P.first);
           if (!DRs.hasAliasOf(R))
             continue;
           R = PRI.mapTo(DRs.intersectWith(R), T.first);
for (NodeAddr<PhiNode*> PA : Phis) {
         // chain will need to fork at this phi, since some of the reached
         // uses may have definitions joining in from multiple predecessors.
         // For each reached "real" use, identify the set of reaching defs
         // coming from each predecessor P, and add them to PhiLOX[P].
         //
         auto PrA = DFG.addr<BlockNode*>(PUA.Addr->getPredecessor());
         RefMap &LOX = PhiLOX[PrA.Addr->getCode()];
 
-        for (const std::pair<RegisterId,NodeRefSet> &RS : RUs) {
+        for (const std::pair<const RegisterId, NodeRefSet> &RS : RUs) {
           // We need to visit each individual use.
           for (std::pair<NodeId,LaneBitmask> P : RS.second) {
             // Create a register ref corresponding to the use, and find
             // all reaching defs starting from the phi use, and treating
             // all related shadows as a single use cluster.
             RegisterRef S(RS.first, P.second);
             NodeList Ds = getAllReachingDefs(S, PUA, true, false, NoRegs);
             for (NodeAddr<DefNode*> D : Ds) {
void Liveness::traverse(MachineBasicBlock *B, RefMap &LiveIn) {
   // defs that are present in this block. Then we will add reaching defs of
   // all upward-exposed uses.
 
   // To filter out the defs, first make a copy of LiveIn, and then re-populate
   // LiveIn with the defs that should remain.
   RefMap LiveInCopy = LiveIn;
   LiveIn.clear();
 
-  for (const std::pair<RegisterId,NodeRefSet> &LE : LiveInCopy) {
+  for (const std::pair<const RegisterId, NodeRefSet> &LE : LiveInCopy) {
     RegisterRef LRef(LE.first);
     NodeRefSet &NewDefs = LiveIn[LRef.Reg]; // To be filled.
     const NodeRefSet &OldDefs = LE.second;
     for (NodeRef OR : OldDefs) {
       // R is a def node that was live-on-exit
       auto DA = DFG.addr<DefNode*>(OR.first);
       NodeAddr<InstrNode*> IA = DA.Addr->getOwner(DFG);
       NodeAddr<BlockNode*> BA = IA.Addr->getOwner(DFG);
void Liveness::traverse(MachineBasicBlock *B, RefMap &LiveIn) {
   if (Trace) {
     dbgs() << "after phi uses in block\n";
     dbgs() << "  LiveIn: " << Print<RefMap>(LiveIn, DFG) << '\n';
     dbgs() << "  Local:  " << Print<RegisterAggr>(Local, DFG) << '\n';
   }
 
   for (auto C : IIDF[B]) {
     RegisterAggr &LiveC = LiveMap[C];
-    for (const std::pair<RegisterId,NodeRefSet> &S : LiveIn)
+    for (const std::pair<const RegisterId, NodeRefSet> &S : LiveIn)
       for (auto R : S.second)
         if (MDT.properlyDominates(getBlockWithRef(R.first), C))
           LiveC.insert(RegisterRef(S.first, R.second));
   }
 }
 
 void Liveness::emptify(RefMap &M) {
   for (auto I = M.begin(), E = M.end(); I != E; )
     I = I->second.empty() ? M.erase(I) : std::next(I);
 }