[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

2092

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 ↗

(On Diff #480753)

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/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/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

if (Ctx.FileKind >= FileType::TBD_V5) {
     return serializeInterfaceFileToJSON(OS, File, Ctx.FileKind, Compact);
   }
 
   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/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-readtapi/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/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/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/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) {