[lld/mac] Make two local variables const

[thakis]

Summary

While reading this code, I was wondering if we change these variables in the
loop. We don't, so make them const to make this easier to see next time.

No behavior change.

[tschuett]

lld/MachO/InputFiles.cpp

813

symbolOffset is not const?

813

Sorry. It is not const.

844

These integers are not const?

[int3]

lgtm. seems like something that can be pushed w/o review tho

[oontvoo]

LG

lld/MachO/InputFiles.cpp

813

I had the same question - then I saw that findCOntainingSubsection() takes an output param.
any objection to refactoring that too - then this one could be const? (doesn't have to be in this patch)

[thakis]

In D135877#3855727, @int3 wrote:

lgtm. seems like something that can be pushed w/o review tho

Yes, almost did that. Will do next time, sorry!

lld/MachO/InputFiles.cpp

for (size_t i = 0; i < sections.size(); ++i) {
     uint64_t sectionAddr = sectionHeaders[i].addr;
     uint32_t sectionAlign = 1u << sectionHeaders[i].align;
 
     // Some sections have already been split into subsections during
     // parseSections(), so we simply need to match Symbols to the corresponding
     // subsection here.
     if (sections[i]->doneSplitting) {
       for (size_t j = 0; j < symbolIndices.size(); ++j) {
-        uint32_t symIndex = symbolIndices[j];
+        const uint32_t symIndex = symbolIndices[j];
         const NList &sym = nList[symIndex];
         StringRef name = strtab + sym.n_strx;
         uint64_t symbolOffset = sym.n_value - sectionAddr;
         InputSection *isec =
             findContainingSubsection(*sections[i], &symbolOffset);
         if (symbolOffset != 0) {
           error(toString(*sections[i]) + ":  symbol " + name +
                 " at misaligned offset");
           continue;
         }
         symbols[symIndex] =
             createDefined(sym, name, isec, 0, isec->getSize(), forceHidden);
       }
       continue;
     }
     sections[i]->doneSplitting = true;
 
     // Calculate symbol sizes and create subsections by splitting the sections
     // along symbol boundaries.
     // We populate subsections by repeatedly splitting the last (highest
     // address) subsection.
     llvm::stable_sort(symbolIndices, [&](uint32_t lhs, uint32_t rhs) {
       return nList[lhs].n_value < nList[rhs].n_value;
     });
     for (size_t j = 0; j < symbolIndices.size(); ++j) {
-      uint32_t symIndex = symbolIndices[j];
+      const uint32_t symIndex = symbolIndices[j];
       const NList &sym = nList[symIndex];
       StringRef name = strtab + sym.n_strx;
       Subsection &subsec = subsections.back();
       InputSection *isec = subsec.isec;
 
       uint64_t subsecAddr = sectionAddr + subsec.offset;
       size_t symbolOffset = sym.n_value - subsecAddr;
       uint64_t symbolSize =
           j + 1 < symbolIndices.size()
               ? nList[symbolIndices[j + 1]].n_value - sym.n_value
               : isec->data.size() - symbolOffset;
       // There are 4 cases where we do not need to create a new subsection:
       //   1. If the input file does not use subsections-via-symbols.
       //   2. Multiple symbols at the same address only induce one subsection.
       //      (The symbolOffset == 0 check covers both this case as well as
       //      the first loop iteration.)