[lld-macho][nfc] Use llvm::enumerate + destructuring in more places

[int3]

Summary

I love C++17!

chromium_framework_less_dwarf on my 16-core Mac Pro shows no stat sig change in wall time but a slight decrease in user time:

           base           diff           difference (95% CI)
sys_time   1.759 ± 0.037  1.761 ± 0.033  [  -0.9% ..   +1.1%]
user_time  4.920 ± 0.043  4.886 ± 0.051  [  -1.2% ..   -0.2%]
wall_time  5.950 ± 0.117  5.900 ± 0.116  [  -1.8% ..   +0.2%]
samples    26             37

[thakis]

Lg

lld/MachO/InputFiles.cpp

template <class LP> void ObjFile::parseLazy() {
   const load_command *cmd = findCommand(hdr, LC_SYMTAB);
   if (!cmd)
     return;
   auto *c = reinterpret_cast<const symtab_command *>(cmd);
   ArrayRef<NList> nList(reinterpret_cast<const NList *>(buf + c->symoff),
                         c->nsyms);
   const char *strtab = reinterpret_cast<const char *>(buf) + c->stroff;
   symbols.resize(nList.size());
-  for (auto it : llvm::enumerate(nList)) {
-    const NList &sym = it.value();
+  for (const auto &[i, sym] : llvm::enumerate(nList)) {
     if ((sym.n_type & N_EXT) && !isUndef(sym)) {
       // TODO: Bound checking
       StringRef name = strtab + sym.n_strx;
-      symbols[it.index()] = symtab->addLazyObject(name, *this);
+      symbols[i] = symtab->addLazyObject(name, *this);
       if (!lazy)
         break;
     }
   }
 }
 
 void ObjFile::parseDebugInfo() {
   std::unique_ptr<DwarfObject> dObj = DwarfObject::create(this);
void BitcodeFile::parse() {
   // time.
   symbols.clear();
   for (const lto::InputFile::Symbol &objSym : obj->symbols())
     symbols.push_back(createBitcodeSymbol(objSym, *this));
 }
 
 void BitcodeFile::parseLazy() {
   symbols.resize(obj->symbols().size());
-  for (auto it : llvm::enumerate(obj->symbols())) {
-    const lto::InputFile::Symbol &objSym = it.value();
+  for (const auto &[i, objSym] : llvm::enumerate(obj->symbols())) {
     if (!objSym.isUndefined()) {
-      symbols[it.index()] =
-          symtab->addLazyObject(saver().save(objSym.getName()), *this);
+      symbols[i] = symtab->addLazyObject(saver().save(objSym.getName()), *this);
       if (!lazy)
         break;
     }
   }
 }
 
 void macho::extract(InputFile &file, StringRef reason) {
   assert(file.lazy);

lld/MachO/SyntheticSections.cpp

void macho::writeChainedFixup(uint8_t *buf, const Symbol *sym, int64_t addend) {
   if (needsBinding(sym))
     writeChainedBind(buf, sym, addend);
   else
     writeChainedRebase(buf, sym->getVA() + addend);
 }
 
 void NonLazyPointerSectionBase::writeTo(uint8_t *buf) const {
   if (config->emitChainedFixups) {
-    for (size_t i = 0, n = entries.size(); i < n; ++i)
-      writeChainedFixup(&buf[i * target->wordSize], entries[i], 0);
+    for (const auto &[i, entry] : llvm::enumerate(entries))
+      writeChainedFixup(&buf[i * target->wordSize], entry, 0);
   } else {
-    for (size_t i = 0, n = entries.size(); i < n; ++i)
-      if (auto *defined = dyn_cast<Defined>(entries[i]))
+    for (const auto &[i, entry] : llvm::enumerate(entries))
+      if (auto *defined = dyn_cast<Defined>(entry))
         write64le(&buf[i * target->wordSize], defined->getVA());
   }
 }
 
 GotSection::GotSection()
     : NonLazyPointerSectionBase(segment_names::data, section_names::got) {
   flags = S_NON_LAZY_SYMBOL_POINTERS;
 }
void CStringSection::addInput(CStringInputSection *isec) {
   isec->parent = this;
   inputs.push_back(isec);
   if (isec->align > align)
     align = isec->align;
 }
 
 void CStringSection::writeTo(uint8_t *buf) const {
   for (const CStringInputSection *isec : inputs) {
-    for (size_t i = 0, e = isec->pieces.size(); i != e; ++i) {
-      if (!isec->pieces[i].live)
+    for (const auto &[i, piece] : llvm::enumerate(isec->pieces)) {
+      if (!piece.live)
         continue;
       StringRef string = isec->getStringRef(i);
-      memcpy(buf + isec->pieces[i].outSecOff, string.data(), string.size());
+      memcpy(buf + piece.outSecOff, string.data(), string.size());
     }
   }
 }
 
 void CStringSection::finalizeContents() {
   uint64_t offset = 0;
   for (CStringInputSection *isec : inputs) {
-    for (size_t i = 0, e = isec->pieces.size(); i != e; ++i) {
-      if (!isec->pieces[i].live)
+    for (const auto &[i, piece] : llvm::enumerate(isec->pieces)) {
+      if (!piece.live)
         continue;
       // See comment above DeduplicatedCStringSection for how alignment is
       // handled.
-      uint32_t pieceAlign =
-          1 << countTrailingZeros(isec->align | isec->pieces[i].inSecOff);
+      uint32_t pieceAlign = 1
+                            << countTrailingZeros(isec->align | piece.inSecOff);
       offset = alignTo(offset, pieceAlign);
-      isec->pieces[i].outSecOff = offset;
+      piece.outSecOff = offset;
       isec->isFinal = true;
       StringRef string = isec->getStringRef(i);
       offset += string.size() + 1; // account for null terminator
     }
   }
   size = offset;
 }
 

 // requires its operand addresses to be 16-byte aligned). However, there will
 // typically also be other cstrings in the same file that aren't used via SIMD
 // and don't need this alignment. They will be emitted at some arbitrary address
 // `A`, but ld64 will treat them as being 16-byte aligned with an offset of `16
 // % A`.
 void DeduplicatedCStringSection::finalizeContents() {
   // Find the largest alignment required for each string.
   for (const CStringInputSection *isec : inputs) {
-    for (size_t i = 0, e = isec->pieces.size(); i != e; ++i) {
-      const StringPiece &piece = isec->pieces[i];
+    for (const auto &[i, piece] : llvm::enumerate(isec->pieces)) {
       if (!piece.live)
         continue;
       auto s = isec->getCachedHashStringRef(i);
       assert(isec->align != 0);
       uint8_t trailingZeros = countTrailingZeros(isec->align | piece.inSecOff);
       auto it = stringOffsetMap.insert(
           std::make_pair(s, StringOffset(trailingZeros)));
       if (!it.second && it.first->second.trailingZeros < trailingZeros)
         it.first->second.trailingZeros = trailingZeros;
     }
   }
 
   // Assign an offset for each string and save it to the corresponding
   // StringPieces for easy access.
   for (CStringInputSection *isec : inputs) {
-    for (size_t i = 0, e = isec->pieces.size(); i != e; ++i) {
-      if (!isec->pieces[i].live)
+    for (const auto &[i, piece] : llvm::enumerate(isec->pieces)) {
+      if (!piece.live)
         continue;
       auto s = isec->getCachedHashStringRef(i);
       auto it = stringOffsetMap.find(s);
       assert(it != stringOffsetMap.end());
       StringOffset &offsetInfo = it->second;
       if (offsetInfo.outSecOff == UINT64_MAX) {
         offsetInfo.outSecOff = alignTo(size, 1ULL << offsetInfo.trailingZeros);
         size =
             offsetInfo.outSecOff + s.size() + 1; // account for null terminator
       }
-      isec->pieces[i].outSecOff = offsetInfo.outSecOff;
+      piece.outSecOff = offsetInfo.outSecOff;
     }
     isec->isFinal = true;
   }
 }
 
 void DeduplicatedCStringSection::writeTo(uint8_t *buf) const {
   for (const auto &p : stringOffsetMap) {
     StringRef data = p.first.val();