[COFF] Allow comdat discarding and GC of non-section chunks

[rnk]

Summary

Move the "Live" and "Discarded" bools from SectionChunk to Chunk. This
will allow us to add a new kind of chunk for control flow guard that
participates in comdat resolution and dead stripping. It is very similar
to .sxdata and SEHTableChunk, but object files may have more than one
such section.

[ruiu]

LGTM given that you are going to enable GC for other chunks.

[rnk]

After hacking a bit more on this, I decided not to do this. I think we'll treat these .gfids chunks as SectionChunks that are not held in ObjectFile::Chunks, the same way we treat DebugChunks. They will be regular SectionChunks that participate in section GC, but they will not be emitted into the output, just like .debug$S chunks. We'll iterate them later, check which ones are live, and create a single chunk for the whole table.

lld/COFF/Chunks.h

 const uint32_t PermMask = 0xFF0000F0;
 
 // 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 { SectionKind, OtherKind };
+  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;
 
   // Write this chunk to a mmap'ed file, assuming Buf is pointing to
   // beginning of the file. Because this function may use RVA values
public:
   // Windows-specific.
   // Collect all locations that contain absolute addresses for base relocations.
   virtual 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 ""; }
 
+  // Returns true if the chunk was not dropped by GC or COMDAT deduplication.
+  bool isLive() { return Live && !Discarded; }
+
+  // Used by the garbage collector.
+  void markLive() {
+    assert(Config->DoGC && "should only mark things live from GC");
+    assert(!isLive() && "Cannot mark an already live section!");
+    Live = true;
+  }
+
+  // Returns true if this chunk was dropped by COMDAT deduplication.
+  bool isDiscarded() const { return Discarded; }
+
+  // Used by the SymbolTable when discarding unused comdat sections. This is
+  // redundant when GC is enabled, as all comdat sections will start out dead.
+  void markDiscarded() { Discarded = true; }
+
 protected:
   Chunk(Kind K = OtherKind) : ChunkKind(K) {}
   const Kind ChunkKind;
 
+  // True if this chunk was discarded because it was a duplicate comdat section.
+  bool Discarded;
+
+  // Used by the garbage collector.
+  bool Live;
+
   // The alignment of this chunk. The writer uses the value.
   uint32_t Align = 1;
 
   // The RVA of this chunk in the output. The writer sets a value.
   uint64_t RVA = 0;
 
 public:
   // The offset from beginning of the output section. The writer sets a value.
public:
   void applyRelARM(uint8_t *Off, uint16_t Type, Defined *Sym, uint64_t P) const;
 
   // 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);
+  void addAssociative(Chunk *Child);
 
   StringRef getDebugName() override;
   void setSymbol(DefinedRegular *S) { if (!Sym) Sym = S; }
 
-  // Returns true if the chunk was not dropped by GC or COMDAT deduplication.
-  bool isLive() { return Live && !Discarded; }
-
-  // Used by the garbage collector.
-  void markLive() {
-    assert(Config->DoGC && "should only mark things live from GC");
-    assert(!isLive() && "Cannot mark an already live section!");
-    Live = true;
-  }
-
-  // Returns true if this chunk was dropped by COMDAT deduplication.
-  bool isDiscarded() const { return Discarded; }
-
-  // Used by the SymbolTable when discarding unused comdat sections. This is
-  // redundant when GC is enabled, as all comdat sections will start out dead.
-  void markDiscarded() { Discarded = true; }
-
   // 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 SectionName == ".debug" || SectionName.startswith(".debug$");
   }
 
   // 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, Relocs.begin()),
                             symbol_iterator(File, Relocs.end()));
   }
 
   // Allow iteration over the associated child chunks for this section.
-  ArrayRef<SectionChunk *> children() const { return AssocChildren; }
+  ArrayRef<Chunk *> children() const { return AssocChildren; }
 
   // A pointer pointing to a replacement for this chunk.
   // Initially it points to "this" object. If this chunk is merged
   // with other chunk by ICF, it points to another chunk,
   // and this chunk is considrered as dead.
   SectionChunk *Repl;
 
   // The CRC of the contents as described in the COFF spec 4.5.5.
   // Auxiliary Format 5: Section Definitions. Used for ICF.
   uint32_t Checksum = 0;
 
   const coff_section *Header;
 
   // The file that this chunk was created from.
   ObjectFile *File;
 
 private:
   StringRef SectionName;
-  std::vector<SectionChunk *> AssocChildren;
+  std::vector<Chunk *> AssocChildren;
   llvm::iterator_range<const coff_relocation *> Relocs;
   size_t NumRelocs;
 
-  // True if this chunk was discarded because it was a duplicate comdat section.
-  bool Discarded;
-
-  // Used by the garbage collector.
-  bool Live;
-
   // Used for ICF (Identical COMDAT Folding)
   void replace(SectionChunk *Other);
   uint32_t Class[2] = {0, 0};
 
   // Sym points to a section symbol if this is a COMDAT chunk.
   DefinedRegular *Sym = nullptr;
 };
 

lld/COFF/Chunks.cpp

case ARMNT:
       applyRelARM(Off, Rel.Type, Sym, P);
       break;
     default:
       llvm_unreachable("unknown machine type");
     }
   }
 }
 
-void SectionChunk::addAssociative(SectionChunk *Child) {
+void SectionChunk::addAssociative(Chunk *Child) {
   AssocChildren.push_back(Child);
 }
 
 static uint8_t getBaserelType(const coff_relocation &Rel) {
   switch (Config->Machine) {
   case AMD64:
     if (Rel.Type == IMAGE_REL_AMD64_ADDR64)
       return IMAGE_REL_BASED_DIR64;

lld/COFF/MarkLive.cpp

while (!Worklist.empty()) {
     SectionChunk *SC = Worklist.pop_back_val();
     assert(SC->isLive() && "We mark as live when pushing onto the worklist!");
 
     // Mark all symbols listed in the relocation table for this section.
     for (SymbolBody *B : SC->symbols())
       AddSym(B);
 
     // Mark associative sections if any.
-    for (SectionChunk *C : SC->children())
-      Enqueue(C);
+    for (Chunk *C : SC->children())
+      if (auto *SC = dyn_cast<SectionChunk>(C))
+        Enqueue(SC);
   }
 }
 
 }
 }

lld/COFF/SymbolTable.cpp

Symbol *SymbolTable::addRegular(InputFile *F, StringRef N, bool IsCOMDAT,
   if (SP == SP_CONFLICT) {
     reportDuplicate(S, F);
   } else if (SP == SP_NEW) {
     replaceBody<DefinedRegular>(S, F, N, IsCOMDAT, /*IsExternal*/ true, Sym, C);
   } else if (SP == SP_EXISTING && IsCOMDAT && C) {
     C->markDiscarded();
     // Discard associative chunks that we've parsed so far. No need to recurse
     // because an associative section cannot have children.
-    for (SectionChunk *Child : C->children())
+    for (Chunk *Child : C->children())
       Child->markDiscarded();
   }
   return S;
 }
 
 Symbol *SymbolTable::addCommon(InputFile *F, StringRef N, uint64_t Size,
                                const coff_symbol_generic *Sym, CommonChunk *C) {
   Symbol *S;