[Transforms] 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/Transforms/Scalar/SCCP.cpp

2200

Drop top-level const, here and elsewhere?

llvm/lib/Transforms/IPO/WholeProgramDevirt.cpp

bool DevirtModule::tryFindVirtualCallTargets(
 
   // Give up if we couldn't find any targets.
   return !TargetsForSlot.empty();
 }
 
 bool DevirtIndex::tryFindVirtualCallTargets(
     std::vector<ValueInfo> &TargetsForSlot, const TypeIdCompatibleVtableInfo TIdInfo,
     uint64_t ByteOffset) {
-  for (const TypeIdOffsetVtableInfo P : TIdInfo) {
+  for (const TypeIdOffsetVtableInfo &P : TIdInfo) {
     // Ensure that we have at most one external linkage vtable initializer.
     assert(P.VTableVI.getSummaryList().size() == 1 ||
            llvm::count_if(
                P.VTableVI.getSummaryList(),
                [&](const std::unique_ptr<GlobalValueSummary> &Summary) {
                  return GlobalValue::isExternalLinkage(Summary->linkage());
                }) <= 1);
     // Find the first non-available_externally linkage vtable initializer.

llvm/lib/Transforms/Scalar/LoopLoadElimination.cpp

bool processLoop() {
     // fed by multiple stores.
     removeDependencesFromMultipleStores(StoreToLoadDependences);
     if (StoreToLoadDependences.empty())
       return false;
 
     // Filter the candidates further.
     SmallVector<StoreToLoadForwardingCandidate, 4> Candidates;
     unsigned NumForwarding = 0;
-    for (const StoreToLoadForwardingCandidate Cand : StoreToLoadDependences) {
+    for (const StoreToLoadForwardingCandidate &Cand : StoreToLoadDependences) {
       LLVM_DEBUG(dbgs() << "Candidate " << Cand);
 
       // Make sure that the stored values is available everywhere in the loop in
       // the next iteration.
       if (!doesStoreDominatesAllLatches(Cand.Store->getParent(), L, DT))
         continue;
 
       // If the load is conditional we can't hoist its 0-iteration instance to

llvm/lib/Transforms/Scalar/SCCP.cpp

bool llvm::runIPSCCP(
   const MapVector<Function*, LatticeVal> &RV = Solver.getTrackedRetVals();
   for (const auto &I : RV) {
     Function *F = I.first;
     if (I.second.isOverdefined() || F->getReturnType()->isVoidTy())
       continue;
     findReturnsToZap(*F, ReturnsToZap, Solver);
   }
 
-  for (const auto &F : Solver.getMRVFunctionsTracked()) {
+  for (auto F : Solver.getMRVFunctionsTracked()) {
     assert(F->getReturnType()->isStructTy() &&
            "The return type should be a struct");
     StructType *STy = cast<StructType>(F->getReturnType());
     if (Solver.isStructLatticeConstant(F, STy))
       findReturnsToZap(*F, ReturnsToZap, Solver);
   }
 
   // Zap all returns which we've identified as zap to change.

llvm/lib/Transforms/Utils/InlineFunction.cpp

 /// callee's entry block gets the same frequency as the callsite block and the
 /// relative frequencies of all cloned blocks remain the same after cloning.
 static void updateCallerBFI(BasicBlock *CallSiteBlock,
                             const ValueToValueMapTy &VMap,
                             BlockFrequencyInfo *CallerBFI,
                             BlockFrequencyInfo *CalleeBFI,
                             const BasicBlock &CalleeEntryBlock) {
   SmallPtrSet<BasicBlock *, 16> ClonedBBs;
-  for (auto const &Entry : VMap) {
+  for (auto Entry : VMap) {
     if (!isa<BasicBlock>(Entry.first) || !Entry.second)
       continue;
     auto *OrigBB = cast<BasicBlock>(Entry.first);
     auto *ClonedBB = cast<BasicBlock>(Entry.second);
     uint64_t Freq = CalleeBFI->getBlockFreq(OrigBB).getFrequency();
     if (!ClonedBBs.insert(ClonedBB).second) {
       // Multiple blocks in the callee might get mapped to one cloned block in
       // the caller since we prune the callee as we clone it. When that happens,
void llvm::updateProfileCallee(
   if (entryDelta < 0 && static_cast<uint64_t>(-entryDelta) > priorEntryCount)
     newEntryCount = 0;
   else
     newEntryCount = priorEntryCount + entryDelta;
 
   // During inlining ?
   if (VMap) {
     uint64_t cloneEntryCount = priorEntryCount - newEntryCount;
-    for (auto const &Entry : *VMap)
+    for (auto Entry : *VMap)
       if (isa<CallInst>(Entry.first))
         if (auto *CI = dyn_cast_or_null<CallInst>(Entry.second))
           CI->updateProfWeight(cloneEntryCount, priorEntryCount);
   }
 
   if (entryDelta) {
     Callee->setEntryCount(newEntryCount);
 

llvm/lib/Transforms/Utils/LoopUnrollPeel.cpp

for (PHINode &PHI : Edge.second->phis()) {
       Instruction *LatchInst = dyn_cast<Instruction>(LatchVal);
       if (LatchInst && L->contains(LatchInst))
         LatchVal = VMap[LatchVal];
       PHI.addIncoming(LatchVal, cast<BasicBlock>(VMap[Edge.first]));
     }
 
   // LastValueMap is updated with the values for the current loop
   // which are used the next time this function is called.
-  for (const auto &KV : VMap)
+  for (auto KV : VMap)
     LVMap[KV.first] = KV.second;
 }
 
 /// Peel off the first \p PeelCount iterations of loop \p L.
 ///
 /// Note that this does not peel them off as a single straight-line block.
 /// Rather, each iteration is peeled off separately, and needs to check the
 /// exit condition.