Index: llvm/include/llvm/AsmParser/SlotMapping.h
===================================================================
--- llvm/include/llvm/AsmParser/SlotMapping.h
+++ llvm/include/llvm/AsmParser/SlotMapping.h
@@ -32,7 +32,7 @@
 /// module's source.
 struct SlotMapping {
   std::vector<GlobalValue *> GlobalValues;
-  std::map<unsigned, TrackingMDNodeRef> MetadataNodes;
+  std::map<unsigned, TrackingMDRef> MetadataNodes;
   StringMap<Type *> NamedTypes;
   std::map<unsigned, Type *> Types;
 };
Index: llvm/include/llvm/CodeGen/GlobalISel/MachineIRBuilder.h
===================================================================
--- llvm/include/llvm/CodeGen/GlobalISel/MachineIRBuilder.h
+++ llvm/include/llvm/CodeGen/GlobalISel/MachineIRBuilder.h
@@ -184,26 +184,26 @@
   /// Build and insert a DBG_VALUE instruction expressing the fact that the
   /// associated \p Variable lives in \p Reg (suitably modified by \p Expr).
   MachineInstrBuilder buildDirectDbgValue(unsigned Reg, const MDNode *Variable,
-                                          const MDNode *Expr);
+                                          const Metadata *Expr);
 
   /// Build and insert a DBG_VALUE instruction expressing the fact that the
   /// associated \p Variable lives in memory at \p Reg (suitably modified by \p
   /// Expr).
   MachineInstrBuilder buildIndirectDbgValue(unsigned Reg,
                                             const MDNode *Variable,
-                                            const MDNode *Expr);
+                                            const Metadata *Expr);
 
   /// Build and insert a DBG_VALUE instruction expressing the fact that the
   /// associated \p Variable lives in the stack slot specified by \p FI
   /// (suitably modified by \p Expr).
   MachineInstrBuilder buildFIDbgValue(int FI, const MDNode *Variable,
-                                      const MDNode *Expr);
+                                      const Metadata *Expr);
 
   /// Build and insert a DBG_VALUE instructions specifying that \p Variable is
   /// given by \p C (suitably modified by \p Expr).
   MachineInstrBuilder buildConstDbgValue(const Constant &C,
                                          const MDNode *Variable,
-                                         const MDNode *Expr);
+                                         const Metadata *Expr);
 
   /// Build and insert \p Res<def> = G_FRAME_INDEX \p Idx
   ///
Index: llvm/include/llvm/CodeGen/MachineInstrBuilder.h
===================================================================
--- llvm/include/llvm/CodeGen/MachineInstrBuilder.h
+++ llvm/include/llvm/CodeGen/MachineInstrBuilder.h
@@ -35,7 +35,7 @@
 namespace llvm {
 
 class MCInstrDesc;
-class MDNode;
+class Metadata;
 
 namespace RegState {
 
@@ -211,11 +211,11 @@
     return *this;
   }
 
-  const MachineInstrBuilder &addMetadata(const MDNode *MD) const {
+  const MachineInstrBuilder &addMetadata(const Metadata *MD) const {
     MI->addOperand(*MF, MachineOperand::CreateMetadata(MD));
     assert((MI->isDebugValue() ? static_cast<bool>(MI->getDebugVariable())
                                : true) &&
-           "first MDNode argument of a DBG_VALUE not a variable");
+           "first Metadata argument of a DBG_VALUE not a variable");
     return *this;
   }
 
@@ -402,7 +402,7 @@
 MachineInstrBuilder BuildMI(MachineFunction &MF, const DebugLoc &DL,
                             const MCInstrDesc &MCID, bool IsIndirect,
                             unsigned Reg, const MDNode *Variable,
-                            const MDNode *Expr);
+                            const Metadata *Expr);
 
 /// This version of the builder builds a DBG_VALUE intrinsic
 /// for either a value in a register or a register-indirect
@@ -411,7 +411,7 @@
                             MachineBasicBlock::iterator I, const DebugLoc &DL,
                             const MCInstrDesc &MCID, bool IsIndirect,
                             unsigned Reg, const MDNode *Variable,
-                            const MDNode *Expr);
+                            const Metadata *Expr);
 
 /// Clone a DBG_VALUE whose value has been spilled to FrameIndex.
 MachineInstr *buildDbgValueForSpill(MachineBasicBlock &BB,
Index: llvm/include/llvm/CodeGen/MachineOperand.h
===================================================================
--- llvm/include/llvm/CodeGen/MachineOperand.h
+++ llvm/include/llvm/CodeGen/MachineOperand.h
@@ -27,7 +27,7 @@
 class MachineBasicBlock;
 class MachineInstr;
 class MachineRegisterInfo;
-class MDNode;
+class Metadata;
 class ModuleSlotTracker;
 class TargetMachine;
 class TargetIntrinsicInfo;
@@ -161,7 +161,7 @@
     const ConstantInt *CI;   // For MO_CImmediate. Integers > 64bit.
     int64_t ImmVal;          // For MO_Immediate.
     const uint32_t *RegMask; // For MO_RegisterMask and MO_RegisterLiveOut.
-    const MDNode *MD;        // For MO_Metadata.
+    const Metadata *MD;      // For MO_Metadata.
     MCSymbol *Sym;           // For MO_MCSymbol.
     unsigned CFIIndex;       // For MO_CFI.
     Intrinsic::ID IntrinsicID; // For MO_IntrinsicID.
@@ -516,7 +516,7 @@
     return Contents.RegMask;
   }
 
-  const MDNode *getMetadata() const {
+  const Metadata *getMetadata() const {
     assert(isMetadata() && "Wrong MachineOperand accessor");
     return Contents.MD;
   }
@@ -549,7 +549,7 @@
     Contents.OffsetedInfo.Val.Index = Idx;
   }
 
-  void setMetadata(const MDNode *MD) {
+  void setMetadata(const Metadata *MD) {
     assert(isMetadata() && "Wrong MachineOperand mutator");
     Contents.MD = MD;
   }
@@ -743,7 +743,7 @@
     Op.Contents.RegMask = Mask;
     return Op;
   }
-  static MachineOperand CreateMetadata(const MDNode *Meta) {
+  static MachineOperand CreateMetadata(const Metadata *Meta) {
     MachineOperand Op(MachineOperand::MO_Metadata);
     Op.Contents.MD = Meta;
     return Op;
Index: llvm/include/llvm/IR/DebugInfoMetadata.h
===================================================================
--- llvm/include/llvm/IR/DebugInfoMetadata.h
+++ llvm/include/llvm/IR/DebugInfoMetadata.h
@@ -16,6 +16,7 @@
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/BitmaskEnum.h"
+#include "llvm/ADT/FoldingSet.h"
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
@@ -2118,31 +2119,18 @@
 /// DW_OP_stack_value) is the constant variable value.
 ///
 /// TODO: Co-allocate the expression elements.
-/// TODO: Separate from MDNode, or otherwise drop Distinct and Temporary
-/// storage types.
-class DIExpression : public MDNode {
+class DIExpression : public Metadata, public FoldingSetNode {
   friend class LLVMContextImpl;
-  friend class MDNode;
 
   std::vector<uint64_t> Elements;
 
-  DIExpression(LLVMContext &C, StorageType Storage, ArrayRef<uint64_t> Elements)
-      : MDNode(C, DIExpressionKind, Storage, None),
+  DIExpression(ArrayRef<uint64_t> Elements)
+      : Metadata(DIExpressionKind, Uniqued),
         Elements(Elements.begin(), Elements.end()) {}
   ~DIExpression() = default;
 
-  static DIExpression *getImpl(LLVMContext &Context,
-                               ArrayRef<uint64_t> Elements, StorageType Storage,
-                               bool ShouldCreate = true);
-
-  TempDIExpression cloneImpl() const {
-    return getTemporary(getContext(), getElements());
-  }
-
 public:
-  DEFINE_MDNODE_GET(DIExpression, (ArrayRef<uint64_t> Elements), (Elements))
-
-  TempDIExpression clone() const { return cloneImpl(); }
+  static DIExpression *get(LLVMContext &Context, ArrayRef<uint64_t> Elements);
 
   ArrayRef<uint64_t> getElements() const { return Elements; }
 
@@ -2291,8 +2279,11 @@
 
   /// Prepend \p DIExpr with a deref and offset operation and optionally turn it
   /// into a stack value.
-  static DIExpression *prepend(const DIExpression *DIExpr, bool Deref,
-                               int64_t Offset = 0, bool StackValue = false);
+  static DIExpression *prepend(LLVMContext &C, const DIExpression *DIExpr,
+                               bool Deref, int64_t Offset = 0,
+                               bool StackValue = false);
+
+  void Profile(FoldingSetNodeID &ID) const;
 };
 
 /// Global variables.
Index: llvm/include/llvm/IR/Metadata.def
===================================================================
--- llvm/include/llvm/IR/Metadata.def
+++ llvm/include/llvm/IR/Metadata.def
@@ -74,6 +74,7 @@
 #endif
 
 HANDLE_METADATA_LEAF(MDString)
+HANDLE_METADATA_LEAF(DIExpression)
 HANDLE_METADATA_BRANCH(ValueAsMetadata)
 HANDLE_METADATA_LEAF(ConstantAsMetadata)
 HANDLE_METADATA_LEAF(LocalAsMetadata)
@@ -81,7 +82,6 @@
 HANDLE_MDNODE_BRANCH(MDNode)
 HANDLE_MDNODE_LEAF_UNIQUABLE(MDTuple)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DILocation)
-HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIExpression)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIGlobalVariableExpression)
 HANDLE_SPECIALIZED_MDNODE_BRANCH(DINode)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(GenericDINode)
Index: llvm/lib/AsmParser/LLParser.h
===================================================================
--- llvm/lib/AsmParser/LLParser.h
+++ llvm/lib/AsmParser/LLParser.h
@@ -115,7 +115,7 @@
     StringMap<std::pair<Type*, LocTy> > NamedTypes;
     std::map<unsigned, std::pair<Type*, LocTy> > NumberedTypes;
 
-    std::map<unsigned, TrackingMDNodeRef> NumberedMetadata;
+    std::map<unsigned, TrackingMDRef> NumberedMetadata;
     std::map<unsigned, std::pair<TempMDTuple, LocTy>> ForwardRefMDNodes;
 
     // Global Value reference information.
@@ -291,7 +291,8 @@
     bool ParseStandaloneMetadata();
     bool ParseNamedMetadata();
     bool ParseMDString(MDString *&Result);
-    bool ParseMDNodeID(MDNode *&Result);
+    bool ParseDIExpression(Metadata *&Result);
+    bool ParseMDNodeID(Metadata *&Result);
     bool ParseUnnamedAttrGrp();
     bool ParseFnAttributeValuePairs(AttrBuilder &B,
                                     std::vector<unsigned> &FwdRefAttrGrps,
@@ -425,9 +426,9 @@
     bool ParseValueAsMetadata(Metadata *&MD, const Twine &TypeMsg,
                               PerFunctionState *PFS);
     bool ParseMetadata(Metadata *&MD, PerFunctionState *PFS);
-    bool ParseMDTuple(MDNode *&MD, bool IsDistinct = false);
-    bool ParseMDNode(MDNode *&MD);
-    bool ParseMDNodeTail(MDNode *&MD);
+    bool ParseMDTuple(Metadata *&MD, bool IsDistinct = false);
+    bool ParseMDNode(Metadata *&MD);
+    bool ParseMDNodeTail(Metadata *&MD);
     bool ParseMDNodeVector(SmallVectorImpl<Metadata *> &MDs);
     bool ParseMetadataAttachment(unsigned &Kind, MDNode *&MD);
     bool ParseInstructionMetadata(Instruction &Inst);
@@ -441,10 +442,10 @@
     bool ParseMDFieldsImplBody(ParserTy parseField);
     template <class ParserTy>
     bool ParseMDFieldsImpl(ParserTy parseField, LocTy &ClosingLoc);
-    bool ParseSpecializedMDNode(MDNode *&N, bool IsDistinct = false);
+    bool ParseSpecializedMDNode(Metadata *&N, bool IsDistinct = false);
 
 #define HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS)                                  \
-  bool Parse##CLASS(MDNode *&Result, bool IsDistinct);
+  bool Parse##CLASS(Metadata *&Result, bool IsDistinct);
 #include "llvm/IR/Metadata.def"
 
     // Function Parsing.
Index: llvm/lib/AsmParser/LLParser.cpp
===================================================================
--- llvm/lib/AsmParser/LLParser.cpp
+++ llvm/lib/AsmParser/LLParser.cpp
@@ -210,8 +210,9 @@
 
   // Resolve metadata cycles.
   for (auto &N : NumberedMetadata) {
-    if (N.second && !N.second->isResolved())
-      N.second->resolveCycles();
+    MDNode *MD = dyn_cast_or_null<MDNode>(N.second);
+    if (MD && !MD->isResolved())
+      MD->resolveCycles();
   }
 
   for (auto *Inst : InstsWithTBAATag) {
@@ -606,7 +607,7 @@
 
 // MDNode:
 //   ::= '!' MDNodeNumber
-bool LLParser::ParseMDNodeID(MDNode *&Result) {
+bool LLParser::ParseMDNodeID(Metadata *&Result) {
   // !{ ..., !42, ... }
   LocTy IDLoc = Lex.getLoc();
   unsigned MID = 0;
@@ -615,7 +616,7 @@
 
   // If not a forward reference, just return it now.
   if (NumberedMetadata.count(MID)) {
-    Result = NumberedMetadata[MID];
+    Result = NumberedMetadata[MID].get();
     return false;
   }
 
@@ -643,19 +644,17 @@
   NamedMDNode *NMD = M->getOrInsertNamedMetadata(Name);
   if (Lex.getKind() != lltok::rbrace)
     do {
-      MDNode *N = nullptr;
-      // Parse DIExpressions inline as a special case. They are still MDNodes,
-      // so they can still appear in named metadata. Remove this logic if they
-      // become plain Metadata.
-      if (Lex.getKind() == lltok::MetadataVar &&
-          Lex.getStrVal() == "DIExpression") {
-        if (ParseDIExpression(N, /*IsDistinct=*/false))
-          return true;
-      } else if (ParseToken(lltok::exclaim, "Expected '!' here") ||
-                 ParseMDNodeID(N)) {
+      if (ParseToken(lltok::exclaim, "Expected '!' here"))
         return true;
-      }
-      NMD->addOperand(N);
+
+      Metadata *N = nullptr;
+      if (ParseMDNodeID(N))
+        return true;
+      MDNode *MD = dyn_cast<MDNode>(N);
+      if (!MD)
+        return TokError(
+            "only other metadata nodes can appear in named metadata");
+      NMD->addOperand(MD);
     } while (EatIfPresent(lltok::comma));
 
   return ParseToken(lltok::rbrace, "expected end of metadata node");
@@ -668,7 +667,7 @@
   Lex.Lex();
   unsigned MetadataID = 0;
 
-  MDNode *Init;
+  Metadata *Init;
   if (ParseUInt32(MetadataID) ||
       ParseToken(lltok::equal, "expected '=' here"))
     return true;
@@ -679,8 +678,12 @@
 
   bool IsDistinct = EatIfPresent(lltok::kw_distinct);
   if (Lex.getKind() == lltok::MetadataVar) {
-    if (ParseSpecializedMDNode(Init, IsDistinct))
+    if (Lex.getStrVal() == "DIExpression") {
+      if (ParseDIExpression(Init))
+        return true;
+    } else if (ParseSpecializedMDNode(Init, IsDistinct)) {
       return true;
+    }
   } else if (ParseToken(lltok::exclaim, "Expected '!' here") ||
              ParseMDTuple(Init, IsDistinct))
     return true;
@@ -1758,7 +1761,13 @@
   Kind = M->getMDKindID(Name);
   Lex.Lex();
 
-  return ParseMDNode(MD);
+  Metadata *N;
+  if (ParseMDNode(N))
+    return true;
+  MD = dyn_cast<MDNode>(N);
+  if (!MD)
+    return TokError("expected metadata node for attachment");
+  return false;
 }
 
 /// ParseInstructionMetadata
@@ -1789,7 +1798,6 @@
   MDNode *N;
   if (ParseMetadataAttachment(MDK, N))
     return true;
-
   GO.addMetadata(MDK, *N);
   return false;
 }
@@ -3392,7 +3400,7 @@
   return false;
 }
 
-bool LLParser::ParseMDTuple(MDNode *&MD, bool IsDistinct) {
+bool LLParser::ParseMDTuple(Metadata *&MD, bool IsDistinct) {
   SmallVector<Metadata *, 16> Elts;
   if (ParseMDNodeVector(Elts))
     return true;
@@ -3405,15 +3413,18 @@
 ///  ::= !{ ... }
 ///  ::= !7
 ///  ::= !DILocation(...)
-bool LLParser::ParseMDNode(MDNode *&N) {
-  if (Lex.getKind() == lltok::MetadataVar)
+bool LLParser::ParseMDNode(Metadata *&N) {
+  if (Lex.getKind() == lltok::MetadataVar) {
+    if (Lex.getStrVal() == "DIExpression")
+      return ParseDIExpression(N);
     return ParseSpecializedMDNode(N);
+  }
 
   return ParseToken(lltok::exclaim, "expected '!' here") ||
          ParseMDNodeTail(N);
 }
 
-bool LLParser::ParseMDNodeTail(MDNode *&N) {
+bool LLParser::ParseMDNodeTail(Metadata *&N) {
   // !{ ... }
   if (Lex.getKind() == lltok::lbrace)
     return ParseMDTuple(N);
@@ -3860,9 +3871,12 @@
   return ParseMDField(Loc, Name, Result);
 }
 
-bool LLParser::ParseSpecializedMDNode(MDNode *&N, bool IsDistinct) {
+bool LLParser::ParseSpecializedMDNode(Metadata *&N, bool IsDistinct) {
   assert(Lex.getKind() == lltok::MetadataVar && "Expected metadata type name");
 
+  if (Lex.getStrVal() == "DIExpression")
+    return ParseDIExpression(N);
+
 #define HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS)                                  \
   if (Lex.getStrVal() == #CLASS)                                               \
     return Parse##CLASS(N, IsDistinct);
@@ -3895,7 +3909,7 @@
 
 /// ParseDILocationFields:
 ///   ::= !DILocation(line: 43, column: 8, scope: !5, inlinedAt: !6)
-bool LLParser::ParseDILocation(MDNode *&Result, bool IsDistinct) {
+bool LLParser::ParseDILocation(Metadata *&Result, bool IsDistinct) {
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   OPTIONAL(line, LineField, );                                                 \
   OPTIONAL(column, ColumnField, );                                             \
@@ -3911,7 +3925,7 @@
 
 /// ParseGenericDINode:
 ///   ::= !GenericDINode(tag: 15, header: "...", operands: {...})
-bool LLParser::ParseGenericDINode(MDNode *&Result, bool IsDistinct) {
+bool LLParser::ParseGenericDINode(Metadata *&Result, bool IsDistinct) {
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   REQUIRED(tag, DwarfTagField, );                                              \
   OPTIONAL(header, MDStringField, );                                           \
@@ -3926,7 +3940,7 @@
 
 /// ParseDISubrange:
 ///   ::= !DISubrange(count: 30, lowerBound: 2)
-bool LLParser::ParseDISubrange(MDNode *&Result, bool IsDistinct) {
+bool LLParser::ParseDISubrange(Metadata *&Result, bool IsDistinct) {
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   REQUIRED(count, MDSignedField, (-1, -1, INT64_MAX));                         \
   OPTIONAL(lowerBound, MDSignedField, );
@@ -3939,7 +3953,7 @@
 
 /// ParseDIEnumerator:
 ///   ::= !DIEnumerator(value: 30, name: "SomeKind")
-bool LLParser::ParseDIEnumerator(MDNode *&Result, bool IsDistinct) {
+bool LLParser::ParseDIEnumerator(Metadata *&Result, bool IsDistinct) {
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   REQUIRED(name, MDStringField, );                                             \
   REQUIRED(value, MDSignedField, );
@@ -3952,7 +3966,7 @@
 
 /// ParseDIBasicType:
 ///   ::= !DIBasicType(tag: DW_TAG_base_type, name: "int", size: 32, align: 32)
-bool LLParser::ParseDIBasicType(MDNode *&Result, bool IsDistinct) {
+bool LLParser::ParseDIBasicType(Metadata *&Result, bool IsDistinct) {
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   OPTIONAL(tag, DwarfTagField, (dwarf::DW_TAG_base_type));                     \
   OPTIONAL(name, MDStringField, );                                             \
@@ -3972,7 +3986,7 @@
 ///                      line: 7, scope: !1, baseType: !2, size: 32,
 ///                      align: 32, offset: 0, flags: 0, extraData: !3,
 ///                      dwarfAddressSpace: 3)
-bool LLParser::ParseDIDerivedType(MDNode *&Result, bool IsDistinct) {
+bool LLParser::ParseDIDerivedType(Metadata *&Result, bool IsDistinct) {
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   REQUIRED(tag, DwarfTagField, );                                              \
   OPTIONAL(name, MDStringField, );                                             \
@@ -4001,7 +4015,7 @@
   return false;
 }
 
-bool LLParser::ParseDICompositeType(MDNode *&Result, bool IsDistinct) {
+bool LLParser::ParseDICompositeType(Metadata *&Result, bool IsDistinct) {
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   REQUIRED(tag, DwarfTagField, );                                              \
   OPTIONAL(name, MDStringField, );                                             \
@@ -4042,7 +4056,7 @@
   return false;
 }
 
-bool LLParser::ParseDISubroutineType(MDNode *&Result, bool IsDistinct) {
+bool LLParser::ParseDISubroutineType(Metadata *&Result, bool IsDistinct) {
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   OPTIONAL(flags, DIFlagField, );                                              \
   OPTIONAL(cc, DwarfCCField, );                                                \
@@ -4059,7 +4073,7 @@
 ///   ::= !DIFileType(filename: "path/to/file", directory: "/path/to/dir"
 ///                   checksumkind: CSK_MD5,
 ///                   checksum: "000102030405060708090a0b0c0d0e0f")
-bool LLParser::ParseDIFile(MDNode *&Result, bool IsDistinct) {
+bool LLParser::ParseDIFile(Metadata *&Result, bool IsDistinct) {
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   REQUIRED(filename, MDStringField, );                                         \
   REQUIRED(directory, MDStringField, );                                        \
@@ -4079,7 +4093,7 @@
 ///                      splitDebugFilename: "abc.debug",
 ///                      emissionKind: FullDebug, enums: !1, retainedTypes: !2,
 ///                      globals: !4, imports: !5, macros: !6, dwoId: 0x0abcd)
-bool LLParser::ParseDICompileUnit(MDNode *&Result, bool IsDistinct) {
+bool LLParser::ParseDICompileUnit(Metadata *&Result, bool IsDistinct) {
   if (!IsDistinct)
     return Lex.Error("missing 'distinct', required for !DICompileUnit");
 
@@ -4119,7 +4133,7 @@
 ///                     virtualIndex: 10, thisAdjustment: 4, flags: 11,
 ///                     isOptimized: false, templateParams: !4, declaration: !5,
 ///                     variables: !6, thrownTypes: !7)
-bool LLParser::ParseDISubprogram(MDNode *&Result, bool IsDistinct) {
+bool LLParser::ParseDISubprogram(Metadata *&Result, bool IsDistinct) {
   auto Loc = Lex.getLoc();
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   OPTIONAL(scope, MDField, );                                                  \
@@ -4162,7 +4176,7 @@
 
 /// ParseDILexicalBlock:
 ///   ::= !DILexicalBlock(scope: !0, file: !2, line: 7, column: 9)
-bool LLParser::ParseDILexicalBlock(MDNode *&Result, bool IsDistinct) {
+bool LLParser::ParseDILexicalBlock(Metadata *&Result, bool IsDistinct) {
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   REQUIRED(scope, MDField, (/* AllowNull */ false));                           \
   OPTIONAL(file, MDField, );                                                   \
@@ -4178,7 +4192,7 @@
 
 /// ParseDILexicalBlockFile:
 ///   ::= !DILexicalBlockFile(scope: !0, file: !2, discriminator: 9)
-bool LLParser::ParseDILexicalBlockFile(MDNode *&Result, bool IsDistinct) {
+bool LLParser::ParseDILexicalBlockFile(Metadata *&Result, bool IsDistinct) {
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   REQUIRED(scope, MDField, (/* AllowNull */ false));                           \
   OPTIONAL(file, MDField, );                                                   \
@@ -4193,7 +4207,7 @@
 
 /// ParseDINamespace:
 ///   ::= !DINamespace(scope: !0, file: !2, name: "SomeNamespace", line: 9)
-bool LLParser::ParseDINamespace(MDNode *&Result, bool IsDistinct) {
+bool LLParser::ParseDINamespace(Metadata *&Result, bool IsDistinct) {
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   REQUIRED(scope, MDField, );                                                  \
   OPTIONAL(name, MDStringField, );                                             \
@@ -4208,7 +4222,7 @@
 
 /// ParseDIMacro:
 ///   ::= !DIMacro(macinfo: type, line: 9, name: "SomeMacro", value: "SomeValue")
-bool LLParser::ParseDIMacro(MDNode *&Result, bool IsDistinct) {
+bool LLParser::ParseDIMacro(Metadata *&Result, bool IsDistinct) {
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   REQUIRED(type, DwarfMacinfoTypeField, );                                     \
   OPTIONAL(line, LineField, );                                                 \
@@ -4224,7 +4238,7 @@
 
 /// ParseDIMacroFile:
 ///   ::= !DIMacroFile(line: 9, file: !2, nodes: !3)
-bool LLParser::ParseDIMacroFile(MDNode *&Result, bool IsDistinct) {
+bool LLParser::ParseDIMacroFile(Metadata *&Result, bool IsDistinct) {
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   OPTIONAL(type, DwarfMacinfoTypeField, (dwarf::DW_MACINFO_start_file));       \
   OPTIONAL(line, LineField, );                                                 \
@@ -4241,7 +4255,7 @@
 /// ParseDIModule:
 ///   ::= !DIModule(scope: !0, name: "SomeModule", configMacros: "-DNDEBUG",
 ///                 includePath: "/usr/include", isysroot: "/")
-bool LLParser::ParseDIModule(MDNode *&Result, bool IsDistinct) {
+bool LLParser::ParseDIModule(Metadata *&Result, bool IsDistinct) {
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   REQUIRED(scope, MDField, );                                                  \
   REQUIRED(name, MDStringField, );                                             \
@@ -4258,7 +4272,7 @@
 
 /// ParseDITemplateTypeParameter:
 ///   ::= !DITemplateTypeParameter(name: "Ty", type: !1)
-bool LLParser::ParseDITemplateTypeParameter(MDNode *&Result, bool IsDistinct) {
+bool LLParser::ParseDITemplateTypeParameter(Metadata *&Result, bool IsDistinct) {
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   OPTIONAL(name, MDStringField, );                                             \
   REQUIRED(type, MDField, );
@@ -4273,7 +4287,7 @@
 /// ParseDITemplateValueParameter:
 ///   ::= !DITemplateValueParameter(tag: DW_TAG_template_value_parameter,
 ///                                 name: "V", type: !1, value: i32 7)
-bool LLParser::ParseDITemplateValueParameter(MDNode *&Result, bool IsDistinct) {
+bool LLParser::ParseDITemplateValueParameter(Metadata *&Result, bool IsDistinct) {
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   OPTIONAL(tag, DwarfTagField, (dwarf::DW_TAG_template_value_parameter));      \
   OPTIONAL(name, MDStringField, );                                             \
@@ -4291,7 +4305,7 @@
 ///   ::= !DIGlobalVariable(scope: !0, name: "foo", linkageName: "foo",
 ///                         file: !1, line: 7, type: !2, isLocal: false,
 ///                         isDefinition: true, declaration: !3, align: 8)
-bool LLParser::ParseDIGlobalVariable(MDNode *&Result, bool IsDistinct) {
+bool LLParser::ParseDIGlobalVariable(Metadata *&Result, bool IsDistinct) {
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   REQUIRED(name, MDStringField, (/* AllowEmpty */ false));                     \
   OPTIONAL(scope, MDField, );                                                  \
@@ -4320,7 +4334,7 @@
 ///   ::= !DILocalVariable(scope: !0, name: "foo",
 ///                        file: !1, line: 7, type: !2, arg: 2, flags: 7,
 ///                        align: 8)
-bool LLParser::ParseDILocalVariable(MDNode *&Result, bool IsDistinct) {
+bool LLParser::ParseDILocalVariable(Metadata *&Result, bool IsDistinct) {
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   REQUIRED(scope, MDField, (/* AllowNull */ false));                           \
   OPTIONAL(name, MDStringField, );                                             \
@@ -4341,7 +4355,7 @@
 
 /// ParseDIExpression:
 ///   ::= !DIExpression(0, 7, -1)
-bool LLParser::ParseDIExpression(MDNode *&Result, bool IsDistinct) {
+bool LLParser::ParseDIExpression(Metadata *&Result) {
   assert(Lex.getKind() == lltok::MetadataVar && "Expected metadata type name");
   Lex.Lex();
 
@@ -4373,13 +4387,13 @@
   if (ParseToken(lltok::rparen, "expected ')' here"))
     return true;
 
-  Result = GET_OR_DISTINCT(DIExpression, (Context, Elements));
+  Result = DIExpression::get(Context, Elements);
   return false;
 }
 
 /// ParseDIGlobalVariableExpression:
 ///   ::= !DIGlobalVariableExpression(var: !0, expr: !1)
-bool LLParser::ParseDIGlobalVariableExpression(MDNode *&Result,
+bool LLParser::ParseDIGlobalVariableExpression(Metadata *&Result,
                                                bool IsDistinct) {
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   REQUIRED(var, MDField, );                                                    \
@@ -4395,7 +4409,7 @@
 /// ParseDIObjCProperty:
 ///   ::= !DIObjCProperty(name: "foo", file: !1, line: 7, setter: "setFoo",
 ///                       getter: "getFoo", attributes: 7, type: !2)
-bool LLParser::ParseDIObjCProperty(MDNode *&Result, bool IsDistinct) {
+bool LLParser::ParseDIObjCProperty(Metadata *&Result, bool IsDistinct) {
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   OPTIONAL(name, MDStringField, );                                             \
   OPTIONAL(file, MDField, );                                                   \
@@ -4416,7 +4430,7 @@
 /// ParseDIImportedEntity:
 ///   ::= !DIImportedEntity(tag: DW_TAG_imported_module, scope: !0, entity: !1,
 ///                         line: 7, name: "foo")
-bool LLParser::ParseDIImportedEntity(MDNode *&Result, bool IsDistinct) {
+bool LLParser::ParseDIImportedEntity(Metadata *&Result, bool IsDistinct) {
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   REQUIRED(tag, DwarfTagField, );                                              \
   REQUIRED(scope, MDField, );                                                  \
@@ -4485,13 +4499,8 @@
 ///  ::= !"string"
 ///  ::= !DILocation(...)
 bool LLParser::ParseMetadata(Metadata *&MD, PerFunctionState *PFS) {
-  if (Lex.getKind() == lltok::MetadataVar) {
-    MDNode *N;
-    if (ParseSpecializedMDNode(N))
-      return true;
-    MD = N;
-    return false;
-  }
+  if (Lex.getKind() == lltok::MetadataVar)
+    return ParseSpecializedMDNode(MD);
 
   // ValueAsMetadata:
   // <type> <value>
@@ -4515,11 +4524,7 @@
   // MDNode:
   // !{ ... }
   // !7
-  MDNode *N;
-  if (ParseMDNodeTail(N))
-    return true;
-  MD = N;
-  return false;
+  return ParseMDNodeTail(MD);
 }
 
 //===----------------------------------------------------------------------===//
Index: llvm/lib/Bitcode/Reader/MetadataLoader.cpp
===================================================================
--- llvm/lib/Bitcode/Reader/MetadataLoader.cpp
+++ llvm/lib/Bitcode/Reader/MetadataLoader.cpp
@@ -1638,8 +1638,8 @@
     if (Error Err = upgradeDIExpression(Version, Elts, Buffer))
       return Err;
 
-    MetadataList.assignValue(
-        GET_OR_DISTINCT(DIExpression, (Context, Elts)), NextMetadataNo);
+    // FIXME: Wut.
+    MetadataList.assignValue(DIExpression::get(Context, Elts), NextMetadataNo);
     NextMetadataNo++;
     break;
   }
Index: llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
===================================================================
--- llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
+++ llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
@@ -1701,7 +1701,9 @@
                                             unsigned Abbrev) {
   Record.reserve(N->getElements().size() + 1);
   const uint64_t Version = 3 << 1;
-  Record.push_back((uint64_t)N->isDistinct() | Version);
+  // Previously isDistinct occupied bit 0, but now it is always zero to indicate
+  // that DIExpressions are always uniqued and never distinct.
+  Record.push_back(Version);
   Record.append(N->elements_begin(), N->elements_end());
 
   Stream.EmitRecord(bitc::METADATA_EXPRESSION, Record, Abbrev);
@@ -1826,6 +1828,7 @@
 enum MetadataAbbrev : unsigned {
 #define HANDLE_MDNODE_LEAF(CLASS) CLASS##AbbrevID,
 #include "llvm/IR/Metadata.def"
+  DIExpressionAbbrevID,
   LastPlusOne
 };
 
@@ -1858,8 +1861,16 @@
     continue;
 #include "llvm/IR/Metadata.def"
       }
+    } else if (const DIExpression *Exp = dyn_cast<DIExpression>(MD)) {
+      if (MDAbbrevs)
+        writeDIExpression(Exp, Record,
+                          (*MDAbbrevs)[MetadataAbbrev::DIExpressionAbbrevID]);
+      else
+        writeDIExpression(Exp, Record, 0);
+      continue;
+    } else if (const ValueAsMetadata *VMD = dyn_cast<ValueAsMetadata>(MD)) {
+      writeValueAsMetadata(VMD, Record);
     }
-    writeValueAsMetadata(cast<ValueAsMetadata>(MD), Record);
   }
 }
 
Index: llvm/lib/Bitcode/Writer/ValueEnumerator.cpp
===================================================================
--- llvm/lib/Bitcode/Writer/ValueEnumerator.cpp
+++ llvm/lib/Bitcode/Writer/ValueEnumerator.cpp
@@ -634,9 +634,9 @@
   if (!MD)
     return nullptr;
 
-  assert(
-      (isa<MDNode>(MD) || isa<MDString>(MD) || isa<ConstantAsMetadata>(MD)) &&
-      "Invalid metadata kind");
+  assert((isa<MDNode>(MD) || isa<MDString>(MD) || isa<ConstantAsMetadata>(MD) ||
+          isa<DIExpression>(MD)) &&
+         "Invalid metadata kind");
 
   auto Insertion = MetadataMap.insert(std::make_pair(MD, MDIndex(F)));
   MDIndex &Entry = Insertion.first->second;
Index: llvm/lib/CodeGen/AsmPrinter/AsmPrinterInlineAsm.cpp
===================================================================
--- llvm/lib/CodeGen/AsmPrinter/AsmPrinterInlineAsm.cpp
+++ llvm/lib/CodeGen/AsmPrinter/AsmPrinterInlineAsm.cpp
@@ -484,8 +484,9 @@
   unsigned LocCookie = 0;
   const MDNode *LocMD = nullptr;
   for (unsigned i = MI->getNumOperands(); i != 0; --i) {
-    if (MI->getOperand(i-1).isMetadata() &&
-        (LocMD = MI->getOperand(i-1).getMetadata()) &&
+    if (MI->getOperand(i - 1).isMetadata() &&
+        (LocMD =
+             dyn_cast_or_null<MDNode>(MI->getOperand(i - 1).getMetadata())) &&
         LocMD->getNumOperands() != 0) {
       if (const ConstantInt *CI =
               mdconst::dyn_extract<ConstantInt>(LocMD->getOperand(0))) {
Index: llvm/lib/CodeGen/GlobalISel/MachineIRBuilder.cpp
===================================================================
--- llvm/lib/CodeGen/GlobalISel/MachineIRBuilder.cpp
+++ llvm/lib/CodeGen/GlobalISel/MachineIRBuilder.cpp
@@ -85,7 +85,7 @@
 
 MachineInstrBuilder
 MachineIRBuilder::buildDirectDbgValue(unsigned Reg, const MDNode *Variable,
-                                      const MDNode *Expr) {
+                                      const Metadata *Expr) {
   assert(isa<DILocalVariable>(Variable) && "not a variable");
   assert(cast<DIExpression>(Expr)->isValid() && "not an expression");
   assert(cast<DILocalVariable>(Variable)->isValidLocationForIntrinsic(DL) &&
@@ -96,7 +96,7 @@
 
 MachineInstrBuilder
 MachineIRBuilder::buildIndirectDbgValue(unsigned Reg, const MDNode *Variable,
-                                        const MDNode *Expr) {
+                                        const Metadata *Expr) {
   assert(isa<DILocalVariable>(Variable) && "not a variable");
   assert(cast<DIExpression>(Expr)->isValid() && "not an expression");
   assert(cast<DILocalVariable>(Variable)->isValidLocationForIntrinsic(DL) &&
@@ -107,7 +107,7 @@
 
 MachineInstrBuilder MachineIRBuilder::buildFIDbgValue(int FI,
                                                       const MDNode *Variable,
-                                                      const MDNode *Expr) {
+                                                      const Metadata *Expr) {
   assert(isa<DILocalVariable>(Variable) && "not a variable");
   assert(cast<DIExpression>(Expr)->isValid() && "not an expression");
   assert(cast<DILocalVariable>(Variable)->isValidLocationForIntrinsic(DL) &&
@@ -121,7 +121,7 @@
 
 MachineInstrBuilder MachineIRBuilder::buildConstDbgValue(const Constant &C,
                                                          const MDNode *Variable,
-                                                         const MDNode *Expr) {
+                                                         const Metadata *Expr) {
   assert(isa<DILocalVariable>(Variable) && "not a variable");
   assert(cast<DIExpression>(Expr)->isValid() && "not an expression");
   assert(cast<DILocalVariable>(Variable)->isValidLocationForIntrinsic(DL) &&
Index: llvm/lib/CodeGen/LiveDebugValues.cpp
===================================================================
--- llvm/lib/CodeGen/LiveDebugValues.cpp
+++ llvm/lib/CodeGen/LiveDebugValues.cpp
@@ -467,7 +467,8 @@
       int SpillOffset = extractSpillBaseRegAndOffset(MI, SpillBase);
       const MachineInstr *DMI = &VarLocIDs[ID].MI;
       auto *SpillExpr = DIExpression::prepend(
-          DMI->getDebugExpression(), DIExpression::NoDeref, SpillOffset);
+          DMI->getDebugVariable()->getContext(), DMI->getDebugExpression(),
+          DIExpression::NoDeref, SpillOffset);
       MachineInstr *SpDMI =
           BuildMI(*MF, DMI->getDebugLoc(), DMI->getDesc(), true, SpillBase,
                   DMI->getDebugVariable(), SpillExpr);
Index: llvm/lib/CodeGen/LiveDebugVariables.cpp
===================================================================
--- llvm/lib/CodeGen/LiveDebugVariables.cpp
+++ llvm/lib/CodeGen/LiveDebugVariables.cpp
@@ -109,7 +109,7 @@
 /// closure of that relation.
 class UserValue {
   const MDNode *Variable;   ///< The debug info variable we are part of.
-  const MDNode *Expression; ///< Any complex address expression.
+  const DIExpression *Expression; ///< Any complex address expression.
   bool IsIndirect;        ///< true if this is a register-indirect+offset value.
   DebugLoc dl;            ///< The debug location for the variable. This is
                           ///< used by dwarf writer to find lexical scope.
@@ -142,7 +142,7 @@
 
 public:
   /// UserValue - Create a new UserValue.
-  UserValue(const MDNode *var, const MDNode *expr, bool i, DebugLoc L,
+  UserValue(const MDNode *var, const DIExpression *expr, bool i, DebugLoc L,
             LocMap::Allocator &alloc)
       : Variable(var), Expression(expr), IsIndirect(i), dl(std::move(L)),
         leader(this), locInts(alloc) {}
@@ -159,7 +159,7 @@
   UserValue *getNext() const { return next; }
 
   /// match - Does this UserValue match the parameters?
-  bool match(const MDNode *Var, const MDNode *Expr, const DILocation *IA,
+  bool match(const MDNode *Var, const DIExpression *Expr, const DILocation *IA,
              bool indirect) const {
     return Var == Variable && Expr == Expression && dl->getInlinedAt() == IA &&
            indirect == IsIndirect;
@@ -301,7 +301,7 @@
   UVMap userVarMap;
 
   /// getUserValue - Find or create a UserValue.
-  UserValue *getUserValue(const MDNode *Var, const MDNode *Expr,
+  UserValue *getUserValue(const MDNode *Var, const DIExpression *Expr,
                           bool IsIndirect, const DebugLoc &DL);
 
   /// lookupVirtReg - Find the EC leader for VirtReg or null.
@@ -454,7 +454,7 @@
       LDV->mapVirtReg(locations[i].getReg(), this);
 }
 
-UserValue *LDVImpl::getUserValue(const MDNode *Var, const MDNode *Expr,
+UserValue *LDVImpl::getUserValue(const MDNode *Var, const DIExpression *Expr,
                                  bool IsIndirect, const DebugLoc &DL) {
   UserValue *&Leader = userVarMap[Var];
   if (Leader) {
@@ -498,7 +498,7 @@
   if (IsIndirect)
     assert(MI.getOperand(1).getImm() == 0 && "DBG_VALUE with nonzero offset");
   const MDNode *Var = MI.getDebugVariable();
-  const MDNode *Expr = MI.getDebugExpression();
+  const DIExpression *Expr = MI.getDebugExpression();
   //here.
   UserValue *UV = getUserValue(Var, Expr, IsIndirect, MI.getDebugLoc());
   UV->addDef(Idx, MI.getOperand(0));
Index: llvm/lib/CodeGen/MIRParser/MIParser.h
===================================================================
--- llvm/lib/CodeGen/MIRParser/MIParser.h
+++ llvm/lib/CodeGen/MIRParser/MIParser.h
@@ -22,7 +22,7 @@
 
 class MachineBasicBlock;
 class MachineFunction;
-class MDNode;
+class Metadata;
 class RegisterBank;
 struct SlotMapping;
 class SMDiagnostic;
@@ -115,8 +115,8 @@
 bool parseStackObjectReference(PerFunctionMIParsingState &PFS, int &FI,
                                StringRef Src, SMDiagnostic &Error);
 
-bool parseMDNode(PerFunctionMIParsingState &PFS, MDNode *&Node, StringRef Src,
-                 SMDiagnostic &Error);
+bool parseMetadata(PerFunctionMIParsingState &PFS, Metadata *&M, StringRef Src,
+                   SMDiagnostic &Error);
 
 } // end namespace llvm
 
Index: llvm/lib/CodeGen/MIRParser/MIParser.cpp
===================================================================
--- llvm/lib/CodeGen/MIRParser/MIParser.cpp
+++ llvm/lib/CodeGen/MIRParser/MIParser.cpp
@@ -172,7 +172,7 @@
   bool parseStandaloneVirtualRegister(VRegInfo *&Info);
   bool parseStandaloneRegister(unsigned &Reg);
   bool parseStandaloneStackObject(int &FI);
-  bool parseStandaloneMDNode(MDNode *&Node);
+  bool parseStandaloneMetadata(Metadata *&Node);
 
   bool
   parseBasicBlockDefinition(DenseMap<unsigned, MachineBasicBlock *> &MBBSlots);
@@ -209,8 +209,16 @@
   bool parseSubRegisterIndexOperand(MachineOperand &Dest);
   bool parseJumpTableIndexOperand(MachineOperand &Dest);
   bool parseExternalSymbolOperand(MachineOperand &Dest);
-  bool parseMDNode(MDNode *&Node);
-  bool parseDIExpression(MDNode *&Node);
+
+  /// Parse a metadata or MDNode referred to by number. Some types, such as
+  /// DIExpression, can be numbered or appear inline, but they are not MDNodes.
+  bool parseMDNode(Metadata *&M);
+
+  /// Parse an MDNode reference only. Reject metadata ids that refer to
+  /// non-MDNodes like DIExpression.
+  bool parseMDNodeOnly(MDNode *&Node);
+
+  bool parseDIExpression(Metadata *&Node);
   bool parseMetadataOperand(MachineOperand &Dest);
   bool parseCFIOffset(int &Offset);
   bool parseCFIRegister(unsigned &Reg);
@@ -744,10 +752,13 @@
     lex();
     if (Token.isNot(MIToken::exclaim))
       return error("expected a metadata node after 'debug-location'");
-    MDNode *Node = nullptr;
+    Metadata *Node = nullptr;
     if (parseMDNode(Node))
       return true;
-    DebugLocation = DebugLoc(Node);
+    DILocation *Loc = dyn_cast<DILocation>(Node);
+    if (!Loc)
+      return error("expected DILocation after 'debug-location'");
+    DebugLocation = Loc;
   }
 
   // Parse the machine memory operands.
@@ -854,13 +865,13 @@
   return false;
 }
 
-bool MIParser::parseStandaloneMDNode(MDNode *&Node) {
+bool MIParser::parseStandaloneMetadata(Metadata *&M) {
   lex();
   if (Token.is(MIToken::exclaim)) {
-    if (parseMDNode(Node))
+    if (parseMDNode(M))
       return true;
   } else if (Token.is(MIToken::md_diexpr)) {
-    if (parseDIExpression(Node))
+    if (parseDIExpression(M))
       return true;
   } else
     return error("expected a metadata node");
@@ -1496,7 +1507,7 @@
   return false;
 }
 
-bool MIParser::parseMDNode(MDNode *&Node) {
+bool MIParser::parseMDNode(Metadata *&M) {
   assert(Token.is(MIToken::exclaim));
 
   auto Loc = Token.location();
@@ -1510,11 +1521,21 @@
   if (NodeInfo == PFS.IRSlots.MetadataNodes.end())
     return error(Loc, "use of undefined metadata '!" + Twine(ID) + "'");
   lex();
-  Node = NodeInfo->second.get();
+  M = NodeInfo->second.get();
   return false;
 }
 
-bool MIParser::parseDIExpression(MDNode *&Expr) {
+bool MIParser::parseMDNodeOnly(MDNode *&Node) {
+  Metadata *M;
+  if (parseMDNode(M))
+    return true;
+  Node = dyn_cast<MDNode>(M);
+  if (!Node)
+    return error("expected metadata node, not plain metadata");
+  return false;
+}
+
+bool MIParser::parseDIExpression(Metadata *&Expr) {
   assert(Token.is(MIToken::md_diexpr));
   lex();
 
@@ -1556,15 +1577,15 @@
 }
 
 bool MIParser::parseMetadataOperand(MachineOperand &Dest) {
-  MDNode *Node = nullptr;
+  Metadata *M;
   if (Token.is(MIToken::exclaim)) {
-    if (parseMDNode(Node))
+    if (parseMDNode(M))
       return true;
   } else if (Token.is(MIToken::md_diexpr)) {
-    if (parseDIExpression(Node))
+    if (parseDIExpression(M))
       return true;
   }
-  Dest = MachineOperand::CreateMetadata(Node);
+  Dest = MachineOperand::CreateMetadata(M);
   return false;
 }
 
@@ -2311,22 +2332,22 @@
       break;
     case MIToken::md_tbaa:
       lex();
-      if (parseMDNode(AAInfo.TBAA))
+      if (parseMDNodeOnly(AAInfo.TBAA))
         return true;
       break;
     case MIToken::md_alias_scope:
       lex();
-      if (parseMDNode(AAInfo.Scope))
+      if (parseMDNodeOnly(AAInfo.Scope))
         return true;
       break;
     case MIToken::md_noalias:
       lex();
-      if (parseMDNode(AAInfo.NoAlias))
+      if (parseMDNodeOnly(AAInfo.NoAlias))
         return true;
       break;
     case MIToken::md_range:
       lex();
-      if (parseMDNode(Range))
+      if (parseMDNodeOnly(Range))
         return true;
       break;
     // TODO: Report an error on duplicate metadata nodes.
@@ -2621,7 +2642,7 @@
   return MIParser(PFS, Error, Src).parseStandaloneStackObject(FI);
 }
 
-bool llvm::parseMDNode(PerFunctionMIParsingState &PFS,
-                       MDNode *&Node, StringRef Src, SMDiagnostic &Error) {
-  return MIParser(PFS, Error, Src).parseStandaloneMDNode(Node);
+bool llvm::parseMetadata(PerFunctionMIParsingState &PFS, Metadata *&M,
+                         StringRef Src, SMDiagnostic &Error) {
+  return MIParser(PFS, Error, Src).parseStandaloneMetadata(M);
 }
Index: llvm/lib/CodeGen/MIRParser/MIRParser.cpp
===================================================================
--- llvm/lib/CodeGen/MIRParser/MIRParser.cpp
+++ llvm/lib/CodeGen/MIRParser/MIRParser.cpp
@@ -134,8 +134,8 @@
                                const yaml::MachineJumpTable &YamlJTI);
 
 private:
-  bool parseMDNode(PerFunctionMIParsingState &PFS, MDNode *&Node,
-                   const yaml::StringValue &Source);
+  bool parseMetadata(PerFunctionMIParsingState &PFS, Metadata *&M,
+                     const yaml::StringValue &Source);
 
   bool parseMBBReference(PerFunctionMIParsingState &PFS,
                          MachineBasicBlock *&MBB,
@@ -664,50 +664,51 @@
   return false;
 }
 
-/// Verify that given node is of a certain type. Return true on error.
+/// Verify that given metadata is of a certain type. Return true on error.
 template <typename T>
-static bool typecheckMDNode(T *&Result, MDNode *Node,
-                            const yaml::StringValue &Source,
-                            StringRef TypeString, MIRParserImpl &Parser) {
-  if (!Node)
+static bool typecheckMetadata(T *&Result, Metadata *M,
+                              const yaml::StringValue &Source,
+                              StringRef TypeString, MIRParserImpl &Parser) {
+  if (!M)
     return false;
-  Result = dyn_cast<T>(Node);
+  Result = dyn_cast<T>(M);
   if (!Result)
     return Parser.error(Source.SourceRange.Start,
                         "expected a reference to a '" + TypeString +
-                            "' metadata node");
+                            "' metadata");
   return false;
 }
 
-bool MIRParserImpl::parseStackObjectsDebugInfo(PerFunctionMIParsingState &PFS,
-    const yaml::MachineStackObject &Object, int FrameIdx) {
+bool MIRParserImpl::parseStackObjectsDebugInfo(
+    PerFunctionMIParsingState &PFS, const yaml::MachineStackObject &Obj,
+    int FrameIdx) {
   // Debug information can only be attached to stack objects; Fixed stack
   // objects aren't supported.
   assert(FrameIdx >= 0 && "Expected a stack object frame index");
-  MDNode *Var = nullptr, *Expr = nullptr, *Loc = nullptr;
-  if (parseMDNode(PFS, Var, Object.DebugVar) ||
-      parseMDNode(PFS, Expr, Object.DebugExpr) ||
-      parseMDNode(PFS, Loc, Object.DebugLoc))
+  Metadata *Var = nullptr, *Expr = nullptr, *Loc = nullptr;
+  if (parseMetadata(PFS, Var, Obj.DebugVar) ||
+      parseMetadata(PFS, Expr, Obj.DebugExpr) ||
+      parseMetadata(PFS, Loc, Obj.DebugLoc))
     return true;
   if (!Var && !Expr && !Loc)
     return false;
   DILocalVariable *DIVar = nullptr;
   DIExpression *DIExpr = nullptr;
   DILocation *DILoc = nullptr;
-  if (typecheckMDNode(DIVar, Var, Object.DebugVar, "DILocalVariable", *this) ||
-      typecheckMDNode(DIExpr, Expr, Object.DebugExpr, "DIExpression", *this) ||
-      typecheckMDNode(DILoc, Loc, Object.DebugLoc, "DILocation", *this))
+  if (typecheckMetadata(DIVar, Var, Obj.DebugVar, "DILocalVariable", *this) ||
+      typecheckMetadata(DIExpr, Expr, Obj.DebugExpr, "DIExpression", *this) ||
+      typecheckMetadata(DILoc, Loc, Obj.DebugLoc, "DILocation", *this))
     return true;
   PFS.MF.setVariableDbgInfo(DIVar, DIExpr, unsigned(FrameIdx), DILoc);
   return false;
 }
 
-bool MIRParserImpl::parseMDNode(PerFunctionMIParsingState &PFS,
-    MDNode *&Node, const yaml::StringValue &Source) {
+bool MIRParserImpl::parseMetadata(PerFunctionMIParsingState &PFS, Metadata *&M,
+                                  const yaml::StringValue &Source) {
   if (Source.Value.empty())
     return false;
   SMDiagnostic Error;
-  if (llvm::parseMDNode(PFS, Node, Source.Value, Error))
+  if (llvm::parseMetadata(PFS, M, Source.Value, Error))
     return error(Error, Source.SourceRange);
   return false;
 }
Index: llvm/lib/CodeGen/MachineInstr.cpp
===================================================================
--- llvm/lib/CodeGen/MachineInstr.cpp
+++ llvm/lib/CodeGen/MachineInstr.cpp
@@ -2326,8 +2326,8 @@
   unsigned LocCookie = 0;
   const MDNode *LocMD = nullptr;
   for (unsigned i = getNumOperands(); i != 0; --i) {
-    if (getOperand(i-1).isMetadata() &&
-        (LocMD = getOperand(i-1).getMetadata()) &&
+    if (getOperand(i - 1).isMetadata() &&
+        (LocMD = dyn_cast_or_null<MDNode>(getOperand(i - 1).getMetadata())) &&
         LocMD->getNumOperands() != 0) {
       if (const ConstantInt *CI =
               mdconst::dyn_extract<ConstantInt>(LocMD->getOperand(0))) {
@@ -2346,7 +2346,7 @@
 MachineInstrBuilder llvm::BuildMI(MachineFunction &MF, const DebugLoc &DL,
                                   const MCInstrDesc &MCID, bool IsIndirect,
                                   unsigned Reg, const MDNode *Variable,
-                                  const MDNode *Expr) {
+                                  const Metadata *Expr) {
   assert(isa<DILocalVariable>(Variable) && "not a variable");
   assert(cast<DIExpression>(Expr)->isValid() && "not an expression");
   assert(cast<DILocalVariable>(Variable)->isValidLocationForIntrinsic(DL) &&
@@ -2365,11 +2365,10 @@
         .addMetadata(Expr);
 }
 
-MachineInstrBuilder llvm::BuildMI(MachineBasicBlock &BB,
-                                  MachineBasicBlock::iterator I,
-                                  const DebugLoc &DL, const MCInstrDesc &MCID,
-                                  bool IsIndirect, unsigned Reg,
-                                  const MDNode *Variable, const MDNode *Expr) {
+MachineInstrBuilder
+llvm::BuildMI(MachineBasicBlock &BB, MachineBasicBlock::iterator I,
+              const DebugLoc &DL, const MCInstrDesc &MCID, bool IsIndirect,
+              unsigned Reg, const MDNode *Variable, const Metadata *Expr) {
   assert(isa<DILocalVariable>(Variable) && "not a variable");
   assert(cast<DIExpression>(Expr)->isValid() && "not an expression");
   MachineFunction &MF = *BB.getParent();
@@ -2394,7 +2393,8 @@
   // DW_OP_deref. Otherwise just turning this from a register into a
   // memory/indirect location is sufficient.
   if (IsIndirect)
-    Expr = DIExpression::prepend(Expr, DIExpression::WithDeref);
+    Expr =
+        DIExpression::prepend(Var->getContext(), Expr, DIExpression::WithDeref);
   return BuildMI(BB, I, DL, Orig.getDesc())
       .addFrameIndex(FrameIndex)
       .addImm(0U)
Index: llvm/lib/CodeGen/PrologEpilogInserter.cpp
===================================================================
--- llvm/lib/CodeGen/PrologEpilogInserter.cpp
+++ llvm/lib/CodeGen/PrologEpilogInserter.cpp
@@ -1083,8 +1083,9 @@
         int64_t Offset =
             TFI->getFrameIndexReference(Fn, MI.getOperand(0).getIndex(), Reg);
         MI.getOperand(0).ChangeToRegister(Reg, false /*isDef*/);
-        auto *DIExpr = DIExpression::prepend(MI.getDebugExpression(),
-                                             DIExpression::NoDeref, Offset);
+        auto *DIExpr = DIExpression::prepend(
+            MI.getDebugVariable()->getContext(), MI.getDebugExpression(),
+            DIExpression::NoDeref, Offset);
         MI.getOperand(3).setMetadata(DIExpr);
         continue;
       }
Index: llvm/lib/CodeGen/RegAllocFast.cpp
===================================================================
--- llvm/lib/CodeGen/RegAllocFast.cpp
+++ llvm/lib/CodeGen/RegAllocFast.cpp
@@ -883,7 +883,7 @@
                 assert(MI->getOperand(1).getImm() == 0 &&
                        "DBG_VALUE with nonzero offset");
               const MDNode *Var = MI->getDebugVariable();
-              const MDNode *Expr = MI->getDebugExpression();
+              const DIExpression *Expr = MI->getDebugExpression();
               DebugLoc DL = MI->getDebugLoc();
               MachineBasicBlock *MBB = MI->getParent();
               assert(
Index: llvm/lib/CodeGen/SelectionDAG/InstrEmitter.cpp
===================================================================
--- llvm/lib/CodeGen/SelectionDAG/InstrEmitter.cpp
+++ llvm/lib/CodeGen/SelectionDAG/InstrEmitter.cpp
@@ -674,7 +674,7 @@
 InstrEmitter::EmitDbgValue(SDDbgValue *SD,
                            DenseMap<SDValue, unsigned> &VRBaseMap) {
   MDNode *Var = SD->getVariable();
-  MDNode *Expr = SD->getExpression();
+  Metadata *Expr = SD->getExpression();
   DebugLoc DL = SD->getDebugLoc();
   assert(cast<DILocalVariable>(Var)->isValidLocationForIntrinsic(DL) &&
          "Expected inlined-at fields to agree");
Index: llvm/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp
===================================================================
--- llvm/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp
+++ llvm/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp
@@ -526,7 +526,7 @@
       MachineInstr *Def = RegInfo->getVRegDef(LDI->second);
       MachineBasicBlock::iterator InsertPos = Def;
       const MDNode *Variable = MI->getDebugVariable();
-      const MDNode *Expr = MI->getDebugExpression();
+      const Metadata *Expr = MI->getDebugExpression();
       DebugLoc DL = MI->getDebugLoc();
       bool IsIndirect = MI->isIndirectDebugValue();
       if (IsIndirect)
@@ -1162,8 +1162,9 @@
 
       DIExpression *Expr = DI->getExpression();
       if (Offset.getBoolValue())
-        Expr = DIExpression::prepend(Expr, DIExpression::NoDeref,
-                                     Offset.getZExtValue());
+        Expr =
+            DIExpression::prepend(DI->getContext(), Expr, DIExpression::NoDeref,
+                                  Offset.getZExtValue());
       MF->setVariableDbgInfo(DI->getVariable(), Expr, FI, DI->getDebugLoc());
     }
   }
Index: llvm/lib/IR/AsmWriter.cpp
===================================================================
--- llvm/lib/IR/AsmWriter.cpp
+++ llvm/lib/IR/AsmWriter.cpp
@@ -2100,6 +2100,11 @@
     return;
   }
 
+  if (const DIExpression *Expr = dyn_cast<DIExpression>(MD)) {
+    writeDIExpression(Out, Expr, TypePrinter, Machine, Context);
+    return;
+  }
+
   if (const MDString *MDS = dyn_cast<MDString>(MD)) {
     Out << "!\"";
     PrintEscapedString(MDS->getString(), Out);
Index: llvm/lib/IR/DIBuilder.cpp
===================================================================
--- llvm/lib/IR/DIBuilder.cpp
+++ llvm/lib/IR/DIBuilder.cpp
@@ -813,7 +813,6 @@
     DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
 
   trackIfUnresolved(VarInfo);
-  trackIfUnresolved(Expr);
   Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, Storage),
                    MetadataAsValue::get(VMContext, VarInfo),
                    MetadataAsValue::get(VMContext, Expr)};
@@ -832,7 +831,6 @@
     DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
 
   trackIfUnresolved(VarInfo);
-  trackIfUnresolved(Expr);
   Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, Storage),
                    MetadataAsValue::get(VMContext, VarInfo),
                    MetadataAsValue::get(VMContext, Expr)};
@@ -859,7 +857,6 @@
     ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
 
   trackIfUnresolved(VarInfo);
-  trackIfUnresolved(Expr);
   Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, V),
                    MetadataAsValue::get(VMContext, VarInfo),
                    MetadataAsValue::get(VMContext, Expr)};
@@ -881,7 +878,6 @@
     ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
 
   trackIfUnresolved(VarInfo);
-  trackIfUnresolved(Expr);
   Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, V),
                    MetadataAsValue::get(VMContext, VarInfo),
                    MetadataAsValue::get(VMContext, Expr)};
Index: llvm/lib/IR/DebugInfoMetadata.cpp
===================================================================
--- llvm/lib/IR/DebugInfoMetadata.cpp
+++ llvm/lib/IR/DebugInfoMetadata.cpp
@@ -586,11 +586,24 @@
   DEFINE_GETIMPL_STORE(DILocalVariable, (Line, Arg, Flags, AlignInBits), Ops);
 }
 
-DIExpression *DIExpression::getImpl(LLVMContext &Context,
-                                    ArrayRef<uint64_t> Elements,
-                                    StorageType Storage, bool ShouldCreate) {
-  DEFINE_GETIMPL_LOOKUP(DIExpression, (Elements));
-  DEFINE_GETIMPL_STORE_NO_OPS(DIExpression, (Elements));
+DIExpression *DIExpression::get(LLVMContext &Context,
+                                ArrayRef<uint64_t> Elements) {
+  FoldingSet<DIExpression> &DIExpressions = Context.pImpl->DIExpressions;
+  FoldingSetNodeID ID;
+  for (auto Elt : Elements)
+    ID.AddInteger(Elt);
+  void *InsertPoint;
+  DIExpression *Expr = DIExpressions.FindNodeOrInsertPos(ID, InsertPoint);
+  if (!Expr) {
+    Expr = new DIExpression(Elements);
+    DIExpressions.InsertNode(Expr, InsertPoint);
+  }
+  return Expr;
+}
+
+void DIExpression::Profile(FoldingSetNodeID &ID) const {
+  for (auto Elt : Elements)
+    ID.AddInteger(Elt);
 }
 
 unsigned DIExpression::ExprOperand::getSize() const {
@@ -698,7 +711,7 @@
   return false;
 }
 
-DIExpression *DIExpression::prepend(const DIExpression *Expr, bool Deref,
+DIExpression *DIExpression::prepend(LLVMContext &C, const DIExpression *Expr, bool Deref,
                                     int64_t Offset, bool StackValue) {
   SmallVector<uint64_t, 8> Ops;
   appendOffset(Ops, Offset);
@@ -721,7 +734,7 @@
     }
   if (StackValue)
     Ops.push_back(dwarf::DW_OP_stack_value);
-  return DIExpression::get(Expr->getContext(), Ops);
+  return DIExpression::get(C, Ops);
 }
 
 bool DIExpression::isConstant() const {
Index: llvm/lib/IR/LLVMContextImpl.h
===================================================================
--- llvm/lib/IR/LLVMContextImpl.h
+++ llvm/lib/IR/LLVMContextImpl.h
@@ -1191,6 +1191,7 @@
   FoldingSet<AttributeSetNode> AttrsSetNodes;
 
   StringMap<MDString, BumpPtrAllocator> MDStringCache;
+  FoldingSet<DIExpression> DIExpressions;
   DenseMap<Value *, ValueAsMetadata *> ValuesAsMetadata;
   DenseMap<Metadata *, MetadataAsValue *> MetadataAsValues;
 
Index: llvm/lib/IR/LLVMContextImpl.cpp
===================================================================
--- llvm/lib/IR/LLVMContextImpl.cpp
+++ llvm/lib/IR/LLVMContextImpl.cpp
@@ -131,6 +131,10 @@
   // Destroy ValuesAsMetadata.
   for (auto &Pair : ValuesAsMetadata)
     delete Pair.second;
+
+  // Destroy DIExpressions.
+  for (auto I = DIExpressions.begin(), E = DIExpressions.end(); I != E;)
+    delete &*I++;
 }
 
 void LLVMContextImpl::dropTriviallyDeadConstantArrays() {
Index: llvm/lib/IR/Verifier.cpp
===================================================================
--- llvm/lib/IR/Verifier.cpp
+++ llvm/lib/IR/Verifier.cpp
@@ -419,6 +419,7 @@
   template <class Ty> bool isValidMetadataArray(const MDTuple &N);
 #define HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS) void visit##CLASS(const CLASS &N);
 #include "llvm/IR/Metadata.def"
+  void visitDIExpression(const DIExpression &N);
   void visitDIScope(const DIScope &N);
   void visitDIVariable(const DIVariable &N);
   void visitDILexicalBlockBase(const DILexicalBlockBase &N);
@@ -777,6 +778,10 @@
       visitMDNode(*N);
       continue;
     }
+    if (auto *E = dyn_cast<DIExpression>(Op)) {
+      visitDIExpression(*E);
+      continue;
+    }
     if (auto *V = dyn_cast<ValueAsMetadata>(Op)) {
       visitValueAsMetadata(*V, nullptr);
       continue;
@@ -820,6 +825,10 @@
     visitMDNode(*N);
     return;
   }
+  if (auto *E = dyn_cast<DIExpression>(MD)) {
+    visitDIExpression(*E);
+    return;
+  }
 
   // Only visit each node once.  Metadata can be mutually recursive, so this
   // avoids infinite recursion here, as well as being an optimization.
Index: llvm/lib/Target/X86/X86OptimizeLEAs.cpp
===================================================================
--- llvm/lib/Target/X86/X86OptimizeLEAs.cpp
+++ llvm/lib/Target/X86/X86OptimizeLEAs.cpp
@@ -543,17 +543,17 @@
 MachineInstr *OptimizeLEAPass::replaceDebugValue(MachineInstr &MI,
                                                  unsigned VReg,
                                                  int64_t AddrDispShift) {
+  const MDNode *Var = MI.getDebugVariable();
   DIExpression *Expr = const_cast<DIExpression *>(MI.getDebugExpression());
 
   if (AddrDispShift != 0)
-    Expr = DIExpression::prepend(Expr, DIExpression::NoDeref, AddrDispShift,
-                                 DIExpression::WithStackValue);
+    Expr = DIExpression::prepend(Var->getContext(), Expr, DIExpression::NoDeref,
+                                 AddrDispShift, DIExpression::WithStackValue);
 
   // Replace DBG_VALUE instruction with modified version.
   MachineBasicBlock *MBB = MI.getParent();
   DebugLoc DL = MI.getDebugLoc();
   bool IsIndirect = MI.isIndirectDebugValue();
-  const MDNode *Var = MI.getDebugVariable();
   if (IsIndirect)
     assert(MI.getOperand(1).getImm() == 0 && "DBG_VALUE with nonzero offset");
   return BuildMI(*MBB, MBB->erase(&MI), DL, TII->get(TargetOpcode::DBG_VALUE),
Index: llvm/lib/Transforms/Utils/Local.cpp
===================================================================
--- llvm/lib/Transforms/Utils/Local.cpp
+++ llvm/lib/Transforms/Utils/Local.cpp
@@ -1262,7 +1262,7 @@
   auto *DIVar = DDI->getVariable();
   auto *DIExpr = DDI->getExpression();
   assert(DIVar && "Missing variable");
-  DIExpr = DIExpression::prepend(DIExpr, Deref, Offset);
+  DIExpr = DIExpression::prepend(DDI->getContext(), DIExpr, Deref, Offset);
   // Insert llvm.dbg.declare immediately after the original alloca, and remove
   // old llvm.dbg.declare.
   Builder.insertDeclare(NewAddress, DIVar, DIExpr, Loc, InsertBefore);
@@ -1344,9 +1344,9 @@
         auto *DIExpr = DVI->getExpression();
         DIBuilder DIB(M, /*AllowUnresolved*/ false);
         // GEP offsets are i32 and thus always fit into an int64_t.
-        DIExpr = DIExpression::prepend(DIExpr, DIExpression::NoDeref,
-                                       Offset.getSExtValue(),
-                                       DIExpression::WithStackValue);
+        DIExpr = DIExpression::prepend(
+            I.getContext(), DIExpr, DIExpression::NoDeref,
+            Offset.getSExtValue(), DIExpression::WithStackValue);
         DVI->setOperand(0, MDWrap(I.getOperand(0)));
         DVI->setOperand(2, MetadataAsValue::get(I.getContext(), DIExpr));
         DEBUG(dbgs() << "SALVAGE: " << *DVI << '\n');
@@ -1358,7 +1358,8 @@
       // Rewrite the load into DW_OP_deref.
       auto *DIExpr = DVI->getExpression();
       DIBuilder DIB(M, /*AllowUnresolved*/ false);
-      DIExpr = DIExpression::prepend(DIExpr, DIExpression::WithDeref);
+      DIExpr = DIExpression::prepend(I.getContext(), DIExpr,
+                                     DIExpression::WithDeref);
       DVI->setOperand(0, MDWrap(I.getOperand(0)));
       DVI->setOperand(2, MetadataAsValue::get(I.getContext(), DIExpr));
       DEBUG(dbgs() << "SALVAGE:  " << *DVI << '\n');
Index: llvm/test/Assembler/diexpression.ll
===================================================================
--- llvm/test/Assembler/diexpression.ll
+++ llvm/test/Assembler/diexpression.ll
@@ -1,7 +1,8 @@
 ; RUN: llvm-as < %s | llvm-dis | llvm-as | llvm-dis | FileCheck %s
 ; RUN: verify-uselistorder %s
 
-; CHECK: !named = !{
+; CHECK: !named = !{![[TUPLE:[0-9]+]]}
+; CHECK: ![[TUPLE]] = !{
 ; CHECK-SAME: !DIExpression(),
 ; CHECK-SAME: !DIExpression(DW_OP_deref),
 ; CHECK-SAME: !DIExpression(DW_OP_constu, 3, DW_OP_plus),
@@ -10,7 +11,7 @@
 ; CHECK-SAME: !DIExpression(DW_OP_constu, 2, DW_OP_swap, DW_OP_xderef),
 ; CHECK-SAME: !DIExpression(DW_OP_plus_uconst, 3)}
 
-!named = !{!0, !1, !2, !3, !4, !5, !6}
+!named = !{!7}
 
 !0 = !DIExpression()
 !1 = !DIExpression(DW_OP_deref)
@@ -19,3 +20,4 @@
 !4 = !DIExpression(DW_OP_deref, DW_OP_plus_uconst, 3, DW_OP_LLVM_fragment, 3, 7)
 !5 = !DIExpression(DW_OP_constu, 2, DW_OP_swap, DW_OP_xderef)
 !6 = !DIExpression(DW_OP_plus_uconst, 3)
+!7 = !{!0, !1, !2, !3, !4, !5, !6}
Index: llvm/test/Assembler/invalid-diexpression-verify.ll
===================================================================
--- llvm/test/Assembler/invalid-diexpression-verify.ll
+++ llvm/test/Assembler/invalid-diexpression-verify.ll
@@ -1,8 +1,9 @@
 ; RUN: not llvm-as -disable-output < %s 2>&1 | FileCheck -check-prefix VERIFY %s
 ; RUN: llvm-as -disable-verify < %s | llvm-dis | FileCheck -check-prefix NOVERIFY %s
 
-; NOVERIFY: !named = !{!DIExpression(0, 1, 9, 7, 2)}
+; NOVERIFY: !named = !{!0}
+; NOVERIFY: !0 = !{!DIExpression(0, 1, 9, 7, 2)}
 !named = !{!0}
 
 ; VERIFY: assembly parsed, but does not verify
-!0 = !DIExpression(0, 1, 9, 7, 2)
+!0 = !{!DIExpression(0, 1, 9, 7, 2)}
Index: llvm/unittests/IR/MetadataTest.cpp
===================================================================
--- llvm/unittests/IR/MetadataTest.cpp
+++ llvm/unittests/IR/MetadataTest.cpp
@@ -2021,9 +2021,6 @@
   EXPECT_EQ(9u, N->getElement(2));
   EXPECT_EQ(78u, N->getElement(3));
   EXPECT_EQ(0u, N->getElement(4));
-
-  TempDIExpression Temp = N->clone();
-  EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
 }
 
 TEST_F(DIExpressionTest, isValid) {