[DWARFv5] MC support for MD5 checksum

[probinson]

Summary

Extend .file directive syntax to allow specifying an MD5 checksum for
the source file. Emit the checksums into DWARF v5 line tables.

We'll pass checksums from IR to AsmPrinter in a follow-up, and
after that get Clang to provide them in IR.

[aprantl]

Thanks, looks mostly good.

llvm/include/llvm/MC/MCDwarf.h

56

Optional<MD5::MD5Result>?

llvm/lib/MC/MCParser/AsmParser.cpp

3361

I think I would feel more comfortable with a report_fatal_error on invalid inputs.

llvm/test/MC/ELF/debug-md5.s

5

Just out of curiosity: why did you opt for a string literal instead of a hex numeral? Is there some precedent for that?

[probinson]

llvm/include/llvm/MC/MCDwarf.h

56

This is a non-owning pointer to data allocated in MCContext. Does that change your opinion? (Or Blaikie's?)

llvm/lib/MC/MCParser/AsmParser.cpp

3361

Potentially being user input, this ought to be using the check() mechanism instead of an assertion. Sorry about the brain-lapse here.

llvm/test/MC/ELF/debug-md5.s

5

I believe .cv_file does it that way (the CodeView version of .file). IIRC the integer-parsing functions don't have a way to return a 128-bit result. Handled as a string, I can parse it directly into the allocated MD5Result.

[probinson]

Address review feedback.

[probinson]

Committed in rL322134. (Forgot to put the Differential Revision tag in the commit message.)

llvm/include/llvm/MC/MCContext.h

 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/MC/MCDwarf.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/SectionKind.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/Compiler.h"
+#include "llvm/Support/MD5.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <map>
 #include <memory>
 #include <string>
public:
     /// after preprocessing or for -save-temps.
     const std::string &getMainFileName() const { return MainFileName; }
 
     /// \brief Set the main file name and override the default.
     void setMainFileName(StringRef S) { MainFileName = S; }
 
     /// Creates an entry in the dwarf file and directory tables.
     unsigned getDwarfFile(StringRef Directory, StringRef FileName,
-                          unsigned FileNumber, unsigned CUID);
+                          unsigned FileNumber, MD5::MD5Result *Checksum,
+                          unsigned CUID);
 
     bool isValidDwarfFileNumber(unsigned FileNumber, unsigned CUID = 0);
 
     const std::map<unsigned, MCDwarfLineTable> &getMCDwarfLineTables() const {
       return MCDwarfLineTablesCUMap;
     }
 
     MCDwarfLineTable &getMCDwarfLineTable(unsigned CUID) {

llvm/include/llvm/MC/MCDwarf.h

 #ifndef LLVM_MC_MCDWARF_H
 #define LLVM_MC_MCDWARF_H
 
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/MC/MCSection.h"
+#include "llvm/Support/MD5.h"
 #include <cassert>
 #include <cstdint>
 #include <string>
 #include <utility>
 #include <vector>
 
 namespace llvm {
 

 /// index 0 is not used and not a valid dwarf file number).
 struct MCDwarfFile {
   // \brief The base name of the file without its directory path.
   // The StringRef references memory allocated in the MCContext.
   std::string Name;
 
   // \brief The index into the list of directory names for this file name.
   unsigned DirIndex;
+
+  /// The MD5 checksum, if there is one. Non-owning pointer to data allocated
+  /// in MCContext.
+  MD5::MD5Result *Checksum = nullptr;
 };
 
 /// \brief Instances of this class represent the information from a
 /// dwarf .loc directive.
 class MCDwarfLoc {
   uint32_t FileNum;
   uint32_t Line;
   uint16_t Column;

 };
 
 struct MCDwarfLineTableHeader {
   MCSymbol *Label = nullptr;
   SmallVector<std::string, 3> MCDwarfDirs;
   SmallVector<MCDwarfFile, 3> MCDwarfFiles;
   StringMap<unsigned> SourceIdMap;
   StringRef CompilationDir;
+  bool HasMD5 = false;
 
   MCDwarfLineTableHeader() = default;
 
   unsigned getFile(StringRef &Directory, StringRef &FileName,
-                   unsigned FileNumber = 0);
+                   MD5::MD5Result *Checksum, unsigned FileNumber = 0);
   std::pair<MCSymbol *, MCSymbol *> Emit(MCStreamer *MCOS,
                                          MCDwarfLineTableParams Params) const;
   std::pair<MCSymbol *, MCSymbol *>
   Emit(MCStreamer *MCOS, MCDwarfLineTableParams Params,
        ArrayRef<char> SpecialOpcodeLengths) const;
 };
 
 class MCDwarfDwoLineTable {
   MCDwarfLineTableHeader Header;
 
 public:
   void setCompilationDir(StringRef CompilationDir) {
     Header.CompilationDir = CompilationDir;
   }
 
-  unsigned getFile(StringRef Directory, StringRef FileName) {
-    return Header.getFile(Directory, FileName);
+  unsigned getFile(StringRef Directory, StringRef FileName,
+                   MD5::MD5Result *Checksum) {
+    return Header.getFile(Directory, FileName, Checksum);
   }
 
   void Emit(MCStreamer &MCOS, MCDwarfLineTableParams Params) const;
 };
 
 class MCDwarfLineTable {
   MCDwarfLineTableHeader Header;
   MCLineSection MCLineSections;
 
 public:
   // This emits the Dwarf file and the line tables for all Compile Units.
   static void Emit(MCObjectStreamer *MCOS, MCDwarfLineTableParams Params);
 
   // This emits the Dwarf file and the line tables for a given Compile Unit.
   void EmitCU(MCObjectStreamer *MCOS, MCDwarfLineTableParams Params) const;
 
   unsigned getFile(StringRef &Directory, StringRef &FileName,
-                   unsigned FileNumber = 0);
+                   MD5::MD5Result *Checksum, unsigned FileNumber = 0);
 
   MCSymbol *getLabel() const {
     return Header.Label;
   }
 
   void setLabel(MCSymbol *Label) {
     Header.Label = Label;
   }

llvm/include/llvm/MC/MCStreamer.h

 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/MC/MCDirectives.h"
 #include "llvm/MC/MCDwarf.h"
 #include "llvm/MC/MCLinkerOptimizationHint.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/MCWinEH.h"
+#include "llvm/Support/MD5.h"
 #include "llvm/Support/SMLoc.h"
 #include "llvm/Support/TargetParser.h"
 #include <cassert>
 #include <cstdint>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
public:
   /// \brief Emit the "identifiers" directive.  This implements the
   /// '.ident "version foo"' assembler directive.
   virtual void EmitIdent(StringRef IdentString) {}
 
   /// \brief Associate a filename with a specified logical file number.  This
   /// implements the DWARF2 '.file 4 "foo.c"' assembler directive.
   virtual unsigned EmitDwarfFileDirective(unsigned FileNo, StringRef Directory,
                                           StringRef Filename,
+                                          MD5::MD5Result *Checksum = nullptr,
                                           unsigned CUID = 0);
 
   /// \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);

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h

public:
 
   /// addLocalLabelAddress - Add a dwarf label attribute data and value using
   /// DW_FORM_addr only.
   void addLocalLabelAddress(DIE &Die, dwarf::Attribute Attribute,
                             const MCSymbol *Label);
 
   DwarfCompileUnit &getCU() override { return *this; }
 
-  unsigned getOrCreateSourceID(StringRef FileName, StringRef DirName) override;
+  unsigned getOrCreateSourceID(StringRef FileName, StringRef DirName,
+                               MD5::MD5Result *Checksum) override;
 
   void addImportedEntity(const DIImportedEntity* IE) {
     DIScope *Scope = IE->getScope();
     assert(Scope && "Invalid Scope encoding!");
     if (!isa<DILocalScope>(Scope))
       // No need to add imported enities that are not local declaration.
       return;
 

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

if (Label)
     Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_addr,
                  DIELabel(Label));
   else
     Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_addr,
                  DIEInteger(0));
 }
 
 unsigned DwarfCompileUnit::getOrCreateSourceID(StringRef FileName,
-                                               StringRef DirName) {
+                                               StringRef DirName,
+                                               MD5::MD5Result *Checksum) {
   // If we print assembly, we can't separate .file entries according to
   // compile units. Thus all files will belong to the default compile unit.
 
   // FIXME: add a better feature test than hasRawTextSupport. Even better,
   // extend .file to support this.
   return Asm->OutStreamer->EmitDwarfFileDirective(
-      0, DirName, FileName,
+      0, DirName, FileName, Checksum,
       Asm->OutStreamer->hasRawTextSupport() ? 0 : getUniqueID());
 }
 
 DIE *DwarfCompileUnit::getOrCreateGlobalVariableDIE(
     const DIGlobalVariable *GV, ArrayRef<GlobalExpr> GlobalExprs) {
   // Check for pre-existence.
   if (DIE *Die = getDIE(GV))
     return Die;
DIE *DwarfCompileUnit::constructInlinedScopeDIE(LexicalScope *Scope) {
   auto ScopeDIE = DIE::get(DIEValueAllocator, dwarf::DW_TAG_inlined_subroutine);
   addDIEEntry(*ScopeDIE, dwarf::DW_AT_abstract_origin, *OriginDIE);
 
   attachRangesOrLowHighPC(*ScopeDIE, Scope->getRanges());
 
   // Add the call site information to the DIE.
   const DILocation *IA = Scope->getInlinedAt();
   addUInt(*ScopeDIE, dwarf::DW_AT_call_file, None,
-          getOrCreateSourceID(IA->getFilename(), IA->getDirectory()));
+          getOrCreateSourceID(IA->getFilename(), IA->getDirectory(), nullptr));
   addUInt(*ScopeDIE, dwarf::DW_AT_call_line, None, IA->getLine());
   if (IA->getDiscriminator() && DD->getDwarfVersion() >= 4)
     addUInt(*ScopeDIE, dwarf::DW_AT_GNU_discriminator, None,
             IA->getDiscriminator());
 
   // Add name to the name table, we do this here because we're guaranteed
   // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
   DD->addSubprogramNames(InlinedSP, *ScopeDIE);

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

if (auto *Scope = cast_or_null<DIScope>(S)) {
     Fn = Scope->getFilename();
     Dir = Scope->getDirectory();
     if (Line != 0 && getDwarfVersion() >= 4)
       if (auto *LBF = dyn_cast<DILexicalBlockFile>(Scope))
         Discriminator = LBF->getDiscriminator();
 
     unsigned CUID = Asm->OutStreamer->getContext().getDwarfCompileUnitID();
     Src = static_cast<DwarfCompileUnit &>(*InfoHolder.getUnits()[CUID])
-              .getOrCreateSourceID(Fn, Dir);
+              .getOrCreateSourceID(Fn, Dir, nullptr);
   }
   Asm->OutStreamer->EmitDwarfLocDirective(Src, Line, Col, Flags, 0,
                                           Discriminator, Fn);
 }
 
 //===----------------------------------------------------------------------===//
 // Emit Methods
 //===----------------------------------------------------------------------===//

 }
 
 void DwarfDebug::emitMacroFile(DIMacroFile &F, DwarfCompileUnit &U) {
   assert(F.getMacinfoType() == dwarf::DW_MACINFO_start_file);
   Asm->EmitULEB128(dwarf::DW_MACINFO_start_file);
   Asm->EmitULEB128(F.getLine());
   DIFile *File = F.getFile();
   unsigned FID =
-      U.getOrCreateSourceID(File->getFilename(), File->getDirectory());
+      U.getOrCreateSourceID(File->getFilename(), File->getDirectory(),
+                            nullptr); // FIXME: MD5?
   Asm->EmitULEB128(FID);
   handleMacroNodes(F.getElements(), U);
   Asm->EmitULEB128(dwarf::DW_MACINFO_end_file);
 }
 
 /// Emit macros into a debug macinfo section.
 void DwarfDebug::emitDebugMacinfo() {
   if (CUMap.empty())

llvm/lib/CodeGen/AsmPrinter/DwarfUnit.h

 protected:
   ~DwarfUnit();
 
   /// Create new static data member DIE.
   DIE *getOrCreateStaticMemberDIE(const DIDerivedType *DT);
 
   /// Look up the source ID with the given directory and source file names. If
   /// none currently exists, create a new ID and insert it in the line table.
-  virtual unsigned getOrCreateSourceID(StringRef File, StringRef Directory) = 0;
+  virtual unsigned getOrCreateSourceID(StringRef File, StringRef Directory,
+                                       MD5::MD5Result *Checksum) = 0;
 
   /// Look in the DwarfDebug map for the MDNode that corresponds to the
   /// reference.
   template <typename T> T *resolve(TypedDINodeRef<T> Ref) const {
     return Ref.resolve();
   }
 
   /// If this is a named finished type then include it in the list of types for

 };
 
 class DwarfTypeUnit final : public DwarfUnit {
   uint64_t TypeSignature;
   const DIE *Ty;
   DwarfCompileUnit &CU;
   MCDwarfDwoLineTable *SplitLineTable;
 
-  unsigned getOrCreateSourceID(StringRef File, StringRef Directory) override;
+  unsigned getOrCreateSourceID(StringRef File, StringRef Directory,
+                               MD5::MD5Result *Checksum) override;
   bool isDwoUnit() const override;
 
 public:
   DwarfTypeUnit(DwarfCompileUnit &CU, AsmPrinter *A, DwarfDebug *DW,
                 DwarfFile *DWU, MCDwarfDwoLineTable *SplitLineTable = nullptr);
 
   void setTypeSignature(uint64_t Signature) { TypeSignature = Signature; }
   void setType(const DIE *Ty) { this->Ty = Ty; }

llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp

 void DwarfUnit::addSectionOffset(DIE &Die, dwarf::Attribute Attribute,
                                  uint64_t Integer) {
   if (DD->getDwarfVersion() >= 4)
     addUInt(Die, Attribute, dwarf::DW_FORM_sec_offset, Integer);
   else
     addUInt(Die, Attribute, dwarf::DW_FORM_data4, Integer);
 }
 
-unsigned DwarfTypeUnit::getOrCreateSourceID(StringRef FileName, StringRef DirName) {
-  return SplitLineTable ? SplitLineTable->getFile(DirName, FileName)
-                        : getCU().getOrCreateSourceID(FileName, DirName);
+unsigned DwarfTypeUnit::getOrCreateSourceID(StringRef FileName,
+                                            StringRef DirName,
+                                            MD5::MD5Result *Checksum) {
+  return SplitLineTable
+             ? SplitLineTable->getFile(DirName, FileName, Checksum)
+             : getCU().getOrCreateSourceID(FileName, DirName, Checksum);
 }
 
 void DwarfUnit::addOpAddress(DIELoc &Die, const MCSymbol *Sym) {
   if (!DD->useSplitDwarf()) {
     addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
     addLabel(Die, dwarf::DW_FORM_udata, Sym);
   } else {
     addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute,
   Die.addValue(DIEValueAllocator, Attribute, Block->BestForm(), Block);
 }
 
 void DwarfUnit::addSourceLine(DIE &Die, unsigned Line, StringRef File,
                               StringRef Directory) {
   if (Line == 0)
     return;
 
-  unsigned FileID = getOrCreateSourceID(File, Directory);
+  unsigned FileID = getOrCreateSourceID(File, Directory, nullptr);
   assert(FileID && "Invalid file id");
   addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
   addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
 }
 
 void DwarfUnit::addSourceLine(DIE &Die, const DILocalVariable *V) {
   assert(V);
 
bool DwarfUnit::applySubprogramDefinitionAttributes(const DISubprogram *SP,
   if (auto *SPDecl = SP->getDeclaration()) {
     DeclDie = getDIE(SPDecl);
     assert(DeclDie && "This DIE should've already been constructed when the "
                       "definition DIE was created in "
                       "getOrCreateSubprogramDIE");
     // Look at the Decl's linkage name only if we emitted it.
     if (DD->useAllLinkageNames())
       DeclLinkageName = SPDecl->getLinkageName();
-    unsigned DeclID =
-        getOrCreateSourceID(SPDecl->getFilename(), SPDecl->getDirectory());
-    unsigned DefID = getOrCreateSourceID(SP->getFilename(), SP->getDirectory());
+    unsigned DeclID = getOrCreateSourceID(SPDecl->getFilename(),
+                                          SPDecl->getDirectory(), nullptr);
+    unsigned DefID =
+        getOrCreateSourceID(SP->getFilename(), SP->getDirectory(), nullptr);
     if (DeclID != DefID)
       addUInt(SPDie, dwarf::DW_AT_decl_file, None, DefID);
 
     if (SP->getLine() != SPDecl->getLine())
       addUInt(SPDie, dwarf::DW_AT_decl_line, None, SP->getLine());
   }
 
   // Add function template parameters.

llvm/lib/MC/MCAsmStreamer.cpp

public:
 
   void emitValueToOffset(const MCExpr *Offset,
                          unsigned char Value,
                          SMLoc Loc) override;
 
   void EmitFileDirective(StringRef Filename) override;
   unsigned EmitDwarfFileDirective(unsigned FileNo, StringRef Directory,
                                   StringRef Filename,
+                                  MD5::MD5Result *Checksum = 0,
                                   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,
void MCAsmStreamer::EmitFileDirective(StringRef Filename) {
   OS << "\t.file\t";
   PrintQuotedString(Filename, OS);
   EmitEOL();
 }
 
 unsigned MCAsmStreamer::EmitDwarfFileDirective(unsigned FileNo,
                                                StringRef Directory,
                                                StringRef Filename,
+                                               MD5::MD5Result *Checksum,
                                                unsigned CUID) {
   assert(CUID == 0);
 
   MCDwarfLineTable &Table = getContext().getMCDwarfLineTable(CUID);
   unsigned NumFiles = Table.getMCDwarfFiles().size();
-  FileNo = Table.getFile(Directory, Filename, FileNo);
+  FileNo = Table.getFile(Directory, Filename, Checksum, FileNo);
   if (FileNo == 0)
     return 0;
   if (NumFiles == Table.getMCDwarfFiles().size())
     return FileNo;
 
   SmallString<128> FullPathName;
 
   if (!UseDwarfDirectory && !Directory.empty()) {

llvm/lib/MC/MCContext.cpp

 // Dwarf Management
 //===----------------------------------------------------------------------===//
 
 /// getDwarfFile - takes a file name an number to place in the dwarf file and
 /// directory tables.  If the file number has already been allocated it is an
 /// error and zero is returned and the client reports the error, else the
 /// allocated file number is returned.  The file numbers may be in any order.
 unsigned MCContext::getDwarfFile(StringRef Directory, StringRef FileName,
-                                 unsigned FileNumber, unsigned CUID) {
+                                 unsigned FileNumber, MD5::MD5Result *Checksum,
+                                 unsigned CUID) {
   MCDwarfLineTable &Table = MCDwarfLineTablesCUMap[CUID];
-  return Table.getFile(Directory, FileName, FileNumber);
+  return Table.getFile(Directory, FileName, Checksum, FileNumber);
 }
 
 /// isValidDwarfFileNumber - takes a dwarf file number and returns true if it
 /// currently is assigned and false otherwise.
 bool MCContext::isValidDwarfFileNumber(unsigned FileNumber, unsigned CUID) {
   const SmallVectorImpl<MCDwarfFile> &MCDwarfFiles = getMCDwarfFiles(CUID);
   if (FileNumber == 0 || FileNumber >= MCDwarfFiles.size())
     return false;

llvm/lib/MC/MCDwarf.cpp

emitV2FileDirTables(MCStreamer *MCOS,
   }
   MCOS->EmitIntValue(0, 1); // Terminate the file list.
 }
 
 static void
 emitV5FileDirTables(MCStreamer *MCOS,
                     const SmallVectorImpl<std::string> &MCDwarfDirs,
                     const SmallVectorImpl<MCDwarfFile> &MCDwarfFiles,
-                    StringRef CompilationDir) {
+                    StringRef CompilationDir, bool HasMD5) {
   // The directory format, which is just inline null-terminated strings.
   MCOS->EmitIntValue(1, 1);
   MCOS->EmitULEB128IntValue(dwarf::DW_LNCT_path);
   MCOS->EmitULEB128IntValue(dwarf::DW_FORM_string);
   // Then the list of directory paths.  CompilationDir comes first.
   MCOS->EmitULEB128IntValue(MCDwarfDirs.size() + 1);
   MCOS->EmitBytes(CompilationDir);
   MCOS->EmitBytes(StringRef("\0", 1));
   for (auto Dir : MCDwarfDirs) {
     MCOS->EmitBytes(Dir);                // The DirectoryName, and...
     MCOS->EmitBytes(StringRef("\0", 1)); // its null terminator.
   }
 
   // The file format, which is the inline null-terminated filename and a
   // directory index.  We don't track file size/timestamp so don't emit them
-  // in the v5 table.
-  // FIXME: Arrange to emit MD5 signatures for the source files.
-  MCOS->EmitIntValue(2, 1);
+  // in the v5 table.  Emit MD5 checksums if we have them.
+  MCOS->EmitIntValue(HasMD5 ? 3 : 2, 1);
   MCOS->EmitULEB128IntValue(dwarf::DW_LNCT_path);
   MCOS->EmitULEB128IntValue(dwarf::DW_FORM_string);
   MCOS->EmitULEB128IntValue(dwarf::DW_LNCT_directory_index);
   MCOS->EmitULEB128IntValue(dwarf::DW_FORM_udata);
-  // Then the list of file names. These start at 1 for some reason.
+  if (HasMD5) {
+    MCOS->EmitULEB128IntValue(dwarf::DW_LNCT_MD5);
+    MCOS->EmitULEB128IntValue(dwarf::DW_FORM_data16);
+  }
+  // Then the list of file names. These start at 1.
   MCOS->EmitULEB128IntValue(MCDwarfFiles.size() - 1);
   for (unsigned i = 1; i < MCDwarfFiles.size(); ++i) {
     assert(!MCDwarfFiles[i].Name.empty());
     MCOS->EmitBytes(MCDwarfFiles[i].Name); // FileName and...
     MCOS->EmitBytes(StringRef("\0", 1));   // its null terminator.
     MCOS->EmitULEB128IntValue(MCDwarfFiles[i].DirIndex); // Directory number.
+    if (HasMD5) {
+      MD5::MD5Result *Cksum = MCDwarfFiles[i].Checksum;
+      MCOS->EmitBinaryData(
+          StringRef(reinterpret_cast<const char *>(Cksum->Bytes.data()),
+                    Cksum->Bytes.size()));
+    }
   }
 }
 
 std::pair<MCSymbol *, MCSymbol *>
 MCDwarfLineTableHeader::Emit(MCStreamer *MCOS, MCDwarfLineTableParams Params,
                              ArrayRef<char> StandardOpcodeLengths) const {
   MCContext &context = MCOS->getContext();
 
MCDwarfLineTableHeader::Emit(MCStreamer *MCOS, MCDwarfLineTableParams Params,
 
   // Standard opcode lengths
   for (char Length : StandardOpcodeLengths)
     MCOS->EmitIntValue(Length, 1);
 
   // Put out the directory and file tables.  The formats vary depending on
   // the version.
   if (LineTableVersion >= 5)
-    emitV5FileDirTables(MCOS, MCDwarfDirs, MCDwarfFiles, CompilationDir);
+    emitV5FileDirTables(MCOS, MCDwarfDirs, MCDwarfFiles, CompilationDir,
+                        HasMD5);
   else
     emitV2FileDirTables(MCOS, MCDwarfDirs, MCDwarfFiles);
 
   // This is the end of the prologue, so set the value of the symbol at the
   // end of the prologue (that was used in a previous expression).
   MCOS->EmitLabel(ProEndSym);
 
   return std::make_pair(LineStartSym, LineEndSym);
 }
 
 void MCDwarfLineTable::EmitCU(MCObjectStreamer *MCOS,
                               MCDwarfLineTableParams Params) const {
   MCSymbol *LineEndSym = Header.Emit(MCOS, Params).second;
 
   // Put out the line tables.
   for (const auto &LineSec : MCLineSections.getMCLineEntries())
     EmitDwarfLineTable(MCOS, LineSec.first, LineSec.second);
 
   // This is the end of the section, so set the value of the symbol at the end
   // of this section (that was used in a previous expression).
   MCOS->EmitLabel(LineEndSym);
 }
 
 unsigned MCDwarfLineTable::getFile(StringRef &Directory, StringRef &FileName,
+                                   MD5::MD5Result *Checksum,
                                    unsigned FileNumber) {
-  return Header.getFile(Directory, FileName, FileNumber);
+  return Header.getFile(Directory, FileName, Checksum, FileNumber);
 }
 
 unsigned MCDwarfLineTableHeader::getFile(StringRef &Directory,
                                          StringRef &FileName,
+                                         MD5::MD5Result *Checksum,
                                          unsigned FileNumber) {
   if (Directory == CompilationDir)
     Directory = "";
   if (FileName.empty()) {
     FileName = "<stdin>";
     Directory = "";
   }
   assert(!FileName.empty());
unsigned MCDwarfLineTableHeader::getFile(StringRef &Directory,
 
   // Get the new MCDwarfFile slot for this FileNumber.
   MCDwarfFile &File = MCDwarfFiles[FileNumber];
 
   // It is an error to use see the same number more than once.
   if (!File.Name.empty())
     return 0;
 
+  // If any files have an MD5 checksum, they all must.
+  if (FileNumber > 1)
+    assert(HasMD5 == (Checksum != nullptr));
+
   if (Directory.empty()) {
     // Separate the directory part from the basename of the FileName.
     StringRef tFileName = sys::path::filename(FileName);
     if (!tFileName.empty()) {
       Directory = sys::path::parent_path(FileName);
       if (!Directory.empty())
         FileName = tFileName;
     }
if (Directory.empty()) {
     // no directories.  MCDwarfDirs[] is unlike MCDwarfFiles[] in that the
     // directory names are stored at MCDwarfDirs[DirIndex-1] where FileNames
     // are stored at MCDwarfFiles[FileNumber].Name .
     DirIndex++;
   }
 
   File.Name = FileName;
   File.DirIndex = DirIndex;
+  File.Checksum = Checksum;
+  if (Checksum)
+    HasMD5 = true;
 
   // return the allocated FileNumber.
   return FileNumber;
 }
 
 /// Utility function to emit the encoding to a streamer.
 void MCDwarfLineAddr::Emit(MCStreamer *MCOS, MCDwarfLineTableParams Params,
                            int64_t LineDelta, uint64_t AddrDelta) {

llvm/lib/MC/MCParser/AsmParser.cpp

 #include "llvm/MC/MCSection.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/MCTargetOptions.h"
 #include "llvm/MC/MCValue.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/MD5.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/SMLoc.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cassert>
 #include <cctype>
if ((!HasFillExpr || Lexer.getMAI().getTextAlignFillValue() == FillExpr) &&
     getStreamer().EmitValueToAlignment(Alignment, FillExpr, ValueSize,
                                        MaxBytesToFill);
   }
 
   return ReturnVal;
 }
 
 /// parseDirectiveFile
-/// ::= .file [number] filename
-/// ::= .file number directory filename
+/// ::= .file filename
+/// ::= .file number [directory] filename [md5 checksum]
 bool AsmParser::parseDirectiveFile(SMLoc DirectiveLoc) {
   // FIXME: I'm not sure what this is.
   int64_t FileNumber = -1;
   SMLoc FileNumberLoc = getLexer().getLoc();
   if (getLexer().is(AsmToken::Integer)) {
     FileNumber = getTok().getIntVal();
     Lex();
 
if (check(FileNumber == -1,
         parseEscapedString(FilenameData))
       return true;
     Filename = FilenameData;
     Directory = Path;
   } else {
     Filename = Path;
   }
 
-  if (parseToken(AsmToken::EndOfStatement,
+  std::string Checksum;
+  if (!parseOptionalToken(AsmToken::EndOfStatement)) {
+    StringRef Keyword;
+    if (check(getTok().isNot(AsmToken::Identifier),
+              "unexpected token in '.file' directive") ||
+        parseIdentifier(Keyword) ||
+        check(Keyword != "md5", "unexpected token in '.file' directive"))
+      return true;
+    if (getLexer().is(AsmToken::String) &&
+        check(FileNumber == -1, "MD5 checksum specified, but no file number"))
+      return true;
+    if (check(getTok().isNot(AsmToken::String),
+              "unexpected token in '.file' directive") ||
+        parseEscapedString(Checksum) ||
+        check(Checksum.size() != 32, "invalid MD5 checksum specified") ||
+        parseToken(AsmToken::EndOfStatement,
                    "unexpected token in '.file' directive"))
       return true;
+  }
 
   if (FileNumber == -1)
     getStreamer().EmitFileDirective(Filename);
   else {
+    MD5::MD5Result *CKMem = nullptr;
+    if (!Checksum.empty()) {
+      Checksum = fromHex(Checksum);
+      if (check(Checksum.size() != 16, "invalid MD5 checksum specified"))
+        return true;
+      CKMem = (MD5::MD5Result *)Ctx.allocate(sizeof(MD5::MD5Result), 1);
+      memcpy(&CKMem->Bytes, Checksum.data(), 16);
+    }
     // If there is -g option as well as debug info from directive file,
     // we turn off -g option, directly use the existing debug info instead.
     if (getContext().getGenDwarfForAssembly())
       getContext().setGenDwarfForAssembly(false);
-    else if (getStreamer().EmitDwarfFileDirective(FileNumber, Directory, Filename) ==
-        0)
+    else if (getStreamer().EmitDwarfFileDirective(FileNumber, Directory,
+                                                  Filename, CKMem) == 0)
       return Error(FileNumberLoc, "file number already allocated");
   }
 
   return false;
 }
 
 /// parseDirectiveLine
 /// ::= .line [number]

llvm/lib/MC/MCStreamer.cpp

 
 /// The implementation in this class just redirects to emitFill.
 void MCStreamer::EmitZeros(uint64_t NumBytes) {
   emitFill(NumBytes, 0);
 }
 
 unsigned MCStreamer::EmitDwarfFileDirective(unsigned FileNo,
                                             StringRef Directory,
-                                            StringRef Filename, unsigned CUID) {
-  return getContext().getDwarfFile(Directory, Filename, FileNo, CUID);
+                                            StringRef Filename,
+                                            MD5::MD5Result *Checksum,
+                                            unsigned CUID) {
+  return getContext().getDwarfFile(Directory, Filename, FileNo, Checksum, CUID);
 }
 
 void MCStreamer::EmitDwarfLocDirective(unsigned FileNo, unsigned Line,
                                        unsigned Column, unsigned Flags,
                                        unsigned Isa,
                                        unsigned Discriminator,
                                        StringRef FileName) {
   getContext().setCurrentDwarfLoc(FileNo, Line, Column, Flags, Isa,

llvm/test/MC/ELF/debug-md5-err.s

+# RUN: not llvm-mc -triple x86_64-unknown-unknown -dwarf-version 5 -filetype=asm %s -o /dev/null 2>&1 | FileCheck %s
+
+# This is syntactically legal, looks like no checksum provided.
+# CHECK-NOT: [[@LINE+1]]:{{[0-9]+}}: error:
+        .file 1 "dir1/foo" "00112233445566778899aabbccddeeff"
+
+# Missing md5 keyword.
+# CHECK: [[@LINE+1]]:{{[0-9]+}}: error: unexpected token in '.file' directive
+        .file 2 "dir1" "foo" "00112233445566778899aabbccddeeff"
+
+# Bad length.
+# CHECK: [[@LINE+1]]:{{[0-9]+}}: error: invalid MD5 checksum specified
+        .file 3 "dir2" "bar" md5 "ff"
+
+# Not a string.
+# CHECK: [[@LINE+1]]:{{[0-9]+}}: error: unexpected token in '.file' directive
+        .file 4 "dir3" "foo" md5 ffeeddccbbaa99887766554433221100
+
+# Non-DWARF .file syntax with checksum.
+# CHECK: [[@LINE+1]]:{{[0-9]+}}: error: MD5 checksum specified, but no file number
+        .file "baz" md5 "ffeeddccbbaa998877665544332211gg"

llvm/test/MC/ELF/debug-md5.s

+// RUN: llvm-mc -triple x86_64-unknown-unknown -dwarf-version 5 -filetype=obj %s -o -| llvm-dwarfdump --debug-line - | FileCheck %s
+
+        .file 1 "dir1/foo"   md5 "00112233445566778899aabbccddeeff"
+        .file 2 "dir2" "bar" md5 "ffeeddccbbaa99887766554433221100"
+        .loc 1 1 0
+        nop
+        .loc 2 1 0
+        nop
+
+# CHECK: debug_line[0x00000000]
+# CHECK: version: 5
+# CHECK: include_directories[ 1] = ''
+# CHECK: include_directories[ 2] = 'dir1'
+# CHECK: include_directories[ 3] = 'dir2'
+# CHECK-NOT: include_directories
+# CHECK: Dir MD5 Checksum File Name
+# CHECK: file_names[ 1] 1 00112233445566778899aabbccddeeff foo
+# CHECK: file_names[ 2] 2 ffeeddccbbaa99887766554433221100 bar