Hash DISubprogram Metadata using pointer for MDString argument instead of value (NFC)

[mehdi_amini]

Summary

MDString are uniqued in the Context on creation, hashing the
pointer is less expensive than hashing the String itself.

[dexonsmith]

Nice cleanup, assuming the tests pass. LGTM, as long you follow up
by doing the rest of the MDNodeKeyImpls so they aren't inconsistent.
In fact, I don't really see a problem with doing them in bulk, but
split it up how you like.

[mehdi_amini]

Update using the pointer value for MDString for all the Metadata types

[mehdi_amini]

(mark as accepted before commit)

[mehdi_amini]

r263867

include/llvm/IR/DebugInfoMetadata.h

DEFINE_MDNODE_GET(GenericDINode, (unsigned Tag, MDString *Header,
                                     ArrayRef<Metadata *> DwarfOps),
                     (Tag, Header, DwarfOps))
 
   /// \brief Return a (temporary) clone of this.
   TempGenericDINode clone() const { return cloneImpl(); }
 
   unsigned getTag() const { return SubclassData16; }
   StringRef getHeader() const { return getStringOperand(0); }
+  MDString *getRawHeader() const { return getOperandAs<MDString>(0); }
 
   op_iterator dwarf_op_begin() const { return op_begin() + 1; }
   op_iterator dwarf_op_end() const { return op_end(); }
   op_range dwarf_operands() const {
     return op_range(dwarf_op_begin(), dwarf_op_end());
   }
 
   unsigned getNumDwarfOperands() const { return getNumOperands() - 1; }

lib/IR/DebugInfoMetadata.cpp

StringRef DIScope::getName() const {
   if (auto *M = dyn_cast<DIModule>(this))
     return M->getName();
   assert((isa<DILexicalBlockBase>(this) || isa<DIFile>(this) ||
           isa<DICompileUnit>(this)) &&
          "Unhandled type of scope.");
   return "";
 }
 
-static StringRef getString(const MDString *S) {
-  if (S)
-    return S->getString();
-  return StringRef();
-}
-
 #ifndef NDEBUG
 static bool isCanonical(const MDString *S) {
   return !S || !S->getString().empty();
 }
 #endif
 
 GenericDINode *GenericDINode::getImpl(LLVMContext &Context, unsigned Tag,
                                       MDString *Header,
                                       ArrayRef<Metadata *> DwarfOps,
                                       StorageType Storage, bool ShouldCreate) {
   unsigned Hash = 0;
   if (Storage == Uniqued) {
-    GenericDINodeInfo::KeyTy Key(Tag, getString(Header), DwarfOps);
+    GenericDINodeInfo::KeyTy Key(Tag, Header, DwarfOps);
     if (auto *N = getUniqued(Context.pImpl->GenericDINodes, Key))
       return N;
     if (!ShouldCreate)
       return nullptr;
     Hash = Key.getHash();
   } else {
     assert(ShouldCreate && "Expected non-uniqued nodes to always be created");
   }
DISubrange *DISubrange::getImpl(LLVMContext &Context, int64_t Count, int64_t Lo,
   DEFINE_GETIMPL_LOOKUP(DISubrange, (Count, Lo));
   DEFINE_GETIMPL_STORE_NO_OPS(DISubrange, (Count, Lo));
 }
 
 DIEnumerator *DIEnumerator::getImpl(LLVMContext &Context, int64_t Value,
                                     MDString *Name, StorageType Storage,
                                     bool ShouldCreate) {
   assert(isCanonical(Name) && "Expected canonical MDString");
-  DEFINE_GETIMPL_LOOKUP(DIEnumerator, (Value, getString(Name)));
+  DEFINE_GETIMPL_LOOKUP(DIEnumerator, (Value, Name));
   Metadata *Ops[] = {Name};
   DEFINE_GETIMPL_STORE(DIEnumerator, (Value), Ops);
 }
 
 DIBasicType *DIBasicType::getImpl(LLVMContext &Context, unsigned Tag,
                                   MDString *Name, uint64_t SizeInBits,
                                   uint64_t AlignInBits, unsigned Encoding,
                                   StorageType Storage, bool ShouldCreate) {
   assert(isCanonical(Name) && "Expected canonical MDString");
-  DEFINE_GETIMPL_LOOKUP(
-      DIBasicType, (Tag, getString(Name), SizeInBits, AlignInBits, Encoding));
+  DEFINE_GETIMPL_LOOKUP(DIBasicType,
+                        (Tag, Name, SizeInBits, AlignInBits, Encoding));
   Metadata *Ops[] = {nullptr, nullptr, Name};
   DEFINE_GETIMPL_STORE(DIBasicType, (Tag, SizeInBits, AlignInBits, Encoding),
                        Ops);
 }
 
 DIDerivedType *DIDerivedType::getImpl(
     LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *File,
     unsigned Line, Metadata *Scope, Metadata *BaseType, uint64_t SizeInBits,
     uint64_t AlignInBits, uint64_t OffsetInBits, unsigned Flags,
     Metadata *ExtraData, StorageType Storage, bool ShouldCreate) {
   assert(isCanonical(Name) && "Expected canonical MDString");
-  DEFINE_GETIMPL_LOOKUP(DIDerivedType, (Tag, getString(Name), File, Line, Scope,
-                                        BaseType, SizeInBits, AlignInBits,
-                                        OffsetInBits, Flags, ExtraData));
+  DEFINE_GETIMPL_LOOKUP(DIDerivedType,
+                        (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
+                         AlignInBits, OffsetInBits, Flags, ExtraData));
   Metadata *Ops[] = {File, Scope, Name, BaseType, ExtraData};
   DEFINE_GETIMPL_STORE(
       DIDerivedType, (Tag, Line, SizeInBits, AlignInBits, OffsetInBits, Flags),
       Ops);
 }
 
 DICompositeType *DICompositeType::getImpl(
     LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *File,
     unsigned Line, Metadata *Scope, Metadata *BaseType, uint64_t SizeInBits,
     uint64_t AlignInBits, uint64_t OffsetInBits, unsigned Flags,
     Metadata *Elements, unsigned RuntimeLang, Metadata *VTableHolder,
     Metadata *TemplateParams, MDString *Identifier, StorageType Storage,
     bool ShouldCreate) {
   assert(isCanonical(Name) && "Expected canonical MDString");
-  DEFINE_GETIMPL_LOOKUP(DICompositeType,
-                        (Tag, getString(Name), File, Line, Scope, BaseType,
-                         SizeInBits, AlignInBits, OffsetInBits, Flags, Elements,
-                         RuntimeLang, VTableHolder, TemplateParams,
-                         getString(Identifier)));
+  DEFINE_GETIMPL_LOOKUP(
+      DICompositeType, (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
+                        AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
+                        VTableHolder, TemplateParams, Identifier));
   Metadata *Ops[] = {File,     Scope,        Name,           BaseType,
                      Elements, VTableHolder, TemplateParams, Identifier};
   DEFINE_GETIMPL_STORE(DICompositeType, (Tag, Line, RuntimeLang, SizeInBits,
                                          AlignInBits, OffsetInBits, Flags),
                        Ops);
 }
 
 DISubroutineType *DISubroutineType::getImpl(LLVMContext &Context,
                                             unsigned Flags, Metadata *TypeArray,
                                             StorageType Storage,
                                             bool ShouldCreate) {
   DEFINE_GETIMPL_LOOKUP(DISubroutineType, (Flags, TypeArray));
   Metadata *Ops[] = {nullptr, nullptr, nullptr, TypeArray};
   DEFINE_GETIMPL_STORE(DISubroutineType, (Flags), Ops);
 }
 
 DIFile *DIFile::getImpl(LLVMContext &Context, MDString *Filename,
                         MDString *Directory, StorageType Storage,
                         bool ShouldCreate) {
   assert(isCanonical(Filename) && "Expected canonical MDString");
   assert(isCanonical(Directory) && "Expected canonical MDString");
-  DEFINE_GETIMPL_LOOKUP(DIFile, (getString(Filename), getString(Directory)));
+  DEFINE_GETIMPL_LOOKUP(DIFile, (Filename, Directory));
   Metadata *Ops[] = {Filename, Directory};
   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,
DISubprogram *DISubprogram::getImpl(
     bool IsLocalToUnit, bool IsDefinition, unsigned ScopeLine,
     Metadata *ContainingType, unsigned Virtuality, unsigned VirtualIndex,
     unsigned Flags, bool IsOptimized, Metadata *TemplateParams,
     Metadata *Declaration, Metadata *Variables, StorageType Storage,
     bool ShouldCreate) {
   assert(isCanonical(Name) && "Expected canonical MDString");
   assert(isCanonical(LinkageName) && "Expected canonical MDString");
   DEFINE_GETIMPL_LOOKUP(DISubprogram,
-                        (Scope, getString(Name), getString(LinkageName), File,
-                         Line, Type, IsLocalToUnit, IsDefinition, ScopeLine,
-                         ContainingType, Virtuality, VirtualIndex, Flags,
-                         IsOptimized, TemplateParams, Declaration, Variables));
+                        (Scope, Name, LinkageName, File, Line, Type,
+                         IsLocalToUnit, IsDefinition, ScopeLine, ContainingType,
+                         Virtuality, VirtualIndex, Flags, IsOptimized,
+                         TemplateParams, Declaration, Variables));
   Metadata *Ops[] = {File,        Scope,    Name,           Name,
                      LinkageName, Type,     ContainingType, TemplateParams,
                      Declaration, Variables};
   DEFINE_GETIMPL_STORE(DISubprogram,
                        (Line, ScopeLine, Virtuality, VirtualIndex, Flags,
                         IsLocalToUnit, IsDefinition, IsOptimized),
                        Ops);
 }
DILexicalBlockFile *DILexicalBlockFile::getImpl(LLVMContext &Context,
   Metadata *Ops[] = {File, Scope};
   DEFINE_GETIMPL_STORE(DILexicalBlockFile, (Discriminator), Ops);
 }
 
 DINamespace *DINamespace::getImpl(LLVMContext &Context, Metadata *Scope,
                                   Metadata *File, MDString *Name, unsigned Line,
                                   StorageType Storage, bool ShouldCreate) {
   assert(isCanonical(Name) && "Expected canonical MDString");
-  DEFINE_GETIMPL_LOOKUP(DINamespace, (Scope, File, getString(Name), Line));
+  DEFINE_GETIMPL_LOOKUP(DINamespace, (Scope, File, Name, Line));
   Metadata *Ops[] = {File, Scope, Name};
   DEFINE_GETIMPL_STORE(DINamespace, (Line), Ops);
 }
 
 DIModule *DIModule::getImpl(LLVMContext &Context, Metadata *Scope,
                             MDString *Name, MDString *ConfigurationMacros,
                             MDString *IncludePath, MDString *ISysRoot,
                             StorageType Storage, bool ShouldCreate) {
   assert(isCanonical(Name) && "Expected canonical MDString");
-  DEFINE_GETIMPL_LOOKUP(DIModule,
-    (Scope, getString(Name), getString(ConfigurationMacros),
-     getString(IncludePath), getString(ISysRoot)));
+  DEFINE_GETIMPL_LOOKUP(
+      DIModule, (Scope, Name, ConfigurationMacros, IncludePath, ISysRoot));
   Metadata *Ops[] = {Scope, Name, ConfigurationMacros, IncludePath, ISysRoot};
   DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(DIModule, Ops);
 }
 
 DITemplateTypeParameter *DITemplateTypeParameter::getImpl(LLVMContext &Context,
                                                           MDString *Name,
                                                           Metadata *Type,
                                                           StorageType Storage,
                                                           bool ShouldCreate) {
   assert(isCanonical(Name) && "Expected canonical MDString");
-  DEFINE_GETIMPL_LOOKUP(DITemplateTypeParameter, (getString(Name), Type));
+  DEFINE_GETIMPL_LOOKUP(DITemplateTypeParameter, (Name, Type));
   Metadata *Ops[] = {Name, Type};
   DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(DITemplateTypeParameter, Ops);
 }
 
 DITemplateValueParameter *DITemplateValueParameter::getImpl(
     LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *Type,
     Metadata *Value, StorageType Storage, bool ShouldCreate) {
   assert(isCanonical(Name) && "Expected canonical MDString");
-  DEFINE_GETIMPL_LOOKUP(DITemplateValueParameter,
-                        (Tag, getString(Name), Type, Value));
+  DEFINE_GETIMPL_LOOKUP(DITemplateValueParameter, (Tag, Name, Type, Value));
   Metadata *Ops[] = {Name, Type, Value};
   DEFINE_GETIMPL_STORE(DITemplateValueParameter, (Tag), Ops);
 }
 
 DIGlobalVariable *
 DIGlobalVariable::getImpl(LLVMContext &Context, Metadata *Scope, MDString *Name,
                           MDString *LinkageName, Metadata *File, unsigned Line,
                           Metadata *Type, bool IsLocalToUnit, bool IsDefinition,
                           Metadata *Variable,
                           Metadata *StaticDataMemberDeclaration,
                           StorageType Storage, bool ShouldCreate) {
   assert(isCanonical(Name) && "Expected canonical MDString");
   assert(isCanonical(LinkageName) && "Expected canonical MDString");
   DEFINE_GETIMPL_LOOKUP(DIGlobalVariable,
-                        (Scope, getString(Name), getString(LinkageName), File,
-                         Line, Type, IsLocalToUnit, IsDefinition, Variable,
+                        (Scope, Name, LinkageName, File, Line, Type,
+                         IsLocalToUnit, IsDefinition, Variable,
                          StaticDataMemberDeclaration));
   Metadata *Ops[] = {Scope, Name,        File,     Type,
                      Name,  LinkageName, Variable, StaticDataMemberDeclaration};
   DEFINE_GETIMPL_STORE(DIGlobalVariable, (Line, IsLocalToUnit, IsDefinition),
                        Ops);
 }
 
 DILocalVariable *DILocalVariable::getImpl(LLVMContext &Context, Metadata *Scope,
                                           MDString *Name, Metadata *File,
                                           unsigned Line, Metadata *Type,
                                           unsigned Arg, unsigned Flags,
                                           StorageType Storage,
                                           bool ShouldCreate) {
   // 64K ought to be enough for any frontend.
   assert(Arg <= UINT16_MAX && "Expected argument number to fit in 16-bits");
 
   assert(Scope && "Expected scope");
   assert(isCanonical(Name) && "Expected canonical MDString");
   DEFINE_GETIMPL_LOOKUP(DILocalVariable,
-                        (Scope, getString(Name), File, Line, Type, Arg, Flags));
+                        (Scope, Name, File, Line, Type, Arg, Flags));
   Metadata *Ops[] = {Scope, Name, File, Type};
   DEFINE_GETIMPL_STORE(DILocalVariable, (Line, Arg, Flags), Ops);
 }
 
 DIExpression *DIExpression::getImpl(LLVMContext &Context,
                                     ArrayRef<uint64_t> Elements,
                                     StorageType Storage, bool ShouldCreate) {
   DEFINE_GETIMPL_LOOKUP(DIExpression, (Elements));

 
 DIObjCProperty *DIObjCProperty::getImpl(
     LLVMContext &Context, MDString *Name, Metadata *File, unsigned Line,
     MDString *GetterName, MDString *SetterName, unsigned Attributes,
     Metadata *Type, StorageType Storage, bool ShouldCreate) {
   assert(isCanonical(Name) && "Expected canonical MDString");
   assert(isCanonical(GetterName) && "Expected canonical MDString");
   assert(isCanonical(SetterName) && "Expected canonical MDString");
-  DEFINE_GETIMPL_LOOKUP(DIObjCProperty,
-                        (getString(Name), File, Line, getString(GetterName),
-                         getString(SetterName), Attributes, Type));
+  DEFINE_GETIMPL_LOOKUP(DIObjCProperty, (Name, File, Line, GetterName,
+                                         SetterName, Attributes, Type));
   Metadata *Ops[] = {Name, File, GetterName, SetterName, Type};
   DEFINE_GETIMPL_STORE(DIObjCProperty, (Line, Attributes), Ops);
 }
 
 DIImportedEntity *DIImportedEntity::getImpl(LLVMContext &Context, unsigned Tag,
                                             Metadata *Scope, Metadata *Entity,
                                             unsigned Line, MDString *Name,
                                             StorageType Storage,
                                             bool ShouldCreate) {
   assert(isCanonical(Name) && "Expected canonical MDString");
-  DEFINE_GETIMPL_LOOKUP(DIImportedEntity,
-                        (Tag, Scope, Entity, Line, getString(Name)));
+  DEFINE_GETIMPL_LOOKUP(DIImportedEntity, (Tag, Scope, Entity, Line, Name));
   Metadata *Ops[] = {Scope, Entity, Name};
   DEFINE_GETIMPL_STORE(DIImportedEntity, (Tag, Line), Ops);
 }
 
 DIMacro *DIMacro::getImpl(LLVMContext &Context, unsigned MIType,
                           unsigned Line, MDString *Name, MDString *Value,
                           StorageType Storage, bool ShouldCreate) {
   assert(isCanonical(Name) && "Expected canonical MDString");
-  DEFINE_GETIMPL_LOOKUP(DIMacro,
-                        (MIType, Line, getString(Name), getString(Value)));
+  DEFINE_GETIMPL_LOOKUP(DIMacro, (MIType, Line, Name, Value));
   Metadata *Ops[] = { Name, Value };
   DEFINE_GETIMPL_STORE(DIMacro, (MIType, Line), Ops);
 }
 
 DIMacroFile *DIMacroFile::getImpl(LLVMContext &Context, unsigned MIType,
                                   unsigned Line, Metadata *File,
                                   Metadata *Elements, StorageType Storage,
                                   bool ShouldCreate) {
   DEFINE_GETIMPL_LOOKUP(DIMacroFile,
                         (MIType, Line, File, Elements));
   Metadata *Ops[] = { File, Elements };
   DEFINE_GETIMPL_STORE(DIMacroFile, (MIType, Line), Ops);
 }
 

lib/IR/LLVMContextImpl.h

template <> struct MDNodeKeyImpl<DILocation> {
   unsigned getHashValue() const {
     return hash_combine(Line, Column, Scope, InlinedAt);
   }
 };
 
 /// \brief DenseMapInfo for GenericDINode.
 template <> struct MDNodeKeyImpl<GenericDINode> : MDNodeOpsKey {
   unsigned Tag;
-  StringRef Header;
-  MDNodeKeyImpl(unsigned Tag, StringRef Header, ArrayRef<Metadata *> DwarfOps)
+  MDString *Header;
+  MDNodeKeyImpl(unsigned Tag, MDString *Header, ArrayRef<Metadata *> DwarfOps)
       : MDNodeOpsKey(DwarfOps), Tag(Tag), Header(Header) {}
   MDNodeKeyImpl(const GenericDINode *N)
-      : MDNodeOpsKey(N, 1), Tag(N->getTag()), Header(N->getHeader()) {}
+      : MDNodeOpsKey(N, 1), Tag(N->getTag()), Header(N->getRawHeader()) {}
 
   bool isKeyOf(const GenericDINode *RHS) const {
-    return Tag == RHS->getTag() && Header == RHS->getHeader() &&
+    return Tag == RHS->getTag() && Header == RHS->getRawHeader() &&
            compareOps(RHS, 1);
   }
 
   unsigned getHashValue() const { return hash_combine(getHash(), Tag, Header); }
 
   static unsigned calculateHash(GenericDINode *N) {
     return MDNodeOpsKey::calculateHash(N, 1);
   }
template <> struct MDNodeKeyImpl<DISubrange> {
   bool isKeyOf(const DISubrange *RHS) const {
     return Count == RHS->getCount() && LowerBound == RHS->getLowerBound();
   }
   unsigned getHashValue() const { return hash_combine(Count, LowerBound); }
 };
 
 template <> struct MDNodeKeyImpl<DIEnumerator> {
   int64_t Value;
-  StringRef Name;
+  MDString *Name;
 
-  MDNodeKeyImpl(int64_t Value, StringRef Name) : Value(Value), Name(Name) {}
+  MDNodeKeyImpl(int64_t Value, MDString *Name) : Value(Value), Name(Name) {}
   MDNodeKeyImpl(const DIEnumerator *N)
-      : Value(N->getValue()), Name(N->getName()) {}
+      : Value(N->getValue()), Name(N->getRawName()) {}
 
   bool isKeyOf(const DIEnumerator *RHS) const {
-    return Value == RHS->getValue() && Name == RHS->getName();
+    return Value == RHS->getValue() && Name == RHS->getRawName();
   }
   unsigned getHashValue() const { return hash_combine(Value, Name); }
 };
 
 template <> struct MDNodeKeyImpl<DIBasicType> {
   unsigned Tag;
-  StringRef Name;
+  MDString *Name;
   uint64_t SizeInBits;
   uint64_t AlignInBits;
   unsigned Encoding;
 
-  MDNodeKeyImpl(unsigned Tag, StringRef Name, uint64_t SizeInBits,
+  MDNodeKeyImpl(unsigned Tag, MDString *Name, uint64_t SizeInBits,
                 uint64_t AlignInBits, unsigned Encoding)
       : Tag(Tag), Name(Name), SizeInBits(SizeInBits), AlignInBits(AlignInBits),
         Encoding(Encoding) {}
   MDNodeKeyImpl(const DIBasicType *N)
-      : Tag(N->getTag()), Name(N->getName()), SizeInBits(N->getSizeInBits()),
+      : Tag(N->getTag()), Name(N->getRawName()), SizeInBits(N->getSizeInBits()),
         AlignInBits(N->getAlignInBits()), Encoding(N->getEncoding()) {}
 
   bool isKeyOf(const DIBasicType *RHS) const {
-    return Tag == RHS->getTag() && Name == RHS->getName() &&
+    return Tag == RHS->getTag() && Name == RHS->getRawName() &&
            SizeInBits == RHS->getSizeInBits() &&
            AlignInBits == RHS->getAlignInBits() &&
            Encoding == RHS->getEncoding();
   }
   unsigned getHashValue() const {
     return hash_combine(Tag, Name, SizeInBits, AlignInBits, Encoding);
   }
 };
 
 template <> struct MDNodeKeyImpl<DIDerivedType> {
   unsigned Tag;
-  StringRef Name;
+  MDString *Name;
   Metadata *File;
   unsigned Line;
   Metadata *Scope;
   Metadata *BaseType;
   uint64_t SizeInBits;
   uint64_t AlignInBits;
   uint64_t OffsetInBits;
   unsigned Flags;
   Metadata *ExtraData;
 
-  MDNodeKeyImpl(unsigned Tag, StringRef Name, Metadata *File, unsigned Line,
+  MDNodeKeyImpl(unsigned Tag, MDString *Name, Metadata *File, unsigned Line,
                 Metadata *Scope, Metadata *BaseType, uint64_t SizeInBits,
                 uint64_t AlignInBits, uint64_t OffsetInBits, unsigned Flags,
                 Metadata *ExtraData)
       : Tag(Tag), Name(Name), File(File), Line(Line), Scope(Scope),
         BaseType(BaseType), SizeInBits(SizeInBits), AlignInBits(AlignInBits),
         OffsetInBits(OffsetInBits), Flags(Flags), ExtraData(ExtraData) {}
   MDNodeKeyImpl(const DIDerivedType *N)
-      : Tag(N->getTag()), Name(N->getName()), File(N->getRawFile()),
+      : Tag(N->getTag()), Name(N->getRawName()), File(N->getRawFile()),
         Line(N->getLine()), Scope(N->getRawScope()),
         BaseType(N->getRawBaseType()), SizeInBits(N->getSizeInBits()),
         AlignInBits(N->getAlignInBits()), OffsetInBits(N->getOffsetInBits()),
         Flags(N->getFlags()), ExtraData(N->getRawExtraData()) {}
 
   bool isKeyOf(const DIDerivedType *RHS) const {
-    return Tag == RHS->getTag() && Name == RHS->getName() &&
+    return Tag == RHS->getTag() && Name == RHS->getRawName() &&
            File == RHS->getRawFile() && Line == RHS->getLine() &&
            Scope == RHS->getRawScope() && BaseType == RHS->getRawBaseType() &&
            SizeInBits == RHS->getSizeInBits() &&
            AlignInBits == RHS->getAlignInBits() &&
            OffsetInBits == RHS->getOffsetInBits() && Flags == RHS->getFlags() &&
            ExtraData == RHS->getRawExtraData();
   }
   unsigned getHashValue() const {
     return hash_combine(Tag, Name, File, Line, Scope, BaseType, SizeInBits,
                         AlignInBits, OffsetInBits, Flags, ExtraData);
   }
 };
 
 template <> struct MDNodeKeyImpl<DICompositeType> {
   unsigned Tag;
-  StringRef Name;
+  MDString *Name;
   Metadata *File;
   unsigned Line;
   Metadata *Scope;
   Metadata *BaseType;
   uint64_t SizeInBits;
   uint64_t AlignInBits;
   uint64_t OffsetInBits;
   unsigned Flags;
   Metadata *Elements;
   unsigned RuntimeLang;
   Metadata *VTableHolder;
   Metadata *TemplateParams;
-  StringRef Identifier;
+  MDString *Identifier;
 
-  MDNodeKeyImpl(unsigned Tag, StringRef Name, Metadata *File, unsigned Line,
+  MDNodeKeyImpl(unsigned Tag, MDString *Name, Metadata *File, unsigned Line,
                 Metadata *Scope, Metadata *BaseType, uint64_t SizeInBits,
                 uint64_t AlignInBits, uint64_t OffsetInBits, unsigned Flags,
                 Metadata *Elements, unsigned RuntimeLang,
                 Metadata *VTableHolder, Metadata *TemplateParams,
-                StringRef Identifier)
+                MDString *Identifier)
       : Tag(Tag), Name(Name), File(File), Line(Line), Scope(Scope),
         BaseType(BaseType), SizeInBits(SizeInBits), AlignInBits(AlignInBits),
         OffsetInBits(OffsetInBits), Flags(Flags), Elements(Elements),
         RuntimeLang(RuntimeLang), VTableHolder(VTableHolder),
         TemplateParams(TemplateParams), Identifier(Identifier) {}
   MDNodeKeyImpl(const DICompositeType *N)
-      : Tag(N->getTag()), Name(N->getName()), File(N->getRawFile()),
+      : Tag(N->getTag()), Name(N->getRawName()), File(N->getRawFile()),
         Line(N->getLine()), Scope(N->getRawScope()),
         BaseType(N->getRawBaseType()), SizeInBits(N->getSizeInBits()),
         AlignInBits(N->getAlignInBits()), OffsetInBits(N->getOffsetInBits()),
         Flags(N->getFlags()), Elements(N->getRawElements()),
         RuntimeLang(N->getRuntimeLang()), VTableHolder(N->getRawVTableHolder()),
         TemplateParams(N->getRawTemplateParams()),
-        Identifier(N->getIdentifier()) {}
+        Identifier(N->getRawIdentifier()) {}
 
   bool isKeyOf(const DICompositeType *RHS) const {
-    return Tag == RHS->getTag() && Name == RHS->getName() &&
+    return Tag == RHS->getTag() && Name == RHS->getRawName() &&
            File == RHS->getRawFile() && Line == RHS->getLine() &&
            Scope == RHS->getRawScope() && BaseType == RHS->getRawBaseType() &&
            SizeInBits == RHS->getSizeInBits() &&
            AlignInBits == RHS->getAlignInBits() &&
            OffsetInBits == RHS->getOffsetInBits() && Flags == RHS->getFlags() &&
            Elements == RHS->getRawElements() &&
            RuntimeLang == RHS->getRuntimeLang() &&
            VTableHolder == RHS->getRawVTableHolder() &&
            TemplateParams == RHS->getRawTemplateParams() &&
-           Identifier == RHS->getIdentifier();
+           Identifier == RHS->getRawIdentifier();
   }
   unsigned getHashValue() const {
     return hash_combine(Tag, Name, File, Line, Scope, BaseType, SizeInBits,
                         AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
                         VTableHolder, TemplateParams, Identifier);
   }
 };
 
 template <> struct MDNodeKeyImpl<DISubroutineType> {
   unsigned Flags;
   Metadata *TypeArray;
 
   MDNodeKeyImpl(int64_t Flags, Metadata *TypeArray)
       : Flags(Flags), TypeArray(TypeArray) {}
   MDNodeKeyImpl(const DISubroutineType *N)
       : Flags(N->getFlags()), TypeArray(N->getRawTypeArray()) {}
 
   bool isKeyOf(const DISubroutineType *RHS) const {
     return Flags == RHS->getFlags() && TypeArray == RHS->getRawTypeArray();
   }
   unsigned getHashValue() const { return hash_combine(Flags, TypeArray); }
 };
 
 template <> struct MDNodeKeyImpl<DIFile> {
-  StringRef Filename;
-  StringRef Directory;
+  MDString *Filename;
+  MDString *Directory;
 
-  MDNodeKeyImpl(StringRef Filename, StringRef Directory)
+  MDNodeKeyImpl(MDString *Filename, MDString *Directory)
       : Filename(Filename), Directory(Directory) {}
   MDNodeKeyImpl(const DIFile *N)
-      : Filename(N->getFilename()), Directory(N->getDirectory()) {}
+      : Filename(N->getRawFilename()), Directory(N->getRawDirectory()) {}
 
   bool isKeyOf(const DIFile *RHS) const {
-    return Filename == RHS->getFilename() && Directory == RHS->getDirectory();
+    return Filename == RHS->getRawFilename() &&
+           Directory == RHS->getRawDirectory();
   }
   unsigned getHashValue() const { return hash_combine(Filename, Directory); }
 };
 
 template <> struct MDNodeKeyImpl<DISubprogram> {
   Metadata *Scope;
-  StringRef Name;
-  StringRef LinkageName;
+  MDString *Name;
+  MDString *LinkageName;
   Metadata *File;
   unsigned Line;
   Metadata *Type;
   bool IsLocalToUnit;
   bool IsDefinition;
   unsigned ScopeLine;
   Metadata *ContainingType;
   unsigned Virtuality;
   unsigned VirtualIndex;
   unsigned Flags;
   bool IsOptimized;
   Metadata *TemplateParams;
   Metadata *Declaration;
   Metadata *Variables;
 
-  MDNodeKeyImpl(Metadata *Scope, StringRef Name, StringRef LinkageName,
+  MDNodeKeyImpl(Metadata *Scope, MDString *Name, MDString *LinkageName,
                 Metadata *File, unsigned Line, Metadata *Type,
                 bool IsLocalToUnit, bool IsDefinition, unsigned ScopeLine,
                 Metadata *ContainingType, unsigned Virtuality,
                 unsigned VirtualIndex, unsigned Flags, bool IsOptimized,
                 Metadata *TemplateParams, Metadata *Declaration,
                 Metadata *Variables)
       : Scope(Scope), Name(Name), LinkageName(LinkageName), File(File),
         Line(Line), Type(Type), IsLocalToUnit(IsLocalToUnit),
         IsDefinition(IsDefinition), ScopeLine(ScopeLine),
         ContainingType(ContainingType), Virtuality(Virtuality),
         VirtualIndex(VirtualIndex), Flags(Flags), IsOptimized(IsOptimized),
         TemplateParams(TemplateParams), Declaration(Declaration),
         Variables(Variables) {}
   MDNodeKeyImpl(const DISubprogram *N)
-      : Scope(N->getRawScope()), Name(N->getName()),
-        LinkageName(N->getLinkageName()), File(N->getRawFile()),
+      : Scope(N->getRawScope()), Name(N->getRawName()),
+        LinkageName(N->getRawLinkageName()), File(N->getRawFile()),
         Line(N->getLine()), Type(N->getRawType()),
         IsLocalToUnit(N->isLocalToUnit()), IsDefinition(N->isDefinition()),
         ScopeLine(N->getScopeLine()), ContainingType(N->getRawContainingType()),
         Virtuality(N->getVirtuality()), VirtualIndex(N->getVirtualIndex()),
         Flags(N->getFlags()), IsOptimized(N->isOptimized()),
         TemplateParams(N->getRawTemplateParams()),
         Declaration(N->getRawDeclaration()), Variables(N->getRawVariables()) {}
 
   bool isKeyOf(const DISubprogram *RHS) const {
-    return Scope == RHS->getRawScope() && Name == RHS->getName() &&
-           LinkageName == RHS->getLinkageName() && File == RHS->getRawFile() &&
-           Line == RHS->getLine() && Type == RHS->getRawType() &&
-           IsLocalToUnit == RHS->isLocalToUnit() &&
+    return Scope == RHS->getRawScope() && Name == RHS->getRawName() &&
+           LinkageName == RHS->getRawLinkageName() &&
+           File == RHS->getRawFile() && Line == RHS->getLine() &&
+           Type == RHS->getRawType() && IsLocalToUnit == RHS->isLocalToUnit() &&
            IsDefinition == RHS->isDefinition() &&
            ScopeLine == RHS->getScopeLine() &&
            ContainingType == RHS->getRawContainingType() &&
            Virtuality == RHS->getVirtuality() &&
            VirtualIndex == RHS->getVirtualIndex() && Flags == RHS->getFlags() &&
            IsOptimized == RHS->isOptimized() &&
            TemplateParams == RHS->getRawTemplateParams() &&
            Declaration == RHS->getRawDeclaration() &&
template <> struct MDNodeKeyImpl<DILexicalBlockFile> {
   unsigned getHashValue() const {
     return hash_combine(Scope, File, Discriminator);
   }
 };
 
 template <> struct MDNodeKeyImpl<DINamespace> {
   Metadata *Scope;
   Metadata *File;
-  StringRef Name;
+  MDString *Name;
   unsigned Line;
 
-  MDNodeKeyImpl(Metadata *Scope, Metadata *File, StringRef Name, unsigned Line)
+  MDNodeKeyImpl(Metadata *Scope, Metadata *File, MDString *Name, unsigned Line)
       : Scope(Scope), File(File), Name(Name), Line(Line) {}
   MDNodeKeyImpl(const DINamespace *N)
-      : Scope(N->getRawScope()), File(N->getRawFile()), Name(N->getName()),
+      : Scope(N->getRawScope()), File(N->getRawFile()), Name(N->getRawName()),
         Line(N->getLine()) {}
 
   bool isKeyOf(const DINamespace *RHS) const {
     return Scope == RHS->getRawScope() && File == RHS->getRawFile() &&
-           Name == RHS->getName() && Line == RHS->getLine();
+           Name == RHS->getRawName() && Line == RHS->getLine();
   }
   unsigned getHashValue() const {
     return hash_combine(Scope, File, Name, Line);
   }
 };
 
 template <> struct MDNodeKeyImpl<DIModule> {
   Metadata *Scope;
-  StringRef Name;
-  StringRef ConfigurationMacros;
-  StringRef IncludePath;
-  StringRef ISysRoot;
-  MDNodeKeyImpl(Metadata *Scope, StringRef Name,
-                StringRef ConfigurationMacros,
-                StringRef IncludePath,
-                StringRef ISysRoot)
+  MDString *Name;
+  MDString *ConfigurationMacros;
+  MDString *IncludePath;
+  MDString *ISysRoot;
+  MDNodeKeyImpl(Metadata *Scope, MDString *Name, MDString *ConfigurationMacros,
+                MDString *IncludePath, MDString *ISysRoot)
       : Scope(Scope), Name(Name), ConfigurationMacros(ConfigurationMacros),
         IncludePath(IncludePath), ISysRoot(ISysRoot) {}
   MDNodeKeyImpl(const DIModule *N)
-    : Scope(N->getRawScope()), Name(N->getName()),
-      ConfigurationMacros(N->getConfigurationMacros()),
-      IncludePath(N->getIncludePath()), ISysRoot(N->getISysRoot()) {}
+      : Scope(N->getRawScope()), Name(N->getRawName()),
+        ConfigurationMacros(N->getRawConfigurationMacros()),
+        IncludePath(N->getRawIncludePath()), ISysRoot(N->getRawISysRoot()) {}
 
   bool isKeyOf(const DIModule *RHS) const {
-    return Scope == RHS->getRawScope() && Name == RHS->getName() &&
-           ConfigurationMacros == RHS->getConfigurationMacros() &&
-           IncludePath == RHS->getIncludePath() &&
-           ISysRoot == RHS->getISysRoot();
+    return Scope == RHS->getRawScope() && Name == RHS->getRawName() &&
+           ConfigurationMacros == RHS->getRawConfigurationMacros() &&
+           IncludePath == RHS->getRawIncludePath() &&
+           ISysRoot == RHS->getRawISysRoot();
   }
   unsigned getHashValue() const {
     return hash_combine(Scope, Name,
                         ConfigurationMacros, IncludePath, ISysRoot);
   }
 };
 
 template <> struct MDNodeKeyImpl<DITemplateTypeParameter> {
-  StringRef Name;
+  MDString *Name;
   Metadata *Type;
 
-  MDNodeKeyImpl(StringRef Name, Metadata *Type) : Name(Name), Type(Type) {}
+  MDNodeKeyImpl(MDString *Name, Metadata *Type) : Name(Name), Type(Type) {}
   MDNodeKeyImpl(const DITemplateTypeParameter *N)
-      : Name(N->getName()), Type(N->getRawType()) {}
+      : Name(N->getRawName()), Type(N->getRawType()) {}
 
   bool isKeyOf(const DITemplateTypeParameter *RHS) const {
-    return Name == RHS->getName() && Type == RHS->getRawType();
+    return Name == RHS->getRawName() && Type == RHS->getRawType();
   }
   unsigned getHashValue() const { return hash_combine(Name, Type); }
 };
 
 template <> struct MDNodeKeyImpl<DITemplateValueParameter> {
   unsigned Tag;
-  StringRef Name;
+  MDString *Name;
   Metadata *Type;
   Metadata *Value;
 
-  MDNodeKeyImpl(unsigned Tag, StringRef Name, Metadata *Type, Metadata *Value)
+  MDNodeKeyImpl(unsigned Tag, MDString *Name, Metadata *Type, Metadata *Value)
       : Tag(Tag), Name(Name), Type(Type), Value(Value) {}
   MDNodeKeyImpl(const DITemplateValueParameter *N)
-      : Tag(N->getTag()), Name(N->getName()), Type(N->getRawType()),
+      : Tag(N->getTag()), Name(N->getRawName()), Type(N->getRawType()),
         Value(N->getValue()) {}
 
   bool isKeyOf(const DITemplateValueParameter *RHS) const {
-    return Tag == RHS->getTag() && Name == RHS->getName() &&
+    return Tag == RHS->getTag() && Name == RHS->getRawName() &&
            Type == RHS->getRawType() && Value == RHS->getValue();
   }
   unsigned getHashValue() const { return hash_combine(Tag, Name, Type, Value); }
 };
 
 template <> struct MDNodeKeyImpl<DIGlobalVariable> {
   Metadata *Scope;
-  StringRef Name;
-  StringRef LinkageName;
+  MDString *Name;
+  MDString *LinkageName;
   Metadata *File;
   unsigned Line;
   Metadata *Type;
   bool IsLocalToUnit;
   bool IsDefinition;
   Metadata *Variable;
   Metadata *StaticDataMemberDeclaration;
 
-  MDNodeKeyImpl(Metadata *Scope, StringRef Name, StringRef LinkageName,
+  MDNodeKeyImpl(Metadata *Scope, MDString *Name, MDString *LinkageName,
                 Metadata *File, unsigned Line, Metadata *Type,
                 bool IsLocalToUnit, bool IsDefinition, Metadata *Variable,
                 Metadata *StaticDataMemberDeclaration)
       : Scope(Scope), Name(Name), LinkageName(LinkageName), File(File),
         Line(Line), Type(Type), IsLocalToUnit(IsLocalToUnit),
         IsDefinition(IsDefinition), Variable(Variable),
         StaticDataMemberDeclaration(StaticDataMemberDeclaration) {}
   MDNodeKeyImpl(const DIGlobalVariable *N)
-      : Scope(N->getRawScope()), Name(N->getName()),
-        LinkageName(N->getLinkageName()), File(N->getRawFile()),
+      : Scope(N->getRawScope()), Name(N->getRawName()),
+        LinkageName(N->getRawLinkageName()), File(N->getRawFile()),
         Line(N->getLine()), Type(N->getRawType()),
         IsLocalToUnit(N->isLocalToUnit()), IsDefinition(N->isDefinition()),
         Variable(N->getRawVariable()),
         StaticDataMemberDeclaration(N->getRawStaticDataMemberDeclaration()) {}
 
   bool isKeyOf(const DIGlobalVariable *RHS) const {
-    return Scope == RHS->getRawScope() && Name == RHS->getName() &&
-           LinkageName == RHS->getLinkageName() && File == RHS->getRawFile() &&
-           Line == RHS->getLine() && Type == RHS->getRawType() &&
-           IsLocalToUnit == RHS->isLocalToUnit() &&
+    return Scope == RHS->getRawScope() && Name == RHS->getRawName() &&
+           LinkageName == RHS->getRawLinkageName() &&
+           File == RHS->getRawFile() && Line == RHS->getLine() &&
+           Type == RHS->getRawType() && IsLocalToUnit == RHS->isLocalToUnit() &&
            IsDefinition == RHS->isDefinition() &&
            Variable == RHS->getRawVariable() &&
            StaticDataMemberDeclaration ==
                RHS->getRawStaticDataMemberDeclaration();
   }
   unsigned getHashValue() const {
     return hash_combine(Scope, Name, LinkageName, File, Line, Type,
                         IsLocalToUnit, IsDefinition, Variable,
                         StaticDataMemberDeclaration);
   }
 };
 
 template <> struct MDNodeKeyImpl<DILocalVariable> {
   Metadata *Scope;
-  StringRef Name;
+  MDString *Name;
   Metadata *File;
   unsigned Line;
   Metadata *Type;
   unsigned Arg;
   unsigned Flags;
 
-  MDNodeKeyImpl(Metadata *Scope, StringRef Name, Metadata *File, unsigned Line,
+  MDNodeKeyImpl(Metadata *Scope, MDString *Name, Metadata *File, unsigned Line,
                 Metadata *Type, unsigned Arg, unsigned Flags)
       : Scope(Scope), Name(Name), File(File), Line(Line), Type(Type), Arg(Arg),
         Flags(Flags) {}
   MDNodeKeyImpl(const DILocalVariable *N)
-      : Scope(N->getRawScope()), Name(N->getName()), File(N->getRawFile()),
+      : Scope(N->getRawScope()), Name(N->getRawName()), File(N->getRawFile()),
         Line(N->getLine()), Type(N->getRawType()), Arg(N->getArg()),
         Flags(N->getFlags()) {}
 
   bool isKeyOf(const DILocalVariable *RHS) const {
-    return Scope == RHS->getRawScope() && Name == RHS->getName() &&
+    return Scope == RHS->getRawScope() && Name == RHS->getRawName() &&
            File == RHS->getRawFile() && Line == RHS->getLine() &&
            Type == RHS->getRawType() && Arg == RHS->getArg() &&
            Flags == RHS->getFlags();
   }
   unsigned getHashValue() const {
     return hash_combine(Scope, Name, File, Line, Type, Arg, Flags);
   }
 };
 
 template <> struct MDNodeKeyImpl<DIExpression> {
   ArrayRef<uint64_t> Elements;
 
   MDNodeKeyImpl(ArrayRef<uint64_t> Elements) : Elements(Elements) {}
   MDNodeKeyImpl(const DIExpression *N) : Elements(N->getElements()) {}
 
   bool isKeyOf(const DIExpression *RHS) const {
     return Elements == RHS->getElements();
   }
   unsigned getHashValue() const {
     return hash_combine_range(Elements.begin(), Elements.end());
   }
 };
 
 template <> struct MDNodeKeyImpl<DIObjCProperty> {
-  StringRef Name;
+  MDString *Name;
   Metadata *File;
   unsigned Line;
-  StringRef GetterName;
-  StringRef SetterName;
+  MDString *GetterName;
+  MDString *SetterName;
   unsigned Attributes;
   Metadata *Type;
 
-  MDNodeKeyImpl(StringRef Name, Metadata *File, unsigned Line,
-                StringRef GetterName, StringRef SetterName, unsigned Attributes,
+  MDNodeKeyImpl(MDString *Name, Metadata *File, unsigned Line,
+                MDString *GetterName, MDString *SetterName, unsigned Attributes,
                 Metadata *Type)
       : Name(Name), File(File), Line(Line), GetterName(GetterName),
         SetterName(SetterName), Attributes(Attributes), Type(Type) {}
   MDNodeKeyImpl(const DIObjCProperty *N)
-      : Name(N->getName()), File(N->getRawFile()), Line(N->getLine()),
-        GetterName(N->getGetterName()), SetterName(N->getSetterName()),
+      : Name(N->getRawName()), File(N->getRawFile()), Line(N->getLine()),
+        GetterName(N->getRawGetterName()), SetterName(N->getRawSetterName()),
         Attributes(N->getAttributes()), Type(N->getRawType()) {}
 
   bool isKeyOf(const DIObjCProperty *RHS) const {
-    return Name == RHS->getName() && File == RHS->getRawFile() &&
-           Line == RHS->getLine() && GetterName == RHS->getGetterName() &&
-           SetterName == RHS->getSetterName() &&
+    return Name == RHS->getRawName() && File == RHS->getRawFile() &&
+           Line == RHS->getLine() && GetterName == RHS->getRawGetterName() &&
+           SetterName == RHS->getRawSetterName() &&
            Attributes == RHS->getAttributes() && Type == RHS->getRawType();
   }
   unsigned getHashValue() const {
     return hash_combine(Name, File, Line, GetterName, SetterName, Attributes,
                         Type);
   }
 };
 
 template <> struct MDNodeKeyImpl<DIImportedEntity> {
   unsigned Tag;
   Metadata *Scope;
   Metadata *Entity;
   unsigned Line;
-  StringRef Name;
+  MDString *Name;
 
   MDNodeKeyImpl(unsigned Tag, Metadata *Scope, Metadata *Entity, unsigned Line,
-                StringRef Name)
+                MDString *Name)
       : Tag(Tag), Scope(Scope), Entity(Entity), Line(Line), Name(Name) {}
   MDNodeKeyImpl(const DIImportedEntity *N)
       : Tag(N->getTag()), Scope(N->getRawScope()), Entity(N->getRawEntity()),
-        Line(N->getLine()), Name(N->getName()) {}
+        Line(N->getLine()), Name(N->getRawName()) {}
 
   bool isKeyOf(const DIImportedEntity *RHS) const {
     return Tag == RHS->getTag() && Scope == RHS->getRawScope() &&
            Entity == RHS->getRawEntity() && Line == RHS->getLine() &&
-           Name == RHS->getName();
+           Name == RHS->getRawName();
   }
   unsigned getHashValue() const {
     return hash_combine(Tag, Scope, Entity, Line, Name);
   }
 };
 
 template <> struct MDNodeKeyImpl<DIMacro> {
   unsigned MIType;
   unsigned Line;
-  StringRef Name;
-  StringRef Value;
+  MDString *Name;
+  MDString *Value;
 
-  MDNodeKeyImpl(unsigned MIType, unsigned Line, StringRef Name, StringRef Value)
+  MDNodeKeyImpl(unsigned MIType, unsigned Line, MDString *Name, MDString *Value)
       : MIType(MIType), Line(Line), Name(Name), Value(Value) {}
   MDNodeKeyImpl(const DIMacro *N)
-      : MIType(N->getMacinfoType()), Line(N->getLine()), Name(N->getName()),
-        Value(N->getValue()) {}
+      : MIType(N->getMacinfoType()), Line(N->getLine()), Name(N->getRawName()),
+        Value(N->getRawValue()) {}
 
   bool isKeyOf(const DIMacro *RHS) const {
     return MIType == RHS->getMacinfoType() && Line == RHS->getLine() &&
-           Name == RHS->getName() && Value == RHS->getValue();
+           Name == RHS->getRawName() && Value == RHS->getRawValue();
   }
   unsigned getHashValue() const {
     return hash_combine(MIType, Line, Name, Value);
   }
 };
 
 template <> struct MDNodeKeyImpl<DIMacroFile> {
   unsigned MIType;