[NFC] Use const references to avoid copying objects in for-loops

[jhenderson]

I'm not particularly familiar with much of this code, but it seems to me likely that it's not always the case that you should use const & for several of these, no more than you would if you were passing them in as function parameters. Unfortunately, the use of auto (often in violation of my undersetanding of the LLVM coding standards on auto usage) makes it hard to tell what the situation is.

llvm/lib/ObjCopy/ELF/ELFObject.cpp

2073

This is probably unnecessary, though it can't hurt: it's a std::pair of two things that are designed to be passed by value, so hardly costly to copy (and will likely be a no-op change in optimized builds, at a guess).

llvm/tools/llvm-readobj/ObjDumper.h

55

FWIW, I wouldn't normally pass around a std::function by reference.

[MaskRay]

At least for enumerate, the loop variable change is unnecessary.

[gAlfonso-bit]

Removed changes to enumerate

[gAlfonso-bit]

@MaskRay Addressed!

[MaskRay]

This kind of blindly applying clang-tidy -checks='-*,performance-for-range-copy' --fix changes is easy for the contributor but is time consuming for reviewers.
Anyway, I have applied appropriated fixes to places where const auto & is not the best.

llvm/include/llvm/MC/MCParser/MCAsmParser.h

public:
   /// clients.
   virtual bool printError(SMLoc L, const Twine &Msg,
                           SMRange Range = std::nullopt) = 0;
 
   bool hasPendingError() { return !PendingErrors.empty(); }
 
   bool printPendingErrors() {
     bool rv = !PendingErrors.empty();
-    for (auto Err : PendingErrors) {
+    for (const auto& Err : PendingErrors) {
       printError(Err.Loc, Twine(Err.Msg), Err.Range);
     }
     PendingErrors.clear();
     return rv;
   }
 
   void clearPendingErrors() { PendingErrors.clear(); }
 

llvm/lib/DebugInfo/DWARF/DWARFVerifier.cpp

unsigned DWARFVerifier::verifyDebugInfoCallSite(const DWARFDie &Die) {
   return 0;
 }
 
 unsigned DWARFVerifier::verifyAbbrevSection(const DWARFDebugAbbrev *Abbrev) {
   unsigned NumErrors = 0;
   if (Abbrev) {
     const DWARFAbbreviationDeclarationSet *AbbrDecls =
         Abbrev->getAbbreviationDeclarationSet(0);
-    for (auto AbbrDecl : *AbbrDecls) {
+    for (const auto& AbbrDecl : *AbbrDecls) {
       SmallDenseSet<uint16_t> AttributeSet;
       for (auto Attribute : AbbrDecl.attributes()) {
         auto Result = AttributeSet.insert(Attribute.Attr);
         if (!Result.second) {
           error() << "Abbreviation declaration contains multiple "
                   << AttributeString(Attribute.Attr) << " attributes.\n";
           AbbrDecl.dump(OS);
           ++NumErrors;
if (!Index.parse(D))
     return 1;
   using MapType = IntervalMap<uint32_t, uint64_t>;
   MapType::Allocator Alloc;
   std::vector<std::unique_ptr<MapType>> Sections(Index.getColumnKinds().size());
   for (const DWARFUnitIndex::Entry &E : Index.getRows()) {
     uint64_t Sig = E.getSignature();
     if (!E.getContributions())
       continue;
-    for (auto E : enumerate(InfoColumnKind == DW_SECT_INFO
+    for (const auto& E : enumerate(InfoColumnKind == DW_SECT_INFO
                                 ? makeArrayRef(E.getContributions(),
                                                Index.getColumnKinds().size())
                                 : makeArrayRef(E.getContribution(), 1))) {
       const DWARFUnitIndex::Entry::SectionContribution &SC = E.value();
       int Col = E.index();
       if (SC.Length == 0)
         continue;
       if (!Sections[Col])

llvm/lib/MC/ELFObjectWriter.cpp

void ELFWriter::computeSymbolTable(
   std::vector<ELFSymbolData> ExternalSymbolData;
   MutableArrayRef<std::pair<std::string, size_t>> FileNames =
       Asm.getFileNames();
   for (const std::pair<std::string, size_t> &F : FileNames)
     StrTabBuilder.add(F.first);
 
   // Add the data for the symbols.
   bool HasLargeSectionIndex = false;
-  for (auto It : llvm::enumerate(Asm.symbols())) {
+  for (const auto& It : llvm::enumerate(Asm.symbols())) {
     const auto &Symbol = cast<MCSymbolELF>(It.value());
     bool Used = Symbol.isUsedInReloc();
     bool WeakrefUsed = Symbol.isWeakrefUsedInReloc();
     bool isSignature = Symbol.isSignature();
 
     if (!isInSymtab(Layout, Symbol, Used || WeakrefUsed || isSignature,
                     OWriter.Renames.count(&Symbol)))
       continue;

llvm/lib/MC/MCPseudoProbe.cpp

for (auto &Probe : It->second) {
       OS << " [Probe]:\t";
       Probe.print(OS, GUID2FuncDescMap, true);
     }
   }
 }
 
 void MCPseudoProbeDecoder::printProbesForAllAddresses(raw_ostream &OS) {
   std::vector<uint64_t> Addresses;
-  for (auto Entry : Address2ProbesMap)
+  for (const auto& Entry : Address2ProbesMap)
     Addresses.push_back(Entry.first);
   llvm::sort(Addresses);
   for (auto K : Addresses) {
     OS << "Address:\t";
     OS << K;
     OS << "\n";
     printProbeForAddress(OS, K);
   }

llvm/lib/ObjCopy/ELF/ELFObject.cpp

 
 template <class ELFT> void ELFWriter<ELFT>::writeSegmentData() {
   for (Segment &Seg : Obj.segments()) {
     size_t Size = std::min<size_t>(Seg.FileSize, Seg.getContents().size());
     std::memcpy(Buf->getBufferStart() + Seg.Offset, Seg.getContents().data(),
                 Size);
   }
 
-  for (auto it : Obj.getUpdatedSections()) {
+  for (const auto& it : Obj.getUpdatedSections()) {
     SectionBase *Sec = it.first;
     ArrayRef<uint8_t> Data = it.second;
 
     auto *Parent = Sec->ParentSegment;
     assert(Parent && "This section should've been part of a segment.");
     uint64_t Offset =
         Sec->OriginalOffset - Parent->OriginalOffset + Parent->Offset;
     llvm::copy(Data, Buf->getBufferStart() + Offset);

llvm/lib/Object/COFFImportFile.cpp

Error writeImportLibrary(StringRef ImportName, StringRef Path,
   Members.push_back(OF.createImportDescriptor(ImportDescriptor));
 
   std::vector<uint8_t> NullImportDescriptor;
   Members.push_back(OF.createNullImportDescriptor(NullImportDescriptor));
 
   std::vector<uint8_t> NullThunk;
   Members.push_back(OF.createNullThunk(NullThunk));
 
-  for (COFFShortExport E : Exports) {
+  for (const COFFShortExport& E : Exports) {
     if (E.Private)
       continue;
 
     ImportType ImportType = IMPORT_CODE;
     if (E.Data)
       ImportType = IMPORT_DATA;
     if (E.Constant)
       ImportType = IMPORT_CONST;

llvm/lib/ObjectYAML/MachOEmitter.cpp

case MachO::LC_SEGMENT_64:
       }
     }
   }
 }
 
 void MachOWriter::writeBindOpcodes(
     raw_ostream &OS, std::vector<MachOYAML::BindOpcode> &BindOpcodes) {
 
-  for (auto Opcode : BindOpcodes) {
+  for (const auto& Opcode : BindOpcodes) {
     uint8_t OpByte = Opcode.Opcode | Opcode.Imm;
     OS.write(reinterpret_cast<char *>(&OpByte), 1);
     for (auto Data : Opcode.ULEBExtraData) {
       encodeULEB128(Data, OS);
     }
     for (auto Data : Opcode.SLEBExtraData) {
       encodeSLEB128(Data, OS);
     }
if (Entry.Flags & MachO::EXPORT_SYMBOL_FLAGS_REEXPORT) {
       OS.write('\0');
     } else {
       encodeULEB128(Entry.Address, OS);
       if (Entry.Flags & MachO::EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER)
         encodeULEB128(Entry.Other, OS);
     }
   }
   OS.write(static_cast<uint8_t>(Entry.Children.size()));
-  for (auto EE : Entry.Children) {
+  for (const auto& EE : Entry.Children) {
     OS << EE.Name;
     OS.write('\0');
     encodeULEB128(EE.NodeOffset, OS);
   }
   for (auto EE : Entry.Children)
     dumpExportEntry(OS, EE);
 }
 
for (auto writeOp : WriteQueue) {
     ZeroToOffset(OS, writeOp.first);
     (this->*writeOp.second)(OS);
   }
 }
 
 void MachOWriter::writeRebaseOpcodes(raw_ostream &OS) {
   MachOYAML::LinkEditData &LinkEdit = Obj.LinkEdit;
 
-  for (auto Opcode : LinkEdit.RebaseOpcodes) {
+  for (const auto& Opcode : LinkEdit.RebaseOpcodes) {
     uint8_t OpByte = Opcode.Opcode | Opcode.Imm;
     OS.write(reinterpret_cast<char *>(&OpByte), 1);
     for (auto Data : Opcode.ExtraData)
       encodeULEB128(Data, OS);
   }
 }
 
 void MachOWriter::writeBasicBindOpcodes(raw_ostream &OS) {

llvm/lib/ObjectYAML/WasmEmitter.cpp

void WasmWriter::writeSectionContent(raw_ostream &OS,
   encodeULEB128(Section.Version, OS);
 
   SubSectionWriter SubSection(OS);
 
   // SYMBOL_TABLE subsection
   if (Section.SymbolTable.size()) {
     writeUint8(OS, wasm::WASM_SYMBOL_TABLE);
     encodeULEB128(Section.SymbolTable.size(), SubSection.getStream());
-    for (auto Sym : llvm::enumerate(Section.SymbolTable)) {
+    for (const auto& Sym : llvm::enumerate(Section.SymbolTable)) {
       const WasmYAML::SymbolInfo &Info = Sym.value();
       assert(Info.Index == Sym.index());
       writeUint8(SubSection.getStream(), Info.Kind);
       encodeULEB128(Info.Flags, SubSection.getStream());
       switch (Info.Kind) {
       case wasm::WASM_SYMBOL_TYPE_FUNCTION:
       case wasm::WASM_SYMBOL_TYPE_GLOBAL:
       case wasm::WASM_SYMBOL_TYPE_TABLE:

llvm/lib/Support/VirtualFileSystem.cpp

void OverlayFileSystem::printImpl(raw_ostream &OS, PrintType Type,
                                   unsigned IndentLevel) const {
   printIndent(OS, IndentLevel);
   OS << "OverlayFileSystem\n";
   if (Type == PrintType::Summary)
     return;
 
   if (Type == PrintType::Contents)
     Type = PrintType::Summary;
-  for (auto FS : overlays_range())
+  for (const auto& FS : overlays_range())
     FS->print(OS, Type, IndentLevel + 1);
 }
 
 llvm::vfs::detail::DirIterImpl::~DirIterImpl() = default;
 
 namespace {
 
 /// Combines and deduplicates directory entries across multiple file systems.
while (true) {
         return EC; // name not seen before
     }
     llvm_unreachable("returned above");
   }
 
 public:
   CombiningDirIterImpl(ArrayRef<FileSystemPtr> FileSystems, std::string Dir,
                        std::error_code &EC) {
-    for (auto FS : FileSystems) {
+    for (const auto& FS : FileSystems) {
       std::error_code FEC;
       directory_iterator Iter = FS->dir_begin(Dir, FEC);
       if (FEC && FEC != errc::no_such_file_or_directory) {
         EC = FEC;
         return;
       }
       if (!FEC)
         IterList.push_back(Iter);

llvm/lib/TextAPI/TextStub.cpp

Error TextAPIWriter::writeToStream(raw_ostream &OS, const InterfaceFile &File) {
   TextAPIContext Ctx;
   Ctx.Path = std::string(File.getPath());
   Ctx.FileKind = File.getFileType();
   llvm::yaml::Output YAMLOut(OS, &Ctx, /*WrapColumn=*/80);
 
   std::vector<const InterfaceFile *> Files;
   Files.emplace_back(&File);
 
-  for (auto Document : File.documents())
+  for (const auto& Document : File.documents())
     Files.emplace_back(Document.get());
 
   // Stream out yaml.
   YAMLOut << Files;
 
   return Error::success();
 }

llvm/tools/dsymutil/BinaryHolder.cpp

BinaryHolder::ArchiveEntry::getObjectEntry(StringRef Filename,
 
   // Create a new ObjectEntry, but don't add it to the cache yet. Loading of
   // the archive members might fail and we don't want to lock the whole archive
   // during this operation.
   auto OE = std::make_unique<ObjectEntry>();
 
   for (const auto &Archive : Archives) {
     Error Err = Error::success();
-    for (auto Child : Archive->children(Err)) {
+    for (const auto& Child : Archive->children(Err)) {
       if (auto NameOrErr = Child.getName()) {
         if (*NameOrErr == ObjectFilename) {
           auto ModTimeOrErr = Child.getLastModified();
           if (!ModTimeOrErr)
             return ModTimeOrErr.takeError();
 
           if (Timestamp != sys::TimePoint<>() &&
               Timestamp != std::chrono::time_point_cast<std::chrono::seconds>(

llvm/tools/llvm-dwarfdump/llvm-dwarfdump.cpp

 }
 
 /// Return true if the object file has not been filtered by an --arch option.
 static bool filterArch(ObjectFile &Obj) {
   if (ArchFilters.empty())
     return true;
 
   if (auto *MachO = dyn_cast<MachOObjectFile>(&Obj)) {
-    for (auto Arch : ArchFilters) {
+    for (const auto& Arch : ArchFilters) {
       // Match architecture number.
       unsigned Value;
       if (!StringRef(Arch).getAsInteger(0, Value))
         if (Value == getCPUType(*MachO))
           return true;
 
       // Match as name.
       if (MachO->getArchTriple().getArchName() == Triple(Arch).getArchName())
static bool dumpObjectFile(ObjectFile &Obj, DWARFContext &DICtx,
 
   // Handle the --lookup option.
   if (Lookup)
     return lookup(Obj, DICtx, Lookup, OS);
 
   // Handle the --name option.
   if (!Name.empty()) {
     StringSet<> Names;
-    for (auto name : Name)
+    for (const auto& name : Name)
       Names.insert((IgnoreCase && !UseRegex) ? StringRef(name).lower() : name);
 
     filterByName(Names, DICtx.normal_units(), OS);
     filterByName(Names, DICtx.dwo_units(), OS);
     return true;
   }
 
   // Handle the --find option and lower it to --debug-info=<offset>.

 
 static bool handleBuffer(StringRef Filename, MemoryBufferRef Buffer,
                          HandlerFn HandleObj, raw_ostream &OS);
 
 static bool handleArchive(StringRef Filename, Archive &Arch,
                           HandlerFn HandleObj, raw_ostream &OS) {
   bool Result = true;
   Error Err = Error::success();
-  for (auto Child : Arch.children(Err)) {
+  for (const auto& Child : Arch.children(Err)) {
     auto BuffOrErr = Child.getMemoryBufferRef();
     error(Filename, BuffOrErr.takeError());
     auto NameOrErr = Child.getName();
     error(Filename, NameOrErr.takeError());
     std::string Name = (Filename + "(" + NameOrErr.get() + ")").str();
     Result &= handleBuffer(Name, BuffOrErr.get(), HandleObj, OS);
   }
   error(Filename, std::move(Err));
if (auto DsymObjectsOrErr = MachOObjectFile::findDsymObjectMembers(F)) {
         llvm::append_range(Objects, *DsymObjectsOrErr);
     } else {
       error(DsymObjectsOrErr.takeError());
     }
   }
 
   bool Success = true;
   if (Verify) {
-    for (auto Object : Objects)
+    for (const auto& Object : Objects)
       Success &= handleFile(Object, verifyObjectFile, OutputFile.os());
   } else if (Statistics) {
-    for (auto Object : Objects)
+    for (const auto& Object : Objects)
       Success &= handleFile(Object, collectStatsForObjectFile, OutputFile.os());
   } else if (ShowSectionSizes) {
-    for (auto Object : Objects)
+    for (const auto& Object : Objects)
       Success &= handleFile(Object, collectObjectSectionSizes, OutputFile.os());
   } else if (ShowSources) {
-    for (auto Object : Objects)
+    for (const auto& Object : Objects)
       Success &= handleFile(Object, collectObjectSources, OutputFile.os());
   } else {
-    for (auto Object : Objects)
+    for (const auto& Object : Objects)
       Success &= handleFile(Object, dumpObjectFile, OutputFile.os());
   }
 
   return Success ? EXIT_SUCCESS : EXIT_FAILURE;
 }

llvm/tools/llvm-gsymutil/llvm-gsymutil.cpp

 /// Return true if the object file has not been filtered by an --arch option.
 static bool filterArch(MachOObjectFile &Obj) {
   if (ArchFilters.empty())
     return true;
 
   Triple ObjTriple(Obj.getArchTriple());
   StringRef ObjArch = ObjTriple.getArchName();
 
-  for (auto Arch : ArchFilters) {
+  for (const auto& Arch : ArchFilters) {
     // Match name.
     if (Arch == ObjArch)
       return true;
 
     // Match architecture number.
     unsigned Value;
     if (!StringRef(Arch).getAsInteger(0, Value))
       if (Value == getCPUType(Obj))
if (auto DsymObjectsOrErr =
     if (DsymObjectsOrErr->empty())
       Objects.push_back(ConvertFilename);
     else
       llvm::append_range(Objects, *DsymObjectsOrErr);
   } else {
     error(DsymObjectsOrErr.takeError());
   }
 
-  for (auto Object : Objects) {
+  for (const auto& Object : Objects) {
     if (auto Err = handleFileConversionToGSYM(Object, OutFile))
       return Err;
   }
   return Error::success();
 }
 
 static void doLookup(GsymReader &Gsym, uint64_t Addr, raw_ostream &OS) {
   if (auto Result = Gsym.lookup(Addr)) {

llvm/tools/llvm-pdbutil/TypeReferenceTracker.cpp

TypeReferenceTracker::TypeReferenceTracker(InputFile &File)
   }
 }
 
 void TypeReferenceTracker::mark() {
   // Walk type roots:
   // - globals
   // - modi symbols
   // - LF_UDT_MOD_SRC_LINE? VC always links these in.
-  for (SymbolGroup SG : File.symbol_groups()) {
+  for (const SymbolGroup& SG : File.symbol_groups()) {
     if (File.isObj()) {
       for (const auto &SS : SG.getDebugSubsections()) {
         // FIXME: Are there other type-referencing subsections? Inlinees?
         // Probably for IDs.
         if (SS.kind() != DebugSubsectionKind::Symbols)
           continue;
 
         CVSymbolArray Symbols;

llvm/tools/llvm-pdbutil/llvm-pdbutil.cpp

static void yamlToPdb(StringRef Path) {
   for (const auto &MI : Dbi.ModInfos) {
     auto &ModiBuilder = ExitOnErr(DbiBuilder.addModuleInfo(MI.Mod));
     ModiBuilder.setObjFileName(MI.Obj);
 
     for (auto S : MI.SourceFiles)
       ExitOnErr(DbiBuilder.addModuleSourceFile(ModiBuilder, S));
     if (MI.Modi) {
       const auto &ModiStream = *MI.Modi;
-      for (auto Symbol : ModiStream.Symbols) {
+      for (const auto& Symbol : ModiStream.Symbols) {
         ModiBuilder.addSymbol(
             Symbol.toCodeViewSymbol(Allocator, CodeViewContainer::Pdb));
       }
     }
 
     // Each module has its own checksum subsection, so scan for it every time.
     Strings.setChecksums(nullptr);
     CodeViewYAML::initializeStringsAndChecksums(MI.Subsections, Strings);

llvm/tools/llvm-readobj/ObjDumper.h

public:
   using CompPredicate =
       std::function<bool(object::SymbolRef, object::SymbolRef)>;
 
   // Each Obj format has a slightly different way of retrieving a symbol's info
   // So we defer the predicate's impl to each format.
   void addPredicate(CompPredicate Pred) { Predicates.push_back(Pred); }
 
   bool operator()(object::SymbolRef LHS, object::SymbolRef RHS) {
-    for (CompPredicate Pred : Predicates) {
+    for (const CompPredicate& Pred : Predicates) {
       if (Pred(LHS, RHS))
         return true;
       if (Pred(RHS, LHS))
         return false;
     }
     return false;
   }
 

llvm/tools/llvm-tapi-diff/DiffEngine.cpp

diffAttribute("Application Extension Safe", Output,
                 DiffScalarVal<bool, AD_Diff_Scalar_Bool>(
                     Order, Interface->isApplicationExtensionSafe()));
   diffAttribute("Reexported Libraries", Output,
                 Interface->reexportedLibraries(), Order);
   diffAttribute("Allowable Clients", Output, Interface->allowableClients(),
                 Order);
   diffAttribute("Parent Umbrellas", Output, Interface->umbrellas(), Order);
   diffAttribute("Symbols", Output, Interface->symbols(), Order);
-  for (auto Doc : Interface->documents()) {
+  for (const auto& Doc : Interface->documents()) {
     DiffOutput Documents("Inlined Reexported Frameworks/Libraries");
     Documents.Kind = AD_Inline_Doc;
     Documents.Values.push_back(std::make_unique<InlineDoc>(
         InlineDoc(Doc->getInstallName(), getSingleIF(Doc.get(), Order))));
     Output.push_back(std::move(Documents));
   }
   return Output;
 }

llvm/tools/llvm-xray/xray-converter.cpp

 SmallVector<StackTrieNode *, 4>
 findSiblings(StackTrieNode *parent, int32_t FnId, uint32_t TId,
              const DenseMap<uint32_t, SmallVector<StackTrieNode *, 4>>
                  &StackRootsByThreadId) {
 
   SmallVector<StackTrieNode *, 4> Siblings{};
 
   if (parent == nullptr) {
-    for (auto map_iter : StackRootsByThreadId) {
+    for (const auto& map_iter : StackRootsByThreadId) {
       // Only look for siblings in other threads.
       if (map_iter.first != TId)
         for (auto node_iter : map_iter.second) {
           if (node_iter->FuncId == FnId)
             Siblings.push_back(node_iter);
         }
     }
     return Siblings;

llvm/tools/llvm-xray/xray-fdr-dump.cpp

for (auto &Ptr : Records)
     if (auto E = Ptr->apply(BI))
       return E;
 
   if (auto E = BI.flush())
     return E;
 
   // Then we validate while printing each block.
   BlockVerifier BV;
-  for (auto ProcessThreadBlocks : Index) {
+  for (const auto& ProcessThreadBlocks : Index) {
     auto &Blocks = ProcessThreadBlocks.second;
     for (auto &B : Blocks) {
       for (auto *R : B.Records) {
         if (auto E = R->apply(BV))
           return E;
         if (auto E = R->apply(BP))
           return E;
       }
       BV.reset();
       BP.reset();
     }
   }
   outs().flush();
   return Error::success();
 });

llvm/tools/llvm-xray/xray-stacks.cpp

OS << formatv("#{0,-4} {1,-60} {2,+12} {3,+16}\n", Level++,
                   LeafFuncId.size() > 60 ? LeafFuncId.substr(0, 57) + "..."
                                          : LeafFuncId,
                   Leaf->ExtraData.TerminalDurations.size(), LeafSum);
     OS << "\n";
   }
 
   /// Prints top stacks for each thread.
   void printPerThread(raw_ostream &OS, FuncIdConversionHelper &FN) {
-    for (auto iter : Roots) {
+    for (const auto& iter : Roots) {
       OS << "Thread " << iter.first << ":\n";
       print(OS, FN, iter.second);
       OS << "\n";
     }
   }
 
   /// Prints timing sums for each stack in each threads.
   template <AggregationType AggType>
   void printAllPerThread(raw_ostream &OS, FuncIdConversionHelper &FN,
                          StackOutputFormat format) {
-    for (auto iter : Roots) {
+    for (const auto& iter : Roots) {
       uint32_t threadId = iter.first;
       RootVector &perThreadRoots = iter.second;
       bool reportThreadId = true;
       printAll<AggType>(OS, FN, perThreadRoots, threadId, reportThreadId);
     }
   }
 
   /// Prints top stacks from looking at all the leaves and ignoring thread IDs.
void printIgnoringThreads(raw_ostream &OS, FuncIdConversionHelper &FN) {
 
     print(OS, FN, RootValues);
   }
 
   /// Creates a merged list of Tries for unique stacks that disregards their
   /// thread IDs.
   RootVector mergeAcrossThreads(std::forward_list<StackTrieNode> &NodeStore) {
     RootVector MergedByThreadRoots;
-    for (auto MapIter : Roots) {
+    for (const auto& MapIter : Roots) {
       const auto &RootNodeVector = MapIter.second;
       for (auto *Node : RootNodeVector) {
         auto MaybeFoundIter =
             find_if(MergedByThreadRoots, [Node](StackTrieNode *elem) {
               return Node->FuncId == elem->FuncId;
             });
         if (MaybeFoundIter == MergedByThreadRoots.end()) {
           MergedByThreadRoots.push_back(Node);

llvm/tools/obj2yaml/dwarf2yaml.cpp

 #include <optional>
 
 using namespace llvm;
 
 void dumpDebugAbbrev(DWARFContext &DCtx, DWARFYAML::Data &Y) {
   auto AbbrevSetPtr = DCtx.getDebugAbbrev();
   if (AbbrevSetPtr) {
     uint64_t AbbrevTableID = 0;
-    for (auto AbbrvDeclSet : *AbbrevSetPtr) {
+    for (const auto& AbbrvDeclSet : *AbbrevSetPtr) {
       Y.DebugAbbrev.emplace_back();
       Y.DebugAbbrev.back().ID = AbbrevTableID++;
-      for (auto AbbrvDecl : AbbrvDeclSet.second) {
+      for (const auto& AbbrvDecl : AbbrvDeclSet.second) {
         DWARFYAML::Abbrev Abbrv;
         Abbrv.Code = AbbrvDecl.getCode();
         Abbrv.Tag = AbbrvDecl.getTag();
         Abbrv.Children = AbbrvDecl.hasChildren() ? dwarf::DW_CHILDREN_yes
                                                  : dwarf::DW_CHILDREN_no;
         for (auto Attribute : AbbrvDecl.attributes()) {
           DWARFYAML::AttributeAbbrev AttAbrv;
           AttAbrv.Attribute = Attribute.Attr;

llvm/unittests/ADT/IteratorTest.cpp

TEST(FilterIteratorTest, Lambda) {
   EXPECT_EQ((SmallVector<int, 3>{1, 3, 5}), Actual);
 }
 
 TEST(FilterIteratorTest, Enumerate) {
   auto IsOdd = [](auto N) { return N.value() % 2 == 1; };
   int A[] = {0, 1, 2, 3, 4, 5, 6};
   auto Enumerate = llvm::enumerate(A);
   SmallVector<int> Actual;
-  for (auto IndexedValue : make_filter_range(Enumerate, IsOdd))
+  for (const auto& IndexedValue : make_filter_range(Enumerate, IsOdd))
     Actual.push_back(IndexedValue.value());
   EXPECT_EQ((SmallVector<int, 3>{1, 3, 5}), Actual);
 }
 
 TEST(FilterIteratorTest, CallableObject) {
   int Counter = 0;
   struct Callable {
     int &Counter;

llvm/unittests/ADT/STLExtrasTest.cpp

TEST(STLExtrasTest, EnumerateLValue) {
   EXPECT_TRUE(IntResults.empty());
 }
 
 TEST(STLExtrasTest, EnumerateModifyLValue) {
   // Test that you can modify the underlying entries of an lvalue range through
   // the enumeration iterator.
   std::vector<char> foo = {'a', 'b', 'c'};
 
-  for (auto X : llvm::enumerate(foo)) {
+  for (const auto& X : llvm::enumerate(foo)) {
     ++X.value();
   }
   EXPECT_THAT(foo, ElementsAre('b', 'c', 'd'));
 
   // Also test if this works with structured bindings.
   foo = {'a', 'b', 'c'};
 
   for (auto [index, value] : llvm::enumerate(foo)) {
     ++value;
   }
   EXPECT_THAT(foo, ElementsAre('b', 'c', 'd'));
 }
 
 TEST(STLExtrasTest, EnumerateRValueRef) {
   // Test that an rvalue can be enumerated.
   typedef std::pair<std::size_t, int> PairType;
   std::vector<PairType> Results;
 
   auto Enumerator = llvm::enumerate(std::vector<int>{1, 2, 3});
 
-  for (auto X : llvm::enumerate(std::vector<int>{1, 2, 3})) {
+  for (const auto& X : llvm::enumerate(std::vector<int>{1, 2, 3})) {
     Results.emplace_back(X.index(), X.value());
   }
 
   EXPECT_THAT(Results,
               ElementsAre(PairType(0u, 1), PairType(1u, 2), PairType(2u, 3)));
 
   // Also test if this works with structured bindings.
   Results.clear();
 
   for (auto [index, value] : llvm::enumerate(std::vector<int>{1, 2, 3})) {
     Results.emplace_back(index, value);
   }
 
   EXPECT_THAT(Results,
               ElementsAre(PairType(0u, 1), PairType(1u, 2), PairType(2u, 3)));
 }
 
 TEST(STLExtrasTest, EnumerateModifyRValue) {
   // Test that when enumerating an rvalue, modification still works (even if
   // this isn't terribly useful, it at least shows that we haven't snuck an
   // extra const in there somewhere.
   typedef std::pair<std::size_t, char> PairType;
   std::vector<PairType> Results;
 
-  for (auto X : llvm::enumerate(std::vector<char>{'1', '2', '3'})) {
+  for (const auto& X : llvm::enumerate(std::vector<char>{'1', '2', '3'})) {
     ++X.value();
     Results.emplace_back(X.index(), X.value());
   }
 
   EXPECT_THAT(Results, ElementsAre(PairType(0u, '2'), PairType(1u, '3'),
                                    PairType(2u, '4')));
 
   // Also test if this works with structured bindings.

llvm/unittests/DebugInfo/CodeView/RandomAccessVisitorTest.cpp

TEST_F(RandomAccessVisitorTest, MultipleVisits) {
 
   // [0,8) should be present
   EXPECT_EQ(8u, Types.size());
   for (uint32_t I = 0; I < 8; ++I)
     EXPECT_TRUE(ValidateDatabaseRecord(Types, I));
 
   // 5, 5, 5
   EXPECT_EQ(3u, TestState->Callbacks.count());
-  for (auto I : enumerate(IndicesToVisit))
+  for (const auto& I : enumerate(IndicesToVisit))
     EXPECT_TRUE(ValidateVisitedRecord(I.index(), I.value()));
 }
 
 TEST_F(RandomAccessVisitorTest, DescendingWithinChunk) {
   // Visit multiple items from the same "chunk" in reverse order.  In this
   // example, it's 7 then 4 then 2.  At the end, all records from 0 to 7 should
   // be known by the database, but only 2, 4, and 7 should have been visited.
   TestState->Offsets = createPartialOffsets(GlobalState->Stream, {0, 8});
TEST_F(RandomAccessVisitorTest, DescendingWithinChunk) {
 
   // [0, 7]
   EXPECT_EQ(8u, Types.size());
   for (uint32_t I = 0; I < 8; ++I)
     EXPECT_TRUE(ValidateDatabaseRecord(Types, I));
 
   // 2, 4, 7
   EXPECT_EQ(3u, TestState->Callbacks.count());
-  for (auto I : enumerate(IndicesToVisit))
+  for (const auto& I : enumerate(IndicesToVisit))
     EXPECT_TRUE(ValidateVisitedRecord(I.index(), I.value()));
 }
 
 TEST_F(RandomAccessVisitorTest, AscendingWithinChunk) {
   // * Visit multiple items from the same chunk in ascending order, ensuring
   //   that intermediate items are not visited.  In the below example, it's
   //   5 -> 6 -> 7 which come from the [4,8) chunk.
   TestState->Offsets = createPartialOffsets(GlobalState->Stream, {0, 8});
TEST_F(RandomAccessVisitorTest, StopPrematurelyInChunk) {
 
   // [0, 8) should be visited.
   EXPECT_EQ(8u, Types.size());
   for (uint32_t I = 0; I < 8; ++I)
     EXPECT_TRUE(ValidateDatabaseRecord(Types, I));
 
   // [0, 2]
   EXPECT_EQ(3u, TestState->Callbacks.count());
-  for (auto I : enumerate(IndicesToVisit))
+  for (const auto& I : enumerate(IndicesToVisit))
     EXPECT_TRUE(ValidateVisitedRecord(I.index(), I.value()));
 }
 
 TEST_F(RandomAccessVisitorTest, InnerChunk) {
   // Test that when a request comes from a chunk in the middle of the partial
   // offsets array, that items from surrounding chunks are not visited or
   // added to the database.
   TestState->Offsets = createPartialOffsets(GlobalState->Stream, {0, 4, 9});

llvm/unittests/FileCheck/FileCheckTest.cpp

 
 TEST_F(FileCheckTest, CapturedVarDiags) {
   PatternTester Tester;
   ASSERT_FALSE(Tester.parsePattern("[[STRVAR:[a-z]+]] [[#NUMVAR:@LINE]]"));
   EXPECT_THAT_EXPECTED(Tester.match("foobar 2"), Succeeded());
   std::vector<FileCheckDiag> Diags;
   Tester.printVariableDefs(FileCheckDiag::MatchFoundAndExpected, Diags);
   EXPECT_EQ(Diags.size(), 2ul);
-  for (FileCheckDiag Diag : Diags) {
+  for (const FileCheckDiag& Diag : Diags) {
     EXPECT_EQ(Diag.CheckTy, Check::CheckPlain);
     EXPECT_EQ(Diag.MatchTy, FileCheckDiag::MatchFoundAndExpected);
     EXPECT_EQ(Diag.InputStartLine, 1u);
     EXPECT_EQ(Diag.InputEndLine, 1u);
   }
   EXPECT_EQ(Diags[0].InputStartCol, 1u);
   EXPECT_EQ(Diags[0].InputEndCol, 7u);
   EXPECT_EQ(Diags[1].InputStartCol, 8u);
   EXPECT_EQ(Diags[1].InputEndCol, 9u);
   EXPECT_EQ(Diags[0].Note, "captured var \"STRVAR\"");
   EXPECT_EQ(Diags[1].Note, "captured var \"NUMVAR\"");
 }
 } // namespace

llvm/utils/FileCheck/FileCheck.cpp

BuildInputAnnotations(const SourceMgr &SM, unsigned CheckFileBufferID,
                       unsigned &LabelWidth) {
   struct CompareSMLoc {
     bool operator()(const SMLoc &LHS, const SMLoc &RHS) const {
       return LHS.getPointer() < RHS.getPointer();
     }
   };
   // How many diagnostics does each pattern have?
   std::map<SMLoc, unsigned, CompareSMLoc> DiagCountPerPattern;
-  for (auto Diag : Diags)
+  for (const auto& Diag : Diags)
     ++DiagCountPerPattern[Diag.CheckLoc];
   // How many diagnostics have we seen so far per pattern?
   std::map<SMLoc, unsigned, CompareSMLoc> DiagIndexPerPattern;
   // How many total diagnostics have we seen so far?
   unsigned DiagIndex = 0;
   // What's the widest label?
   LabelWidth = 0;
   for (auto DiagItr = Diags.begin(), DiagEnd = Diags.end(); DiagItr != DiagEnd;
bool Newline = false;
       WithColor COS(*LineOS, raw_ostream::SAVEDCOLOR, /*Bold=*/false,
                     /*BG=*/false, TheColorMode);
       bool InMatch = false;
       if (Req.Verbose)
         COS.changeColor(raw_ostream::CYAN, true, true);
       for (unsigned Col = 1; InputFilePtr != InputFileEnd && !Newline; ++Col) {
         bool WasInMatch = InMatch;
         InMatch = false;
-        for (auto M : FoundAndExpectedMatches) {
+        for (const auto& M : FoundAndExpectedMatches) {
           if (M.InputStartCol <= Col && Col < M.InputEndCol) {
             InMatch = true;
             break;
           }
         }
         if (!WasInMatch && InMatch)
           COS.resetColor();
         else if (WasInMatch && !InMatch)

llvm/utils/TableGen/InstrInfoEmitter.cpp

void InstrInfoEmitter::emitOperandTypeMappings(
   std::map<int, std::vector<StringRef>> SizeToOperandName;
   for (const Record *Op : Operands) {
     if (!Op->isSubClassOf("X86MemOperand"))
       continue;
     if (int Size = Op->getValueAsInt("Size"))
       SizeToOperandName[Size].push_back(Op->getName());
   }
   OS << "  default: return 0;\n";
-  for (auto KV : SizeToOperandName) {
+  for (const auto& KV : SizeToOperandName) {
     for (const StringRef &OperandName : KV.second)
       OS << "  case OpTypes::" << OperandName << ":\n";
     OS << "    return " << KV.first << ";\n\n";
   }
   OS << "  }\n}\n";
   OS << "} // end namespace " << Namespace << "\n";
   OS << "} // end namespace llvm\n";
   OS << "#endif // GET_INSTRINFO_MEM_OPERAND_SIZE\n\n";

llvm/utils/TableGen/IntrinsicEmitter.cpp

void IntrinsicEmitter::EmitTargetInfo(const CodeGenIntrinsicTable &Ints,
   OS << "// Target mapping\n";
   OS << "#ifdef GET_INTRINSIC_TARGET_DATA\n";
   OS << "struct IntrinsicTargetInfo {\n"
      << "  llvm::StringLiteral Name;\n"
      << "  size_t Offset;\n"
      << "  size_t Count;\n"
      << "};\n";
   OS << "static constexpr IntrinsicTargetInfo TargetInfos[] = {\n";
-  for (auto Target : Ints.Targets)
+  for (const auto& Target : Ints.Targets)
     OS << "  {llvm::StringLiteral(\"" << Target.Name << "\"), " << Target.Offset
        << ", " << Target.Count << "},\n";
   OS << "};\n";
   OS << "#endif\n\n";
 }
 
 void IntrinsicEmitter::EmitIntrinsicToNameTable(
     const CodeGenIntrinsicTable &Ints, raw_ostream &OS) {