[PDB] Print section contributions and section map

[zturner]

Summary

I'm not sure how to interpret either of these arrays, but at least we understand the format.

I suspect that the section map is used for determining RVAs of relocated fields, but I don't know how to do the calculation, and none of the fields of OMFSegMapDesc are documented in Microsoft headers (aside from printing their values, which is how I arrived at the layout) so the meaning is unclear.

[zturner]

So apparently entries in the SectionMap correspond to the symbols of type COFF Group and Section. For example, if you look at the Entry field in the section map which has Section=2, and then you go up to the Symbol section and look for all the COFF Group entries with Segment=2 and add up their lengths, you will see that they match. I'm still not sure what to use the fields of the section map entries for though. I assume those Flags are important, but unfortunately they are undocumented.

[zturner]

Also print out image section characteristics of the COFF Group and COFF Section symbols that appear in the modules' symbol tables.

[rnk]

include/llvm/DebugInfo/CodeView/EnumTables.h

27 ↗

(On Diff #59268)

These shouldn't live in headers, they'll be duplicated in all TUs that use them. Probably the best way to expose this would be to declare a function that returns an ArrayRef of register names, and then implement that in the .cpp file, given that we don't want to duplicate the size of the array in the header. Keep the prototypes in the SymbolDumper.h header.

include/llvm/DebugInfo/PDB/Raw/RawTypes.h

32

Is Contr short for Contribution? Maybe Contrib instead of Contr?

45

This isn't "standard layout" unfortunately:
http://en.cppreference.com/w/cpp/concept/StandardLayoutType

ASan actually has a mode that inserts additional padding between fields of non-standard layout types, but it was never productionized. Instead of using inheritance, I'd have the first member be the normal SectionContrib type.

[zturner]

Updated based on suggestions

[ruiu]

tools/llvm-pdbdump/llvm-pdbdump.cpp

186

section-contribs?

553

I'd do s/contr/contrib/g to all files in this patch.

562

Define this class outside of this function.

Also this class definition made me think of the visitor design choice. Currently visitor's callback is a class with visit() member function. But it can be just a std::function, no? We can create a lambda here and pass it to visitSectionContributions function.

583

Why do you have to call flush?

[zturner]

tools/llvm-pdbdump/llvm-pdbdump.cpp

553

A little tricky since that will catch Contrib too, but anyway I'll fix up the rest of the instances.

562

The problem is we don't know whether it will be called back with a SectionContrib or a SectionContrib2. If it were possible to make a "multi lambda" or something that supported overloads, then yes we could do that. Of course, I could raise the logic outside and use a switch statement, but in general I like the pattern of handling variant-data with a visitor.

Is there a reason to prefer defining the class outside the function? This is effectively a lambda with an overload, so just like your lambda would be scoped to the function, I wrote the class the same way.

583

Not strictly necessary, other dump functions do this as well, I guess because it's nice to be able to see the output in a debugger if you're stepping through

[ruiu]

tools/llvm-pdbdump/llvm-pdbdump.cpp

562

OK, if there's a chance for the class to have more than two callback functions, using a class makes sense to me. But currently it has only one callback function, so I'd do with a simple lambda rather than a class to avoid overdesining. I guess it's your call.

No particular reason to not avoid defining classes inside functions, but it is at least rather unusual in LLVM. If it is a deliberate choice and if you like this, it's OK to me.

[zturner]

tools/llvm-pdbdump/llvm-pdbdump.cpp

562

It already has 2 functions. visit is overloaded to take a const SectionContrib & and a const SectionContrib2 &. See below this function, where the overload delegates to this version of the function and then prints out additional data.

[zturner]

Figured out the flags and documented the field descriptions, also cleaned up enum tables and made them more consistent.

[rnk]

lgtm with nits

include/llvm/DebugInfo/PDB/Raw/DbiStream.h

74

s/Contr/Contrib/?

lib/DebugInfo/PDB/Raw/EnumTables.cpp

32–34 ↗

(On Diff #59300)

A less fragile way to do this is to declare it like:

ArrayRef<EnumEntry<uint16_t>> llvm::pdb::getOMFSegMapDescFlagNames() { ...

[ruiu]

LGTM

[majnemer]

test/DebugInfo/PDB/pdbdump-headers.test

1125

Can we pretty print these flags?

[zturner]

test/DebugInfo/PDB/pdbdump-headers.test

1125

Already done in this revision (see llvm-pdbdump.cpp), I just forgot to update the test. It's working locally.

[Eugene.Zelenko]

Committed in r271488.

include/llvm/DebugInfo/CodeView/StreamReader.h

public:
   Error readBytes(ArrayRef<uint8_t> &Buffer, uint32_t Size);
   Error readInteger(uint16_t &Dest);
   Error readInteger(uint32_t &Dest);
   Error readZeroString(StringRef &Dest);
   Error readFixedString(StringRef &Dest, uint32_t Length);
   Error readStreamRef(StreamRef &Ref);
   Error readStreamRef(StreamRef &Ref, uint32_t Length);
 
+  template <typename T> Error readEnum(T &Dest) {
+    typename std::underlying_type<T>::type N;
+    if (auto EC = readInteger(N))
+      return EC;
+    Dest = static_cast<T>(N);
+    return Error::success();
+  }
+
   template <typename T> Error readObject(const T *&Dest) {
     ArrayRef<uint8_t> Buffer;
     if (auto EC = readBytes(Buffer, sizeof(T)))
       return EC;
     Dest = reinterpret_cast<const T *>(Buffer.data());
     return Error::success();
   }
 

include/llvm/DebugInfo/PDB/Raw/DbiStream.h

 
 #include "llvm/DebugInfo/CodeView/StreamArray.h"
 #include "llvm/DebugInfo/CodeView/StreamRef.h"
 #include "llvm/DebugInfo/PDB/PDBTypes.h"
 #include "llvm/DebugInfo/PDB/Raw/MappedBlockStream.h"
 #include "llvm/DebugInfo/PDB/Raw/ModInfo.h"
 #include "llvm/DebugInfo/PDB/Raw/NameHashTable.h"
 #include "llvm/DebugInfo/PDB/Raw/RawConstants.h"
+#include "llvm/DebugInfo/PDB/Raw/RawTypes.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Error.h"
 
 namespace llvm {
 namespace pdb {
 class PDBFile;
+class ISectionContrVisitor;
 
 class DbiStream {
   struct HeaderInfo;
 
 public:
   DbiStream(PDBFile &File);
   ~DbiStream();
   Error reload();
public:
   uint16_t getBuildMinorVersion() const;
 
   uint32_t getPdbDllVersion() const;
 
   uint32_t getSymRecordStreamIndex() const;
 
   PDB_Machine getMachineType() const;
 
+  uint32_t getDebugStreamIndex(DbgHeaderType Type) const;
+
   ArrayRef<ModuleInfoEx> modules() const;
 
-  uint32_t getDebugStreamIndex(DbgHeaderType Type) const;
+  codeview::FixedStreamArray<SecMapEntry> getSectionMap() const;
+  void visitSectionContributions(ISectionContrVisitor &Visitor) const;
 
 private:
+  Error initializeSectionContributionData();
+  Error initializeSectionMapData();
   Error initializeFileInfo();
 
   PDBFile &Pdb;
   MappedBlockStream Stream;
 
   std::vector<ModuleInfoEx> ModuleInfos;
   NameHashTable ECNames;
 
   codeview::StreamRef ModInfoSubstream;
   codeview::StreamRef SecContrSubstream;
   codeview::StreamRef SecMapSubstream;
   codeview::StreamRef FileInfoSubstream;
   codeview::StreamRef TypeServerMapSubstream;
   codeview::StreamRef ECSubstream;
 
   codeview::FixedStreamArray<support::ulittle16_t> DbgStreams;
 
+  PdbRaw_DbiSecContrVer SectionContrVersion;
+  codeview::FixedStreamArray<SectionContr> SectionContrs;
+  codeview::FixedStreamArray<SectionContr2> SectionContrs2;
+  codeview::FixedStreamArray<SecMapEntry> SectionMap;
+
   const HeaderInfo *Header;
 };
 }
 }
 
 #endif

include/llvm/DebugInfo/PDB/Raw/ISectionContrVisitor.h

+//===- ISectionContrVisitor.h -----------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEBUGINFO_PDB_RAW_ISECTIONCONTRVISITOR_H
+#define LLVM_DEBUGINFO_PDB_RAW_ISECTIONCONTRVISITOR_H
+
+namespace llvm {
+namespace pdb {
+struct SectionContr;
+struct SectionContr2;
+
+class ISectionContrVisitor {
+public:
+  virtual ~ISectionContrVisitor() {}
+
+  virtual void visit(const SectionContr &C) = 0;
+  virtual void visit(const SectionContr2 &C) = 0;
+};
+} // namespace pdb
+} // namespace llvm
+
+#endif // LLVM_DEBUGINFO_PDB_RAW_ISECTIONCONTRVISITOR_H
 No newline at end of file

include/llvm/DebugInfo/PDB/Raw/PublicsStream.h

 #ifndef LLVM_DEBUGINFO_PDB_RAW_PUBLICSSTREAM_H
 #define LLVM_DEBUGINFO_PDB_RAW_PUBLICSSTREAM_H
 
 #include "llvm/DebugInfo/CodeView/StreamArray.h"
 #include "llvm/DebugInfo/CodeView/SymbolRecord.h"
 #include "llvm/DebugInfo/PDB/PDBTypes.h"
 #include "llvm/DebugInfo/PDB/Raw/MappedBlockStream.h"
 #include "llvm/DebugInfo/PDB/Raw/RawConstants.h"
+#include "llvm/DebugInfo/PDB/Raw/RawTypes.h"
 
 #include "llvm/Support/Error.h"
 
 namespace llvm {
 namespace pdb {
 class DbiStream;
 class PDBFile;
 

include/llvm/DebugInfo/PDB/Raw/RawConstants.h

-//===- PDBRawConstants.h ----------------------------------------*- C++ -*-===//
+//===- RawConstants.h -------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_PDB_RAW_PDBRAWCONSTANTS_H
 #define LLVM_DEBUGINFO_PDB_RAW_PDBRAWCONSTANTS_H
 
-#include "llvm/Support/Endian.h"
-
 #include <cstdint>
 
 namespace llvm {
 namespace pdb {
 
 enum PdbRaw_ImplVer : uint32_t {
   PdbImplVC2 = 19941610,
   PdbImplVC4 = 19950623,

 enum PdbRaw_TpiVer : uint32_t {
   PdbTpiV40 = 19950410,
   PdbTpiV41 = 19951122,
   PdbTpiV50 = 19961031,
   PdbTpiV70 = 19990903,
   PdbTpiV80 = 20040203,
 };
 
+enum PdbRaw_DbiSecContrVer : uint32_t {
+  DbiSecContrVer60 = 0xeffe0000 + 19970605,
+  DbiSecContrV2 = 0xeffe0000 + 20140516
+};
+
 enum SpecialStream : uint32_t {
   // Stream 0 contains the copy of previous version of the MSF directory.
   // We are not currently using it, but technically if we find the main
   // MSF is corrupted, we could fallback to it.
   OldMSFDirectory = 0,
 
   StreamPDB = 1,
   StreamTPI = 2,
enum class DbgHeaderType : uint16_t {
   TokenRidMap,
   Xdata,
   Pdata,
   NewFPO,
   SectionHdrOrig,
   Max
 };
 
-// This struct is defined as "SO" in langapi/include/pdb.h.
-struct SectionOffset {
-  support::ulittle32_t Off;
-  support::ulittle16_t Isect;
-  char Padding[2];
-};
-
-// This is HRFile.
-struct PSHashRecord {
-  support::ulittle32_t Off; // Offset in the symbol record stream
-  support::ulittle32_t CRef;
-};
-
 } // end namespace pdb
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_PDB_RAW_PDBRAWCONSTANTS_H

include/llvm/DebugInfo/PDB/Raw/RawTypes.h

+//===- RawTypes.h -----------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEBUGINFO_PDB_RAW_RAWTYPES_H
+#define LLVM_DEBUGINFO_PDB_RAW_RAWTYPES_H
+
+#include "llvm/Support/Endian.h"
+
+namespace llvm {
+namespace pdb {
+// This struct is defined as "SO" in langapi/include/pdb.h.
+struct SectionOffset {
+  support::ulittle32_t Off;
+  support::ulittle16_t Isect;
+  char Padding[2];
+};
+
+// This is HRFile.
+struct PSHashRecord {
+  support::ulittle32_t Off; // Offset in the symbol record stream
+  support::ulittle32_t CRef;
+};
+
+// This struct is defined as `SC` in include/dbicommon.h
+struct SectionContr {
+  support::ulittle16_t ISect;
+  char Padding[2];
+  support::little32_t Off;
+  support::little32_t Size;
+  support::ulittle32_t Characteristics;
+  support::ulittle16_t Imod;
+  char Padding2[2];
+  support::ulittle32_t DataCrc;
+  support::ulittle32_t RelocCrc;
+};
+
+// This struct is defined as `SC2` in include/dbicommon.h
+struct SectionContr2 : public SectionContr {
+  support::ulittle32_t ISectCoff;
+};
+
+// This corresponds to the `OMFSegMap` structure.  The definition is not
+// present in the reference implementation, but the layout is derived from
+// code that accesses the fields.
+struct SecMapHeader {
+  support::ulittle16_t SecCount;
+  support::ulittle16_t SecCountLog;
+};
+
+// This corresponds to the `OMFSegMapDesc` structure.  The definition is not
+// present in the reference implementation, but the layout is derived from
+// code that accesses the fields.
+struct SecMapEntry {
+  support::ulittle16_t Flags;
+  support::ulittle16_t Ovl;
+  support::ulittle16_t Group;
+  support::ulittle16_t Frame;
+  support::ulittle16_t SecName;
+  support::ulittle16_t ClassName;
+  support::ulittle32_t Offset;
+  support::ulittle32_t SecByteLength;
+};
+
+} // namespace pdb
+} // namespace llvm
+
+#endif
 No newline at end of file

lib/DebugInfo/PDB/Raw/DbiStream.cpp

 //===- DbiStream.cpp - PDB Dbi Stream (Stream 3) Access -------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 #include "llvm/DebugInfo/PDB/Raw/DbiStream.h"
 
 #include "llvm/DebugInfo/CodeView/StreamArray.h"
 #include "llvm/DebugInfo/CodeView/StreamReader.h"
+#include "llvm/DebugInfo/PDB/Raw/ISectionContrVisitor.h"
 #include "llvm/DebugInfo/PDB/Raw/InfoStream.h"
 #include "llvm/DebugInfo/PDB/Raw/ModInfo.h"
 #include "llvm/DebugInfo/PDB/Raw/NameHashTable.h"
 #include "llvm/DebugInfo/PDB/Raw/PDBFile.h"
 #include "llvm/DebugInfo/PDB/Raw/RawConstants.h"
 #include "llvm/DebugInfo/PDB/Raw/RawError.h"
+#include "llvm/DebugInfo/PDB/Raw/RawTypes.h"
 
 using namespace llvm;
+using namespace llvm::codeview;
 using namespace llvm::pdb;
 using namespace llvm::support;
 
 namespace {
 // Some of the values are stored in bitfields.  Since this needs to be portable
 // across compilers and architectures (big / little endian in particular) we
 // can't use the actual structures below, but must instead do the shifting
 // and masking ourselves.  The struct definitions are provided for reference.
struct DbiStream::HeaderInfo {
   little32_t OptionalDbgHdrSize;  // Size of DbgHeader info
   little32_t ECSubstreamSize;     // Size of EC stream (what is EC?)
   ulittle16_t Flags;              // See DbiFlags enum.
   ulittle16_t MachineType;        // See PDB_MachineType enum.
 
   ulittle32_t Reserved; // Pad to 64 bytes
 };
 
+template <typename ContrType>
+Error loadSectionContributions(FixedStreamArray<ContrType> &Output,
+                               StreamReader &Reader) {
+  if (Reader.bytesRemaining() % sizeof(ContrType) != 0)
+    return make_error<RawError>(
+        raw_error_code::corrupt_file,
+        "Invalid number of bytes of section contributions");
+
+  uint32_t Count = Reader.bytesRemaining() / sizeof(ContrType);
+  if (auto EC = Reader.readArray(Output, Count))
+    return EC;
+  return Error::success();
+}
+
 DbiStream::DbiStream(PDBFile &File)
     : Pdb(File), Stream(StreamDBI, File), Header(nullptr) {
   static_assert(sizeof(HeaderInfo) == 64, "Invalid HeaderInfo size!");
 }
 
 DbiStream::~DbiStream() {}
 
 Error DbiStream::reload() {
-  codeview::StreamReader Reader(Stream);
+  StreamReader Reader(Stream);
 
   if (Stream.getLength() < sizeof(HeaderInfo))
     return make_error<RawError>(raw_error_code::corrupt_file,
                                 "DBI Stream does not contain a header.");
   if (auto EC = Reader.readObject(Header))
     return make_error<RawError>(raw_error_code::corrupt_file,
                                 "DBI Stream does not contain a header.");
 
   if (Header->VersionSignature != -1)
     return make_error<RawError>(raw_error_code::corrupt_file,
                                 "Invalid DBI version signature.");
 
   // Require at least version 7, which should be present in all PDBs
   // produced in the last decade and allows us to avoid having to
   // special case all kinds of complicated arcane formats.
   if (Header->VersionHeader < PdbDbiV70)
-    return make_error<RawError>(raw_error_code::corrupt_file,
+    return make_error<RawError>(raw_error_code::feature_unsupported,
                                 "Unsupported DBI version.");
 
   auto InfoStream = Pdb.getPDBInfoStream();
   if (auto EC = InfoStream.takeError())
     return EC;
 
   if (Header->Age != InfoStream.get().getAge())
     return make_error<RawError>(raw_error_code::corrupt_file,
if (Header->FileInfoSize % sizeof(uint32_t) != 0)
     return make_error<RawError>(raw_error_code::corrupt_file,
                                 "DBI file info substream not aligned.");
   if (Header->TypeServerSize % sizeof(uint32_t) != 0)
     return make_error<RawError>(raw_error_code::corrupt_file,
                                 "DBI type server substream not aligned.");
 
   // Since each ModInfo in the stream is a variable length, we have to iterate
   // them to know how many there actually are.
-  codeview::VarStreamArray<ModInfo> ModInfoArray;
+  VarStreamArray<ModInfo> ModInfoArray;
   if (auto EC = Reader.readArray(ModInfoArray, Header->ModiSubstreamSize))
     return EC;
   for (auto &Info : ModInfoArray) {
     ModuleInfos.emplace_back(Info);
   }
 
   if (auto EC = Reader.readStreamRef(SecContrSubstream,
                                      Header->SecContrSubstreamSize))
     return EC;
   if (auto EC = Reader.readStreamRef(SecMapSubstream, Header->SectionMapSize))
     return EC;
   if (auto EC = Reader.readStreamRef(FileInfoSubstream, Header->FileInfoSize))
     return EC;
   if (auto EC =
           Reader.readStreamRef(TypeServerMapSubstream, Header->TypeServerSize))
     return EC;
   if (auto EC = Reader.readStreamRef(ECSubstream, Header->ECSubstreamSize))
     return EC;
   if (auto EC = Reader.readArray(DbgStreams, Header->OptionalDbgHdrSize /
                                                  sizeof(ulittle16_t)))
     return EC;
 
+  if (auto EC = initializeSectionContributionData())
+    return EC;
+
+  if (auto EC = initializeSectionMapData())
+    return EC;
+
   if (auto EC = initializeFileInfo())
     return EC;
 
   if (Reader.bytesRemaining() > 0)
     return make_error<RawError>(raw_error_code::corrupt_file,
                                 "Found unexpected bytes in DBI Stream.");
 
-  codeview::StreamReader ECReader(ECSubstream);
+  StreamReader ECReader(ECSubstream);
   if (auto EC = ECNames.load(ECReader))
     return EC;
 
   return Error::success();
 }
 
 PdbRaw_DbiVer DbiStream::getDbiVersion() const {
   uint32_t Value = Header->VersionHeader;

 }
 
 PDB_Machine DbiStream::getMachineType() const {
   uint16_t Machine = Header->MachineType;
   return static_cast<PDB_Machine>(Machine);
 }
 
 ArrayRef<ModuleInfoEx> DbiStream::modules() const { return ModuleInfos; }
+codeview::FixedStreamArray<SecMapEntry> DbiStream::getSectionMap() const {
+  return SectionMap;
+}
+
+void llvm::pdb::DbiStream::visitSectionContributions(
+    ISectionContrVisitor &Visitor) const {
+  if (SectionContrVersion == DbiSecContrVer60) {
+    for (auto &SC : SectionContrs)
+      Visitor.visit(SC);
+  } else if (SectionContrVersion == DbiSecContrV2) {
+    for (auto &SC : SectionContrs2)
+      Visitor.visit(SC);
+  }
+}
+
+Error DbiStream::initializeSectionContributionData() {
+  StreamReader SCReader(SecContrSubstream);
+  if (auto EC = SCReader.readEnum(SectionContrVersion))
+    return EC;
+
+  if (SectionContrVersion == DbiSecContrVer60)
+    return loadSectionContributions<SectionContr>(SectionContrs, SCReader);
+  if (SectionContrVersion == DbiSecContrV2)
+    return loadSectionContributions<SectionContr2>(SectionContrs2, SCReader);
+
+  return make_error<RawError>(raw_error_code::feature_unsupported,
+                              "Unsupported DBI Section Contribution version");
+}
+
+Error DbiStream::initializeSectionMapData() {
+  StreamReader SMReader(SecMapSubstream);
+  const SecMapHeader *Header;
+  if (auto EC = SMReader.readObject(Header))
+    return EC;
+  if (auto EC = SMReader.readArray(SectionMap, Header->SecCount))
+    return EC;
+  return Error::success();
+}
 
 Error DbiStream::initializeFileInfo() {
   struct FileInfoSubstreamHeader {
     ulittle16_t NumModules;     // Total # of modules, should match number of
                                 // records in the ModuleInfo substream.
     ulittle16_t NumSourceFiles; // Total # of source files.  This value is not
                                 // accurate because PDB actually supports more
                                 // than 64k source files, so we ignore it and
                                 // compute the value from other stream fields.
   };
 
   // The layout of the FileInfoSubstream is like this:
   // struct {
   //   ulittle16_t NumModules;
   //   ulittle16_t NumSourceFiles;
   //   ulittle16_t ModIndices[NumModules];
   //   ulittle16_t ModFileCounts[NumModules];
   //   ulittle32_t FileNameOffsets[NumSourceFiles];
   //   char Names[][NumSourceFiles];
   // };
   // with the caveat that `NumSourceFiles` cannot be trusted, so
   // it is computed by summing `ModFileCounts`.
   //
   const FileInfoSubstreamHeader *FH;
-  codeview::StreamReader FISR(FileInfoSubstream);
+  StreamReader FISR(FileInfoSubstream);
   if (auto EC = FISR.readObject(FH))
     return EC;
 
   // The number of modules in the stream should be the same as reported by
   // the FileInfoSubstreamHeader.
   if (FH->NumModules != ModuleInfos.size())
     return make_error<RawError>(raw_error_code::corrupt_file,
                                 "FileInfo substream count doesn't match DBI.");
 
-  codeview::FixedStreamArray<ulittle16_t> ModIndexArray;
-  codeview::FixedStreamArray<ulittle16_t> ModFileCountArray;
-  codeview::FixedStreamArray<little32_t> FileNameOffsets;
+  FixedStreamArray<ulittle16_t> ModIndexArray;
+  FixedStreamArray<ulittle16_t> ModFileCountArray;
+  FixedStreamArray<little32_t> FileNameOffsets;
 
   // First is an array of `NumModules` module indices.  This is not used for the
   // same reason that `NumSourceFiles` is not used.  It's an array of uint16's,
   // but it's possible there are more than 64k source files, which would imply
   // more than 64k modules (e.g. object files) as well.  So we ignore this
   // field.
   if (auto EC = FISR.readArray(ModIndexArray, ModuleInfos.size()))
     return EC;
Error DbiStream::initializeFileInfo() {
   // when reading from the file on 64-bit systems, we continue to ignore that
   // field in `ModInfo`, and instead build a vector of StringRefs and stores
   // them in `ModuleInfoEx`.  The value written to and read from the file is
   // not used anyway, it is only there as a way to store the offsets for the
   // purposes of later accessing the names at runtime.
   if (auto EC = FISR.readArray(FileNameOffsets, NumSourceFiles))
     return EC;
 
-  codeview::StreamRef NamesBufferRef;
+  StreamRef NamesBufferRef;
   if (auto EC = FISR.readStreamRef(NamesBufferRef))
     return EC;
-  codeview::StreamReader Names(NamesBufferRef);
+  StreamReader Names(NamesBufferRef);
 
   // We go through each ModuleInfo, determine the number N of source files for
   // that module, and then get the next N offsets from the Offsets array, using
   // them to get the corresponding N names from the Names buffer and associating
   // each one with the corresponding module.
   uint32_t NextFileIndex = 0;
   for (size_t I = 0; I < ModuleInfos.size(); ++I) {
     uint32_t NumFiles = ModFileCountArray[I];

lib/DebugInfo/PDB/Raw/ModStream.cpp

if (auto EC = Reader.readInteger(SymbolSubstreamSig))
     return EC;
   if (auto EC = Reader.readArray(SymbolsSubstream, SymbolSize - 4))
     return EC;
 
   if (auto EC = Reader.readStreamRef(LinesSubstream, C11Size))
     return EC;
   if (auto EC = Reader.readStreamRef(C13LinesSubstream, C13Size))
     return EC;
+  ArrayRef<uint8_t> LineBytes;
+  codeview::StreamReader LinesReader(C13LinesSubstream);
+  if (auto EC = LinesReader.readBytes(LineBytes, C13LinesSubstream.getLength()))
+    return EC;
 
   uint32_t GlobalRefsSize;
   if (auto EC = Reader.readInteger(GlobalRefsSize))
     return EC;
   if (auto EC = Reader.readStreamRef(GlobalRefsSubstream, GlobalRefsSize))
     return EC;
   if (Reader.bytesRemaining() > 0)
     return llvm::make_error<RawError>(raw_error_code::corrupt_file,

test/DebugInfo/PDB/pdbdump-headers.test

 ; ALL:             Characteristics: 0x42000040
 ; ALL:             Name: .reloc
 ; ALL:           }
 ; ALL:         }
 ; ALL:       ]
 ; ALL:     }
 ; ALL:   ]
 ; ALL: }
+; ALL: Section Contributions [
+; ALL:   Contribution {
+; ALL:     ISect: 1
+; ALL:     Off: 0
+; ALL:     Size: 10
+; ALL:     Characteristics [ (0x60000020)
+; ALL:       IMAGE_SCN_CNT_CODE (0x20)
+; ALL:       IMAGE_SCN_MEM_EXECUTE (0x20000000)
+; ALL:       IMAGE_SCN_MEM_READ (0x40000000)
+; ALL:     ]
+; ALL:     Module {
+; ALL:       Index: 1
+; ALL:       Name: * Linker *
+; ALL:     }
+; ALL:     Data CRC: 0
+; ALL:     Reloc CRC: 0
+; ALL:   }
+; ALL:   Contribution {
+; ALL:     ISect: 1
+; ALL:     Off: 16
+; ALL:     Size: 10
+; ALL:     Characteristics [ (0x60500020)
+; ALL:       IMAGE_SCN_ALIGN_16BYTES (0x500000)
+; ALL:       IMAGE_SCN_CNT_CODE (0x20)
+; ALL:       IMAGE_SCN_MEM_EXECUTE (0x20000000)
+; ALL:       IMAGE_SCN_MEM_READ (0x40000000)
+; ALL:     ]
+; ALL:     Module {
+; ALL:       Index: 0
+; ALL:       Name: d:\src\llvm\test\DebugInfo\PDB\Inputs\empty.obj
+; ALL:     }
+; ALL:     Data CRC: 3617027124
+; ALL:     Reloc CRC: 0
+; ALL:   }
+; ALL:   Contribution {
+; ALL:     ISect: 2
+; ALL:     Off: 0
+; ALL:     Size: 56
+; ALL:     Characteristics [ (0x40000040)
+; ALL:       IMAGE_SCN_CNT_INITIALIZED_DATA (0x40)
+; ALL:       IMAGE_SCN_MEM_READ (0x40000000)
+; ALL:     ]
+; ALL:     Module {
+; ALL:       Index: 1
+; ALL:       Name: * Linker *
+; ALL:     }
+; ALL:     Data CRC: 0
+; ALL:     Reloc CRC: 0
+; ALL:   }
+; ALL:   Contribution {
+; ALL:     ISect: 2
+; ALL:     Off: 324
+; ALL:     Size: 72
+; ALL:     Characteristics [ (0x40300040)
+; ALL:       IMAGE_SCN_ALIGN_4BYTES (0x300000)
+; ALL:       IMAGE_SCN_CNT_INITIALIZED_DATA (0x40)
+; ALL:       IMAGE_SCN_MEM_READ (0x40000000)
+; ALL:     ]
+; ALL:     Module {
+; ALL:       Index: 1
+; ALL:       Name: * Linker *
+; ALL:     }
+; ALL:     Data CRC: 0
+; ALL:     Reloc CRC: 0
+; ALL:   }
+; ALL:   Contribution {
+; ALL:     ISect: 2
+; ALL:     Off: 396
+; ALL:     Size: 20
+; ALL:     Characteristics [ (0x40300040)
+; ALL:       IMAGE_SCN_ALIGN_4BYTES (0x300000)
+; ALL:       IMAGE_SCN_CNT_INITIALIZED_DATA (0x40)
+; ALL:       IMAGE_SCN_MEM_READ (0x40000000)
+; ALL:     ]
+; ALL:     Module {
+; ALL:       Index: 1
+; ALL:       Name: * Linker *
+; ALL:     }
+; ALL:     Data CRC: 0
+; ALL:     Reloc CRC: 0
+; ALL:   }
+; ALL:   Contribution {
+; ALL:     ISect: 3
+; ALL:     Off: 0
+; ALL:     Size: 4
+; ALL:     Characteristics [ (0xC0300080)
+; ALL:       IMAGE_SCN_ALIGN_4BYTES (0x300000)
+; ALL:       IMAGE_SCN_CNT_UNINITIALIZED_DATA (0x80)
+; ALL:       IMAGE_SCN_MEM_READ (0x40000000)
+; ALL:       IMAGE_SCN_MEM_WRITE (0x80000000)
+; ALL:     ]
+; ALL:     Module {
+; ALL:       Index: 0
+; ALL:       Name: d:\src\llvm\test\DebugInfo\PDB\Inputs\empty.obj
+; ALL:     }
+; ALL:     Data CRC: 0
+; ALL:     Reloc CRC: 0
+; ALL:   }
+; ALL: ]
+; ALL: Section Map [
+; ALL:   Entry {
+; ALL:     Flags: 269
+; ALL:     Ovl: 0
+; ALL:     Group: 0
+; ALL:     Frame: 1
+; ALL:     SecName: 65535
+; ALL:     ClassName: 65535
+; ALL:     Offset: 0
+; ALL:     SecByteLength: 4122
+; ALL:   }
+; ALL:   Entry {
+; ALL:     Flags: 265
+; ALL:     Ovl: 0
+; ALL:     Group: 0
+; ALL:     Frame: 2
+; ALL:     SecName: 65535
+; ALL:     ClassName: 65535
+; ALL:     Offset: 0
+; ALL:     SecByteLength: 690
+; ALL:   }
+; ALL:   Entry {
+; ALL:     Flags: 267
+; ALL:     Ovl: 0
+; ALL:     Group: 0
+; ALL:     Frame: 3
+; ALL:     SecName: 65535
+; ALL:     ClassName: 65535
+; ALL:     Offset: 0
+; ALL:     SecByteLength: 4
+; ALL:   }
+; ALL:   Entry {
+; ALL:     Flags: 265
+; ALL:     Ovl: 0
+; ALL:     Group: 0
+; ALL:     Frame: 4
+; ALL:     SecName: 65535
+; ALL:     ClassName: 65535
+; ALL:     Offset: 0
+; ALL:     SecByteLength: 8
+; ALL:   }
+; ALL:   Entry {
+; ALL:     Flags: 520
+; ALL:     Ovl: 0
+; ALL:     Group: 0
+; ALL:     Frame: 0
+; ALL:     SecName: 65535
+; ALL:     ClassName: 65535
+; ALL:     Offset: 0
+; ALL:     SecByteLength: 4294967295
+; ALL:   }
+; ALL: ]
 ; ALL: Publics Stream {
 ; ALL:   Stream number: 7
 ; ALL:   SymHash: 556
 ; ALL:   AddrMap: 8
 ; ALL:   Number of buckets: 2
 ; ALL:   Hash Buckets: [0, 12]
 ; ALL:   Address Map: [36, 0]
 ; ALL:   Thunk Map: [4112]

tools/llvm-pdbdump/llvm-pdbdump.cpp

 #include "llvm/DebugInfo/PDB/IPDBSession.h"
 #include "llvm/DebugInfo/PDB/PDB.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolCompiland.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolData.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolExe.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolFunc.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolThunk.h"
 #include "llvm/DebugInfo/PDB/Raw/DbiStream.h"
+#include "llvm/DebugInfo/PDB/Raw/ISectionContrVisitor.h"
 #include "llvm/DebugInfo/PDB/Raw/InfoStream.h"
 #include "llvm/DebugInfo/PDB/Raw/MappedBlockStream.h"
 #include "llvm/DebugInfo/PDB/Raw/ModInfo.h"
 #include "llvm/DebugInfo/PDB/Raw/ModStream.h"
 #include "llvm/DebugInfo/PDB/Raw/NameHashTable.h"
 #include "llvm/DebugInfo/PDB/Raw/PDBFile.h"
 #include "llvm/DebugInfo/PDB/Raw/PublicsStream.h"
 #include "llvm/DebugInfo/PDB/Raw/RawError.h"
 #include "llvm/DebugInfo/PDB/Raw/RawSession.h"
 #include "llvm/DebugInfo/PDB/Raw/TpiStream.h"
+#include "llvm/Support/COFF.h"
+#include "llvm/Support/COM.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/raw_ostream.h"
 
-#if defined(HAVE_DIA_SDK)
-#ifndef NOMINMAX
-#define NOMINMAX
-#endif
-#include <Windows.h>
-#endif
-
 using namespace llvm;
 using namespace llvm::pdb;
 
+namespace {
+#define LLVM_PDBDUMP_ENUM_ENT(ns, enum)                                        \
+  { #enum, ns::enum }
+
+static const EnumEntry<COFF::SectionCharacteristics>
+    ImageSectionCharacteristics[] = {
+        LLVM_PDBDUMP_ENUM_ENT(COFF, IMAGE_SCN_TYPE_NOLOAD),
+        LLVM_PDBDUMP_ENUM_ENT(COFF, IMAGE_SCN_TYPE_NO_PAD),
+        LLVM_PDBDUMP_ENUM_ENT(COFF, IMAGE_SCN_CNT_CODE),
+        LLVM_PDBDUMP_ENUM_ENT(COFF, IMAGE_SCN_CNT_INITIALIZED_DATA),
+        LLVM_PDBDUMP_ENUM_ENT(COFF, IMAGE_SCN_CNT_UNINITIALIZED_DATA),
+        LLVM_PDBDUMP_ENUM_ENT(COFF, IMAGE_SCN_LNK_OTHER),
+        LLVM_PDBDUMP_ENUM_ENT(COFF, IMAGE_SCN_LNK_INFO),
+        LLVM_PDBDUMP_ENUM_ENT(COFF, IMAGE_SCN_LNK_REMOVE),
+        LLVM_PDBDUMP_ENUM_ENT(COFF, IMAGE_SCN_LNK_COMDAT),
+        LLVM_PDBDUMP_ENUM_ENT(COFF, IMAGE_SCN_GPREL),
+        LLVM_PDBDUMP_ENUM_ENT(COFF, IMAGE_SCN_MEM_PURGEABLE),
+        LLVM_PDBDUMP_ENUM_ENT(COFF, IMAGE_SCN_MEM_16BIT),
+        LLVM_PDBDUMP_ENUM_ENT(COFF, IMAGE_SCN_MEM_LOCKED),
+        LLVM_PDBDUMP_ENUM_ENT(COFF, IMAGE_SCN_MEM_PRELOAD),
+        LLVM_PDBDUMP_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_1BYTES),
+        LLVM_PDBDUMP_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_2BYTES),
+        LLVM_PDBDUMP_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_4BYTES),
+        LLVM_PDBDUMP_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_8BYTES),
+        LLVM_PDBDUMP_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_16BYTES),
+        LLVM_PDBDUMP_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_32BYTES),
+        LLVM_PDBDUMP_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_64BYTES),
+        LLVM_PDBDUMP_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_128BYTES),
+        LLVM_PDBDUMP_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_256BYTES),
+        LLVM_PDBDUMP_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_512BYTES),
+        LLVM_PDBDUMP_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_1024BYTES),
+        LLVM_PDBDUMP_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_2048BYTES),
+        LLVM_PDBDUMP_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_4096BYTES),
+        LLVM_PDBDUMP_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_8192BYTES),
+        LLVM_PDBDUMP_ENUM_ENT(COFF, IMAGE_SCN_LNK_NRELOC_OVFL),
+        LLVM_PDBDUMP_ENUM_ENT(COFF, IMAGE_SCN_MEM_DISCARDABLE),
+        LLVM_PDBDUMP_ENUM_ENT(COFF, IMAGE_SCN_MEM_NOT_CACHED),
+        LLVM_PDBDUMP_ENUM_ENT(COFF, IMAGE_SCN_MEM_NOT_PAGED),
+        LLVM_PDBDUMP_ENUM_ENT(COFF, IMAGE_SCN_MEM_SHARED),
+        LLVM_PDBDUMP_ENUM_ENT(COFF, IMAGE_SCN_MEM_EXECUTE),
+        LLVM_PDBDUMP_ENUM_ENT(COFF, IMAGE_SCN_MEM_READ),
+        LLVM_PDBDUMP_ENUM_ENT(COFF, IMAGE_SCN_MEM_WRITE)};
+}
+
 namespace opts {
 
 enum class PDB_DumpType { ByType, ByObjFile, Both };
 
 cl::list<std::string> InputFilenames(cl::Positional,
                                      cl::desc("<input PDB files>"),
                                      cl::OneOrMore);
 
cl::opt<bool> DumpModules("raw-modules", cl::desc("dump compiland information"),
                           cl::cat(NativeOptions));
 cl::opt<bool> DumpModuleFiles("raw-module-files",
                               cl::desc("dump file information"),
                               cl::cat(NativeOptions));
 cl::opt<bool> DumpModuleSyms("raw-module-syms", cl::desc("dump module symbols"),
                              cl::cat(NativeOptions));
 cl::opt<bool> DumpPublics("raw-publics", cl::desc("dump Publics stream data"),
                           cl::cat(NativeOptions));
+cl::opt<bool> DumpSectionContrs("raw-section-contrs",
+                                cl::desc("dump section contributions"),
+                                cl::cat(NativeOptions));
+cl::opt<bool> DumpSectionMap("raw-section-map", cl::desc("dump section map"),
+                             cl::cat(NativeOptions));
 cl::opt<bool>
     DumpSymRecordBytes("raw-sym-record-bytes",
                        cl::desc("dump CodeView symbol record raw bytes"),
                        cl::cat(NativeOptions));
 cl::opt<bool>
     RawAll("raw-all",
            cl::desc("Implies most other options in 'Native Options' category"),
            cl::cat(NativeOptions));
for (auto &Modi : DS.modules()) {
           return make_error<RawError>(raw_error_code::corrupt_file,
                                       "DBI stream contained corrupt record");
       }
     }
   }
   return Error::success();
 }
 
+static Error dumpSectionContrs(ScopedPrinter &P, PDBFile &File) {
+  if (!opts::DumpSectionContrs)
+    return Error::success();
+
+  auto DbiS = File.getPDBDbiStream();
+  if (auto EC = DbiS.takeError())
+    return EC;
+  DbiStream &DS = DbiS.get();
+  ListScope L(P, "Section Contributions");
+  class Visitor : public ISectionContrVisitor {
+  public:
+    Visitor(ScopedPrinter &P, DbiStream &DS) : P(P), DS(DS) {}
+    void visit(const SectionContr &SC) override {
+      DictScope D(P, "Contribution");
+      P.printNumber("ISect", SC.ISect);
+      P.printNumber("Off", SC.Off);
+      P.printNumber("Size", SC.Size);
+      P.printFlags("Characteristics", SC.Characteristics,
+                   makeArrayRef(ImageSectionCharacteristics),
+                   COFF::SectionCharacteristics(0x00F00000));
+      {
+        DictScope DD(P, "Module");
+        P.printNumber("Index", SC.Imod);
+        auto M = DS.modules();
+        if (M.size() > SC.Imod) {
+          P.printString("Name", M[SC.Imod].Info.getModuleName());
+        }
+      }
+      P.printNumber("Data CRC", SC.DataCrc);
+      P.printNumber("Reloc CRC", SC.RelocCrc);
+      P.flush();
+    }
+    void visit(const SectionContr2 &SC) override {
+      visit(static_cast<const SectionContr &>(SC));
+      P.printNumber("ISect Coff", SC.ISectCoff);
+      P.flush();
+    }
+
+  private:
+    ScopedPrinter &P;
+    DbiStream &DS;
+  };
+  Visitor V(P, DS);
+  DS.visitSectionContributions(V);
+  return Error::success();
+}
+
+static Error dumpSectionMap(ScopedPrinter &P, PDBFile &File) {
+  if (!opts::DumpSectionMap)
+    return Error::success();
+
+  auto DbiS = File.getPDBDbiStream();
+  if (auto EC = DbiS.takeError())
+    return EC;
+  DbiStream &DS = DbiS.get();
+  ListScope L(P, "Section Map");
+  for (auto &M : DS.getSectionMap()) {
+    DictScope D(P, "Entry");
+    P.printNumber("Flags", M.Flags);
+    P.printNumber("Ovl", M.Ovl);
+    P.printNumber("Group", M.Group);
+    P.printNumber("Frame", M.Frame);
+    P.printNumber("SecName", M.SecName);
+    P.printNumber("ClassName", M.ClassName);
+    P.printNumber("Offset", M.Offset);
+    P.printNumber("SecByteLength", M.SecByteLength);
+    P.flush();
+  }
+  return Error::success();
+}
+
 static Error dumpTpiStream(ScopedPrinter &P, PDBFile &File,
                            codeview::CVTypeDumper &TD, uint32_t StreamIdx) {
   assert(StreamIdx == StreamTPI || StreamIdx == StreamIPI);
 
   bool DumpRecordBytes = false;
   bool DumpRecords = false;
   StringRef Label;
   StringRef VerLabel;
static Error dumpStructure(RawSession &RS) {
   if (auto EC = dumpTpiStream(P, File, TD, StreamTPI))
     return EC;
   if (auto EC = dumpTpiStream(P, File, TD, StreamIPI))
     return EC;
 
   if (auto EC = dumpDbiStream(P, File, TD))
     return EC;
 
+  if (auto EC = dumpSectionContrs(P, File))
+    return EC;
+
+  if (auto EC = dumpSectionMap(P, File))
+    return EC;
+
   if (auto EC = dumpPublicsStream(P, File, TD))
     return EC;
+
   return Error::success();
 }
 
 bool isRawDumpEnabled() {
   if (opts::DumpHeaders)
     return true;
   if (opts::DumpModules)
     return true;
bool isRawDumpEnabled() {
   if (opts::DumpTpiRecordBytes)
     return true;
   if (opts::DumpTpiRecords)
     return true;
   if (opts::DumpIpiRecords)
     return true;
   if (opts::DumpIpiRecordBytes)
     return true;
+  if (opts::DumpSectionContrs)
+    return true;
+  if (opts::DumpSectionMap)
+    return true;
   return false;
 }
 
 static void dumpInput(StringRef Path) {
   std::unique_ptr<IPDBSession> Session;
   if (isRawDumpEnabled()) {
     ExitOnErr(loadDataForPDB(PDB_ReaderType::Raw, Path, Session));
 
if (opts::RawAll) {
     opts::DumpModules = true;
     opts::DumpModuleFiles = true;
     opts::DumpModuleSyms = true;
     opts::DumpPublics = true;
     opts::DumpStreamSummary = true;
     opts::DumpStreamBlocks = true;
     opts::DumpTpiRecords = true;
     opts::DumpIpiRecords = true;
+    opts::DumpSectionMap = true;
+    opts::DumpSectionContrs = true;
   }
 
   // When adding filters for excluded compilands and types, we need to remember
   // that these are regexes.  So special characters such as * and \ need to be
   // escaped in the regex.  In the case of a literal \, this means it needs to
   // be escaped again in the C++.  So matching a single \ in the input requires
   // 4 \es in the C++.
   if (opts::ExcludeCompilerGenerated) {
     opts::ExcludeTypes.push_back("__vc_attributes");
     opts::ExcludeCompilands.push_back("\\* Linker \\*");
   }
   if (opts::ExcludeSystemLibraries) {
     opts::ExcludeCompilands.push_back(
         "f:\\\\binaries\\\\Intermediate\\\\vctools\\\\crt_bld");
     opts::ExcludeCompilands.push_back("f:\\\\dd\\\\vctools\\\\crt");
     opts::ExcludeCompilands.push_back("d:\\\\th.obj.x86fre\\\\minkernel");
   }
 
-#if defined(HAVE_DIA_SDK)
-  CoInitializeEx(nullptr, COINIT_MULTITHREADED);
-#endif
+  llvm::sys::InitializeCOMRAII COM(llvm::sys::COMThreadingMode::MultiThreaded);
 
   std::for_each(opts::InputFilenames.begin(), opts::InputFilenames.end(),
                 dumpInput);
 
-#if defined(HAVE_DIA_SDK)
-  CoUninitialize();
-#endif
   outs().flush();
   return 0;
 }