[lld-macho][nfc] Move some methods from InputFile to ObjFile

[int3]

Summary

Additionally:

1. Move the helper functions in InputSection.h below the definition of InputSection, so the important stuff is on top
2. Remove unnecessary explicit

[compnerd]

The change itself is fine, though I think that the commit message can be improved. The shuffling of the code should be called out in the summary IMO.

[int3]

Shuffling of which code? The changes to InputSection are mentioned in the summary, and the changes to InputFile are mentioned in the commit title

[int3]

update

lld/MachO/InputFiles.h

public:
 
   virtual ~InputFile() = default;
   Kind kind() const { return fileKind; }
   StringRef getName() const { return name; }
 
   MemoryBufferRef mb;
 
   std::vector<Symbol *> symbols;
-  ArrayRef<llvm::MachO::section_64> sectionHeaders;
   std::vector<SubsectionMap> subsections;
   // Provides an easy way to sort InputFiles deterministically.
   const int id;
 
   // If not empty, this stores the name of the archive containing this file.
   // We use this string for creating error messages.
   std::string archiveName;
 
 protected:
   InputFile(Kind kind, MemoryBufferRef mb)
       : mb(mb), id(idCount++), fileKind(kind), name(mb.getBufferIdentifier()) {}
 
   InputFile(Kind kind, const llvm::MachO::InterfaceFile &interface)
       : id(idCount++), fileKind(kind), name(saver.save(interface.getPath())) {}
 
-  void parseSections(ArrayRef<llvm::MachO::section_64>);
-
-  void parseSymbols(ArrayRef<lld::structs::nlist_64> nList, const char *strtab,
-                    bool subsectionsViaSymbols);
-
-  Symbol *parseNonSectionSymbol(const structs::nlist_64 &sym, StringRef name);
-
-  void parseRelocations(const llvm::MachO::section_64 &, SubsectionMap &);
-
 private:
   const Kind fileKind;
   const StringRef name;
 
   static int idCount;
 };
 
 // .o file
 class ObjFile : public InputFile {
 public:
-  explicit ObjFile(MemoryBufferRef mb, uint32_t modTime, StringRef archiveName);
+  ObjFile(MemoryBufferRef mb, uint32_t modTime, StringRef archiveName);
   static bool classof(const InputFile *f) { return f->kind() == ObjKind; }
 
   llvm::DWARFUnit *compileUnit = nullptr;
   const uint32_t modTime;
+  ArrayRef<llvm::MachO::section_64> sectionHeaders;
 
 private:
+  void parseSections(ArrayRef<llvm::MachO::section_64>);
+  void parseSymbols(ArrayRef<lld::structs::nlist_64> nList, const char *strtab,
+                    bool subsectionsViaSymbols);
+  Symbol *parseNonSectionSymbol(const structs::nlist_64 &sym, StringRef name);
+  void parseRelocations(const llvm::MachO::section_64 &, SubsectionMap &);
   void parseDebugInfo();
 };
 
 // command-line -sectcreate file
 class OpaqueFile : public InputFile {
 public:
-  explicit OpaqueFile(MemoryBufferRef mb, StringRef segName,
-                      StringRef sectName);
+  OpaqueFile(MemoryBufferRef mb, StringRef segName, StringRef sectName);
   static bool classof(const InputFile *f) { return f->kind() == OpaqueKind; }
 };
 
 // .dylib file
 class DylibFile : public InputFile {
 public:
   // Mach-O dylibs can re-export other dylibs as sub-libraries, meaning that the
   // symbols in those sub-libraries will be available under the umbrella

lld/MachO/InputFiles.cpp

for (uint32_t i = 0, n = hdr->ncmds; i < n; ++i) {
     auto *cmd = reinterpret_cast<const load_command *>(p);
     if (cmd->cmd == type)
       return cmd;
     p += cmd->cmdsize;
   }
   return nullptr;
 }
 
-void InputFile::parseSections(ArrayRef<section_64> sections) {
+void ObjFile::parseSections(ArrayRef<section_64> sections) {
   subsections.reserve(sections.size());
   auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
 
   for (const section_64 &sec : sections) {
     InputSection *isec = make<InputSection>();
     isec->file = this;
     isec->name =
         StringRef(sec.sectname, strnlen(sec.sectname, sizeof(sec.sectname)));

 // subsection.
 static InputSection *findContainingSubsection(SubsectionMap &map,
                                               uint32_t *offset) {
   auto it = std::prev(map.upper_bound(*offset));
   *offset -= it->first;
   return it->second;
 }
 
-void InputFile::parseRelocations(const section_64 &sec,
-                                 SubsectionMap &subsecMap) {
+void ObjFile::parseRelocations(const section_64 &sec,
   auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
   ArrayRef<any_relocation_info> anyRelInfos(
       reinterpret_cast<const any_relocation_info *>(buf + sec.reloff),
       sec.nreloc);
 
   for (const any_relocation_info &anyRelInfo : anyRelInfos) {
     if (anyRelInfo.r_word0 & R_SCATTERED)
       fatal("TODO: Scattered relocations not supported");

 static macho::Symbol *createAbsolute(const structs::nlist_64 &sym,
                                      StringRef name) {
   if (sym.n_type & N_EXT)
     return symtab->addDefined(name, nullptr, sym.n_value, /*isWeakDef=*/false);
   return make<Defined>(name, nullptr, sym.n_value, /*isWeakDef=*/false,
                        /*isExternal=*/false);
 }
 
-macho::Symbol *InputFile::parseNonSectionSymbol(const structs::nlist_64 &sym,
-                                                StringRef name) {
+macho::Symbol *ObjFile::parseNonSectionSymbol(const structs::nlist_64 &sym,
   uint8_t type = sym.n_type & N_TYPE;
   switch (type) {
   case N_UNDF:
     return sym.n_value == 0
                ? symtab->addUndefined(name)
                : symtab->addCommon(name, this, sym.n_value,
                                    1 << GET_COMM_ALIGN(sym.n_desc));
   case N_ABS:
     return createAbsolute(sym, name);
   case N_PBUD:
   case N_INDR:
     error("TODO: support symbols of type " + std::to_string(type));
     return nullptr;
   case N_SECT:
     llvm_unreachable(
         "N_SECT symbols should not be passed to parseNonSectionSymbol");
   default:
     llvm_unreachable("invalid symbol type");
   }
 }
 
-void InputFile::parseSymbols(ArrayRef<structs::nlist_64> nList,
-                             const char *strtab, bool subsectionsViaSymbols) {
+void ObjFile::parseSymbols(ArrayRef<structs::nlist_64> nList,
   // resize(), not reserve(), because we are going to create N_ALT_ENTRY symbols
   // out-of-sequence.
   symbols.resize(nList.size());
   std::vector<size_t> altEntrySymIdxs;
 
   for (size_t i = 0, n = nList.size(); i < n; ++i) {
     const structs::nlist_64 &sym = nList[i];
     StringRef name = strtab + sym.n_strx;

lld/MachO/InputSection.h

struct Reloc {
   // to.
   uint32_t offset;
   // Adding this offset to the address of the referent symbol or subsection
   // gives the destination that this relocation refers to.
   uint64_t addend;
   llvm::PointerUnion<Symbol *, InputSection *> referent;
 };
 
-inline bool isZeroFill(uint32_t flags) {
-  return llvm::MachO::isVirtualSection(flags & llvm::MachO::SECTION_TYPE);
-}
-
-inline bool isThreadLocalVariables(uint32_t flags) {
-  return (flags & llvm::MachO::SECTION_TYPE) ==
-         llvm::MachO::S_THREAD_LOCAL_VARIABLES;
-}
-
-inline bool isDebugSection(uint32_t flags) {
-  return (flags & llvm::MachO::SECTION_ATTRIBUTES_USR) ==
-         llvm::MachO::S_ATTR_DEBUG;
-}
-
 class InputSection {
 public:
   virtual ~InputSection() = default;
   virtual uint64_t getSize() const { return data.size(); }
-  virtual uint64_t getFileSize() const {
-    return isZeroFill(flags) ? 0 : getSize();
-  }
+  virtual uint64_t getFileSize() const;
   uint64_t getFileOffset() const;
   uint64_t getVA() const;
 
   virtual void writeTo(uint8_t *buf);
 
   InputFile *file = nullptr;
   StringRef name;
   StringRef segname;
 
   OutputSection *parent = nullptr;
   uint64_t outSecOff = 0;
   uint64_t outSecFileOff = 0;
 
   uint32_t align = 1;
   uint32_t flags = 0;
 
   ArrayRef<uint8_t> data;
   std::vector<Reloc> relocs;
 };
 
+inline bool isZeroFill(uint32_t flags) {
+  return llvm::MachO::isVirtualSection(flags & llvm::MachO::SECTION_TYPE);
+}
+
+inline bool isThreadLocalVariables(uint32_t flags) {
+  return (flags & llvm::MachO::SECTION_TYPE) ==
+         llvm::MachO::S_THREAD_LOCAL_VARIABLES;
+}
+
+inline bool isDebugSection(uint32_t flags) {
+  return (flags & llvm::MachO::SECTION_ATTRIBUTES_USR) ==
+         llvm::MachO::S_ATTR_DEBUG;
+}
+
 bool isCodeSection(InputSection *);
 
 extern std::vector<InputSection *> inputSections;
 
 } // namespace macho
 
 std::string toString(const macho::InputSection *);
 
 } // namespace lld
 
 #endif

lld/MachO/InputSection.cpp

 using namespace lld::macho;
 
 std::vector<InputSection *> macho::inputSections;
 
 uint64_t InputSection::getFileOffset() const {
   return parent->fileOff + outSecFileOff;
 }
 
+uint64_t InputSection::getFileSize() const {
+  return isZeroFill(flags) ? 0 : getSize();
+}
+
 uint64_t InputSection::getVA() const { return parent->addr + outSecOff; }
 
 void InputSection::writeTo(uint8_t *buf) {
   if (getFileSize() == 0)
     return;
 
   memcpy(buf, data.data(), data.size());