[NFC] Fixes -Wrange-loop-analysis warnings

[Mordante]

Summary

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

This should be the last cleanup patch.

[merge_guards_bot]

Unit tests: pass. 61116 tests passed, 0 failed and 728 were skipped.

clang-tidy: fail. Please fix clang-tidy findings.

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[xbolva00]

lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptx86ABIFixups.cpp

22

NFC patch?

[aaron.ballman]

It seems like some of the deductions are not spelling out the qualifiers or pointer/references explicitly in some cases, at least from my spot-checking. Can you go back through this patch to make sure we're getting those correct?

clang-tools-extra/clang-tidy/cppcoreguidelines/SlicingCheck.cpp

78

Shouldn't this deduce to const auto *?

clang-tools-extra/clang-tidy/readability/IdentifierNamingCheck.cpp

795

Same here.

lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptx86ABIFixups.cpp

75

auto *?

llvm/lib/Support/CommandLine.cpp

246

auto *?

2115

auto *?

[Mordante]

Reviewed the types and added a * for pointers and added a const when applicable.

[Mordante]

lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptx86ABIFixups.cpp

22

Changed to NFC.

75

Changed to const auto *

[aaron.ballman]

LGTM, thank you!

[Mordante]

Thanks for the review! I'll commit all the -Wrange-loop-analysis patches later today.

[MaskRay]

I really like the new feature. Thanks for making the efforts!

However, I am afraid I don't like some of the fixes here. You can replace const auto with const auto & and call that a fix... IMHO if the type is not obvious, const ConcreteType & will be better.

I think there is a false positive.

https://github.com/llvm/llvm-project/tree/master/lld/ELF/Relocations.cpp#L1622

for (const std::pair<ThunkSection *, uint32_t> ts : isd->thunkSections)

Diagnostic:

lld/ELF/Relocations.cpp:1622:14: note: use reference type 'const std::pair<ThunkSection *, uint32_t> &' (aka 'const pair<lld::elf::ThunkSection *, unsigned int> &') to prevent copying
            for (const std::pair<ThunkSection *, uint32_t> ts : isd->thunkSections)

i.e. The diagnostic asks me to replace const std::pair<T *, size_t> with const std::pair<T *, size_t> &, when it is clear that the type is cheap to copy.

[Mordante]

In D71857#1800663, @MaskRay wrote:

However, I am afraid I don't like some of the fixes here. You can replace const auto with const auto & and call that a fix... IMHO if the type is not obvious, const ConcreteType & will be better.

I notice some parts of the code prefer auto and others ConcreteType, so there is no consensus on what is the best. I feel with this change I want to change as little as possible.

I think there is a false positive.

https://github.com/llvm/llvm-project/tree/master/lld/ELF/Relocations.cpp#L1622

for (const std::pair<ThunkSection *, uint32_t> ts : isd->thunkSections)

Diagnostic:

lld/ELF/Relocations.cpp:1622:14: note: use reference type 'const std::pair<ThunkSection *, uint32_t> &' (aka 'const pair<lld::elf::ThunkSection *, unsigned int> &') to prevent copying
            for (const std::pair<ThunkSection *, uint32_t> ts : isd->thunkSections)

i.e. The diagnostic asks me to replace const std::pair<T *, size_t> with const std::pair<T *, size_t> &, when it is clear that the type is cheap to copy.

The code has a 'protection' for this case clang/lib/Sema/SemaStmt.cpp:2803:

// TODO: Determine a maximum size that a POD type can be before a diagnostic
// should be emitted.  Also, only ignore POD types with trivial copy
// constructors.
if (VariableType.isPODType(SemaRef.Context))
  return;

I could change this protection to test whether the type is trivially copyable which will reduce the number of warnings. Unfortunately std::pair is not trivially copyable so that won't help here. Do you think it makes sense to allow trivially copyable types instead of POD types? Any suggestion how we could solve it for std::pair?

[Mordante]

In D71857#1800663, @MaskRay wrote:

I think there is a false positive.

https://github.com/llvm/llvm-project/tree/master/lld/ELF/Relocations.cpp#L1622

for (const std::pair<ThunkSection *, uint32_t> ts : isd->thunkSections)

Removing the const like L1648 will also solve the issue.

[MaskRay]

In D71857#1804307, @Mordante wrote:

In D71857#1800663, @MaskRay wrote:

I think there is a false positive.

https://github.com/llvm/llvm-project/tree/master/lld/ELF/Relocations.cpp#L1622

for (const std::pair<ThunkSection *, uint32_t> ts : isd->thunkSections)

Removing the const like L1648 will also solve the issue.

Yes, both std::pair and auto work, but const std::pair doesn't. std::pair has an unfortunate user-defined copy assignment operator (https://eel.is/c++draft/pairs#pair-16 "Assigns p.first to first and p.second to second." Does this wording mandate a user-defined function?) I will drop const for this lld file.

For other user-defined types. I think loosening the diagnostic to allow trivially copyable types will be nice. Types that take only a few words (say. 1~3) are likely faster with a copy.

clang-tools-extra/clang-doc/MDGenerator.cpp

else if (VParents.empty())
       writeLine("Inherits from " + Parents, OS);
     else
       writeLine("Inherits from " + Parents + ", " + VParents, OS);
     writeNewLine(OS);
   }
 
   if (!I.Members.empty()) {
     writeHeader("Members", 2, OS);
-    for (const auto Member : I.Members) {
+    for (const auto &Member : I.Members) {
       std::string Access = getAccess(Member.Access);
       if (Access != "")
         writeLine(Access + " " + Member.Type.Name + " " + Member.Name, OS);
       else
         writeLine(Member.Type.Name + " " + Member.Name, OS);
     }
     writeNewLine(OS);
   }

clang-tools-extra/clang-tidy/cppcoreguidelines/SlicingCheck.cpp

 /// Warns on methods overridden in DerivedDecl with respect to BaseDecl.
 /// FIXME: this warns on all overrides outside of the sliced path in case of
 /// multiple inheritance.
 void SlicingCheck::DiagnoseSlicedOverriddenMethods(
     const Expr &Call, const CXXRecordDecl &DerivedDecl,
     const CXXRecordDecl &BaseDecl) {
   if (DerivedDecl.getCanonicalDecl() == BaseDecl.getCanonicalDecl())
     return;
-  for (const auto &Method : DerivedDecl.methods()) {
+  for (const auto *Method : DerivedDecl.methods()) {
     // Virtual destructors are OK. We're ignoring constructors since they are
     // tagged as overrides.
     if (isa<CXXConstructorDecl>(Method) || isa<CXXDestructorDecl>(Method))
       continue;
     if (Method->size_overridden_methods() > 0) {
       diag(Call.getExprLoc(),
            "slicing object from type %0 to %1 discards override %2")
           << &DerivedDecl << &BaseDecl << Method;

clang-tools-extra/clang-tidy/readability/IdentifierNamingCheck.cpp

if (NestedNameSpecifier *Spec = Loc->getNestedNameSpecifier()) {
       if (NamespaceDecl *Decl = Spec->getAsNamespace()) {
         addUsage(NamingCheckFailures, Decl, Loc->getLocalSourceRange());
         return;
       }
     }
   }
 
   if (const auto *Decl = Result.Nodes.getNodeAs<UsingDecl>("using")) {
-    for (const auto &Shadow : Decl->shadows()) {
+    for (const auto *Shadow : Decl->shadows()) {
       addUsage(NamingCheckFailures, Shadow->getTargetDecl(),
                Decl->getNameInfo().getSourceRange());
     }
     return;
   }
 
   if (const auto *DeclRef = Result.Nodes.getNodeAs<DeclRefExpr>("declRef")) {
     SourceRange Range = DeclRef->getNameInfo().getSourceRange();

clang-tools-extra/clang-tidy/utils/DeclRefExprUtils.cpp

 namespace decl_ref_expr {
 
 using namespace ::clang::ast_matchers;
 using llvm::SmallPtrSet;
 
 namespace {
 
 template <typename S> bool isSetDifferenceEmpty(const S &S1, const S &S2) {
-  for (const auto &E : S1)
+  for (auto E : S1)
     if (S2.count(E) == 0)
       return false;
   return true;
 }
 
 // Extracts all Nodes keyed by ID from Matches and inserts them into Nodes.
 template <typename Node>
 void extractNodesByIdTo(ArrayRef<BoundNodes> Matches, StringRef ID,

clang-tools-extra/clang-tidy/utils/ExceptionAnalyzer.cpp

if (const Stmt *Body = Func->getBody()) {
     ExceptionInfo Result =
         throwsException(Body, ExceptionInfo::Throwables(), CallStack);
     CallStack.erase(Func);
     return Result;
   }
 
   auto Result = ExceptionInfo::createUnknown();
   if (const auto *FPT = Func->getType()->getAs<FunctionProtoType>()) {
-    for (const QualType Ex : FPT->exceptions())
+    for (const QualType &Ex : FPT->exceptions())
       Result.registerException(Ex.getTypePtr());
   }
   return Result;
 }
 
 /// Analyzes a single statment on it's throwing behaviour. This is in principle
 /// possible except some 'Unknown' functions are called.
 ExceptionAnalyzer::ExceptionInfo ExceptionAnalyzer::throwsException(

clang-tools-extra/clangd/index/MemIndex.cpp

bool MemIndex::fuzzyFind(
   assert(!StringRef(Req.Query).contains("::") &&
          "There must be no :: in query.");
   trace::Span Tracer("MemIndex fuzzyFind");
 
   TopN<std::pair<float, const Symbol *>> Top(
       Req.Limit ? *Req.Limit : std::numeric_limits<size_t>::max());
   FuzzyMatcher Filter(Req.Query);
   bool More = false;
-  for (const auto Pair : Index) {
+  for (const auto &Pair : Index) {
     const Symbol *Sym = Pair.second;
 
     // Exact match against all possible scopes.
     if (!Req.AnyScope && !llvm::is_contained(Req.Scopes, Sym->Scope))
       continue;
     if (Req.RestrictForCodeCompletion &&
         !(Sym->Flags & Symbol::IndexedForCodeCompletion))
       continue;

clang/lib/CodeGen/CodeGenPGO.cpp

MapRegionCounters(PGOHashVersion HashVersion,
                     llvm::DenseMap<const Stmt *, unsigned> &CounterMap)
       : NextCounter(0), Hash(HashVersion), CounterMap(CounterMap) {}
 
   // Blocks and lambdas are handled as separate functions, so we need not
   // traverse them in the parent context.
   bool TraverseBlockExpr(BlockExpr *BE) { return true; }
   bool TraverseLambdaExpr(LambdaExpr *LE) {
     // Traverse the captures, but not the body.
-    for (const auto &C : zip(LE->captures(), LE->capture_inits()))
+    for (auto C : zip(LE->captures(), LE->capture_inits()))
       TraverseLambdaCapture(LE, &std::get<0>(C), std::get<1>(C));
     return true;
   }
   bool TraverseCapturedStmt(CapturedStmt *CS) { return true; }
 
   bool VisitDecl(const Decl *D) {
     switch (D->getKind()) {
     default:

clang/lib/CodeGen/ItaniumCXXABI.cpp

static void emitGlobalDtorWithCXAAtExit(CodeGenFunction &CGF,
   llvm::Value *args[] = {llvm::ConstantExpr::getBitCast(
                              cast<llvm::Constant>(dtor.getCallee()), dtorTy),
                          llvm::ConstantExpr::getBitCast(addr, AddrInt8PtrTy),
                          handle};
   CGF.EmitNounwindRuntimeCall(atexit, args);
 }
 
 void CodeGenModule::registerGlobalDtorsWithAtExit() {
-  for (const auto I : DtorsUsingAtExit) {
+  for (const auto &I : DtorsUsingAtExit) {
     int Priority = I.first;
     const llvm::TinyPtrVector<llvm::Function *> &Dtors = I.second;
 
     // Create a function that registers destructors that have the same priority.
     //
     // Since constructor functions are run in non-descending order of their
     // priorities, destructors are registered in non-descending order of their
     // priorities, and since destructor functions are run in the reverse order

clang/lib/StaticAnalyzer/Checkers/MoveChecker.cpp

void MoveChecker::checkPreCall(const CallEvent &Call, CheckerContext &C) const {
 
   modelUse(State, ThisRegion, RD, MK_FunCall, C);
 }
 
 void MoveChecker::checkDeadSymbols(SymbolReaper &SymReaper,
                                    CheckerContext &C) const {
   ProgramStateRef State = C.getState();
   TrackedRegionMapTy TrackedRegions = State->get<TrackedRegionMap>();
-  for (const auto &E : TrackedRegions) {
+  for (auto E : TrackedRegions) {
     const MemRegion *Region = E.first;
     bool IsRegDead = !SymReaper.isLiveRegion(Region);
 
     // Remove the dead regions from the region map.
     if (IsRegDead) {
       State = State->remove<TrackedRegionMap>(Region);
     }
   }

clang/lib/Tooling/ASTDiff/ASTDiff.cpp

 
 void ASTDiff::Impl::addOptimalMapping(Mapping &M, NodeId Id1,
                                       NodeId Id2) const {
   if (std::max(T1.getNumberOfDescendants(Id1), T2.getNumberOfDescendants(Id2)) >
       Options.MaxSize)
     return;
   ZhangShashaMatcher Matcher(*this, T1, T2, Id1, Id2);
   std::vector<std::pair<NodeId, NodeId>> R = Matcher.getMatchingNodes();
-  for (const auto Tuple : R) {
+  for (const auto &Tuple : R) {
     NodeId Src = Tuple.first;
     NodeId Dst = Tuple.second;
     if (!M.hasSrc(Src) && !M.hasDst(Dst))
       M.link(Src, Dst);
   }
 }
 
 double ASTDiff::Impl::getJaccardSimilarity(const Mapping &M, NodeId Id1,

clang/tools/clang-refactor/TestSupport.cpp

void dumpChanges(const tooling::AtomicChanges &Changes, raw_ostream &OS) {
   for (const auto &Change : Changes)
     OS << const_cast<tooling::AtomicChange &>(Change).toYAMLString() << "\n";
 }
 
 bool areChangesSame(const tooling::AtomicChanges &LHS,
                     const tooling::AtomicChanges &RHS) {
   if (LHS.size() != RHS.size())
     return false;
-  for (const auto &I : llvm::zip(LHS, RHS)) {
+  for (auto I : llvm::zip(LHS, RHS)) {
     if (!(std::get<0>(I) == std::get<1>(I)))
       return false;
   }
   return true;
 }
 
 bool printRewrittenSources(const tooling::AtomicChanges &Changes,
                            raw_ostream &OS) {

lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptx86ABIFixups.cpp

 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IRReader/IRReader.h"
 #include "llvm/Pass.h"
 
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/Log.h"
 
 using namespace lldb_private;
 namespace {
 
 bool isRSAPICall(llvm::Module &module, llvm::CallInst *call_inst) {
   // TODO get the list of renderscript modules from lldb and check if
   // this llvm::Module calls into any of them.
bool isRSAllocationPtrTy(const llvm::Type *type) {
   return ptr_type->isStructTy() &&
          ptr_type->getStructName().startswith("struct.rs_allocation");
 }
 
 bool isRSAllocationTyCallSite(llvm::Module &module, llvm::CallInst *call_inst) {
   (void)module;
   if (!call_inst->hasByValArgument())
     return false;
-  for (const auto &param : call_inst->operand_values())
+  for (const auto *param : call_inst->operand_values())
     if (isRSAllocationPtrTy(param->getType()))
       return true;
   return false;
 }
 
 llvm::FunctionType *cloneToStructRetFnTy(llvm::CallInst *call_inst) {
   // on x86 StructReturn functions return a pointer to the return value, rather
   // than the return value itself

lldb/source/Plugins/Platform/Android/AdbClient.cpp

Status AdbClient::GetDevices(DeviceIDList &device_list) {
 
   std::vector<char> in_buffer;
   error = ReadMessage(in_buffer);
 
   llvm::StringRef response(&in_buffer[0], in_buffer.size());
   llvm::SmallVector<llvm::StringRef, 4> devices;
   response.split(devices, "\n", -1, false);
 
-  for (const auto device : devices)
+  for (const auto &device : devices)
     device_list.push_back(device.split('\t').first);
 
   // Force disconnect since ADB closes connection after host:devices response
   // is sent.
   m_conn.reset();
   return error;
 }
 

lldb/source/Target/StackFrameRecognizer.cpp

 RecognizedStackFrameSP
 ScriptedStackFrameRecognizer::RecognizeFrame(lldb::StackFrameSP frame) {
   if (!m_python_object_sp || !m_interpreter)
     return RecognizedStackFrameSP();
 
   ValueObjectListSP args =
       m_interpreter->GetRecognizedArguments(m_python_object_sp, frame);
   auto args_synthesized = ValueObjectListSP(new ValueObjectList());
-  for (const auto o : args->GetObjects()) {
+  for (const auto &o : args->GetObjects()) {
     args_synthesized->Append(ValueObjectRecognizerSynthesizedValue::Create(
         *o, eValueTypeVariableArgument));
   }
 
   return RecognizedStackFrameSP(
       new ScriptedRecognizedStackFrame(args_synthesized));
 }
 

llvm/include/llvm/Analysis/LoopInfo.h

 #endif
   }
 
   /// True if terminator in the block can branch to another block that is
   /// outside of the current loop. \p BB must be inside the loop.
   bool isLoopExiting(const BlockT *BB) const {
     assert(!isInvalid() && "Loop not in a valid state!");
     assert(contains(BB) && "Exiting block must be part of the loop");
-    for (const auto &Succ : children<const BlockT *>(BB)) {
+    for (const auto *Succ : children<const BlockT *>(BB)) {
       if (!contains(Succ))
         return true;
     }
     return false;
   }
 
   /// Returns true if \p BB is a loop-latch.
   /// A latch block is a block that contains a branch back to the header.

llvm/include/llvm/Analysis/LoopInfoImpl.h

 /// outside of the loop.  These are the blocks _inside of the current loop_
 /// which branch out.  The returned list is always unique.
 ///
 template <class BlockT, class LoopT>
 void LoopBase<BlockT, LoopT>::getExitingBlocks(
     SmallVectorImpl<BlockT *> &ExitingBlocks) const {
   assert(!isInvalid() && "Loop not in a valid state!");
   for (const auto BB : blocks())
-    for (const auto &Succ : children<BlockT *>(BB))
+    for (auto *Succ : children<BlockT *>(BB))
       if (!contains(Succ)) {
         // Not in current loop? It must be an exit block.
         ExitingBlocks.push_back(BB);
         break;
       }
 }
 
 /// getExitingBlock - If getExitingBlocks would return exactly one block,

 /// getExitBlocks - Return all of the successor blocks of this loop.  These
 /// are the blocks _outside of the current loop_ which are branched to.
 ///
 template <class BlockT, class LoopT>
 void LoopBase<BlockT, LoopT>::getExitBlocks(
     SmallVectorImpl<BlockT *> &ExitBlocks) const {
   assert(!isInvalid() && "Loop not in a valid state!");
   for (const auto BB : blocks())
-    for (const auto &Succ : children<BlockT *>(BB))
+    for (auto *Succ : children<BlockT *>(BB))
       if (!contains(Succ))
         // Not in current loop? It must be an exit block.
         ExitBlocks.push_back(Succ);
 }
 
 /// getExitBlock - If getExitBlocks would return exactly one block,
 /// return that block. Otherwise return null.
 template <class BlockT, class LoopT>

 }
 
 /// getExitEdges - Return all pairs of (_inside_block_,_outside_block_).
 template <class BlockT, class LoopT>
 void LoopBase<BlockT, LoopT>::getExitEdges(
     SmallVectorImpl<Edge> &ExitEdges) const {
   assert(!isInvalid() && "Loop not in a valid state!");
   for (const auto BB : blocks())
-    for (const auto &Succ : children<BlockT *>(BB))
+    for (auto *Succ : children<BlockT *>(BB))
       if (!contains(Succ))
         // Not in current loop? It must be an exit block.
         ExitEdges.emplace_back(BB, Succ);
 }
 
 /// getLoopPreheader - If there is a preheader for this loop, return it.  A
 /// loop has a preheader if there is only one edge to the header of the loop
 /// from outside of the loop and it is legal to hoist instructions into the

llvm/include/llvm/Support/GenericDomTree.h

void Split(typename GraphTraits<N>::NodeRef NewBB) {
     using GraphT = GraphTraits<N>;
     using NodeRef = typename GraphT::NodeRef;
     assert(std::distance(GraphT::child_begin(NewBB),
                          GraphT::child_end(NewBB)) == 1 &&
            "NewBB should have a single successor!");
     NodeRef NewBBSucc = *GraphT::child_begin(NewBB);
 
     std::vector<NodeRef> PredBlocks;
-    for (const auto &Pred : children<Inverse<N>>(NewBB))
+    for (auto Pred : children<Inverse<N>>(NewBB))
       PredBlocks.push_back(Pred);
 
     assert(!PredBlocks.empty() && "No predblocks?");
 
     bool NewBBDominatesNewBBSucc = true;
-    for (const auto &Pred : children<Inverse<N>>(NewBBSucc)) {
+    for (auto Pred : children<Inverse<N>>(NewBBSucc)) {
       if (Pred != NewBB && !dominates(NewBBSucc, Pred) &&
           isReachableFromEntry(Pred)) {
         NewBBDominatesNewBBSucc = false;
         break;
       }
     }
 
     // Find NewBB's immediate dominator and create new dominator tree node for

llvm/lib/Analysis/DomTreeUpdater.cpp

void DomTreeUpdater::validateDeleteBB(BasicBlock *DelBB) {
   new UnreachableInst(DelBB->getContext(), DelBB);
 }
 
 void DomTreeUpdater::applyUpdates(ArrayRef<DominatorTree::UpdateType> Updates) {
   if (!DT && !PDT)
     return;
 
   if (Strategy == UpdateStrategy::Lazy) {
-    for (const auto U : Updates)
+    for (const auto &U : Updates)
       if (!isSelfDominance(U))
         PendUpdates.push_back(U);
 
     return;
   }
 
   if (DT)
     DT->applyUpdates(Updates);
   if (PDT)
     PDT->applyUpdates(Updates);
 }
 
 void DomTreeUpdater::applyUpdatesPermissive(
     ArrayRef<DominatorTree::UpdateType> Updates) {
   if (!DT && !PDT)
     return;
 
   SmallSet<std::pair<BasicBlock *, BasicBlock *>, 8> Seen;
   SmallVector<DominatorTree::UpdateType, 8> DeduplicatedUpdates;
-  for (const auto U : Updates) {
+  for (const auto &U : Updates) {
     auto Edge = std::make_pair(U.getFrom(), U.getTo());
     // Because it is illegal to submit updates that have already been applied
     // and updates to an edge need to be strictly ordered,
     // it is safe to infer the existence of an edge from the first update
     // to this edge.
     // If the first update to an edge is "Delete", it means that the edge
     // existed before. If the first update to an edge is "Insert", it means
     // that the edge didn't exist before.

llvm/lib/Analysis/MemoryDependenceAnalysis.cpp

if (it != NonLocalDefsCache.end()) {
       RemoveFromReverseMap(ReverseNonLocalDefsCache,
                            it->second.getResult().getInst(), P.getPointer());
       NonLocalDefsCache.erase(it);
     }
 
     if (auto *I = dyn_cast<Instruction>(P.getPointer())) {
       auto toRemoveIt = ReverseNonLocalDefsCache.find(I);
       if (toRemoveIt != ReverseNonLocalDefsCache.end()) {
-        for (const auto &entry : toRemoveIt->second)
+        for (const auto *entry : toRemoveIt->second)
           NonLocalDefsCache.erase(entry);
         ReverseNonLocalDefsCache.erase(toRemoveIt);
       }
     }
   }
 
   CachedNonLocalPointerInfo::iterator It = NonLocalPointerDeps.find(P);
   if (It == NonLocalPointerDeps.end())

llvm/lib/Analysis/ScalarEvolution.cpp

const SCEVAddRecExpr *PredicatedScalarEvolution::getAsAddRec(Value *V) {
   RewriteMap[SE.getSCEV(V)] = {Generation, New};
   return New;
 }
 
 PredicatedScalarEvolution::PredicatedScalarEvolution(
     const PredicatedScalarEvolution &Init)
     : RewriteMap(Init.RewriteMap), SE(Init.SE), L(Init.L), Preds(Init.Preds),
       Generation(Init.Generation), BackedgeCount(Init.BackedgeCount) {
-  for (const auto &I : Init.FlagsMap)
+  for (auto I : Init.FlagsMap)
     FlagsMap.insert(I);
 }
 
 void PredicatedScalarEvolution::print(raw_ostream &OS, unsigned Depth) const {
   // For each block.
   for (auto *BB : L.getBlocks())
     for (auto &I : *BB) {
       if (!SE.isSCEVable(I.getType()))

llvm/lib/CodeGen/InlineSpiller.cpp

if (SubTreeCost > MBFI.getBlockFreq(Block) * MarginProb) {
       });
       SpillsInSubTree.clear();
       SpillsInSubTree.insert(*RIt);
       SubTreeCost = MBFI.getBlockFreq(Block);
     }
   }
   // For spills in SpillsToKeep with LiveReg set (i.e., not original spill),
   // save them to SpillsToIns.
-  for (const auto Ent : SpillsToKeep) {
+  for (const auto &Ent : SpillsToKeep) {
     if (Ent.second)
       SpillsToIns[Ent.first->getBlock()] = Ent.second;
   }
 }
 
 /// For spills with equal values, remove redundant spills and hoist those left
 /// to less hot spots.
 ///
for (auto &Ent : MergeableSpills) {
     SmallVector<MachineInstr *, 16> SpillsToRm;
     // SpillsToIns is the spill set to be newly inserted after hoisting.
     DenseMap<MachineBasicBlock *, unsigned> SpillsToIns;
 
     runHoistSpills(OrigLI, *OrigVNI, EqValSpills, SpillsToRm, SpillsToIns);
 
     LLVM_DEBUG({
       dbgs() << "Finally inserted spills in BB: ";
-      for (const auto Ispill : SpillsToIns)
+      for (const auto &Ispill : SpillsToIns)
         dbgs() << Ispill.first->getNumber() << " ";
       dbgs() << "\nFinally removed spills in BB: ";
       for (const auto Rspill : SpillsToRm)
         dbgs() << Rspill->getParent()->getNumber() << " ";
       dbgs() << "\n";
     });
 
     // Stack live range update.
     LiveInterval &StackIntvl = LSS.getInterval(Slot);
     if (!SpillsToIns.empty() || !SpillsToRm.empty())
       StackIntvl.MergeValueInAsValue(OrigLI, OrigVNI,
                                      StackIntvl.getValNumInfo(0));
 
     // Insert hoisted spills.
-    for (auto const Insert : SpillsToIns) {
+    for (auto const &Insert : SpillsToIns) {
       MachineBasicBlock *BB = Insert.first;
       unsigned LiveReg = Insert.second;
       MachineBasicBlock::iterator MI = IPA.getLastInsertPointIter(OrigLI, *BB);
       TII.storeRegToStackSlot(*BB, MI, LiveReg, false, Slot,
                               MRI.getRegClass(LiveReg), &TRI);
       LIS.InsertMachineInstrRangeInMaps(std::prev(MI), MI);
       ++NumSpills;
     }

llvm/lib/CodeGen/InterleavedLoadCombinePass.cpp

InstructionCost +=
         TTI.getInstructionCost(I, TargetTransformInfo::TCK_Latency);
 
     // The final SVIs are allowed not to be dead, all uses will be replaced
     if (SVIs.find(I) != SVIs.end())
       continue;
 
     // If there are users outside the set to be eliminated, we abort the
     // transformation. No gain can be expected.
-    for (const auto &U : I->users()) {
+    for (auto *U : I->users()) {
       if (Is.find(dyn_cast<Instruction>(U)) == Is.end())
         return false;
     }
   }
 
   // We know that all LoadInst are within the same BB. This guarantees that
   // either everything or nothing is loaded.
   LoadInst *First = findFirstLoad(LIs);

llvm/lib/CodeGen/RegAllocFast.cpp

void RegAllocFast::allocateBasicBlock(MachineBasicBlock &MBB) {
   LLVM_DEBUG(dbgs() << "\nAllocating " << MBB);
 
   PhysRegState.assign(TRI->getNumRegs(), regDisabled);
   assert(LiveVirtRegs.empty() && "Mapping not cleared from last block?");
 
   MachineBasicBlock::iterator MII = MBB.begin();
 
   // Add live-in registers as live.
-  for (const MachineBasicBlock::RegisterMaskPair LI : MBB.liveins())
+  for (const MachineBasicBlock::RegisterMaskPair &LI : MBB.liveins())
     if (MRI->isAllocatable(LI.PhysReg))
       definePhysReg(MII, LI.PhysReg, regReserved);
 
   VirtDead.clear();
   Coalesced.clear();
 
   // Otherwise, sequentially allocate each instruction in the MBB.
   for (MachineInstr &MI : MBB) {

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

static bool isVectorReductionOp(const User *I) {
   bool ReduxExtracted = false;
 
   while (!UsersToVisit.empty()) {
     auto User = UsersToVisit.back();
     UsersToVisit.pop_back();
     if (!Visited.insert(User).second)
       continue;
 
-    for (const auto &U : User->users()) {
+    for (const auto *U : User->users()) {
       auto Inst = dyn_cast<Instruction>(U);
       if (!Inst)
         return false;
 
       if (Inst->getOpcode() == OpCode || isa<PHINode>(U)) {
         if (const FPMathOperator *FPOp = dyn_cast<const FPMathOperator>(Inst))
           if (!isa<PHINode>(FPOp) && !FPOp->getFastMathFlags().isFast())
             return false;

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

void TargetLoweringObjectFileELF::emitModuleMetadata(MCStreamer &Streamer,
   auto &C = getContext();
 
   if (NamedMDNode *LinkerOptions = M.getNamedMetadata("llvm.linker.options")) {
     auto *S = C.getELFSection(".linker-options", ELF::SHT_LLVM_LINKER_OPTIONS,
                               ELF::SHF_EXCLUDE);
 
     Streamer.SwitchSection(S);
 
-    for (const auto &Operand : LinkerOptions->operands()) {
+    for (const auto *Operand : LinkerOptions->operands()) {
       if (cast<MDNode>(Operand)->getNumOperands() != 2)
         report_fatal_error("invalid llvm.linker.options");
       for (const auto &Option : cast<MDNode>(Operand)->operands()) {
         Streamer.EmitBytes(cast<MDString>(Option)->getString());
         Streamer.EmitIntValue(0, 1);
       }
     }
   }
 
   if (NamedMDNode *DependentLibraries = M.getNamedMetadata("llvm.dependent-libraries")) {
     auto *S = C.getELFSection(".deplibs", ELF::SHT_LLVM_DEPENDENT_LIBRARIES,
                               ELF::SHF_MERGE | ELF::SHF_STRINGS, 1, "");
 
     Streamer.SwitchSection(S);
 
-    for (const auto &Operand : DependentLibraries->operands()) {
+    for (const auto *Operand : DependentLibraries->operands()) {
       Streamer.EmitBytes(
           cast<MDString>(cast<MDNode>(Operand)->getOperand(0))->getString());
       Streamer.EmitIntValue(0, 1);
     }
   }
 
   unsigned Version = 0;
   unsigned Flags = 0;
void TargetLoweringObjectFileMachO::Initialize(MCContext &Ctx,
   TTypeEncoding =
       dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4;
 }
 
 void TargetLoweringObjectFileMachO::emitModuleMetadata(MCStreamer &Streamer,
                                                        Module &M) const {
   // Emit the linker options if present.
   if (auto *LinkerOptions = M.getNamedMetadata("llvm.linker.options")) {
-    for (const auto &Option : LinkerOptions->operands()) {
+    for (const auto *Option : LinkerOptions->operands()) {
       SmallVector<std::string, 4> StrOptions;
       for (const auto &Piece : cast<MDNode>(Option)->operands())
         StrOptions.push_back(cast<MDString>(Piece)->getString());
       Streamer.EmitLinkerOptions(StrOptions);
     }
   }
 
   unsigned VersionVal = 0;

 void TargetLoweringObjectFileCOFF::emitModuleMetadata(MCStreamer &Streamer,
                                                       Module &M) const {
   if (NamedMDNode *LinkerOptions = M.getNamedMetadata("llvm.linker.options")) {
     // Emit the linker options to the linker .drectve section.  According to the
     // spec, this section is a space-separated string containing flags for
     // linker.
     MCSection *Sec = getDrectveSection();
     Streamer.SwitchSection(Sec);
-    for (const auto &Option : LinkerOptions->operands()) {
+    for (const auto *Option : LinkerOptions->operands()) {
       for (const auto &Piece : cast<MDNode>(Option)->operands()) {
         // Lead with a space for consistency with our dllexport implementation.
         std::string Directive(" ");
         Directive.append(cast<MDString>(Piece)->getString());
         Streamer.EmitBytes(Directive);
       }
     }
   }

llvm/lib/DebugInfo/DWARF/DWARFAcceleratorTable.cpp

void AppleAcceleratorTable::Entry::extract(
   for (auto &Atom : Values)
     Atom.extractValue(AccelTable.AccelSection, Offset, FormParams);
 }
 
 Optional<DWARFFormValue>
 AppleAcceleratorTable::Entry::lookup(HeaderData::AtomType Atom) const {
   assert(HdrData && "Dereferencing end iterator?");
   assert(HdrData->Atoms.size() == Values.size());
-  for (const auto &Tuple : zip_first(HdrData->Atoms, Values)) {
+  for (auto Tuple : zip_first(HdrData->Atoms, Values)) {
     if (std::get<0>(Tuple).first == Atom)
       return std::get<1>(Tuple);
   }
   return None;
 }
 
 Optional<uint64_t> AppleAcceleratorTable::Entry::getDIESectionOffset() const {
   return HdrData->extractOffset(lookup(dwarf::DW_ATOM_die_offset));
DWARFDebugNames::Entry::Entry(const NameIndex &NameIdx, const Abbrev &Abbr)
   Values.reserve(Abbr.Attributes.size());
   for (const auto &Attr : Abbr.Attributes)
     Values.emplace_back(Attr.Form);
 }
 
 Optional<DWARFFormValue>
 DWARFDebugNames::Entry::lookup(dwarf::Index Index) const {
   assert(Abbr->Attributes.size() == Values.size());
-  for (const auto &Tuple : zip_first(Abbr->Attributes, Values)) {
+  for (auto Tuple : zip_first(Abbr->Attributes, Values)) {
     if (std::get<0>(Tuple).Index == Index)
       return std::get<1>(Tuple);
   }
   return None;
 }
 
 Optional<uint64_t> DWARFDebugNames::Entry::getDIEUnitOffset() const {
   if (Optional<DWARFFormValue> Off = lookup(dwarf::DW_IDX_die_offset))
if (!Index || *Index >= NameIdx->getCUCount())
     return None;
   return NameIdx->getCUOffset(*Index);
 }
 
 void DWARFDebugNames::Entry::dump(ScopedPrinter &W) const {
   W.printHex("Abbrev", Abbr->Code);
   W.startLine() << formatv("Tag: {0}\n", Abbr->Tag);
   assert(Abbr->Attributes.size() == Values.size());
-  for (const auto &Tuple : zip_first(Abbr->Attributes, Values)) {
+  for (auto Tuple : zip_first(Abbr->Attributes, Values)) {
     W.startLine() << formatv("{0}: ", std::get<0>(Tuple).Index);
     std::get<1>(Tuple).dump(W.getOStream());
     W.getOStream() << '\n';
   }
 }
 
 char DWARFDebugNames::SentinelError::ID;
 std::error_code DWARFDebugNames::SentinelError::convertToErrorCode() const {

llvm/lib/DebugInfo/DWARF/DWARFVerifier.cpp

unsigned DWARFVerifier::verifyDebugInfoForm(const DWARFDie &Die,
   return NumErrors;
 }
 
 unsigned DWARFVerifier::verifyDebugInfoReferences() {
   // Take all references and make sure they point to an actual DIE by
   // getting the DIE by offset and emitting an error
   OS << "Verifying .debug_info references...\n";
   unsigned NumErrors = 0;
-  for (const std::pair<uint64_t, std::set<uint64_t>> &Pair :
+  for (const std::pair<const uint64_t, std::set<uint64_t>> &Pair :
        ReferenceToDIEOffsets) {
     if (DCtx.getDIEForOffset(Pair.first))
       continue;
     ++NumErrors;
     error() << "invalid DIE reference " << format("0x%08" PRIx64, Pair.first)
             << ". Offset is in between DIEs:\n";
     for (auto Offset : Pair.second)
       dump(DCtx.getDIEForOffset(Offset)) << '\n';

llvm/lib/DebugInfo/Symbolize/Symbolize.cpp

Optional<ArrayRef<uint8_t>> getBuildID(const ELFFile<ELFT> *Obj) {
   if (!PhdrsOrErr) {
     consumeError(PhdrsOrErr.takeError());
     return {};
   }
   for (const auto &P : *PhdrsOrErr) {
     if (P.p_type != ELF::PT_NOTE)
       continue;
     Error Err = Error::success();
-    for (const auto &N : Obj->notes(P, Err))
+    for (auto N : Obj->notes(P, Err))
       if (N.getType() == ELF::NT_GNU_BUILD_ID && N.getName() == ELF::ELF_NOTE_GNU)
         return N.getDesc();
   }
   return {};
 }
 
 Optional<ArrayRef<uint8_t>> getBuildID(const ELFObjectFileBase *Obj) {
   Optional<ArrayRef<uint8_t>> BuildID;

llvm/lib/ExecutionEngine/Orc/ExecutionUtils.cpp

 void CtorDtorRunner::add(iterator_range<CtorDtorIterator> CtorDtors) {
   if (CtorDtors.empty())
     return;
 
   MangleAndInterner Mangle(
       JD.getExecutionSession(),
       (*CtorDtors.begin()).Func->getParent()->getDataLayout());
 
-  for (const auto &CtorDtor : CtorDtors) {
+  for (auto CtorDtor : CtorDtors) {
     assert(CtorDtor.Func && CtorDtor.Func->hasName() &&
            "Ctor/Dtor function must be named to be runnable under the JIT");
 
     // FIXME: Maybe use a symbol promoter here instead.
     if (CtorDtor.Func->hasLocalLinkage()) {
       CtorDtor.Func->setLinkage(GlobalValue::ExternalLinkage);
       CtorDtor.Func->setVisibility(GlobalValue::HiddenVisibility);
     }

llvm/lib/IR/TypeFinder.cpp

for (const BasicBlock &BB : FI)
         I.getAllMetadataOtherThanDebugLoc(MDForInst);
         for (const auto &MD : MDForInst)
           incorporateMDNode(MD.second);
         MDForInst.clear();
       }
   }
 
   for (const auto &NMD : M.named_metadata())
-    for (const auto &MDOp : NMD.operands())
+    for (const auto *MDOp : NMD.operands())
       incorporateMDNode(MDOp);
 }
 
 void TypeFinder::clear() {
   VisitedConstants.clear();
   VisitedTypes.clear();
   StructTypes.clear();
 }

llvm/lib/Linker/IRMover.cpp

if (auto *GVar = dyn_cast<GlobalVariable>(&Src)) {
     linkGlobalVariable(cast<GlobalVariable>(Dst), *GVar);
     return Error::success();
   }
   linkIndirectSymbolBody(cast<GlobalIndirectSymbol>(Dst), cast<GlobalIndirectSymbol>(Src));
   return Error::success();
 }
 
 void IRLinker::flushRAUWWorklist() {
-  for (const auto Elem : RAUWWorklist) {
+  for (const auto &Elem : RAUWWorklist) {
     GlobalValue *Old;
     Value *New;
     std::tie(Old, New) = Elem;
 
     Old->replaceAllUsesWith(New);
     Old->eraseFromParent();
   }
   RAUWWorklist.clear();

llvm/lib/MC/XCOFFObjectWriter.cpp

for (const auto *Group : Section->Groups) {
         continue;
 
       const int16_t SectionIndex = Section->Index;
       for (const auto &Csect : *Group) {
         // Write out the control section first and then each symbol in it.
         writeSymbolTableEntryForControlSection(
             Csect, SectionIndex, Csect.MCCsect->getStorageClass());
 
-        for (const auto Sym : Csect.Syms)
+        for (const auto &Sym : Csect.Syms)
           writeSymbolTableEntryForCsectMemberLabel(
               Sym, Csect, SectionIndex, Layout.getSymbolOffset(*(Sym.MCSym)));
       }
     }
   }
 }
 
 void XCOFFObjectWriter::assignAddressesAndIndices(const MCAsmLayout &Layout) {

llvm/lib/MCA/HardwareUnits/ResourceManager.cpp

while (ConsumedBuffers) {
     RS.releaseBuffer();
     // Do not unreserve dispatch hazard resource buffers. Wait until all
     // pipeline resources have been freed too.
   }
 }
 
 uint64_t ResourceManager::checkAvailability(const InstrDesc &Desc) const {
   uint64_t BusyResourceMask = 0;
-  for (const std::pair<uint64_t, const ResourceUsage> &E : Desc.Resources) {
+  for (const std::pair<uint64_t, ResourceUsage> &E : Desc.Resources) {
     unsigned NumUnits = E.second.isReserved() ? 0U : E.second.NumUnits;
     unsigned Index = getResourceStateIndex(E.first);
     if (!Resources[Index]->isReady(NumUnits))
       BusyResourceMask |= E.first;
   }
 
   BusyResourceMask &= ProcResUnitMask;
   if (BusyResourceMask)

llvm/lib/MCA/Stages/InstructionTables.cpp

 namespace llvm {
 namespace mca {
 
 Error InstructionTables::execute(InstRef &IR) {
   const InstrDesc &Desc = IR.getInstruction()->getDesc();
   UsedResources.clear();
 
   // Identify the resources consumed by this instruction.
-  for (const std::pair<uint64_t, ResourceUsage> Resource : Desc.Resources) {
+  for (const std::pair<const uint64_t, ResourceUsage> Resource :
+       Desc.Resources) {
     // Skip zero-cycle resources (i.e., unused resources).
     if (!Resource.second.size())
       continue;
     unsigned Cycles = Resource.second.size();
     unsigned Index = std::distance(
         Masks.begin(), std::find(Masks.begin(), Masks.end(), Resource.first));
     const MCProcResourceDesc &ProcResource = *SM.getProcResource(Index);
     unsigned NumUnits = ProcResource.NumUnits;

llvm/lib/ObjectYAML/CodeViewYAMLDebugSections.cpp

std::shared_ptr<DebugSubsection> YAMLLinesSubsection::toCodeViewSubsection(
   auto Result =
       std::make_shared<DebugLinesSubsection>(*SC.checksums(), *SC.strings());
   Result->setCodeSize(Lines.CodeSize);
   Result->setRelocationAddress(Lines.RelocSegment, Lines.RelocOffset);
   Result->setFlags(Lines.Flags);
   for (const auto &LC : Lines.Blocks) {
     Result->createBlock(LC.FileName);
     if (Result->hasColumnInfo()) {
-      for (const auto &Item : zip(LC.Lines, LC.Columns)) {
+      for (auto Item : zip(LC.Lines, LC.Columns)) {
         auto &L = std::get<0>(Item);
         auto &C = std::get<1>(Item);
         uint32_t LE = L.LineStart + L.EndDelta;
         Result->addLineAndColumnInfo(L.Offset,
                                      LineInfo(L.LineStart, LE, L.IsStatement),
                                      C.StartColumn, C.EndColumn);
       }
     } else {

llvm/lib/Support/CommandLine.cpp

if (!SC->OptionsMap.insert(std::make_pair(Name, &Opt)).second) {
       errs() << ProgramName << ": CommandLine Error: Option '" << Name
              << "' registered more than once!\n";
       report_fatal_error("inconsistency in registered CommandLine options");
     }
 
     // If we're adding this to all sub-commands, add it to the ones that have
     // already been registered.
     if (SC == &*AllSubCommands) {
-      for (const auto &Sub : RegisteredSubCommands) {
+      for (auto *Sub : RegisteredSubCommands) {
         if (SC == Sub)
           continue;
         addLiteralOption(Opt, Sub, Name);
       }
     }
   }
 
   void addLiteralOption(Option &Opt, StringRef Name) {
void addOption(Option *O, SubCommand *SC) {
     // incorrectly
     // linked LLVM distribution.
     if (HadErrors)
       report_fatal_error("inconsistency in registered CommandLine options");
 
     // If we're adding this to all sub-commands, add it to the ones that have
     // already been registered.
     if (SC == &*AllSubCommands) {
-      for (const auto &Sub : RegisteredSubCommands) {
+      for (auto *Sub : RegisteredSubCommands) {
         if (SC == Sub)
           continue;
         addOption(O, Sub);
       }
     }
   }
 
   void addOption(Option *O, bool ProcessDefaultOption = false) {
public:
   }
 
   bool hasOptions(const SubCommand &Sub) const {
     return (!Sub.OptionsMap.empty() || !Sub.PositionalOpts.empty() ||
             nullptr != Sub.ConsumeAfterOpt);
   }
 
   bool hasOptions() const {
-    for (const auto &S : RegisteredSubCommands) {
+    for (const auto *S : RegisteredSubCommands) {
       if (hasOptions(*S))
         return true;
     }
     return false;
   }
 
   SubCommand *getActiveSubCommand() { return ActiveSubCommand; }
 
static void sortOpts(StringMap<Option *> &OptMap,
 
   // Sort the options list alphabetically.
   array_pod_sort(Opts.begin(), Opts.end(), OptNameCompare);
 }
 
 static void
 sortSubCommands(const SmallPtrSetImpl<SubCommand *> &SubMap,
                 SmallVectorImpl<std::pair<const char *, SubCommand *>> &Subs) {
-  for (const auto &S : SubMap) {
+  for (auto *S : SubMap) {
     if (S->getName().empty())
       continue;
     Subs.push_back(std::make_pair(S->getName().data(), S));
   }
   array_pod_sort(Subs.begin(), Subs.end(), SubNameCompare);
 }
 
 namespace {

llvm/lib/Support/TargetParser.cpp

 
 StringRef llvm::AMDGPU::getArchNameR600(GPUKind AK) {
   if (const auto *Entry = getArchEntry(AK, R600GPUs))
     return Entry->CanonicalName;
   return "";
 }
 
 AMDGPU::GPUKind llvm::AMDGPU::parseArchAMDGCN(StringRef CPU) {
-  for (const auto C : AMDGCNGPUs) {
+  for (const auto &C : AMDGCNGPUs) {
     if (CPU == C.Name)
       return C.Kind;
   }
 
   return AMDGPU::GPUKind::GK_NONE;
 }
 
 AMDGPU::GPUKind llvm::AMDGPU::parseArchR600(StringRef CPU) {
-  for (const auto C : R600GPUs) {
+  for (const auto &C : R600GPUs) {
     if (CPU == C.Name)
       return C.Kind;
   }
 
   return AMDGPU::GPUKind::GK_NONE;
 }
 
 unsigned AMDGPU::getArchAttrAMDGCN(GPUKind AK) {
   if (const auto *Entry = getArchEntry(AK, AMDGCNGPUs))
     return Entry->Features;
   return FEATURE_NONE;
 }
 
 unsigned AMDGPU::getArchAttrR600(GPUKind AK) {
   if (const auto *Entry = getArchEntry(AK, R600GPUs))
     return Entry->Features;
   return FEATURE_NONE;
 }
 
 void AMDGPU::fillValidArchListAMDGCN(SmallVectorImpl<StringRef> &Values) {
   // XXX: Should this only report unique canonical names?
-  for (const auto C : AMDGCNGPUs)
+  for (const auto &C : AMDGCNGPUs)
     Values.push_back(C.Name);
 }
 
 void AMDGPU::fillValidArchListR600(SmallVectorImpl<StringRef> &Values) {
-  for (const auto C : R600GPUs)
+  for (const auto &C : R600GPUs)
     Values.push_back(C.Name);
 }
 
 AMDGPU::IsaVersion AMDGPU::getIsaVersion(StringRef GPU) {
   AMDGPU::GPUKind AK = parseArchAMDGCN(GPU);
   if (AK == AMDGPU::GPUKind::GK_NONE) {
     if (GPU == "generic-hsa")
       return {7, 0, 0};