[lld-macho][NFC] Define isHidden() in LinkEditSection

[int3]

Summary

Since it's always true

[smeenai]

LGTM

lld/MachO/SyntheticSections.h

 // All sections in __LINKEDIT should inherit from this.
 class LinkEditSection : public SyntheticSection {
 public:
   LinkEditSection(const char *segname, const char *name)
       : SyntheticSection(segname, name) {
     align = WordSize;
   }
 
+  // Sections in __LINKEDIT are special: their offsets are recorded in the
+  // load commands like LC_DYLD_INFO_ONLY and LC_SYMTAB, instead of in section
+  // headers.
+  bool isHidden() const override final { return true; }
+
   virtual uint64_t getRawSize() const = 0;
 
   // codesign (or more specifically libstuff) checks that each section in
   // __LINKEDIT ends where the next one starts -- no gaps are permitted. We
   // therefore align every section's start and end points to WordSize.
   //
   // NOTE: This assumes that the extra bytes required for alignment can be
   // zero-valued bytes.

 };
 
 // Stores bind opcodes for telling dyld which symbols to load non-lazily.
 class BindingSection : public LinkEditSection {
 public:
   BindingSection();
   void finalizeContents();
   uint64_t getRawSize() const override { return contents.size(); }
-  // Like other sections in __LINKEDIT, the binding section is special: its
-  // offsets are recorded in the LC_DYLD_INFO_ONLY load command, instead of in
-  // section headers.
-  bool isHidden() const override { return true; }
   bool isNeeded() const override { return !bindings.empty(); }
   void writeTo(uint8_t *buf) const override;
 
   void addEntry(const DylibSymbol *dysym, SectionPointerUnion section,
                 uint64_t offset, int64_t addend = 0) {
     bindings.emplace_back(dysym, BindingTarget(section, offset, addend));
   }
 

 //   coalesce to a non-weak definition if one is found. Note that unlike in the
 //   entries in the BindingSection, the bindings here only refer to these
 //   symbols by name, but do not specify which dylib to load them from.
 class WeakBindingSection : public LinkEditSection {
 public:
   WeakBindingSection();
   void finalizeContents();
   uint64_t getRawSize() const override { return contents.size(); }
-  // Like other sections in __LINKEDIT, the binding section is special: its
-  // offsets are recorded in the LC_DYLD_INFO_ONLY load command, instead of in
-  // section headers.
-  bool isHidden() const override { return true; }
   bool isNeeded() const override {
     return !bindings.empty() || !definitions.empty();
   }
 
   void writeTo(uint8_t *buf) const override;
 
   void addEntry(const Symbol *symbol, SectionPointerUnion section,
                 uint64_t offset, int64_t addend = 0) {
public:
   void writeTo(uint8_t *buf) const override;
 };
 
 class LazyBindingSection : public LinkEditSection {
 public:
   LazyBindingSection();
   void finalizeContents();
   uint64_t getRawSize() const override { return contents.size(); }
-  // Like other sections in __LINKEDIT, the lazy binding section is special: its
-  // offsets are recorded in the LC_DYLD_INFO_ONLY load command, instead of in
-  // section headers.
-  bool isHidden() const override { return true; }
   bool isNeeded() const override { return !entries.empty(); }
   void writeTo(uint8_t *buf) const override;
   // Note that every entry here will by referenced by a corresponding entry in
   // the StubHelperSection.
   void addEntry(DylibSymbol *dysym);
   const llvm::SetVector<DylibSymbol *> &getEntries() const { return entries; }
 
 private:
   uint32_t encode(const DylibSymbol &);
 
   llvm::SetVector<DylibSymbol *> entries;
   SmallVector<char, 128> contents;
   llvm::raw_svector_ostream os{contents};
 };
 
 // Stores a trie that describes the set of exported symbols.
 class ExportSection : public LinkEditSection {
 public:
   ExportSection();
   void finalizeContents();
   uint64_t getRawSize() const override { return size; }
-  // Like other sections in __LINKEDIT, the export section is special: its
-  // offsets are recorded in the LC_DYLD_INFO_ONLY load command, instead of in
-  // section headers.
-  bool isHidden() const override { return true; }
   void writeTo(uint8_t *buf) const override;
 
   bool hasWeakSymbol = false;
 
 private:
   TrieBuilder trieBuilder;
   size_t size = 0;
 };
 
 // Stores the strings referenced by the symbol table.
 class StringTableSection : public LinkEditSection {
 public:
   StringTableSection();
   // Returns the start offset of the added string.
   uint32_t addString(StringRef);
   uint64_t getRawSize() const override { return size; }
-  // Like other sections in __LINKEDIT, the string table section is special: its
-  // offsets are recorded in the LC_SYMTAB load command, instead of in section
-  // headers.
-  bool isHidden() const override { return true; }
   void writeTo(uint8_t *buf) const override;
 
 private:
   // An n_strx value of 0 always indicates the empty string, so we must locate
   // our non-empty string values at positive offsets in the string table.
   // Therefore we insert a dummy value at position zero.
   std::vector<StringRef> strings{"\0"};
   size_t size = 1;
 };
 
 struct SymtabEntry {
   Symbol *sym;
   size_t strx;
 };
 
-class SymtabSection : public SyntheticSection {
+class SymtabSection : public LinkEditSection {
 public:
   SymtabSection(StringTableSection &);
   void finalizeContents();
   size_t getNumSymbols() const { return symbols.size(); }
-  uint64_t getSize() const override;
-  // Like other sections in __LINKEDIT, the symtab section is special: its
-  // offsets are recorded in the LC_SYMTAB load command, instead of in section
-  // headers.
-  bool isHidden() const override { return true; }
+  uint64_t getRawSize() const override;
   void writeTo(uint8_t *buf) const override;
 
 private:
   StringTableSection &stringTableSection;
   std::vector<SymtabEntry> symbols;
 };
 
 struct InStruct {

lld/MachO/SyntheticSections.cpp

for (const Symbol *sym : symtab->getSymbols()) {
     }
   }
   size = trieBuilder.build();
 }
 
 void ExportSection::writeTo(uint8_t *buf) const { trieBuilder.writeTo(buf); }
 
 SymtabSection::SymtabSection(StringTableSection &stringTableSection)
-    : SyntheticSection(segment_names::linkEdit, section_names::symbolTable),
+    : LinkEditSection(segment_names::linkEdit, section_names::symbolTable),
       stringTableSection(stringTableSection) {}
 
-uint64_t SymtabSection::getSize() const {
+uint64_t SymtabSection::getRawSize() const {
   return symbols.size() * sizeof(structs::nlist_64);
 }
 
 void SymtabSection::finalizeContents() {
   // TODO support other symbol types
   for (Symbol *sym : symtab->getSymbols())
     if (isa<Defined>(sym))
       symbols.push_back({sym, stringTableSection.addString(sym->getName())});