[lld-macho][nfc] Have InputSection ctors take some parameters

[int3]

Summary

This is motivated by an upcoming diff in which the
WordLiteralInputSection ctor sets itself up based on the value of its
section flags. As such, it needs to be passed the flags value as part
of its ctor parameters, instead of having them assigned after the fact
in parseSection(). While refactoring code to make that possible, I
figured it would make sense for the other InputSections to also take
their initial values as ctor parameters.

[thakis]

lld/MachO/InputFiles.cpp

243–244

I think you're removing all callers of this below -- remove this function, it should be unused.

lld/MachO/ConcatOutputSection.cpp

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>();
-      thunkInfo.isec->name = isec->name;
-      thunkInfo.isec->segname = isec->segname;
+      thunkInfo.isec = make<ConcatInputSection>(isec->segname, isec->name);
       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);

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>();
+    auto *isec =
+        make<ConcatInputSection>(segment_names::data, section_names::common);
     isec->file = common->getFile();
-    isec->name = section_names::common;
-    isec->segname = segment_names::data;
     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;
     inputSections.push_back(isec);
 

lld/MachO/InputFiles.cpp

Optional<MemoryBufferRef> macho::readFile(StringRef path) {
   }
 
   error("unable to find matching architecture in " + path);
   return None;
 }
 
 InputFile::InputFile(Kind kind, const InterfaceFile &interface)
     : id(idCount++), fileKind(kind), name(saver.save(interface.getPath())) {}
 
 template <class Section>
-static void parseSection(ObjFile *file, const uint8_t *buf, const Section &sec,
-                         InputSection *isec) {
-  isec->file = file;
-  isec->name =
-      StringRef(sec.sectname, strnlen(sec.sectname, sizeof(sec.sectname)));
-  isec->segname =
-      StringRef(sec.segname, strnlen(sec.segname, sizeof(sec.segname)));
-  isec->data = {isZeroFill(sec.flags) ? nullptr : buf + sec.offset,
-                static_cast<size_t>(sec.size)};
-  if (sec.align >= 32)
-    error("alignment " + std::to_string(sec.align) + " of section " +
-          isec->name + " is too large");
-  else
-    isec->align = 1 << sec.align;
-  isec->flags = sec.flags;
-}
-
-template <class Section>
 void ObjFile::parseSections(ArrayRef<Section> sections) {
   subsections.reserve(sections.size());
   auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
 
   for (const Section &sec : sections) {
+    StringRef name =
+        StringRef(sec.sectname, strnlen(sec.sectname, sizeof(sec.sectname)));
+    StringRef segname =
+        StringRef(sec.segname, strnlen(sec.segname, sizeof(sec.segname)));
+    ArrayRef<uint8_t> data = {isZeroFill(sec.flags) ? nullptr
+                                                    : buf + sec.offset,
+                              static_cast<size_t>(sec.size)};
+    if (sec.align >= 32)
+      error("alignment " + std::to_string(sec.align) + " of section " + name +
+            " is too large");
+    uint32_t align = 1 << sec.align;
+    uint32_t flags = sec.flags;
+
     if (config->dedupLiterals &&
         (sectionType(sec.flags) == S_CSTRING_LITERALS ||
          isWordLiteralSection(sec.flags))) {
       if (sec.nreloc)
         fatal(toString(this) + " contains relocations in " + sec.segname + "," +
               sec.sectname +
               ", so LLD cannot deduplicate literals. Try re-running without "
               "--deduplicate-literals.");
 
       InputSection *isec;
       if (sectionType(sec.flags) == S_CSTRING_LITERALS) {
-        isec = make<CStringInputSection>();
-        parseSection(this, buf, sec, isec);
+        isec =
+            make<CStringInputSection>(segname, name, this, data, align, flags);
         // FIXME: parallelize this?
         cast<CStringInputSection>(isec)->splitIntoPieces();
       } else {
-        isec = make<WordLiteralInputSection>();
-        parseSection(this, buf, sec, isec);
+        isec = make<WordLiteralInputSection>(segname, name, this, data, align,
+                                             flags);
       }
       subsections.push_back({{0, isec}});
     } else {
-      auto *isec = make<ConcatInputSection>();
-      parseSection(this, buf, sec, isec);
+      auto *isec =
+          make<ConcatInputSection>(segname, name, this, data, align, flags);
       if (!(isDebugSection(isec->flags) &&
             isec->segname == 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.
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>();
+  ConcatInputSection *isec =
+      make<ConcatInputSection>(segName.take_front(16), sectName.take_front(16));
   isec->file = this;
-  isec->name = sectName.take_front(16);
-  isec->segname = segName.take_front(16);
   const auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
   isec->data = {buf, mb.getBufferSize()};
   isec->live = true;
   subsections.push_back({{0, isec}});
 }
 
 ObjFile::ObjFile(MemoryBufferRef mb, uint32_t modTime, StringRef archiveName)
     : InputFile(ObjKind, mb), modTime(modTime) {

lld/MachO/InputSection.h

public:
   uint32_t callSiteCount = 0;
   bool isFinal = false; // is address assigned?
 
 
   ArrayRef<uint8_t> data;
   std::vector<Reloc> relocs;
 
 protected:
-  explicit InputSection(Kind kind) : sectionKind(kind) {}
+  InputSection(Kind kind, StringRef segname, StringRef name)
+      : name(name), segname(segname), sectionKind(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) {}
 
 private:
   Kind sectionKind;
 };
 
 // ConcatInputSections are combined into (Concat)OutputSections through simple
 // concatentation, in contrast with literal sections which may have their
 // contents merged before output.
 class ConcatInputSection : public InputSection {
 public:
-  ConcatInputSection() : InputSection(ConcatKind) {}
+  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)
+      : InputSection(ConcatKind, segname, name, file, data, align, flags) {}
+
   uint64_t getFileOffset(uint64_t off) const override;
   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; }
   bool isCoalescedWeak() const { return wasCoalesced && numRefs == 0; }
   bool shouldOmitFromOutput() const { return !live || isCoalescedWeak(); }
 

 //
 // NOTE: One significant difference between LLD and ld64 is that we merge all
 // cstring literals, even those referenced directly by non-private symbols.
 // ld64 is more conservative and does not do that. This was mostly done for
 // implementation simplicity; if we find programs that need the more
 // conservative behavior we can certainly implement that.
 class CStringInputSection : public InputSection {
 public:
-  CStringInputSection() : InputSection(CStringLiteralKind) {}
+  CStringInputSection(StringRef segname, StringRef name, InputFile *file,
+                      ArrayRef<uint8_t> data, uint32_t align, uint32_t flags)
+      : InputSection(CStringLiteralKind, segname, name, file, data, align,
+                     flags) {}
   uint64_t getFileOffset(uint64_t off) const override;
   uint64_t getOffset(uint64_t off) const override;
   // FIXME implement this
   bool isLive(uint64_t off) const override { return true; }
   // Find the StringPiece that contains this offset.
   const StringPiece &getStringPiece(uint64_t off) const;
   // Split at each null byte.
   void splitIntoPieces();
static bool classof(const InputSection *isec) {
     return isec->kind() == CStringLiteralKind;
   }
 
   std::vector<StringPiece> pieces;
 };
 
 class WordLiteralInputSection : public InputSection {
 public:
-  WordLiteralInputSection() : InputSection(WordLiteralKind) {}
+  WordLiteralInputSection(StringRef segname, StringRef name, InputFile *file,
+                          ArrayRef<uint8_t> data, uint32_t align,
+                          uint32_t flags);
   uint64_t getFileOffset(uint64_t off) const override;
   uint64_t getOffset(uint64_t off) const override;
   // FIXME implement this
   bool isLive(uint64_t off) const override { return true; }
 
   static bool classof(const InputSection *isec) {
     return isec->kind() == WordLiteralKind;
   }

lld/MachO/InputSection.cpp

 }
 
 uint64_t CStringInputSection::getOffset(uint64_t off) const {
   const StringPiece &piece = getStringPiece(off);
   uint64_t addend = off - piece.inSecOff;
   return piece.outSecOff + addend;
 }
 
+WordLiteralInputSection::WordLiteralInputSection(StringRef segname,
+                                                 StringRef name,
+                                                 InputFile *file,
+                                                 ArrayRef<uint8_t> data,
+                                                 uint32_t align, uint32_t flags)
+    : InputSection(WordLiteralKind, segname, name, file, data, align, flags) {}
+
 uint64_t WordLiteralInputSection::getFileOffset(uint64_t off) const {
   return parent->fileOff + getOffset(off);
 }
 
 uint64_t WordLiteralInputSection::getOffset(uint64_t off) const {
   auto *osec = cast<WordLiteralSection>(parent);
   const uint8_t *buf = data.data();
   switch (sectionType(flags)) {

lld/MachO/SyntheticSections.cpp

 using namespace lld;
 using namespace lld::macho;
 
 InStruct macho::in;
 std::vector<SyntheticSection *> macho::syntheticSections;
 
 SyntheticSection::SyntheticSection(const char *segname, const char *name)
     : OutputSection(SyntheticKind, name), segname(segname) {
-  isec = make<ConcatInputSection>();
-  isec->segname = segname;
-  isec->name = name;
+  isec = make<ConcatInputSection>(segname, name);
   isec->parent = this;
   syntheticSections.push_back(this);
 }
 
 // dyld3's MachOLoaded::getSlide() assumes that the __TEXT segment starts
 // from the beginning of the file (i.e. the header).
 MachHeaderSection::MachHeaderSection()
     : SyntheticSection(segment_names::text, section_names::header) {
void StubHelperSection::setup() {
   dyldPrivate =
       make<Defined>("__dyld_private", nullptr, in.imageLoaderCache, 0, 0,
                     /*isWeakDef=*/false,
                     /*isExternal=*/false, /*isPrivateExtern=*/false,
                     /*isThumb=*/false, /*isReferencedDynamically=*/false,
                     /*noDeadStrip=*/false);
 }
 
-ImageLoaderCacheSection::ImageLoaderCacheSection() {
-  segname = segment_names::data;
-  name = section_names::data;
+ImageLoaderCacheSection::ImageLoaderCacheSection()
+    : ConcatInputSection(segment_names::data, section_names::data) {
   uint8_t *arr = bAlloc.Allocate<uint8_t>(target->wordSize);
   memset(arr, 0, target->wordSize);
   data = {arr, target->wordSize};
   align = target->wordSize;
   live = true;
 }
 
 LazyPointerSection::LazyPointerSection()