[pdb, lld] Write CodeView line tables to PDB.

[zturner]

Summary

In the global DBI stream, there is a list of module descriptors, one for each compiland. These descriptors contain a StreamIndex field, and if it is set to something valid, this stream index contains much more debug info about the module, such as symbols and codeview line info.

Prior to this patch, we were not writing the CodeView line information portion of this stream. This patch adds support for it. The way to use the new functionality is as follows:

PdbFileBuilder Pdb;
auto &Dbi = Pdb.getDbiBuilder();
auto &StringTable = Pdb.getStringTable();

auto &Module = Dbi.addModuleInfo("foo.obj");

StringTable.insert("foo.cpp");
auto &Source = Dbi.addModuleSourceFile("foo.obj", "foo.cpp");

auto Lines = llvm::make_unique<codeview::ModuleDebugLineFragment>();
auto Checksums = llvm::make_unique<codeview::ModuleDebugChecksumFragment>();

// All line contributions for foo.cpp

// Line Number Name Offsets refer to the Dbi string.
Lines->createBlock("foo.cpp", Dbi.getNameIndex("foo.cpp"));
Lines->addLineInfo(CodeOffset, LineNumber);
Lines->addLineInfo(CodeOffset2, LineNumber2);

// All line contributions for foo.h
Lines->createBlock("foo.h", Dbi.getNameIndex("foo.h"));
Lines->addLineInfo(CodeOffset3, LineNumber3);

// File checkum NameOffsets refer to the global string table.
Checksums->addChecksum(StringTable.getNameIndex("foo.cpp"), FileChecksumKind::MD5, llvm::md5(getFileContents("foo.cpp")));

Module.setC13LineInfo(std::move(Lines));
Module.setC13ChecksumInfo(std::move(Checksums));

Pdb.commit("out.pdb");

[zturner]

Fixed an issue where the YAML output and the raw output were different. One was printing the End Delta as the absolute end line, and the other was printing as the delta. Made this consistent, in both cases it is now a delta.

[zturner]

Made this CL a little smaller by committing a portion of it independently. This is the rebased patch with only the portion that is still uncommitted.

[inglorion]

It seems a little awkward to me that we're passing both a filename and an index for the same filename to createBlock. Looking through the code, I get the impression that we don't actually need the StringRef, only the index. If so, could you remove the StringRef?

llvm/include/llvm/DebugInfo/CodeView/ModuleDebugFileChecksumFragment.h

1

Can you change this to "ModuleDebugFileChecksumFragment.h" while you're at it?

[zturner]

Fixed suggestions from inglorion@

[ruiu]

llvm/include/llvm/DebugInfo/CodeView/CodeView.h

550–552

Is k prefix hangarian?

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

64

What is this for?

[zturner]

llvm/include/llvm/DebugInfo/CodeView/CodeView.h

550–552

My bad, I should have called this LF_None and LF_HaveColumns. I'll fix in a follow up

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

64

Good question, I should remove this.

[zturner]

Fixed suggestions from ruiu

[inglorion]

Please also update the example in the summary, e.g. createBlock() now only takes one argument.

[inglorion]

llvm/tools/llvm-pdbdump/llvm-pdbdump.cpp

507

This no longer takes the filename, right?

[zturner]

It turns out the way I'm translating file names is all wrong, and it's not that easy to fix. The work here is mostly done but I'm going to try to fix this up and re-upload. In the meantime, I'll try to see if I can break up certain parts of this change into smaller pieces and submit them, so that when I'm finally done fixing the root of the problem, the resulting CL will be smaller than this one.

llvm/include/llvm/DebugInfo/CodeView/CodeView.h

 };
 
 enum class TrampolineType : uint16_t { TrampIncremental, BranchIsland };
 
 // These values correspond to the CV_SourceChksum_t enumeration.
 enum class FileChecksumKind : uint8_t { None, MD5, SHA1, SHA256 };
 
 enum LineFlags : uint16_t {
-  HaveColumns = 1, // CV_LINES_HAVE_COLUMNS
+  kLineFlagsNone = 0,
+  kLineFlagsHaveColumns = 1, // CV_LINES_HAVE_COLUMNS
 };
 }
 }
 
 #endif

llvm/include/llvm/DebugInfo/CodeView/ModuleDebugFileChecksumFragment.h

-//===- ModuleDebugLineFragment.h --------------------------------*- C++ -*-===//
+//===- ModuleDebugFileChecksumFragment.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_CODEVIEW_MODULEDEBUGFILECHECKSUMFRAGMENT_H
 #define LLVM_DEBUGINFO_CODEVIEW_MODULEDEBUGFILECHECKSUMFRAGMENT_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/DebugInfo/CodeView/ModuleDebugFragment.h"
+#include "llvm/Support/Allocator.h"
 #include "llvm/Support/BinaryStreamArray.h"
 #include "llvm/Support/BinaryStreamReader.h"
 #include "llvm/Support/Endian.h"
 
 namespace llvm {
 namespace codeview {
 
 struct FileChecksumEntry {
public:
 
   static Error extract(BinaryStreamRef Stream, uint32_t &Len,
                        codeview::FileChecksumEntry &Item, void *Ctx);
 };
 }
 
 namespace llvm {
 namespace codeview {
-class ModuleDebugFileChecksumFragment final : public ModuleDebugFragment {
-  typedef VarStreamArray<FileChecksumEntry> FileChecksumArray;
+class ModuleDebugFileChecksumFragmentRef final : public ModuleDebugFragmentRef {
+  typedef VarStreamArray<codeview::FileChecksumEntry> FileChecksumArray;
   typedef FileChecksumArray::Iterator Iterator;
 
 public:
-  ModuleDebugFileChecksumFragment()
-      : ModuleDebugFragment(ModuleDebugFragmentKind::FileChecksums) {}
+  ModuleDebugFileChecksumFragmentRef()
+      : ModuleDebugFragmentRef(ModuleDebugFragmentKind::FileChecksums) {}
 
-  static bool classof(const ModuleDebugFragment *S) {
+  static bool classof(const ModuleDebugFragmentRef *S) {
     return S->kind() == ModuleDebugFragmentKind::FileChecksums;
   }
 
   Error initialize(BinaryStreamReader Reader);
 
   Iterator begin() const { return Checksums.begin(); }
   Iterator end() const { return Checksums.end(); }
 
 private:
   FileChecksumArray Checksums;
 };
+
+class ModuleDebugFileChecksumFragment final : public ModuleDebugFragment {
+public:
+  ModuleDebugFileChecksumFragment();
+
+  static bool classof(const ModuleDebugFragment *S) {
+    return S->kind() == ModuleDebugFragmentKind::FileChecksums;
+  }
+
+  void addChecksum(uint32_t FileNameOffset, FileChecksumKind Kind,
+                   ArrayRef<uint8_t> Bytes);
+
+  uint32_t calculateSerializedLength() override;
+  Error commit(BinaryStreamWriter &Writer) override;
+
+private:
+  uint32_t SerializedSize = 0;
+  llvm::BumpPtrAllocator Storage;
+  std::vector<FileChecksumEntry> Checksums;
+};
 }
 }
 
 #endif

llvm/include/llvm/DebugInfo/CodeView/ModuleDebugFragment.h

 //===- ModuleDebugFragment.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_CODEVIEW_MODULEDEBUGFRAGMENT_H
 #define LLVM_DEBUGINFO_CODEVIEW_MODULEDEBUGFRAGMENT_H
 
 #include "llvm/DebugInfo/CodeView/CodeView.h"
+#include "llvm/Support/BinaryStreamWriter.h"
 #include "llvm/Support/Casting.h"
 
 namespace llvm {
 namespace codeview {
 
+class ModuleDebugFragmentRef {
+public:
+  explicit ModuleDebugFragmentRef(ModuleDebugFragmentKind Kind) : Kind(Kind) {}
+  virtual ~ModuleDebugFragmentRef();
+
+  ModuleDebugFragmentKind kind() const { return Kind; }
+
+protected:
+  ModuleDebugFragmentKind Kind;
+};
+
 class ModuleDebugFragment {
 public:
   explicit ModuleDebugFragment(ModuleDebugFragmentKind Kind) : Kind(Kind) {}
-
   virtual ~ModuleDebugFragment();
+
   ModuleDebugFragmentKind kind() const { return Kind; }
 
+  virtual Error commit(BinaryStreamWriter &Writer) = 0;
+  virtual uint32_t calculateSerializedLength() = 0;
+
 protected:
   ModuleDebugFragmentKind Kind;
 };
 
 } // namespace codeview
 } // namespace llvm
 
 #endif // LLVM_DEBUGINFO_CODEVIEW_MODULEDEBUGFRAGMENT_H

llvm/include/llvm/DebugInfo/CodeView/ModuleDebugFragmentRecord.h

 //===- ModuleDebugFragment.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_CODEVIEW_MODULEDEBUGFRAGMENTRECORD_H
 #define LLVM_DEBUGINFO_CODEVIEW_MODULEDEBUGFRAGMENTRECORD_H
 
 #include "llvm/DebugInfo/CodeView/CodeView.h"
 #include "llvm/Support/BinaryStreamArray.h"
 #include "llvm/Support/BinaryStreamRef.h"
+#include "llvm/Support/BinaryStreamWriter.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Error.h"
 
 namespace llvm {
 namespace codeview {
 
+class ModuleDebugFragment;
+
 // Corresponds to the `CV_DebugSSubsectionHeader_t` structure.
 struct ModuleDebugFragmentHeader {
   support::ulittle32_t Kind;   // codeview::ModuleDebugFragmentKind enum
   support::ulittle32_t Length; // number of bytes occupied by this record.
 };
 
 class ModuleDebugFragmentRecord {
 public:
   ModuleDebugFragmentRecord();
   ModuleDebugFragmentRecord(ModuleDebugFragmentKind Kind, BinaryStreamRef Data);
 
   static Error initialize(BinaryStreamRef Stream,
                           ModuleDebugFragmentRecord &Info);
+
   uint32_t getRecordLength() const;
   ModuleDebugFragmentKind kind() const;
   BinaryStreamRef getRecordData() const;
 
 private:
   ModuleDebugFragmentKind Kind;
   BinaryStreamRef Data;
 };
 
+class ModuleDebugFragmentRecordBuilder {
+public:
+  ModuleDebugFragmentRecordBuilder(ModuleDebugFragmentKind Kind,
+                                   ModuleDebugFragment &Frag);
+  uint32_t calculateSerializedLength();
+  Error commit(BinaryStreamWriter &Writer);
+
+private:
+  ModuleDebugFragmentKind Kind;
+  ModuleDebugFragment &Frag;
+};
+
 typedef VarStreamArray<ModuleDebugFragmentRecord> ModuleDebugFragmentArray;
 
 } // namespace codeview
 
 template <>
 struct VarStreamArrayExtractor<codeview::ModuleDebugFragmentRecord> {
   typedef void ContextType;
 

llvm/include/llvm/DebugInfo/CodeView/ModuleDebugFragmentVisitor.h

 namespace llvm {
 
 namespace codeview {
 
 class ModuleDebugFragmentVisitor {
 public:
   virtual ~ModuleDebugFragmentVisitor() = default;
 
-  virtual Error visitUnknown(ModuleDebugUnknownFragment &Unknown) {
+  virtual Error visitUnknown(ModuleDebugUnknownFragmentRef &Unknown) {
     return Error::success();
   }
-  virtual Error visitLines(ModuleDebugLineFragment &Lines) {
+  virtual Error visitLines(ModuleDebugLineFragmentRef &Lines) {
     return Error::success();
   }
 
-  virtual Error visitFileChecksums(ModuleDebugFileChecksumFragment &Checksums) {
+  virtual Error
+  visitFileChecksums(ModuleDebugFileChecksumFragmentRef &Checksums) {
     return Error::success();
   }
 };
 
 Error visitModuleDebugFragment(const ModuleDebugFragmentRecord &R,
                                ModuleDebugFragmentVisitor &V);
 } // end namespace codeview
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_CODEVIEW_MODULEDEBUGFRAGMENTVISITOR_H

llvm/include/llvm/DebugInfo/CodeView/ModuleDebugLineFragment.h

 //===- ModuleDebugLineFragment.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_CODEVIEW_MODULEDEBUGLINEFRAGMENT_H
 #define LLVM_DEBUGINFO_CODEVIEW_MODULEDEBUGLINEFRAGMENT_H
 
+#include "llvm/DebugInfo/CodeView/Line.h"
 #include "llvm/DebugInfo/CodeView/ModuleDebugFragment.h"
 #include "llvm/Support/BinaryStreamArray.h"
 #include "llvm/Support/BinaryStreamReader.h"
 #include "llvm/Support/Error.h"
 
 namespace llvm {
 namespace codeview {
 

 class LineColumnExtractor {
 public:
   typedef const LineFragmentHeader ContextType;
 
   static Error extract(BinaryStreamRef Stream, uint32_t &Len,
                        LineColumnEntry &Item, const LineFragmentHeader *Header);
 };
 
-class ModuleDebugLineFragment final : public ModuleDebugFragment {
+class ModuleDebugLineFragmentRef final : public ModuleDebugFragmentRef {
   friend class LineColumnExtractor;
   typedef VarStreamArray<LineColumnEntry, LineColumnExtractor> LineInfoArray;
   typedef LineInfoArray::Iterator Iterator;
 
 public:
-  ModuleDebugLineFragment();
+  ModuleDebugLineFragmentRef();
 
-  static bool classof(const ModuleDebugFragment *S) {
+  static bool classof(const ModuleDebugFragmentRef *S) {
     return S->kind() == ModuleDebugFragmentKind::Lines;
   }
 
   Error initialize(BinaryStreamReader Reader);
 
   Iterator begin() const { return LinesAndColumns.begin(); }
   Iterator end() const { return LinesAndColumns.end(); }
 
   const LineFragmentHeader *header() const { return Header; }
 
 private:
   const LineFragmentHeader *Header = nullptr;
   LineInfoArray LinesAndColumns;
 };
+
+class ModuleDebugLineFragment final : public ModuleDebugFragment {
+  struct Block {
+    Block(uint32_t NI) : NameIndex(NI) {}
+
+    uint32_t NameIndex;
+    std::vector<LineNumberEntry> Lines;
+    std::vector<ColumnNumberEntry> Columns;
+  };
+
+public:
+  ModuleDebugLineFragment();
+
+  static bool classof(const ModuleDebugFragment *S) {
+    return S->kind() == ModuleDebugFragmentKind::Lines;
+  }
+
+  void createBlock(uint32_t NameIndex);
+  void addLineInfo(uint32_t Offset, const LineInfo &Line);
+  void addLineAndColumnInfo(uint32_t Offset, const LineInfo &Line,
+                            uint32_t ColStart, uint32_t ColEnd);
+
+  uint32_t calculateSerializedLength() override;
+  Error commit(BinaryStreamWriter &Writer) override;
+
+  void setRelocationAddress(uint16_t Segment, uint16_t Offset);
+  void setCodeSize(uint32_t Size);
+  void setFlags(LineFlags Flags);
+
+  bool hasColumnInfo() const;
+
+private:
+  uint16_t RelocOffset = 0;
+  uint16_t RelocSegment = 0;
+  uint32_t CodeSize = 0;
+  LineFlags Flags = kLineFlagsNone;
+  std::vector<Block> Blocks;
+};
 }
 }
 
 #endif

llvm/include/llvm/DebugInfo/CodeView/ModuleDebugUnknownFragment.h

 #define LLVM_DEBUGINFO_CODEVIEW_MODULEDEBUGUNKNOWNFRAGMENT_H
 
 #include "llvm/DebugInfo/CodeView/ModuleDebugFragment.h"
 #include "llvm/Support/BinaryStreamRef.h"
 
 namespace llvm {
 namespace codeview {
 
-class ModuleDebugUnknownFragment final : public ModuleDebugFragment {
+class ModuleDebugUnknownFragmentRef final : public ModuleDebugFragmentRef {
 public:
-  ModuleDebugUnknownFragment(ModuleDebugFragmentKind Kind, BinaryStreamRef Data)
-      : ModuleDebugFragment(Kind), Data(Data) {}
+  ModuleDebugUnknownFragmentRef(ModuleDebugFragmentKind Kind,
+                                BinaryStreamRef Data)
+      : ModuleDebugFragmentRef(Kind), Data(Data) {}
 
   BinaryStreamRef getData() const { return Data; }
 
 private:
   BinaryStreamRef Data;
 };
 }
 }
 
 #endif

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

public:
   ~DbiModuleDescriptor();
 
   static Error initialize(BinaryStreamRef Stream, DbiModuleDescriptor &Info);
 
   bool hasECInfo() const;
   uint16_t getTypeServerIndex() const;
   uint16_t getModuleStreamIndex() const;
   uint32_t getSymbolDebugInfoByteSize() const;
-  uint32_t getLineInfoByteSize() const;
+  uint32_t getC11LineInfoByteSize() const;
   uint32_t getC13LineInfoByteSize() const;
   uint32_t getNumberOfFiles() const;
   uint32_t getSourceFileNameIndex() const;
   uint32_t getPdbFilePathNameIndex() const;
 
   StringRef getModuleName() const;
   StringRef getObjFileName() const;
 

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

 //===- DbiModuleDescriptorBuilder.h - PDB module information ----*- 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_DBIMODULEDESCRIPTORBUILDER_H
 #define LLVM_DEBUGINFO_PDB_RAW_DBIMODULEDESCRIPTORBUILDER_H
 
 #include "llvm/ADT/StringRef.h"
+#include "llvm/DebugInfo/CodeView/ModuleDebugFileChecksumFragment.h"
+#include "llvm/DebugInfo/CodeView/ModuleDebugLineFragment.h"
 #include "llvm/DebugInfo/CodeView/SymbolRecord.h"
 #include "llvm/DebugInfo/PDB/Native/RawTypes.h"
 #include "llvm/Support/Error.h"
 #include <cstdint>
 #include <string>
 #include <vector>
 
 namespace llvm {
 class BinaryStreamWriter;
 
+namespace codeview {
+class ModuleDebugFragmentRecordBuilder;
+}
+
 namespace msf {
 class MSFBuilder;
 struct MSFLayout;
 }
 namespace pdb {
 
 class DbiModuleDescriptorBuilder {
   friend class DbiStreamBuilder;
 
 public:
   DbiModuleDescriptorBuilder(StringRef ModuleName, uint32_t ModIndex,
                              msf::MSFBuilder &Msf);
+  ~DbiModuleDescriptorBuilder();
 
   DbiModuleDescriptorBuilder(const DbiModuleDescriptorBuilder &) = delete;
   DbiModuleDescriptorBuilder &
   operator=(const DbiModuleDescriptorBuilder &) = delete;
 
   void setObjFileName(StringRef Name);
   void addSymbol(codeview::CVSymbol Symbol);
 
+  void setC13LineInfo(std::unique_ptr<codeview::ModuleDebugLineFragment> Lines);
+  void setC13FileChecksums(
+      std::unique_ptr<codeview::ModuleDebugFileChecksumFragment> Checksums);
+
   uint16_t getStreamIndex() const;
   StringRef getModuleName() const { return ModuleName; }
   StringRef getObjFileName() const { return ObjFileName; }
 
   ArrayRef<std::string> source_files() const {
     return makeArrayRef(SourceFiles);
   }
 
   uint32_t calculateSerializedLength() const;
 
   void finalize();
   Error finalizeMsfLayout();
 
   Error commit(BinaryStreamWriter &ModiWriter, const msf::MSFLayout &MsfLayout,
                WritableBinaryStreamRef MsfBuffer);
 
 private:
+  uint32_t calculateC13DebugInfoSize() const;
+
   void addSourceFile(StringRef Path);
   msf::MSFBuilder &MSF;
 
   uint32_t SymbolByteSize = 0;
   std::string ModuleName;
   std::string ObjFileName;
   std::vector<std::string> SourceFiles;
   std::vector<codeview::CVSymbol> Symbols;
+  std::unique_ptr<codeview::ModuleDebugLineFragment> LineInfo;
+  std::unique_ptr<codeview::ModuleDebugFileChecksumFragment> ChecksumInfo;
+
+  std::unique_ptr<codeview::ModuleDebugFragmentRecordBuilder> C13Builders[2];
+
   ModuleInfoHeader Layout;
 };
 
 } // end namespace pdb
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_PDB_RAW_DBIMODULEDESCRIPTORBUILDER_H

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

public:
 
   // 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>

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

 #include "llvm/Support/BinaryStreamRef.h"
 #include "llvm/Support/Error.h"
 
 namespace llvm {
 namespace pdb {
 class PDBFile;
 class DbiModuleDescriptor;
 
-class ModuleDebugStream {
+class ModuleDebugStreamRef {
   typedef codeview::ModuleDebugFragmentArray::Iterator
       LinesAndChecksumsIterator;
 
 public:
-  ModuleDebugStream(const DbiModuleDescriptor &Module,
+  ModuleDebugStreamRef(const DbiModuleDescriptor &Module,
                        std::unique_ptr<msf::MappedBlockStream> Stream);
-  ~ModuleDebugStream();
+  ~ModuleDebugStreamRef();
 
   Error reload();
 
   uint32_t signature() const { return Signature; }
 
   iterator_range<codeview::CVSymbolArray::Iterator>
   symbols(bool *HadError) const;
 
   llvm::iterator_range<LinesAndChecksumsIterator> linesAndChecksums() const;
 
   bool hasLineInfo() const;
 
   Error commit();
 
 private:
   const DbiModuleDescriptor &Mod;
 
   uint32_t Signature;
 
   std::unique_ptr<msf::MappedBlockStream> Stream;
 
   codeview::CVSymbolArray SymbolsSubstream;
-  BinaryStreamRef LinesSubstream;
+  BinaryStreamRef C11LinesSubstream;
   BinaryStreamRef C13LinesSubstream;
   BinaryStreamRef GlobalRefsSubstream;
 
   codeview::ModuleDebugFragmentArray LinesAndChecksums;
 };
+
+class ModuleDebugStream {};
 }
 }
 
 #endif

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

struct ModuleInfoHeader {
   support::ulittle16_t Flags;
 
   /// Stream Number of module debug info
   support::ulittle16_t ModDiStream;
 
   /// Size of local symbol debug info in above stream
   support::ulittle32_t SymBytes;
 
-  /// Size of line number debug info in above stream
-  support::ulittle32_t LineBytes;
+  /// Size of C11 line number info in above stream
+  support::ulittle32_t C11Bytes;
 
   /// Size of C13 line number info in above stream
   support::ulittle32_t C13Bytes;
 
   /// Number of files contributing to this module
   support::ulittle16_t NumFiles;
 
   /// Padding so the next field is 4-byte aligned.

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

 
 namespace pdb {
 
 class StringTableBuilder {
 public:
   // If string S does not exist in the string table, insert it.
   // Returns the ID for S.
   uint32_t insert(StringRef S);
+  uint32_t getStringIndex(StringRef S);
 
   uint32_t finalize();
   Error commit(BinaryStreamWriter &Writer) const;
 
 private:
   DenseMap<StringRef, uint32_t> Strings;
   uint32_t StringSize = 1;
 };
 
 } // end namespace pdb
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_PDB_RAW_STRINGTABLEBUILDER_H

llvm/lib/DebugInfo/CodeView/ModuleDebugFileChecksumFragment.cpp

Error llvm::VarStreamArrayExtractor<FileChecksumEntry>::extract(
   Item.Kind = static_cast<FileChecksumKind>(Header->ChecksumKind);
   if (auto EC = Reader.readBytes(Item.Checksum, Header->ChecksumSize))
     return EC;
 
   Len = alignTo(Header->ChecksumSize + sizeof(FileChecksumEntryHeader), 4);
   return Error::success();
 }
 
-Error ModuleDebugFileChecksumFragment::initialize(BinaryStreamReader Reader) {
+Error ModuleDebugFileChecksumFragmentRef::initialize(
+    BinaryStreamReader Reader) {
   if (auto EC = Reader.readArray(Checksums, Reader.bytesRemaining()))
     return EC;
 
   return Error::success();
 }
+
+ModuleDebugFileChecksumFragment::ModuleDebugFileChecksumFragment()
+    : ModuleDebugFragment(ModuleDebugFragmentKind::FileChecksums) {}
+
+void ModuleDebugFileChecksumFragment::addChecksum(uint32_t FileNameOffset,
+                                                  FileChecksumKind Kind,
+                                                  ArrayRef<uint8_t> Bytes) {
+  FileChecksumEntry Entry;
+  if (!Bytes.empty()) {
+    uint8_t *Copy = Storage.Allocate<uint8_t>(Bytes.size());
+    ::memcpy(Copy, Bytes.data(), Bytes.size());
+    Entry.Checksum = makeArrayRef(Copy, Bytes.size());
+  }
+  Entry.FileNameOffset = FileNameOffset;
+  Entry.Kind = Kind;
+  Checksums.push_back(Entry);
+  SerializedSize += sizeof(FileChecksumEntryHeader) + Bytes.size();
+}
+
+uint32_t ModuleDebugFileChecksumFragment::calculateSerializedLength() {
+  return SerializedSize;
+}
+
+Error ModuleDebugFileChecksumFragment::commit(BinaryStreamWriter &Writer) {
+  for (const auto &FC : Checksums) {
+    FileChecksumEntryHeader Header;
+    Header.ChecksumKind = uint8_t(FC.Kind);
+    Header.ChecksumSize = FC.Checksum.size();
+    Header.FileNameOffset = FC.FileNameOffset;
+    if (auto EC = Writer.writeObject(Header))
+      return EC;
+    if (auto EC = Writer.writeArray(makeArrayRef(FC.Checksum)))
+      return EC;
+  }
+  return Error::success();
+}

llvm/lib/DebugInfo/CodeView/ModuleDebugFragment.cpp

 //===- ModuleDebugFragment.cpp -----------------------------------*- C++-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/CodeView/ModuleDebugFragment.h"
 
 using namespace llvm::codeview;
 
+ModuleDebugFragmentRef::~ModuleDebugFragmentRef() {}
+
 ModuleDebugFragment::~ModuleDebugFragment() {}

llvm/lib/DebugInfo/CodeView/ModuleDebugFragmentRecord.cpp

 //===- ModuleDebugFragmentRecord.cpp -----------------------------*- C++-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/CodeView/ModuleDebugFragmentRecord.h"
+#include "llvm/DebugInfo/CodeView/ModuleDebugFragment.h"
 
 #include "llvm/Support/BinaryStreamReader.h"
 
 using namespace llvm;
 using namespace llvm::codeview;
 
 ModuleDebugFragmentRecord::ModuleDebugFragmentRecord()
     : Kind(ModuleDebugFragmentKind::None) {}
uint32_t ModuleDebugFragmentRecord::getRecordLength() const {
   return sizeof(ModuleDebugFragmentHeader) + Data.getLength();
 }
 
 ModuleDebugFragmentKind ModuleDebugFragmentRecord::kind() const { return Kind; }
 
 BinaryStreamRef ModuleDebugFragmentRecord::getRecordData() const {
   return Data;
 }
+
+ModuleDebugFragmentRecordBuilder::ModuleDebugFragmentRecordBuilder(
+    ModuleDebugFragmentKind Kind, ModuleDebugFragment &Frag)
+    : Kind(Kind), Frag(Frag) {}
+
+uint32_t ModuleDebugFragmentRecordBuilder::calculateSerializedLength() {
+  uint32_t Size =
+      sizeof(ModuleDebugFragmentHeader) + Frag.calculateSerializedLength();
+  Size = alignTo(Size, 4);
+  return Size;
+}
+
+Error ModuleDebugFragmentRecordBuilder::commit(BinaryStreamWriter &Writer) {
+  ModuleDebugFragmentHeader Header;
+  Header.Kind = uint32_t(Kind);
+  Header.Length = Frag.calculateSerializedLength();
+
+  if (auto EC = Writer.writeObject(Header))
+    return EC;
+  if (auto EC = Frag.commit(Writer))
+    return EC;
+  if (auto EC = Writer.padToAlignment(4))
+    return EC;
+
+  return Error::success();
+}

llvm/lib/DebugInfo/CodeView/ModuleDebugFragmentVisitor.cpp

 //===- ModuleDebugFragmentVisitor.cpp ---------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/CodeView/ModuleDebugFragmentVisitor.h"
 
 #include "llvm/DebugInfo/CodeView/ModuleDebugFileChecksumFragment.h"
 #include "llvm/DebugInfo/CodeView/ModuleDebugLineFragment.h"
+#include "llvm/DebugInfo/CodeView/ModuleDebugUnknownFragment.h"
 #include "llvm/Support/BinaryStreamReader.h"
 #include "llvm/Support/BinaryStreamRef.h"
 
 using namespace llvm;
 using namespace llvm::codeview;
 
 Error llvm::codeview::visitModuleDebugFragment(
     const ModuleDebugFragmentRecord &R, ModuleDebugFragmentVisitor &V) {
   BinaryStreamReader Reader(R.getRecordData());
   switch (R.kind()) {
   case ModuleDebugFragmentKind::Lines: {
-    ModuleDebugLineFragment Fragment;
+    ModuleDebugLineFragmentRef Fragment;
     if (auto EC = Fragment.initialize(Reader))
       return EC;
 
     return V.visitLines(Fragment);
   }
   case ModuleDebugFragmentKind::FileChecksums: {
-    ModuleDebugFileChecksumFragment Fragment;
+    ModuleDebugFileChecksumFragmentRef Fragment;
     if (auto EC = Fragment.initialize(Reader))
       return EC;
 
     return V.visitFileChecksums(Fragment);
   }
   default: {
-    ModuleDebugUnknownFragment Fragment(R.kind(), R.getRecordData());
+    ModuleDebugUnknownFragmentRef Fragment(R.kind(), R.getRecordData());
     return V.visitUnknown(Fragment);
   }
   }
 }

llvm/lib/DebugInfo/CodeView/ModuleDebugLineFragment.cpp

-//===- ModuleDebugLineFragment.cpp --------------------------------*- C++
-//-*-===//
+//===- ModuleDebugLineFragment.cpp -------------------------------*- C++-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/CodeView/ModuleDebugLineFragment.h"
 
 #include "llvm/DebugInfo/CodeView/CodeViewError.h"
 #include "llvm/DebugInfo/CodeView/ModuleDebugFragmentRecord.h"
 
 using namespace llvm;
 using namespace llvm::codeview;
 
 Error LineColumnExtractor::extract(BinaryStreamRef Stream, uint32_t &Len,
                                    LineColumnEntry &Item,
                                    const LineFragmentHeader *Header) {
   using namespace codeview;
   const LineBlockFragmentHeader *BlockHeader;
   BinaryStreamReader Reader(Stream);
   if (auto EC = Reader.readObject(BlockHeader))
     return EC;
-  bool HasColumn = Header->Flags & uint32_t(LineFlags::HaveColumns);
+  bool HasColumn = Header->Flags & uint16_t(kLineFlagsHaveColumns);
   uint32_t LineInfoSize =
       BlockHeader->NumLines *
       (sizeof(LineNumberEntry) + (HasColumn ? sizeof(ColumnNumberEntry) : 0));
   if (BlockHeader->BlockSize < sizeof(LineBlockFragmentHeader))
     return make_error<CodeViewError>(cv_error_code::corrupt_record,
                                      "Invalid line block record size");
   uint32_t Size = BlockHeader->BlockSize - sizeof(LineBlockFragmentHeader);
   if (LineInfoSize > Size)
     return make_error<CodeViewError>(cv_error_code::corrupt_record,
                                      "Invalid line block record size");
   // The value recorded in BlockHeader->BlockSize includes the size of
   // LineBlockFragmentHeader.
   Len = BlockHeader->BlockSize;
   Item.NameIndex = BlockHeader->NameIndex;
   if (auto EC = Reader.readArray(Item.LineNumbers, BlockHeader->NumLines))
     return EC;
   if (HasColumn) {
     if (auto EC = Reader.readArray(Item.Columns, BlockHeader->NumLines))
       return EC;
   }
   return Error::success();
 }
 
-ModuleDebugLineFragment::ModuleDebugLineFragment()
-    : ModuleDebugFragment(ModuleDebugFragmentKind::Lines) {}
+ModuleDebugLineFragmentRef::ModuleDebugLineFragmentRef()
+    : ModuleDebugFragmentRef(ModuleDebugFragmentKind::Lines) {}
 
-Error ModuleDebugLineFragment::initialize(BinaryStreamReader Reader) {
+Error ModuleDebugLineFragmentRef::initialize(BinaryStreamReader Reader) {
   if (auto EC = Reader.readObject(Header))
     return EC;
 
   if (auto EC =
           Reader.readArray(LinesAndColumns, Reader.bytesRemaining(), Header))
     return EC;
 
   return Error::success();
 }
+
+ModuleDebugLineFragment::ModuleDebugLineFragment()
+    : ModuleDebugFragment(ModuleDebugFragmentKind::Lines) {}
+
+void ModuleDebugLineFragment::createBlock(uint32_t NameIndex) {
+  Blocks.emplace_back(NameIndex);
+}
+
+void ModuleDebugLineFragment::addLineInfo(uint32_t Offset,
+                                          const LineInfo &Line) {
+  Block &B = Blocks.back();
+  LineNumberEntry LNE;
+  LNE.Flags = Line.getRawData();
+  LNE.Offset = Offset;
+  B.Lines.push_back(LNE);
+}
+
+void ModuleDebugLineFragment::addLineAndColumnInfo(uint32_t Offset,
+                                                   const LineInfo &Line,
+                                                   uint32_t ColStart,
+                                                   uint32_t ColEnd) {
+  Block &B = Blocks.back();
+  assert(B.Lines.size() == B.Columns.size());
+
+  addLineInfo(Offset, Line);
+  ColumnNumberEntry CNE;
+  CNE.StartColumn = ColStart;
+  CNE.EndColumn = ColEnd;
+  B.Columns.push_back(CNE);
+}
+
+Error ModuleDebugLineFragment::commit(BinaryStreamWriter &Writer) {
+  LineFragmentHeader Header;
+  Header.CodeSize = CodeSize;
+  Header.Flags = hasColumnInfo() ? kLineFlagsHaveColumns : 0;
+  Header.RelocOffset = RelocOffset;
+  Header.RelocSegment = RelocSegment;
+
+  if (auto EC = Writer.writeObject(Header))
+    return EC;
+
+  for (const auto &B : Blocks) {
+    LineBlockFragmentHeader BlockHeader;
+    assert(B.Lines.size() == B.Columns.size() || B.Columns.empty());
+
+    BlockHeader.NumLines = B.Lines.size();
+    BlockHeader.BlockSize = sizeof(LineBlockFragmentHeader);
+    BlockHeader.BlockSize += BlockHeader.NumLines * sizeof(LineNumberEntry);
+    if (hasColumnInfo())
+      BlockHeader.BlockSize += BlockHeader.NumLines * sizeof(ColumnNumberEntry);
+    BlockHeader.NameIndex = B.NameIndex;
+    if (auto EC = Writer.writeObject(BlockHeader))
+      return EC;
+
+    if (auto EC = Writer.writeArray(makeArrayRef(B.Lines)))
+      return EC;
+
+    if (hasColumnInfo()) {
+      if (auto EC = Writer.writeArray(makeArrayRef(B.Columns)))
+        return EC;
+    }
+  }
+  return Error::success();
+}
+
+uint32_t ModuleDebugLineFragment::calculateSerializedLength() {
+  uint32_t Size = sizeof(LineFragmentHeader);
+  for (const auto &B : Blocks) {
+    Size += sizeof(LineBlockFragmentHeader);
+    Size += B.Lines.size() * sizeof(LineNumberEntry);
+    if (hasColumnInfo())
+      Size += B.Columns.size() * sizeof(ColumnNumberEntry);
+  }
+  return Size;
+}
+
+void ModuleDebugLineFragment::setRelocationAddress(uint16_t Segment,
+                                                   uint16_t Offset) {
+  RelocOffset = Offset;
+  RelocSegment = Segment;
+}
+
+void ModuleDebugLineFragment::setCodeSize(uint32_t Size) { CodeSize = Size; }
+
+void ModuleDebugLineFragment::setFlags(LineFlags Flags) { this->Flags = Flags; }
+
+bool ModuleDebugLineFragment::hasColumnInfo() const {
+  return Flags & kLineFlagsHaveColumns;
+}

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

 uint16_t DbiModuleDescriptor::getModuleStreamIndex() const {
   return Layout->ModDiStream;
 }
 
 uint32_t DbiModuleDescriptor::getSymbolDebugInfoByteSize() const {
   return Layout->SymBytes;
 }
 
-uint32_t DbiModuleDescriptor::getLineInfoByteSize() const {
-  return Layout->LineBytes;
+uint32_t DbiModuleDescriptor::getC11LineInfoByteSize() const {
+  return Layout->C11Bytes;
 }
 
 uint32_t DbiModuleDescriptor::getC13LineInfoByteSize() const {
   return Layout->C13Bytes;
 }
 
 uint32_t DbiModuleDescriptor::getNumberOfFiles() const {
   return Layout->NumFiles;

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

 //===- DbiModuleDescriptorBuilder.cpp - PDB Mod Info Creation ---*- C++ -*-===//
 //
 //                     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/Native/DbiModuleDescriptorBuilder.h"
 
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/DebugInfo/CodeView/ModuleDebugFragmentRecord.h"
 #include "llvm/DebugInfo/MSF/MSFBuilder.h"
 #include "llvm/DebugInfo/MSF/MSFCommon.h"
 #include "llvm/DebugInfo/MSF/MappedBlockStream.h"
 #include "llvm/DebugInfo/PDB/Native/DbiModuleDescriptor.h"
 #include "llvm/DebugInfo/PDB/Native/RawConstants.h"
 #include "llvm/DebugInfo/PDB/Native/RawError.h"
 #include "llvm/Support/BinaryItemStream.h"
 #include "llvm/Support/BinaryStreamWriter.h"
template <> struct BinaryItemTraits<CVSymbol> {
   static size_t length(const CVSymbol &Item) { return Item.RecordData.size(); }
 
   static ArrayRef<uint8_t> bytes(const CVSymbol &Item) {
     return Item.RecordData;
   }
 };
 }
 
-static uint32_t calculateDiSymbolStreamSize(uint32_t SymbolByteSize) {
+static uint32_t calculateDiSymbolStreamSize(uint32_t SymbolByteSize,
+                                            uint32_t C13Size) {
   uint32_t Size = sizeof(uint32_t); // Signature
   Size += SymbolByteSize;           // Symbol Data
-  Size += 0;                        // TODO: Layout.LineBytes
-  Size += 0;                        // TODO: Layout.C13Bytes
+  Size += 0;                        // TODO: Layout.C11Bytes
+  Size += C13Size;                  // TODO: Layout.C13Bytes
   Size += sizeof(uint32_t);         // GlobalRefs substream size (always 0)
   Size += 0;                        // GlobalRefs substream bytes
   return Size;
 }
 
 DbiModuleDescriptorBuilder::DbiModuleDescriptorBuilder(StringRef ModuleName,
                                                        uint32_t ModIndex,
                                                        msf::MSFBuilder &Msf)
     : MSF(Msf), ModuleName(ModuleName) {
   Layout.Mod = ModIndex;
 }
 
+DbiModuleDescriptorBuilder::~DbiModuleDescriptorBuilder() {}
+
 uint16_t DbiModuleDescriptorBuilder::getStreamIndex() const {
   return Layout.ModDiStream;
 }
 
 void DbiModuleDescriptorBuilder::setObjFileName(StringRef Name) {
   ObjFileName = Name;
 }
 
 void DbiModuleDescriptorBuilder::addSymbol(CVSymbol Symbol) {
   Symbols.push_back(Symbol);
   SymbolByteSize += Symbol.data().size();
 }
 
 void DbiModuleDescriptorBuilder::addSourceFile(StringRef Path) {
   SourceFiles.push_back(Path);
 }
 
+uint32_t DbiModuleDescriptorBuilder::calculateC13DebugInfoSize() const {
+  uint32_t Result = 0;
+  for (const auto &Builder : C13Builders) {
+    if (Builder)
+      Result += Builder->calculateSerializedLength();
+  }
+  return Result;
+}
+
 uint32_t DbiModuleDescriptorBuilder::calculateSerializedLength() const {
   uint32_t L = sizeof(Layout);
   uint32_t M = ModuleName.size() + 1;
   uint32_t O = ObjFileName.size() + 1;
   return alignTo(L + M + O, sizeof(uint32_t));
 }
 
 void DbiModuleDescriptorBuilder::finalize() {
-  Layout.C13Bytes = 0;
   Layout.FileNameOffs = 0; // TODO: Fix this
   Layout.Flags = 0;        // TODO: Fix this
-  Layout.LineBytes = 0;
+  Layout.C11Bytes = 0;
+  Layout.C13Bytes = calculateC13DebugInfoSize();
   (void)Layout.Mod;         // Set in constructor
   (void)Layout.ModDiStream; // Set in finalizeMsfLayout
   Layout.NumFiles = SourceFiles.size();
   Layout.PdbFilePathNI = 0;
   Layout.SrcFileNameNI = 0;
 
   // This value includes both the signature field as well as the record bytes
   // from the symbol stream.
   Layout.SymBytes = SymbolByteSize + sizeof(uint32_t);
 }
 
 Error DbiModuleDescriptorBuilder::finalizeMsfLayout() {
   this->Layout.ModDiStream = kInvalidStreamIndex;
-  auto ExpectedSN = MSF.addStream(calculateDiSymbolStreamSize(SymbolByteSize));
+  uint32_t C13Size = calculateC13DebugInfoSize();
+  auto ExpectedSN =
+      MSF.addStream(calculateDiSymbolStreamSize(SymbolByteSize, C13Size));
   if (!ExpectedSN)
     return ExpectedSN.takeError();
   Layout.ModDiStream = *ExpectedSN;
   return Error::success();
 }
 
 Error DbiModuleDescriptorBuilder::commit(BinaryStreamWriter &ModiWriter,
                                          const msf::MSFLayout &MsfLayout,
if (auto EC =
             SymbolWriter.writeInteger<uint32_t>(COFF::DEBUG_SECTION_MAGIC))
       return EC;
     BinaryItemStream<CVSymbol> Records(llvm::support::endianness::little);
     Records.setItems(Symbols);
     BinaryStreamRef RecordsRef(Records);
     if (auto EC = SymbolWriter.writeStreamRef(RecordsRef))
       return EC;
     // TODO: Write C11 Line data
-    // TODO: Write C13 Line data
+
+    for (const auto &Builder : C13Builders) {
+      if (Builder) {
+        if (auto EC = Builder->commit(SymbolWriter))
+          return EC;
+      }
+    }
+
     // TODO: Figure out what GlobalRefs substream actually is and populate it.
     if (auto EC = SymbolWriter.writeInteger<uint32_t>(0))
       return EC;
     if (SymbolWriter.bytesRemaining() > 0)
       return make_error<RawError>(raw_error_code::stream_too_long);
   }
   return Error::success();
 }
+
+void DbiModuleDescriptorBuilder::setC13LineInfo(
+    std::unique_ptr<ModuleDebugLineFragment> Lines) {
+  LineInfo = std::move(Lines);
+  C13Builders[0] = llvm::make_unique<ModuleDebugFragmentRecordBuilder>(
+      LineInfo->kind(), *LineInfo);
+}
+
+void DbiModuleDescriptorBuilder::setC13FileChecksums(
+    std::unique_ptr<ModuleDebugFileChecksumFragment> Checksums) {
+  ChecksumInfo = std::move(Checksums);
+  C13Builders[1] = llvm::make_unique<ModuleDebugFragmentRecordBuilder>(
+      ChecksumInfo->kind(), *ChecksumInfo);
+}

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

return make_error<RawError>(raw_error_code::no_entry,
                                 "The specified module was not found");
   uint32_t Index = SourceFileNames.size();
   SourceFileNames.insert(std::make_pair(File, Index));
   auto &ModEntry = *ModIter;
   ModEntry.second->addSourceFile(File);
   return Error::success();
 }
 
+Expected<uint32_t> DbiStreamBuilder::getSourceFileNameIndex(StringRef File) {
+  auto NameIter = SourceFileNames.find(File);
+  if (NameIter == SourceFileNames.end())
+    return make_error<RawError>(raw_error_code::no_entry,
+                                "The specified source file was not found");
+  return NameIter->getValue();
+}
+
 uint32_t DbiStreamBuilder::calculateModiSubstreamSize() const {
   uint32_t Size = 0;
   for (const auto &M : ModiList)
     Size += M->calculateSerializedLength();
   return Size;
 }
 
 uint32_t DbiStreamBuilder::calculateSectionContribsStreamSize() const {

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

 #include <algorithm>
 #include <cstdint>
 
 using namespace llvm;
 using namespace llvm::codeview;
 using namespace llvm::msf;
 using namespace llvm::pdb;
 
-ModuleDebugStream::ModuleDebugStream(const DbiModuleDescriptor &Module,
-                                     std::unique_ptr<MappedBlockStream> Stream)
+ModuleDebugStreamRef::ModuleDebugStreamRef(
+    const DbiModuleDescriptor &Module,
     : Mod(Module), Stream(std::move(Stream)) {}
 
-ModuleDebugStream::~ModuleDebugStream() = default;
+ModuleDebugStreamRef::~ModuleDebugStreamRef() = default;
 
-Error ModuleDebugStream::reload() {
+Error ModuleDebugStreamRef::reload() {
   BinaryStreamReader Reader(*Stream);
 
   uint32_t SymbolSize = Mod.getSymbolDebugInfoByteSize();
-  uint32_t C11Size = Mod.getLineInfoByteSize();
+  uint32_t C11Size = Mod.getC11LineInfoByteSize();
   uint32_t C13Size = Mod.getC13LineInfoByteSize();
 
   if (C11Size > 0 && C13Size > 0)
     return make_error<RawError>(raw_error_code::corrupt_file,
                                 "Module has both C11 and C13 line info");
 
   BinaryStreamRef S;
 
   if (auto EC = Reader.readInteger(Signature))
     return EC;
   if (auto EC = Reader.readArray(SymbolsSubstream, SymbolSize - 4))
     return EC;
 
-  if (auto EC = Reader.readStreamRef(LinesSubstream, C11Size))
+  if (auto EC = Reader.readStreamRef(C11LinesSubstream, C11Size))
     return EC;
   if (auto EC = Reader.readStreamRef(C13LinesSubstream, C13Size))
     return EC;
 
   BinaryStreamReader LineReader(C13LinesSubstream);
   if (auto EC =
           LineReader.readArray(LinesAndChecksums, LineReader.bytesRemaining()))
     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 make_error<RawError>(raw_error_code::corrupt_file,
                                 "Unexpected bytes in module stream.");
 
   return Error::success();
 }
 
 iterator_range<codeview::CVSymbolArray::Iterator>
-ModuleDebugStream::symbols(bool *HadError) const {
+ModuleDebugStreamRef::symbols(bool *HadError) const {
   // It's OK if the stream is empty.
   if (SymbolsSubstream.getUnderlyingStream().getLength() == 0)
     return make_range(SymbolsSubstream.end(), SymbolsSubstream.end());
   return make_range(SymbolsSubstream.begin(HadError), SymbolsSubstream.end());
 }
 
-llvm::iterator_range<ModuleDebugStream::LinesAndChecksumsIterator>
-ModuleDebugStream::linesAndChecksums() const {
+llvm::iterator_range<ModuleDebugStreamRef::LinesAndChecksumsIterator>
+ModuleDebugStreamRef::linesAndChecksums() const {
   return make_range(LinesAndChecksums.begin(), LinesAndChecksums.end());
 }
 
-bool ModuleDebugStream::hasLineInfo() const {
+bool ModuleDebugStreamRef::hasLineInfo() const {
   return C13LinesSubstream.getLength() > 0;
 }
 
-Error ModuleDebugStream::commit() { return Error::success(); }
+Error ModuleDebugStreamRef::commit() { return Error::success(); }

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

uint32_t StringTableBuilder::insert(StringRef S) {
 
   // If a given string didn't exist in the string table, we want to increment
   // the string table size.
   if (P.second)
     StringSize += S.size() + 1; // +1 for '\0'
   return P.first->second;
 }
 
+uint32_t StringTableBuilder::getStringIndex(StringRef S) {
+  auto Iter = Strings.find(S);
+  assert(Iter != Strings.end());
+  return Iter->second;
+}
+
 static uint32_t computeBucketCount(uint32_t NumStrings) {
   // The /names stream is basically an on-disk open-addressing hash table.
   // Hash collisions are resolved by linear probing. We cannot make
   // utilization 100% because it will make the linear probing extremely
   // slow. But lower utilization wastes disk space. As a reasonable
   // load factor, we choose 80%. We need +1 because slot 0 is reserved.
   return (NumStrings + 1) * 1.25;
 }

llvm/lib/MC/MCCodeView.cpp

void CodeViewContext::emitLineTableForFunction(MCObjectStreamer &OS,
   OS.EmitCOFFSecRel32(FuncBegin, /*Offset=*/0);
   OS.EmitCOFFSectionIndex(FuncBegin);
 
   // Actual line info.
   std::vector<MCCVLineEntry> Locs = getFunctionLineEntries(FuncId);
   bool HaveColumns = any_of(Locs, [](const MCCVLineEntry &LineEntry) {
     return LineEntry.getColumn() != 0;
   });
-  OS.EmitIntValue(HaveColumns ? int(LineFlags::HaveColumns) : 0, 2);
+  OS.EmitIntValue(HaveColumns ? int(kLineFlagsHaveColumns) : 0, 2);
   OS.emitAbsoluteSymbolDiff(FuncEnd, FuncBegin, 4);
 
   for (auto I = Locs.begin(), E = Locs.end(); I != E;) {
     // Emit a file segment for the run of locations that share a file id.
     unsigned CurFileNum = I->getFileNum();
     auto FileSegEnd =
         std::find_if(I, E, [CurFileNum](const MCCVLineEntry &Loc) {
           return Loc.getFileNum() != CurFileNum;

llvm/test/DebugInfo/PDB/Inputs/simple-line-info.yaml

+---
+StringTable:
+  - 'junk_a'
+  - 'd:\src\llvm\test\debuginfo\pdb\inputs\empty.cpp'
+  - 'junk_b'
+DbiStream:
+  Modules:
+    - Module:          'd:\src\llvm\test\DebugInfo\PDB\Inputs\empty.obj'
+      ObjFile:         'd:\src\llvm\test\DebugInfo\PDB\Inputs\empty.obj'
+      SourceFiles:
+        - 'd:\src\llvm\test\debuginfo\pdb\inputs\empty.cpp'
+      LineInfo:
+        Lines:
+          CodeSize:        10
+          Flags:           [  ]
+          RelocOffset:     16
+          RelocSegment:    1
+          LineInfo:
+            - FileName:        'd:\src\llvm\test\debuginfo\pdb\inputs\empty.cpp'
+              Lines:
+                - Offset:          0
+                  LineStart:       5
+                  IsStatement:     true
+                  EndDelta:        0
+                - Offset:          3
+                  LineStart:       6
+                  IsStatement:     true
+                  EndDelta:        0
+                - Offset:          8
+                  LineStart:       7
+                  IsStatement:     true
+                  EndDelta:        0
+              Columns:
+        Checksums:
+          - FileName:        'd:\src\llvm\test\debuginfo\pdb\inputs\empty.cpp'
+            Kind:            MD5
+            Checksum:        A0A5BD0D3ECD93FC29D19DE826FBF4BC
+...

llvm/test/DebugInfo/PDB/pdbdump-yaml-lineinfo-write.test

+; This testcase verifies that we can produce a PDB with line
+; information.  It does this by describing some line information
+; manually in YAML, creating a PDB out of it, then dumping then
+; line information from the resulting PDB.
+
+; RUN: llvm-pdbdump yaml2pdb -pdb=%t.pdb %p/Inputs/simple-line-info.yaml
+; RUN: llvm-pdbdump raw -line-info %t.pdb | FileCheck -check-prefix=LINES %s
+
+LINES:       Modules [
+LINES-NEXT:    {
+LINES-NEXT:      Name: d:\src\llvm\test\DebugInfo\PDB\Inputs\empty.obj
+LINES:           LineInfo [
+LINES-NEXT:        Lines {
+LINES-NEXT:          FileName: d:\src\llvm\test\debuginfo\pdb\inputs\empty.cpp
+LINES-NEXT:          Line {
+LINES-NEXT:            Offset: 0
+LINES-NEXT:            LineNumberStart: 5
+LINES-NEXT:            EndDelta: 0
+LINES-NEXT:            IsStatement: Yes
+LINES-NEXT:          }
+LINES-NEXT:          Line {
+LINES-NEXT:            Offset: 3
+LINES-NEXT:            LineNumberStart: 6
+LINES-NEXT:            EndDelta: 0
+LINES-NEXT:            IsStatement: Yes
+LINES-NEXT:          }
+LINES-NEXT:          Line {
+LINES-NEXT:            Offset: 8
+LINES-NEXT:            LineNumberStart: 7
+LINES-NEXT:            EndDelta: 0
+LINES-NEXT:            IsStatement: Yes
+LINES-NEXT:          }
+LINES-NEXT:        }
+LINES-NEXT:        FileChecksums {
+LINES-NEXT:          Checksum {
+LINES-NEXT:            FileName: d:\src\llvm\test\debuginfo\pdb\inputs\empty.cpp
+LINES-NEXT:            Kind: MD5 (0x1)
+LINES-NEXT:            Checksum (
+LINES-NEXT:              0000: A0A5BD0D 3ECD93FC 29D19DE8 26FBF4BC  |....>...)...&...|
+LINES-NEXT:            )
+LINES-NEXT:          }
+LINES-NEXT:        }
+LINES-NEXT:      ]
+LINES-NEXT:    }

llvm/test/DebugInfo/PDB/pdbdump-yaml-lineinfo.test

 YAML:     ObjFile:         'd:\src\llvm\test\DebugInfo\PDB\Inputs\empty.obj'
 YAML:     SourceFiles:
 YAML:       - 'd:\src\llvm\test\debuginfo\pdb\inputs\empty.cpp'
 YAML:     LineInfo:
 YAML:       Lines:
 YAML:         CodeSize:        10
 YAML:         Flags:           [  ]
 YAML:         RelocOffset:     16
-YAML:      RelocSegment:    1
+YAML:         RelocSegment:    1
 YAML:      LineInfo:
 YAML:        - FileName:        'd:\src\llvm\test\debuginfo\pdb\inputs\empty.cpp'
 YAML:          Lines:
 YAML:            - Offset:          0
 YAML:              LineStart:       5
 YAML:              IsStatement:     true
-YAML:              EndDelta:        5
+YAML:              EndDelta:        0
 YAML:            - Offset:          3
 YAML:              LineStart:       6
 YAML:              IsStatement:     true
-YAML:              EndDelta:        6
+YAML:              EndDelta:        0
 YAML:            - Offset:          8
 YAML:              LineStart:       7
 YAML:              IsStatement:     true
-YAML:              EndDelta:        7
+YAML:              EndDelta:        0
 YAML:          Columns:
 YAML:     Checksums:
 YAML:       - FileName:        'd:\src\llvm\test\debuginfo\pdb\inputs\empty.cpp'
 YAML:         Kind:            MD5
 YAML:         Checksum:        A0A5BD0D3ECD93FC29D19DE826FBF4BC
 YAML:  - Module:          '* Linker *'
 YAML:    ObjFile:         ''
 YAML: ...
 No newline at end of file

llvm/tools/llvm-pdbdump/LLVMOutputStyle.cpp

if (DumpModules) {
     for (auto &Modi : DS->modules()) {
       DictScope DD(P);
       P.printString("Name", Modi.Info.getModuleName().str());
       P.printNumber("Debug Stream Index", Modi.Info.getModuleStreamIndex());
       P.printString("Object File Name", Modi.Info.getObjFileName().str());
       P.printNumber("Num Files", Modi.Info.getNumberOfFiles());
       P.printNumber("Source File Name Idx", Modi.Info.getSourceFileNameIndex());
       P.printNumber("Pdb File Name Idx", Modi.Info.getPdbFilePathNameIndex());
-      P.printNumber("Line Info Byte Size", Modi.Info.getLineInfoByteSize());
+      P.printNumber("Line Info Byte Size", Modi.Info.getC11LineInfoByteSize());
       P.printNumber("C13 Line Info Byte Size",
                     Modi.Info.getC13LineInfoByteSize());
       P.printNumber("Symbol Byte Size", Modi.Info.getSymbolDebugInfoByteSize());
       P.printNumber("Type Server Index", Modi.Info.getTypeServerIndex());
       P.printBoolean("Has EC Info", Modi.Info.hasECInfo());
       if (opts::raw::DumpModuleFiles) {
         std::string FileListName =
             to_string(Modi.SourceFiles.size()) + " Contributing Source Files";
         ListScope LL(P, FileListName);
         for (auto File : Modi.SourceFiles)
           P.printString(File.str());
       }
       bool HasModuleDI =
           (Modi.Info.getModuleStreamIndex() < File.getNumStreams());
       bool ShouldDumpSymbols =
           (opts::raw::DumpModuleSyms || opts::raw::DumpSymRecordBytes);
       if (HasModuleDI && (ShouldDumpSymbols || opts::raw::DumpLineInfo)) {
         auto ModStreamData = MappedBlockStream::createIndexedStream(
             File.getMsfLayout(), File.getMsfBuffer(),
             Modi.Info.getModuleStreamIndex());
 
-        ModuleDebugStream ModS(Modi.Info, std::move(ModStreamData));
+        ModuleDebugStreamRef ModS(Modi.Info, std::move(ModStreamData));
         if (auto EC = ModS.reload())
           return EC;
 
         if (ShouldDumpSymbols) {
           ListScope SS(P, "Symbols");
           codeview::CVSymbolDumper SD(P, TypeDB, nullptr, false);
           bool HadError = false;
           for (auto S : ModS.symbols(&HadError)) {
for (auto &Modi : DS->modules()) {
         }
         if (opts::raw::DumpLineInfo) {
           ListScope SS(P, "LineInfo");
           // Define a locally scoped visitor to print the different
           // substream types types.
           class RecordVisitor : public codeview::ModuleDebugFragmentVisitor {
           public:
             RecordVisitor(ScopedPrinter &P, PDBFile &F) : P(P), F(F) {}
-            Error visitUnknown(ModuleDebugUnknownFragment &Fragment) override {
+            Error
+            visitUnknown(ModuleDebugUnknownFragmentRef &Fragment) override {
               DictScope DD(P, "Unknown");
               ArrayRef<uint8_t> Data;
               BinaryStreamReader R(Fragment.getData());
               if (auto EC = R.readBytes(Data, R.bytesRemaining())) {
                 return make_error<RawError>(
                     raw_error_code::corrupt_file,
                     "DBI stream contained corrupt line info record");
               }
               P.printBinaryBlock("Data", Data);
               return Error::success();
             }
             Error visitFileChecksums(
-                ModuleDebugFileChecksumFragment &Checksums) override {
+                ModuleDebugFileChecksumFragmentRef &Checksums) override {
               DictScope DD(P, "FileChecksums");
               for (const auto &C : Checksums) {
                 DictScope DDD(P, "Checksum");
                 if (auto Result = getFileNameForOffset(C.FileNameOffset))
                   P.printString("FileName", Result.get());
                 else
                   return Result.takeError();
                 P.flush();
                 P.printEnum("Kind", uint8_t(C.Kind), getFileChecksumNames());
                 P.printBinaryBlock("Checksum", C.Checksum);
               }
               return Error::success();
             }
 
-            Error visitLines(ModuleDebugLineFragment &Lines) override {
+            Error visitLines(ModuleDebugLineFragmentRef &Lines) override {
               DictScope DD(P, "Lines");
               for (const auto &L : Lines) {
                 if (auto Result = getFileNameForOffset2(L.NameIndex))
                   P.printString("FileName", Result.get());
                 else
                   return Result.takeError();
                 P.flush();
                 for (const auto &N : L.LineNumbers) {

llvm/tools/llvm-pdbdump/PdbYaml.h

struct PdbSourceLineInfo {
   uint32_t RelocSegment;
   codeview::LineFlags Flags;
   uint32_t CodeSize;
 
   std::vector<PdbSourceLineBlock> LineInfo;
 };
 
 struct PdbSourceFileInfo {
-  PdbSourceLineInfo Lines;
+  Optional<PdbSourceLineInfo> Lines;
   std::vector<PdbSourceFileChecksumEntry> FileChecksums;
 };
 
 struct PdbDbiModuleInfo {
   StringRef Obj;
   StringRef Mod;
   std::vector<StringRef> SourceFiles;
   Optional<PdbSourceFileInfo> FileLineInfo;

llvm/tools/llvm-pdbdump/PdbYaml.cpp

static void enumeration(IO &io, llvm::codeview::FileChecksumKind &Kind) {
     io.enumCase(Kind, "SHA1", llvm::codeview::FileChecksumKind::SHA1);
     io.enumCase(Kind, "SHA256", llvm::codeview::FileChecksumKind::SHA256);
   }
 };
 
 template <> struct ScalarBitSetTraits<llvm::codeview::LineFlags> {
   static void bitset(IO &io, llvm::codeview::LineFlags &Flags) {
     io.bitSetCase(Flags, "HasColumnInfo",
-                  llvm::codeview::LineFlags::HaveColumns);
+                  llvm::codeview::kLineFlagsHaveColumns);
     io.enumFallback<Hex16>(Flags);
   }
 };
 }
 }
 
 void ScalarTraits<HexFormattedString>::output(const HexFormattedString &Value,
                                               void *ctx, raw_ostream &Out) {

llvm/tools/llvm-pdbdump/YAMLOutputStyle.h

 #include "PdbYaml.h"
 
 #include "llvm/DebugInfo/CodeView/CVTypeDumper.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/YAMLTraits.h"
 
 namespace llvm {
 namespace pdb {
-class ModuleDebugStream;
+class ModuleDebugStreamRef;
 
 class YAMLOutputStyle : public OutputStyle {
 public:
   YAMLOutputStyle(PDBFile &File);
 
   Error dump() override;
 
 private:
   Expected<Optional<llvm::pdb::yaml::PdbSourceFileInfo>>
-  getFileLineInfo(const pdb::ModuleDebugStream &ModS);
+  getFileLineInfo(const pdb::ModuleDebugStreamRef &ModS);
 
   Error dumpStringTable();
   Error dumpFileHeaders();
   Error dumpStreamMetadata();
   Error dumpStreamDirectory();
   Error dumpPDBStream();
   Error dumpDbiStream();
   Error dumpTpiStream();

llvm/tools/llvm-pdbdump/YAMLOutputStyle.cpp

if (opts::pdb2yaml::DbiModuleSourceLineInfo)
     opts::pdb2yaml::DbiModuleSourceFileInfo = true;
 
   if (opts::pdb2yaml::DbiModuleSourceFileInfo)
     opts::pdb2yaml::DbiModuleInfo = true;
 
   if (opts::pdb2yaml::DbiModuleInfo)
     opts::pdb2yaml::DbiStream = true;
 
+  // Some names from the module source file info get pulled from the string
+  // table, so if we're writing module source info, we have to write the string
+  // table as well.
+  if (opts::pdb2yaml::DbiModuleSourceLineInfo)
+    opts::pdb2yaml::StringTable = true;
+
   if (auto EC = dumpFileHeaders())
     return EC;
 
   if (auto EC = dumpStreamMetadata())
     return EC;
 
   if (auto EC = dumpStreamDirectory())
     return EC;

 }
 
 namespace {
 class C13SubstreamVisitor : public ModuleDebugFragmentVisitor {
 public:
   C13SubstreamVisitor(llvm::pdb::yaml::PdbSourceFileInfo &Info, PDBFile &F)
       : Info(Info), F(F) {}
 
-  Error visitUnknown(ModuleDebugUnknownFragment &Fragment) override {
+  Error visitUnknown(ModuleDebugUnknownFragmentRef &Fragment) override {
     return Error::success();
   }
 
   Error
-  visitFileChecksums(ModuleDebugFileChecksumFragment &Checksums) override {
+  visitFileChecksums(ModuleDebugFileChecksumFragmentRef &Checksums) override {
     for (const auto &C : Checksums) {
       llvm::pdb::yaml::PdbSourceFileChecksumEntry Entry;
       if (auto Result = getGlobalString(C.FileNameOffset))
         Entry.FileName = *Result;
       else
         return Result.takeError();
 
       Entry.Kind = C.Kind;
       Entry.ChecksumBytes.Bytes = C.Checksum;
       Info.FileChecksums.push_back(Entry);
     }
     return Error::success();
   }
 
-  Error visitLines(ModuleDebugLineFragment &Lines) override {
+  Error visitLines(ModuleDebugLineFragmentRef &Lines) override {
+    Info.Lines.emplace();
 
-    Info.Lines.CodeSize = Lines.header()->CodeSize;
-    Info.Lines.Flags =
+    Info.Lines->CodeSize = Lines.header()->CodeSize;
+    Info.Lines->Flags =
         static_cast<codeview::LineFlags>(uint16_t(Lines.header()->Flags));
-    Info.Lines.RelocOffset = Lines.header()->RelocOffset;
-    Info.Lines.RelocSegment = Lines.header()->RelocSegment;
+    Info.Lines->RelocOffset = Lines.header()->RelocOffset;
+    Info.Lines->RelocSegment = Lines.header()->RelocSegment;
 
     for (const auto &L : Lines) {
       llvm::pdb::yaml::PdbSourceLineBlock Block;
 
       if (auto Result = getDbiFileName(L.NameIndex))
         Block.FileName = *Result;
       else
         return Result.takeError();
 
       for (const auto &N : L.LineNumbers) {
         llvm::pdb::yaml::PdbSourceLineEntry Line;
         Line.Offset = N.Offset;
         codeview::LineInfo LI(N.Flags);
         Line.LineStart = LI.getStartLine();
-        Line.EndDelta = LI.getEndLine();
+        Line.EndDelta = LI.getLineDelta();
         Line.IsStatement = LI.isStatement();
         Block.Lines.push_back(Line);
       }
 
-      if (Info.Lines.Flags & codeview::LineFlags::HaveColumns) {
+      if (Info.Lines->Flags & codeview::kLineFlagsHaveColumns) {
         for (const auto &C : L.Columns) {
           llvm::pdb::yaml::PdbSourceColumnEntry Column;
           Column.StartColumn = C.StartColumn;
           Column.EndColumn = C.EndColumn;
           Block.Columns.push_back(Column);
         }
       }
 
-      Info.Lines.LineInfo.push_back(Block);
+      Info.Lines->LineInfo.push_back(Block);
     }
     return Error::success();
   }
 
 private:
   Expected<StringRef> getGlobalString(uint32_t Offset) {
     auto ST = F.getStringTable();
     if (!ST)
private:
   }
 
   llvm::pdb::yaml::PdbSourceFileInfo &Info;
   PDBFile &F;
 };
 }
 
 Expected<Optional<llvm::pdb::yaml::PdbSourceFileInfo>>
-YAMLOutputStyle::getFileLineInfo(const pdb::ModuleDebugStream &ModS) {
+YAMLOutputStyle::getFileLineInfo(const pdb::ModuleDebugStreamRef &ModS) {
   if (!ModS.hasLineInfo())
     return None;
 
   yaml::PdbSourceFileInfo Info;
   C13SubstreamVisitor Visitor(Info, File);
   for (auto &Frag : ModS.linesAndChecksums()) {
     if (auto E = codeview::visitModuleDebugFragment(Frag, Visitor))
       return std::move(E);
for (const auto &MI : DS.modules()) {
       DMI.Obj = MI.Info.getObjFileName();
       if (opts::pdb2yaml::DbiModuleSourceFileInfo)
         DMI.SourceFiles = MI.SourceFiles;
 
       auto ModStreamData = msf::MappedBlockStream::createIndexedStream(
           File.getMsfLayout(), File.getMsfBuffer(),
           MI.Info.getModuleStreamIndex());
 
-      pdb::ModuleDebugStream ModS(MI.Info, std::move(ModStreamData));
+      pdb::ModuleDebugStreamRef ModS(MI.Info, std::move(ModStreamData));
       if (auto EC = ModS.reload())
         return EC;
 
       if (opts::pdb2yaml::DbiModuleSourceLineInfo) {
         auto ExpectedInfo = getFileLineInfo(ModS);
         if (!ExpectedInfo)
           return ExpectedInfo.takeError();
         DMI.FileLineInfo = *ExpectedInfo;

llvm/tools/llvm-pdbdump/fuzzer/llvm-pdbdump-fuzzer.cpp

extern "C" int LLVMFuzzerTestOneInput(uint8_t *data, size_t size) {
 
   for (auto &Modi : DS.modules()) {
     auto ModStreamData = pdb::MappedBlockStream::createIndexedStream(
       Modi.Info.getModuleStreamIndex(), *File);
     if (!ModStreamData) {
       consumeError(ModStreamData.takeError());
       return 0;
     }
-    pdb::ModuleDebugStream ModS(Modi.Info, std::move(*ModStreamData));
+    pdb::ModuleDebugStreamRef ModS(Modi.Info, std::move(*ModStreamData));
     if (auto E = ModS.reload()) {
       consumeError(std::move(E));
       return 0;
     }
     codeview::CVSymbolDumper SD(P, TD, nullptr, false);
     bool HadError = false;
     for (auto &S : ModS.symbols(&HadError)) {
       SD.dump(S);
     }
   }
   return 0;
 }

llvm/tools/llvm-pdbdump/llvm-pdbdump.cpp

 #include "PrettyFunctionDumper.h"
 #include "PrettyTypeDumper.h"
 #include "PrettyVariableDumper.h"
 #include "YAMLOutputStyle.h"
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/BitVector.h"
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Config/config.h"
 #include "llvm/DebugInfo/MSF/MSFBuilder.h"
 #include "llvm/DebugInfo/PDB/GenericError.h"
 #include "llvm/DebugInfo/PDB/IPDBEnumChildren.h"
 #include "llvm/DebugInfo/PDB/IPDBRawSymbol.h"
 #include "llvm/DebugInfo/PDB/IPDBSession.h"
 #include "llvm/DebugInfo/PDB/Native/DbiModuleDescriptorBuilder.h"
for (const auto &MI : Dbi.ModInfos) {
     for (auto S : MI.SourceFiles)
       ExitOnErr(DbiBuilder.addModuleSourceFile(MI.Mod, S));
     if (MI.Modi.hasValue()) {
       const auto &ModiStream = *MI.Modi;
       ModiBuilder.setObjFileName(MI.Obj);
       for (auto Symbol : ModiStream.Symbols)
         ModiBuilder.addSymbol(Symbol.Record);
     }
+    if (MI.FileLineInfo.hasValue()) {
+      const auto &FLI = *MI.FileLineInfo;
+      if (FLI.Lines.hasValue()) {
+        const auto &YamlLines = *FLI.Lines;
+        auto Lines = llvm::make_unique<ModuleDebugLineFragment>();
+        Lines->setCodeSize(YamlLines.CodeSize);
+        Lines->setRelocationAddress(YamlLines.RelocSegment,
+                                    YamlLines.RelocOffset);
+        Lines->setFlags(YamlLines.Flags);
+        for (const auto &LC : YamlLines.LineInfo) {
+          uint32_t NI =
+              ExitOnErr(DbiBuilder.getSourceFileNameIndex(LC.FileName));
+          Lines->createBlock(LC.FileName, NI);
+          if (Lines->hasColumnInfo()) {
+            for (const auto &Item : zip(LC.Lines, LC.Columns)) {
+              auto &L = std::get<0>(Item);
+              auto &C = std::get<1>(Item);
+              uint32_t LE = L.LineStart + L.EndDelta;
+              Lines->addLineAndColumnInfo(
+                  L.Offset, LineInfo(L.LineStart, LE, L.IsStatement),
+                  C.StartColumn, C.EndColumn);
+            }
+          } else {
+            for (const auto &L : LC.Lines) {
+              uint32_t LE = L.LineStart + L.EndDelta;
+              Lines->addLineInfo(L.Offset,
+                                 LineInfo(L.LineStart, LE, L.IsStatement));
+            }
+          }
+        }
+        ModiBuilder.setC13LineInfo(std::move(Lines));
+      }
+
+      if (!FLI.FileChecksums.empty()) {
+        auto Checksums = llvm::make_unique<ModuleDebugFileChecksumFragment>();
+        auto &Strings = Builder.getStringTableBuilder();
+        for (auto &FC : FLI.FileChecksums) {
+          uint32_t Index = Strings.getStringIndex(FC.FileName);
+          Checksums->addChecksum(Index, FC.Kind, FC.ChecksumBytes.Bytes);
+        }
+        ModiBuilder.setC13FileChecksums(std::move(Checksums));
+      }
+    }
   }
 
   auto &TpiBuilder = Builder.getTpiBuilder();
   const auto &Tpi = YamlObj.TpiStream.getValueOr(DefaultTpiStream);
   TpiBuilder.setVersionHeader(Tpi.Version);
   for (const auto &R : Tpi.Records)
     TpiBuilder.addTypeRecord(R.Record.data(), R.Record.Hash);
 

llvm/tools/llvm-readobj/COFFDumper.cpp

for (unsigned I = 0, E = FunctionNames.size(); I != E; ++I) {
     StringRef Name = FunctionNames[I];
     ListScope S(W, "FunctionLineTable");
     W.printString("LinkageName", Name);
 
     DataExtractor DE(FunctionLineTables[Name], true, 4);
     uint32_t Offset = 6;  // Skip relocations.
     uint16_t Flags = DE.getU16(&Offset);
     W.printHex("Flags", Flags);
-    bool HasColumnInformation = Flags & codeview::LineFlags::HaveColumns;
+    bool HasColumnInformation = Flags & kLineFlagsHaveColumns;
     uint32_t FunctionSize = DE.getU32(&Offset);
     W.printHex("CodeSize", FunctionSize);
     while (DE.isValidOffset(Offset)) {
       // For each range of lines with the same filename, we have a segment
       // in the line table.  The filename string is accessed using double
       // indirection to the string table subsection using the index subsection.
       uint32_t OffsetInIndex = DE.getU32(&Offset),
                NumLines = DE.getU32(&Offset),
if (auto EC = CVSD.dump(Symbols)) {
     error(std::move(EC));
   }
   W.flush();
 }
 
 void COFFDumper::printCodeViewFileChecksums(StringRef Subsection) {
   BinaryByteStream S(Subsection, llvm::support::little);
   BinaryStreamReader SR(S);
-  ModuleDebugFileChecksumFragment Checksums;
+  ModuleDebugFileChecksumFragmentRef Checksums;
   error(Checksums.initialize(SR));
 
   for (auto &FC : Checksums) {
     DictScope S(W, "FileChecksum");
 
     if (FC.FileNameOffset >= CVStringTable.size())
       error(object_error::parse_failed);
     StringRef Filename =