[lld-macho][nfc] Add `final` to classes where possible

[int3]

Summary

I wanted to see if we would get any perf wins out of this, but
it doesn't seem to be the case. But it still seems worth committing.

[MaskRay]

There may be size benefit due to devirtualization without LTO.

[grandinj]

I did this (for LibreOffice), and final seems to be only a win when we do LTO and we can de-virtualise a bunch of stuff.

I was hoping that final would also help for dynamic_cast (where, in theory, if we're casting to a final type, we can optimise to a simple comparison), but that doesn't seem to be impemented by the dynamic_cast machinery (or the compiler)

lld/MachO/ConcatOutputSection.h

 namespace macho {
 
 class Defined;
 
 // Linking multiple files will inevitably mean resolving sections in different
 // files that are labeled with the same segment and section name. This class
 // contains all such sections and writes the data from each section sequentially
 // in the final binary.
-class ConcatOutputSection : public OutputSection {
+class ConcatOutputSection final : public OutputSection {
 public:
   explicit ConcatOutputSection(StringRef name)
       : OutputSection(ConcatKind, name) {}
 
   const ConcatInputSection *firstSection() const { return inputs.front(); }
   const ConcatInputSection *lastSection() const { return inputs.back(); }
 
   // These accessors will only be valid after finalizing the section

lld/MachO/InputFiles.h

 private:
   const Kind fileKind;
   const StringRef name;
 
   static int idCount;
 };
 
 // .o file
-class ObjFile : public InputFile {
+class ObjFile final : public InputFile {
 public:
   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;
   std::vector<ConcatInputSection *> debugSections;
 
 private:
   template <class LP> void parse();
   template <class Section> void parseSections(ArrayRef<Section>);
   template <class LP>
   void parseSymbols(ArrayRef<typename LP::section> sectionHeaders,
                     ArrayRef<typename LP::nlist> nList, const char *strtab,
                     bool subsectionsViaSymbols);
   template <class NList>
   Symbol *parseNonSectionSymbol(const NList &sym, StringRef name);
   template <class Section>
   void parseRelocations(ArrayRef<Section> sectionHeaders, const Section &,
                         SubsectionMap &);
   void parseDebugInfo();
 };
 
 // command-line -sectcreate file
-class OpaqueFile : public InputFile {
+class OpaqueFile final : public InputFile {
 public:
   OpaqueFile(MemoryBufferRef mb, StringRef segName, StringRef sectName);
   static bool classof(const InputFile *f) { return f->kind() == OpaqueKind; }
 };
 
 // .dylib or .tbd file
-class DylibFile : public InputFile {
+class DylibFile final : 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
   // library's namespace. Those sub-libraries can also have their own
   // re-exports. When loading a re-exported dylib, `umbrella` should be set to
   // the root dylib to ensure symbols in the child library are correctly bound
   // to the root. On the other hand, if a dylib is being directly loaded
   // (through an -lfoo flag), then `umbrella` should be a nullptr.

 
 private:
   bool handleLDSymbol(StringRef originalName);
   void handleLDPreviousSymbol(StringRef name, StringRef originalName);
   void handleLDInstallNameSymbol(StringRef name, StringRef originalName);
 };
 
 // .a file
-class ArchiveFile : public InputFile {
+class ArchiveFile final : public InputFile {
 public:
   explicit ArchiveFile(std::unique_ptr<llvm::object::Archive> &&file);
   static bool classof(const InputFile *f) { return f->kind() == ArchiveKind; }
   void fetch(const llvm::object::Archive::Symbol &sym);
 
 private:
   std::unique_ptr<llvm::object::Archive> file;
   // Keep track of children fetched from the archive by tracking
   // which address offsets have been fetched already.
   llvm::DenseSet<uint64_t> seen;
 };
 
-class BitcodeFile : public InputFile {
+class BitcodeFile final : public InputFile {
 public:
   explicit BitcodeFile(MemoryBufferRef mb);
   static bool classof(const InputFile *f) { return f->kind() == BitcodeKind; }
 
   std::unique_ptr<llvm::lto::InputFile> obj;
 };
 
 extern llvm::SetVector<InputFile *> inputFiles;

lld/MachO/InputSection.h

 
 private:
   Kind sectionKind;
 };
 
 // ConcatInputSections are combined into (Concat)OutputSections through simple
 // concatenation, in contrast with literal sections which may have their
 // contents merged before output.
-class ConcatInputSection : public InputSection {
+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)
       : InputSection(ConcatKind, segname, name, file, data, align, flags) {}
 

 // deduplicated and tail-merged, so translating offsets between the input and
 // outputs sections is more complicated.
 //
 // 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 {
+class CStringInputSection final : public InputSection {
 public:
   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 getOffset(uint64_t off) const override;
   bool isLive(uint64_t off) const override { return getStringPiece(off).live; }
   void markLive(uint64_t off) override { getStringPiece(off).live = true; }
public:
 
   static bool classof(const InputSection *isec) {
     return isec->kind() == CStringLiteralKind;
   }
 
   std::vector<StringPiece> pieces;
 };
 
-class WordLiteralInputSection : public InputSection {
+class WordLiteralInputSection final : public InputSection {
 public:
   WordLiteralInputSection(StringRef segname, StringRef name, InputFile *file,
                           ArrayRef<uint8_t> data, uint32_t align,
                           uint32_t flags);
   uint64_t getOffset(uint64_t off) const override;
   bool isLive(uint64_t off) const override {
     return live[off >> power2LiteralSize];
   }

lld/MachO/SyntheticSections.h

public:
   // NOTE: This assumes that the extra bytes required for alignment can be
   // zero-valued bytes.
   uint64_t getSize() const override final {
     return llvm::alignTo(getRawSize(), align);
   }
 };
 
 // The header of the Mach-O file, which must have a file offset of zero.
-class MachHeaderSection : public SyntheticSection {
+class MachHeaderSection final : public SyntheticSection {
 public:
   MachHeaderSection();
   bool isHidden() const override { return true; }
   uint64_t getSize() const override;
   void writeTo(uint8_t *buf) const override;
 
   void addLoadCommand(LoadCommand *);
 
 protected:
   std::vector<LoadCommand *> loadCommands;
   uint32_t sizeOfCmds = 0;
 };
 
 // A hidden section that exists solely for the purpose of creating the
 // __PAGEZERO segment, which is used to catch null pointer dereferences.
-class PageZeroSection : public SyntheticSection {
+class PageZeroSection final : public SyntheticSection {
 public:
   PageZeroSection();
   bool isHidden() const override { return true; }
   uint64_t getSize() const override { return target->pageZeroSize; }
   uint64_t getFileSize() const override { return 0; }
   void writeTo(uint8_t *buf) const override {}
 };
 
public:
   uint64_t getVA(uint32_t gotIndex) const {
     return addr + gotIndex * target->wordSize;
   }
 
 private:
   llvm::SetVector<const Symbol *> entries;
 };
 
-class GotSection : public NonLazyPointerSectionBase {
+class GotSection final : public NonLazyPointerSectionBase {
 public:
   GotSection()
       : NonLazyPointerSectionBase(segment_names::dataConst,
                                   section_names::got) {
     // TODO: section_64::reserved1 should be an index into the indirect symbol
     // table, which we do not currently emit
   }
 };
 
-class TlvPointerSection : public NonLazyPointerSectionBase {
+class TlvPointerSection final : public NonLazyPointerSectionBase {
 public:
   TlvPointerSection()
       : NonLazyPointerSectionBase(segment_names::data,
                                   section_names::threadPtrs) {}
 };
 
 struct Location {
   const InputSection *isec;
   uint64_t offset;
 
   Location(const InputSection *isec, uint64_t offset)
       : isec(isec), offset(offset) {}
   uint64_t getVA() const { return isec->getVA(offset); }
 };
 
 // Stores rebase opcodes, which tell dyld where absolute addresses have been
 // encoded in the binary. If the binary is not loaded at its preferred address,
 // dyld has to rebase these addresses by adding an offset to them.
-class RebaseSection : public LinkEditSection {
+class RebaseSection final : public LinkEditSection {
 public:
   RebaseSection();
   void finalizeContents() override;
   uint64_t getRawSize() const override { return contents.size(); }
   bool isNeeded() const override { return !locations.empty(); }
   void writeTo(uint8_t *buf) const override;
 
   void addEntry(const InputSection *isec, uint64_t offset) {
struct BindingEntry {
   const DylibSymbol *dysym;
   int64_t addend;
   Location target;
   BindingEntry(const DylibSymbol *dysym, int64_t addend, Location target)
       : dysym(dysym), addend(addend), target(std::move(target)) {}
 };
 
 // Stores bind opcodes for telling dyld which symbols to load non-lazily.
-class BindingSection : public LinkEditSection {
+class BindingSection final : public LinkEditSection {
 public:
   BindingSection();
   void finalizeContents() override;
   uint64_t getRawSize() const override { return contents.size(); }
   bool isNeeded() const override { return !bindings.empty(); }
   void writeTo(uint8_t *buf) const override;
 
   void addEntry(const DylibSymbol *dysym, const InputSection *isec,

 //
 //   1) Non-weak definitions: This is a symbol definition that weak symbols in
 //   other dylibs should coalesce to.
 //
 //   2) Weak bindings: These tell dyld that a given symbol reference should
 //   coalesce to a non-weak definition if one is found. Note that unlike 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 {
+class WeakBindingSection final : public LinkEditSection {
 public:
   WeakBindingSection();
   void finalizeContents() override;
   uint64_t getRawSize() const override { return contents.size(); }
   bool isNeeded() const override {
     return !bindings.empty() || !definitions.empty();
   }
 

 //
 // With weak symbols, the situation is slightly different. Since there is no
 // "weak lazy" lookup, function calls to weak symbols are always non-lazily
 // bound. We emit both regular non-lazy bindings as well as weak bindings, in
 // order that the weak bindings may overwrite the non-lazy bindings if an
 // appropriate symbol is found at runtime. However, the bound addresses will
 // still be written (non-lazily) into the LazyPointerSection.
 
-class StubsSection : public SyntheticSection {
+class StubsSection final : public SyntheticSection {
 public:
   StubsSection();
   uint64_t getSize() const override;
   bool isNeeded() const override { return !entries.empty(); }
   void finalize() override;
   void writeTo(uint8_t *buf) const override;
   const llvm::SetVector<Symbol *> &getEntries() const { return entries; }
   // Returns whether the symbol was added. Note that every stubs entry will
public:
   }
 
   bool isFinal = false; // is address assigned?
 
 private:
   llvm::SetVector<Symbol *> entries;
 };
 
-class StubHelperSection : public SyntheticSection {
+class StubHelperSection final : public SyntheticSection {
 public:
   StubHelperSection();
   uint64_t getSize() const override;
   bool isNeeded() const override;
   void writeTo(uint8_t *buf) const override;
 
   void setup();
 
   DylibSymbol *stubBinder = nullptr;
   Defined *dyldPrivate = nullptr;
 };
 
 // Note that this section may also be targeted by non-lazy bindings. In
 // particular, this happens when branch relocations target weak symbols.
-class LazyPointerSection : public SyntheticSection {
+class LazyPointerSection final : public SyntheticSection {
 public:
   LazyPointerSection();
   uint64_t getSize() const override;
   bool isNeeded() const override;
   void writeTo(uint8_t *buf) const override;
 };
 
-class LazyBindingSection : public LinkEditSection {
+class LazyBindingSection final : public LinkEditSection {
 public:
   LazyBindingSection();
   void finalizeContents() override;
   uint64_t getRawSize() const override { return contents.size(); }
   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 {
+class ExportSection final : public LinkEditSection {
 public:
   ExportSection();
   void finalizeContents() override;
   uint64_t getRawSize() const override { return size; }
   void writeTo(uint8_t *buf) const override;
 
   bool hasWeakSymbol = false;
 
 private:
   TrieBuilder trieBuilder;
   size_t size = 0;
 };
 
 // Stores ULEB128 delta encoded addresses of functions.
-class FunctionStartsSection : public LinkEditSection {
+class FunctionStartsSection final : public LinkEditSection {
 public:
   FunctionStartsSection();
   void finalizeContents() override;
   uint64_t getRawSize() const override { return contents.size(); }
   void writeTo(uint8_t *buf) const override;
 
 private:
   SmallVector<char, 128> contents;
 };
 
 // Stores the strings referenced by the symbol table.
-class StringTableSection : public LinkEditSection {
+class StringTableSection final : public LinkEditSection {
 public:
   StringTableSection();
   // Returns the start offset of the added string.
   uint32_t addString(StringRef);
   uint64_t getRawSize() const override { return size; }
   void writeTo(uint8_t *buf) const override;
 
   static constexpr size_t emptyStringIndex = 1;

 // concatenation of several sub-arrays of indices, each sub-array belonging to
 // a separate section. The starting offset of each sub-array is stored in the
 // reserved1 header field of the respective section.
 //
 // These sub-arrays provide symbol information for sections that store
 // contiguous sequences of symbol references. These references can be pointers
 // (e.g. those in the GOT and TLVP sections) or assembly sequences (e.g.
 // function stubs).
-class IndirectSymtabSection : public LinkEditSection {
+class IndirectSymtabSection final : public LinkEditSection {
 public:
   IndirectSymtabSection();
   void finalizeContents() override;
   uint32_t getNumSymbols() const;
   uint64_t getRawSize() const override {
     return getNumSymbols() * sizeof(uint32_t);
   }
   bool isNeeded() const override;
   void writeTo(uint8_t *buf) const override;
 };
 
 // The code signature comes at the very end of the linked output file.
-class CodeSignatureSection : public LinkEditSection {
+class CodeSignatureSection final : public LinkEditSection {
 public:
   static constexpr uint8_t blockSizeShift = 12;
   static constexpr size_t blockSize = (1 << blockSizeShift); // 4 KiB
   static constexpr size_t hashSize = 256 / 8;
   static constexpr size_t blobHeadersSize = llvm::alignTo<8>(
       sizeof(llvm::MachO::CS_SuperBlob) + sizeof(llvm::MachO::CS_BlobIndex));
   static constexpr uint32_t fixedHeadersSize =
       blobHeadersSize + sizeof(llvm::MachO::CS_CodeDirectory);
 
   uint32_t fileNamePad = 0;
   uint32_t allHeadersSize = 0;
   StringRef fileName;
 
   CodeSignatureSection();
   uint64_t getRawSize() const override;
   bool isNeeded() const override { return true; }
   void writeTo(uint8_t *buf) const override;
   uint32_t getBlockCount() const;
   void writeHashes(uint8_t *buf) const;
 };
 
-class BitcodeBundleSection : public SyntheticSection {
+class BitcodeBundleSection final : public SyntheticSection {
 public:
   BitcodeBundleSection();
   uint64_t getSize() const override { return xarSize; }
   void finalize() override;
   void writeTo(uint8_t *buf) const override;
 
 private:
   llvm::SmallString<261> xarPath;
   uint64_t xarSize;
 };
 
-class CStringSection : public SyntheticSection {
+class CStringSection final : public SyntheticSection {
 public:
   CStringSection();
   void addInput(CStringInputSection *);
   uint64_t getSize() const override { return builder.getSize(); }
   void finalize() override;
   bool isNeeded() const override { return !inputs.empty(); }
   void writeTo(uint8_t *buf) const override { builder.write(buf); }
 
   std::vector<CStringInputSection *> inputs;
 
 private:
   llvm::StringTableBuilder builder;
 };
 
 /*
  * This section contains deduplicated literal values. The 16-byte values are
  * laid out first, followed by the 8- and then the 4-byte ones.
  */
-class WordLiteralSection : public SyntheticSection {
+class WordLiteralSection final : public SyntheticSection {
 public:
   using UInt128 = std::pair<uint64_t, uint64_t>;
   // I don't think the standard guarantees the size of a pair, so let's make
   // sure it's exact -- that way we can construct it via `mmap`.
   static_assert(sizeof(UInt128) == 16, "");
 
   WordLiteralSection();
   void addInput(WordLiteralInputSection *);

lld/MachO/SyntheticSections.cpp

 }
 
 uint32_t SymtabSection::getNumSymbols() const {
   return stabs.size() + localSymbols.size() + externalSymbols.size() +
          undefinedSymbols.size();
 }
 
 // This serves to hide (type-erase) the template parameter from SymtabSection.
-template <class LP> class SymtabSectionImpl : public SymtabSection {
+template <class LP> class SymtabSectionImpl final : public SymtabSection {
 public:
   SymtabSectionImpl(StringTableSection &stringTableSection)
       : SymtabSection(stringTableSection) {}
   uint64_t getRawSize() const override;
   void writeTo(uint8_t *buf) const override;
 };
 
 template <class LP> uint64_t SymtabSectionImpl<LP>::getRawSize() const {

lld/MachO/Writer.cpp

public:
   CodeSignatureSection *codeSignatureSection = nullptr;
   FunctionStartsSection *functionStartsSection = nullptr;
 
   LCUuid *uuidCommand = nullptr;
   OutputSegment *linkEditSegment = nullptr;
 };
 
 // LC_DYLD_INFO_ONLY stores the offsets of symbol import/export information.
-class LCDyldInfo : public LoadCommand {
+class LCDyldInfo final : public LoadCommand {
 public:
   LCDyldInfo(RebaseSection *rebaseSection, BindingSection *bindingSection,
              WeakBindingSection *weakBindingSection,
              LazyBindingSection *lazyBindingSection,
              ExportSection *exportSection)
       : rebaseSection(rebaseSection), bindingSection(bindingSection),
         weakBindingSection(weakBindingSection),
         lazyBindingSection(lazyBindingSection), exportSection(exportSection) {}
public:
 
   RebaseSection *rebaseSection;
   BindingSection *bindingSection;
   WeakBindingSection *weakBindingSection;
   LazyBindingSection *lazyBindingSection;
   ExportSection *exportSection;
 };
 
-class LCFunctionStarts : public LoadCommand {
+class LCFunctionStarts final : public LoadCommand {
 public:
   explicit LCFunctionStarts(FunctionStartsSection *functionStartsSection)
       : functionStartsSection(functionStartsSection) {}
 
   uint32_t getSize() const override { return sizeof(linkedit_data_command); }
 
   void writeTo(uint8_t *buf) const override {
     auto *c = reinterpret_cast<linkedit_data_command *>(buf);
     c->cmd = LC_FUNCTION_STARTS;
     c->cmdsize = getSize();
     c->dataoff = functionStartsSection->fileOff;
     c->datasize = functionStartsSection->getFileSize();
   }
 
 private:
   FunctionStartsSection *functionStartsSection;
 };
 
-class LCDysymtab : public LoadCommand {
+class LCDysymtab final : public LoadCommand {
 public:
   LCDysymtab(SymtabSection *symtabSection,
              IndirectSymtabSection *indirectSymtabSection)
       : symtabSection(symtabSection),
         indirectSymtabSection(indirectSymtabSection) {}
 
   uint32_t getSize() const override { return sizeof(dysymtab_command); }
 
void writeTo(uint8_t *buf) const override {
     c->indirectsymoff = indirectSymtabSection->fileOff;
     c->nindirectsyms = indirectSymtabSection->getNumSymbols();
   }
 
   SymtabSection *symtabSection;
   IndirectSymtabSection *indirectSymtabSection;
 };
 
-template <class LP> class LCSegment : public LoadCommand {
+template <class LP> class LCSegment final : public LoadCommand {
 public:
   LCSegment(StringRef name, OutputSegment *seg) : name(name), seg(seg) {}
 
   uint32_t getSize() const override {
     return sizeof(typename LP::segment_command) +
            seg->numNonHiddenSections() * sizeof(typename LP::section);
   }
 
void writeTo(uint8_t *buf) const override {
     }
   }
 
 private:
   StringRef name;
   OutputSegment *seg;
 };
 
-class LCMain : public LoadCommand {
+class LCMain final : public LoadCommand {
   uint32_t getSize() const override {
     return sizeof(structs::entry_point_command);
   }
 
   void writeTo(uint8_t *buf) const override {
     auto *c = reinterpret_cast<structs::entry_point_command *>(buf);
     c->cmd = LC_MAIN;
     c->cmdsize = getSize();
 
     if (config->entry->isInStubs())
       c->entryoff =
           in.stubs->fileOff + config->entry->stubsIndex * target->stubSize;
     else
       c->entryoff = config->entry->getVA() - in.header->addr;
 
     c->stacksize = 0;
   }
 };
 
-class LCSymtab : public LoadCommand {
+class LCSymtab final : public LoadCommand {
 public:
   LCSymtab(SymtabSection *symtabSection, StringTableSection *stringTableSection)
       : symtabSection(symtabSection), stringTableSection(stringTableSection) {}
 
   uint32_t getSize() const override { return sizeof(symtab_command); }
 
   void writeTo(uint8_t *buf) const override {
     auto *c = reinterpret_cast<symtab_command *>(buf);
     c->cmd = LC_SYMTAB;
     c->cmdsize = getSize();
     c->symoff = symtabSection->fileOff;
     c->nsyms = symtabSection->getNumSymbols();
     c->stroff = stringTableSection->fileOff;
     c->strsize = stringTableSection->getFileSize();
   }
 
   SymtabSection *symtabSection = nullptr;
   StringTableSection *stringTableSection = nullptr;
 };
 
 // There are several dylib load commands that share the same structure:
 //   * LC_LOAD_DYLIB
 //   * LC_ID_DYLIB
 //   * LC_REEXPORT_DYLIB
-class LCDylib : public LoadCommand {
+class LCDylib final : public LoadCommand {
 public:
   LCDylib(LoadCommandType type, StringRef path,
           uint32_t compatibilityVersion = 0, uint32_t currentVersion = 0)
       : type(type), path(path), compatibilityVersion(compatibilityVersion),
         currentVersion(currentVersion) {
     instanceCount++;
   }
 
private:
   StringRef path;
   uint32_t compatibilityVersion;
   uint32_t currentVersion;
   static uint32_t instanceCount;
 };
 
 uint32_t LCDylib::instanceCount = 0;
 
-class LCLoadDylinker : public LoadCommand {
+class LCLoadDylinker final : public LoadCommand {
 public:
   uint32_t getSize() const override {
     return alignTo(sizeof(dylinker_command) + path.size() + 1, 8);
   }
 
   void writeTo(uint8_t *buf) const override {
     auto *c = reinterpret_cast<dylinker_command *>(buf);
     buf += sizeof(dylinker_command);
 
     c->cmd = LC_LOAD_DYLINKER;
     c->cmdsize = getSize();
     c->name = sizeof(dylinker_command);
 
     memcpy(buf, path.data(), path.size());
     buf[path.size()] = '\0';
   }
 
 private:
   // Recent versions of Darwin won't run any binary that has dyld at a
   // different location.
   const StringRef path = "/usr/lib/dyld";
 };
 
-class LCRPath : public LoadCommand {
+class LCRPath final : public LoadCommand {
 public:
   explicit LCRPath(StringRef path) : path(path) {}
 
   uint32_t getSize() const override {
     return alignTo(sizeof(rpath_command) + path.size() + 1, target->wordSize);
   }
 
   void writeTo(uint8_t *buf) const override {
     auto *c = reinterpret_cast<rpath_command *>(buf);
     buf += sizeof(rpath_command);
 
     c->cmd = LC_RPATH;
     c->cmdsize = getSize();
     c->path = sizeof(rpath_command);
 
     memcpy(buf, path.data(), path.size());
     buf[path.size()] = '\0';
   }
 
 private:
   StringRef path;
 };
 
-class LCMinVersion : public LoadCommand {
+class LCMinVersion final : public LoadCommand {
 public:
   explicit LCMinVersion(const PlatformInfo &platformInfo)
       : platformInfo(platformInfo) {}
 
   uint32_t getSize() const override { return sizeof(version_min_command); }
 
   void writeTo(uint8_t *buf) const override {
     auto *c = reinterpret_cast<version_min_command *>(buf);
void writeTo(uint8_t *buf) const override {
     c->version = encodeVersion(platformInfo.minimum);
     c->sdk = encodeVersion(platformInfo.sdk);
   }
 
 private:
   const PlatformInfo &platformInfo;
 };
 
-class LCBuildVersion : public LoadCommand {
+class LCBuildVersion final : public LoadCommand {
 public:
   explicit LCBuildVersion(const PlatformInfo &platformInfo)
       : platformInfo(platformInfo) {}
 
   const int ntools = 1;
 
   uint32_t getSize() const override {
     return sizeof(build_version_command) + ntools * sizeof(build_tool_version);

 };
 
 // Stores a unique identifier for the output file based on an MD5 hash of its
 // contents. In order to hash the contents, we must first write them, but
 // LC_UUID itself must be part of the written contents in order for all the
 // offsets to be calculated correctly. We resolve this circular paradox by
 // first writing an LC_UUID with an all-zero UUID, then updating the UUID with
 // its real value later.
-class LCUuid : public LoadCommand {
+class LCUuid final : public LoadCommand {
 public:
   uint32_t getSize() const override { return sizeof(uuid_command); }
 
   void writeTo(uint8_t *buf) const override {
     auto *c = reinterpret_cast<uuid_command *>(buf);
     c->cmd = LC_UUID;
     c->cmdsize = getSize();
     uuidBuf = c->uuid;
void writeUuid(uint64_t digest) const {
     // bad lie we can put here.
     assert((uuidBuf[6] & 0xf0) == 0x30 && "See RFC 4122 Sections 4.2.2, 4.1.3");
     assert((uuidBuf[8] & 0xc0) == 0x80 && "See RFC 4122 Section 4.2.2");
   }
 
   mutable uint8_t *uuidBuf;
 };
 
-template <class LP> class LCEncryptionInfo : public LoadCommand {
+template <class LP> class LCEncryptionInfo final : public LoadCommand {
 public:
   uint32_t getSize() const override {
     return sizeof(typename LP::encryption_info_command);
   }
 
   void writeTo(uint8_t *buf) const override {
     using EncryptionInfo = typename LP::encryption_info_command;
     auto *c = reinterpret_cast<EncryptionInfo *>(buf);
     buf += sizeof(EncryptionInfo);
     c->cmd = LP::encryptionInfoLCType;
     c->cmdsize = getSize();
     c->cryptoff = in.header->getSize();
     auto it = find_if(outputSegments, [](const OutputSegment *seg) {
       return seg->name == segment_names::text;
     });
     assert(it != outputSegments.end());
     c->cryptsize = (*it)->fileSize - c->cryptoff;
   }
 };
 
-class LCCodeSignature : public LoadCommand {
+class LCCodeSignature final : public LoadCommand {
 public:
   LCCodeSignature(CodeSignatureSection *section) : section(section) {}
 
   uint32_t getSize() const override { return sizeof(linkedit_data_command); }
 
   void writeTo(uint8_t *buf) const override {
     auto *c = reinterpret_cast<linkedit_data_command *>(buf);
     c->cmd = LC_CODE_SIGNATURE;