PECOFF: Use the string table for long section names in EXEs/DLLs

[majnemer]

Summary

Normally, PE files have section names of eight characters or less.
However, this is problematic for DWARF because DWARF section names are
things like .debug_aranges.

Instead of truncating the section name, redirect the section name into
the string table.

[ruiu]

LGTM with a few nits

lib/ReaderWriter/PECOFF/WriterPECOFF.cpp

203

Add blank lines between no one-liner methods.

793

Please add a comment saying that we support long section name even in an executable, which is a GNU extension to PE/COFF. Also note that dumpbin cannot handle that at this moment.

797

Move this line before the previous if. I think we need to zero-pad after "/%u".

[majnemer]

Closed by commit rL221212 (authored by @majnemer).

lib/ReaderWriter/PECOFF/WriterPECOFF.cpp

 class SectionChunk;
 
 /// A Chunk is an abstract contiguous range in an output file.
 class Chunk {
 public:
   enum Kind {
     kindHeader,
     kindSection,
+    kindStringTable,
     kindAtomChunk
   };
 
   explicit Chunk(Kind kind) : _kind(kind), _size(0) {}
   virtual ~Chunk() {}
   virtual void write(uint8_t *buffer) = 0;
   virtual uint64_t size() const { return _size; }
   virtual uint64_t onDiskSize() const { return size(); }
public:
   }
 
   void setNumberOfSections(uint32_t num) { _coffHeader.NumberOfSections = num; }
 
   void setAddressOfEntryPoint(uint32_t address) {
     _peHeader.AddressOfEntryPoint = address;
   }
 
+  void setPointerToSymbolTable(uint32_t rva) {
+    _coffHeader.PointerToSymbolTable = rva;
+  }
+
 private:
   llvm::object::coff_file_header _coffHeader;
   PEHeader _peHeader;
 };
 
 /// A SectionHeaderTableChunk represents Section Table Header of PE/COFF
 /// format, which is a list of section headers.
 class SectionHeaderTableChunk : public HeaderChunk {
 public:
   SectionHeaderTableChunk() : HeaderChunk() {}
   void addSection(SectionChunk *chunk);
   uint64_t size() const override;
   void write(uint8_t *buffer) override;
 
 private:
   static llvm::object::coff_section createSectionHeader(SectionChunk *chunk);
 
   std::vector<SectionChunk *> _sections;
 };
 
+class StringTableChunk : public Chunk {
+public:
+  StringTableChunk() : Chunk(kindStringTable) {}
+  static bool classof(const Chunk *c) {
+    return c->getKind() == kindStringTable;
+  }
+  uint32_t addSectionName(StringRef sectionName) {
+    if (_stringTable.empty())
+      _stringTable.insert(_stringTable.begin(), 4, 0);
+    uint32_t offset = _stringTable.size();
+    _stringTable.insert(_stringTable.end(), sectionName.begin(),
+                        sectionName.end());
+    _stringTable.push_back('\0');
+    return offset;
+  }
+  uint64_t size() const override { return _stringTable.size(); }
+  void write(uint8_t *buffer) override {
+    if (_stringTable.empty())
+      return;
+    *reinterpret_cast<ulittle32_t *>(_stringTable.data()) = _stringTable.size();
+    std::memcpy(buffer, _stringTable.data(), _stringTable.size());
+  }
+
+private:
+  std::vector<char> _stringTable;
+};
+
 class SectionChunk : public Chunk {
 public:
   uint64_t onDiskSize() const override {
     if (_characteristics & llvm::COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA)
       return 0;
     return llvm::RoundUpToAlignment(size(), SECTOR_SIZE);
   }
 
   uint64_t align() const override { return SECTOR_SIZE; }
   uint32_t getCharacteristics() const { return _characteristics; }
   StringRef getSectionName() const { return _sectionName; }
 
   static bool classof(const Chunk *c) {
     Kind kind = c->getKind();
     return kind == kindSection || kind == kindAtomChunk;
   }
 
   uint64_t getVirtualAddress() { return _virtualAddress; }
   virtual void setVirtualAddress(uint32_t rva) { _virtualAddress = rva; }
 
+  uint32_t getStringTableOffset() const { return _stringTableOffset; }
+  void setStringTableOffset(uint32_t offset) { _stringTableOffset = offset; }
+
 protected:
   SectionChunk(Kind kind, StringRef sectionName, uint32_t characteristics)
       : Chunk(kind), _sectionName(sectionName),
-        _characteristics(characteristics), _virtualAddress(0) {}
+        _characteristics(characteristics), _virtualAddress(0),
+        _stringTableOffset(0) {}
 
 private:
   StringRef _sectionName;
   const uint32_t _characteristics;
   uint64_t _virtualAddress;
+  uint32_t _stringTableOffset;
 };
 
 /// An AtomChunk represents a section containing atoms.
 class AtomChunk : public SectionChunk {
 public:
   AtomChunk(const PECOFFLinkingContext &ctx, StringRef name,
             const std::vector<const DefinedAtom *> &atoms);
 
for (SectionChunk *chunk : _sections) {
     offset += sizeof(header);
   }
 }
 
 llvm::object::coff_section
 SectionHeaderTableChunk::createSectionHeader(SectionChunk *chunk) {
   llvm::object::coff_section header;
 
-  // Section name must be equal to or less than 8 characters in the
-  // executable. Longer names will be truncated.
   StringRef sectionName = chunk->getSectionName();
-
-  // Name field must be NUL-padded. If the name is exactly 8 byte long,
-  // there's no terminating NUL.
-  std::memset(header.Name, 0, sizeof(header.Name));
-  std::strncpy(header.Name, sectionName.data(),
-               std::min(sizeof(header.Name), sectionName.size()));
+  if (uint32_t stringTableOffset = chunk->getStringTableOffset()) {
+    sprintf(header.Name, "/%u", stringTableOffset);
+  } else {
+    std::memset(header.Name, 0, llvm::COFF::NameSize);
+    std::strncpy(header.Name, sectionName.data(), sectionName.size());
+  }
 
   uint32_t characteristics = chunk->getCharacteristics();
   header.VirtualSize = chunk->size();
   header.VirtualAddress = chunk->getVirtualAddress();
   header.SizeOfRawData = chunk->onDiskSize();
   header.PointerToRelocations = 0;
   header.PointerToLinenumbers = 0;
   header.NumberOfRelocations = 0;

 private:
   void applyAllRelocations(uint8_t *bufferStart);
   void printAllAtomAddresses() const;
   void reorderSEHTableEntries(uint8_t *bufferStart);
   void reorderSEHTableEntriesX86(uint8_t *bufferStart);
   void reorderSEHTableEntriesX64(uint8_t *bufferStart);
 
   void addChunk(Chunk *chunk);
-  void addSectionChunk(SectionChunk *chunk, SectionHeaderTableChunk *table);
+  void addSectionChunk(SectionChunk *chunk, SectionHeaderTableChunk *table,
+                       StringTableChunk *stringTable);
   void setImageSizeOnDisk();
   uint64_t
   calcSectionSize(llvm::COFF::SectionCharacteristics sectionType) const;
 
   uint64_t calcSizeOfInitializedData() const {
     return calcSectionSize(llvm::COFF::IMAGE_SCN_CNT_INITIALIZED_DATA);
   }
 
void PECOFFWriter::build(const File &linkedFile) {
   AtomVectorMap atoms;
   groupAtoms(_ctx, linkedFile, atoms);
 
   // Create file chunks and add them to the list.
   auto *dosStub = new DOSStubChunk(_ctx);
   auto *peHeader = new PEHeaderChunk<PEHeader>(_ctx);
   auto *dataDirectory = new DataDirectoryChunk();
   auto *sectionTable = new SectionHeaderTableChunk();
+  auto *stringTable = new StringTableChunk();
   addChunk(dosStub);
   addChunk(peHeader);
   addChunk(dataDirectory);
   addChunk(sectionTable);
+  addChunk(stringTable);
 
   // Create sections and add the atoms to them.
   for (auto i : atoms) {
     StringRef sectionName = i.first;
     std::vector<const DefinedAtom *> &contents = i.second;
     auto *section = new AtomChunk(_ctx, sectionName, contents);
     if (section->size() > 0)
-      addSectionChunk(section, sectionTable);
+      addSectionChunk(section, sectionTable, stringTable);
   }
 
   // Build atom to its RVA map.
   for (std::unique_ptr<Chunk> &cp : _chunks)
     if (AtomChunk *chunk = dyn_cast<AtomChunk>(&*cp))
       chunk->buildAtomRvaMap(_atomRva);
 
   // We know the addresses of all defined atoms that needs to be
   // relocated. So we can create the ".reloc" section which contains
   // all the relocation sites.
   if (_ctx.getBaseRelocationEnabled()) {
     BaseRelocChunk *baseReloc = new BaseRelocChunk(_chunks, _ctx);
     if (baseReloc->size()) {
-      addSectionChunk(baseReloc, sectionTable);
+      addSectionChunk(baseReloc, sectionTable, stringTable);
       dataDirectory->setField(DataDirectoryIndex::BASE_RELOCATION_TABLE,
                               baseReloc->getVirtualAddress(),
                               baseReloc->size());
     }
   }
 
   setImageSizeOnDisk();
+  if (stringTable->size())
+    peHeader->setPointerToSymbolTable(stringTable->fileOffset());
 
   for (std::unique_ptr<Chunk> &chunk : _chunks) {
     SectionChunk *section = dyn_cast<SectionChunk>(chunk.get());
     if (!section)
       continue;
     if (section->getSectionName() == ".text") {
       peHeader->setBaseOfCode(section->getVirtualAddress());
 
void PECOFFWriter::reorderSEHTableEntriesX64(uint8_t *bufferStart) {
   }
 }
 
 void PECOFFWriter::addChunk(Chunk *chunk) {
   _chunks.push_back(std::unique_ptr<Chunk>(chunk));
 }
 
 void PECOFFWriter::addSectionChunk(SectionChunk *chunk,
-                                   SectionHeaderTableChunk *table) {
+                                   SectionHeaderTableChunk *table,
+                                   StringTableChunk *stringTable) {
   _chunks.push_back(std::unique_ptr<Chunk>(chunk));
   table->addSection(chunk);
   _numSections++;
 
+  StringRef sectionName = chunk->getSectionName();
+  if (sectionName.size() > llvm::COFF::NameSize) {
+    uint32_t stringTableOffset = stringTable->addSectionName(sectionName);
+    chunk->setStringTableOffset(stringTableOffset);
+  }
+
   // Compute and set the starting address of sections when loaded in
   // memory. They are different from positions on disk because sections need
   // to be sector-aligned on disk but page-aligned in memory.
   chunk->setVirtualAddress(_imageSizeInMemory);
   _imageSizeInMemory = llvm::RoundUpToAlignment(
       _imageSizeInMemory + chunk->size(), _ctx.getPageSize());
 }
 

test/pecoff/long-section-name.test

 # RUN: yaml2obj %p/Inputs/nop.obj.yaml > %t.obj
 #
 # RUN: lld -flavor link /out:%t.exe /subsystem:console /entry:start \
 # RUN:   /merge:.text=.longsectionname -- %t.obj
 # RUN: llvm-readobj -sections %t.exe | FileCheck %s
 
-CHECK: Name: .longsec (2E 6C 6F 6E 67 73 65 63)
+CHECK: Name: .longsectionname (2F 34 00 00 00 00 00 00)