Fix Bug 30978 by emitting cv file checksums.

[ecbeckmann]

Summary

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

[ecbeckmann]

Rebase

[ecbeckmann]

tests

[ecbeckmann]

Some more testing changes.

[zturner]

Try to be more careful so as not to submit testing code / comments etc in uploaded patches. Reasons like this are why I prefer using a debugger instead of printf debugging :)

llvm/include/llvm/IR/DebugInfoMetadata.h

476–481

If you're going to make it an enum class, then it doesn't need the CSK prefix in the name, since you have to write ChecksumKind anyway. I wouldn't suggest churning the code to change the names everywhere it's used, so instead maybe just leave this as a regular enum. It's already scoped to DIFile anyway, so there's no risk of namespace pollution.

llvm/include/llvm/MC/MCCodeView.h

300–315

Any reason this isn't just:

struct FileInfo {
  StringRef Name;
  StringRef Checksum;
  ChecksumKind Kind;
};

SmallVector<FileInfo> Files;

having a StringMap seems unnecessary if we're already iterating a linear container anyway

llvm/lib/DebugInfo/CodeView/DebugChecksumsSubsection.cpp

53 ↗

(On Diff #114116)

Delete

llvm/lib/DebugInfo/CodeView/DebugStringTableSubsection.cpp

32 ↗

(On Diff #114116)

Delete

38 ↗

(On Diff #114116)

Delete

44 ↗

(On Diff #114116)

Delete

llvm/lib/MC/MCCodeView.cpp

194–206

What is this? A bunch of code commented out, and then emitting a bunch of magic numbers?

llvm/tools/llvm-readobj/COFFDumper.cpp

927 ↗

(On Diff #114116)

Delete

929 ↗

(On Diff #114116)

Delete

1088 ↗

(On Diff #114116)

Delete

1090 ↗

(On Diff #114116)

Delete

[rnk]

llvm/lib/MC/MCCodeView.cpp

462–466

We shouldn't assume all DIFiles have MD5 checksums, we'll need some way to know the filechecksum table offset.

We should probably implement this FIXME:

// FIXME: We should store the string table offset of the filename, rather than
// the filename itself for efficiency.
Filename = addToStringTable(Filename);
Filenames[Idx] = Filename;

We should do that by making FIlenames a vector of two integers: the offset of the file in the file checksum table, and the offset of the filename in the string table.

All the places where we do 8 * (FileId - 1) we would rewrite to use Filenames[FileId - 1].ChecksumTableOffset.

[ecbeckmann]

Use MCFixup

[ecbeckmann]

Imprved?

[ecbeckmann]

Everything works finally.

[ecbeckmann]

llvm/include/llvm/MC/MCCodeView.h

286

remove

299–300

Just one comment says:

Array storing file information. Each tuple contains the string table offset, a symbol representing the file table offset, and a set flag.

304

remove

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

702–703

remove this comment

704

remove junk here too

llvm/lib/DebugInfo/CodeView/DebugChecksumsSubsection.cpp

53 ↗

(On Diff #114469)

remove

llvm/lib/DebugInfo/CodeView/DebugStringTableSubsection.cpp

32 ↗

(On Diff #114469)

remove

39 ↗

(On Diff #114469)

remove

45 ↗

(On Diff #114469)

remove

[ecbeckmann]

llvm/lib/MC/MCCodeView.cpp

49

remove

62–63

remove comment

138

combine this all into one line

139

Don't reassign to S and just directly use Ret.first

154

add a comment explaining this function

155

remove

161

remove spaces here

167

remove these

173

+=4 for the string table offset

176

+1 for size, +1 for kind, +2 to align (maybe just replace that with alignTo for clarity)

179

remove logging, more comments to explain offset

182

add comment explaining that, since the checksum section has been emitted, we can assume the offsets have been finalized so we can assign them.

192–193

update this comment

195

remove these

205

yes remove this

248

add comment to explain, how it needs to use a MCFixup provided by EmitValueImpl

260

remove

263

create a temporary symbol to hold the offset once it is calculated

270

remove

283

a

420

r

462–463

change this comment

llvm/lib/MC/MCObjectStreamer.cpp

144

r

llvm/lib/MC/MCParser/AsmParser.cpp

3464

should be lower case for consistency

llvm/lib/MC/WinCOFFObjectWriter.cpp

725 ↗

(On Diff #114469)

r

llvm/tools/llvm-readobj/COFFDumper.cpp

910 ↗

(On Diff #114469)

r these

1020 ↗

(On Diff #114469)

r

1106 ↗

(On Diff #114469)

not needed

[ecbeckmann]

Make this entire thing easier to follow and understand.

llvm/lib/MC/MCCodeView.cpp

60

This is confusing to read, make it more intuitive

[ecbeckmann]

Fortunately this seems to work whether generating assembly or object

[ecbeckmann]

Why do we have to add placeholders for the checksum offsets? Aren't they just added in order, one after another?

Actually, the implementation of addFile hasn't assumed it is done in order, and you can actually add random fileNo's whenever you want. Therefore, we shouldn't assume they are always done in order, and we should allow for the case where we don't yet know the checksum offset.

[ecbeckmann]

Add checksum offset directive.

[ecbeckmann]

Restructrue, create real symbol not temp.

[ecbeckmann]

Remove errant errors.

[ecbeckmann]

Format

[ecbeckmann]

llvm/include/llvm/IR/DebugInfoMetadata.h

476–481

Unfortunately I need the actual enum values to correspond exactly to the checksum types flag integer values actually present in the codeview section, hence the strongly typed enum class. This is important because I will now be emitting the ChecksumKind as assembly directives as well as directly into the binary.

llvm/include/llvm/MC/MCCodeView.h

300–315

Yes, combined all this info into one vector. It's still useful to have a StringMap because we want to check if a filename is already used before making a new entry.

[ecbeckmann]

Reformat

[ecbeckmann]

Reformat.

[ecbeckmann]

llvm/lib/MC/MCCodeView.cpp

194–206

It was all debugging code that was unintended for review. Please disregard. Sorry again for not making this patch private to begin with.

462–466

Filenames renamed to Files, which is now a vector of a massive structure containing all offset and checksum information.

[ecbeckmann]

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

686–687

Update this FIXME to say that we do provide checksum file info, and what VS uses this for.

[rnk]

llvm/lib/MC/MCCodeView.cpp

169

I don't think you want to do this, this leaks the internal MCSymbol (file1, etc) to the assembler. Nothing in the assembly defines file1, so the assembly isn't very readable.

llvm/test/DebugInfo/COFF/inlining.ll

52

What I had in mind was that we'd add a directive like .cv_filechecksum_offset <fileid> and MCCodeView.cpp would internally implement it without leaking any labels to the caller. We could use a label difference of two symbols to implement the offset computation, but any symbols shouldn't leak out to the assembler.

[probinson]

llvm/include/llvm/IR/DebugInfoMetadata.h

476–481

If you need the enums to have specific values, e.g. because those values end up in the object file (hard to tell here but I think that's what you are saying), you should set the enum values explicitly. This documents the exact values you need (even if they happen to be sequential at the moment). Making it an enum class doesn't get you that.

llvm/lib/IR/DebugInfoMetadata.cpp

363

If you require exact correspondence between an enum and some array of strings, we usually do that with a .def file and macros. See for example Dwarf.def. As it is, the association between this array and the ChecksumKind values is implied rather than explicit. Safer to be explicit.

[rnk]

llvm/lib/MC/MCCodeView.cpp

68

Use MCContext::createTempSymbol to make sure these don't show up in the .obj symbol table.

[ecbeckmann]

Don't leak symbol into assembler, remove enum class, use createTempSymbol.

[ecbeckmann]

llvm/include/llvm/IR/DebugInfoMetadata.h

476–481

Remove enum class to explicitly define values.

llvm/lib/IR/DebugInfoMetadata.cpp

363

Okay this should probably be addressed in another patch as this patch did not introduce the array.

llvm/lib/MC/MCCodeView.cpp

169

Instead of emitting the symbol, we will emit the .cv_filechecksumoffset <fileno> directive.

[ecbeckmann]

Some formatting fixes.

[ecbeckmann]

Removed some last unnecessary changes.

[probinson]

A few minor commentary points; nothing huge. I've been looking at this mainly with the thought of having to do something similar for DWARF 5 eventually, but it seems likely there won't be a lot to leverage as CodeView and DWARF appear to associate the hashes with files pretty differently. Oh well.

llvm/include/llvm/IR/DebugInfoMetadata.h

476–481

And maybe a comment that these end up in the object file, so some well-meaning person doesn't come a long later and remove the "unnecessary" explicit values.

llvm/include/llvm/MC/MCStreamer.h

732

As long as you're changing the comment anyway, please remove the \brief.

778

Remove \brief.

[ecbeckmann]

llvm/test/DebugInfo/COFF/inlining.ll

52

implemented as such

[rnk]

Thanks, looks good!

llvm/include/llvm/MC/MCCodeView.h

302–303

Generally, if the comment describing the variable doesn't fit on one line, consider moving it before the variable. Then we won't end up with this awkard split after the *.

[ecbeckmann]

Changed some comments.

[ecbeckmann]

Updated comment formatting.

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_None = 0,
+    CSK_MD5 = 1,
+    CSK_SHA1 = 2,
     CSK_Last = CSK_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),
         CSKind(CSK) {}
return getTemporary(getContext(), getFilename(), getDirectory(),
                         getChecksumKind(), getChecksum());
   }
 
 public:
   DEFINE_MDNODE_GET(DIFile, (StringRef Filename, StringRef Directory,
                              ChecksumKind CSK = CSK_None,
                              StringRef CS = StringRef()),
                     (Filename, Directory, CSK, CS))
-  DEFINE_MDNODE_GET(DIFile, (MDString *Filename, MDString *Directory,
+  DEFINE_MDNODE_GET(DIFile, (MDString * Filename, MDString *Directory,
                              ChecksumKind CSK = CSK_None,
                              MDString *CS = nullptr),
                     (Filename, Directory, CSK, CS))
 
   TempDIFile clone() const { return cloneImpl(); }
 
   StringRef getFilename() const { return getStringOperand(0); }
   StringRef getDirectory() const { return getStringOperand(1); }

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(MCObjectStreamer &OS, unsigned FileNo);
+
 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; // Stored as 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.
+  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(unsigned FileNo) 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
-  /// implements the '.cv_file 4 "foo.c"' assembler directive. Returns true on
-  /// success.
-  virtual bool EmitCVFileDirective(unsigned FileNo, StringRef Filename);
+  /// \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,
+                                   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() {}
 
+  /// \brief This implements the CodeView '.cv_filechecksumoffset' assembler
+  /// directive.
+  virtual void EmitCVFileChecksumOffsetDirective(unsigned FileNo) {}
+
   /// 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/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,

 }
 
 void CodeViewDebug::emitInlineeLinesSubsection() {
   if (InlinedSubprograms.empty())
     return;
 
   OS.AddComment("Inlinee lines subsection");
   MCSymbol *InlineEnd = beginCVSubsection(DebugSubsectionKind::InlineeLines);
 
-  // We don't provide any extra file info.
-  // FIXME: Find out if debuggers use this info.
+  // We emit the checksum info for files.  This is used by debuggers to
+  // determine if a pdb matches the source before loading it.  Visual Studio,
+  // for instance, will display a warning that the breakpoints are not valid if
+  // the pdb does not match the source.
   OS.AddComment("Inlinee lines signature");
   OS.EmitIntValue(unsigned(InlineeLinesSignature::Normal), 4);
 
   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.EmitCVFileChecksumOffsetDirective(FileId);
     OS.AddComment("Starting line number");
     OS.EmitIntValue(SP->getLine(), 4);
   }
 
   endCVSubsection(InlineEnd);
 }
 
 void CodeViewDebug::emitInlinedCallSite(const FunctionInfo &FI,

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);
 }
 
+// FIXME: Implement this string-enum correspondence with a .def file and macros,
+// so that the association is explicit rather than implied.
 static const char *ChecksumKindName[DIFile::CSK_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);
 }
 

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(unsigned FileNo) 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(unsigned FileNo) {
+  OS << "\t.cv_filechecksumoffset\t" << FileNo;
+  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().createTempSymbol("checksum_offset", false);
+  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;
 }
 
 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);
 
   // Put the string table data fragment here, if we haven't already put it
   // somewhere else. If somebody wants two string tables in their .s file, one
   // will just be empty.
   if (!InsertedStrTabFragment) {
     OS.insert(getStringTableFragment());
     InsertedStrTabFragment = true;
   }
 
   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);
 
+  unsigned CurrentOffset = 0;
+
   // 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.EmitAssignment(File.ChecksumTableOffset,
+                      MCConstantExpr::create(CurrentOffset, Ctx));
+    CurrentOffset += 4; // String table offset.
+    if (!File.ChecksumKind) {
+      CurrentOffset +=
+          4; // One byte each for checksum size and kind, then align to 4 bytes.
+    } else {
+      CurrentOffset += 2; // One byte each for checksum size and kind.
+      CurrentOffset += File.Checksum.size();
+      CurrentOffset = alignTo(CurrentOffset, 4);
+    }
+
+    OS.EmitIntValue(File.StringTableOffset, 4);
+
+    if (!File.ChecksumKind) {
+      // There is no checksum.  Therefore zero the next two fields and align
+      // back to 4 bytes.
       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);
+
+  ChecksumOffsetsAssigned = true;
+}
+
+// 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(MCObjectStreamer &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);
 
   OS.EmitIntValue(unsigned(DebugSubsectionKind::Lines), 4);
   OS.emitAbsoluteSymbolDiff(LineEnd, LineBegin, 4);
   OS.EmitLabel(LineBegin);
   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(LF_HaveColumns) : 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;
         });
     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.EmitCVFileChecksumOffsetDirective(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)
       break;
 
for (const MCCVLineEntry &Loc : Locs) {
     // source location update. The current table format does not support column
     // 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

if (Value->evaluateAsAbsolute(AbsValue, getAssembler())) {
     if (!isUIntN(8 * Size, AbsValue) && !isIntN(8 * Size, AbsValue)) {
       getContext().reportError(
           Loc, "value evaluated as " + Twine(AbsValue) + " is out of range.");
       return;
     }
     EmitIntValue(AbsValue, Size);
     return;
   }
   DF->getFixups().push_back(
       MCFixup::create(DF->getContents().size(), Value,
                       MCFixup::getKindForSize(Size, false), Loc));
   DF->getContents().resize(DF->getContents().size() + Size, 0);
 }
 
 void MCObjectStreamer::EmitCFIStartProcImpl(MCDwarfFrameInfo &Frame) {
   // We need to create a local symbol to avoid relocations.
   Frame.Begin = getContext().createTempSymbol();

 
 void MCObjectStreamer::EmitCVStringTableDirective() {
   getContext().getCVContext().emitStringTable(*this);
 }
 void MCObjectStreamer::EmitCVFileChecksumsDirective() {
   getContext().getCVContext().emitFileChecksums(*this);
 }
 
+void MCObjectStreamer::EmitCVFileChecksumOffsetDirective(unsigned FileNo) {
+  getContext().getCVContext().emitFileChecksumOffset(*this, FileNo);
+}
 
 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 fileno
+bool AsmParser::parseDirectiveCVFileChecksumOffset() {
+  int64_t FileNo;
+  if (parseIntToken(FileNo, "expected identifier in directive"))
+    return true;
+  if (parseToken(AsmToken::EndOfStatement, "Expected End of Statement"))
+    return true;
+  getStreamer().EmitCVFileChecksumOffsetDirective(FileNo);
+  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,

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: .cv_filechecksumoffset 1        # 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: .cv_filechecksumoffset 1        # Offset into filechecksum table
 ; 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: .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.*]]:
 

 ; 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

 ; 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

 ; 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/unittests/IR/MetadataTest.cpp

TEST_F(DIFileTest, get) {
   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::CSK_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.