[lld-macho][nfc] Factor out findSymbolAtOffset

[int3]

Summary

Our compact unwind handling code currently has some logic to locate a
symbol at a given offset in an InputSection. The EH frame code will need
to do something similar, so let's factor out the code.

[thakis]

Do you see a speedup from the microoptimization in some other benchmark? If not, omit it (?)

lld/MachO/InputFiles.cpp

1020

Previously we advanced it instead of doing it = isec->relocs.erase(it) if nothing was found. The rhs doesn't do that. Is that intentional?

[int3]

Yeah I don't see any benchmark improvement... I guess it's not worth the additional code complexity

lld/MachO/InputFiles.cpp

1020

oops, good catch

[int3]

lld/MachO/InputFiles.cpp

1020

I think erasing it might actually make more sense, but I'll revisit this in a future diff. this one is supposed to be a NFC

[int3]

address comments

lld/MachO/InputFiles.cpp

static_assert(std::is_same<uint64_t, T>::value ||
                 "unexpected type for offset");
   auto it = std::prev(llvm::upper_bound(
       section.subsections, *offset,
       [](uint64_t value, Subsection subsec) { return value < subsec.offset; }));
   *offset -= it->offset;
   return it->isec;
 }
 
+// Find a symbol at offset `off` within `isec`.
+static Defined *findSymbolAtOffset(const ConcatInputSection *isec,
+                                   uint64_t off) {
+  auto it = llvm::lower_bound(isec->symbols, off, [](Defined *d, uint64_t off) {
+    return d->value < off;
+  });
+  // The offset should point at the exact address of a symbol (with no addend.)
+  if (it == isec->symbols.end() || (*it)->value != off) {
+    assert(isec->wasCoalesced);
+    return nullptr;
+  }
+  return *it;
+}
+
 template <class SectionHeader>
 static bool validateRelocationInfo(InputFile *file, const SectionHeader &sec,
                                    relocation_info rel) {
   const RelocAttrs &relocAttrs = target->getRelocAttrs(rel.r_type);
   bool valid = true;
   auto message = [relocAttrs, file, sec, rel, &valid](const Twine &diagnostic) {
     valid = false;
     return (relocAttrs.name + " relocation " + diagnostic + " at offset " +
for (auto it = isec->relocs.begin(); it != isec->relocs.end();) {
       // for compact unwind to reference addresses in __TEXT, but not addresses
       // in any other segment.
       if (referentIsec->getSegName() != segment_names::text)
         error(isec->getLocation(r.offset) + " references section " +
               referentIsec->getName() + " which is not in segment __TEXT");
       // The functionAddress relocations are typically section relocations.
       // However, unwind info operates on a per-symbol basis, so we search for
       // the function symbol here.
-      auto symIt = llvm::lower_bound(
-          referentIsec->symbols, add,
-          [](Defined *d, uint64_t add) { return d->value < add; });
-      // The relocation should point at the exact address of a symbol (with no
-      // addend).
-      if (symIt == referentIsec->symbols.end() || (*symIt)->value != add) {
-        assert(referentIsec->wasCoalesced);
+      Defined *d = findSymbolAtOffset(referentIsec, add);
+      if (!d) {
         ++it;
         continue;
       }
-      (*symIt)->unwindEntry = isec;
+      d->unwindEntry = isec;
       // Since we've sliced away the functionAddress, we should remove the
       // corresponding relocation too. Given that clang emits relocations in
       // reverse order of address, this relocation should be at the end of the
       // vector for most of our input object files, so this is typically an O(1)
       // operation.
       it = isec->relocs.erase(it);
     }
   }