[lld-macho] Refactor Defined to take an InputSection/OutputSection union.

[oontvoo]

Summary

• pre-work for D97007
• I also made a few public field const when possible.

[int3]

Oof, I didn't realize that using SectionPointerUnion for Defineds would result in so many isInput checks...

Hmm let me see if I can simplify __dso_handle with a different approach

[int3]

I think fake InputSections are the way to go: D98545

[oontvoo]

Cool. Thanks!

lld/MachO/InputSection.h

return sectionType(flags) == llvm::MachO::S_THREAD_LOCAL_REGULAR ||
          sectionType(flags) == llvm::MachO::S_THREAD_LOCAL_ZEROFILL;
 }
 
 inline bool isDebugSection(uint32_t flags) {
   return (flags & llvm::MachO::SECTION_ATTRIBUTES_USR) ==
          llvm::MachO::S_ATTR_DEBUG;
 }
 
-bool isCodeSection(InputSection *);
+bool isCodeSection(const InputSection *);
 
 extern std::vector<InputSection *> inputSections;
 
 } // namespace macho
 
 std::string toString(const macho::InputSection *);
 
 } // namespace lld
 
 #endif

lld/MachO/InputSection.cpp

if (target->hasAttr(r.type, RelocAttrBits::SUBTRAHEND)) {
       }
     } else if (auto *referentIsec = r.referent.dyn_cast<InputSection *>()) {
       referentVA = referentIsec->getVA();
     }
     target->relocateOne(loc, r, referentVA, getVA() + r.offset);
   }
 }
 
-bool macho::isCodeSection(InputSection *isec) {
+bool macho::isCodeSection(const InputSection *isec) {
   uint32_t type = isec->flags & SECTION_TYPE;
   if (type != S_REGULAR && type != S_COALESCED)
     return false;
 
   uint32_t attr = isec->flags & SECTION_ATTRIBUTES_USR;
   if (attr == S_ATTR_PURE_INSTRUCTIONS)
     return true;
 

lld/MachO/Symbols.h

 //===- Symbols.h ------------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_MACHO_SYMBOLS_H
 #define LLD_MACHO_SYMBOLS_H
 
 #include "InputFiles.h"
 #include "InputSection.h"
+#include "OutputSection.h"
 #include "Target.h"
+
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Strings.h"
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/PointerUnion.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Support/MathExtras.h"
 
 namespace lld {
 namespace macho {
 
-class InputSection;
 class MachHeaderSection;
 
+using SectionPointerUnion =
+    llvm::PointerUnion<const InputSection *, const OutputSection *>;
+
 struct StringRefZ {
   StringRefZ(const char *s) : data(s), size(-1) {}
   StringRefZ(StringRef s) : data(s.data()), size(s.size()) {}
 
   const char *data;
   const uint32_t size;
 };
 
protected:
   Kind symbolKind;
   const char *nameData;
   mutable uint32_t nameSize;
   InputFile *file;
 };
 
 class Defined : public Symbol {
 public:
-  Defined(StringRefZ name, InputFile *file, InputSection *isec, uint32_t value,
-          bool isWeakDef, bool isExternal, bool isPrivateExtern)
-      : Symbol(DefinedKind, name, file), isec(isec), value(value),
+  Defined(StringRefZ name, InputFile *file, SectionPointerUnion section,
+          uint32_t value, bool isWeakDef, bool isExternal, bool isPrivateExtern)
+      : Symbol(DefinedKind, name, file), section(section), value(value),
+        overridesWeakDef(false), privateExtern(isPrivateExtern),
+        isInput(section.is<const InputSection *>()), weakDef(isWeakDef),
+        external(isExternal) {}
+
+  Defined(StringRefZ name, InputFile *file, SectionPointerUnion section,
+          uint32_t value, bool isWeakDef, bool isExternal, bool isPrivateExtern,
+          uint64_t va, uint64_t fileOff)
+      : Symbol(DefinedKind, name, file), section(section), value(value),
         overridesWeakDef(false), privateExtern(isPrivateExtern),
-        weakDef(isWeakDef), external(isExternal) {}
+        isInput(section.is<const InputSection *>()), weakDef(isWeakDef),
+        external(isExternal), va(va), fileOffset(fileOff) {}
 
   bool isWeakDef() const override { return weakDef; }
   bool isExternalWeakDef() const {
     return isWeakDef() && isExternal() && !privateExtern;
   }
+
   bool isTlv() const override {
-    return !isAbsolute() && isThreadLocalVariables(isec->flags);
+    return !isAbsolute() && isInput &&
+           isThreadLocalVariables(getInputSection()->flags);
   }
 
   bool isExternal() const { return external; }
-  bool isAbsolute() const { return isec == nullptr; }
+  bool isAbsolute() const { return isInput && section.isNull(); }
 
   uint64_t getVA() const override;
   uint64_t getFileOffset() const override;
 
+  const InputSection *getInputSection() const {
+    if (!isInput)
+      return nullptr;
+    return section.dyn_cast<const InputSection *>();
+  }
+
+  const OutputSection *getOutputSection() const {
+    if (isInput)
+      return nullptr;
+    return section.dyn_cast<const OutputSection *>();
+  }
+
+  uint64_t getInputOrOutputSize() const {
+    if (const InputSection *in = getInputSection())
+      return in->getSize();
+    if (const OutputSection *out = getOutputSection())
+      return out->getSize();
+    return 0;
+  }
+
   static bool classof(const Symbol *s) { return s->kind() == DefinedKind; }
 
-  InputFile *file;
-  InputSection *isec;
-  uint32_t value;
+  const SectionPointerUnion section;
+  const uint32_t value;
 
   bool overridesWeakDef : 1;
   bool privateExtern : 1;
+  const bool isInput : 1;
 
 private:
   const bool weakDef : 1;
   const bool external : 1;
+
+  llvm::Optional<uint64_t> va;
+  llvm::Optional<uint64_t> fileOffset;
 };
 
 // This enum does double-duty: as a symbol property, it indicates whether & how
 // a dylib symbol is referenced. As a DylibFile property, it indicates the kind
 // of referenced symbols contained within the file. If there are both weak
 // and strong references to the same file, we will count the file as
 // strongly-referenced.
 enum class RefState : uint8_t { Unreferenced = 0, Weak = 1, Strong = 2 };

lld/MachO/Symbols.cpp

std::string lld::toString(const Symbol &sym) {
   return demangle(sym.getName());
 }
 
 std::string lld::toMachOString(const object::Archive::Symbol &b) {
   return demangle(b.getName());
 }
 
 uint64_t Defined::getVA() const {
+  if (va.hasValue())
+    return *va;
   if (isAbsolute())
     return value;
-  return isec->getVA() + value;
+  if (isInput && !section.isNull())
+    return section.dyn_cast<const InputSection *>()->getVA() + value;
+
+  return 0;
 }
 
 uint64_t Defined::getFileOffset() const {
+  if (fileOffset.hasValue())
+    return *fileOffset;
   if (isAbsolute()) {
     error("absolute symbol " + toString(*this) +
           " does not have a file offset");
     return 0;
   }
-  return isec->getFileOffset() + value;
+  if (isInput && !section.isNull())
+    return section.dyn_cast<const InputSection *>()->getFileOffset() + value;
+  return 0;
 }
 
 void LazySymbol::fetchArchiveMember() { getFile()->fetch(sym); }
 
 uint64_t DSOHandle::getVA() const { return header->addr; }
 
 uint64_t DSOHandle::getFileOffset() const { return header->fileOff; }
 
 constexpr StringRef DSOHandle::name;

lld/MachO/SyntheticSections.h

 //===- SyntheticSections.h -------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_MACHO_SYNTHETIC_SECTIONS_H
 #define LLD_MACHO_SYNTHETIC_SECTIONS_H
 
 #include "Config.h"
 #include "ExportTrie.h"
 #include "InputSection.h"
 #include "OutputSection.h"
 #include "OutputSegment.h"
+#include "Symbols.h"
 #include "Target.h"
 
 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace llvm {

 
 class TlvPointerSection : public NonLazyPointerSectionBase {
 public:
   TlvPointerSection()
       : NonLazyPointerSectionBase(segment_names::data,
                                   section_names::threadPtrs) {}
 };
 
-using SectionPointerUnion =
-    llvm::PointerUnion<const InputSection *, const OutputSection *>;
-
 struct Location {
   SectionPointerUnion section = nullptr;
   uint64_t offset = 0;
 
   Location(SectionPointerUnion section, uint64_t offset)
       : section(section), offset(offset) {}
   uint64_t getVA() const;
 };

lld/MachO/SyntheticSections.cpp

FunctionStartsSection::FunctionStartsSection()
     : LinkEditSection(segment_names::linkEdit, section_names::functionStarts_) {
 }
 
 void FunctionStartsSection::finalizeContents() {
   raw_svector_ostream os{contents};
   uint64_t addr = in.header->addr;
   for (const Symbol *sym : symtab->getSymbols()) {
     if (const auto *defined = dyn_cast<Defined>(sym)) {
-      if (!defined->isec || !isCodeSection(defined->isec))
+      const InputSection *isec = defined->getInputSection();
+      if (!isec || !isCodeSection(isec))
         continue;
       // TODO: Add support for thumbs, in that case
       // the lowest bit of nextAddr needs to be set to 1.
       uint64_t nextAddr = defined->getVA();
       uint64_t delta = nextAddr - addr;
       if (delta == 0)
         continue;
       encodeULEB128(delta, os);
void SymtabSection::emitObjectFileStab(ObjFile *file) {
 
   stab.strx = stringTableSection.addString(saver.save(path.str()));
   stab.desc = 1;
   stab.value = file->modTime;
   stabs.emplace_back(std::move(stab));
 }
 
 void SymtabSection::emitEndFunStab(Defined *defined) {
+
   StabsEntry stab(N_FUN);
   // FIXME this should be the size of the symbol. Using the section size in
   // lieu is only correct if .subsections_via_symbols is set.
-  stab.value = defined->isec->getSize();
+  stab.value = defined->getInputOrOutputSize();
   stabs.emplace_back(std::move(stab));
 }
 
 void SymtabSection::emitStabs() {
   std::vector<Defined *> symbolsNeedingStabs;
   for (const SymtabEntry &entry :
        concat<SymtabEntry>(localSymbols, externalSymbols)) {
     Symbol *sym = entry.sym;
     if (auto *defined = dyn_cast<Defined>(sym)) {
-      if (defined->isAbsolute())
+      if (!defined->isInput || defined->isAbsolute())
         continue;
-      InputSection *isec = defined->isec;
+      const InputSection *isec = defined->getInputSection();
       ObjFile *file = dyn_cast_or_null<ObjFile>(isec->file);
       if (!file || !file->compileUnit)
         continue;
       symbolsNeedingStabs.push_back(defined);
     }
   }
 
   llvm::stable_sort(symbolsNeedingStabs, [&](Defined *a, Defined *b) {
-    return a->isec->file->id < b->isec->file->id;
+    assert(a->isInput && b->isInput);
+    return a->getInputSection()->file->id < b->getInputSection()->file->id;
   });
 
   // Emit STABS symbols so that dsymutil and/or the debugger can map address
   // regions in the final binary to the source and object files from which they
   // originated.
   InputFile *lastFile = nullptr;
   for (Defined *defined : symbolsNeedingStabs) {
-    InputSection *isec = defined->isec;
+    assert(defined->isInput);
+    const InputSection *isec = defined->getInputSection();
+    ;
     ObjFile *file = dyn_cast<ObjFile>(isec->file);
     assert(file);
 
     if (lastFile == nullptr || lastFile != file) {
       if (lastFile != nullptr)
         emitEndSourceStab();
       lastFile = file;
 
       emitBeginSourceStab(file->compileUnit);
       emitObjectFileStab(file);
     }
 
     StabsEntry symStab;
-    symStab.sect = defined->isec->parent->index;
+    symStab.sect = isec->parent->index;
     symStab.strx = stringTableSection.addString(defined->getName());
     symStab.value = defined->getVA();
 
     if (isCodeSection(isec)) {
       symStab.type = N_FUN;
       stabs.emplace_back(std::move(symStab));
       emitEndFunStab(defined);
     } else {
if (auto *defined = dyn_cast<Defined>(entry.sym)) {
       }
 
       if (defined->isAbsolute()) {
         nList->n_type = scope | N_ABS;
         nList->n_sect = NO_SECT;
         nList->n_value = defined->value;
       } else {
         nList->n_type = scope | N_SECT;
-        nList->n_sect = defined->isec->parent->index;
+        if (const InputSection *isec = defined->getInputSection())
+          nList->n_sect = isec->parent->index;
+        else if (const OutputSection *out = defined->getOutputSection())
+          nList->n_sect = out->index;
+
         // For the N_SECT symbol type, n_value is the address of the symbol
         nList->n_value = defined->getVA();
       }
       nList->n_desc |= defined->isExternalWeakDef() ? N_WEAK_DEF : 0;
     } else if (auto *dysym = dyn_cast<DylibSymbol>(entry.sym)) {
       uint16_t n_desc = nList->n_desc;
       int16_t ordinal = ordinalForDylibSymbol(*dysym);
       if (ordinal == BIND_SPECIAL_DYLIB_FLAT_LOOKUP)

lld/MachO/UnwindInfoSection.cpp

for (Reloc &r : isec->relocs) {
     if (auto *s = r.referent.dyn_cast<lld::macho::Symbol *>()) {
       if (auto *undefined = dyn_cast<Undefined>(s)) {
         treatUndefinedSymbol(*undefined);
         // treatUndefinedSymbol() can replace s with a DylibSymbol; re-check.
         if (isa<Undefined>(s))
           continue;
       }
       if (auto *defined = dyn_cast<Defined>(s)) {
+        // FIXME: some synthetic symbol could be output?
+        if (!defined->isInput)
+          continue;
         // Check if we have created a synthetic symbol at the same address.
-        macho::Symbol *&personality =
-            personalityTable[{defined->isec, defined->value}];
+        macho::Symbol *&personality = personalityTable[{
+            const_cast<InputSection *>(defined->getInputSection()),
+            defined->value}];
         if (personality == nullptr) {
           personality = defined;
           in.got->addEntry(defined);
         } else if (personality != defined) {
           r.referent = personality;
         }
         continue;
       }
for (Reloc &r : isec->relocs) {
     }
   }
 }
 
 // Unwind info lives in __DATA, and finalization of __TEXT will occur before
 // finalization of __DATA. Moreover, the finalization of unwind info depends on
 // the exact addresses that it references. So it is safe for compact unwind to
 // reference addresses in __TEXT, but not addresses in any other segment.
-static void checkTextSegment(InputSection *isec) {
+static void checkTextSegment(const InputSection *isec) {
   if (isec->segname != segment_names::text)
     error("compact unwind references address in " + toString(isec) +
           " which is not in segment __TEXT");
 }
 
 // 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 (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 (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);
+            if (defined->isInput)
+              checkTextSegment(defined->getInputSection());
           // 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
           // that we can distinguish the null pointer case.
           referentVA = referentSym->gotIndex + 1;
         }
       } else if (auto *referentIsec = r.referent.dyn_cast<InputSection *>()) {
         checkTextSegment(referentIsec);
         referentVA = referentIsec->getVA() + r.addend;

lld/MachO/Writer.cpp

static DenseMap<const InputSection *, size_t> buildInputSectionPriorities() {
   if (config->priorities.empty())
     return sectionPriorities;
 
   auto addSym = [&](Defined &sym) {
     auto it = config->priorities.find(sym.getName());
     if (it == config->priorities.end())
       return;
 
+    if (!sym.isInput)
+      return;
     SymbolPriorityEntry &entry = it->second;
-    size_t &priority = sectionPriorities[sym.isec];
-    priority = std::max(priority, getSymbolPriority(entry, sym.isec->file));
+    const InputSection *isec = sym.getInputSection();
+    size_t &priority = sectionPriorities[isec];
+    priority = std::max(priority, getSymbolPriority(entry, isec->file));
   };
 
   // TODO: Make sure this handles weak symbols correctly.
   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);