Fix bug 34608 by moving private header out of public header.WindowsManifestMerger.h should not include llvm/Config/config.h, since it is private. The include has been moved to the source instead.

[ecbeckmann]

Summary

The checksums had already been placed in the IR, this patch allows
MCCodeView to actually write it out to an MCStreamer.

Move private config.h header dependency out of public header file.

Addresses Bug 34608

[ecbeckmann]

Exclude checksums

[orivej]

This fixes the issue. Thank you!

[orivej]

llvm/lib/WindowsManifest/WindowsManifestMerger.cpp

16

Shouldn't the synonymous header be always the first include (to check that it is self-sufficient)?

[ecbeckmann]

Put synonymous header first.

[ecbeckmann]

llvm/lib/WindowsManifest/WindowsManifestMerger.cpp

16

right good point

clang/lib/CodeGen/CGDebugInfo.cpp

StringRef CGDebugInfo::getClassName(const RecordDecl *RD) {
   return StringRef();
 }
 
 llvm::DIFile::ChecksumKind
 CGDebugInfo::computeChecksum(FileID FID, SmallString<32> &Checksum) const {
   Checksum.clear();
 
   if (!CGM.getCodeGenOpts().EmitCodeView)
-    return llvm::DIFile::CSK_None;
+    return llvm::DIFile::ChecksumKind::CSK_None;
 
   SourceManager &SM = CGM.getContext().getSourceManager();
   bool Invalid;
   llvm::MemoryBuffer *MemBuffer = SM.getBuffer(FID, &Invalid);
   if (Invalid)
-    return llvm::DIFile::CSK_None;
+    return llvm::DIFile::ChecksumKind::CSK_None;
 
   llvm::MD5 Hash;
   llvm::MD5::MD5Result Result;
 
   Hash.update(MemBuffer->getBuffer());
   Hash.final(Result);
 
   Hash.stringifyResult(Result, Checksum);
-  return llvm::DIFile::CSK_MD5;
+  return llvm::DIFile::ChecksumKind::CSK_MD5;
 }
 
 llvm::DIFile *CGDebugInfo::getOrCreateFile(SourceLocation Loc) {
   if (!Loc.isValid())
     // If Location is not valid then use main input file.
     return DBuilder.createFile(remapDIPath(TheCU->getFilename()),
                                remapDIPath(TheCU->getDirectory()),
                                TheCU->getFile()->getChecksumKind(),
if (!CWDName.empty())
     return CWDName;
   SmallString<256> CWD;
   llvm::sys::fs::current_path(CWD);
   return CWDName = internString(CWD);
 }
 
 void CGDebugInfo::CreateCompileUnit() {
   SmallString<32> Checksum;
-  llvm::DIFile::ChecksumKind CSKind = llvm::DIFile::CSK_None;
+  llvm::DIFile::ChecksumKind CSKind = llvm::DIFile::ChecksumKind::CSK_None;
 
   // Should we be asking the SourceManager for the main file name, instead of
   // accepting it as an argument? This just causes the main file name to
   // mismatch with source locations and create extra lexical scopes or
   // mismatched debug info (a CU with a DW_AT_file of "-", because that's what
   // the driver passed, but functions/other things have DW_AT_file of "<stdin>"
   // because that's what the SourceManager says)
 

llvm/include/llvm/IR/DIBuilder.h

createCompileUnit(unsigned Lang, DIFile *File, StringRef Producer,
                       bool DebugInfoForProfiling = false,
                       bool GnuPubnames = false);
 
     /// Create a file descriptor to hold debugging information for a file.
     /// \param Filename  File name.
     /// \param Directory Directory.
     /// \param CSKind    Checksum kind (e.g. CSK_None, CSK_MD5, CSK_SHA1, etc.).
     /// \param Checksum  Checksum data.
-    DIFile *createFile(StringRef Filename, StringRef Directory,
-                       DIFile::ChecksumKind CSKind = DIFile::CSK_None,
-                       StringRef Checksum = StringRef());
+    DIFile *
+    createFile(StringRef Filename, StringRef Directory,
+               DIFile::ChecksumKind CSKind = DIFile::ChecksumKind::None,
 
     /// Create debugging information entry for a macro.
     /// \param Parent     Macro parent (could be nullptr).
     /// \param Line       Source line number where the macro is defined.
     /// \param MacroType  DW_MACINFO_define or DW_MACINFO_undef.
     /// \param Name       Macro name.
     /// \param Value      Macro value.
     DIMacro *createMacro(DIMacroFile *Parent, unsigned Line, unsigned MacroType,

llvm/include/llvm/IR/DebugInfoMetadata.h

 ///
 /// TODO: Merge with directory/file node (including users).
 /// TODO: Canonicalize paths on creation.
 class DIFile : public DIScope {
   friend class LLVMContextImpl;
   friend class MDNode;
 
 public:
-  enum ChecksumKind {
-    CSK_None,
-    CSK_MD5,
-    CSK_SHA1,
-    CSK_Last = CSK_SHA1 // Should be last enumeration.
+  enum class ChecksumKind : uint8_t {
+    None,
+    MD5,
+    SHA1,
+    Last = SHA1 // Should be last enumeration.
   };
 
 private:
   ChecksumKind CSKind;
 
   DIFile(LLVMContext &C, StorageType Storage, ChecksumKind CSK,
          ArrayRef<Metadata *> Ops)
       : DIScope(C, DIFileKind, Storage, dwarf::DW_TAG_file_type, Ops),
static DIFile *getImpl(LLVMContext &Context, MDString *Filename,
                          StorageType Storage, bool ShouldCreate = true);
 
   TempDIFile cloneImpl() const {
     return getTemporary(getContext(), getFilename(), getDirectory(),
                         getChecksumKind(), getChecksum());
   }
 
 public:
-  DEFINE_MDNODE_GET(DIFile, (StringRef Filename, StringRef Directory,
-                             ChecksumKind CSK = CSK_None,
-                             StringRef CS = StringRef()),
+  DEFINE_MDNODE_GET(DIFile,
+                    (StringRef Filename, StringRef Directory,
+                     ChecksumKind CSK = ChecksumKind::None,
                     (Filename, Directory, CSK, CS))
-  DEFINE_MDNODE_GET(DIFile, (MDString *Filename, MDString *Directory,
-                             ChecksumKind CSK = CSK_None,
-                             MDString *CS = nullptr),
+  DEFINE_MDNODE_GET(DIFile,
+                    (MDString * Filename, MDString *Directory,
+                     ChecksumKind CSK = ChecksumKind::None,
                     (Filename, Directory, CSK, CS))
 
   TempDIFile clone() const { return cloneImpl(); }
 
   StringRef getFilename() const { return getStringOperand(0); }
   StringRef getDirectory() const { return getStringOperand(1); }
   StringRef getChecksum() const { return getStringOperand(2); }
   ChecksumKind getChecksumKind() const { return CSKind; }

llvm/include/llvm/MC/MCCodeView.h

 
 /// Holds state from .cv_file and .cv_loc directives for later emission.
 class CodeViewContext {
 public:
   CodeViewContext();
   ~CodeViewContext();
 
   bool isValidFileNumber(unsigned FileNumber) const;
-  bool addFile(unsigned FileNumber, StringRef Filename);
-  ArrayRef<StringRef> getFilenames() { return Filenames; }
+  bool addFile(MCStreamer &OS, unsigned FileNumber, StringRef Filename,
+               StringRef Checksum, uint8_t ChecksumKind);
 
   /// Records the function id of a normal function. Returns false if the
   /// function id has already been used, and true otherwise.
   bool recordFunctionId(unsigned FuncId);
 
   /// Records the function id of an inlined call site. Records the "inlined at"
   /// location info of the call site, including what function or inlined call
   /// site it was inlined into. Returns false if the function id has already
public:
   void encodeDefRange(MCAsmLayout &Layout, MCCVDefRangeFragment &F);
 
   /// Emits the string table substream.
   void emitStringTable(MCObjectStreamer &OS);
 
   /// Emits the file checksum substream.
   void emitFileChecksums(MCObjectStreamer &OS);
 
+  /// Emits the offset into the checksum table of the given file number.
+  void emitFileChecksumOffset(MCStreamer &OS, unsigned FileNo);
+
+  /// Assign the given file to have this offset in the checksum table.
+  void emitFileChecksumOffsetAssignment(MCStreamer &OS, MCSymbol *File,
+                                        unsigned Offset);
+
+  /// Assign all of the currently registered files their offsets in the checksum table.
+  void emitFileChecksumOffsetAssignments(MCStreamer &OS);
+
 private:
   /// The current CodeView line information from the last .cv_loc directive.
   MCCVLoc CurrentCVLoc = MCCVLoc(0, 0, 0, 0, false, true);
   bool CVLocSeen = false;
 
   /// Map from string to string table offset.
   StringMap<unsigned> StringTable;
 
   /// The fragment that ultimately holds our strings.
   MCDataFragment *StrTabFragment = nullptr;
   bool InsertedStrTabFragment = false;
 
   MCDataFragment *getStringTableFragment();
 
-  /// Add something to the string table.
-  StringRef addToStringTable(StringRef S);
+  /// Add something to the string table.  Returns the final string as well as offset into the string table.
+  std::pair<StringRef, unsigned> addToStringTable(StringRef S);
 
   /// Get a string table offset.
   unsigned getStringTableOffset(StringRef S);
 
-  /// An array of absolute paths. Eventually this may include the file checksum.
-  SmallVector<StringRef, 4> Filenames;
+  struct FileInfo {
+    unsigned StringTableOffset;
+    MCSymbol * ChecksumTableOffset; // Is a symbol because it might be requested before it has been calculated, so a fixup may be needed.
+    bool Assigned = false; // Indicates if this FileInfo corresponds to an actual file, or hasn't been set yet.
+    std::string Checksum;
+    uint8_t ChecksumKind;
+  };
+
+  /// Array storing added file information.  Each entry contains string table offset and checksum table offset.
+  SmallVector<FileInfo, 4> Files;
 
   /// The offset of the first and last .cv_loc directive for a given function
   /// id.
   std::map<unsigned, std::pair<size_t, size_t>> MCCVLineStartStop;
 
   /// A collection of MCCVLineEntry for each section.
   std::vector<MCCVLineEntry> MCCVLines;
 
   /// All known functions and inlined call sites, indexed by function id.
   std::vector<MCCVFunctionInfo> Functions;
+
+  /// Indicate whether we have already laid out the checksum table addresses or not.
+  bool ChecksumOffsetsAssigned = false;
 };
 
 } // end namespace llvm
 #endif

llvm/include/llvm/MC/MCObjectStreamer.h

void EmitCVInlineLinetableDirective(unsigned PrimaryFunctionId,
                                       unsigned SourceLineNum,
                                       const MCSymbol *FnStartSym,
                                       const MCSymbol *FnEndSym) override;
   void EmitCVDefRangeDirective(
       ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
       StringRef FixedSizePortion) override;
   void EmitCVStringTableDirective() override;
   void EmitCVFileChecksumsDirective() override;
+  void EmitCVFileChecksumOffsetDirective(MCSymbol *File,
+                                         unsigned Offset) override;
   void EmitDTPRel32Value(const MCExpr *Value) override;
   void EmitDTPRel64Value(const MCExpr *Value) override;
   void EmitTPRel32Value(const MCExpr *Value) override;
   void EmitTPRel64Value(const MCExpr *Value) override;
   void EmitGPRel32Value(const MCExpr *Value) override;
   void EmitGPRel64Value(const MCExpr *Value) override;
   bool EmitRelocDirective(const MCExpr &Offset, StringRef Name,
                           const MCExpr *Expr, SMLoc Loc) override;

llvm/include/llvm/MC/MCStreamer.h

public:
 
   /// \brief This implements the DWARF2 '.loc fileno lineno ...' assembler
   /// directive.
   virtual void EmitDwarfLocDirective(unsigned FileNo, unsigned Line,
                                      unsigned Column, unsigned Flags,
                                      unsigned Isa, unsigned Discriminator,
                                      StringRef FileName);
 
-  /// \brief Associate a filename with a specified logical file number.  This
+  /// \brief Associate a filename with a specified logical file number, and also specify that file's checksum information.  This
   /// implements the '.cv_file 4 "foo.c"' assembler directive. Returns true on
   /// success.
-  virtual bool EmitCVFileDirective(unsigned FileNo, StringRef Filename);
+  virtual bool EmitCVFileDirective(unsigned FileNo, StringRef Filename,
+                                   StringRef Checksum, unsigned ChecksumKind);
 
   /// \brief Introduces a function id for use with .cv_loc.
   virtual bool EmitCVFuncIdDirective(unsigned FunctionId);
 
   /// \brief Introduces an inline call site id for use with .cv_loc. Includes
   /// extra information for inline line table generation.
   virtual bool EmitCVInlineSiteIdDirective(unsigned FunctionId, unsigned IAFunc,
                                            unsigned IAFile, unsigned IALine,
virtual void EmitCVDefRangeDirective(
       StringRef FixedSizePortion);
 
   /// \brief This implements the CodeView '.cv_stringtable' assembler directive.
   virtual void EmitCVStringTableDirective() {}
 
   /// \brief This implements the CodeView '.cv_filechecksums' assembler directive.
   virtual void EmitCVFileChecksumsDirective() {}
 
+  virtual void EmitCVFileChecksumOffset(unsigned FileNo);
+
+  /// \brief This implements the CodeView '.cv_filechecksumoffset' assembler directive.
+  virtual void EmitCVFileChecksumOffsetDirective(MCSymbol *File,
+                                                 unsigned Offset) {}
+
+  /// This outputs all of the checksum offset directives of added files, in order of file number.
+  virtual void EmitCVFileChecksumOffsetDirectives();
+
   /// Emit the absolute difference between two symbols.
   ///
   /// \pre Offset of \c Hi is greater than the offset \c Lo.
   virtual void emitAbsoluteSymbolDiff(const MCSymbol *Hi, const MCSymbol *Lo,
                                       unsigned Size);
 
   virtual MCSymbol *getDwarfLineTableSymbol(unsigned CUID);
   virtual void EmitCFISections(bool EH, bool Debug);

llvm/include/llvm/WindowsManifest/WindowsManifestMerger.h

 // Ref:
 // https://msdn.microsoft.com/en-us/library/windows/desktop/aa374191(v=vs.85).aspx
 //
 //===---------------------------------------------------------------------===//
 
 #ifndef LLVM_INCLUDE_LLVM_SUPPORT_WINDOWS_MANIFEST_MERGER_H
 #define LLVM_INCLUDE_LLVM_SUPPORT_WINDOWS_MANIFEST_MERGER_H
 
-#include "llvm/Config/config.h"
 #include "llvm/Support/Error.h"
 
 namespace llvm {
 
 class MemoryBuffer;
 
 namespace windows_manifest {
 

llvm/lib/AsmParser/LLParser.cpp

MDStringField(bool AllowEmpty = true)
       : ImplTy(nullptr), AllowEmpty(AllowEmpty) {}
 };
 
 struct MDFieldList : public MDFieldImpl<SmallVector<Metadata *, 4>> {
   MDFieldList() : ImplTy(SmallVector<Metadata *, 4>()) {}
 };
 
 struct ChecksumKindField : public MDFieldImpl<DIFile::ChecksumKind> {
-  ChecksumKindField() : ImplTy(DIFile::CSK_None) {}
+  ChecksumKindField() : ImplTy(DIFile::ChecksumKind::None) {}
   ChecksumKindField(DIFile::ChecksumKind CSKind) : ImplTy(CSKind) {}
 };
 
 } // end anonymous namespace
 
 namespace llvm {
 
 template <>

llvm/lib/Bitcode/Reader/MetadataLoader.cpp

case bitc::METADATA_FILE: {
     if (Record.size() != 3 && Record.size() != 5)
       return error("Invalid record");
 
     IsDistinct = Record[0];
     MetadataList.assignValue(
         GET_OR_DISTINCT(
             DIFile,
             (Context, getMDString(Record[1]), getMDString(Record[2]),
-             Record.size() == 3 ? DIFile::CSK_None
+             Record.size() == 3 ? DIFile::ChecksumKind::None
                                 : static_cast<DIFile::ChecksumKind>(Record[3]),
              Record.size() == 3 ? nullptr : getMDString(Record[4]))),
         NextMetadataNo);
     NextMetadataNo++;
     break;
   }
   case bitc::METADATA_COMPILE_UNIT: {
     if (Record.size() < 14 || Record.size() > 19)

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

 }
 
 void ModuleBitcodeWriter::writeDIFile(const DIFile *N,
                                       SmallVectorImpl<uint64_t> &Record,
                                       unsigned Abbrev) {
   Record.push_back(N->isDistinct());
   Record.push_back(VE.getMetadataOrNullID(N->getRawFilename()));
   Record.push_back(VE.getMetadataOrNullID(N->getRawDirectory()));
-  Record.push_back(N->getChecksumKind());
+  Record.push_back(static_cast<uint8_t>(N->getChecksumKind()));
   Record.push_back(VE.getMetadataOrNullID(N->getRawChecksum()));
 
   Stream.EmitRecord(bitc::METADATA_FILE, Record, Abbrev);
   Record.clear();
 }
 
 void ModuleBitcodeWriter::writeDICompileUnit(const DICompileUnit *N,
                                              SmallVectorImpl<uint64_t> &Record,

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

 }
 
 unsigned CodeViewDebug::maybeRecordFile(const DIFile *F) {
   unsigned NextId = FileIdMap.size() + 1;
   auto Insertion = FileIdMap.insert(std::make_pair(F, NextId));
   if (Insertion.second) {
     // We have to compute the full filepath and emit a .cv_file directive.
     StringRef FullPath = getFullFilepath(F);
-    bool Success = OS.EmitCVFileDirective(NextId, FullPath);
+    StringRef Checksum = F->getChecksum();
+    DIFile::ChecksumKind ChecksumKind = F->getChecksumKind();
+    bool Success = OS.EmitCVFileDirective(NextId, FullPath, Checksum,
+                                          static_cast<unsigned>(ChecksumKind));
     (void)Success;
     assert(Success && ".cv_file directive failed");
   }
   return Insertion.first->second;
 }
 
 CodeViewDebug::InlineSite &
 CodeViewDebug::getInlineSite(const DILocation *InlinedAt,
if (!GlobalUDTs.empty()) {
     MCSymbol *SymbolsEnd = beginCVSubsection(DebugSubsectionKind::Symbols);
     emitDebugInfoForUDTs(GlobalUDTs);
     endCVSubsection(SymbolsEnd);
   }
 
   // This subsection holds a file index to offset in string table table.
   OS.AddComment("File index to string table offset subsection");
   OS.EmitCVFileChecksumsDirective();
+  OS.EmitCVFileChecksumOffsetDirectives();
 
   // This subsection holds the string table.
   OS.AddComment("String table");
   OS.EmitCVStringTableDirective();
 
   // Emit type information last, so that any types we translate while emitting
   // function info are included.
   emitTypeInformation();
for (const DISubprogram *SP : InlinedSubprograms) {
     assert(TypeIndices.count({SP, nullptr}));
     TypeIndex InlineeIdx = TypeIndices[{SP, nullptr}];
 
     OS.AddBlankLine();
     unsigned FileId = maybeRecordFile(SP->getFile());
     OS.AddComment("Inlined function " + SP->getName() + " starts at " +
                   SP->getFilename() + Twine(':') + Twine(SP->getLine()));
     OS.AddBlankLine();
-    // The filechecksum table uses 8 byte entries for now, and file ids start at
-    // 1.
-    unsigned FileOffset = (FileId - 1) * 8;
     OS.AddComment("Type index of inlined function");
     OS.EmitIntValue(InlineeIdx.getIndex(), 4);
     OS.AddComment("Offset into filechecksum table");
-    OS.EmitIntValue(FileOffset, 4);
+    OS.EmitCVFileChecksumOffset(FileId);
     OS.AddComment("Starting line number");
     OS.EmitIntValue(SP->getLine(), 4);
   }
 
   endCVSubsection(InlineEnd);
 }
 
 void CodeViewDebug::emitInlinedCallSite(const FunctionInfo &FI,

llvm/lib/DebugInfo/CodeView/DebugChecksumsSubsection.cpp

operator()(BinaryStreamRef Stream, uint32_t &Len, FileChecksumEntry &Item) {
 
   Len = alignTo(Header->ChecksumSize + sizeof(FileChecksumEntryHeader), 4);
   return Error::success();
 }
 
 Error DebugChecksumsSubsectionRef::initialize(BinaryStreamReader Reader) {
   if (auto EC = Reader.readArray(Checksums, Reader.bytesRemaining()))
     return EC;
-
   return Error::success();
 }
 
 Error DebugChecksumsSubsectionRef::initialize(BinaryStreamRef Section) {
   BinaryStreamReader Reader(Section);
   return initialize(Reader);
 }
 

llvm/lib/IR/AsmWriter.cpp

void MDFieldPrinter::printMacinfoType(const DIMacroNode *N) {
   auto Type = dwarf::MacinfoString(N->getMacinfoType());
   if (!Type.empty())
     Out << Type;
   else
     Out << N->getMacinfoType();
 }
 
 void MDFieldPrinter::printChecksumKind(const DIFile *N) {
-  if (N->getChecksumKind() == DIFile::CSK_None)
+  if (N->getChecksumKind() == DIFile::ChecksumKind::None)
     // Skip CSK_None checksum kind.
     return;
   Out << FS << "checksumkind: " << N->getChecksumKindAsString();
 }
 
 void MDFieldPrinter::printString(StringRef Name, StringRef Value,
                                  bool ShouldSkipEmpty) {
   if (ShouldSkipEmpty && Value.empty())

llvm/lib/IR/DebugInfoMetadata.cpp

DISubroutineType *DISubroutineType::getImpl(LLVMContext &Context, DIFlags Flags,
                                             uint8_t CC, Metadata *TypeArray,
                                             StorageType Storage,
                                             bool ShouldCreate) {
   DEFINE_GETIMPL_LOOKUP(DISubroutineType, (Flags, CC, TypeArray));
   Metadata *Ops[] = {nullptr, nullptr, nullptr, TypeArray};
   DEFINE_GETIMPL_STORE(DISubroutineType, (Flags, CC), Ops);
 }
 
-static const char *ChecksumKindName[DIFile::CSK_Last + 1] = {
-  "CSK_None",
-  "CSK_MD5",
-  "CSK_SHA1"
-};
+static const char *
+    ChecksumKindName[static_cast<uint8_t>(DIFile::ChecksumKind::Last) + 1] =
+        {"CSK_None", "CSK_MD5", "CSK_SHA1"};
 
 DIFile::ChecksumKind DIFile::getChecksumKind(StringRef CSKindStr) {
   return StringSwitch<DIFile::ChecksumKind>(CSKindStr)
-      .Case("CSK_MD5", DIFile::CSK_MD5)
-      .Case("CSK_SHA1", DIFile::CSK_SHA1)
-      .Default(DIFile::CSK_None);
+      .Case("CSK_MD5", DIFile::ChecksumKind::MD5)
+      .Case("CSK_SHA1", DIFile::ChecksumKind::SHA1)
+      .Default(DIFile::ChecksumKind::None);
 }
 
 StringRef DIFile::getChecksumKindAsString() const {
-  assert(CSKind <= DIFile::CSK_Last && "Invalid checksum kind");
-  return ChecksumKindName[CSKind];
+  assert(CSKind <= DIFile::ChecksumKind::Last && "Invalid checksum kind");
+  return ChecksumKindName[static_cast<uint8_t>(CSKind)];
 }
 
 DIFile *DIFile::getImpl(LLVMContext &Context, MDString *Filename,
                         MDString *Directory, DIFile::ChecksumKind CSKind,
                         MDString *Checksum, StorageType Storage,
                         bool ShouldCreate) {
   assert(isCanonical(Filename) && "Expected canonical MDString");
   assert(isCanonical(Directory) && "Expected canonical MDString");

llvm/lib/IR/Verifier.cpp

if (auto *Types = N.getRawTypeArray()) {
     }
   }
   AssertDI(!hasConflictingReferenceFlags(N.getFlags()),
            "invalid reference flags", &N);
 }
 
 void Verifier::visitDIFile(const DIFile &N) {
   AssertDI(N.getTag() == dwarf::DW_TAG_file_type, "invalid tag", &N);
-  AssertDI((N.getChecksumKind() != DIFile::CSK_None ||
-            N.getChecksum().empty()), "invalid checksum kind", &N);
+  AssertDI((N.getChecksumKind() != DIFile::ChecksumKind::None ||
+            N.getChecksum().empty()),
+           "invalid checksum kind", &N);
 }
 
 void Verifier::visitDICompileUnit(const DICompileUnit &N) {
   AssertDI(N.isDistinct(), "compile units must be distinct", &N);
   AssertDI(N.getTag() == dwarf::DW_TAG_compile_unit, "invalid tag", &N);
 
   // Don't bother verifying the compilation directory or producer string
   // as those could be empty.

llvm/lib/MC/MCAsmStreamer.cpp

unsigned EmitDwarfFileDirective(unsigned FileNo, StringRef Directory,
                                   StringRef Filename,
                                   unsigned CUID = 0) override;
   void EmitDwarfLocDirective(unsigned FileNo, unsigned Line,
                              unsigned Column, unsigned Flags,
                              unsigned Isa, unsigned Discriminator,
                              StringRef FileName) override;
   MCSymbol *getDwarfLineTableSymbol(unsigned CUID) override;
 
-  bool EmitCVFileDirective(unsigned FileNo, StringRef Filename) override;
+  bool EmitCVFileDirective(unsigned FileNo, StringRef Filename,
+                           StringRef Checksum, unsigned ChecksumKind) override;
   bool EmitCVFuncIdDirective(unsigned FuncId) override;
   bool EmitCVInlineSiteIdDirective(unsigned FunctionId, unsigned IAFunc,
                                    unsigned IAFile, unsigned IALine,
                                    unsigned IACol, SMLoc Loc) override;
   void EmitCVLocDirective(unsigned FunctionId, unsigned FileNo, unsigned Line,
                           unsigned Column, bool PrologueEnd, bool IsStmt,
                           StringRef FileName, SMLoc Loc) override;
   void EmitCVLinetableDirective(unsigned FunctionId, const MCSymbol *FnStart,
                                 const MCSymbol *FnEnd) override;
   void EmitCVInlineLinetableDirective(unsigned PrimaryFunctionId,
                                       unsigned SourceFileId,
                                       unsigned SourceLineNum,
                                       const MCSymbol *FnStartSym,
                                       const MCSymbol *FnEndSym) override;
   void EmitCVDefRangeDirective(
       ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
       StringRef FixedSizePortion) override;
   void EmitCVStringTableDirective() override;
   void EmitCVFileChecksumsDirective() override;
+  void EmitCVFileChecksumOffsetDirective(MCSymbol *File,
+                                         unsigned Offset) override;
 
   void EmitIdent(StringRef IdentString) override;
   void EmitCFISections(bool EH, bool Debug) override;
   void EmitCFIDefCfa(int64_t Register, int64_t Offset) override;
   void EmitCFIDefCfaOffset(int64_t Offset) override;
   void EmitCFIDefCfaRegister(int64_t Register) override;
   void EmitCFIOffset(int64_t Register, int64_t Offset) override;
   void EmitCFIPersonality(const MCSymbol *Sym, unsigned Encoding) override;

 }
 
 MCSymbol *MCAsmStreamer::getDwarfLineTableSymbol(unsigned CUID) {
   // Always use the zeroth line table, since asm syntax only supports one line
   // table for now.
   return MCStreamer::getDwarfLineTableSymbol(0);
 }
 
-bool MCAsmStreamer::EmitCVFileDirective(unsigned FileNo, StringRef Filename) {
-  if (!getContext().getCVContext().addFile(FileNo, Filename))
+bool MCAsmStreamer::EmitCVFileDirective(unsigned FileNo, StringRef Filename,
+                                        StringRef Checksum,
+                                        unsigned ChecksumKind) {
+  if (!getContext().getCVContext().addFile(*this, FileNo, Filename, Checksum,
+                                           ChecksumKind))
     return false;
 
   OS << "\t.cv_file\t" << FileNo << ' ';
-
   PrintQuotedString(Filename, OS);
+
+  if (!ChecksumKind) {
+    EmitEOL();
+    return true;
+  }
+
+  OS << ' ';
+  PrintQuotedString(Checksum, OS);
+  OS << ' ' << ChecksumKind;
+
   EmitEOL();
   return true;
 }
 
 bool MCAsmStreamer::EmitCVFuncIdDirective(unsigned FuncId) {
   OS << "\t.cv_func_id " << FuncId << '\n';
   return MCStreamer::EmitCVFuncIdDirective(FuncId);
 }
void MCAsmStreamer::EmitCVStringTableDirective() {
   EmitEOL();
 }
 
 void MCAsmStreamer::EmitCVFileChecksumsDirective() {
   OS << "\t.cv_filechecksums";
   EmitEOL();
 }
 
+void MCAsmStreamer::EmitCVFileChecksumOffsetDirective(MCSymbol *File,
+                                                      unsigned Offset) {
+  OS << "\t.cv_filechecksumoffset\t";
+  File->print(OS, MAI);
+  OS << " " << Offset;
+  EmitEOL();
+}
+
 void MCAsmStreamer::EmitIdent(StringRef IdentString) {
   assert(MAI->hasIdentDirective() && ".ident directive not supported");
   OS << "\t.ident\t";
   PrintQuotedString(IdentString, OS);
   EmitEOL();
 }
 
 void MCAsmStreamer::EmitCFISections(bool EH, bool Debug) {

llvm/lib/MC/MCCodeView.cpp

CodeViewContext::~CodeViewContext() {
   if (!InsertedStrTabFragment)
     delete StrTabFragment;
 }
 
 /// This is a valid number for use with .cv_loc if we've already seen a .cv_file
 /// for it.
 bool CodeViewContext::isValidFileNumber(unsigned FileNumber) const {
   unsigned Idx = FileNumber - 1;
-  if (Idx < Filenames.size())
-    return !Filenames[Idx].empty();
+  if (Idx < Files.size())
+    return Files[Idx].Assigned;
   return false;
 }
 
-bool CodeViewContext::addFile(unsigned FileNumber, StringRef Filename) {
+bool CodeViewContext::addFile(MCStreamer &OS, unsigned FileNumber,
+                              StringRef Filename, StringRef Checksum,
+                              uint8_t ChecksumKind) {
   assert(FileNumber > 0);
-  Filename = addToStringTable(Filename);
+  auto FilenameOffset = addToStringTable(Filename);
+  Filename = FilenameOffset.first;
   unsigned Idx = FileNumber - 1;
-  if (Idx >= Filenames.size())
-    Filenames.resize(Idx + 1);
+  if (Idx >= Files.size())
+    Files.resize(Idx + 1);
 
   if (Filename.empty())
     Filename = "<stdin>";
 
-  if (!Filenames[Idx].empty())
+  if (Files[Idx].Assigned)
     return false;
 
-  // FIXME: We should store the string table offset of the filename, rather than
-  // the filename itself for efficiency.
-  Filename = addToStringTable(Filename);
+  FilenameOffset = addToStringTable(Filename);
+  Filename = FilenameOffset.first;
+  unsigned Offset = FilenameOffset.second;
+
+  auto ChecksumOffsetSymbol =
+      OS.getContext().getOrCreateSymbol("file" + std::to_string(FileNumber));
+  Files[Idx].StringTableOffset = Offset;
+  Files[Idx].ChecksumTableOffset = ChecksumOffsetSymbol;
+  Files[Idx].Assigned = true;
+  Files[Idx].Checksum = Checksum.str();
+  Files[Idx].ChecksumKind = ChecksumKind;
 
-  Filenames[Idx] = Filename;
   return true;
 }
 
 bool CodeViewContext::recordFunctionId(unsigned FuncId) {
   if (FuncId >= Functions.size())
     Functions.resize(FuncId + 1);
 
   // Return false if this function info was already allocated.
MCDataFragment *CodeViewContext::getStringTableFragment() {
   if (!StrTabFragment) {
     StrTabFragment = new MCDataFragment();
     // Start a new string table out with a null byte.
     StrTabFragment->getContents().push_back('\0');
   }
   return StrTabFragment;
 }
 
-StringRef CodeViewContext::addToStringTable(StringRef S) {
+std::pair<StringRef, unsigned> CodeViewContext::addToStringTable(StringRef S) {
   SmallVectorImpl<char> &Contents = getStringTableFragment()->getContents();
   auto Insertion =
       StringTable.insert(std::make_pair(S, unsigned(Contents.size())));
   // Return the string from the table, since it is stable.
-  S = Insertion.first->first();
+  std::pair<StringRef, unsigned> Ret = std::make_pair(Insertion.first->first(), Insertion.first->second);
   if (Insertion.second) {
     // The string map key is always null terminated.
-    Contents.append(S.begin(), S.end() + 1);
+    Contents.append(Ret.first.begin(), Ret.first.end() + 1);
   }
-  return S;
+  return Ret;
 }
 
 unsigned CodeViewContext::getStringTableOffset(StringRef S) {
   // A string table offset of zero is always the empty string.
   if (S.empty())
     return 0;
   auto I = StringTable.find(S);
   assert(I != StringTable.end());
   return I->second;
 }
 
+
+//Induce fixups for all the placeholder symbols used to store file checksum offsets.
+void CodeViewContext::emitFileChecksumOffsetAssignment(MCStreamer &OS,
+                                                       MCSymbol *File,
+                                                       unsigned Offset) {
+  MCContext &Ctx = OS.getContext();
+  OS.EmitAssignment(File, MCConstantExpr::create(Offset, Ctx));
+}
+
+void CodeViewContext::emitFileChecksumOffsetAssignments(MCStreamer &OS) {
+  if (ChecksumOffsetsAssigned)
+    return;
+  ChecksumOffsetsAssigned = true;
+  unsigned CurrentOffset = 0;
+  for (auto File : Files) {
+    OS.EmitCVFileChecksumOffsetDirective(File.ChecksumTableOffset, CurrentOffset);
+    CurrentOffset += 4;
+    if (!File.ChecksumKind) {
+      CurrentOffset += 4;
+      continue;
+    }
+    CurrentOffset += 2;
+    CurrentOffset += File.Checksum.size();
+    CurrentOffset = alignTo(CurrentOffset, 4);
+  }
+}
+
 void CodeViewContext::emitStringTable(MCObjectStreamer &OS) {
   MCContext &Ctx = OS.getContext();
   MCSymbol *StringBegin = Ctx.createTempSymbol("strtab_begin", false),
            *StringEnd = Ctx.createTempSymbol("strtab_end", false);
 
   OS.EmitIntValue(unsigned(DebugSubsectionKind::StringTable), 4);
   OS.emitAbsoluteSymbolDiff(StringEnd, StringBegin, 4);
   OS.EmitLabel(StringBegin);
void CodeViewContext::emitStringTable(MCObjectStreamer &OS) {
   OS.EmitValueToAlignment(4, 0);
 
   OS.EmitLabel(StringEnd);
 }
 
 void CodeViewContext::emitFileChecksums(MCObjectStreamer &OS) {
   // Do nothing if there are no file checksums. Microsoft's linker rejects empty
   // CodeView substreams.
-  if (Filenames.empty())
+  if (Files.empty())
     return;
 
   MCContext &Ctx = OS.getContext();
   MCSymbol *FileBegin = Ctx.createTempSymbol("filechecksums_begin", false),
            *FileEnd = Ctx.createTempSymbol("filechecksums_end", false);
 
   OS.EmitIntValue(unsigned(DebugSubsectionKind::FileChecksums), 4);
   OS.emitAbsoluteSymbolDiff(FileEnd, FileBegin, 4);
   OS.EmitLabel(FileBegin);
 
   // Emit an array of FileChecksum entries. We index into this table using the
-  // user-provided file number. Each entry is currently 8 bytes, as we don't
-  // emit checksums.
-  for (StringRef Filename : Filenames) {
-    OS.EmitIntValue(getStringTableOffset(Filename), 4);
-    // Zero the next two fields and align back to 4 bytes. This indicates that
-    // no checksum is present.
+  // user-provided file number.  Each entry may be a variable number of bytes
+  // determined by the checksum kind and size.
+  for (auto File : Files) {
+    OS.EmitIntValue(File.StringTableOffset, 4);
+
+    if (!File.ChecksumKind) {
+      // There is no checksum.
       OS.EmitIntValue(0, 4);
+      continue;
+    }
+    OS.EmitIntValue(static_cast<uint8_t>(File.Checksum.size()),
+                    1);
+    OS.EmitIntValue(File.ChecksumKind, 1);
+    OS.EmitBytes(File.Checksum);
+    OS.EmitValueToAlignment(4);
   }
 
   OS.EmitLabel(FileEnd);
 }
 
+// Output checksum table offset of the given file number.  It is possible that not all
+// files have been registered yet, and so the offset cannot be calculated.  In this case
+// a symbol representing the offset is emitted, and the value of this symbol will be fixed
+// up at a later time.
+void CodeViewContext::emitFileChecksumOffset(MCStreamer &OS, unsigned FileNo) {
+  unsigned Idx = FileNo - 1;
+
+  if (Idx >= Files.size())
+    Files.resize(Idx + 1);
+
+  if (ChecksumOffsetsAssigned) {
+    OS.EmitSymbolValue(Files[Idx].ChecksumTableOffset, 4);
+    return;
+  }
+
+  const MCSymbolRefExpr *SRE =
+      MCSymbolRefExpr::create(Files[Idx].ChecksumTableOffset, OS.getContext());
+
+  OS.EmitValueImpl(SRE, 4);
+}
+
 void CodeViewContext::emitLineTableForFunction(MCObjectStreamer &OS,
                                                unsigned FuncId,
                                                const MCSymbol *FuncBegin,
                                                const MCSymbol *FuncEnd) {
   MCContext &Ctx = OS.getContext();
   MCSymbol *LineBegin = Ctx.createTempSymbol("linetable_begin", false),
            *LineEnd = Ctx.createTempSymbol("linetable_end", false);
 
void CodeViewContext::emitLineTableForFunction(MCObjectStreamer &OS,
   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;
         });
     unsigned EntryCount = FileSegEnd - I;
-    OS.AddComment("Segment for file '" + Twine(Filenames[CurFileNum - 1]) +
-                  "' begins");
-    OS.EmitIntValue(8 * (CurFileNum - 1), 4);
+    OS.AddComment(
+        "Segment for file '" +
+        Twine(getStringTableFragment()
+                  ->getContents()[Files[CurFileNum - 1].StringTableOffset]) +
+    OS.EmitCVFileChecksumOffset(CurFileNum);
     OS.EmitIntValue(EntryCount, 4);
     uint32_t SegmentSize = 12;
     SegmentSize += 8 * EntryCount;
     if (HaveColumns)
       SegmentSize += 4 * EntryCount;
     OS.EmitIntValue(SegmentSize, 4);
 
     for (auto J = I; J != FileSegEnd; ++J) {
void CodeViewContext::encodeInlineLineTable(MCAsmLayout &Layout,
 
   const MCSymbol *LastLabel = Frag.getFnStartSym();
   MCCVFunctionInfo::LineInfo LastSourceLoc, CurSourceLoc;
   LastSourceLoc.File = Frag.StartFileId;
   LastSourceLoc.Line = Frag.StartLineNum;
 
   SmallVectorImpl<char> &Buffer = Frag.getContents();
   Buffer.clear(); // Clear old contents if we went through relaxation.
+
   for (const MCCVLineEntry &Loc : Locs) {
     // Exit early if our line table would produce an oversized InlineSiteSym
     // record. Account for the ChangeCodeLength annotation emitted after the
     // loop ends.
     constexpr uint32_t InlineSiteSize = 12;
     constexpr uint32_t AnnotationSize = 8;
     size_t MaxBufferSize = MaxRecordLength - InlineSiteSize - AnnotationSize;
     if (Buffer.size() >= MaxBufferSize)
for (const MCCVLineEntry &Loc : Locs) {
     // info, so we can skip updates for those.
     if (HaveOpenRange && CurSourceLoc.File == LastSourceLoc.File &&
         CurSourceLoc.Line == LastSourceLoc.Line)
       continue;
 
     HaveOpenRange = true;
 
     if (CurSourceLoc.File != LastSourceLoc.File) {
-      // File ids are 1 based, and each file checksum table entry is 8 bytes
-      // long. See emitFileChecksums above.
-      unsigned FileOffset = 8 * (CurSourceLoc.File - 1);
+      unsigned FileOffset = static_cast<const MCConstantExpr *>(
+                                      Files[CurSourceLoc.File - 1].ChecksumTableOffset->getVariableValue())->getValue();
       compressAnnotation(BinaryAnnotationsOpCode::ChangeFile, Buffer);
       compressAnnotation(FileOffset, Buffer);
     }
 
     int LineDelta = CurSourceLoc.Line - LastSourceLoc.Line;
     unsigned EncodedLineDelta = encodeSignedNumber(LineDelta);
     unsigned CodeDelta = computeLabelDiff(Layout, LastLabel, Loc.getLabel());
     if (CodeDelta == 0 && LineDelta != 0) {

llvm/lib/MC/MCObjectStreamer.cpp

 
 void MCObjectStreamer::EmitCVStringTableDirective() {
   getContext().getCVContext().emitStringTable(*this);
 }
 void MCObjectStreamer::EmitCVFileChecksumsDirective() {
   getContext().getCVContext().emitFileChecksums(*this);
 }
 
+void MCObjectStreamer::EmitCVFileChecksumOffsetDirective(MCSymbol *File,
+                                                         unsigned Offset) {
+  getContext().getCVContext().emitFileChecksumOffsetAssignment(*this, File,
+                                                               Offset);
+}
 
 void MCObjectStreamer::EmitBytes(StringRef Data) {
   MCCVLineEntry::Make(this);
   MCDwarfLineEntry::Make(this, getCurrentSectionOnly());
   MCDataFragment *DF = getOrCreateDataFragment();
   flushPendingLabels(DF, DF->getContents().size());
   DF->getContents().append(Data.begin(), Data.end());
 }

llvm/lib/MC/MCParser/AsmParser.cpp

enum DirectiveKind {
     DK_CV_FUNC_ID,
     DK_CV_INLINE_SITE_ID,
     DK_CV_LOC,
     DK_CV_LINETABLE,
     DK_CV_INLINE_LINETABLE,
     DK_CV_DEF_RANGE,
     DK_CV_STRINGTABLE,
     DK_CV_FILECHECKSUMS,
+    DK_CV_FILECHECKSUM_OFFSET,
     DK_CFI_SECTIONS,
     DK_CFI_STARTPROC,
     DK_CFI_ENDPROC,
     DK_CFI_DEF_CFA,
     DK_CFI_DEF_CFA_OFFSET,
     DK_CFI_ADJUST_CFA_OFFSET,
     DK_CFI_DEF_CFA_REGISTER,
     DK_CFI_OFFSET,
private:
   bool parseDirectiveCVFuncId();
   bool parseDirectiveCVInlineSiteId();
   bool parseDirectiveCVLoc();
   bool parseDirectiveCVLinetable();
   bool parseDirectiveCVInlineLinetable();
   bool parseDirectiveCVDefRange();
   bool parseDirectiveCVStringTable();
   bool parseDirectiveCVFileChecksums();
+  bool parseDirectiveCVFileChecksumOffset();
 
   // .cfi directives
   bool parseDirectiveCFIRegister(SMLoc DirectiveLoc);
   bool parseDirectiveCFIWindowSave();
   bool parseDirectiveCFISections();
   bool parseDirectiveCFIStartProc();
   bool parseDirectiveCFIEndProc();
   bool parseDirectiveCFIDefCfaOffset();
if (IDVal[0] == '.' && IDVal != ".") {
     case DK_CV_INLINE_LINETABLE:
       return parseDirectiveCVInlineLinetable();
     case DK_CV_DEF_RANGE:
       return parseDirectiveCVDefRange();
     case DK_CV_STRINGTABLE:
       return parseDirectiveCVStringTable();
     case DK_CV_FILECHECKSUMS:
       return parseDirectiveCVFileChecksums();
+    case DK_CV_FILECHECKSUM_OFFSET:
+      return parseDirectiveCVFileChecksumOffset();
     case DK_CFI_SECTIONS:
       return parseDirectiveCFISections();
     case DK_CFI_STARTPROC:
       return parseDirectiveCFIStartProc();
     case DK_CFI_ENDPROC:
       return parseDirectiveCFIEndProc();
     case DK_CFI_DEF_CFA:
       return parseDirectiveCFIDefCfa(IDLoc);

 
 /// parseDirectiveStabs
 /// ::= .stabs string, number, number, number
 bool AsmParser::parseDirectiveStabs() {
   return TokError("unsupported directive '.stabs'");
 }
 
 /// parseDirectiveCVFile
-/// ::= .cv_file number filename
+/// ::= .cv_file number filename [checksum] [checksumkind]
 bool AsmParser::parseDirectiveCVFile() {
   SMLoc FileNumberLoc = getTok().getLoc();
   int64_t FileNumber;
   std::string Filename;
+  std::string Checksum;
+  int64_t ChecksumKind = 0;
 
   if (parseIntToken(FileNumber,
                     "expected file number in '.cv_file' directive") ||
       check(FileNumber < 1, FileNumberLoc, "file number less than one") ||
       check(getTok().isNot(AsmToken::String),
             "unexpected token in '.cv_file' directive") ||
-      // Usually directory and filename are together, otherwise just
-      // directory. Allow the strings to have escaped octal character sequence.
-      parseEscapedString(Filename) ||
+      parseEscapedString(Filename))
+    return true;
+  if (!parseOptionalToken(AsmToken::EndOfStatement)) {
+    if (check(getTok().isNot(AsmToken::String),
+              "unexpected token in '.cv_file' directive") ||
+        parseEscapedString(Checksum) ||
+        parseIntToken(ChecksumKind,
+                      "expected checksum kind in '.cv_file' directive") ||
         parseToken(AsmToken::EndOfStatement,
                    "unexpected token in '.cv_file' directive"))
       return true;
+  }
 
-  if (!getStreamer().EmitCVFileDirective(FileNumber, Filename))
+  if (!getStreamer().EmitCVFileDirective(FileNumber, Filename, Checksum,
+                                         static_cast<uint8_t>(ChecksumKind)))
     return Error(FileNumberLoc, "file number already allocated");
 
   return false;
 }
 
 bool AsmParser::parseCVFunctionId(int64_t &FunctionId,
                                   StringRef DirectiveName) {
   SMLoc Loc;

 
 /// parseDirectiveCVFileChecksums
 /// ::= .cv_filechecksums
 bool AsmParser::parseDirectiveCVFileChecksums() {
   getStreamer().EmitCVFileChecksumsDirective();
   return false;
 }
 
+/// parseDirectiveCVFileChecksumOffset
+/// ::= .cv_filechecksumoffset fileid offset
+bool AsmParser::parseDirectiveCVFileChecksumOffset() {
+  SMLoc Loc = getTok().getLoc();
+  StringRef FileId;
+  int64_t Offset;
+  if (parseTokenLoc(Loc) ||
+      check(parseIdentifier(FileId), Loc, "expected identifier in directive") ||
+      parseIntToken(Offset,
+                    "expected Offset in  '.cv_filechecksumoffset' directive"))
+    return true;
+  if (parseToken(AsmToken::EndOfStatement, "Expected End of Statement"))
+    return true;
+  MCSymbol *File = getContext().getOrCreateSymbol(FileId);
+  getStreamer().EmitCVFileChecksumOffsetDirective(File, Offset);
+  return false;
+}
+
 /// parseDirectiveCFISections
 /// ::= .cfi_sections section [, section]
 bool AsmParser::parseDirectiveCFISections() {
   StringRef Name;
   bool EH = false;
   bool Debug = false;
 
   if (parseIdentifier(Name))
void AsmParser::initializeDirectiveKindMap() {
   DirectiveKindMap[".cv_func_id"] = DK_CV_FUNC_ID;
   DirectiveKindMap[".cv_loc"] = DK_CV_LOC;
   DirectiveKindMap[".cv_linetable"] = DK_CV_LINETABLE;
   DirectiveKindMap[".cv_inline_linetable"] = DK_CV_INLINE_LINETABLE;
   DirectiveKindMap[".cv_inline_site_id"] = DK_CV_INLINE_SITE_ID;
   DirectiveKindMap[".cv_def_range"] = DK_CV_DEF_RANGE;
   DirectiveKindMap[".cv_stringtable"] = DK_CV_STRINGTABLE;
   DirectiveKindMap[".cv_filechecksums"] = DK_CV_FILECHECKSUMS;
+  DirectiveKindMap[".cv_filechecksumoffset"] = DK_CV_FILECHECKSUM_OFFSET;
   DirectiveKindMap[".sleb128"] = DK_SLEB128;
   DirectiveKindMap[".uleb128"] = DK_ULEB128;
   DirectiveKindMap[".cfi_sections"] = DK_CFI_SECTIONS;
   DirectiveKindMap[".cfi_startproc"] = DK_CFI_STARTPROC;
   DirectiveKindMap[".cfi_endproc"] = DK_CFI_ENDPROC;
   DirectiveKindMap[".cfi_def_cfa"] = DK_CFI_DEF_CFA;
   DirectiveKindMap[".cfi_def_cfa_offset"] = DK_CFI_DEF_CFA_OFFSET;
   DirectiveKindMap[".cfi_adjust_cfa_offset"] = DK_CFI_ADJUST_CFA_OFFSET;

llvm/lib/MC/MCStreamer.cpp

 }
 
 void MCStreamer::EnsureValidDwarfFrame() {
   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
   if (!CurFrame || CurFrame->End)
     report_fatal_error("No open frame");
 }
 
-bool MCStreamer::EmitCVFileDirective(unsigned FileNo, StringRef Filename) {
-  return getContext().getCVContext().addFile(FileNo, Filename);
+bool MCStreamer::EmitCVFileDirective(unsigned FileNo, StringRef Filename,
+                                     StringRef Checksum,
+                                     unsigned ChecksumKind) {
+  return getContext().getCVContext().addFile(*this, FileNo, Filename, Checksum,
+                                             ChecksumKind);
 }
 
 bool MCStreamer::EmitCVFuncIdDirective(unsigned FunctionId) {
   return getContext().getCVContext().recordFunctionId(FunctionId);
 }
 
 bool MCStreamer::EmitCVInlineSiteIdDirective(unsigned FunctionId,
                                              unsigned IAFunc, unsigned IAFile,
void MCStreamer::EmitCVInlineLinetableDirective(unsigned PrimaryFunctionId,
                                                 unsigned SourceLineNum,
                                                 const MCSymbol *FnStartSym,
                                                 const MCSymbol *FnEndSym) {}
 
 void MCStreamer::EmitCVDefRangeDirective(
     ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
     StringRef FixedSizePortion) {}
 
+void MCStreamer::EmitCVFileChecksumOffset(unsigned FileNo) {
+  getContext().getCVContext().emitFileChecksumOffset(*this, FileNo);
+}
+
+void MCStreamer::EmitCVFileChecksumOffsetDirectives() {
+  getContext().getCVContext().emitFileChecksumOffsetAssignments(*this);
+}
+
 void MCStreamer::EmitEHSymAttributes(const MCSymbol *Symbol,
                                      MCSymbol *EHSymbol) {
 }
 
 void MCStreamer::InitSections(bool NoExecStack) {
   SwitchSection(getContext().getObjectFileInfo()->getTextSection());
 }
 

llvm/lib/WindowsManifest/WindowsManifestMerger.cpp

 //===-- WindowsManifestMerger.cpp ------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===---------------------------------------------------------------------===//
 //
 // This file implements the .manifest merger class.
 //
 //===---------------------------------------------------------------------===//
 
-#include "llvm/WindowsManifest/WindowsManifestMerger.h"
+#include "llvm/Config/config.h"
 #include "llvm/Support/MemoryBuffer.h"
+#include "llvm/WindowsManifest/WindowsManifestMerger.h"
 
 #include <map>
 
 #if LLVM_LIBXML2_ENABLED
 #include <libxml/xmlreader.h>
 #endif
 
 #define TO_XML_CHAR(X) reinterpret_cast<const unsigned char *>(X)

llvm/test/DebugInfo/COFF/asm.ll

 ; X86:      .cv_loc 0 1 6 0
 ; X86:      ret
 ; X86:      [[END_OF_F:.?Lfunc_end.*]]:
 
 ; Line table
 ; X86:      .cv_linetable 0, _f, [[END_OF_F]]
 ; File index to string table offset subsection
 ; X86-NEXT: .cv_filechecksums
+; X86-NEXT: .cv_filechecksumoffset file1 0
 ; String table
 ; X86-NEXT: .cv_stringtable
 
 ; OBJ32:    Section {
 ; OBJ32:      Name: .debug$S (2E 64 65 62 75 67 24 53)
 ; OBJ32:      Characteristics [ (0x42300040)
 ; OBJ32:      ]
 ; OBJ32:    CodeViewDebugInfo [

 ; X64:      addq    $40, %rsp
 ; X64-NEXT: ret
 ; X64:      [[END_OF_F:.?Lfunc_end.*]]:
 
 ; Line table
 ; X64:      .cv_linetable 0, f, [[END_OF_F]]
 ; File index to string table offset subsection
 ; X64-NEXT: .cv_filechecksums
+; X64-NEXT: .cv_filechecksumoffset file1 0
 ; String table
 ; X64-NEXT: .cv_stringtable
 
 ; OBJ64:    Section {
 ; OBJ64:      Name: .debug$S (2E 64 65 62 75 67 24 53)
 ; OBJ64:      Characteristics [ (0x42300040)
 ; OBJ64:      ]
 ; OBJ64:      Subsection [

llvm/test/DebugInfo/COFF/inlining.ll

 
 ; ASM: .section .debug$S,"dr"
 ; ASM: .long   246                     # Inlinee lines subsection
 ; ASM: .long   [[inline_end:.*]]-[[inline_beg:.*]] #
 ; ASM: [[inline_beg]]:
 ; ASM: .long   0
 ; ASM: # Inlined function bar starts at t.cpp:8
 ; ASM: .long   4098                    # Type index of inlined function
-; ASM: .long   0                       # Offset into filechecksum table
+; ASM: .long   file1                  # Offset into filechecksum table
 ; ASM: .long   8                       # Starting line number
 ; ASM: # Inlined function foo starts at t.cpp:2
 ; ASM: .long   4099
-; ASM: .long   0
+; ASM: .long   file1
 ; ASM: .long   2
 ; ASM: [[inline_end]]:
 
 ; ASM: .long   241                     # Symbol subsection for baz
 ; ASM: .long   {{.*}} # Subsection size
 ; ASM: .short 4429
 ; ASM: .long
 ; ASM: .long
 ; ASM: .long
 ; ASM: .cv_inline_linetable 1 1 8 Lfunc_begin0 Lfunc_end0
 ; ASM: .short 4429
 ; ASM: .long
 ; ASM: .long
 ; ASM: .long
 ; ASM: .cv_inline_linetable 2 1 2 Lfunc_begin0 Lfunc_end0
 ; ASM: .short  4430
 ; ASM: .short  4430
 
+; ASM: .cv_filechecksums
+; ASM: .cv_filechecksumoffset file1 0
+
 ; ASM: .section .debug$T,"dr"
 ; ASM: .long 4 # Debug section magic
 ; ASM: # ArgList (0x1000) {
 ; ASM: #   TypeLeafKind: LF_ARGLIST (0x1201)
 ; ASM: #   NumArgs: 0
 ; ASM: #   Arguments [
 ; ASM: #   ]
 ; ASM: # }

llvm/test/DebugInfo/COFF/multifile.ll

 ;  6 #line 2 "two.c"
 ;  7   g();
 ;  8 #line 7 "one.c"
 ;  9   g();
 ; 10 }
 
 ; X86-LABEL: _f:
 ; X86:      # BB
-; X86:      .cv_file 1 "D:\\one.c"
+; X86:      .cv_file 1 "D:\\one.c" "70b51f534d80639d033ae92c6a856af6" 1
 ; X86:      .cv_loc 0 1 1 0 is_stmt 0 # one.c:1:0
 ; X86:      calll   _g
-; X86:      .cv_file 2 "D:\\two.c"
+; X86:      .cv_file 2 "D:\\two.c" "70b51f534d80639d033ae92c6a856af6" 1
 ; X86:      .cv_loc 0 2 2 0 # two.c:2:0
 ; X86:      calll   _g
 ; X86:      .cv_loc 0 1 7 0 # one.c:7:0
 ; X86:      calll   _g
 ; X86:      .cv_loc 0 1 8 0 # one.c:8:0
 ; X86:      ret
 ; X86:      [[END_OF_F:.?Lfunc_end.*]]:
 
 ; Line table
 ; X86:      .cv_linetable 0, _f, [[END_OF_F]]
 ; File index to string table offset subsection
 ; X86-NEXT: .cv_filechecksums
+; X86-NEXT: .cv_filechecksumoffset file1 0
+; X86-NEXT: .cv_filechecksumoffset file2 40
+
 ; String table
 ; X86-NEXT: .cv_stringtable
 
 ; OBJ32:    Section {
 ; OBJ32:      Name: .debug$S (2E 64 65 62 75 67 24 53)
 ; OBJ32:      Characteristics [ (0x42300040)
 ; OBJ32:      ]
 ; OBJ32:      Subsection [
 ; OBJ32-NEXT:   SubSectionType: Symbols (0xF1)
 ; OBJ32:        {{.*}}Proc{{.*}}Sym {
 ; OBJ32:          CodeSize: 0x10
 ; OBJ32:          DisplayName: f
 ; OBJ32:          LinkageName: _f
 ; OBJ32:        }
 ; OBJ32-NEXT:   ProcEnd {
 ; OBJ32:        }
 ; OBJ32-NEXT: ]
+; OBJ32:    Subsection [
+; OBJ32:        SubSectionType: FileChecksums (0xF4)
+; OBJ32-NEXT:   SubSectionSize: 0x50
+; OBJ32-NEXT:   FileChecksum {
+; OBJ32-NEXT:     Filename: D:\one.c (0x1)
+; OBJ32-NEXT:     ChecksumSize: 0x20
+; OBJ32-NEXT:     ChecksumKind: MD5 (0x1)
+; OBJ32-NEXT:     ChecksumBytes (
+; OBJ32-NEXT:       0000: 37306235 31663533 34643830 36333964  |70b51f534d80639d|
+; OBJ32-NEXT:       0010: 30333361 65393263 36613835 36616636  |033ae92c6a856af6|
+; OBJ32-NEXT:     )
+; OBJ32-NEXT:   }
+; OBJ32-NEXT:   FileChecksum {
+; OBJ32-NEXT:     Filename: D:\two.c (0xA)
+; OBJ32-NEXT:     ChecksumSize: 0x20
+; OBJ32-NEXT:     ChecksumKind: MD5 (0x1)
+; OBJ32-NEXT:     ChecksumBytes (
+; OBJ32-NEXT:       0000: 37306235 31663533 34643830 36333964  |70b51f534d80639d|
+; OBJ32-NEXT:       0010: 30333361 65393263 36613835 36616636  |033ae92c6a856af6|
+; OBJ32-NEXT:     )
+; OBJ32-NEXT:   }
+; OBJ32-NEXT:  ]
 ; OBJ32:      FunctionLineTable [
 ; OBJ32-NEXT:   Name: _f
 ; OBJ32-NEXT:   Flags: 0x0
 ; OBJ32-NEXT:   CodeSize: 0x10
 ; OBJ32-NEXT:   FilenameSegment [
 ; OBJ32-NEXT:     Filename: D:\one.c
 ; OBJ32-NEXT:     +0x0 [
 ; OBJ32-NEXT:       LineNumberStart: 1

 ; OBJ32-NEXT:       LineNumberEndDelta: 0
 ; OBJ32-NEXT:       IsStatement: No
 ; OBJ32-NEXT:     ]
 ; OBJ32-NEXT:   ]
 ; OBJ32-NEXT: ]
 
 ; X64-LABEL: f:
 ; X64-NEXT: .L{{.*}}:{{$}}
-; X64:      .cv_file 1 "D:\\input.c"
+; X64:      .cv_file 1 "D:\\input.c" "70b51f534d80639d033ae92c6a856af6" 1
 ; X64:      .cv_loc 0 1 3 0 is_stmt 0 # input.c:3:0
 ; X64:      # BB
 ; X64:      subq    $40, %rsp
-; X64:      .cv_file 2 "D:\\one.c"
+; X64:      .cv_file 2 "D:\\one.c" "70b51f534d80639d033ae92c6a856af6" 1
 ; X64:      .cv_loc 0 2 1 0 # one.c:1:0
 ; X64:      callq   g
-; X64:      .cv_file 3 "D:\\two.c"
+; X64:      .cv_file 3 "D:\\two.c" "70b51f534d80639d033ae92c6a856af6" 1
 ; X64:      .cv_loc 0 3 2 0 # two.c:2:0
 ; X64:      callq   g
 ; X64:      .cv_loc 0 2 7 0 # one.c:7:0
 ; X64:      callq   g
 ; X64:      .cv_loc 0 2 8 0 # one.c:8:0
 ; X64:      addq    $40, %rsp
 ; X64-NEXT: ret
 ; X64:      [[END_OF_F:.?Lfunc_end.*]]:

 ; OBJ64:        {{.*}}Proc{{.*}}Sym {
 ; OBJ64:          CodeSize: 0x18
 ; OBJ64:          DisplayName: f
 ; OBJ64:          LinkageName: f
 ; OBJ64:        }
 ; OBJ64-NEXT:   ProcEnd {
 ; OBJ64:        }
 ; OBJ64-NEXT: ]
+; OBJ64:    Subsection [
+; OBJ64:        SubSectionType: FileChecksums (0xF4)
+; OBJ64-NEXT:   SubSectionSize: 0x78
+; OBJ64-NEXT:   FileChecksum {
+; OBJ64-NEXT:     Filename: D:\input.c (0x1)
+; OBJ64-NEXT:     ChecksumSize: 0x20
+; OBJ64-NEXT:     ChecksumKind: MD5 (0x1)
+; OBJ64-NEXT:     ChecksumBytes (
+; OBJ64-NEXT:       0000: 37306235 31663533 34643830 36333964  |70b51f534d80639d|
+; OBJ64-NEXT:       0010: 30333361 65393263 36613835 36616636  |033ae92c6a856af6|
+; OBJ64-NEXT:     )
+; OBJ64-NEXT:   }
+; OBJ64-NEXT:   FileChecksum {
+; OBJ64-NEXT:     Filename: D:\one.c (0xC)
+; OBJ64-NEXT:     ChecksumSize: 0x20
+; OBJ64-NEXT:     ChecksumKind: MD5 (0x1)
+; OBJ64-NEXT:     ChecksumBytes (
+; OBJ64-NEXT:       0000: 37306235 31663533 34643830 36333964  |70b51f534d80639d|
+; OBJ64-NEXT:       0010: 30333361 65393263 36613835 36616636  |033ae92c6a856af6|
+; OBJ64-NEXT:     )
+; OBJ64-NEXT:   }
+; OBJ64-NEXT:   FileChecksum {
+; OBJ64-NEXT:     Filename: D:\two.c (0x15)
+; OBJ64-NEXT:     ChecksumSize: 0x20
+; OBJ64-NEXT:     ChecksumKind: MD5 (0x1)
+; OBJ64-NEXT:     ChecksumBytes (
+; OBJ64-NEXT:       0000: 37306235 31663533 34643830 36333964  |70b51f534d80639d|
+; OBJ64-NEXT:       0010: 30333361 65393263 36613835 36616636  |033ae92c6a856af6|
+; OBJ64-NEXT:     )
+; OBJ64-NEXT:   }
+; OBJ64-NEXT:  ]
 ; OBJ64:      FunctionLineTable [
 ; OBJ64-NEXT:   Name: f
 ; OBJ64-NEXT:   Flags: 0x0
 ; OBJ64-NEXT:   CodeSize: 0x18
 ; OBJ64-NEXT:   FilenameSegment [
 ; OBJ64-NEXT:     Filename: D:\input.c
 ; OBJ64-NEXT:     +0x0 [
 ; OBJ64-NEXT:       LineNumberStart: 3

 attributes #0 = { nounwind "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "no-realign-stack" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
 attributes #1 = { "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "no-realign-stack" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
 
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!9, !10}
 !llvm.ident = !{!11}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C99, producer: "clang version 3.5 ", isOptimized: false, emissionKind: FullDebug, file: !1, enums: !2, retainedTypes: !2, globals: !2, imports: !2)
-!1 = !DIFile(filename: "<unknown>", directory: "D:\5C")
+!1 = !DIFile(filename: "<unknown>", directory: "D:\5C", checksumkind: CSK_MD5, checksum:"70b51f534d80639d033ae92c6a856af6")
 !2 = !{}
 !4 = distinct !DISubprogram(name: "f", line: 3, isLocal: false, isDefinition: true, virtualIndex: 6, flags: DIFlagPrototyped, isOptimized: false, unit: !0, scopeLine: 3, file: !5, scope: !6, type: !7, variables: !2)
-!5 = !DIFile(filename: "input.c", directory: "D:\5C")
-!6 = !DIFile(filename: "input.c", directory: "D:C")
+!5 = !DIFile(filename: "input.c", directory: "D:\5C", checksumkind: CSK_MD5, checksum:"70b51f534d80639d033ae92c6a856af6")
+!6 = !DIFile(filename: "input.c", directory: "D:C", checksumkind: CSK_MD5, checksum:"70b51f534d80639d033ae92c6a856af6")
 !7 = !DISubroutineType(types: !8)
 !8 = !{null}
 !9 = !{i32 2, !"CodeView", i32 1}
 !10 = !{i32 1, !"Debug Info Version", i32 3}
 !11 = !{!"clang version 3.5 "}
 !12 = !DILocation(line: 1, scope: !13)
 !13 = !DILexicalBlockFile(discriminator: 0, file: !14, scope: !4)
-!14 = !DIFile(filename: "one.c", directory: "D:\5C")
+!14 = !DIFile(filename: "one.c", directory: "D:\5C", checksumkind: CSK_MD5, checksum:"70b51f534d80639d033ae92c6a856af6")
 !15 = !DILocation(line: 2, scope: !16)
 !16 = !DILexicalBlockFile(discriminator: 0, file: !17, scope: !4)
-!17 = !DIFile(filename: "two.c", directory: "D:\5C")
+!17 = !DIFile(filename: "two.c", directory: "D:\5C", checksumkind: CSK_MD5, checksum:"70b51f534d80639d033ae92c6a856af6")
 !18 = !DILocation(line: 7, scope: !13)
 !19 = !DILocation(line: 8, scope: !13)

llvm/test/DebugInfo/COFF/simple.ll

 ; 1 void g(void);
 ; 2
 ; 3 void f(void) {
 ; 4   g();
 ; 5 }
 
 ; X86-LABEL: _f:
 ; X86:      # BB
-; X86:      .cv_file 1 "D:\\test.c"
+; X86:      .cv_file 1 "D:\\test.c" "f310ab26998ca831cbdf169e4eecacfa" 1
 ; X86:      .cv_loc 0 1 4 2 is_stmt 0 # test.c:4:2
 ; X86:      calll   _g
 ; X86:      .cv_loc 0 1 5 0 # test.c:5:0
 ; X86:      ret
 ; X86:      [[END_OF_F:Lfunc_end.*]]:
 ;
 ; X86-LABEL: .section        .debug$S,"dr"
 ; X86-NEXT: .p2align 2

 ; X86-NEXT: .short  2
 ; X86-NEXT: .short  4431
 ; X86-NEXT: [[F1_END]]:
 ; X86-NEXT: .p2align 2
 ; Line table
 ; X86-NEXT: .cv_linetable 0, _f, [[END_OF_F]]
 ; File index to string table offset subsection
 ; X86-NEXT: .cv_filechecksums
+; X86-NEXT: .cv_filechecksumoffset file1 0
 ; String table
 ; X86-NEXT: .cv_stringtable
 
 ; OBJ32:    Section {
 ; OBJ32:      Name: .debug$S (2E 64 65 62 75 67 24 53)
 ; OBJ32:      Characteristics [ (0x42300040)
 ; OBJ32:      ]
 ; OBJ32:      Relocations [
 ; OBJ32-NEXT:   0x64 IMAGE_REL_I386_SECREL _f
 ; OBJ32-NEXT:   0x68 IMAGE_REL_I386_SECTION _f
 ; OBJ32-NEXT:   0x7C IMAGE_REL_I386_SECREL _f
 ; OBJ32-NEXT:   0x80 IMAGE_REL_I386_SECTION _f
 ; OBJ32-NEXT: ]
 ; OBJ32:      Subsection [
 ; OBJ32-NEXT:   SubSectionType: Symbols (0xF1)
 ; OBJ32:        {{.*}}Proc{{.*}}Sym {
 ; OBJ32:          CodeSize: 0x6
 ; OBJ32:          DisplayName: f
 ; OBJ32:          LinkageName: _f
 ; OBJ32:        }
 ; OBJ32-NEXT:   ProcEnd {
 ; OBJ32:        }
 ; OBJ32-NEXT: ]
+; OBJ32:       Subsection [
+; OBJ32:         SubSectionType: FileChecksums (0xF4)
+; OBJ32-NEXT:    SubSectionSize: 0x28
+; OBJ32-NEXT:    FileChecksum {
+; OBJ32-NEXT:      Filename: D:\test.c (0x1)
+; OBJ32-NEXT:      ChecksumSize: 0x20
+; OBJ32-NEXT:      ChecksumKind: MD5 (0x1)
+; OBJ32-NEXT:      ChecksumBytes (
+; OBJ32-NEXT:        0000: 66333130 61623236 39393863 61383331  |f310ab26998ca831|
+; OBJ32-NEXT:        0010: 63626466 31363965 34656563 61636661  |cbdf169e4eecacfa|
+; OBJ32-NEXT:      )
+; OBJ32-NEXT:    }
+; OBJ32-NEXT:  ]
 ; OBJ32:      FunctionLineTable [
 ; OBJ32-NEXT:   Name: _f
 ; OBJ32-NEXT:   Flags: 0x1
 ; OBJ32-NEXT:   CodeSize: 0x6
 ; OBJ32-NEXT:   FilenameSegment [
 ; OBJ32-NEXT:     Filename: D:\test.c
 ; OBJ32-NEXT:     +0x0 [
 ; OBJ32-NEXT:       LineNumberStart: 4

 ; OBJ32-NEXT:       ColStart: 0
 ; OBJ32-NEXT:       ColEnd: 0
 ; OBJ32-NEXT:     ]
 ; OBJ32-NEXT:   ]
 ; OBJ32-NEXT: ]
 
 ; X64-LABEL: f:
 ; X64-NEXT: .L{{.*}}:{{$}}
-; X64:      .cv_file 1 "D:\\test.c"
+; X64:      .cv_file 1 "D:\\test.c" "f310ab26998ca831cbdf169e4eecacfa" 1
 ; X64:      .cv_loc 0 1 3 0 is_stmt 0 # test.c:3:0
 ; X64:      # BB
 ; X64:      subq    $40, %rsp
 ; X64:      .cv_loc 0 1 4 2 # test.c:4:2
 ; X64-NEXT: callq   g
 ; X64:      .cv_loc 0 1 5 0 # test.c:5:0
 ; X64:      addq    $40, %rsp
 ; X64-NEXT: ret

 ; X64-NEXT: .short  2
 ; X64-NEXT: .short  4431
 ; X64-NEXT: [[F1_END]]:
 ; X64-NEXT: .p2align   2
 ; Line table
 ; X64-NEXT: .cv_linetable 0, f, [[END_OF_F]]
 ; File index to string table offset subsection
 ; X64-NEXT: .cv_filechecksums
+; X64-NEXT: .cv_filechecksumoffset file1 0
 ; String table
 ; X64-NEXT: .cv_stringtable
 
 ; OBJ64:    Section {
 ; OBJ64:      Name: .debug$S (2E 64 65 62 75 67 24 53)
 ; OBJ64:      Characteristics [ (0x42300040)
 ; OBJ64:      ]
 ; OBJ64:      Relocations [
 ; OBJ64-NEXT:   0x64 IMAGE_REL_AMD64_SECREL f
 ; OBJ64-NEXT:   0x68 IMAGE_REL_AMD64_SECTION f
 ; OBJ64-NEXT:   0x7C IMAGE_REL_AMD64_SECREL f
 ; OBJ64-NEXT:   0x80 IMAGE_REL_AMD64_SECTION f
 ; OBJ64-NEXT: ]
 ; OBJ64:      Subsection [
 ; OBJ64-NEXT:   SubSectionType: Symbols (0xF1)
 ; OBJ64:        {{.*}}Proc{{.*}}Sym {
 ; OBJ64:          CodeSize: 0xE
 ; OBJ64:          DisplayName: f
 ; OBJ64:          LinkageName: f
 ; OBJ64:        }
 ; OBJ64-NEXT:   ProcEnd {
 ; OBJ64:        }
 ; OBJ64-NEXT: ]
+; OBJ64:       Subsection [
+; OBJ64:         SubSectionType: FileChecksums (0xF4)
+; OBJ64-NEXT:    SubSectionSize: 0x28
+; OBJ64-NEXT:    FileChecksum {
+; OBJ64-NEXT:      Filename: D:\test.c (0x1)
+; OBJ64-NEXT:      ChecksumSize: 0x20
+; OBJ64-NEXT:      ChecksumKind: MD5 (0x1)
+; OBJ64-NEXT:      ChecksumBytes (
+; OBJ64-NEXT:        0000: 66333130 61623236 39393863 61383331  |f310ab26998ca831|
+; OBJ64-NEXT:        0010: 63626466 31363965 34656563 61636661  |cbdf169e4eecacfa|
+; OBJ64-NEXT:      )
+; OBJ64-NEXT:    }
+; OBJ64-NEXT:  ]
 ; OBJ64:      FunctionLineTable [
 ; OBJ64-NEXT:   Name: f
 ; OBJ64-NEXT:   Flags: 0x1
 ; OBJ64-NEXT:   CodeSize: 0xE
 ; OBJ64-NEXT:   FilenameSegment [
 ; OBJ64-NEXT:     Filename: D:\test.c
 ; OBJ64-NEXT:     +0x0 [
 ; OBJ64-NEXT:       LineNumberStart: 3

 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!9, !10}
 !llvm.ident = !{!11}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C99, producer: "clang version 3.5 ", isOptimized: false, emissionKind: FullDebug, file: !1, enums: !2, retainedTypes: !2, globals: !2, imports: !2)
 !1 = !DIFile(filename: "<unknown>", directory: "D:\5C")
 !2 = !{}
 !4 = distinct !DISubprogram(name: "f", line: 3, isLocal: false, isDefinition: true, virtualIndex: 6, flags: DIFlagPrototyped, isOptimized: false, unit: !0, scopeLine: 3, file: !5, scope: !6, type: !7, variables: !2)
-!5 = !DIFile(filename: "test.c", directory: "D:\5C")
-!6 = !DIFile(filename: "test.c", directory: "D:C")
+!5 = !DIFile(filename: "test.c", directory: "D:\5C", checksumkind: CSK_MD5, checksum: "f310ab26998ca831cbdf169e4eecacfa")
+!6 = !DIFile(filename: "test.c", directory: "D:C", checksumkind: CSK_MD5, checksum: "f310ab26998ca831cbdf169e4eecacfa")
 !7 = !DISubroutineType(types: !8)
 !8 = !{null}
 !9 = !{i32 2, !"CodeView", i32 1}
 !10 = !{i32 1, !"Debug Info Version", i32 3}
 !11 = !{!"clang version 3.5 "}
 !12 = !DILocation(line: 4, column: 2, scope: !4)
 !13 = !DILocation(line: 5, scope: !4)

llvm/test/MC/AArch64/coff-debug.ll

 ; CHECK:   Subsection [
 ; CHECK:     SubSectionType: Lines (0xF2)
 ; CHECK:     LinkageName: main
 ; CHECK:   ]
 ; CHECK:   Subsection [
 ; CHECK:     SubSectionType: FileChecksums (0xF4)
 ; CHECK:     FileChecksum {
 ; CHECK:       ChecksumSize: 0x0
-; CHECK:       ChecksumKind: None (0x0)
+; CHECK:       ChecksumKind: MD5 (0x1)
 ; CHECK:       ChecksumBytes: ()
 ; CHECK:     }
 ; CHECK:   ]
 ; CHECK:   Subsection [
 ; CHECK:     SubSectionType: StringTable (0xF3)
 ; CHECK:   ]
 ; CHECK:   FunctionLineTable [
 ; CHECK:     LinkageName: main

llvm/test/MC/COFF/cv-loc.s

.Lfunc_begin0:
   # #include "t.h" end
   .cv_loc 0 1 6 2
   incl (%rdi)
   retq
 .Lfunc_end0:
 
 .section .debug$S
 .cv_filechecksums
+.cv_filechecksumoffset file1 0
+.cv_filechecksumoffset file2 8
 .cv_linetable 0, f, .Lfunc_end0
 
 # CHECK: FunctionLineTable [
 # CHECK:   LinkageName: f
 # CHECK:   Flags: 0x1
 # CHECK:   CodeSize: 0x9
 # CHECK:   FilenameSegment [
 # CHECK:     Filename: a.c (0x0)

llvm/tools/llvm-readobj/COFFDumper.cpp

void COFFDumper::printCodeViewSymbolSection(StringRef SectionName,
   W.printNumber("Section", SectionName, Obj->getSectionID(Section));
 
   uint32_t Magic;
   error(consume(Data, Magic));
   W.printHex("Magic", Magic);
   if (Magic != COFF::DEBUG_SECTION_MAGIC)
     return error(object_error::parse_failed);
 
+
   BinaryStreamReader FSReader(Data, support::little);
   initializeFileAndStringTables(FSReader);
 
+
   // TODO: Convert this over to using ModuleSubstreamVisitor.
   while (!Data.empty()) {
     // The section consists of a number of subsection in the following format:
     // |SubSectionType|SubSectionSize|Contents...|
     uint32_t SubType, SubSectionSize;
     error(consume(Data, SubType));
     error(consume(Data, SubSectionSize));
 

llvm/unittests/IR/MetadataTest.cpp

TEST_F(DISubroutineTypeTest, get) {
   EXPECT_EQ("", N->getName());
 }
 
 typedef MetadataTest DIFileTest;
 
 TEST_F(DIFileTest, get) {
   StringRef Filename = "file";
   StringRef Directory = "dir";
-  DIFile::ChecksumKind CSKind = DIFile::CSK_MD5;
+  DIFile::ChecksumKind CSKind = DIFile::ChecksumKind::MD5;
   StringRef Checksum = "000102030405060708090a0b0c0d0e0f";
   auto *N = DIFile::get(Context, Filename, Directory, CSKind, Checksum);
 
   EXPECT_EQ(dwarf::DW_TAG_file_type, N->getTag());
   EXPECT_EQ(Filename, N->getFilename());
   EXPECT_EQ(Directory, N->getDirectory());
   EXPECT_EQ(CSKind, N->getChecksumKind());
   EXPECT_EQ(Checksum, N->getChecksum());
   EXPECT_EQ(N, DIFile::get(Context, Filename, Directory, CSKind, Checksum));
 
   EXPECT_NE(N, DIFile::get(Context, "other", Directory, CSKind, Checksum));
   EXPECT_NE(N, DIFile::get(Context, Filename, "other", CSKind, Checksum));
-  EXPECT_NE(N, DIFile::get(Context, Filename, Directory, DIFile::CSK_SHA1, Checksum));
+  EXPECT_NE(N, DIFile::get(Context, Filename, Directory,
+                           DIFile::ChecksumKind::SHA1, Checksum));
   EXPECT_NE(N, DIFile::get(Context, Filename, Directory));
 
   TempDIFile Temp = N->clone();
   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
 }
 
 TEST_F(DIFileTest, ScopeGetFile) {
   // Ensure that DIScope::getFile() returns itself.