[PDB] Fix section contributions

[rnk]

Summary

PDB section contributions are supposed to use output section indices and
offsets, not input section indices and offsets.

This allows the debugger to look up the index of the module that it
should look up in the modules stream for symbol information. With this
change, windbg can now find line tables, but it still cannot print local
variables.

Fixes PR34048

[zturner]

llvm/include/llvm/DebugInfo/PDB/Native/DbiStreamBuilder.h

75–77 ↗

(On Diff #109624)

Pass by const&?

lld/trunk/COFF/PDB.h

 namespace llvm {
 namespace codeview {
 union DebugInfo;
 }
 }
 
 namespace lld {
 namespace coff {
+class OutputSection;
 class SymbolTable;
 
-void createPDB(SymbolTable *Symtab, llvm::ArrayRef<uint8_t> SectionTable,
+void createPDB(SymbolTable *Symtab,
+               llvm::ArrayRef<OutputSection *> OutputSections,
+               llvm::ArrayRef<uint8_t> SectionTable,
                const llvm::codeview::DebugInfo *DI);
 }
 }
 
 #endif

lld/trunk/COFF/PDB.cpp

public:
   /// all the type and item records from the .debug$S stream and fill in the
   /// caller-provided ObjectIndexMap.
   const CVIndexMap &mergeDebugT(ObjFile *File, CVIndexMap &ObjectIndexMap);
 
   const CVIndexMap &maybeMergeTypeServerPDB(ObjFile *File,
                                             TypeServer2Record &TS);
 
   /// Add the section map and section contributions to the PDB.
-  void addSections(ArrayRef<uint8_t> SectionTable);
+  void addSections(ArrayRef<OutputSection *> OutputSections,
+                   ArrayRef<uint8_t> SectionTable);
+
+  void addSectionContrib(pdb::DbiModuleDescriptorBuilder &LinkerModule,
+                         OutputSection *OS, Chunk *C);
 
   /// Write the PDB to disk.
   void commit();
 
 private:
   BumpPtrAllocator Alloc;
 
   SymbolTable *Symtab;
private:
 
   std::vector<pdb::SecMapEntry> SectionMap;
 
   /// Type index mappings of type server PDBs that we've loaded so far.
   std::map<GUID, CVIndexMap> TypeServerIndexMappings;
 };
 }
 
-// Returns a list of all SectionChunks.
-static void addSectionContribs(SymbolTable *Symtab,
-                               pdb::DbiStreamBuilder &DbiBuilder) {
-  for (Chunk *C : Symtab->getChunks())
-    if (auto *SC = dyn_cast<SectionChunk>(C))
-      DbiBuilder.addSectionContrib(SC->File->ModuleDBI, SC->Header);
-}
-
 static SectionChunk *findByName(std::vector<SectionChunk *> &Sections,
                                 StringRef Name) {
   for (SectionChunk *C : Sections)
     if (C->getSectionName() == Name)
       return C;
   return nullptr;
 }
 
Mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol(
       ONS, Allocator, CodeViewContainer::Pdb));
   Mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol(
       CS, Allocator, CodeViewContainer::Pdb));
   Mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol(
       EBS, Allocator, CodeViewContainer::Pdb));
 }
 
 // Creates a PDB file.
-void coff::createPDB(SymbolTable *Symtab, ArrayRef<uint8_t> SectionTable,
+void coff::createPDB(SymbolTable *Symtab,
+                     ArrayRef<OutputSection *> OutputSections,
+                     ArrayRef<uint8_t> SectionTable,
                      const llvm::codeview::DebugInfo *DI) {
   PDBLinker PDB(Symtab);
   PDB.initialize(DI);
   PDB.addObjectsToPDB();
-  PDB.addSections(SectionTable);
+  PDB.addSections(OutputSections, SectionTable);
   PDB.commit();
 }
 
 void PDBLinker::initialize(const llvm::codeview::DebugInfo *DI) {
   ExitOnErr(Builder.initialize(4096)); // 4096 is blocksize
 
   // Create streams in MSF for predefined streams, namely
   // PDB, TPI, DBI and IPI.
void PDBLinker::initialize(const llvm::codeview::DebugInfo *DI) {
   InfoBuilder.setVersion(pdb::PdbRaw_ImplVer::PdbImplVC70);
 
   // Add an empty DBI stream.
   pdb::DbiStreamBuilder &DbiBuilder = Builder.getDbiBuilder();
   DbiBuilder.setVersionHeader(pdb::PdbDbiV70);
   ExitOnErr(DbiBuilder.addDbgStream(pdb::DbgHeaderType::NewFPO, {}));
 }
 
-void PDBLinker::addSections(ArrayRef<uint8_t> SectionTable) {
-  // Add Section Contributions.
-  pdb::DbiStreamBuilder &DbiBuilder = Builder.getDbiBuilder();
-  addSectionContribs(Symtab, DbiBuilder);
-
-  // Add Section Map stream.
-  ArrayRef<object::coff_section> Sections = {
-      (const object::coff_section *)SectionTable.data(),
-      SectionTable.size() / sizeof(object::coff_section)};
-  SectionMap = pdb::DbiStreamBuilder::createSectionMap(Sections);
-  DbiBuilder.setSectionMap(SectionMap);
+void PDBLinker::addSectionContrib(pdb::DbiModuleDescriptorBuilder &LinkerModule,
+                                  OutputSection *OS, Chunk *C) {
+  pdb::SectionContrib SC;
+  memset(&SC, 0, sizeof(SC));
+  SC.ISect = OS->SectionIndex;
+  SC.Off = C->getRVA() - OS->getRVA();
+  SC.Size = C->getSize();
+  if (auto *SecChunk = dyn_cast<SectionChunk>(C)) {
+    SC.Characteristics = SecChunk->Header->Characteristics;
+    SC.Imod = SecChunk->File->ModuleDBI->getModuleIndex();
+  } else {
+    SC.Characteristics = OS->getCharacteristics();
+    // FIXME: When we start creating DBI for import libraries, use those here.
+    SC.Imod = LinkerModule.getModuleIndex();
+  }
+  SC.DataCrc = 0;  // FIXME
+  SC.RelocCrc = 0; // FIXME
+  Builder.getDbiBuilder().addSectionContrib(SC);
+}
 
+void PDBLinker::addSections(ArrayRef<OutputSection *> OutputSections,
+                            ArrayRef<uint8_t> SectionTable) {
   // It's not entirely clear what this is, but the * Linker * module uses it.
+  pdb::DbiStreamBuilder &DbiBuilder = Builder.getDbiBuilder();
   NativePath = Config->PDBPath;
   sys::fs::make_absolute(NativePath);
   sys::path::native(NativePath, sys::path::Style::windows);
   uint32_t PdbFilePathNI = DbiBuilder.addECName(NativePath);
   auto &LinkerModule = ExitOnErr(DbiBuilder.addModuleInfo("* Linker *"));
   LinkerModule.setPdbFilePathNI(PdbFilePathNI);
   addLinkerModuleSymbols(NativePath, LinkerModule, Alloc);
 
+  // Add section contributions. They must be ordered by ascending RVA.
+  for (OutputSection *OS : OutputSections)
+    for (Chunk *C : OS->getChunks())
+      addSectionContrib(LinkerModule, OS, C);
+
+  // Add Section Map stream.
+  ArrayRef<object::coff_section> Sections = {
+      (const object::coff_section *)SectionTable.data(),
+      SectionTable.size() / sizeof(object::coff_section)};
+  SectionMap = pdb::DbiStreamBuilder::createSectionMap(Sections);
+  DbiBuilder.setSectionMap(SectionMap);
+
   // Add COFF section header stream.
   ExitOnErr(
       DbiBuilder.addDbgStream(pdb::DbgHeaderType::SectionHdr, SectionTable));
 }
 
 void PDBLinker::commit() {
   // Write to a file.
   ExitOnErr(Builder.commit(Config->PDBPath));
 }

lld/trunk/COFF/Writer.cpp

void Writer::run() {
   writeSections();
   sortExceptionTable();
   writeBuildId();
 
   if (!Config->PDBPath.empty() && Config->Debug) {
     const llvm::codeview::DebugInfo *DI = nullptr;
     if (Config->DebugTypes & static_cast<unsigned>(coff::DebugType::CV))
       DI = BuildId->DI;
-    createPDB(Symtab, SectionTable, DI);
+    createPDB(Symtab, OutputSections, SectionTable, DI);
   }
 
   writeMapFile(OutputSections);
 
   if (auto EC = Buffer->commit())
     fatal(EC, "failed to write the output file");
 }
 

lld/trunk/test/COFF/pdb-publics-import.test

 Make a DLL that exports a few functions, then make a DLL with PDBs that imports
 them. Check that the __imp_ pointer and the generated thunks appear in the
 publics stream.
 
 RUN: yaml2obj < %p/Inputs/export.yaml > %t1.obj
 RUN: lld-link /out:%t1.dll /dll %t1.obj /implib:%t1.lib \
 RUN:   /export:exportfn1 /export:exportfn2
 RUN: yaml2obj < %p/Inputs/import.yaml > %t2.obj
 RUN: lld-link /out:%t2.exe /pdb:%t2.pdb /debug /entry:main %t2.obj %t1.lib
-RUN: llvm-pdbutil dump %t2.pdb -publics | FileCheck %s
+RUN: llvm-pdbutil dump %t2.pdb -publics -section-contribs | FileCheck %s
 
 CHECK:                             Public Symbols
 CHECK-NEXT: ============================================================
 CHECK-NEXT:      112 | S_PUB32 [size = 20] `main`
 CHECK-NEXT:            flags = function, addr = 0001:0000
 CHECK-NEXT:       64 | S_PUB32 [size = 24] `exportfn1`
 CHECK-NEXT:            flags = function, addr = 0001:0016
 CHECK-NEXT:       88 | S_PUB32 [size = 24] `exportfn2`
 CHECK-NEXT:            flags = function, addr = 0001:0032
 CHECK-NEXT:       32 | S_PUB32 [size = 32] `__imp_exportfn2`
 CHECK-NEXT:            flags = none, addr = 0003:0072
 CHECK-NEXT:        0 | S_PUB32 [size = 32] `__imp_exportfn1`
 CHECK-NEXT:            flags = none, addr = 0003:0064
+
+CHECK:                         Section Contributions
+CHECK-NEXT: ============================================================
+    main
+CHECK-NEXT:   SC  | mod = 0, 0001:0000, size = 8, data crc = 0, reloc crc = 0
+CHECK-NEXT:         IMAGE_SCN_CNT_CODE | IMAGE_SCN_ALIGN_4BYTES | IMAGE_SCN_MEM_EXECUTE |
+CHECK-NEXT:         IMAGE_SCN_MEM_READ
+    exportfn1 thunk
+CHECK-NEXT:   SC  | mod = 1, 0001:0016, size = 6, data crc = 0, reloc crc = 0
+CHECK-NEXT:         IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ
+    exportfn2 thunk
+CHECK-NEXT:   SC  | mod = 1, 0001:0032, size = 6, data crc = 0, reloc crc = 0
+CHECK-NEXT:         IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ
+    .rdata debug directory data chunks
+CHECK-NEXT:   SC  | mod = 1, 0002:0000, size = 28, data crc = 0, reloc crc = 0
+CHECK-NEXT:         IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ
+CHECK-NEXT:   SC  | mod = 1, 0002:0028, size = 110, data crc = 0, reloc crc = 0
+CHECK-NEXT:         IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ

lld/trunk/test/COFF/pdb.test

 RAW-NEXT:  Hash Buckets
 RAW-NEXT:    0x00000000
 RAW-NEXT:    0x0000000c
 RAW-NEXT:  Address Map
 RAW-NEXT:    off = 20
 RAW-NEXT:    off = 0
 RAW:                        Section Contributions
 RAW-NEXT: ============================================================
-RAW-NEXT:   SC  | mod = 0, 65535:1288, size = 14, data crc = 0, reloc crc = 0
+RAW-NEXT:   SC  | mod = 0, 0001:0000, size = 12, data crc = 0, reloc crc = 0
+RAW-NEXT:         IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_ALIGN_4BYTES | IMAGE_SCN_MEM_READ
+RAW-NEXT:   SC  | mod = 0, 0002:0000, size = 14, data crc = 0, reloc crc = 0
 RAW-NEXT:         IMAGE_SCN_CNT_CODE | IMAGE_SCN_ALIGN_16BYTES | IMAGE_SCN_MEM_EXECUTE |
 RAW-NEXT:         IMAGE_SCN_MEM_READ
-RAW-NEXT:   SC  | mod = 0, 65535:1312, size = 8, data crc = 0, reloc crc = 0
-RAW-NEXT:         IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_ALIGN_4BYTES | IMAGE_SCN_MEM_READ
-RAW-NEXT:   SC  | mod = 0, 65535:1320, size = 12, data crc = 0, reloc crc = 0
-RAW-NEXT:         IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_ALIGN_4BYTES | IMAGE_SCN_MEM_READ
-RAW-NEXT:   SC  | mod = 1, 65535:1144, size = 6, data crc = 0, reloc crc = 0
+RAW-NEXT:   SC  | mod = 1, 0002:0016, size = 6, data crc = 0, reloc crc = 0
 RAW-NEXT:         IMAGE_SCN_CNT_CODE | IMAGE_SCN_ALIGN_16BYTES | IMAGE_SCN_MEM_EXECUTE |
 RAW-NEXT:         IMAGE_SCN_MEM_READ
+RAW-NEXT:   SC  | mod = 0, 0003:0000, size = 8, data crc = 0, reloc crc = 0
+RAW-NEXT:         IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_ALIGN_4BYTES | IMAGE_SCN_MEM_READ
 RAW:                             Section Map
 RAW-NEXT: ============================================================
 RAW-NEXT:   Section 0000 | ovl = 0, group = 0, frame = 0, name = 1
 RAW-NEXT:                  class = 65535, offset = 0, size =
 RAW-NEXT:                  flags = read | 32 bit addr | selector
 RAW-NEXT:   Section 0001 | ovl = 1, group = 0, frame = 0, name = 2
 RAW-NEXT:                  class = 65535, offset = 0, size =
 RAW-NEXT:                  flags = read | execute | 32 bit addr | selector

llvm/trunk/include/llvm/DebugInfo/PDB/Native/DbiStreamBuilder.h

public:
   Error addModuleSourceFile(StringRef Module, StringRef File);
   Error addModuleSourceFile(DbiModuleDescriptorBuilder &Module, StringRef File);
   Expected<uint32_t> getSourceFileNameIndex(StringRef FileName);
 
   Error finalizeMsfLayout();
 
   Error commit(const msf::MSFLayout &Layout, WritableBinaryStreamRef MsfBuffer);
 
-  void addSectionContrib(DbiModuleDescriptorBuilder *ModuleDbi,
-                         const llvm::object::coff_section *SecHdr);
+  void addSectionContrib(const SectionContrib &SC) {
+    SectionContribs.emplace_back(SC);
+  }
 
   // A helper function to create a Section Map from a COFF section header.
   static std::vector<SecMapEntry>
   createSectionMap(ArrayRef<llvm::object::coff_section> SecHdrs);
 
 private:
   struct DebugStream {
     ArrayRef<uint8_t> Data;

llvm/trunk/lib/DebugInfo/PDB/Native/DbiStreamBuilder.cpp

if (!(Flags & COFF::IMAGE_SCN_MEM_16BIT))
     Ret |= static_cast<uint16_t>(OMFSegDescFlags::AddressIs32Bit);
 
   // This seems always 1.
   Ret |= static_cast<uint16_t>(OMFSegDescFlags::IsSelector);
 
   return Ret;
 }
 
-void DbiStreamBuilder::addSectionContrib(DbiModuleDescriptorBuilder *ModuleDbi,
-                                         const object::coff_section *SecHdr) {
-  SectionContrib SC;
-  memset(&SC, 0, sizeof(SC));
-  SC.ISect = (uint16_t)~0U; // This represents nil.
-  SC.Off = SecHdr->PointerToRawData;
-  SC.Size = SecHdr->SizeOfRawData;
-  SC.Characteristics = SecHdr->Characteristics;
-  // Use the module index in the module dbi stream or nil (-1).
-  SC.Imod = ModuleDbi ? ModuleDbi->getModuleIndex() : (uint16_t)~0U;
-  SectionContribs.emplace_back(SC);
-}
-
 // A utility function to create a Section Map for a given list of COFF sections.
 //
 // A Section Map seem to be a copy of a COFF section list in other format.
 // I don't know why a PDB file contains both a COFF section header and
 // a Section Map, but it seems it must be present in a PDB.
 std::vector<SecMapEntry> DbiStreamBuilder::createSectionMap(
     ArrayRef<llvm::object::coff_section> SecHdrs) {
   std::vector<SecMapEntry> Ret;