[lld-macho][NFC] add const to pointer/reference induction variables of range-based for loops

[gkm]

Summary

Pointer and reference induction variables of range-based for loops are often const, and code authors often lax about qualifying them.

[int3]

lgtm

lld/MachO/Driver.cpp

for (const Arg *arg : args.filtered(OPT_sectcreate)) {
     StringRef sectName = arg->getValue(1);
     StringRef fileName = arg->getValue(2);
     Optional<MemoryBufferRef> buffer = readFile(fileName);
     if (buffer)
       inputFiles.insert(make<OpaqueFile>(*buffer, segName, sectName));
   }
 
   // Initialize InputSections.
-  for (InputFile *file : inputFiles) {
-    for (SubsectionMap &map : file->subsections) {
+  for (const InputFile *file : inputFiles) {
+    for (const SubsectionMap &map : file->subsections) {
       for (const auto &p : map) {
         InputSection *isec = p.second;
         inputSections.push_back(isec);
       }
     }
   }
 
   // Write to an output file.
   writeResult();
 
   if (canExitEarly)
     exitLld(errorCount() ? 1 : 0);
 
   return !errorCount();
 }

lld/MachO/Dwarf.cpp

 std::unique_ptr<DwarfObject> DwarfObject::create(ObjFile *obj) {
   auto dObj = std::make_unique<DwarfObject>();
   bool hasDwarfInfo = false;
   // LLD only needs to extract the source file path from the debug info, so we
   // initialize DwarfObject with just the sections necessary to get that path.
   // The debugger will locate the debug info via the object file paths that we
   // emit in our STABS symbols, so we don't need to process & emit them
   // ourselves.
-  for (InputSection *isec : obj->debugSections) {
+  for (const InputSection *isec : obj->debugSections) {
     if (StringRef *s = StringSwitch<StringRef *>(isec->name)
                            .Case("__debug_info", &dObj->infoSection.Data)
                            .Case("__debug_abbrev", &dObj->abbrevSection)
                            .Case("__debug_str", &dObj->strSection)
                            .Default(nullptr)) {
       *s = toStringRef(isec->data);
       hasDwarfInfo = true;
     }
   }
 
   if (hasDwarfInfo)
     return dObj;
   return nullptr;
 }

lld/MachO/ExportTrie.cpp

if (info) {
     // Overall node size so far is the uleb128 size of the length of the symbol
     // info + the symbol info itself.
     nodeSize = terminalSize + getULEB128Size(terminalSize);
   } else {
     nodeSize = 1; // Size of terminalSize (which has a value of 0)
   }
   // Compute size of all child edges.
   ++nodeSize; // Byte for number of children.
-  for (Edge &edge : edges) {
+  for (const Edge &edge : edges) {
     nodeSize += edge.substring.size() + 1             // String length.
                 + getULEB128Size(edge.child->offset); // Offset len.
   }
   // On input, 'nextOffset' is the new preferred location for this node.
   bool result = (offset != nextOffset);
   // Store new location in node object for use by parents.
   offset = nextOffset;
   nextOffset += nodeSize;

lld/MachO/SyntheticSections.cpp

if (config->outputType == MachO::MH_EXECUTE && config->isPic)
     hdr->flags |= MachO::MH_PIE;
 
   if (in.exports->hasWeakSymbol || in.weakBinding->hasNonWeakDefinition())
     hdr->flags |= MachO::MH_WEAK_DEFINES;
 
   if (in.exports->hasWeakSymbol || in.weakBinding->hasEntry())
     hdr->flags |= MachO::MH_BINDS_TO_WEAK;
 
-  for (OutputSegment *seg : outputSegments) {
-    for (OutputSection *osec : seg->getSections()) {
+  for (const OutputSegment *seg : outputSegments) {
+    for (const OutputSection *osec : seg->getSections()) {
       if (isThreadLocalVariables(osec->flags)) {
         hdr->flags |= MachO::MH_HAS_TLV_DESCRIPTORS;
         break;
       }
     }
   }
 
   uint8_t *p = reinterpret_cast<uint8_t *>(hdr + 1);
-  for (LoadCommand *lc : loadCommands) {
+  for (const LoadCommand *lc : loadCommands) {
     lc->writeTo(p);
     p += lc->getSize();
   }
 }
 
 PageZeroSection::PageZeroSection()
     : SyntheticSection(segment_names::pageZero, section_names::pageZero) {}
 

 void SymtabSection::finalizeContents() {
   auto addSymbol = [&](std::vector<SymtabEntry> &symbols, Symbol *sym) {
     uint32_t strx = stringTableSection.addString(sym->getName());
     symbols.push_back({sym, strx});
   };
 
   // Local symbols aren't in the SymbolTable, so we walk the list of object
   // files to gather them.
-  for (InputFile *file : inputFiles) {
+  for (const InputFile *file : inputFiles) {
     if (auto *objFile = dyn_cast<ObjFile>(file)) {
       for (Symbol *sym : objFile->symbols) {
         if (sym == nullptr)
           continue;
         // TODO: when we implement -dead_strip, we should filter out symbols
         // that belong to dead sections.
         if (auto *defined = dyn_cast<Defined>(sym)) {
           if (!defined->isExternal()) {

lld/MachO/UnwindInfoSection.cpp

 }
 
 // We need to apply the relocations to the pre-link compact unwind section
 // before converting it to post-link form. There should only be absolute
 // relocations here: since we are not emitting the pre-link CU section, there
 // is no source address to make a relative location meaningful.
 static void relocateCompactUnwind(MergedOutputSection *compactUnwindSection,
                                   std::vector<CompactUnwindEntry64> &cuVector) {
-  for (InputSection *isec : compactUnwindSection->inputs) {
+  for (const InputSection *isec : compactUnwindSection->inputs) {
     uint8_t *buf =
         reinterpret_cast<uint8_t *>(cuVector.data()) + isec->outSecFileOff;
     memcpy(buf, isec->data.data(), isec->data.size());
 
-    for (Reloc &r : isec->relocs) {
+    for (const Reloc &r : isec->relocs) {
       uint64_t referentVA = 0;
       if (auto *referentSym = r.referent.dyn_cast<macho::Symbol *>()) {
         if (!isa<Undefined>(referentSym)) {
           assert(referentSym->isInGot());
           if (auto *defined = dyn_cast<Defined>(referentSym))
             checkTextSegment(defined->isec);
           // At this point in the link, we may not yet know the final address of
           // the GOT, so we just encode the index. We make it a 1-based index so

lld/MachO/Writer.cpp

void writeTo(uint8_t *buf) const override {
     if (seg->getSections().empty())
       return;
 
     c->vmaddr = seg->firstSection()->addr;
     c->vmsize =
         seg->lastSection()->addr + seg->lastSection()->getSize() - c->vmaddr;
     c->nsects = seg->numNonHiddenSections();
 
-    for (OutputSection *osec : seg->getSections()) {
+    for (const OutputSection *osec : seg->getSections()) {
       if (!isZeroFill(osec->flags)) {
         assert(osec->fileOff >= seg->fileOff);
         c->filesize = std::max(
             c->filesize, osec->fileOff + osec->getFileSize() - seg->fileOff);
       }
 
       if (osec->isHidden())
         continue;
if (it == config->priorities.end())
       return;
 
     SymbolPriorityEntry &entry = it->second;
     size_t &priority = sectionPriorities[sym.isec];
     priority = std::max(priority, getSymbolPriority(entry, sym.isec->file));
   };
 
   // TODO: Make sure this handles weak symbols correctly.
-  for (InputFile *file : inputFiles)
+  for (const InputFile *file : inputFiles)
     if (isa<ObjFile>(file))
       for (lld::macho::Symbol *sym : file->symbols)
         if (auto *d = dyn_cast<Defined>(sym))
           addSym(*d);
 
   return sectionPriorities;
 }
 
if (!bufferOrErr)
     error("failed to open " + config->outputFile + ": " +
           llvm::toString(bufferOrErr.takeError()));
   else
     buffer = std::move(*bufferOrErr);
 }
 
 void Writer::writeSections() {
   uint8_t *buf = buffer->getBufferStart();
-  for (OutputSegment *seg : outputSegments)
-    for (OutputSection *osec : seg->getSections())
+  for (const OutputSegment *seg : outputSegments)
+    for (const OutputSection *osec : seg->getSections())
       osec->writeTo(buf + osec->fileOff);
 }
 
 void Writer::writeUuid() {
   uint64_t digest =
       xxHash64({buffer->getBufferStart(), buffer->getBufferEnd()});
   uuidCommand->writeUuid(digest);
 }