[PDB] Add a module descriptor for every object file

[rnk]

Summary

Expose the module descriptor index and fill it in for section
contributions.

[zturner]

lld/COFF/PDB.cpp

113–115 ↗

(On Diff #102269)

A slightly cleaner way to do this would be to make an ExitOnError outside of this for loop, then just write auto &MD = Err(Builder.getDbiBuilder().addModuleInfo(Path);

ExitOnError Err("Error while adding objects to PDB");
for (...) {
  auto &MD = Err(Builder.getDbiBuilder().addModuleInfo(Path));

lld/test/COFF/pdb-lib.s

3–4 ↗

(On Diff #102269)

I know this keeps it all in one file, but sed on the input file is kind of a huge hack, what about putting the code in an input file under Inputs/?

Maybe in the future we could remove dependency on sed by making a tool which essentially strips a file of everything but a single label. Like:

llvm-strip --keep-label=BAR --remove-label-headers < %s > bar.asm

12 ↗

(On Diff #102269)

I'd remove anything fragile like debug stream indices.

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

296 ↗

(On Diff #102269)

Is this correct? Shouldn't it be the index of the section?

[rnk]

lld/test/COFF/pdb-lib.s

3–4 ↗

(On Diff #102269)

I'd like something like llvm-strip, or maybe llvm-split, which splits something like this up into multiple inputs:

// ==> file_a.h <==
struct Foo { ... };
extern Foo my_global;

// ==> file_b.c <==
#include "file_a.h"
Foo my_global;

// ==> file_c.c <==
#include "file_a.h"
int use_global() { return my_global.x; }

That's basically the format people use to file bugs. And then you get editor syntax highlighting that works.

Let's just use Inputs for now.

12 ↗

(On Diff #102269)

OK, I'll remove that. I want to keep the line info, source file name, etc, since these are .s files without any .debug$S data and those *should* remain zero.

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

296 ↗

(On Diff #102269)

I haven't figured out what it's supposed to be yet, but zero isn't correct, because it's not the null representation used in microsoft-pdb.

I did some experiments but I wasn't able to nail it down by the end of the day, so I figured I'd send what I have and we can improve on it later.

[zturner]

looks good after the agreed upon changes.

[rnk]

lld/COFF/PDB.cpp

113–115 ↗

(On Diff #102269)

(forgot to respond to this) Thanks, I tried check() first, but that doesn't work because it isn't overloaded for Expected<T&>.

lld/trunk/COFF/InputFiles.h

 #include "llvm/LTO/LTO.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Support/StringSaver.h"
 #include <memory>
 #include <set>
 #include <vector>
 
+namespace llvm {
+namespace pdb {
+class DbiModuleDescriptorBuilder;
+}
+}
+
 namespace lld {
 namespace coff {
 
 using llvm::COFF::IMAGE_FILE_MACHINE_UNKNOWN;
 using llvm::COFF::MachineTypes;
 using llvm::object::Archive;
 using llvm::object::COFFObjectFile;
 using llvm::object::COFFSymbolRef;
public:
   // True if this object file is compatible with SEH.
   // COFF-specific and x86-only.
   bool SEHCompat = false;
 
   // The list of safe exception handlers listed in .sxdata section.
   // COFF-specific and x86-only.
   std::set<SymbolBody *> SEHandlers;
 
+  // Pointer to the PDB module descriptor builder. Various debug info records
+  // will reference object files by "module index", which is here. Things like
+  // source files and section contributions are also recorded here. Will be null
+  // if we are not producing a PDB.
+  llvm::pdb::DbiModuleDescriptorBuilder *ModuleDBI = nullptr;
+
 private:
   void initializeChunks();
   void initializeSymbols();
   void initializeSEH();
 
   SymbolBody *createDefined(COFFSymbolRef Sym, const void *Aux, bool IsFirst);
   SymbolBody *createUndefined(COFFSymbolRef Sym);
 

lld/trunk/COFF/PDB.cpp

 #include "llvm/DebugInfo/MSF/MSFBuilder.h"
 #include "llvm/DebugInfo/MSF/MSFCommon.h"
 #include "llvm/DebugInfo/PDB/Native/DbiStream.h"
 #include "llvm/DebugInfo/PDB/Native/DbiStreamBuilder.h"
 #include "llvm/DebugInfo/PDB/Native/InfoStream.h"
 #include "llvm/DebugInfo/PDB/Native/InfoStreamBuilder.h"
 #include "llvm/DebugInfo/PDB/Native/PDBFile.h"
 #include "llvm/DebugInfo/PDB/Native/PDBFileBuilder.h"
+#include "llvm/DebugInfo/PDB/Native/DbiModuleDescriptorBuilder.h"
 #include "llvm/DebugInfo/PDB/Native/PDBStringTableBuilder.h"
 #include "llvm/DebugInfo/PDB/Native/PDBTypeServerHandler.h"
 #include "llvm/DebugInfo/PDB/Native/TpiStream.h"
 #include "llvm/DebugInfo/PDB/Native/TpiStreamBuilder.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Support/BinaryByteStream.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/FileOutputBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include <memory>
 
 using namespace lld;
 using namespace lld::coff;
 using namespace llvm;
 using namespace llvm::codeview;
 using namespace llvm::support;
 using namespace llvm::support::endian;
 
 using llvm::object::coff_section;
 
 static ExitOnError ExitOnErr;
 
 // Returns a list of all SectionChunks.
-static std::vector<coff_section> getInputSections(SymbolTable *Symtab) {
-  std::vector<coff_section> V;
+static void addSectionContribs(SymbolTable *Symtab, pdb::DbiStreamBuilder &DbiBuilder) {
   for (Chunk *C : Symtab->getChunks())
     if (auto *SC = dyn_cast<SectionChunk>(C))
-      V.push_back(*SC->Header);
-  return V;
+      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;
static void addTypeInfo(pdb::TpiStreamBuilder &TpiBuilder,
 
   // Flatten the in memory type table.
   TypeTable.ForEachRecord([&](TypeIndex TI, ArrayRef<uint8_t> Rec) {
     // FIXME: Hash types.
     TpiBuilder.addTypeRecord(Rec, None);
   });
 }
 
-// Merge .debug$T sections into IpiData and TpiData.
-static void mergeDebugT(SymbolTable *Symtab, pdb::PDBFileBuilder &Builder,
+// Add all object files to the PDB. Merge .debug$T sections into IpiData and
+// TpiData.
+static void addObjectsToPDB(SymbolTable *Symtab, pdb::PDBFileBuilder &Builder,
                             codeview::TypeTableBuilder &TypeTable,
                             codeview::TypeTableBuilder &IDTable) {
   // Follow type servers.  If the same type server is encountered more than
   // once for this instance of `PDBTypeServerHandler` (for example if many
   // object files reference the same TypeServer), the types from the
   // TypeServer will only be visited once.
   pdb::PDBTypeServerHandler Handler;
 
   // Visit all .debug$T sections to add them to Builder.
   for (ObjectFile *File : Symtab->ObjectFiles) {
+    // Add a module descriptor for every object file. We need to put an absolute
+    // path to the object into the PDB. If this is a plain object, we make its
+    // path absolute. If it's an object in an archive, we make the archive path
+    // absolute.
+    bool InArchive = !File->ParentName.empty();
+    SmallString<128> Path = InArchive ? File->ParentName : File->getName();
+    sys::fs::make_absolute(Path);
+    StringRef Name = InArchive ? File->getName() : StringRef(Path);
+    File->ModuleDBI = &ExitOnErr(Builder.getDbiBuilder().addModuleInfo(Name));
+    File->ModuleDBI->setObjFileName(Path);
+
+    // FIXME: Walk the .debug$S sections and add them. Do things like recording
+    // source files.
+
     ArrayRef<uint8_t> Data = getDebugSection(File, ".debug$T");
     if (Data.empty())
       continue;
 
     BinaryByteStream Stream(Data, support::little);
     codeview::CVTypeArray Types;
     BinaryStreamReader Reader(Stream);
     SmallVector<TypeIndex, 128> SourceToDest;
void coff::createPDB(StringRef Path, SymbolTable *Symtab,
   if (DI)
     memcpy(&uuid, &DI->PDB70.Signature, sizeof(uuid));
   InfoBuilder.setGuid(uuid);
   // Should be the current time, but set 0 for reproducibilty.
   InfoBuilder.setSignature(0);
   InfoBuilder.setVersion(pdb::PdbRaw_ImplVer::PdbImplVC70);
 
   // Add an empty DPI stream.
-  auto &DbiBuilder = Builder.getDbiBuilder();
+  pdb::DbiStreamBuilder &DbiBuilder = Builder.getDbiBuilder();
   DbiBuilder.setVersionHeader(pdb::PdbDbiV110);
 
   codeview::TypeTableBuilder TypeTable(BAlloc);
   codeview::TypeTableBuilder IDTable(BAlloc);
-  mergeDebugT(Symtab, Builder, TypeTable, IDTable);
+  addObjectsToPDB(Symtab, Builder, TypeTable, IDTable);
 
   // Add Section Contributions.
-  std::vector<pdb::SectionContrib> Contribs =
-      pdb::DbiStreamBuilder::createSectionContribs(getInputSections(Symtab));
-  DbiBuilder.setSectionContribs(Contribs);
+  addSectionContribs(Symtab, DbiBuilder);
 
   // Add Section Map stream.
   ArrayRef<object::coff_section> Sections = {
       (const object::coff_section *)SectionTable.data(),
       SectionTable.size() / sizeof(object::coff_section)};
   std::vector<pdb::SecMapEntry> SectionMap =
       pdb::DbiStreamBuilder::createSectionMap(Sections);
   DbiBuilder.setSectionMap(SectionMap);

lld/trunk/test/COFF/pdb-lib.s

+# RUN: rm -rf %t && mkdir -p %t && cd %t
+# RUN: llvm-mc -filetype=obj -triple=i686-windows-msvc %s -o foo.obj
+# RUN: llc %S/Inputs/bar.ll -filetype=obj -mtriple=i686-windows-msvc -o bar.obj
+# RUN: llvm-lib bar.obj -out:bar.lib
+# RUN: lld-link -debug -pdb:foo.pdb foo.obj bar.lib -out:foo.exe -entry:main
+# RUN: llvm-pdbutil raw -modules %t/foo.pdb | FileCheck %s
+
+# Make sure that the PDB has module descriptors. foo.obj and bar.lib should be
+# absolute paths, and bar.obj should be the relative path passed to llvm-lib.
+
+# CHECK-LABEL: Modules [
+# CHECK-NEXT:   {
+# CHECK-NEXT:     Name: {{.*pdb-lib.s.tmp[/\\]foo.obj}}
+# CHECK-NEXT:     Debug Stream Index:
+# CHECK-NEXT:     Object File Name: {{.*pdb-lib.s.tmp[/\\]foo.obj}}
+# CHECK-NEXT:     Num Files: 0
+# CHECK-NEXT:     Source File Name Idx: 0
+# CHECK-NEXT:     Pdb File Name Idx: 0
+# CHECK-NEXT:     Line Info Byte Size: 0
+# CHECK-NEXT:     C13 Line Info Byte Size: 0
+# CHECK-NEXT:     Symbol Byte Size: 4
+# CHECK-NEXT:     Type Server Index: 0
+# CHECK-NEXT:     Has EC Info: No
+# CHECK-NEXT:   }
+# CHECK-NEXT:   {
+# CHECK-NEXT:     Name: bar.obj
+# CHECK-NEXT:     Debug Stream Index:
+# CHECK-NEXT:     Object File Name: {{.*pdb-lib.s.tmp[/\\]bar.lib}}
+# CHECK-NEXT:     Num Files: 0
+# CHECK-NEXT:     Source File Name Idx: 0
+# CHECK-NEXT:     Pdb File Name Idx: 0
+# CHECK-NEXT:     Line Info Byte Size: 0
+# CHECK-NEXT:     C13 Line Info Byte Size: 0
+# CHECK-NEXT:     Symbol Byte Size: 4
+# CHECK-NEXT:     Type Server Index: 0
+# CHECK-NEXT:     Has EC Info: No
+# CHECK-NEXT:   }
+# CHECK-NEXT:   {
+# CHECK-NEXT:     Name: * Linker *
+# CHECK-NEXT:     Debug Stream Index:
+# CHECK-NEXT:     Object File Name:
+# CHECK-NEXT:     Num Files: 0
+# CHECK-NEXT:     Source File Name Idx: 0
+# CHECK-NEXT:     Pdb File Name Idx: 0
+# CHECK-NEXT:     Line Info Byte Size: 0
+# CHECK-NEXT:     C13 Line Info Byte Size: 0
+# CHECK-NEXT:     Symbol Byte Size: 4
+# CHECK-NEXT:     Type Server Index: 0
+# CHECK-NEXT:     Has EC Info: No
+# CHECK-NEXT:   }
+# CHECK-NEXT: ]
+
+
+        .def     _main;
+        .scl    2;
+        .type   32;
+        .endef
+        .globl  _main
+_main:
+        calll _bar
+        xor %eax, %eax
+        retl
+

lld/trunk/test/COFF/pdb-options.test

 # RUN: yaml2obj < %p/Inputs/pdb1.yaml > %t1.obj
 # RUN: yaml2obj < %p/Inputs/pdb2.yaml > %t2.obj
 
 ; If /DEBUG is not specified, /pdb is ignored.
+# RUN: rm -f %t.pdb
 # RUN: lld-link /pdb:%t.pdb /entry:main /nodefaultlib %t1.obj %t2.obj
 # RUN: not ls %t.pdb
 
 ; If /DEBUG and /pdb are specified, it uses the specified name.
 # RUN: lld-link /DEBUG /pdb:%t.pdb /entry:main /nodefaultlib %t1.obj %t2.obj
 # RUN: ls %t.pdb
 # RUN: rm %t.pdb
 
 ; If /DEBUG is specified but not /pdb, it uses a default name in the current
 ; directory.  This is a bit hacky since but we need to be IN our test specific
 ; temporary directory when we run this command or we can't test this
 # RUN: cd %T
 # RUN: lld-link /DEBUG /entry:main /nodefaultlib %t1.obj %t2.obj
 # RUN: ls %t1.pdb
 # RUN: rm %t*
 # RUN: cd %T/..

lld/trunk/test/COFF/pdb.test

 # RAW-NEXT:   Machine Type: x86
 # RAW-NEXT:   Symbol Record Stream Index: 65535
 # RAW-NEXT:   Public Symbol Stream Index: 65535
 # RAW-NEXT:   Global Symbol Stream Index: 65535
 # RAW-NEXT:   Toolchain Version: 0.0
 # RAW-NEXT:   mspdb00.dll version: 0.0.0
 # RAW-NEXT:   Modules [
 # RAW-NEXT:     {
-# RAW-NEXT:       Name: * Linker *
+# RAW-NEXT:       Name: {{.*}}tmp1.obj
 # RAW-NEXT:       Debug Stream Index: 9
+# RAW-NEXT:       Object File Name: {{.*}}tmp1.obj
+# RAW-NEXT:       Num Files: 0
+# RAW-NEXT:       Source File Name Idx: 0
+# RAW-NEXT:       Pdb File Name Idx: 0
+# RAW-NEXT:       Line Info Byte Size: 0
+# RAW-NEXT:       C13 Line Info Byte Size: 0
+# RAW-NEXT:       Symbol Byte Size: 4
+# RAW-NEXT:       Type Server Index: 0
+# RAW-NEXT:       Has EC Info: No
+# RAW-NEXT:     }
+# RAW-NEXT:     {
+# RAW-NEXT:       Name: {{.*}}tmp2.obj
+# RAW-NEXT:       Debug Stream Index: 10
+# RAW-NEXT:       Object File Name: {{.*}}tmp2.obj
+# RAW-NEXT:       Num Files: 0
+# RAW-NEXT:       Source File Name Idx: 0
+# RAW-NEXT:       Pdb File Name Idx: 0
+# RAW-NEXT:       Line Info Byte Size: 0
+# RAW-NEXT:       C13 Line Info Byte Size: 0
+# RAW-NEXT:       Symbol Byte Size: 4
+# RAW-NEXT:       Type Server Index: 0
+# RAW-NEXT:       Has EC Info: No
+# RAW-NEXT:     }
+# RAW-NEXT:     {
+# RAW-NEXT:       Name: * Linker *
+# RAW-NEXT:       Debug Stream Index: 11
 # RAW-NEXT:       Object File Name:
 # RAW-NEXT:       Num Files: 0
 # RAW-NEXT:       Source File Name Idx: 0
 # RAW-NEXT:       Pdb File Name Idx: 0
 # RAW-NEXT:       Line Info Byte Size: 0
 # RAW-NEXT:       C13 Line Info Byte Size: 0
 # RAW-NEXT:       Symbol Byte Size: 4
 # RAW-NEXT:       Type Server Index: 0
 # RAW-NEXT:       Has EC Info: No
 # RAW-NEXT:     }
 # RAW-NEXT:   ]
 # RAW-NEXT: }
 # RAW-NEXT: Section Contributions [
 # RAW-NEXT:   Contribution {
-# RAW-NEXT:     ISect: 0
+# RAW-NEXT:     ISect: 65535
 # RAW-NEXT:     Off: 1288
 # RAW-NEXT:     Size: 14
 # RAW-NEXT:     Characteristics [ (0x60500020)
 # RAW-NEXT:       IMAGE_SCN_ALIGN_16BYTES (0x500000)
 # RAW-NEXT:       IMAGE_SCN_CNT_CODE (0x20)
 # RAW-NEXT:       IMAGE_SCN_MEM_EXECUTE (0x20000000)
 # RAW-NEXT:       IMAGE_SCN_MEM_READ (0x40000000)
 # RAW-NEXT:     ]
 # RAW-NEXT:     Module {
 # RAW-NEXT:       Index: 0
-# RAW-NEXT:       Name: * Linker *
+# RAW-NEXT:       Name: {{.*}}tmp1.obj
 # RAW-NEXT:     }
 # RAW-NEXT:     Data CRC: 0
 # RAW-NEXT:     Reloc CRC: 0
 # RAW-NEXT:   }
 # RAW-NEXT:   Contribution {
-# RAW-NEXT:     ISect: 0
+# RAW-NEXT:     ISect: 65535
 # RAW-NEXT:     Off: 1312
 # RAW-NEXT:     Size: 8
 # RAW-NEXT:     Characteristics [ (0x40300040)
 # RAW-NEXT:       IMAGE_SCN_ALIGN_4BYTES (0x300000)
 # RAW-NEXT:       IMAGE_SCN_CNT_INITIALIZED_DATA (0x40)
 # RAW-NEXT:       IMAGE_SCN_MEM_READ (0x40000000)
 # RAW-NEXT:     ]
 # RAW-NEXT:     Module {
 # RAW-NEXT:       Index: 0
-# RAW-NEXT:       Name: * Linker *
+# RAW-NEXT:       Name: {{.*}}tmp1.obj
 # RAW-NEXT:     }
 # RAW-NEXT:     Data CRC: 0
 # RAW-NEXT:     Reloc CRC: 0
 # RAW-NEXT:   }
 # RAW-NEXT:   Contribution {
-# RAW-NEXT:     ISect: 0
+# RAW-NEXT:     ISect: 65535
 # RAW-NEXT:     Off: 1320
 # RAW-NEXT:     Size: 12
 # RAW-NEXT:     Characteristics [ (0x40300040)
 # RAW-NEXT:       IMAGE_SCN_ALIGN_4BYTES (0x300000)
 # RAW-NEXT:       IMAGE_SCN_CNT_INITIALIZED_DATA (0x40)
 # RAW-NEXT:       IMAGE_SCN_MEM_READ (0x40000000)
 # RAW-NEXT:     ]
 # RAW-NEXT:     Module {
 # RAW-NEXT:       Index: 0
-# RAW-NEXT:       Name: * Linker *
+# RAW-NEXT:       Name: {{.*}}tmp1.obj
 # RAW-NEXT:     }
 # RAW-NEXT:     Data CRC: 0
 # RAW-NEXT:     Reloc CRC: 0
 # RAW-NEXT:   }
 # RAW-NEXT:   Contribution {
-# RAW-NEXT:     ISect: 0
+# RAW-NEXT:     ISect: 65535
 # RAW-NEXT:     Off: 1144
 # RAW-NEXT:     Size: 6
 # RAW-NEXT:     Characteristics [ (0x60500020)
 # RAW-NEXT:       IMAGE_SCN_ALIGN_16BYTES (0x500000)
 # RAW-NEXT:       IMAGE_SCN_CNT_CODE (0x20)
 # RAW-NEXT:       IMAGE_SCN_MEM_EXECUTE (0x20000000)
 # RAW-NEXT:       IMAGE_SCN_MEM_READ (0x40000000)
 # RAW-NEXT:     ]
 # RAW-NEXT:     Module {
-# RAW-NEXT:       Index: 0
-# RAW-NEXT:       Name: * Linker *
+# RAW-NEXT:       Index: 1
+# RAW-NEXT:       Name: {{.*}}tmp2.obj
 # RAW-NEXT:     }
 # RAW-NEXT:     Data CRC: 0
 # RAW-NEXT:     Reloc CRC: 0
 # RAW-NEXT:   }
 # RAW-NEXT: ]
 # RAW-NEXT: Section Map [
 # RAW-NEXT:   Entry {
 # RAW-NEXT:     Flags [ (0x109)

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

public:
 
   void
   addDebugSubsection(std::unique_ptr<codeview::DebugSubsection> Subsection);
 
   uint16_t getStreamIndex() const;
   StringRef getModuleName() const { return ModuleName; }
   StringRef getObjFileName() const { return ObjFileName; }
 
+  unsigned getModuleIndex() const { return Layout.Mod; }
+
   ArrayRef<std::string> source_files() const {
     return makeArrayRef(SourceFiles);
   }
 
   uint32_t calculateSerializedLength() const;
 
   void finalize();
   Error finalizeMsfLayout();

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

public:
 
   void setVersionHeader(PdbRaw_DbiVer V);
   void setAge(uint32_t A);
   void setBuildNumber(uint16_t B);
   void setPdbDllVersion(uint16_t V);
   void setPdbDllRbld(uint16_t R);
   void setFlags(uint16_t F);
   void setMachineType(PDB_Machine M);
-  void setSectionContribs(ArrayRef<SectionContrib> SecMap);
   void setSectionMap(ArrayRef<SecMapEntry> SecMap);
 
   // Add given bytes as a new stream.
   Error addDbgStream(pdb::DbgHeaderType Type, ArrayRef<uint8_t> Data);
 
   uint32_t calculateSerializedLength() const;
 
   Expected<DbiModuleDescriptorBuilder &> addModuleInfo(StringRef ModuleName);
   Error addModuleSourceFile(StringRef Module, StringRef File);
   Expected<uint32_t> getSourceFileNameIndex(StringRef FileName);
 
   Error finalizeMsfLayout();
 
   Error commit(const msf::MSFLayout &Layout, WritableBinaryStreamRef MsfBuffer);
 
-  // A helper function to create Section Contributions from COFF input
-  // section headers.
-  static std::vector<SectionContrib>
-  createSectionContribs(ArrayRef<llvm::object::coff_section> SecHdrs);
+  void addSectionContrib(DbiModuleDescriptorBuilder *ModuleDbi,
+                         const llvm::object::coff_section *SecHdr);
 
   // 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;
private:
 
   StringMap<std::unique_ptr<DbiModuleDescriptorBuilder>> ModiMap;
   std::vector<DbiModuleDescriptorBuilder *> ModiList;
 
   StringMap<uint32_t> SourceFileNames;
 
   WritableBinaryStreamRef NamesBuffer;
   MutableBinaryByteStream FileInfoBuffer;
-  ArrayRef<SectionContrib> SectionContribs;
+  std::vector<SectionContrib> SectionContribs;
   ArrayRef<SecMapEntry> SectionMap;
   llvm::SmallVector<DebugStream, (int)DbgHeaderType::Max> DbgStreams;
 };
 }
 }
 
 #endif

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

 void DbiStreamBuilder::setPdbDllVersion(uint16_t V) { PdbDllVersion = V; }
 
 void DbiStreamBuilder::setPdbDllRbld(uint16_t R) { PdbDllRbld = R; }
 
 void DbiStreamBuilder::setFlags(uint16_t F) { Flags = F; }
 
 void DbiStreamBuilder::setMachineType(PDB_Machine M) { MachineType = M; }
 
-void DbiStreamBuilder::setSectionContribs(ArrayRef<SectionContrib> Arr) {
-  SectionContribs = Arr;
-}
-
 void DbiStreamBuilder::setSectionMap(ArrayRef<SecMapEntry> SecMap) {
   SectionMap = SecMap;
 }
 
 Error DbiStreamBuilder::addDbgStream(pdb::DbgHeaderType Type,
                                      ArrayRef<uint8_t> Data) {
   if (DbgStreams[(int)Type].StreamNumber)
     return make_error<RawError>(raw_error_code::duplicate_entry,
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;
 }
 
-// A utility function to create Section Contributions
-// for a given input sections.
-std::vector<SectionContrib> DbiStreamBuilder::createSectionContribs(
-    ArrayRef<object::coff_section> SecHdrs) {
-  std::vector<SectionContrib> Ret;
-
-  // Create a SectionContrib for each input section.
-  for (auto &Sec : SecHdrs) {
-    Ret.emplace_back();
-    auto &Entry = Ret.back();
-    memset(&Entry, 0, sizeof(Entry));
-
-    Entry.Off = Sec.PointerToRawData;
-    Entry.Size = Sec.SizeOfRawData;
-    Entry.Characteristics = Sec.Characteristics;
-  }
-  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(
Error DbiStreamBuilder::commit(const msf::MSFLayout &Layout,
   for (auto &M : ModiList) {
     if (auto EC = M->commit(Writer, Layout, MsfBuffer))
       return EC;
   }
 
   if (!SectionContribs.empty()) {
     if (auto EC = Writer.writeEnum(DbiSecContribVer60))
       return EC;
-    if (auto EC = Writer.writeArray(SectionContribs))
+    if (auto EC = Writer.writeArray(makeArrayRef(SectionContribs)))
       return EC;
   }
 
   if (!SectionMap.empty()) {
     ulittle16_t Size = static_cast<ulittle16_t>(SectionMap.size());
     SecMapHeader SMHeader = {Size, Size};
     if (auto EC = Writer.writeObject(SMHeader))
       return EC;