[NFC] Prepare for new includes

[scott.linder]

Summary

Prepatch for D141970 which makes bare Reloc ambiguous (both
llvm::Reloc and macho::Reloc are visible).

[int3]

I intentionally avoided including Codegen.h for this reason. Can we use forward declarations instead?

[scott.linder]

In D142498#4078797, @int3 wrote:

I intentionally avoided including Codegen.h for this reason. Can we use forward declarations instead?

I didn't think so, but I wasn't certain why; I double checked and realized the prohibition on forward declaring enums only applies when the underlying type is not specified (i.e. the size isn't known).

I'll fix it tomorrow and drop this review; thank you for getting me to check again!

lld/MachO/Arch/ARM.cpp

 
 namespace {
 
 struct ARM : TargetInfo {
   ARM(uint32_t cpuSubtype);
 
   int64_t getEmbeddedAddend(MemoryBufferRef, uint64_t offset,
                             const relocation_info) const override;
-  void relocateOne(uint8_t *loc, const Reloc &, uint64_t va,
+  void relocateOne(uint8_t *loc, const macho::Reloc &, uint64_t va,
                    uint64_t pc) const override;
 
   void writeStub(uint8_t *buf, const Symbol &, uint64_t) const override;
   void writeStubHelperHeader(uint8_t *buf) const override;
   void writeStubHelperEntry(uint8_t *buf, const Symbol &,
                             uint64_t entryAddr) const override;
 
   void writeObjCMsgSendStub(uint8_t *buf, Symbol *sym, uint64_t stubsAddr,
                             uint64_t stubOffset, uint64_t selrefsVA,
                             uint64_t selectorIndex, uint64_t gotAddr,
                             uint64_t msgSendIndex) const override;
 
   void relaxGotLoad(uint8_t *loc, uint8_t type) const override;
   uint64_t getPageSize() const override { return 4 * 1024; }
 
-  void handleDtraceReloc(const Symbol *sym, const Reloc &r,
+  void handleDtraceReloc(const Symbol *sym, const macho::Reloc &r,
                          uint8_t *loc) const override;
 };
 } // namespace
 
 static constexpr std::array<RelocAttrs, 10> relocAttrsArray{{
 #define B(x) RelocAttrBits::x
     {"VANILLA", /* FIXME populate this */ B(_0)},
     {"PAIR", /* FIXME populate this */ B(_0)},

 //
 // BLX is always unconditional, so while we can convert directly from BLX to BL,
 // we need to insert a shim if a BL's target is a Thumb function.
 //
 // Helper aliases for decoding BL / BLX:
 using Cond = Bitfield::Element<uint32_t, 28, 4>;
 using Imm24 = Bitfield::Element<int32_t, 0, 24>;
 
-void ARM::relocateOne(uint8_t *loc, const Reloc &r, uint64_t value,
+void ARM::relocateOne(uint8_t *loc, const macho::Reloc &r, uint64_t value,
                       uint64_t pc) const {
   switch (r.type) {
   case ARM_RELOC_BR24: {
     uint32_t base = read32le(loc);
     bool isBlx = Bitfield::get<Cond>(base) == 0xf;
     const Symbol *sym = r.referent.get<Symbol *>();
     int32_t offset = value - (pc + 8);
 
ARM::ARM(uint32_t cpuSubtype) : TargetInfo(ILP32()) {
   relocAttrs = {relocAttrsArray.data(), relocAttrsArray.size()};
 }
 
 TargetInfo *macho::createARMTargetInfo(uint32_t cpuSubtype) {
   static ARM t(cpuSubtype);
   return &t;
 }
 
-void ARM::handleDtraceReloc(const Symbol *sym, const Reloc &r,
+void ARM::handleDtraceReloc(const Symbol *sym, const macho::Reloc &r,
                             uint8_t *loc) const {
   if (config->outputType == MH_OBJECT)
     return;
 
   switch (r.type) {
   case ARM_RELOC_BR24:
     if (sym->getName().startswith("___dtrace_probe")) {
       // change call site to a NOP

lld/MachO/EhFrame.cpp

  * Create a pair of relocs to write the value of:
  *   `b - (offset + a)` if Invert == false
  *   `(a + offset) - b` if Invert == true
  */
 template <bool Invert = false>
 static void createSubtraction(PointerUnion<Symbol *, InputSection *> a,
                               PointerUnion<Symbol *, InputSection *> b,
                               uint64_t off, uint8_t length,
-                              SmallVectorImpl<Reloc> *newRelocs) {
+                              SmallVectorImpl<macho::Reloc> *newRelocs) {
   auto subtrahend = a;
   auto minuend = b;
   if (Invert)
     std::swap(subtrahend, minuend);
   assert(subtrahend.is<Symbol *>());
-  Reloc subtrahendReloc(target->subtractorRelocType, /*pcrel=*/false, length,
-                        off, /*addend=*/0, subtrahend);
-  Reloc minuendReloc(target->unsignedRelocType, /*pcrel=*/false, length, off,
-                     (Invert ? 1 : -1) * off, minuend);
+  macho::Reloc subtrahendReloc(target->subtractorRelocType, /*pcrel=*/false,
+                               length, off, /*addend=*/0, subtrahend);
+  macho::Reloc minuendReloc(target->unsignedRelocType, /*pcrel=*/false, length,
+                            off, (Invert ? 1 : -1) * off, minuend);
   newRelocs->push_back(subtrahendReloc);
   newRelocs->push_back(minuendReloc);
 }
 
 void EhRelocator::makePcRel(uint64_t off,
                             PointerUnion<Symbol *, InputSection *> target,
                             uint8_t length) {
   createSubtraction(isec->symbols[0], target, off, length, &newRelocs);

lld/MachO/ICF.cpp

bool ICF::equalsConstant(const ConcatInputSection *ia,
   if (ia->parent != ib->parent)
     return false;
   if (ia->data.size() != ib->data.size())
     return false;
   if (ia->data != ib->data)
     return false;
   if (ia->relocs.size() != ib->relocs.size())
     return false;
-  auto f = [](const Reloc &ra, const Reloc &rb) {
+  auto f = [](const macho::Reloc &ra, const macho::Reloc &rb) {
     if (ra.type != rb.type)
       return false;
     if (ra.pcrel != rb.pcrel)
       return false;
     if (ra.length != rb.length)
       return false;
     if (ra.offset != rb.offset)
       return false;

 
 // Compare the "moving" parts of two ConcatInputSections -- i.e. everything not
 // handled by equalsConstant().
 bool ICF::equalsVariable(const ConcatInputSection *ia,
                          const ConcatInputSection *ib) {
   if (verboseDiagnostics)
     ++equalsVariableCount;
   assert(ia->relocs.size() == ib->relocs.size());
-  auto f = [this](const Reloc &ra, const Reloc &rb) {
+  auto f = [this](const macho::Reloc &ra, const macho::Reloc &rb) {
     // We already filtered out mismatching values/addends in equalsConstant.
     if (ra.referent == rb.referent)
       return true;
     const ConcatInputSection *isecA, *isecB;
     if (ra.referent.is<Symbol *>()) {
       // Matching DylibSymbols are already filtered out by the
       // identical-referent check above. Non-matching DylibSymbols were filtered
       // out in equalsConstant(). So we can safely cast to Defined here.
void ICF::forEachClass(llvm::function_ref<void(size_t, size_t)> func) {
   ++icfPass;
 }
 
 void ICF::run() {
   // Into each origin-section hash, combine all reloc referent section hashes.
   for (icfPass = 0; icfPass < 2; ++icfPass) {
     parallelForEach(icfInputs, [&](ConcatInputSection *isec) {
       uint32_t hash = isec->icfEqClass[icfPass % 2];
-      for (const Reloc &r : isec->relocs) {
+      for (const macho::Reloc &r : isec->relocs) {
         if (auto *sym = r.referent.dyn_cast<Symbol *>()) {
           if (auto *defined = dyn_cast<Defined>(sym)) {
             if (defined->isec) {
               if (auto referentIsec =
                       dyn_cast<ConcatInputSection>(defined->isec))
                 hash += defined->value + referentIsec->icfEqClass[icfPass % 2];
               else
                 hash += defined->isec->kind() +
for (InputFile *file : inputFiles) {
 
     Section *addrSigSection = obj->addrSigSection;
     if (!addrSigSection)
       continue;
     assert(addrSigSection->subsections.size() == 1);
 
     const InputSection *isec = addrSigSection->subsections[0].isec;
 
-    for (const Reloc &r : isec->relocs) {
+    for (const macho::Reloc &r : isec->relocs) {
       if (auto *sym = r.referent.dyn_cast<Symbol *>())
         markSymAsAddrSig(sym);
       else
         error(toString(isec) + ": unexpected section relocation");
     }
   }
 }
 
if (isFoldable) {
       // checks. (We can ignore embedded addends when doing ICF because the same
       // information gets recorded in our Reloc structs.) We therefore create a
       // mutable copy of the section data and zero out the embedded addends
       // before performing any hashing / equality checks.
       if (isFoldableWithAddendsRemoved) {
         // We have to do this copying serially as the BumpPtrAllocator is not
         // thread-safe. FIXME: Make a thread-safe allocator.
         MutableArrayRef<uint8_t> copy = isec->data.copy(bAlloc());
-        for (const Reloc &r : isec->relocs)
+        for (const macho::Reloc &r : isec->relocs)
           target->relocateOne(copy.data() + r.offset, r, /*va=*/0,
                               /*relocVA=*/0);
         isec->data = copy;
       }
     } else if (!isEhFrameSection(isec)) {
       // EH frames are gathered as foldables from unwindEntry above; give a
       // unique ID to everything else.
       isec->icfEqClass[0] = ++icfUniqueID;

lld/MachO/InputSection.cpp

 using namespace llvm::MachO;
 using namespace llvm::support;
 using namespace lld;
 using namespace lld::macho;
 
 // Verify ConcatInputSection's size on 64-bit builds. The size of std::vector
 // can differ based on STL debug levels (e.g. iterator debugging on MSVC's STL),
 // so account for that.
-static_assert(sizeof(void *) != 8 ||
-                  sizeof(ConcatInputSection) == sizeof(std::vector<Reloc>) + 88,
+static_assert(sizeof(void *) != 8 || sizeof(ConcatInputSection) ==
+                                         sizeof(std::vector<macho::Reloc>) + 88,
               "Try to minimize ConcatInputSection's size, we create many "
               "instances of it");
 
 std::vector<ConcatInputSection *> macho::inputSections;
 
 uint64_t InputSection::getFileSize() const {
   return isZeroFill(getFlags()) ? 0 : getSize();
 }
void ConcatInputSection::writeTo(uint8_t *buf) {
   assert(!shouldOmitFromOutput());
 
   if (getFileSize() == 0)
     return;
 
   memcpy(buf, data.data(), data.size());
 
   for (size_t i = 0; i < relocs.size(); i++) {
-    const Reloc &r = relocs[i];
+    const macho::Reloc &r = relocs[i];
     uint8_t *loc = buf + r.offset;
     uint64_t referentVA = 0;
 
     const bool needsFixup = config->emitChainedFixups &&
                             target->hasAttr(r.type, RelocAttrBits::UNSIGNED);
     if (target->hasAttr(r.type, RelocAttrBits::SUBTRAHEND)) {
       const Symbol *fromSym = r.referent.get<Symbol *>();
-      const Reloc &minuend = relocs[++i];
+      const macho::Reloc &minuend = relocs[++i];
       uint64_t minuendVA;
       if (const Symbol *toSym = minuend.referent.dyn_cast<Symbol *>())
         minuendVA = toSym->getVA() + minuend.addend;
       else {
         auto *referentIsec = minuend.referent.get<InputSection *>();
         assert(!::shouldOmitFromOutput(referentIsec));
         minuendVA = referentIsec->getVA(minuend.addend);
       }

lld/MachO/Relocations.cpp

 #include "Target.h"
 
 #include "lld/Common/ErrorHandler.h"
 
 using namespace llvm;
 using namespace lld;
 using namespace lld::macho;
 
-static_assert(sizeof(void *) != 8 || sizeof(Reloc) == 24,
+static_assert(sizeof(void *) != 8 || sizeof(macho::Reloc) == 24,
               "Try to minimize Reloc's size; we create many instances");
 
 bool macho::validateSymbolRelocation(const Symbol *sym,
-                                     const InputSection *isec, const Reloc &r) {
+                                     const InputSection *isec,
+                                     const macho::Reloc &r) {
   const RelocAttrs &relocAttrs = target->getRelocAttrs(r.type);
   bool valid = true;
   auto message = [&](const Twine &diagnostic) {
     valid = false;
     return (isec->getLocation(r.offset) + ": " + relocAttrs.name +
             " relocation " + diagnostic)
         .str();
   };
for (OutputSegment *seg : outputSegments) {
     assert(isecIdx > 0);
     ConcatInputSection *isec = osec->inputs[isecIdx - 1];
     *off -= isec->outSecOff;
     return isec;
   }
   return nullptr;
 }
 
-void macho::reportRangeError(void *loc, const Reloc &r, const Twine &v,
+void macho::reportRangeError(void *loc, const macho::Reloc &r, const Twine &v,
                              uint8_t bits, int64_t min, uint64_t max) {
   std::string hint;
   uint64_t off = reinterpret_cast<const uint8_t *>(loc) - in.bufferStart;
   const InputSection *isec = offsetToInputSection(&off);
   std::string locStr = isec ? isec->getLocation(off) : "(invalid location)";
   if (auto *sym = r.referent.dyn_cast<Symbol *>())
     hint = "; references " + toString(*sym);
   error(locStr + ": relocation " + target->getRelocAttrs(r.type).name +

lld/MachO/UnwindInfoSection.cpp

assert(!isec->shouldOmitFromOutput() &&
          "__compact_unwind section should not be omitted");
 
   // FIXME: Make this skip relocations for CompactUnwindEntries that
   // point to dead-stripped functions. That might save some amount of
   // work. But since there are usually just few personality functions
   // that are referenced from many places, at least some of them likely
   // live, it wouldn't reduce number of got entries.
   for (size_t i = 0; i < isec->relocs.size(); ++i) {
-    Reloc &r = isec->relocs[i];
+    macho::Reloc &r = isec->relocs[i];
     assert(target->hasAttr(r.type, RelocAttrBits::UNSIGNED));
     // Since compact unwind sections aren't part of the inputSections vector,
     // they don't get canonicalized by scanRelocations(), so we have to do the
     // canonicalization here.
     if (auto *referentIsec = r.referent.dyn_cast<InputSection *>())
       r.referent = referentIsec->canonical();
 
     // Functions and LSDA entries always reside in the same object file as the
parallelFor(0, symbolsVec.size(), [&](size_t i) {
 
     assert(d->unwindEntry->getName() == section_names::compactUnwind);
 
     auto buf = reinterpret_cast<const uint8_t *>(d->unwindEntry->data.data()) -
                target->wordSize;
     cu.functionLength =
         support::endian::read32le(buf + cuOffsets.functionLength);
     cu.encoding = support::endian::read32le(buf + cuOffsets.encoding);
-    for (const Reloc &r : d->unwindEntry->relocs) {
+    for (const macho::Reloc &r : d->unwindEntry->relocs) {
       if (r.offset == cuOffsets.personality) {
         cu.personality = r.referent.get<Symbol *>();
       } else if (r.offset == cuOffsets.lsda) {
         if (auto *referentSym = r.referent.dyn_cast<Symbol *>())
           cu.lsda = cast<Defined>(referentSym)->isec;
         else
           cu.lsda = r.referent.get<InputSection *>();
       }