DebugInfo: Added support for Checksum debug info feature (LLVM IR part)

[aaboud]

Summary

Resolve Bug 30978.

This patch contains changes in LLVM IR to support Checksum debug info feature.

[mehdi_amini]

I think we try to make as much as possible metadata to be "distinct", CC Duncan to advise.

docs/LangRef.rst

4018

What are the valid list of "type"? What type is the "type" field? Why the prefix ChecksumType_ and not just MD5?
Why not a simpler approach where the type is an MDString? (That already how you parse it in DIChecksum::getChecksumType anyway)

include/llvm/IR/DebugInfoMetadata.h

430

Why there? Where is this API used?

491

What is the reason to have the "None"?

1331

Intended?

[aaboud]

In D27642#619007, @mehdi_amini wrote:

I think we try to make as much as possible metadata to be "distinct", CC Duncan to advise.

Not sure about that, so far we have only DICompileUnit and DISubprogram defined as distinct.
If I am not mistaken, distinct will prevent us from sharing Metadata, and for checksum there is no harm of sharing.

docs/LangRef.rst

4018

Right now the valid list of types are:
ChecksumType_MD5
ChecksumType_SHA1

I will add this to the document.

Answering your other questions:

1. The current solution does not handle the type as string, but as an enumeration with a known token (see LLexer.cpp)
2. Omitting the prefix ChecksumType_ will not allow us to recognize the token.
3. This is similar to what is done with DIFlag...
4. Allowing the user to write the type as string "MD5" is easier to implement, however, checking invalid types will not be elegant as this solution.

Bottom line, I am ready to go with either solutions.
Let's hear what others think.

include/llvm/IR/DebugInfoMetadata.h

430

We need to getChecksum from DICompileUnit, however, this information is stored in the DIScope.

491

We need to pass the checksum data and type to the DICompileUnit together with the filename and directory. However, not always we have a checksum data to send, and that is why we need an indicator that there is no checksum available.

If you try to create a checksum with None type Checksum::get() will return a nullptr.
This is the best way I could find to deal with the issue.
Please, let me know if you have better way to do that.

1331

I should have removed this line.
I am not sure why we have the getFilename() and getDirectory() for DILocation, thought that I might need the getChecksum for same reason, however, I guess it is not needed.

If for any reason we end up need this function we will add it then.
For now I will remove it.

[dexonsmith]

+Adrian.

Note that I'm not worried about using 'distinct' here, since DICheckSum doesn't look like it can participate in cycles. (Otherwise, I haven't looked deeply at the patch.)

[rnk]

Any objections to folding this into DIFile? It would substantially reduce the size of this patch, IMO.

docs/LangRef.rst

4018

I think we could fold DIChecksum into DIFile. It would look like:

!DIFile(filename: ..., checksumkind: ChecksumType_MD5, checksum: !"deadbeef")

This adds a dead integer to DIFile when checksums aren't being used, but it's probably more efficient and less work than having a separate node.

include/llvm/IR/DebugInfoMetadata.h

430

I don't believe we really need it. We can probably do CU->getFile()->getChecksum().

lib/IR/DIBuilder.cpp

127–128

Instead of having createCompileUnit take Filename, Directory, ChecksumType, and Checksum, have it take a DIFIle.

[aaboud]

In D27642#619933, @rnk wrote:

Any objections to folding this into DIFile? It would substantially reduce the size of this patch, IMO.

I have no objection going this way, if everybody agree on that I will implement the change and upload a new patch.

docs/LangRef.rst

4018

Fine with me.

include/llvm/IR/DebugInfoMetadata.h

430

OK, can do.

lib/IR/DIBuilder.cpp

127–128

It would be much better solution for sure.
I will give it a try (in different patch), unless you want to do it yourself :) ?

[aprantl]

docs/LangRef.rst

4018

I'm in favor of rolling it into DIFile. As Paul noted, DWARF 5 also allows for an MD5 checksum on each file entry in the line table section so I'm expecting this to become the normal case eventually.

What's the problem with recognizing MD5 as a context-sensitive token in the parser?

[aaboud]

docs/LangRef.rst

4018

It is not only MD5, right? should the LLexer recognize all possible types of checksum, i.e. MD5, SHA1, etc.?
Or like it is implemented in this patch, it only needs to recognize the checksum type prefix (whatever it will be).

So, how do you prefer to implement this?

1. Prefix - (if yes, what should be the prefix?)
2. Recognize all types
3. Have a wild string

[mehdi_amini]

docs/LangRef.rst

4018

I rather have a much simpler implementation, the validation can be done in the verifier easily and it would handle similarly in-memory validation, bitcode and textual IR (the first two are the most important by the way, textual IR is not what we should optimize for).

With the change that @rnk suggested that would make it quite a smaller patch I believe.

4018

Alternative representation:

!DIFile(filename: ..., checksum: !"MD5:deadbeef")

lib/Bitcode/Reader/BitcodeReader.cpp

2759

What if the value in Record[1] is unexpected?

lib/IR/Verifier.cpp

942

The check could be more strict: what if the bitcode contained an invalid ID?

[aaboud]

Thanks for all the reviews and suggestions.
I just need to hear that all of you agree to one of the suggested solutions.

docs/LangRef.rst

4018

Once again, I do not mind how we implement it, I just need to hear an agreement from most of the participants in this review.
however, I think that with this approach it might complicate the code in CodeViewDebug, as it needs to parse the checksum string to get the type.

I would like to hear Reid opinion on this suggestion before I go and implement it.

lib/Bitcode/Reader/BitcodeReader.cpp

2759

Do you suggest to do this instead?

static_cast<DIChecksum::ChecksumType>(Record[1])

lib/IR/Verifier.cpp

942

I am not sure if you are asking about the getTag() or the getType(), so I will answer for both.

1. If we fold the checksum data into the DIFile metadata, then there will be no need for the tag here.
2. Do you suggest that we check for valid range of check sum types? something like this:

(N.getType() >= DIChecksum::FirstValidType && N,getType() <= DIChecksum::LastValidType)

[mehdi_amini]

docs/LangRef.rst

4018

Is there already a patch up that shows the CodeViewDebug, so that I can see how it gets more complicated there?
I'd expect it to be a StringSwitch on the prefix in the string instead of a switch on the enum value and that's it.

lib/Bitcode/Reader/BitcodeReader.cpp

2759

Not really, this is identical. What I mean is that the value in Record[1] can be totally invalid.

You were concerned about the error checking in the LLParser while it is the least of my concern: the textual IR is more of a "debugging" representation while In Memory and Bitcode representation of the IR are both on the production path.

lib/IR/Verifier.cpp

942

Yes, basically N.getType() could be an integer value that is neither None neither one of the valid types.

[aaboud]

docs/LangRef.rst

4018

Sorry, I do not have this patch, and I am not planing to.
I hope that Reid can implement this in CodeViewDebug once I commit this patch.
This is why I would like to hear his agreement to your proposal before I go this direction.

lib/Bitcode/Reader/BitcodeReader.cpp

2759

1. I implemented the DIChecksumm::CheckSumType similar to DINode::DIFlags.
2. Do you think that if we use String in Record[1], we will be able to validate it here?

I think that it is fare enough to validate these values in the IR, after all LLexer and BitcodeReader are limited on how much they can validate.

[mehdi_amini]

lib/Bitcode/Reader/BitcodeReader.cpp

2759

I'm fine validating this in the IR itself, I'd be even fine leaving this field up to the backend which can only ignore and warn if it can't handle the type of the checksum (i.e. the IR verifier would accept null or any string for this field).

I raised it here because you put some effort into having a "robust" textual IR path while the bitcode was not well validated, which seems somehow backward.

[aprantl]

docs/LangRef.rst

4018

I was skeptical at first about using a string to represent the checksum, but I came around to agree that this format is likely the most straight-forward way to add this to the IR assembler language.

!DIFile(filename: ..., checksum: !"MD5:deadbeef") // with checksum being an optional nullable field.

We probably still want a DIChecksum wrapper around the string that converts the hex string into an llvm::MD5, etc, and/or stores it as a byte string for a more efficient representation.

include/llvm/IR/DebugInfoMetadata.h

491

Why not allow for a nullptr to be passed in that interface?

[rnk]

docs/LangRef.rst

4018

I don't think we want a DIChecksum node. If we're concerned about efficiency, the real gain is eliminating the extra allocation.

I'd rather separate the checksum kind out and store it in DIFile::SubclassData32. It's consistent with what we do for DW_VIRTUALITY_*. It only adds minor complexity to the AsmParser, which is not on any critical path, and avoids a StringSwitch in actual code that will run on every compilation.

[mehdi_amini]

docs/LangRef.rst

4018

Are you really motivated by the efficiency of a single StringSwitch per DIFile at Codegen time?

The complexity is not much in the AsmParser than in the bitcode (backward compatibility, etc.), the explicit "None" instead of just ignoring the field (null), and the validation in the verifier.

[aprantl]

docs/LangRef.rst

4018

@rnk: To make sure I understand where you're going with your comment: You said you would like to separate out the storage of the checksum kind, but how do you propose to store the checksum data?

[aprantl]

About the discussion on distinct: The checksums (and also the DIFile nodes) should be uniqued in an LTO compilation and thus should not be distinct.

[rnk]

docs/LangRef.rst

4018

@aprantl I'd store it in an MDString. Different checksums have different lengths, so we'll need a separate allocation for that.

@mehdi_amini What I really care about is that the code to generate this stuff and move it through LLVM is simple. Remember when Duncan encoded as much debug info as strings as possible before moving to the current DI* class hierarchy? Doing stringly-typed things like !"MD5:deadbeef" feels like that, and given a choice, I'd rather avoid that.

Anyway, @aaboud asked for my opinion, so I figured I should spell it out. If you both feel that !"MD5:deadbeef" is better, I don't feel strongly about this and can definitely live with the checksum kind in the string.

[aprantl]

docs/LangRef.rst

4018

Would you prefer to store the hexadecimal ASCII encoding in the MDString or the raw bytes?

I would also like to point out that the assembler syntax also doesn't necessarily need to match the in-memory representation. We could use the easy-to-parse !"MD5:deadbeef" syntax while still having a different internal representation.

[mehdi_amini]

docs/LangRef.rst

4018

@mehdi_amini What I really care about is that the code to generate this stuff and move it through LLVM is simple

That's also the motivation behind my comment: my impression was that using a MDString is reusing as much of the existing infrastructure and requires changing less places, making it less intrusive for something that likely needs only to be understood manipulated "late" and can stay opaque most of the time. It also makes it handling the checksum as a single unit rather than when it is split.
Not sure if it makes much difference in practice though, that was more my impression of it.

I thought the main motivation for Duncan's work on DI* class was the efficiency of the representation (LTO memory consumption especially). I'd have to ask him though, that is just me speculating.

[aaboud]

Folded Checksum type and data into DIFile metadata.

[rnk]

docs/LangRef.rst

4018

I just wanted to echo what Duncan said here about type safety. Ultimately the point of our representation is to have a coherent object model, and I think separating the kind out from the string helps achieve that. The textual IR and bitcode exist to support and serialize our object model.

lib/AsmParser/LLLexer.cpp

812

This prefix works for me, but we should ask others to stamp it.

lib/IR/DebugInfoMetadata.cpp

381

This assert doesn't look right. The checksum string should be non-empty or null, which is what the isCanonical check does. We shouldn't have an exception for CSK_None.

[mehdi_amini]

docs/LangRef.rst

4018

I don't see what can break the "coherency" of the "object model" on a leaf of the graph.

[majnemer]

include/llvm/IR/DebugInfoMetadata.h

540

I think it'd be nicer to instead do CSK_Last = CSK_SHA1 and use CSK_Last + 1 instead of CSK_Num. It makes it nicer to switch over the ChecksumKind type.

[aaboud]

Addressed comments by Reid and David.

docs/LangRef.rst

 
 DIFile
 """"""
 
 ``DIFile`` nodes represent files. The ``filename:`` can include slashes.
 
 .. code-block:: llvm
 
-    !0 = !DIFile(filename: "path/to/file", directory: "/path/to/dir")
+    !0 = !DIFile(filename: "path/to/file", directory: "/path/to/dir",
+                 checksum: !1)
 
 Files are sometimes used in ``scope:`` fields, and are the only valid target
 for ``file:`` fields.
 
+.. _DIChecksum:
+
+DIChecksum
+""""""""""
+
+``DIChecksum`` nodes represent file checksum.
+
+.. code-block:: llvm
+
+    !0 = !DIChecksum(type: ChecksumType_MD5,
+                     data: "000102030405060708090a0b0c0d0e0f")
+
 .. _DIBasicType:
 
 DIBasicType
 """""""""""
 
 ``DIBasicType`` nodes represent primitive types, such as ``int``, ``bool`` and
 ``float``. ``tag:`` defaults to ``DW_TAG_base_type``.
 

include/llvm/Bitcode/LLVMBitCodes.h

enum MetadataCodes {
   METADATA_EXPRESSION = 29,      // [distinct, n x element]
   METADATA_OBJC_PROPERTY = 30,   // [distinct, name, file, line, ...]
   METADATA_IMPORTED_ENTITY = 31, // [distinct, tag, scope, entity, line, name]
   METADATA_MODULE = 32,          // [distinct, scope, name, ...]
   METADATA_MACRO = 33,           // [distinct, macinfo, line, name, value]
   METADATA_MACRO_FILE = 34,      // [distinct, macinfo, line, file, ...]
   METADATA_STRINGS = 35,         // [count, offset] blob([lengths][chars])
   METADATA_GLOBAL_DECL_ATTACHMENT = 36, // [valueid, n x [id, mdnode]]
+  METADATA_CHECKSUM = 37,        // [distinct, type, data]
 };
 
 // The constants block (CONSTANTS_BLOCK_ID) describes emission for each
 // constant and maintains an implicit current type value.
 enum ConstantsCodes {
   CST_CODE_SETTYPE = 1,          // SETTYPE:       [typeid]
   CST_CODE_NULL = 2,             // NULL
   CST_CODE_UNDEF = 3,            // UNDEF

include/llvm/IR/DIBuilder.h

public:
     /// Construct any deferred debug info descriptors.
     void finalize();
 
     /// A CompileUnit provides an anchor for all debugging
     /// information generated during this instance of compilation.
     /// \param Lang          Source programming language, eg. dwarf::DW_LANG_C99
     /// \param File          File name
     /// \param Dir           Directory
+    /// \param ChecksumType  Checksum type (e.g. MD5, SHA1, etc.).
+    /// \param Checksum      Checksum data.
     /// \param Producer      Identify the producer of debugging information
     ///                      and code.  Usually this is a compiler
     ///                      version string.
     /// \param isOptimized   A boolean flag which indicates whether optimization
     ///                      is enabled or not.
     /// \param Flags         This string lists command line options. This
     ///                      string is directly embedded in debug info
     ///                      output which may be used by a tool
     ///                      analyzing generated debugging information.
     /// \param RV            This indicates runtime version for languages like
     ///                      Objective-C.
     /// \param SplitName     The name of the file that we'll split debug info
     ///                      out into.
     /// \param Kind          The kind of debug information to generate.
     /// \param DWOId         The DWOId if this is a split skeleton compile unit.
     DICompileUnit *
     createCompileUnit(unsigned Lang, StringRef File, StringRef Dir,
+                      DIChecksum::ChecksumType ChecksumType, StringRef Checksum,
                       StringRef Producer, bool isOptimized, StringRef Flags,
                       unsigned RV, StringRef SplitName = StringRef(),
                       DICompileUnit::DebugEmissionKind Kind =
                           DICompileUnit::DebugEmissionKind::FullDebug,
                       uint64_t DWOId = 0, bool SplitDebugInlining = true);
 
-    /// Create a file descriptor to hold debugging information
-    /// for a file.
-    DIFile *createFile(StringRef Filename, StringRef Directory);
+    /// Create a checksum descriptor to hold checksum information for a file.
+    /// \param Type Checksum type (e.g. MD5, SHA1, etc.).
+    /// \param Data Checksum data.
+    DIChecksum *createChecksum(DIChecksum::ChecksumType Type, StringRef Data);
+
+    /// Create a file descriptor to hold debugging information for a file.
+    DIFile *createFile(StringRef Filename, StringRef Directory,
+                       DIChecksum *Checksum = nullptr);
 
     /// Create a single enumerator value.
     DIEnumerator *createEnumerator(StringRef Name, int64_t Val);
 
     /// Create a DWARF unspecified type.
     DIBasicType *createUnspecifiedType(StringRef Name);
 
     /// Create C++11 nullptr type.

include/llvm/IR/DebugInfoMetadata.h

DIScope(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
       : DINode(C, ID, Storage, Tag, Ops) {}
   ~DIScope() = default;
 
 public:
   DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); }
 
   inline StringRef getFilename() const;
   inline StringRef getDirectory() const;
+  inline DIChecksum *getChecksum() const;
 
   StringRef getName() const;
   DIScopeRef getScope() const;
 
   /// Return the raw underlying file.
   ///
   /// An \a DIFile is an \a DIScope, but it doesn't point at a separate file
   /// (it\em is the file).  If \c this is an \a DIFile, we need to return \c
static bool classof(const Metadata *MD) {
     case DILexicalBlockFileKind:
     case DINamespaceKind:
     case DIModuleKind:
       return true;
     }
   }
 };
 
+/// File checksum.
+class DIChecksum : public DINode {
+  friend class LLVMContextImpl;
+  friend class MDNode;
+
+public:
+  enum ChecksumType {
+    None,
+    MD5,
+    SHA1,
+    ChecksumTypeNum // Should be last enumeration.
+  };
+
+private:
+  ChecksumType Type;
+
+  DIChecksum(LLVMContext &C, StorageType Storage, ChecksumType Type,
+             ArrayRef<Metadata *> Ops)
+      : DINode(C, DIChecksumKind, Storage, dwarf::DW_TAG_null, Ops), Type(Type)
+        {}
+  ~DIChecksum() = default;
+
+  static DIChecksum *getImpl(LLVMContext &Context, ChecksumType Type,
+                             StringRef Data, StorageType Storage,
+                             bool ShouldCreate = true) {
+    // Do not create checksum with "None" checksum type.
+    if (Type == None)
+      return nullptr;
+    return getImpl(Context, Type, getCanonicalMDString(Context, Data),
+                   Storage, ShouldCreate);
+  }
+  static DIChecksum *getImpl(LLVMContext &Context, ChecksumType Type,
+                             MDString *Data, StorageType Storage,
+                             bool ShouldCreate = true);
+
+  TempDIChecksum cloneImpl() const {
+    return getTemporary(getContext(), getType(), getData());
+  }
+
+public:
+  DEFINE_MDNODE_GET(DIChecksum, (ChecksumType Type, StringRef Data),
+                    (Type, Data))
+  DEFINE_MDNODE_GET(DIChecksum, (ChecksumType Type, MDString *Data),
+                    (Type, Data))
+
+  TempDIChecksum clone() const { return cloneImpl(); }
+
+  ChecksumType getType() const { return Type; }
+  StringRef getData() const { return getStringOperand(0); }
+  StringRef getTypeAsString() const;
+
+  MDString *getRawData() const { return getOperandAs<MDString>(0); }
+
+  static ChecksumType getChecksumType(StringRef TypeStr);
+
+  static bool classof(const Metadata *MD) {
+    return MD->getMetadataID() == DIChecksumKind;
+  }
+};
+
 /// File.
 ///
 /// TODO: Merge with directory/file node (including users).
 /// TODO: Canonicalize paths on creation.
 class DIFile : public DIScope {
   friend class LLVMContextImpl;
   friend class MDNode;
 
   DIFile(LLVMContext &C, StorageType Storage, ArrayRef<Metadata *> Ops)
       : DIScope(C, DIFileKind, Storage, dwarf::DW_TAG_file_type, Ops) {}
   ~DIFile() = default;
 
   static DIFile *getImpl(LLVMContext &Context, StringRef Filename,
-                         StringRef Directory, StorageType Storage,
-                         bool ShouldCreate = true) {
+                         StringRef Directory, DIChecksum *Checksum,
+                         StorageType Storage, bool ShouldCreate = true) {
     return getImpl(Context, getCanonicalMDString(Context, Filename),
-                   getCanonicalMDString(Context, Directory), Storage,
+                   getCanonicalMDString(Context, Directory), Checksum, Storage,
                    ShouldCreate);
   }
   static DIFile *getImpl(LLVMContext &Context, MDString *Filename,
-                         MDString *Directory, StorageType Storage,
-                         bool ShouldCreate = true);
+                         MDString *Directory, Metadata *Checksum,
+                         StorageType Storage, bool ShouldCreate = true);
 
   TempDIFile cloneImpl() const {
-    return getTemporary(getContext(), getFilename(), getDirectory());
+    return getTemporary(getContext(), getFilename(), getDirectory(),
+                        getChecksum());
   }
 
 public:
-  DEFINE_MDNODE_GET(DIFile, (StringRef Filename, StringRef Directory),
-                    (Filename, Directory))
-  DEFINE_MDNODE_GET(DIFile, (MDString * Filename, MDString *Directory),
-                    (Filename, Directory))
+  DEFINE_MDNODE_GET(DIFile, (StringRef Filename, StringRef Directory,
+                             DIChecksum *Checksum),
+                    (Filename, Directory, Checksum))
+  DEFINE_MDNODE_GET(DIFile, (MDString *Filename, MDString *Directory,
+                             Metadata *Checksum),
+                    (Filename, Directory, Checksum))
 
   TempDIFile clone() const { return cloneImpl(); }
 
   StringRef getFilename() const { return getStringOperand(0); }
   StringRef getDirectory() const { return getStringOperand(1); }
+  DIChecksum *getChecksum() const {
+    return cast_or_null<DIChecksum>(getRawChecksum());
+  }
 
   MDString *getRawFilename() const { return getOperandAs<MDString>(0); }
   MDString *getRawDirectory() const { return getOperandAs<MDString>(1); }
+  Metadata *getRawChecksum() const { return getOperand(2); }
 
   static bool classof(const Metadata *MD) {
     return MD->getMetadataID() == DIFileKind;
   }
 };
 
 StringRef DIScope::getFilename() const {
   if (auto *F = getFile())
     return F->getFilename();
   return "";
 }
 
 StringRef DIScope::getDirectory() const {
   if (auto *F = getFile())
     return F->getDirectory();
   return "";
 }
 
+DIChecksum *DIScope::getChecksum() const {
+  if (auto *F = getFile())
+    return F->getChecksum();
+  return nullptr;
+}
+
 /// Base class for types.
 ///
 /// TODO: Remove the hardcoded name and context, since many types don't use
 /// them.
 /// TODO: Split up flags.
 class DIType : public DIScope {
   unsigned Line;
   DIFlags Flags;
public:
   DILocalScope *getScope() const { return cast<DILocalScope>(getRawScope()); }
   DILocation *getInlinedAt() const {
     return cast_or_null<DILocation>(getRawInlinedAt());
   }
 
   DIFile *getFile() const { return getScope()->getFile(); }
   StringRef getFilename() const { return getScope()->getFilename(); }
   StringRef getDirectory() const { return getScope()->getDirectory(); }
+  //DIChecksum *getChecksum() const { return getScope()->getChecksum(); }
 
   /// Get the scope where this is inlined.
   ///
   /// Walk through \a getInlinedAt() and return \a getScope() from the deepest
   /// location.
   DILocalScope *getInlinedAtScope() const {
     if (auto *IA = getInlinedAt())
       return IA->getInlinedAtScope();

include/llvm/IR/Metadata.def

 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIEnumerator)
 HANDLE_SPECIALIZED_MDNODE_BRANCH(DIScope)
 HANDLE_SPECIALIZED_MDNODE_BRANCH(DIType)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIBasicType)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIDerivedType)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DICompositeType)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DISubroutineType)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIFile)
+HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIChecksum)
 HANDLE_SPECIALIZED_MDNODE_LEAF(DICompileUnit)
 HANDLE_SPECIALIZED_MDNODE_BRANCH(DILocalScope)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DISubprogram)
 HANDLE_SPECIALIZED_MDNODE_BRANCH(DILexicalBlockBase)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DILexicalBlock)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DILexicalBlockFile)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DINamespace)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIModule)

lib/AsmParser/LLLexer.cpp

#define DWKEYWORD(TYPE, TOKEN)                                                 \
   DWKEYWORD(MACINFO, DwarfMacinfo);
 
 #undef DWKEYWORD
 
   if (Keyword.startswith("DIFlag")) {
     StrVal.assign(Keyword.begin(), Keyword.end());
     return lltok::DIFlag;
   }
+
+  if (Keyword.startswith("ChecksumType_")) {
+    StrVal.assign(Keyword.begin(), Keyword.end());
+    return lltok::ChecksumType;
+  }
+
   if (Keyword == "NoDebug" || Keyword == "FullDebug" ||
       Keyword == "LineTablesOnly") {
     StrVal.assign(Keyword.begin(), Keyword.end());
     return lltok::EmissionKind;
   }
 
   // Check for [us]0x[0-9A-Fa-f]+ which are Hexadecimal constant generated by
   // the CFE to avoid forcing it to deal with 64-bit numbers.

lib/AsmParser/LLParser.cpp

struct MDStringField : public MDFieldImpl<MDString *> {
   MDStringField(bool AllowEmpty = true)
       : ImplTy(nullptr), AllowEmpty(AllowEmpty) {}
 };
 
 struct MDFieldList : public MDFieldImpl<SmallVector<Metadata *, 4>> {
   MDFieldList() : ImplTy(SmallVector<Metadata *, 4>()) {}
 };
 
+struct ChecksumTypeField : public MDFieldImpl<DIChecksum::ChecksumType> {
+  ChecksumTypeField() : ImplTy(DIChecksum::None) {}
+  ChecksumTypeField(DIChecksum::ChecksumType Type) : ImplTy(Type) {}
+};
+
 } // end anonymous namespace
 
 namespace llvm {
 
 template <>
 bool LLParser::ParseMDField(LocTy Loc, StringRef Name,
                             MDUnsignedField &Result) {
   if (Lex.getKind() != lltok::APSInt || Lex.getAPSIntVal().isSigned())
bool LLParser::ParseMDField(LocTy Loc, StringRef Name, MDFieldList &Result) {
   SmallVector<Metadata *, 4> MDs;
   if (ParseMDNodeVector(MDs))
     return true;
 
   Result.assign(std::move(MDs));
   return false;
 }
 
+template <>
+bool LLParser::ParseMDField(LocTy Loc, StringRef Name,
+                            ChecksumTypeField &Result) {
+  if (Lex.getKind() != lltok::ChecksumType)
+    return TokError(
+        "invalid checksum type" + Twine(" '") + Lex.getStrVal() + "'");
+
+  DIChecksum::ChecksumType Type = DIChecksum::getChecksumType(Lex.getStrVal());
+  if (Type == DIChecksum::None)
+    return TokError(
+        "invalid checksum type" + Twine(" '") + Lex.getStrVal() + "'");
+
+  Result.assign(Type);
+  Lex.Lex();
+  return false;
+}
+
 } // end namespace llvm
 
 template <class ParserTy>
 bool LLParser::ParseMDFieldsImplBody(ParserTy parseField) {
   do {
     if (Lex.getKind() != lltok::LabelStr)
       return TokError("expected field label here");
 
#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   PARSE_MD_FIELDS();
 #undef VISIT_MD_FIELDS
 
   Result = GET_OR_DISTINCT(DISubroutineType,
                            (Context, flags.Val, cc.Val, types.Val));
   return false;
 }
 
+/// ParseDIChecksum:
+///   ::= !DIChecksum(type: ChecksumType_MD5,
+///                   data: "000102030405060708090a0b0c0d0e0f")
+bool LLParser::ParseDIChecksum(MDNode *&Result, bool IsDistinct) {
+#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
+  REQUIRED(type, ChecksumTypeField, );                                         \
+  REQUIRED(data, MDStringField, );
+  PARSE_MD_FIELDS();
+#undef VISIT_MD_FIELDS
+
+  Result = GET_OR_DISTINCT(DIChecksum, (Context, type.Val, data.Val));
+  return false;
+}
+
 /// ParseDIFileType:
 ///   ::= !DIFileType(filename: "path/to/file", directory: "/path/to/dir")
 bool LLParser::ParseDIFile(MDNode *&Result, bool IsDistinct) {
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   REQUIRED(filename, MDStringField, );                                         \
-  REQUIRED(directory, MDStringField, );
+  REQUIRED(directory, MDStringField, );                                        \
+  OPTIONAL(checksum, MDField, );
   PARSE_MD_FIELDS();
 #undef VISIT_MD_FIELDS
 
-  Result = GET_OR_DISTINCT(DIFile, (Context, filename.Val, directory.Val));
+  Result = GET_OR_DISTINCT(DIFile, (Context, filename.Val, directory.Val,
+                                    checksum.Val));
   return false;
 }
 
 /// ParseDICompileUnit:
 ///   ::= !DICompileUnit(language: DW_LANG_C99, file: !0, producer: "clang",
 ///                      isOptimized: true, flags: "-O2", runtimeVersion: 1,
 ///                      splitDebugFilename: "abc.debug",
 ///                      emissionKind: FullDebug, enums: !1, retainedTypes: !2,

lib/AsmParser/LLToken.h

enum Kind {
   DwarfAttEncoding, // DW_ATE_foo
   DwarfVirtuality,  // DW_VIRTUALITY_foo
   DwarfLang,        // DW_LANG_foo
   DwarfCC,          // DW_CC_foo
   EmissionKind,     // lineTablesOnly
   DwarfOp,          // DW_OP_foo
   DIFlag,           // DIFlagFoo
   DwarfMacinfo,     // DW_MACINFO_foo
+  ChecksumType,     // ChecksumType_foo
 
   // Type valued tokens (TyVal).
   Type,
 
   APFloat, // APFloatVal
   APSInt   // APSInt
 };
 } // end namespace lltok
 } // end namespace llvm
 
 #endif

lib/Bitcode/Reader/BitcodeReader.cpp

case bitc::METADATA_MODULE: {
           GET_OR_DISTINCT(DIModule,
                           (Context, getMDOrNull(Record[1]),
                            getMDString(Record[2]), getMDString(Record[3]),
                            getMDString(Record[4]), getMDString(Record[5]))),
           NextMetadataNo++);
       break;
     }
 
-    case bitc::METADATA_FILE: {
+    case bitc::METADATA_CHECKSUM: {
       if (Record.size() != 3)
         return error("Invalid record");
 
       IsDistinct = Record[0];
       MetadataList.assignValue(
-          GET_OR_DISTINCT(DIFile, (Context, getMDString(Record[1]),
-                                   getMDString(Record[2]))),
-          NextMetadataNo++);
+        GET_OR_DISTINCT(DIChecksum,
+                        (Context, (DIChecksum::ChecksumType)Record[1],
       break;
     }
+
+    case bitc::METADATA_FILE: {
+      if (Record.size() < 3 || Record.size() > 4)
+        return error("Invalid record");
+
+      IsDistinct = Record[0];
+      MetadataList.assignValue(
+          GET_OR_DISTINCT(DIFile,
+                          (Context, getMDString(Record[1]),
+                           getMDString(Record[2]),
+                           Record.size() == 3 ? nullptr : getMDOrNull(Record[3])
+                          )),
+          NextMetadataNo++);
+      break;
+    }
     case bitc::METADATA_COMPILE_UNIT: {
       if (Record.size() < 14 || Record.size() > 17)
         return error("Invalid record");
 
       // Ignore Record[0], which indicates whether this compile unit is
       // distinct.  It's always distinct.
       IsDistinct = true;
       auto *CU = DICompileUnit::getDistinct(

lib/Bitcode/Writer/BitcodeWriter.cpp

void writeDIBasicType(const DIBasicType *N, SmallVectorImpl<uint64_t> &Record,
                         unsigned Abbrev);
   void writeDIDerivedType(const DIDerivedType *N,
                           SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);
   void writeDICompositeType(const DICompositeType *N,
                             SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);
   void writeDISubroutineType(const DISubroutineType *N,
                              SmallVectorImpl<uint64_t> &Record,
                              unsigned Abbrev);
+  void writeDIChecksum(const DIChecksum *N, SmallVectorImpl<uint64_t> &Record,
+                       unsigned Abbrev);
   void writeDIFile(const DIFile *N, SmallVectorImpl<uint64_t> &Record,
                    unsigned Abbrev);
   void writeDICompileUnit(const DICompileUnit *N,
                           SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);
   void writeDISubprogram(const DISubprogram *N,
                          SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);
   void writeDILexicalBlock(const DILexicalBlock *N,
                            SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);
void ModuleBitcodeWriter::writeDISubroutineType(
   Record.push_back(N->getFlags());
   Record.push_back(VE.getMetadataOrNullID(N->getTypeArray().get()));
   Record.push_back(N->getCC());
 
   Stream.EmitRecord(bitc::METADATA_SUBROUTINE_TYPE, Record, Abbrev);
   Record.clear();
 }
 
+void ModuleBitcodeWriter::writeDIChecksum(const DIChecksum *N,
+                                          SmallVectorImpl<uint64_t> &Record,
+                                          unsigned Abbrev) {
+  Record.push_back(N->isDistinct());
+  Record.push_back(N->getType());
+  Record.push_back(VE.getMetadataOrNullID(N->getRawData()));
+
+  Stream.EmitRecord(bitc::METADATA_CHECKSUM, Record, Abbrev);
+  Record.clear();
+}
+
 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(VE.getMetadataOrNullID(N->getRawChecksum()));
 
   Stream.EmitRecord(bitc::METADATA_FILE, Record, Abbrev);
   Record.clear();
 }
 
 void ModuleBitcodeWriter::writeDICompileUnit(const DICompileUnit *N,
                                              SmallVectorImpl<uint64_t> &Record,
                                              unsigned Abbrev) {

lib/IR/AsmWriter.cpp

struct MDFieldPrinter {
   explicit MDFieldPrinter(raw_ostream &Out)
       : Out(Out), TypePrinter(nullptr), Machine(nullptr), Context(nullptr) {}
   MDFieldPrinter(raw_ostream &Out, TypePrinting *TypePrinter,
                  SlotTracker *Machine, const Module *Context)
       : Out(Out), TypePrinter(TypePrinter), Machine(Machine), Context(Context) {
   }
   void printTag(const DINode *N);
   void printMacinfoType(const DIMacroNode *N);
+  void printChecksumType(const DIChecksum *N);
   void printString(StringRef Name, StringRef Value,
                    bool ShouldSkipEmpty = true);
   void printMetadata(StringRef Name, const Metadata *MD,
                      bool ShouldSkipNull = true);
   template <class IntTy>
   void printInt(StringRef Name, IntTy Int, bool ShouldSkipZero = true);
   void printBool(StringRef Name, bool Value, Optional<bool> Default = None);
   void printDIFlags(StringRef Name, DINode::DIFlags Flags);
void MDFieldPrinter::printMacinfoType(const DIMacroNode *N) {
   Out << FS << "type: ";
   auto Type = dwarf::MacinfoString(N->getMacinfoType());
   if (!Type.empty())
     Out << Type;
   else
     Out << N->getMacinfoType();
 }
 
+void MDFieldPrinter::printChecksumType(const DIChecksum *N) {
+  Out << FS << "type: " << N->getTypeAsString();
+}
+
 void MDFieldPrinter::printString(StringRef Name, StringRef Value,
                                  bool ShouldSkipEmpty) {
   if (ShouldSkipEmpty && Value.empty())
     return;
 
   Out << FS << Name << ": \"";
   PrintEscapedString(Value, Out);
   Out << "\"";
static void writeDISubroutineType(raw_ostream &Out, const DISubroutineType *N,
   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
   Printer.printDIFlags("flags", N->getFlags());
   Printer.printDwarfEnum("cc", N->getCC(), dwarf::ConventionString);
   Printer.printMetadata("types", N->getRawTypeArray(),
                         /* ShouldSkipNull */ false);
   Out << ")";
 }
 
-static void writeDIFile(raw_ostream &Out, const DIFile *N, TypePrinting *,
-                        SlotTracker *, const Module *) {
-  Out << "!DIFile(";
+static void writeDIChecksum(raw_ostream &Out, const DIChecksum *N,
+                            TypePrinting *, SlotTracker *, const Module *) {
+  Out << "!DIChecksum(";
   MDFieldPrinter Printer(Out);
+  Printer.printChecksumType(N);
+  Printer.printString("data", N->getData(), /* ShouldSkipEmpty */ false);
+  Out << ")";
+}
+
+static void writeDIFile(raw_ostream &Out, const DIFile *N,
+                        TypePrinting *TypePrinter, SlotTracker *Machine,
+                        const Module *Context) {
+  Out << "!DIFile(";
+  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
   Printer.printString("filename", N->getFilename(),
                       /* ShouldSkipEmpty */ false);
   Printer.printString("directory", N->getDirectory(),
                       /* ShouldSkipEmpty */ false);
+  Printer.printMetadata("checksum", N->getRawChecksum(),
+                        /* ShouldSkipEmpty */ true);
   Out << ")";
 }
 
 static void writeDICompileUnit(raw_ostream &Out, const DICompileUnit *N,
                                TypePrinting *TypePrinter, SlotTracker *Machine,
                                const Module *Context) {
   Out << "!DICompileUnit(";
   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);

lib/IR/DIBuilder.cpp

 /// If N is compile unit return NULL otherwise return N.
 static DIScope *getNonCompileUnitScope(DIScope *N) {
   if (!N || isa<DICompileUnit>(N))
     return nullptr;
   return cast<DIScope>(N);
 }
 
 DICompileUnit *DIBuilder::createCompileUnit(
-    unsigned Lang, StringRef Filename, StringRef Directory, StringRef Producer,
-    bool isOptimized, StringRef Flags, unsigned RunTimeVer, StringRef SplitName,
-    DICompileUnit::DebugEmissionKind Kind, uint64_t DWOId,
+    unsigned Lang, StringRef Filename, StringRef Directory,
+    DIChecksum::ChecksumType ChecksumType, StringRef Checksum,
+    StringRef Producer, bool isOptimized, StringRef Flags, unsigned RunTimeVer,
+    StringRef SplitName, DICompileUnit::DebugEmissionKind Kind, uint64_t DWOId,
     bool SplitDebugInlining) {
 
   assert(((Lang <= dwarf::DW_LANG_Fortran08 && Lang >= dwarf::DW_LANG_C89) ||
           (Lang <= dwarf::DW_LANG_hi_user && Lang >= dwarf::DW_LANG_lo_user)) &&
          "Invalid Language tag");
   assert(!Filename.empty() &&
          "Unable to create compile unit without filename");
 
   assert(!CUNode && "Can only make one compile unit per DIBuilder instance");
   CUNode = DICompileUnit::getDistinct(
-      VMContext, Lang, DIFile::get(VMContext, Filename, Directory), Producer,
-      isOptimized, Flags, RunTimeVer, SplitName, Kind, nullptr, nullptr,
-      nullptr, nullptr, nullptr, DWOId, SplitDebugInlining);
+      VMContext, Lang,
+      DIFile::get(VMContext, Filename, Directory,
+                  DIChecksum::get(VMContext, ChecksumType, Checksum)),
+      Producer, isOptimized, Flags, RunTimeVer, SplitName, Kind, nullptr,
+      nullptr, nullptr, nullptr, nullptr, DWOId, SplitDebugInlining);
 
   // Create a named metadata so that it is easier to find cu in a module.
   NamedMDNode *NMD = M.getOrInsertNamedMetadata("llvm.dbg.cu");
   NMD->addOperand(CUNode);
   trackIfUnresolved(CUNode);
   return CUNode;
 }
 
DIImportedEntity *DIBuilder::createImportedDeclaration(DIScope *Context,
                                                        unsigned Line,
                                                        StringRef Name) {
   // Make sure to use the unique identifier based metadata reference for
   // types that have one.
   return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_declaration,
                                 Context, Decl, Line, Name, AllImportedModules);
 }
 
-DIFile *DIBuilder::createFile(StringRef Filename, StringRef Directory) {
-  return DIFile::get(VMContext, Filename, Directory);
+DIChecksum *DIBuilder::createChecksum(DIChecksum::ChecksumType Type,
+                                      StringRef Data) {
+  return DIChecksum::get(VMContext, Type, Data);
+}
+
+DIFile *DIBuilder::createFile(StringRef Filename, StringRef Directory,
+                              DIChecksum *Checksum) {
+  return DIFile::get(VMContext, Filename, Directory, Checksum);
 }
 
 DIEnumerator *DIBuilder::createEnumerator(StringRef Name, int64_t Val) {
   assert(!Name.empty() && "Unable to create enumerator without name");
   return DIEnumerator::get(VMContext, Val, Name);
 }
 
 DIBasicType *DIBuilder::createUnspecifiedType(StringRef Name) {

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 *ChecksumTypeName[DIChecksum::ChecksumTypeNum] = {
+  "ChecksumType_none",
+  "ChecksumType_MD5",
+  "ChecksumType_SHA1",
+};
+
+StringRef DIChecksum::getTypeAsString() const { return ChecksumTypeName[Type]; }
+
+DIChecksum::ChecksumType DIChecksum::getChecksumType(StringRef TypeStr) {
+  return StringSwitch<DIChecksum::ChecksumType>(TypeStr)
+      .Case("ChecksumType_MD5", DIChecksum::MD5)
+      .Case("ChecksumType_SHA1", DIChecksum::SHA1)
+      .Default(DIChecksum::None);
+}
+
+DIChecksum *DIChecksum::getImpl(LLVMContext &Context, ChecksumType Type,
+                                MDString *Data, StorageType Storage,
+                                bool ShouldCreate) {
+  assert(isCanonical(Data) && "Expected canonical MDString");
+  DEFINE_GETIMPL_LOOKUP(DIChecksum, (Type, Data));
+  Metadata *Ops[] = { Data };
+  DEFINE_GETIMPL_STORE(DIChecksum, (Type), Ops);
+}
+
 DIFile *DIFile::getImpl(LLVMContext &Context, MDString *Filename,
-                        MDString *Directory, StorageType Storage,
-                        bool ShouldCreate) {
+                        MDString *Directory, Metadata *Checksum,
+                        StorageType Storage, bool ShouldCreate) {
   assert(isCanonical(Filename) && "Expected canonical MDString");
   assert(isCanonical(Directory) && "Expected canonical MDString");
-  DEFINE_GETIMPL_LOOKUP(DIFile, (Filename, Directory));
-  Metadata *Ops[] = {Filename, Directory};
+  DEFINE_GETIMPL_LOOKUP(DIFile, (Filename, Directory, Checksum));
+  Metadata *Ops[] = {Filename, Directory, Checksum};
   DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(DIFile, Ops);
 }
 
 DICompileUnit *DICompileUnit::getImpl(
     LLVMContext &Context, unsigned SourceLanguage, Metadata *File,
     MDString *Producer, bool IsOptimized, MDString *Flags,
     unsigned RuntimeVersion, MDString *SplitDebugFilename,
     unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes,
     Metadata *GlobalVariables, Metadata *ImportedEntities, Metadata *Macros,

lib/IR/LLVMContextImpl.h

template <> struct MDNodeKeyImpl<DISubroutineType> {
 
   bool isKeyOf(const DISubroutineType *RHS) const {
     return Flags == RHS->getFlags() && CC == RHS->getCC() &&
            TypeArray == RHS->getRawTypeArray();
   }
   unsigned getHashValue() const { return hash_combine(Flags, CC, TypeArray); }
 };
 
+template <> struct MDNodeKeyImpl<DIChecksum> {
+  DIChecksum::ChecksumType Type;
+  MDString *Data;
+
+  MDNodeKeyImpl(DIChecksum::ChecksumType Type, MDString *Data)
+      : Type(Type), Data(Data) {}
+  MDNodeKeyImpl(const DIChecksum *N)
+      : Type(N->getType()), Data(N->getRawData()) {}
+
+  bool isKeyOf(const DIChecksum *RHS) const {
+    return Type == RHS->getType() && Data == RHS->getRawData();
+  }
+  unsigned getHashValue() const {
+    return hash_combine(Type, Data);
+  }
+};
+
 template <> struct MDNodeKeyImpl<DIFile> {
   MDString *Filename;
   MDString *Directory;
+  Metadata *Checksum;
 
-  MDNodeKeyImpl(MDString *Filename, MDString *Directory)
-      : Filename(Filename), Directory(Directory) {}
+  MDNodeKeyImpl(MDString *Filename, MDString *Directory, Metadata *Checksum)
+      : Filename(Filename), Directory(Directory), Checksum(Checksum) {}
   MDNodeKeyImpl(const DIFile *N)
-      : Filename(N->getRawFilename()), Directory(N->getRawDirectory()) {}
+      : Filename(N->getRawFilename()), Directory(N->getRawDirectory()),
+        Checksum(N->getRawChecksum()) {}
 
   bool isKeyOf(const DIFile *RHS) const {
     return Filename == RHS->getRawFilename() &&
-           Directory == RHS->getRawDirectory();
+           Directory == RHS->getRawDirectory() &&
+           Checksum == RHS->getRawChecksum();
+  }
+  unsigned getHashValue() const {
+    return hash_combine(Filename, Directory, Checksum);
   }
-  unsigned getHashValue() const { return hash_combine(Filename, Directory); }
 };
 
 template <> struct MDNodeKeyImpl<DISubprogram> {
   Metadata *Scope;
   MDString *Name;
   MDString *LinkageName;
   Metadata *File;
   unsigned Line;

lib/IR/Verifier.cpp

if (auto *Types = N.getRawTypeArray()) {
     for (Metadata *Ty : N.getTypeArray()->operands()) {
       AssertDI(isType(Ty), "invalid subroutine type ref", &N, Types, Ty);
     }
   }
   AssertDI(!hasConflictingReferenceFlags(N.getFlags()),
            "invalid reference flags", &N);
 }
 
+void Verifier::visitDIChecksum(const DIChecksum &N) {
+  AssertDI(N.getTag() == dwarf::DW_TAG_null, "invalid tag", &N);
+  AssertDI(N.getType() != DIChecksum::None, "invalid checksum type", &N);
+}
+
 void Verifier::visitDIFile(const DIFile &N) {
   AssertDI(N.getTag() == dwarf::DW_TAG_file_type, "invalid tag", &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);
 

test/Assembler/debug-info.ll

 ; RUN: llvm-as < %s | llvm-dis | llvm-as | llvm-dis | FileCheck %s
 ; RUN: verify-uselistorder %s
 
-; CHECK: !named = !{!0, !0, !1, !2, !3, !4, !5, !6, !7, !8, !8, !9, !10, !11, !12, !13, !14, !15, !16, !17, !18, !19, !20, !21, !22, !23, !24, !25, !26, !27, !27, !28, !29, !30, !31}
-!named = !{!0, !1, !2, !3, !4, !5, !6, !7, !8, !9, !10, !11, !12, !13, !14, !15, !16, !17, !18, !19, !20, !21, !22, !23, !24, !25, !26, !27, !28, !29, !30, !31, !32, !33, !34}
+; CHECK: !named = !{!0, !0, !1, !2, !3, !4, !5, !6, !7, !8, !8, !9, !10, !11, !12, !13, !14, !15, !16, !17, !18, !19, !20, !21, !22, !23, !24, !25, !26, !27, !27, !28, !29, !30, !31, !32, !33}
+!named = !{!0, !1, !2, !3, !4, !5, !6, !7, !8, !9, !10, !11, !12, !13, !14, !15, !16, !17, !18, !19, !20, !21, !22, !23, !24, !25, !26, !27, !28, !29, !30, !31, !32, !33, !34, !35, !36}
 
 ; CHECK:      !0 = !DISubrange(count: 3)
 ; CHECK-NEXT: !1 = !DISubrange(count: 3, lowerBound: 4)
 ; CHECK-NEXT: !2 = !DISubrange(count: 3, lowerBound: -5)
 !0 = !DISubrange(count: 3)
 !1 = !DISubrange(count: 3, lowerBound: 0)
 
 !2 = !DISubrange(count: 3, lowerBound: 4)

 ; CHECK-NEXT: !28 = !DIMacro(type: DW_MACINFO_define, line: 9, name: "Name", value: "Value")
 ; CHECK-NEXT: !29 = distinct !{!28}
 ; CHECK-NEXT: !30 = !DIMacroFile(line: 9, file: !12, nodes: !29)
 ; CHECK-NEXT: !31 = !DIMacroFile(line: 11, file: !12)
 !31 = !DIMacro(type: DW_MACINFO_define, line: 9, name: "Name", value: "Value")
 !32 = distinct !{!31}
 !33 = !DIMacroFile(line: 9, file: !14, nodes: !32)
 !34 = !DIMacroFile(type: DW_MACINFO_start_file, line: 11, file: !14)
+
+; CHECK-NEXT: !32 = !DIFile(filename: "path/to/file", directory: "/path/to/dir", checksum: !33)
+; CHECK-NEXT: !33 = !DIChecksum(type: ChecksumType_MD5, data: "000102030405060708090a0b0c0d0e0f")
+!35 = !DIFile(filename: "path/to/file", directory: "/path/to/dir", checksum: !36)
+!36 = !DIChecksum(type: ChecksumType_MD5, data: "000102030405060708090a0b0c0d0e0f")

unittests/IR/IRBuilderTest.cpp

TEST_F(IRBuilderTest, RAIIHelpersTest) {
   EXPECT_EQ(BB, Builder.GetInsertBlock());
 }
 
 TEST_F(IRBuilderTest, DIBuilder) {
   IRBuilder<> Builder(BB);
   DIBuilder DIB(*M);
   auto File = DIB.createFile("F.CBL", "/");
   auto CU = DIB.createCompileUnit(dwarf::DW_LANG_Cobol74, "F.CBL", "/",
-                                  "llvm-cobol74", true, "", 0);
+                                  DIChecksum::None, "", "llvm-cobol74", true,
+                                  "", 0);
   auto Type = DIB.createSubroutineType(DIB.getOrCreateTypeArray(None));
   auto SP = DIB.createFunction(CU, "foo", "", File, 1, Type, false, true, 1,
                                DINode::FlagZero, true);
   F->setSubprogram(SP);
   AllocaInst *I = Builder.CreateAlloca(Builder.getInt8Ty());
   auto BarSP = DIB.createFunction(CU, "bar", "", File, 1, Type, false, true, 1,
                                   DINode::FlagZero, true);
   auto BadScope = DIB.createLexicalBlockFile(BarSP, File, 0);
TEST_F(IRBuilderTest, DebugLoc) {
   auto CalleeTy = FunctionType::get(Type::getVoidTy(Ctx),
                                     /*isVarArg=*/false);
   auto Callee =
       Function::Create(CalleeTy, Function::ExternalLinkage, "", M.get());
 
   DIBuilder DIB(*M);
   auto File = DIB.createFile("tmp.cpp", "/");
   auto CU = DIB.createCompileUnit(dwarf::DW_LANG_C_plus_plus_11, "tmp.cpp", "/",
-                                  "", true, "", 0);
+                                  DIChecksum::None, "", "", true, "", 0);
   auto SPType = DIB.createSubroutineType(DIB.getOrCreateTypeArray(None));
   auto SP =
       DIB.createFunction(CU, "foo", "foo", File, 1, SPType, false, true, 1);
   DebugLoc DL1 = DILocation::get(Ctx, 2, 0, SP);
   DebugLoc DL2 = DILocation::get(Ctx, 3, 0, SP);
 
   auto BB2 = BasicBlock::Create(Ctx, "bb2", F);
   auto Br = BranchInst::Create(BB2, BB);
TEST_F(IRBuilderTest, DebugLoc) {
 
   DIB.finalize();
 }
 
 TEST_F(IRBuilderTest, DIImportedEntity) {
   IRBuilder<> Builder(BB);
   DIBuilder DIB(*M);
   auto CU = DIB.createCompileUnit(dwarf::DW_LANG_Cobol74, "F.CBL", "/",
-    "llvm-cobol74", true, "", 0);
+                                  DIChecksum::None, "", "llvm-cobol74", true,
+                                  "", 0);
   DIB.createImportedDeclaration(CU, nullptr, 1);
   DIB.createImportedDeclaration(CU, nullptr, 1);
   DIB.createImportedModule(CU, (DIImportedEntity *)nullptr, 2);
   DIB.createImportedModule(CU, (DIImportedEntity *)nullptr, 2);
   DIB.finalize();
   EXPECT_TRUE(verifyModule(*M));
   EXPECT_TRUE(CU->getImportedEntities().size() == 2);
 }
 }

unittests/IR/MetadataTest.cpp

return DISubroutineType::getDistinct(Context, DINode::FlagZero, 0,
                                          getNode(nullptr));
   }
   DISubprogram *getSubprogram() {
     return DISubprogram::getDistinct(Context, nullptr, "", "", nullptr, 0,
                                      nullptr, false, false, 0, nullptr, 0, 0, 0,
                                      DINode::FlagZero, false, nullptr);
   }
   DIFile *getFile() {
-    return DIFile::getDistinct(Context, "file.c", "/path/to/dir");
+    return DIFile::getDistinct(Context, "file.c", "/path/to/dir", nullptr);
   }
   DICompileUnit *getUnit() {
     return DICompileUnit::getDistinct(Context, 1, getFile(), "clang", false,
                                       "-g", 2, "", DICompileUnit::FullDebug,
                                       getTuple(), getTuple(), getTuple(),
                                       getTuple(), getTuple(), 0, true);
   }
   DIType *getBasicType(StringRef Name) {
TEST_F(DISubroutineTypeTest, get) {
   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
 
   // Test always-empty operands.
   EXPECT_EQ(nullptr, N->getScope());
   EXPECT_EQ(nullptr, N->getFile());
   EXPECT_EQ("", N->getName());
 }
 
+typedef MetadataTest DIChecksumTest;
+
+TEST_F(DIChecksumTest, get) {
+  StringRef Checksum = "000102030405060708090a0b0c0d0e0f";
+  auto *N = DIChecksum::get(Context, DIChecksum::MD5, Checksum);
+
+  EXPECT_EQ(DIChecksum::MD5, N->getType());
+  EXPECT_EQ(Checksum, N->getData());
+
+  EXPECT_NE(N, DIChecksum::get(Context, DIChecksum::SHA1, Checksum));
+  EXPECT_NE(N, DIChecksum::get(Context, DIChecksum::MD5, "other"));
+
+  TempDIChecksum Temp = N->clone();
+  EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
+}
+
 typedef MetadataTest DIFileTest;
 
 TEST_F(DIFileTest, get) {
   StringRef Filename = "file";
   StringRef Directory = "dir";
-  auto *N = DIFile::get(Context, Filename, Directory);
+  StringRef Checksum = "000102030405060708090a0b0c0d0e0f";
+  auto *C = DIChecksum::get(Context, DIChecksum::MD5, Checksum);
+  auto *N = DIFile::get(Context, Filename, Directory, C);
 
   EXPECT_EQ(dwarf::DW_TAG_file_type, N->getTag());
   EXPECT_EQ(Filename, N->getFilename());
   EXPECT_EQ(Directory, N->getDirectory());
-  EXPECT_EQ(N, DIFile::get(Context, Filename, Directory));
+  EXPECT_EQ(C, N->getChecksum());
+  EXPECT_EQ(N, DIFile::get(Context, Filename, Directory, C));
 
-  EXPECT_NE(N, DIFile::get(Context, "other", Directory));
-  EXPECT_NE(N, DIFile::get(Context, Filename, "other"));
+  EXPECT_NE(N, DIFile::get(Context, "other", Directory, C));
+  EXPECT_NE(N, DIFile::get(Context, Filename, "other", C));
+  EXPECT_NE(N, DIFile::get(Context, Filename, Directory, nullptr));
 
   TempDIFile Temp = N->clone();
   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
 }
 
 TEST_F(DIFileTest, ScopeGetFile) {
   // Ensure that DIScope::getFile() returns itself.
-  DIScope *N = DIFile::get(Context, "file", "dir");
+  DIScope *N = DIFile::get(Context, "file", "dir", nullptr);
   EXPECT_EQ(N, N->getFile());
 }
 
 typedef MetadataTest DICompileUnitTest;
 
 TEST_F(DICompileUnitTest, get) {
   unsigned SourceLanguage = 1;
   DIFile *File = getFile();

unittests/IR/VerifierTest.cpp

EXPECT_TRUE(
                                           "have external or weak linkage!"));
 }
 
 TEST(VerifierTest, StripInvalidDebugInfo) {
   {
     LLVMContext C;
     Module M("M", C);
     DIBuilder DIB(M);
-    DIB.createCompileUnit(dwarf::DW_LANG_C89, "broken.c", "/", "unittest",
-                          false, "", 0);
+    DIB.createCompileUnit(dwarf::DW_LANG_C89, "broken.c", "/", DIChecksum::None,
+                          "", "unittest", false, "", 0);
     DIB.finalize();
     EXPECT_FALSE(verifyModule(M));
 
     // Now break it by inserting non-CU node to the list of CUs.
     auto *File = DIB.createFile("not-a-CU.f", ".");
     NamedMDNode *NMD = M.getOrInsertNamedMetadata("llvm.dbg.cu");
     NMD->addOperand(File);
     EXPECT_TRUE(verifyModule(M));
 
     ModulePassManager MPM(true);
     MPM.addPass(VerifierPass(false));
     ModuleAnalysisManager MAM(true);
     MAM.registerPass([&] { return VerifierAnalysis(); });
     MPM.run(M, MAM);
     EXPECT_FALSE(verifyModule(M));
   }
   {
     LLVMContext C;
     Module M("M", C);
     DIBuilder DIB(M);
     auto *CU = DIB.createCompileUnit(dwarf::DW_LANG_C89, "broken.c", "/",
-                                     "unittest", false, "", 0);
+                                     DIChecksum::None, "", "unittest", false,
+                                     "", 0);
     new GlobalVariable(M, Type::getInt8Ty(C), false,
                        GlobalValue::ExternalLinkage, nullptr, "g");
 
     auto *F = cast<Function>(M.getOrInsertFunction(
         "f", FunctionType::get(Type::getVoidTy(C), false)));
     IRBuilder<> Builder(BasicBlock::Create(C, "", F));
     Builder.CreateUnreachable();
     F->setSubprogram(DIB.createFunction(CU, "f", "f",
TEST(VerifierTest, StripInvalidDebugInfo) {
     EXPECT_FALSE(verifyModule(M));
   }
 }
 
 TEST(VerifierTest, StripInvalidDebugInfoLegacy) {
   LLVMContext C;
   Module M("M", C);
   DIBuilder DIB(M);
-  DIB.createCompileUnit(dwarf::DW_LANG_C89, "broken.c", "/",
-                        "unittest", false, "", 0);
+  DIB.createCompileUnit(dwarf::DW_LANG_C89, "broken.c", "/", DIChecksum::None,
+                        "", "unittest", false, "", 0);
   DIB.finalize();
   EXPECT_FALSE(verifyModule(M));
 
   // Now break it.
   auto *File = DIB.createFile("not-a-CU.f", ".");
   NamedMDNode *NMD = M.getOrInsertNamedMetadata("llvm.dbg.cu");
   NMD->addOperand(File);
   EXPECT_TRUE(verifyModule(M));

unittests/Transforms/Utils/Cloning.cpp

void CreateOldFunctionBodyAndDI() {
 
     // Function DI
     auto *File = DBuilder.createFile("filename.c", "/file/dir/");
     DITypeRefArray ParamTypes = DBuilder.getOrCreateTypeArray(None);
     DISubroutineType *FuncType =
         DBuilder.createSubroutineType(ParamTypes);
     auto *CU =
         DBuilder.createCompileUnit(dwarf::DW_LANG_C99, "filename.c",
-                                   "/file/dir", "CloneFunc", false, "", 0);
+                                   "/file/dir", DIChecksum::None, "",
+                                   "CloneFunc", false, "", 0);
 
     auto *Subprogram =
         DBuilder.createFunction(CU, "f", "f", File, 4, FuncType, true, true, 3,
                                 DINode::FlagZero, false);
     OldFunc->setSubprogram(Subprogram);
 
     // Function body
     BasicBlock* Entry = BasicBlock::Create(C, "", OldFunc);
void CreateOldFunctionBodyAndDI() {
     DBuilder.insertDbgValueIntrinsic(AllocaContent, 0, Variable, E, DL,
                                      Terminator);
     // Finalize the debug info
     DBuilder.finalize();
 
 
     // Create another, empty, compile unit
     DIBuilder DBuilder2(*M);
-    DBuilder2.createCompileUnit(dwarf::DW_LANG_C99,
-        "extra.c", "/file/dir", "CloneFunc", false, "", 0);
+    DBuilder2.createCompileUnit(dwarf::DW_LANG_C99, "extra.c", "/file/dir",
+                                DIChecksum::None, "", "CloneFunc", false, "",
+                                0);
     DBuilder2.finalize();
   }
 
   void CreateNewFunc() {
     ValueToValueMapTy VMap;
     NewFunc = CloneFunction(OldFunc, VMap, nullptr);
   }
 
void CreateOldModule() {
     auto *F =
         Function::Create(FuncType, GlobalValue::PrivateLinkage, "f", OldM);
     F->setPersonalityFn(PersFn);
 
     // Create debug info
     auto *File = DBuilder.createFile("filename.c", "/file/dir/");
     DITypeRefArray ParamTypes = DBuilder.getOrCreateTypeArray(None);
     DISubroutineType *DFuncType = DBuilder.createSubroutineType(ParamTypes);
-    auto *CU =
-        DBuilder.createCompileUnit(dwarf::DW_LANG_C99, "filename.c",
-                                   "/file/dir", "CloneModule", false, "", 0);
+    auto *CU = DBuilder.createCompileUnit(dwarf::DW_LANG_C99, "filename.c",
+                                          "/file/dir", DIChecksum::None, "",
+                                          "CloneModule", false, "", 0);
     // Function DI
     auto *Subprogram =
         DBuilder.createFunction(CU, "f", "f", File, 4, DFuncType, true, true, 3,
                                 DINode::FlagZero, false);
     F->setSubprogram(Subprogram);
 
     auto *Entry = BasicBlock::Create(C, "", F);
     IBuilder.SetInsertPoint(Entry);