[COFF] De-virtualize Chunk and SectionChunk

[rnk]

Summary

Shaves another pointer off of SectionChunk, reducing the size from 96 to
88 bytes, down from 144 before I started working on this. Combined with
D62356, this reduced peak memory usage when linking chrome_child.dll
from 713MB to 675MB, or 5%. At this point, I declare that I have reached
diminishing returns.

Create NonSectionChunk to provide virtual dispatch to the rest of the
chunk types.

[rnk]

• fix classof bug

[aganea]

lld/COFF/Chunks.h

355 ↗

(On Diff #201109)

This is back to the future! C with manual vtables :) 64-bit pointers are a big problem for space. It'd be nice if we could optionally have 32-bit or even 16-bit pointers (yes it opens the door to other issues, but that could be catched with sanitizers or assertions). In many cases we pool objects of a given type or a given class hierarchy, so they are quite close to each other - having an option to copy the vtable close to the allocated pool would be nice to alleviate for issues like this. A 16-bit index would be more that enough in that case, in place of the 64-bit vtable.

377 ↗

(On Diff #201109)

Since you're doing this, I'm just wondering if the behavior for isHotPatchable shouldn't all be here? I find there's value having all related code together. Maybe there are other cases for the other "virtual-ish" functions below.

inline bool Chunk::isHotPatchable() const {
  if (ChunkKind == SectionKind)
    return File->HotPatchable;
  return ChunkKind  == ImportThunk; // add ImportThunk kind
}

[rnk]

lld/COFF/Chunks.h

355 ↗

(On Diff #201109)

Definitely, back to the future. :) I actually did this before for the LLVM IR Value / Instruction class hierarchy:
https://github.com/llvm/llvm-project/blob/308e82ecebeef1342004637db9fdf11567a299b3/llvm/lib/IR/Value.cpp#L98
https://github.com/llvm/llvm-project/blob/308e82ecebeef1342004637db9fdf11567a299b3/llvm/lib/IR/Instruction.cpp#L654
There we have an almost completely closed type hierarchy, so all cases are enumerated in a switch, but here in LLD, some Chunks are defined in files, and we'd first have to give enums to them all. We surely don't need more than 256 Chunk types, so a byte is enough.

377 ↗

(On Diff #201109)

I think the way to go is to make this change, and then tackle the remaining virtual methods one by one. This patch replaces the hasData() virtual method with the HasData bit, and there are a number of other methods here that could probably use the same treatment.

Initially I tried to lift section Characteristics up into Chunk in the first version of this patch, but it didn't work out, and I backed it out. I put the P2Align data in to Characteristics and had all the Chunk subtypes simply set their Characteristics in the constructor, but I needed another byte for the ChunkKind, or at least a bit to indicate SectionChunk vs. NonSectionChunk. I couldn't get the data packed in right without doing more unrelated rearrangements, so I left it for later.

[rnk]

lld/COFF/Chunks.h

377 ↗

(On Diff #201109)

This suggested change became D62422.

[ruiu]

LGTM

COFF/Chunks.h

 //===- Chunks.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_COFF_CHUNKS_H
 #define LLD_COFF_CHUNKS_H
 
 #include "Config.h"
 #include "InputFiles.h"
 #include "lld/Common/LLVM.h"
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/iterator.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/MC/StringTableBuilder.h"
 #include "llvm/Object/COFF.h"
 #include <utility>
 #include <vector>
 
 namespace lld {

 // A Chunk represents a chunk of data that will occupy space in the
 // output (if the resolver chose that). It may or may not be backed by
 // a section of an input file. It could be linker-created data, or
 // doesn't even have actual data (if common or bss).
 class Chunk {
 public:
   enum Kind : uint8_t { SectionKind, OtherKind };
   Kind kind() const { return ChunkKind; }
-  virtual ~Chunk() = default;
 
   // Returns the size of this chunk (even if this is a common or BSS.)
-  virtual size_t getSize() const = 0;
+  size_t getSize() const;
 
   // Returns chunk alignment in power of two form. Value values are powers of
   // two from 1 to 8192.
   uint32_t getAlignment() const { return 1U << P2Align; }
+
+  // Update the chunk section alignment measured in bytes. Internally alignment
+  // is stored in log2.
   void setAlignment(uint32_t Align) {
     // Treat zero byte alignment as 1 byte alignment.
     Align = Align ? Align : 1;
     assert(llvm::isPowerOf2_32(Align) && "alignment is not a power of 2");
     P2Align = llvm::Log2_32(Align);
     assert(P2Align <= Log2MaxSectionAlignment &&
            "impossible requested alignment");
   }
 
   // Write this chunk to a mmap'ed file, assuming Buf is pointing to
   // beginning of the file. Because this function may use RVA values
   // of other chunks for relocations, you need to set them properly
   // before calling this function.
-  virtual void writeTo(uint8_t *Buf) const {}
+  void writeTo(uint8_t *Buf) const;
 
   // The writer sets and uses the addresses. In practice, PE images cannot be
   // larger than 2GB. Chunks are always laid as part of the image, so Chunk RVAs
   // can be stored with 32 bits.
   uint32_t getRVA() const { return RVA; }
   void setRVA(uint64_t V) {
     RVA = (uint32_t)V;
     assert(RVA == V && "RVA truncated");
   }
 
   // Returns true if this has non-zero data. BSS chunks return
   // false. If false is returned, the space occupied by this chunk
   // will be filled with zeros.
-  virtual bool hasData() const { return true; }
+  bool hasData() const { return HasData; }
 
   // Returns readable/writable/executable bits.
-  virtual uint32_t getOutputCharacteristics() const { return 0; }
+  uint32_t getOutputCharacteristics() const;
 
   // Returns the section name if this is a section chunk.
   // It is illegal to call this function on non-section chunks.
-  virtual StringRef getSectionName() const {
-    llvm_unreachable("unimplemented getSectionName");
-  }
+  StringRef getSectionName() const;
 
   // An output section has pointers to chunks in the section, and each
   // chunk has a back pointer to an output section.
   void setOutputSectionIdx(uint16_t O) { OSIdx = O; }
   uint16_t getOutputSectionIdx() const { return OSIdx; }
   OutputSection *getOutputSection() const;
 
   // Windows-specific.
   // Collect all locations that contain absolute addresses for base relocations.
-  virtual void getBaserels(std::vector<Baserel> *Res) {}
+  void getBaserels(std::vector<Baserel> *Res);
 
   // Returns a human-readable name of this chunk. Chunks are unnamed chunks of
   // bytes, so this is used only for logging or debugging.
-  virtual StringRef getDebugName() { return ""; }
+  StringRef getDebugName() const;
 
-  virtual bool isHotPatchable() const { return false; }
+  // Return true if this file has the hotpatch flag set to true in the
+  // S_COMPILE3 record in codeview debug info. Also returns true for some thunks
+  // synthesized by the linker.
+  bool isHotPatchable() const;
 
 protected:
-  Chunk(Kind K = OtherKind) : ChunkKind(K) {}
+  Chunk(Kind K = OtherKind) : ChunkKind(K), HasData(true), P2Align(0) {}
 
   const Kind ChunkKind;
 
+  // True if the section has data. Corresponds to the
+  // IMAGE_SCN_CNT_UNINITIALIZED_DATA section characteristic bit.
+  uint8_t HasData : 1;
+
   // The alignment of this chunk, stored in log2 form. The writer uses the
   // value.
-  uint8_t P2Align = 0;
+  uint8_t P2Align : 7;
 
   // The output section index for this chunk. The first valid section number is
   // one.
   uint16_t OSIdx = 0;
 
   // The RVA of this chunk in the output. The writer sets a value.
   uint32_t RVA = 0;
 };
 
+class NonSectionChunk : public Chunk {
+public:
+  virtual ~NonSectionChunk() = default;
+
+  // Returns the size of this chunk (even if this is a common or BSS.)
+  virtual size_t getSize() const = 0;
+
+  virtual uint32_t getOutputCharacteristics() const { return 0; }
+
+  // Write this chunk to a mmap'ed file, assuming Buf is pointing to
+  // beginning of the file. Because this function may use RVA values
+  // of other chunks for relocations, you need to set them properly
+  // before calling this function.
+  virtual void writeTo(uint8_t *Buf) const {}
+
+  // Returns the section name if this is a section chunk.
+  // It is illegal to call this function on non-section chunks.
+  virtual StringRef getSectionName() const {
+    llvm_unreachable("unimplemented getSectionName");
+  }
+
+  // Windows-specific.
+  // Collect all locations that contain absolute addresses for base relocations.
+  virtual void getBaserels(std::vector<Baserel> *Res) {}
+
+  // Return true if this file has the hotpatch flag set to true in the
+  // S_COMPILE3 record in codeview debug info. Also returns true for some thunks
+  // synthesized by the linker.
+  virtual bool isHotPatchable() const { return false; }
+
+  // Returns a human-readable name of this chunk. Chunks are unnamed chunks of
+  // bytes, so this is used only for logging or debugging.
+  virtual StringRef getDebugName() const { return ""; }
+
+  static bool classof(const Chunk *C) { return C->kind() == OtherKind; }
+
+protected:
+  NonSectionChunk() : Chunk(OtherKind) {}
+};
+
 // A chunk corresponding a section of an input file.
 class SectionChunk final : public Chunk {
   // Identical COMDAT Folding feature accesses section internal data.
   friend class ICF;
 
 public:
   class symbol_iterator : public llvm::iterator_adaptor_base<
                               symbol_iterator, const coff_relocation *,
                               std::random_access_iterator_tag, Symbol *> {
     friend SectionChunk;
 
     ObjFile *File;
 
     symbol_iterator(ObjFile *File, const coff_relocation *I)
         : symbol_iterator::iterator_adaptor_base(I), File(File) {}
 
   public:
     symbol_iterator() = default;
 
     Symbol *operator*() const { return File->getSymbol(I->SymbolTableIndex); }
   };
 
   SectionChunk(ObjFile *File, const coff_section *Header);
   static bool classof(const Chunk *C) { return C->kind() == SectionKind; }
-  size_t getSize() const override { return Header->SizeOfRawData; }
+  size_t getSize() const { return Header->SizeOfRawData; }
   ArrayRef<uint8_t> getContents() const;
-  void writeTo(uint8_t *Buf) const override;
-  bool hasData() const override;
-  uint32_t getOutputCharacteristics() const override;
-  StringRef getSectionName() const override {
+  void writeTo(uint8_t *Buf) const;
+
+  uint32_t getOutputCharacteristics() const {
+    return Header->Characteristics & (PermMask | TypeMask);
+  }
+  StringRef getSectionName() const {
     return StringRef(SectionNameData, SectionNameSize);
   }
-  void getBaserels(std::vector<Baserel> *Res) override;
+  void getBaserels(std::vector<Baserel> *Res);
   bool isCOMDAT() const;
   void applyRelX64(uint8_t *Off, uint16_t Type, OutputSection *OS, uint64_t S,
                    uint64_t P) const;
   void applyRelX86(uint8_t *Off, uint16_t Type, OutputSection *OS, uint64_t S,
                    uint64_t P) const;
   void applyRelARM(uint8_t *Off, uint16_t Type, OutputSection *OS, uint64_t S,
                    uint64_t P) const;
   void applyRelARM64(uint8_t *Off, uint16_t Type, OutputSection *OS, uint64_t S,
                      uint64_t P) const;
 
   void getRuntimePseudoRelocs(std::vector<RuntimePseudoReloc> &Res);
 
   // Called if the garbage collector decides to not include this chunk
   // in a final output. It's supposed to print out a log message to stdout.
   void printDiscardedMessage() const;
 
   // Adds COMDAT associative sections to this COMDAT section. A chunk
   // and its children are treated as a group by the garbage collector.
   void addAssociative(SectionChunk *Child);
 
-  StringRef getDebugName() override;
+  StringRef getDebugName() const;
 
   // True if this is a codeview debug info chunk. These will not be laid out in
   // the image. Instead they will end up in the PDB, if one is requested.
   bool isCodeView() const {
     return getSectionName() == ".debug" || getSectionName().startswith(".debug$");
   }
 
   // True if this is a DWARF debug info or exception handling chunk.
   bool isDWARF() const {
     return getSectionName().startswith(".debug_") || getSectionName() == ".eh_frame";
   }
 
+  bool isHotPatchable() const { return File->HotPatchable; }
+
   // Allow iteration over the bodies of this chunk's relocated symbols.
   llvm::iterator_range<symbol_iterator> symbols() const {
     return llvm::make_range(symbol_iterator(File, RelocsData),
                             symbol_iterator(File, RelocsData + RelocsSize));
   }
 
   ArrayRef<coff_relocation> getRelocs() const {
     return llvm::makeArrayRef(RelocsData, RelocsSize);
public:
   ArrayRef<uint8_t> consumeDebugMagic();
 
   static ArrayRef<uint8_t> consumeDebugMagic(ArrayRef<uint8_t> Data,
                                              StringRef SectionName);
 
   static SectionChunk *findByName(ArrayRef<SectionChunk *> Sections,
                                   StringRef Name);
 
-  bool isHotPatchable() const override { return File->HotPatchable; }
-
   // The file that this chunk was created from.
   ObjFile *File;
 
   // Pointer to the COFF section header in the input file.
   const coff_section *Header;
 
   // The COMDAT leader symbol if this is a COMDAT chunk.
   DefinedRegular *Sym = nullptr;
private:
 
   // Section name string. Size is stored below.
   const char *SectionNameData;
 
   uint32_t RelocsSize = 0;
   uint32_t SectionNameSize = 0;
 };
 
+// Inline methods to implement faux-virtual dispatch for SectionChunk.
+
+inline size_t Chunk::getSize() const {
+  if (isa<SectionChunk>(this))
+    return static_cast<const SectionChunk *>(this)->getSize();
+  else
+    return static_cast<const NonSectionChunk *>(this)->getSize();
+}
+
+inline uint32_t Chunk::getOutputCharacteristics() const {
+  if (isa<SectionChunk>(this))
+    return static_cast<const SectionChunk *>(this)->getOutputCharacteristics();
+  else
+    return static_cast<const NonSectionChunk *>(this)
+        ->getOutputCharacteristics();
+}
+
+inline void Chunk::writeTo(uint8_t *Buf) const {
+  if (isa<SectionChunk>(this))
+    static_cast<const SectionChunk *>(this)->writeTo(Buf);
+  else
+    static_cast<const NonSectionChunk *>(this)->writeTo(Buf);
+}
+
+inline bool Chunk::isHotPatchable() const {
+  if (isa<SectionChunk>(this))
+    return static_cast<const SectionChunk *>(this)->isHotPatchable();
+  else
+    return static_cast<const NonSectionChunk *>(this)->isHotPatchable();
+}
+
+inline StringRef Chunk::getSectionName() const {
+  if (isa<SectionChunk>(this))
+    return static_cast<const SectionChunk *>(this)->getSectionName();
+  else
+    return static_cast<const NonSectionChunk *>(this)->getSectionName();
+}
+
+inline void Chunk::getBaserels(std::vector<Baserel> *Res) {
+  if (isa<SectionChunk>(this))
+    static_cast<SectionChunk *>(this)->getBaserels(Res);
+  else
+    static_cast<NonSectionChunk *>(this)->getBaserels(Res);
+}
+
+inline StringRef Chunk::getDebugName() const {
+  if (isa<SectionChunk>(this))
+    return static_cast<const SectionChunk *>(this)->getDebugName();
+  else
+    return static_cast<const NonSectionChunk *>(this)->getDebugName();
+}
+
 // This class is used to implement an lld-specific feature (not implemented in
 // MSVC) that minimizes the output size by finding string literals sharing tail
 // parts and merging them.
 //
 // If string tail merging is enabled and a section is identified as containing a
 // string literal, it is added to a MergeChunk with an appropriate alignment.
 // The MergeChunk then tail merges the strings using the StringTableBuilder
 // class and assigns RVAs and section offsets to each of the member chunks based
 // on the offsets assigned by the StringTableBuilder.
-class MergeChunk : public Chunk {
+class MergeChunk : public NonSectionChunk {
 public:
   MergeChunk(uint32_t Alignment);
   static void addSection(SectionChunk *C);
   void finalizeContents();
   void assignSubsectionRVAs();
 
   uint32_t getOutputCharacteristics() const override;
   StringRef getSectionName() const override { return ".rdata"; }
   size_t getSize() const override;
   void writeTo(uint8_t *Buf) const override;
 
   static MergeChunk *Instances[Log2MaxSectionAlignment + 1];
   std::vector<SectionChunk *> Sections;
 
 private:
   llvm::StringTableBuilder Builder;
   bool Finalized = false;
 };
 
 // A chunk for common symbols. Common chunks don't have actual data.
-class CommonChunk : public Chunk {
+class CommonChunk : public NonSectionChunk {
 public:
   CommonChunk(const COFFSymbolRef Sym);
   size_t getSize() const override { return Sym.getValue(); }
-  bool hasData() const override { return false; }
   uint32_t getOutputCharacteristics() const override;
   StringRef getSectionName() const override { return ".bss"; }
 
 private:
   const COFFSymbolRef Sym;
 };
 
 // A chunk for linker-created strings.
-class StringChunk : public Chunk {
+class StringChunk : public NonSectionChunk {
 public:
   explicit StringChunk(StringRef S) : Str(S) {}
   size_t getSize() const override { return Str.size() + 1; }
   void writeTo(uint8_t *Buf) const override;
 
 private:
   StringRef Str;
 };
static const uint8_t ImportThunkARM64[] = {
     0x10, 0x00, 0x00, 0x90, // adrp x16, #0
     0x10, 0x02, 0x40, 0xf9, // ldr  x16, [x16]
     0x00, 0x02, 0x1f, 0xd6, // br   x16
 };
 
 // Windows-specific.
 // A chunk for DLL import jump table entry. In a final output, its
 // contents will be a JMP instruction to some __imp_ symbol.
-class ImportThunkChunkX64 : public Chunk {
+class ImportThunkChunkX64 : public NonSectionChunk {
 public:
   explicit ImportThunkChunkX64(Defined *S);
   size_t getSize() const override { return sizeof(ImportThunkX86); }
   void writeTo(uint8_t *Buf) const override;
 
   bool isHotPatchable() const override { return true; }
 
 private:
   Defined *ImpSymbol;
 };
 
-class ImportThunkChunkX86 : public Chunk {
+class ImportThunkChunkX86 : public NonSectionChunk {
 public:
-  explicit ImportThunkChunkX86(Defined *S) : ImpSymbol(S) {}
+  explicit ImportThunkChunkX86(Defined *S) : ImpSymbol(S) {
+  }
   size_t getSize() const override { return sizeof(ImportThunkX86); }
   void getBaserels(std::vector<Baserel> *Res) override;
   void writeTo(uint8_t *Buf) const override;
 
   bool isHotPatchable() const override { return true; }
 
 private:
   Defined *ImpSymbol;
 };
 
-class ImportThunkChunkARM : public Chunk {
+class ImportThunkChunkARM : public NonSectionChunk {
 public:
-  explicit ImportThunkChunkARM(Defined *S) : ImpSymbol(S) {}
+  explicit ImportThunkChunkARM(Defined *S) : ImpSymbol(S) {
+  }
   size_t getSize() const override { return sizeof(ImportThunkARM); }
   void getBaserels(std::vector<Baserel> *Res) override;
   void writeTo(uint8_t *Buf) const override;
 
   bool isHotPatchable() const override { return true; }
 
 private:
   Defined *ImpSymbol;
 };
 
-class ImportThunkChunkARM64 : public Chunk {
+class ImportThunkChunkARM64 : public NonSectionChunk {
 public:
-  explicit ImportThunkChunkARM64(Defined *S) : ImpSymbol(S) {}
+  explicit ImportThunkChunkARM64(Defined *S) : ImpSymbol(S) {
+  }
   size_t getSize() const override { return sizeof(ImportThunkARM64); }
   void writeTo(uint8_t *Buf) const override;
 
   bool isHotPatchable() const override { return true; }
 
 private:
   Defined *ImpSymbol;
 };
 
-class RangeExtensionThunkARM : public Chunk {
+class RangeExtensionThunkARM : public NonSectionChunk {
 public:
   explicit RangeExtensionThunkARM(Defined *T) : Target(T) {}
   size_t getSize() const override;
   void writeTo(uint8_t *Buf) const override;
 
   Defined *Target;
 };
 
-class RangeExtensionThunkARM64 : public Chunk {
+class RangeExtensionThunkARM64 : public NonSectionChunk {
 public:
   explicit RangeExtensionThunkARM64(Defined *T) : Target(T) {}
   size_t getSize() const override;
   void writeTo(uint8_t *Buf) const override;
 
   Defined *Target;
 };
 
 // Windows-specific.
 // See comments for DefinedLocalImport class.
-class LocalImportChunk : public Chunk {
+class LocalImportChunk : public NonSectionChunk {
 public:
   explicit LocalImportChunk(Defined *S) : Sym(S) {
     setAlignment(Config->Wordsize);
   }
   size_t getSize() const override;
   void getBaserels(std::vector<Baserel> *Res) override;
   void writeTo(uint8_t *Buf) const override;
 
static bool isEqual(const ChunkAndOffset &LHS, const ChunkAndOffset &RHS) {
       return LHS.InputChunk == RHS.InputChunk && LHS.Offset == RHS.Offset;
     }
   };
 };
 
 using SymbolRVASet = llvm::DenseSet<ChunkAndOffset>;
 
 // Table which contains symbol RVAs. Used for /safeseh and /guard:cf.
-class RVATableChunk : public Chunk {
+class RVATableChunk : public NonSectionChunk {
 public:
   explicit RVATableChunk(SymbolRVASet S) : Syms(std::move(S)) {}
   size_t getSize() const override { return Syms.size() * 4; }
   void writeTo(uint8_t *Buf) const override;
 
 private:
   SymbolRVASet Syms;
 };
 
 // Windows-specific.
 // This class represents a block in .reloc section.
 // See the PE/COFF spec 5.6 for details.
-class BaserelChunk : public Chunk {
+class BaserelChunk : public NonSectionChunk {
 public:
   BaserelChunk(uint32_t Page, Baserel *Begin, Baserel *End);
   size_t getSize() const override { return Data.size(); }
   void writeTo(uint8_t *Buf) const override;
 
 private:
   std::vector<uint8_t> Data;
 };
 
 class Baserel {
 public:
   Baserel(uint32_t V, uint8_t Ty) : RVA(V), Type(Ty) {}
   explicit Baserel(uint32_t V) : Baserel(V, getDefaultType()) {}
   uint8_t getDefaultType();
 
   uint32_t RVA;
   uint8_t Type;
 };
 
 // This is a placeholder Chunk, to allow attaching a DefinedSynthetic to a
 // specific place in a section, without any data. This is used for the MinGW
 // specific symbol __RUNTIME_PSEUDO_RELOC_LIST_END__, even though the concept
 // of an empty chunk isn't MinGW specific.
-class EmptyChunk : public Chunk {
+class EmptyChunk : public NonSectionChunk {
 public:
   EmptyChunk() {}
   size_t getSize() const override { return 0; }
   void writeTo(uint8_t *Buf) const override {}
 };
 
 // MinGW specific, for the "automatic import of variables from DLLs" feature.
 // This provides the table of runtime pseudo relocations, for variable
 // references that turned out to need to be imported from a DLL even though
 // the reference didn't use the dllimport attribute. The MinGW runtime will
 // process this table after loading, before handling control over to user
 // code.
-class PseudoRelocTableChunk : public Chunk {
+class PseudoRelocTableChunk : public NonSectionChunk {
 public:
   PseudoRelocTableChunk(std::vector<RuntimePseudoReloc> &Relocs)
       : Relocs(std::move(Relocs)) {
     setAlignment(4);
   }
   size_t getSize() const override;
   void writeTo(uint8_t *Buf) const override;
 
public:
   SectionChunk *Target;
   uint32_t TargetOffset;
   // The Flags field contains the size of the relocation, in bits. No other
   // flags are currently defined.
   int Flags;
 };
 
 // MinGW specific. A Chunk that contains one pointer-sized absolute value.
-class AbsolutePointerChunk : public Chunk {
+class AbsolutePointerChunk : public NonSectionChunk {
 public:
   AbsolutePointerChunk(uint64_t Value) : Value(Value) {
     setAlignment(getSize());
   }
   size_t getSize() const override;
   void writeTo(uint8_t *Buf) const override;
 
 private:

COFF/Chunks.cpp

SectionChunk::SectionChunk(ObjFile *F, const coff_section *H)
   StringRef SectionName;
   if (Expected<StringRef> E = File->getCOFFObj()->getSectionName(Header))
     SectionName = *E;
   SectionNameData = SectionName.data();
   SectionNameSize = SectionName.size();
 
   setAlignment(Header->getAlignment());
 
+  HasData = !(Header->Characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA);
+
   // If linker GC is disabled, every chunk starts out alive.  If linker GC is
   // enabled, treat non-comdat sections as roots. Generally optimized object
   // files will be built with -ffunction-sections or /Gy, so most things worth
   // stripping will be in a comdat.
   Live = !Config->DoGC || !isCOMDAT();
 }
 
 // SectionChunk is one of the most frequently allocated classes, so it is
 // important to keep it as compact as possible. As of this writing, the number
 // below is the size of this class on x64 platforms.
-static_assert(sizeof(SectionChunk) <= 96, "SectionChunk grew unexpectedly");
+static_assert(sizeof(SectionChunk) <= 88, "SectionChunk grew unexpectedly");
 
 static void add16(uint8_t *P, int16_t V) { write16le(P, read16le(P) + V); }
 static void add32(uint8_t *P, int32_t V) { write32le(P, read32le(P) + V); }
 static void add64(uint8_t *P, int64_t V) { write64le(P, read64le(P) + V); }
 static void or16(uint8_t *P, uint16_t V) { write16le(P, read16le(P) | V); }
 static void or32(uint8_t *P, uint32_t V) { write32le(P, read32le(P) | V); }
 
 // Verify that given sections are appropriate targets for SECREL
for (const coff_relocation &Rel : getRelocs()) {
     }
     // SizeInBits is used to initialize the Flags field; currently no
     // other flags are defined.
     Res.emplace_back(
         RuntimePseudoReloc(Target, this, Rel.VirtualAddress, SizeInBits));
   }
 }
 
-bool SectionChunk::hasData() const {
-  return !(Header->Characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA);
-}
-
-uint32_t SectionChunk::getOutputCharacteristics() const {
-  return Header->Characteristics & (PermMask | TypeMask);
-}
-
 bool SectionChunk::isCOMDAT() const {
   return Header->Characteristics & IMAGE_SCN_LNK_COMDAT;
 }
 
 void SectionChunk::printDiscardedMessage() const {
   // Removed by dead-stripping. If it's removed by ICF, ICF already
   // printed out the name, so don't repeat that here.
   if (Sym && this == Repl)
     message("Discarded " + Sym->getName());
 }
 
-StringRef SectionChunk::getDebugName() {
+StringRef SectionChunk::getDebugName() const {
   if (Sym)
     return Sym->getName();
   return "";
 }
 
 ArrayRef<uint8_t> SectionChunk::getContents() const {
   ArrayRef<uint8_t> A;
   cantFail(File->getCOFFObj()->getSectionContents(Header, A));
uint32_t SectionChunk::getSectionNumber() const {
   return S.getIndex() + 1;
 }
 
 CommonChunk::CommonChunk(const COFFSymbolRef S) : Sym(S) {
   // The value of a common symbol is its size. Align all common symbols smaller
   // than 32 bytes naturally, i.e. round the size up to the next power of two.
   // This is what MSVC link.exe does.
   setAlignment(std::min(32U, uint32_t(PowerOf2Ceil(Sym.getValue()))));
+  HasData = false;
 }
 
 uint32_t CommonChunk::getOutputCharacteristics() const {
   return IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_MEM_READ |
          IMAGE_SCN_MEM_WRITE;
 }
 
 void StringChunk::writeTo(uint8_t *Buf) const {
uint8_t Baserel::getDefaultType() {
   default:
     llvm_unreachable("unknown machine type");
   }
 }
 
 MergeChunk *MergeChunk::Instances[Log2MaxSectionAlignment + 1] = {};
 
 MergeChunk::MergeChunk(uint32_t Alignment)
-    : Chunk(OtherKind), Builder(StringTableBuilder::RAW, Alignment) {
+    : Builder(StringTableBuilder::RAW, Alignment) {
   setAlignment(Alignment);
 }
 
 void MergeChunk::addSection(SectionChunk *C) {
   assert(isPowerOf2_32(C->getAlignment()));
   uint8_t P2Align = llvm::Log2_32(C->getAlignment());
   assert(P2Align >= 0 && P2Align < array_lengthof(Instances));
   auto *&MC = Instances[P2Align];

COFF/DLL.cpp

 
 namespace lld {
 namespace coff {
 namespace {
 
 // Import table
 
 // A chunk for the import descriptor table.
-class HintNameChunk : public Chunk {
+class HintNameChunk : public NonSectionChunk {
 public:
   HintNameChunk(StringRef N, uint16_t H) : Name(N), Hint(H) {}
 
   size_t getSize() const override {
     // Starts with 2 byte Hint field, followed by a null-terminated string,
     // ends with 0 or 1 byte padding.
     return alignTo(Name.size() + 3, 2);
   }
 
   void writeTo(uint8_t *Buf) const override {
     memset(Buf, 0, getSize());
     write16le(Buf, Hint);
     memcpy(Buf + 2, Name.data(), Name.size());
   }
 
 private:
   StringRef Name;
   uint16_t Hint;
 };
 
 // A chunk for the import descriptor table.
-class LookupChunk : public Chunk {
+class LookupChunk : public NonSectionChunk {
 public:
   explicit LookupChunk(Chunk *C) : HintName(C) {
     setAlignment(Config->Wordsize);
   }
   size_t getSize() const override { return Config->Wordsize; }
 
   void writeTo(uint8_t *Buf) const override {
     if (Config->is64())
       write64le(Buf, HintName->getRVA());
     else
       write32le(Buf, HintName->getRVA());
   }
 
   Chunk *HintName;
 };
 
 // A chunk for the import descriptor table.
 // This chunk represent import-by-ordinal symbols.
 // See Microsoft PE/COFF spec 7.1. Import Header for details.
-class OrdinalOnlyChunk : public Chunk {
+class OrdinalOnlyChunk : public NonSectionChunk {
 public:
   explicit OrdinalOnlyChunk(uint16_t V) : Ordinal(V) {
     setAlignment(Config->Wordsize);
   }
   size_t getSize() const override { return Config->Wordsize; }
 
   void writeTo(uint8_t *Buf) const override {
     // An import-by-ordinal slot has MSB 1 to indicate that
     // this is import-by-ordinal (and not import-by-name).
     if (Config->is64()) {
       write64le(Buf, (1ULL << 63) | Ordinal);
     } else {
       write32le(Buf, (1ULL << 31) | Ordinal);
     }
   }
 
   uint16_t Ordinal;
 };
 
 // A chunk for the import descriptor table.
-class ImportDirectoryChunk : public Chunk {
+class ImportDirectoryChunk : public NonSectionChunk {
 public:
   explicit ImportDirectoryChunk(Chunk *N) : DLLName(N) {}
   size_t getSize() const override { return sizeof(ImportDirectoryTableEntry); }
 
   void writeTo(uint8_t *Buf) const override {
     memset(Buf, 0, getSize());
 
     auto *E = (coff_import_directory_table_entry *)(Buf);
     E->ImportLookupTableRVA = LookupTab->getRVA();
     E->NameRVA = DLLName->getRVA();
     E->ImportAddressTableRVA = AddressTab->getRVA();
   }
 
   Chunk *DLLName;
   Chunk *LookupTab;
   Chunk *AddressTab;
 };
 
 // A chunk representing null terminator in the import table.
 // Contents of this chunk is always null bytes.
-class NullChunk : public Chunk {
+class NullChunk : public NonSectionChunk {
 public:
-  explicit NullChunk(size_t N) : Size(N) {}
-  bool hasData() const override { return false; }
+  explicit NullChunk(size_t N) : Size(N) { HasData = false; }
   size_t getSize() const override { return Size; }
 
   void writeTo(uint8_t *Buf) const override {
     memset(Buf, 0, Size);
   }
 
 private:
   size_t Size;
binImports(const std::vector<DefinedImportData *> &Imports) {
   }
   return V;
 }
 
 // Export table
 // See Microsoft PE/COFF spec 4.3 for details.
 
 // A chunk for the delay import descriptor table etnry.
-class DelayDirectoryChunk : public Chunk {
+class DelayDirectoryChunk : public NonSectionChunk {
 public:
   explicit DelayDirectoryChunk(Chunk *N) : DLLName(N) {}
 
   size_t getSize() const override {
     return sizeof(delay_import_directory_table_entry);
   }
 
   void writeTo(uint8_t *Buf) const override {
static const uint8_t ThunkARM64[] = {
     0xe4, 0x17, 0x43, 0xa9, // ldp     x4, x5, [sp, #48]
     0xe2, 0x0f, 0x42, 0xa9, // ldp     x2, x3, [sp, #32]
     0xe0, 0x07, 0x41, 0xa9, // ldp     x0, x1, [sp, #16]
     0xfd, 0x7b, 0xcd, 0xa8, // ldp     x29, x30, [sp], #208
     0x00, 0x02, 0x1f, 0xd6, // br      x16
 };
 
 // A chunk for the delay import thunk.
-class ThunkChunkX64 : public Chunk {
+class ThunkChunkX64 : public NonSectionChunk {
 public:
   ThunkChunkX64(Defined *I, Chunk *D, Defined *H)
       : Imp(I), Desc(D), Helper(H) {}
 
   size_t getSize() const override { return sizeof(ThunkX64); }
 
   void writeTo(uint8_t *Buf) const override {
     memcpy(Buf, ThunkX64, sizeof(ThunkX64));
     write32le(Buf + 36, Imp->getRVA() - RVA - 40);
     write32le(Buf + 43, Desc->getRVA() - RVA - 47);
     write32le(Buf + 48, Helper->getRVA() - RVA - 52);
   }
 
   Defined *Imp = nullptr;
   Chunk *Desc = nullptr;
   Defined *Helper = nullptr;
 };
 
-class ThunkChunkX86 : public Chunk {
+class ThunkChunkX86 : public NonSectionChunk {
 public:
   ThunkChunkX86(Defined *I, Chunk *D, Defined *H)
       : Imp(I), Desc(D), Helper(H) {}
 
   size_t getSize() const override { return sizeof(ThunkX86); }
 
   void writeTo(uint8_t *Buf) const override {
     memcpy(Buf, ThunkX86, sizeof(ThunkX86));
     write32le(Buf + 3, Imp->getRVA() + Config->ImageBase);
     write32le(Buf + 8, Desc->getRVA() + Config->ImageBase);
     write32le(Buf + 13, Helper->getRVA() - RVA - 17);
   }
 
   void getBaserels(std::vector<Baserel> *Res) override {
     Res->emplace_back(RVA + 3);
     Res->emplace_back(RVA + 8);
   }
 
   Defined *Imp = nullptr;
   Chunk *Desc = nullptr;
   Defined *Helper = nullptr;
 };
 
-class ThunkChunkARM : public Chunk {
+class ThunkChunkARM : public NonSectionChunk {
 public:
   ThunkChunkARM(Defined *I, Chunk *D, Defined *H)
       : Imp(I), Desc(D), Helper(H) {}
 
   size_t getSize() const override { return sizeof(ThunkARM); }
 
   void writeTo(uint8_t *Buf) const override {
     memcpy(Buf, ThunkARM, sizeof(ThunkARM));
     applyMOV32T(Buf + 0, Imp->getRVA() + Config->ImageBase);
     applyMOV32T(Buf + 22, Desc->getRVA() + Config->ImageBase);
     applyBranch24T(Buf + 30, Helper->getRVA() - RVA - 34);
   }
 
   void getBaserels(std::vector<Baserel> *Res) override {
     Res->emplace_back(RVA + 0, IMAGE_REL_BASED_ARM_MOV32T);
     Res->emplace_back(RVA + 22, IMAGE_REL_BASED_ARM_MOV32T);
   }
 
   Defined *Imp = nullptr;
   Chunk *Desc = nullptr;
   Defined *Helper = nullptr;
 };
 
-class ThunkChunkARM64 : public Chunk {
+class ThunkChunkARM64 : public NonSectionChunk {
 public:
   ThunkChunkARM64(Defined *I, Chunk *D, Defined *H)
       : Imp(I), Desc(D), Helper(H) {}
 
   size_t getSize() const override { return sizeof(ThunkARM64); }
 
   void writeTo(uint8_t *Buf) const override {
     memcpy(Buf, ThunkARM64, sizeof(ThunkARM64));
     applyArm64Addr(Buf + 0, Imp->getRVA(), RVA + 0, 12);
     applyArm64Imm(Buf + 4, Imp->getRVA() & 0xfff, 0);
     applyArm64Addr(Buf + 52, Desc->getRVA(), RVA + 52, 12);
     applyArm64Imm(Buf + 56, Desc->getRVA() & 0xfff, 0);
     applyArm64Branch26(Buf + 60, Helper->getRVA() - RVA - 60);
   }
 
   Defined *Imp = nullptr;
   Chunk *Desc = nullptr;
   Defined *Helper = nullptr;
 };
 
 // A chunk for the import descriptor table.
-class DelayAddressChunk : public Chunk {
+class DelayAddressChunk : public NonSectionChunk {
 public:
   explicit DelayAddressChunk(Chunk *C) : Thunk(C) {
     setAlignment(Config->Wordsize);
   }
   size_t getSize() const override { return Config->Wordsize; }
 
   void writeTo(uint8_t *Buf) const override {
     if (Config->is64()) {
public:
 
   Chunk *Thunk;
 };
 
 // Export table
 // Read Microsoft PE/COFF spec 5.3 for details.
 
 // A chunk for the export descriptor table.
-class ExportDirectoryChunk : public Chunk {
+class ExportDirectoryChunk : public NonSectionChunk {
 public:
   ExportDirectoryChunk(int I, int J, Chunk *D, Chunk *A, Chunk *N, Chunk *O)
       : MaxOrdinal(I), NameTabSize(J), DLLName(D), AddressTab(A), NameTab(N),
         OrdinalTab(O) {}
 
   size_t getSize() const override {
     return sizeof(export_directory_table_entry);
   }
public:
   uint16_t MaxOrdinal;
   uint16_t NameTabSize;
   Chunk *DLLName;
   Chunk *AddressTab;
   Chunk *NameTab;
   Chunk *OrdinalTab;
 };
 
-class AddressTableChunk : public Chunk {
+class AddressTableChunk : public NonSectionChunk {
 public:
   explicit AddressTableChunk(size_t MaxOrdinal) : Size(MaxOrdinal + 1) {}
   size_t getSize() const override { return Size * 4; }
 
   void writeTo(uint8_t *Buf) const override {
     memset(Buf, 0, getSize());
 
     for (const Export &E : Config->Exports) {
for (const Export &E : Config->Exports) {
       }
     }
   }
 
 private:
   size_t Size;
 };
 
-class NamePointersChunk : public Chunk {
+class NamePointersChunk : public NonSectionChunk {
 public:
   explicit NamePointersChunk(std::vector<Chunk *> &V) : Chunks(V) {}
   size_t getSize() const override { return Chunks.size() * 4; }
 
   void writeTo(uint8_t *Buf) const override {
     for (Chunk *C : Chunks) {
       write32le(Buf, C->getRVA());
       Buf += 4;
     }
   }
 
 private:
   std::vector<Chunk *> Chunks;
 };
 
-class ExportOrdinalChunk : public Chunk {
+class ExportOrdinalChunk : public NonSectionChunk {
 public:
   explicit ExportOrdinalChunk(size_t I) : Size(I) {}
   size_t getSize() const override { return Size * 2; }
 
   void writeTo(uint8_t *Buf) const override {
     for (Export &E : Config->Exports) {
       if (E.Noname)
         continue;

COFF/Writer.cpp

 static std::vector<OutputSection *> OutputSections;
 
 OutputSection *Chunk::getOutputSection() const {
   return OSIdx == 0 ? nullptr : OutputSections[OSIdx - 1];
 }
 
 namespace {
 
-class DebugDirectoryChunk : public Chunk {
+class DebugDirectoryChunk : public NonSectionChunk {
 public:
   DebugDirectoryChunk(const std::vector<Chunk *> &R, bool WriteRepro)
       : Records(R), WriteRepro(WriteRepro) {}
 
   size_t getSize() const override {
     return (Records.size() + int(WriteRepro)) * sizeof(debug_directory);
   }
 
void fillEntry(debug_directory *D, COFF::DebugType DebugType, size_t Size,
     TimeDateStamps.push_back(&D->TimeDateStamp);
   }
 
   mutable std::vector<support::ulittle32_t *> TimeDateStamps;
   const std::vector<Chunk *> &Records;
   bool WriteRepro;
 };
 
-class CVDebugRecordChunk : public Chunk {
+class CVDebugRecordChunk : public NonSectionChunk {
 public:
   size_t getSize() const override {
     return sizeof(codeview::DebugInfo) + Config->PDBAltPath.size() + 1;
   }
 
   void writeTo(uint8_t *B) const override {
     // Save off the DebugInfo entry to backfill the file signature (build id)
     // in Writer::writeBuildId