[lld-macho] Factor out common InputSection members

[int3]

Summary

We have been creating many ConcatInputSections with identical values due
to .subsections_via_symbols. This diff factors out the identical values
into a Shared struct, to reduce memory consumption and make copying
cheaper.

I also changed callSiteCount from a uint32_t to a 31-bit field to save an
extra word.

All in all, this takes InputSection from 120 to 72 bytes (and
ConcatInputSection from 160 to 112 bytes), i.e. 30% size reduction in
ConcatInputSection.

Numbers for linking chromium_framework on my 3.2 GHz 16-Core Intel Xeon W:

    N           Min           Max        Median           Avg        Stddev
x  20          4.14          4.24          4.18         4.183   0.027548999
+  20          4.04          4.11         4.075        4.0775   0.018027756
Difference at 95.0% confidence
        -0.1055 +/- 0.0149005
        -2.52211% +/- 0.356215%
        (Student's t, pooled s = 0.0232803)

[thakis]

Nice!

lld/MachO/InputSection.h

147

This might fail in 32-bit builds -- probably want to do <= for that.

[int3]

address comment

lld/MachO/ConcatOutputSection.cpp

 using namespace llvm;
 using namespace llvm::MachO;
 using namespace lld;
 using namespace lld::macho;
 
 void ConcatOutputSection::addInput(ConcatInputSection *input) {
   if (inputs.empty()) {
     align = input->align;
-    flags = input->flags;
+    flags = input->getFlags();
   } else {
     align = std::max(align, input->align);
     finalizeFlags(input);
   }
   inputs.push_back(input);
   input->parent = this;
 }
 
for (Reloc &r : reverse(relocs)) {
         // isecAddr and the distance between subsequent call sites is
         // smaller than thunkSize, then a new thunk can go out of
         // range.  Fix by unfinalizing inputs[finalIdx] to reduce the
         // distance between callVA and highVA, then shift some thunks
         // to occupy address-space formerly occupied by the
         // unfinalized inputs[finalIdx].
         fatal(Twine(__FUNCTION__) + ": FIXME: thunk range overrun");
       }
-      thunkInfo.isec = make<ConcatInputSection>(isec->segname, isec->name);
+      thunkInfo.isec =
+          make<ConcatInputSection>(isec->getSegName(), isec->getName());
       thunkInfo.isec->parent = this;
       StringRef thunkName = saver.save(funcSym->getName() + ".thunk." +
                                        std::to_string(thunkInfo.sequence++));
       r.referent = thunkInfo.sym = symtab->addDefined(
           thunkName, /*file=*/nullptr, thunkInfo.isec, /*value=*/0,
           /*size=*/thunkSize, /*isWeakDef=*/false, /*isPrivateExtern=*/true,
           /*isThumb=*/false, /*isReferencedDynamically=*/false,
           /*noDeadStrip=*/false);
while (i < ie || t < te) {
     while (t < te && (i == ie || thunks[t]->outSecOff < inputs[i]->outSecOff)) {
       thunks[t]->writeTo(buf + thunks[t]->outSecOff);
       ++t;
     }
   }
 }
 
 void ConcatOutputSection::finalizeFlags(InputSection *input) {
-  uint8_t inputType = input->flags & SECTION_TYPE;
-  switch (inputType) {
+  switch (sectionType(input->getFlags())) {
   default /*type-unspec'ed*/:
     // FIXME: Add additional logics here when supporting emitting obj files.
     break;
   case S_4BYTE_LITERALS:
   case S_8BYTE_LITERALS:
   case S_16BYTE_LITERALS:
   case S_CSTRING_LITERALS:
   case S_ZEROFILL:
   case S_LAZY_SYMBOL_POINTERS:
   case S_MOD_TERM_FUNC_POINTERS:
   case S_THREAD_LOCAL_REGULAR:
   case S_THREAD_LOCAL_ZEROFILL:
   case S_THREAD_LOCAL_VARIABLES:
   case S_THREAD_LOCAL_INIT_FUNCTION_POINTERS:
   case S_THREAD_LOCAL_VARIABLE_POINTERS:
   case S_NON_LAZY_SYMBOL_POINTERS:
   case S_SYMBOL_STUBS:
-    flags |= input->flags;
+    flags |= input->getFlags();
     break;
   }
 }

lld/MachO/Driver.cpp

 // any CommonSymbols.
 static void replaceCommonSymbols() {
   TimeTraceScope timeScope("Replace common symbols");
   for (Symbol *sym : symtab->getSymbols()) {
     auto *common = dyn_cast<CommonSymbol>(sym);
     if (common == nullptr)
       continue;
 
-    auto *isec =
-        make<ConcatInputSection>(segment_names::data, section_names::common);
-    isec->file = common->getFile();
-    isec->align = common->align;
     // Casting to size_t will truncate large values on 32-bit architectures,
     // but it's not really worth supporting the linking of 64-bit programs on
     // 32-bit archs.
-    isec->data = {nullptr, static_cast<size_t>(common->size)};
-    isec->flags = S_ZEROFILL;
+    ArrayRef<uint8_t> data = {nullptr, static_cast<size_t>(common->size)};
+    auto *isec = make<ConcatInputSection>(
+        segment_names::data, section_names::common, common->getFile(), data,
+        common->align, S_ZEROFILL);
     inputSections.push_back(isec);
 
     // FIXME: CommonSymbol should store isReferencedDynamically, noDeadStrip
     // and pass them on here.
-    replaceSymbol<Defined>(sym, sym->getName(), isec->file, isec, /*value=*/0,
+    replaceSymbol<Defined>(sym, sym->getName(), isec->getFile(), isec,
+                           /*value=*/0,
                            /*size=*/0,
                            /*isWeakDef=*/false,
                            /*isExternal=*/true, common->privateExtern,
                            /*isThumb=*/false,
                            /*isReferencedDynamically=*/false,
                            /*noDeadStrip=*/false);
   }
 }
static void gatherInputSections() {
   TimeTraceScope timeScope("Gathering input sections");
   int inputOrder = 0;
   for (const InputFile *file : inputFiles) {
     for (const SubsectionMap &map : file->subsections) {
       for (const SubsectionEntry &entry : map) {
         if (auto *isec = dyn_cast<ConcatInputSection>(entry.isec)) {
           if (isec->isCoalescedWeak())
             continue;
-          if (isec->segname == segment_names::ld) {
-            assert(isec->name == section_names::compactUnwind);
+          if (isec->getSegName() == segment_names::ld) {
+            assert(isec->getName() == section_names::compactUnwind);
             in.unwindInfo->addInput(isec);
             continue;
           }
           isec->outSecOff = inputOrder++;
           inputSections.push_back(isec);
         } else if (auto *isec = dyn_cast<CStringInputSection>(entry.isec)) {
           if (in.cStringSection->inputOrder == UnspecifiedInputOrder)
             in.cStringSection->inputOrder = inputOrder++;

lld/MachO/Dwarf.cpp

std::unique_ptr<DwarfObject> DwarfObject::create(ObjFile *obj) {
   bool hasDwarfInfo = false;
   // LLD only needs to extract the source file path from the debug info, so we
   // initialize DwarfObject with just the sections necessary to get that path.
   // The debugger will locate the debug info via the object file paths that we
   // emit in our STABS symbols, so we don't need to process & emit them
   // ourselves.
   for (const InputSection *isec : obj->debugSections) {
     if (StringRef *s =
-            StringSwitch<StringRef *>(isec->name)
+            StringSwitch<StringRef *>(isec->getName())
                 .Case(section_names::debugInfo, &dObj->infoSection.Data)
                 .Case(section_names::debugAbbrev, &dObj->abbrevSection)
                 .Case(section_names::debugStr, &dObj->strSection)
                 .Default(nullptr)) {
       *s = toStringRef(isec->data);
       hasDwarfInfo = true;
     }
   }
 
   if (hasDwarfInfo)
     return dObj;
   return nullptr;
 }

lld/MachO/ICF.cpp

 
 // Compare everything except the relocation referents
 static bool equalsConstant(const ConcatInputSection *ia,
                            const ConcatInputSection *ib) {
   if (ia->data.size() != ib->data.size())
     return false;
   if (ia->data != ib->data)
     return false;
-  if (ia->flags != ib->flags)
+  if (ia->getFlags() != ib->getFlags())
     return false;
   if (ia->relocs.size() != ib->relocs.size())
     return false;
   auto f = [&](const Reloc &ra, const Reloc &rb) {
     if (ra.type != rb.type)
       return false;
     if (ra.pcrel != rb.pcrel)
       return false;

lld/MachO/InputFiles.cpp

if (sectionType(sec.flags) == S_CSTRING_LITERALS ||
       for (uint64_t off = 0; off < data.size(); off += literalSize)
         subsecMap.push_back(
             {off, make<ConcatInputSection>(segname, name, this,
                                            data.slice(off, literalSize), align,
                                            flags)});
     } else {
       auto *isec =
           make<ConcatInputSection>(segname, name, this, data, align, flags);
-      if (!(isDebugSection(isec->flags) &&
-            isec->segname == segment_names::dwarf)) {
+      if (!(isDebugSection(isec->getFlags()) &&
+            isec->getSegName() == segment_names::dwarf)) {
         subsections.push_back({{0, isec}});
       } else {
         // Instead of emitting DWARF sections, we emit STABS symbols to the
         // object files that contain them. We filter them out early to avoid
         // parsing their relocations unnecessarily. But we must still push an
         // empty map to ensure the indices line up for the remaining sections.
         subsections.push_back({});
         debugSections.push_back(isec);
if (sym.n_type & N_EXT) {
     // definitions are encountered. With lld's semantics there's no observable
     // difference between a symbol that's isWeakDefCanBeHidden or one that's
     // privateExtern -- neither makes it into the dynamic symbol table. So just
     // promote isWeakDefCanBeHidden to isPrivateExtern here.
     if (isWeakDefCanBeHidden)
       isPrivateExtern = true;
 
     return symtab->addDefined(
-        name, isec->file, isec, value, size, sym.n_desc & N_WEAK_DEF,
+        name, isec->getFile(), isec, value, size, sym.n_desc & N_WEAK_DEF,
         isPrivateExtern, sym.n_desc & N_ARM_THUMB_DEF,
         sym.n_desc & REFERENCED_DYNAMICALLY, sym.n_desc & N_NO_DEAD_STRIP);
   }
 
   assert(!isWeakDefCanBeHidden &&
          "weak_def_can_be_hidden on already-hidden symbol?");
   return make<Defined>(
-      name, isec->file, isec, value, size, sym.n_desc & N_WEAK_DEF,
+      name, isec->getFile(), isec, value, size, sym.n_desc & N_WEAK_DEF,
       /*isExternal=*/false, /*isPrivateExtern=*/false,
       sym.n_desc & N_ARM_THUMB_DEF, sym.n_desc & REFERENCED_DYNAMICALLY,
       sym.n_desc & N_NO_DEAD_STRIP);
 }
 
 // Absolute symbols are defined symbols that do not have an associated
 // InputSection. They cannot be weak.
 template <class NList>
for (size_t j = 0; j < symbolIndices.size(); ++j) {
             createDefined(sym, name, isec, symbolOffset, symbolSize);
         continue;
       }
       auto *concatIsec = cast<ConcatInputSection>(isec);
 
       auto *nextIsec = make<ConcatInputSection>(*concatIsec);
       nextIsec->numRefs = 0;
       nextIsec->wasCoalesced = false;
-      if (isZeroFill(isec->flags)) {
+      if (isZeroFill(isec->getFlags())) {
         // Zero-fill sections have NULL data.data() non-zero data.size()
         nextIsec->data = {nullptr, isec->data.size() - symbolOffset};
         isec->data = {nullptr, symbolOffset};
       } else {
         nextIsec->data = isec->data.slice(symbolOffset);
         isec->data = isec->data.slice(0, symbolOffset);
       }
 
for (size_t j = 0; j < symbolIndices.size(); ++j) {
       subsecEntry = subsecMap.back();
     }
   }
 }
 
 OpaqueFile::OpaqueFile(MemoryBufferRef mb, StringRef segName,
                        StringRef sectName)
     : InputFile(OpaqueKind, mb) {
-  ConcatInputSection *isec =
-      make<ConcatInputSection>(segName.take_front(16), sectName.take_front(16));
-  isec->file = this;
   const auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
-  isec->data = {buf, mb.getBufferSize()};
+  ArrayRef<uint8_t> data = {buf, mb.getBufferSize()};
+  ConcatInputSection *isec =
+      make<ConcatInputSection>(segName.take_front(16), sectName.take_front(16),
+                               /*file=*/this, data);
   isec->live = true;
   subsections.push_back({{0, isec}});
 }
 
 ObjFile::ObjFile(MemoryBufferRef mb, uint32_t modTime, StringRef archiveName)
     : InputFile(ObjKind, mb), modTime(modTime) {
   this->archiveName = std::string(archiveName);
   if (target->wordSize == 8)

lld/MachO/InputSection.h

 //===- InputSection.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_INPUT_SECTION_H
 #define LLD_MACHO_INPUT_SECTION_H
 
 #include "Config.h"
 #include "Relocations.h"
 
 #include "lld/Common/LLVM.h"
+#include "lld/Common/Memory.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/BitVector.h"
 #include "llvm/ADT/CachedHashString.h"
 #include "llvm/BinaryFormat/MachO.h"
 
 namespace lld {
 namespace macho {
 
 class InputFile;
 class OutputSection;
 class Defined;
 
 class InputSection {
 public:
   enum Kind {
     ConcatKind,
     CStringLiteralKind,
     WordLiteralKind,
   };
 
-  Kind kind() const { return sectionKind; }
+  Kind kind() const { return shared->sectionKind; }
   virtual ~InputSection() = default;
   virtual uint64_t getSize() const { return data.size(); }
+  InputFile *getFile() const { return shared->file; }
+  StringRef getName() const { return shared->name; }
+  StringRef getSegName() const { return shared->segname; }
+  uint32_t getFlags() const { return shared->flags; }
   uint64_t getFileSize() const;
   // Translates \p off -- an offset relative to this InputSection -- into an
   // offset from the beginning of its parent OutputSection.
   virtual uint64_t getOffset(uint64_t off) const = 0;
   // The offset from the beginning of the file.
   uint64_t getVA(uint64_t off) const;
   // Whether the data at \p off in this InputSection is live.
   virtual bool isLive(uint64_t off) const = 0;
   virtual void markLive(uint64_t off) = 0;
   virtual InputSection *canonical() { return this; }
 
-  InputFile *file = nullptr;
-  StringRef name;
-  StringRef segname;
-
   OutputSection *parent = nullptr;
 
   uint32_t align = 1;
-  uint32_t flags = 0;
-  uint32_t callSiteCount = 0;
-
+  uint32_t callSiteCount : 31;
   // is address assigned?
-  bool isFinal = false;
+  uint32_t isFinal : 1;
 
   ArrayRef<uint8_t> data;
   std::vector<Reloc> relocs;
 
 protected:
+  // The fields in this struct are immutable. Since we create a lot of
+  // InputSections with identical values for them (due to
+  // .subsections_via_symbols), factoring them out into a shared struct reduces
+  // memory consumption and makes copying cheaper.
+  struct Shared {
+    InputFile *file;
+    StringRef name;
+    StringRef segname;
+    uint32_t flags;
+    Kind sectionKind;
+    Shared(InputFile *file, StringRef name, StringRef segname, uint32_t flags,
+           Kind kind)
+        : file(file), name(name), segname(segname), flags(flags),
+          sectionKind(kind) {}
+  };
+
   InputSection(Kind kind, StringRef segname, StringRef name)
-      : name(name), segname(segname), sectionKind(kind) {}
+      : callSiteCount(0), isFinal(false),
+        shared(make<Shared>(nullptr, name, segname, 0, kind)) {}
 
   InputSection(Kind kind, StringRef segname, StringRef name, InputFile *file,
                ArrayRef<uint8_t> data, uint32_t align, uint32_t flags)
-      : file(file), name(name), segname(segname), align(align), flags(flags),
-        data(data), sectionKind(kind) {}
+      : align(align), callSiteCount(0), isFinal(false), data(data),
+        shared(make<Shared>(file, name, segname, flags, kind)) {}
 
-private:
-  Kind sectionKind;
+  const Shared *const shared;
 };
 
 // ConcatInputSections are combined into (Concat)OutputSections through simple
 // concatenation, in contrast with literal sections which may have their
 // contents merged before output.
 class ConcatInputSection final : public InputSection {
 public:
   ConcatInputSection(StringRef segname, StringRef name)
       : InputSection(ConcatKind, segname, name) {}
 
   ConcatInputSection(StringRef segname, StringRef name, InputFile *file,
-                     ArrayRef<uint8_t> data, uint32_t align, uint32_t flags)
+                     ArrayRef<uint8_t> data, uint32_t align = 1,
+                     uint32_t flags = 0)
       : InputSection(ConcatKind, segname, name, file, data, align, flags) {}
 
   uint64_t getOffset(uint64_t off) const override { return outSecOff + off; }
   uint64_t getVA() const { return InputSection::getVA(0); }
   // ConcatInputSections are entirely live or dead, so the offset is irrelevant.
   bool isLive(uint64_t off) const override { return live; }
   void markLive(uint64_t off) override { live = true; }
   bool isCoalescedWeak() const { return wasCoalesced && numRefs == 0; }
public:
   // How many symbols refer to this InputSection.
   uint32_t numRefs = 0;
   // This variable has two usages. Initially, it represents the input order.
   // After assignAddresses is called, it represents the offset from the
   // beginning of the output section this section was assigned to.
   uint64_t outSecOff = 0;
 };
 
+// Verify ConcatInputSection's size on 64-bit builds.
+static_assert(sizeof(int) != 8 || sizeof(ConcatInputSection) == 112,
+              "Try to minimize ConcatInputSection's size, we create many "
+              "instances of it");
+
 // Helper functions to make it easy to sprinkle asserts.
 
 inline bool shouldOmitFromOutput(InputSection *isec) {
   return isa<ConcatInputSection>(isec) &&
          cast<ConcatInputSection>(isec)->shouldOmitFromOutput();
 }
 
 inline bool isCoalescedWeak(InputSection *isec) {

lld/MachO/InputSection.cpp

 using namespace llvm::MachO;
 using namespace llvm::support;
 using namespace lld;
 using namespace lld::macho;
 
 std::vector<ConcatInputSection *> macho::inputSections;
 
 uint64_t InputSection::getFileSize() const {
-  return isZeroFill(flags) ? 0 : getSize();
+  return isZeroFill(getFlags()) ? 0 : getSize();
 }
 
 uint64_t InputSection::getVA(uint64_t off) const {
   return parent->addr + getOffset(off);
 }
 
 static uint64_t resolveSymbolVA(const Symbol *sym, uint8_t type) {
   const RelocAttrs &relocAttrs = target->getRelocAttrs(type);
   if (relocAttrs.hasAttr(RelocAttrBits::BRANCH))
     return sym->resolveBranchVA();
   else if (relocAttrs.hasAttr(RelocAttrBits::GOT))
     return sym->resolveGotVA();
   else if (relocAttrs.hasAttr(RelocAttrBits::TLV))
     return sym->resolveTlvVA();
   return sym->getVA();
 }
 
 // ICF needs to hash any section that might potentially be duplicated so
 // that it can match on content rather than identity.
 bool ConcatInputSection::isHashableForICF() const {
-  switch (sectionType(flags)) {
+  switch (sectionType(getFlags())) {
   case S_REGULAR:
     return true;
   case S_CSTRING_LITERALS:
   case S_4BYTE_LITERALS:
   case S_8BYTE_LITERALS:
   case S_16BYTE_LITERALS:
   case S_LITERAL_POINTERS:
     llvm_unreachable("found unexpected literal type in ConcatInputSection");
if (target->hasAttr(r.type, RelocAttrBits::SUBTRAHEND)) {
       }
       referentVA = minuendVA - fromSym->getVA();
     } else if (auto *referentSym = r.referent.dyn_cast<Symbol *>()) {
       if (target->hasAttr(r.type, RelocAttrBits::LOAD) &&
           !referentSym->isInGot())
         target->relaxGotLoad(loc, r.type);
       referentVA = resolveSymbolVA(referentSym, r.type) + r.addend;
 
-      if (isThreadLocalVariables(flags)) {
+      if (isThreadLocalVariables(getFlags())) {
         // References from thread-local variable sections are treated as offsets
         // relative to the start of the thread-local data memory area, which
         // is initialized via copying all the TLV data sections (which are all
         // contiguous).
         if (isa<Defined>(referentSym))
           referentVA -= firstTLVDataSection->addr;
       }
     } else if (auto *referentIsec = r.referent.dyn_cast<InputSection *>()) {
WordLiteralInputSection::WordLiteralInputSection(StringRef segname,
   }
 
   live.resize(data.size() >> power2LiteralSize, !config->deadStrip);
 }
 
 uint64_t WordLiteralInputSection::getOffset(uint64_t off) const {
   auto *osec = cast<WordLiteralSection>(parent);
   const uint8_t *buf = data.data();
-  switch (sectionType(flags)) {
+  switch (sectionType(getFlags())) {
   case S_4BYTE_LITERALS:
     return osec->getLiteral4Offset(buf + off);
   case S_8BYTE_LITERALS:
     return osec->getLiteral8Offset(buf + off);
   case S_16BYTE_LITERALS:
     return osec->getLiteral16Offset(buf + off);
   default:
     llvm_unreachable("invalid literal section type");
   }
 }
 
 bool macho::isCodeSection(const InputSection *isec) {
-  uint32_t type = sectionType(isec->flags);
+  uint32_t type = sectionType(isec->getFlags());
   if (type != S_REGULAR && type != S_COALESCED)
     return false;
 
-  uint32_t attr = isec->flags & SECTION_ATTRIBUTES_USR;
+  uint32_t attr = isec->getFlags() & SECTION_ATTRIBUTES_USR;
   if (attr == S_ATTR_PURE_INSTRUCTIONS)
     return true;
 
-  if (isec->segname == segment_names::text)
-    return StringSwitch<bool>(isec->name)
+  if (isec->getSegName() == segment_names::text)
+    return StringSwitch<bool>(isec->getName())
         .Cases(section_names::textCoalNt, section_names::staticInit, true)
         .Default(false);
 
   return false;
 }
 
 bool macho::isCfStringSection(const InputSection *isec) {
-  return isec->name == section_names::cfString &&
-         isec->segname == segment_names::data;
+  return isec->getName() == section_names::cfString &&
+         isec->getSegName() == segment_names::data;
 }
 
 std::string lld::toString(const InputSection *isec) {
-  return (toString(isec->file) + ":(" + isec->name + ")").str();
+  return (toString(isec->getFile()) + ":(" + isec->getName() + ")").str();
 }

lld/MachO/MarkLive.cpp

if (auto *objFile = dyn_cast<ObjFile>(file))
         if (auto *defined = dyn_cast_or_null<Defined>(sym))
           if (!defined->isExternal() && defined->noDeadStrip)
             addSym(defined);
   if (auto *stubBinder =
           dyn_cast_or_null<DylibSymbol>(symtab->find("dyld_stub_binder")))
     addSym(stubBinder);
   for (ConcatInputSection *isec : inputSections) {
     // Sections marked no_dead_strip
-    if (isec->flags & S_ATTR_NO_DEAD_STRIP) {
+    if (isec->getFlags() & S_ATTR_NO_DEAD_STRIP) {
       enqueue(isec, 0);
       continue;
     }
 
     // mod_init_funcs, mod_term_funcs sections
-    if (sectionType(isec->flags) == S_MOD_INIT_FUNC_POINTERS ||
-        sectionType(isec->flags) == S_MOD_TERM_FUNC_POINTERS) {
+    if (sectionType(isec->getFlags()) == S_MOD_INIT_FUNC_POINTERS ||
+        sectionType(isec->getFlags()) == S_MOD_TERM_FUNC_POINTERS) {
       enqueue(isec, 0);
       continue;
     }
   }
 
   // Dead strip runs before UnwindInfoSection handling so we need to keep
   // __LD,__compact_unwind alive here.
   // But that section contains absolute references to __TEXT,__text and
while (!worklist.empty()) {
       }
     }
 
     // S_ATTR_LIVE_SUPPORT sections are live if they point _to_ a live section.
     // Process them in a second pass.
     for (ConcatInputSection *isec : inputSections) {
       // FIXME: Check if copying all S_ATTR_LIVE_SUPPORT sections into a
       // separate vector and only walking that here is faster.
-      if (!(isec->flags & S_ATTR_LIVE_SUPPORT) || isec->live)
+      if (!(isec->getFlags() & S_ATTR_LIVE_SUPPORT) || isec->live)
         continue;
 
       for (const Reloc &r : isec->relocs) {
         bool referentLive;
         if (auto *s = r.referent.dyn_cast<Symbol *>())
           referentLive = s->isLive();
         else
           referentLive = r.referent.get<InputSection *>()->isLive(r.addend);

lld/MachO/Symbols.h

if (auto concatIsec = dyn_cast_or_null<ConcatInputSection>(isec))
       concatIsec->numRefs++;
   }
 
   bool isWeakDef() const override { return weakDef; }
   bool isExternalWeakDef() const {
     return isWeakDef() && isExternal() && !privateExtern;
   }
   bool isTlv() const override {
-    return !isAbsolute() && isThreadLocalVariables(isec->flags);
+    return !isAbsolute() && isThreadLocalVariables(isec->getFlags());
   }
 
   bool isExternal() const { return external; }
   bool isAbsolute() const { return isec == nullptr; }
 
   uint64_t getVA() const override;
 
   static bool classof(const Symbol *s) { return s->kind() == DefinedKind; }

lld/MachO/SyntheticSections.cpp

for (const SymtabEntry &entry :
        concat<SymtabEntry>(localSymbols, externalSymbols)) {
     Symbol *sym = entry.sym;
     assert(sym->isLive() &&
            "dead symbols should not be in localSymbols, externalSymbols");
     if (auto *defined = dyn_cast<Defined>(sym)) {
       if (defined->isAbsolute())
         continue;
       InputSection *isec = defined->isec;
-      ObjFile *file = dyn_cast_or_null<ObjFile>(isec->file);
+      ObjFile *file = dyn_cast_or_null<ObjFile>(isec->getFile());
       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;
+    return a->isec->getFile()->id < b->isec->getFile()->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;
-    ObjFile *file = cast<ObjFile>(isec->file);
+    ObjFile *file = cast<ObjFile>(isec->getFile());
 
     if (lastFile == nullptr || lastFile != file) {
       if (lastFile != nullptr)
         emitEndSourceStab();
       lastFile = file;
 
       emitBeginSourceStab(file->compileUnit);
       emitObjectFileStab(file);

 }
 
 void WordLiteralSection::finalizeContents() {
   for (WordLiteralInputSection *isec : inputs) {
     // We do all processing of the InputSection here, so it will be effectively
     // finalized.
     isec->isFinal = true;
     const uint8_t *buf = isec->data.data();
-    switch (sectionType(isec->flags)) {
+    switch (sectionType(isec->getFlags())) {
     case S_4BYTE_LITERALS: {
       for (size_t off = 0, e = isec->data.size(); off < e; off += 4) {
         if (!isec->isLive(off))
           continue;
         uint32_t value = *reinterpret_cast<const uint32_t *>(buf + off);
         literal4Map.emplace(value, literal4Map.size());
       }
       break;

lld/MachO/UnwindInfoSection.cpp

 
 void UnwindInfoSection::prepareRelocations() {
   for (ConcatInputSection *isec : compactUnwindSection->inputs)
     prepareRelocations(isec);
 }
 
 template <class Ptr>
 void UnwindInfoSectionImpl<Ptr>::addInput(ConcatInputSection *isec) {
-  assert(isec->segname == segment_names::ld &&
-         isec->name == section_names::compactUnwind);
+  assert(isec->getSegName() == segment_names::ld &&
+         isec->getName() == section_names::compactUnwind);
   compactUnwindSection->addInput(isec);
 }
 
 // Compact unwind relocations have different semantics, so we handle them in a
 // separate code path from regular relocations. First, we do not wish to add
 // rebase opcodes for __LD,__compact_unwind, because that section doesn't
 // actually end up in the final binary. Second, personality pointers always
 // reside in the GOT and must be treated specially.
void UnwindInfoSectionImpl<Ptr>::prepareRelocations(ConcatInputSection *isec) {
   }
 }
 
 // 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 ConcatInputSection *checkTextSegment(InputSection *isec) {
-  if (isec->segname != segment_names::text)
+  if (isec->getSegName() != segment_names::text)
     error("compact unwind references address in " + toString(isec) +
           " which is not in segment __TEXT");
   // __text should always be a ConcatInputSection.
   return cast<ConcatInputSection>(isec);
 }
 
 // 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

lld/MachO/Writer.cpp

if (relocAttrs.hasAttr(RelocAttrBits::POINTER) || needsBinding(sym))
       in.got->addEntry(sym);
   } else if (relocAttrs.hasAttr(RelocAttrBits::TLV)) {
     if (needsBinding(sym))
       in.tlvPointers->addEntry(sym);
   } else if (relocAttrs.hasAttr(RelocAttrBits::UNSIGNED)) {
     // References from thread-local variable sections are treated as offsets
     // relative to the start of the referent section, and therefore have no
     // need of rebase opcodes.
-    if (!(isThreadLocalVariables(isec->flags) && isa<Defined>(sym)))
+    if (!(isThreadLocalVariables(isec->getFlags()) && isa<Defined>(sym)))
       addNonLazyBindingEntries(sym, isec, r.offset, r.addend);
   }
 }
 
 void Writer::scanRelocations() {
   TimeTraceScope timeScope("Scan relocations");
   for (ConcatInputSection *isec : inputSections) {
     if (isec->shouldOmitFromOutput())
static DenseMap<const InputSection *, size_t> buildInputSectionPriorities() {
 
   auto addSym = [&](Defined &sym) {
     auto it = config->priorities.find(sym.getName());
     if (it == config->priorities.end())
       return;
 
     SymbolPriorityEntry &entry = it->second;
     size_t &priority = sectionPriorities[sym.isec];
-    priority = std::max(priority, getSymbolPriority(entry, sym.isec->file));
+    priority =
+        std::max(priority, getSymbolPriority(entry, sym.isec->getFile()));
   };
 
   // TODO: Make sure this handles weak symbols correctly.
   for (const InputFile *file : inputFiles) {
     if (isa<ObjFile>(file))
       for (Symbol *sym : file->symbols)
         if (auto *d = dyn_cast_or_null<Defined>(sym))
           addSym(*d);
template <class LP> void Writer::createOutputSections() {
   default:
     llvm_unreachable("unhandled output file type");
   }
 
   // Then add input sections to output sections.
   for (ConcatInputSection *isec : inputSections) {
     if (isec->shouldOmitFromOutput())
       continue;
-    NamePair names = maybeRenameSection({isec->segname, isec->name});
+    NamePair names = maybeRenameSection({isec->getSegName(), isec->getName()});
     ConcatOutputSection *&osec = concatOutputSections[names];
     if (!osec)
       osec = make<ConcatOutputSection>(names.second);
     osec->addInput(isec);
     osec->inputOrder =
         std::min(osec->inputOrder, static_cast<int>(isec->outSecOff));
   }
 
   // Once all the inputs are added, we can finalize the output section
   // properties and create the corresponding output segments.
   for (const auto &it : concatOutputSections) {
     StringRef segname = it.first.first;
     ConcatOutputSection *osec = it.second;
     assert(segname != segment_names::ld);
     getOrCreateOutputSegment(segname)->addOutputSection(osec);
   }
 
   for (SyntheticSection *ssec : syntheticSections) {
     auto it = concatOutputSections.find({ssec->segname, ssec->name});
     if (ssec->isNeeded()) {
       if (it == concatOutputSections.end()) {
         getOrCreateOutputSegment(ssec->segname)->addOutputSection(ssec);
       } else {
-        fatal("section from " + toString(it->second->firstSection()->file) +
+        fatal("section from " +
+              toString(it->second->firstSection()->getFile()) +
               " conflicts with synthetic section " + ssec->segname + "," +
               ssec->name);
       }
     }
   }
 
   // dyld requires __LINKEDIT segment to always exist (even if empty).
   linkEditSegment = getOrCreateOutputSegment(segment_names::linkEdit);