X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FIR%2FLLVMContextImpl.h;h=cf0aa5c62ab7af0dd4fbed036f81eb64d645b845;hb=5646beae513b6d6247eee89d03bb62ac6e05ee6e;hp=3c61c06b81a278e05b634d6c038670cb56aa385b;hpb=eac950e4085c349f0ac06ecab4854e175c7d92d4;p=oota-llvm.git

diff --git a/lib/IR/LLVMContextImpl.h b/lib/IR/LLVMContextImpl.h
index 3c61c06b81a..cf0aa5c62ab 100644
--- a/lib/IR/LLVMContextImpl.h
+++ b/lib/IR/LLVMContextImpl.h
@@ -228,8 +228,8 @@ template <> struct MDNodeKeyImpl<MDTuple> : MDNodeOpsKey {
   }
 };
 
-/// \brief DenseMapInfo for MDLocation.
-template <> struct MDNodeKeyImpl<MDLocation> {
+/// \brief DenseMapInfo for DILocation.
+template <> struct MDNodeKeyImpl<DILocation> {
   unsigned Line;
   unsigned Column;
   Metadata *Scope;
@@ -239,83 +239,85 @@ template <> struct MDNodeKeyImpl<MDLocation> {
                 Metadata *InlinedAt)
       : Line(Line), Column(Column), Scope(Scope), InlinedAt(InlinedAt) {}
 
-  MDNodeKeyImpl(const MDLocation *L)
-      : Line(L->getLine()), Column(L->getColumn()), Scope(L->getScope()),
-        InlinedAt(L->getInlinedAt()) {}
+  MDNodeKeyImpl(const DILocation *L)
+      : Line(L->getLine()), Column(L->getColumn()), Scope(L->getRawScope()),
+        InlinedAt(L->getRawInlinedAt()) {}
 
-  bool isKeyOf(const MDLocation *RHS) const {
+  bool isKeyOf(const DILocation *RHS) const {
     return Line == RHS->getLine() && Column == RHS->getColumn() &&
-           Scope == RHS->getScope() && InlinedAt == RHS->getInlinedAt();
+           Scope == RHS->getRawScope() && InlinedAt == RHS->getRawInlinedAt();
   }
   unsigned getHashValue() const {
     return hash_combine(Line, Column, Scope, InlinedAt);
   }
 };
 
-/// \brief DenseMapInfo for GenericDebugNode.
-template <> struct MDNodeKeyImpl<GenericDebugNode> : MDNodeOpsKey {
+/// \brief DenseMapInfo for GenericDINode.
+template <> struct MDNodeKeyImpl<GenericDINode> : MDNodeOpsKey {
   unsigned Tag;
   StringRef Header;
   MDNodeKeyImpl(unsigned Tag, StringRef Header, ArrayRef<Metadata *> DwarfOps)
       : MDNodeOpsKey(DwarfOps), Tag(Tag), Header(Header) {}
-  MDNodeKeyImpl(const GenericDebugNode *N)
+  MDNodeKeyImpl(const GenericDINode *N)
       : MDNodeOpsKey(N, 1), Tag(N->getTag()), Header(N->getHeader()) {}
 
-  bool isKeyOf(const GenericDebugNode *RHS) const {
+  bool isKeyOf(const GenericDINode *RHS) const {
     return Tag == RHS->getTag() && Header == RHS->getHeader() &&
            compareOps(RHS, 1);
   }
 
   unsigned getHashValue() const { return hash_combine(getHash(), Tag, Header); }
 
-  static unsigned calculateHash(GenericDebugNode *N) {
+  static unsigned calculateHash(GenericDINode *N) {
     return MDNodeOpsKey::calculateHash(N, 1);
   }
 };
 
-template <> struct MDNodeKeyImpl<MDSubrange> {
+template <> struct MDNodeKeyImpl<DISubrange> {
   int64_t Count;
-  int64_t Lo;
+  int64_t LowerBound;
 
-  MDNodeKeyImpl(int64_t Count, int64_t Lo) : Count(Count), Lo(Lo) {}
-  MDNodeKeyImpl(const MDSubrange *N) : Count(N->getCount()), Lo(N->getLo()) {}
+  MDNodeKeyImpl(int64_t Count, int64_t LowerBound)
+      : Count(Count), LowerBound(LowerBound) {}
+  MDNodeKeyImpl(const DISubrange *N)
+      : Count(N->getCount()), LowerBound(N->getLowerBound()) {}
 
-  bool isKeyOf(const MDSubrange *RHS) const {
-    return Count == RHS->getCount() && Lo == RHS->getLo();
+  bool isKeyOf(const DISubrange *RHS) const {
+    return Count == RHS->getCount() && LowerBound == RHS->getLowerBound();
   }
-  unsigned getHashValue() const { return hash_combine(Count, Lo); }
+  unsigned getHashValue() const { return hash_combine(Count, LowerBound); }
 };
 
-template <> struct MDNodeKeyImpl<MDEnumerator> {
+template <> struct MDNodeKeyImpl<DIEnumerator> {
   int64_t Value;
   StringRef Name;
 
   MDNodeKeyImpl(int64_t Value, StringRef Name) : Value(Value), Name(Name) {}
-  MDNodeKeyImpl(const MDEnumerator *N)
+  MDNodeKeyImpl(const DIEnumerator *N)
       : Value(N->getValue()), Name(N->getName()) {}
 
-  bool isKeyOf(const MDEnumerator *RHS) const {
+  bool isKeyOf(const DIEnumerator *RHS) const {
     return Value == RHS->getValue() && Name == RHS->getName();
   }
   unsigned getHashValue() const { return hash_combine(Value, Name); }
 };
 
-template <> struct MDNodeKeyImpl<MDBasicType> {
+template <> struct MDNodeKeyImpl<DIBasicType> {
   unsigned Tag;
   StringRef Name;
-  unsigned SizeInBits;
-  unsigned AlignInBits;
+  uint64_t SizeInBits;
+  uint64_t AlignInBits;
   unsigned Encoding;
 
-  MDNodeKeyImpl(unsigned Tag, StringRef Name, unsigned SizeInBits,
-                unsigned AlignInBits, unsigned Encoding)
+  MDNodeKeyImpl(unsigned Tag, StringRef Name, uint64_t SizeInBits,
+                uint64_t AlignInBits, unsigned Encoding)
       : Tag(Tag), Name(Name), SizeInBits(SizeInBits), AlignInBits(AlignInBits),
         Encoding(Encoding) {}
-  MDNodeKeyImpl(const MDBasicType *N)
+  MDNodeKeyImpl(const DIBasicType *N)
       : Tag(N->getTag()), Name(N->getName()), SizeInBits(N->getSizeInBits()),
         AlignInBits(N->getAlignInBits()), Encoding(N->getEncoding()) {}
 
-  bool isKeyOf(const MDBasicType *RHS) const {
+  bool isKeyOf(const DIBasicType *RHS) const {
     return Tag == RHS->getTag() && Name == RHS->getName() &&
            SizeInBits == RHS->getSizeInBits() &&
            AlignInBits == RHS->getAlignInBits() &&
@@ -326,41 +328,41 @@ template <> struct MDNodeKeyImpl<MDBasicType> {
   }
 };
 
-template <> struct MDNodeKeyImpl<MDDerivedType> {
+template <> struct MDNodeKeyImpl<DIDerivedType> {
   unsigned Tag;
   StringRef Name;
   Metadata *File;
   unsigned Line;
   Metadata *Scope;
   Metadata *BaseType;
-  unsigned SizeInBits;
-  unsigned AlignInBits;
-  unsigned OffsetInBits;
+  uint64_t SizeInBits;
+  uint64_t AlignInBits;
+  uint64_t OffsetInBits;
   unsigned Flags;
   Metadata *ExtraData;
 
   MDNodeKeyImpl(unsigned Tag, StringRef Name, Metadata *File, unsigned Line,
-                Metadata *Scope, Metadata *BaseType, unsigned SizeInBits,
-                unsigned AlignInBits, unsigned OffsetInBits, unsigned Flags,
+                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 MDDerivedType *N)
-      : Tag(N->getTag()), Name(N->getName()), File(N->getFile()),
-        Line(N->getLine()), Scope(N->getScope()), BaseType(N->getBaseType()),
-        SizeInBits(N->getSizeInBits()), AlignInBits(N->getAlignInBits()),
-        OffsetInBits(N->getOffsetInBits()), Flags(N->getFlags()),
-        ExtraData(N->getExtraData()) {}
-
-  bool isKeyOf(const MDDerivedType *RHS) const {
+  MDNodeKeyImpl(const DIDerivedType *N)
+      : Tag(N->getTag()), Name(N->getName()), 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() &&
-           File == RHS->getFile() && Line == RHS->getLine() &&
-           Scope == RHS->getScope() && BaseType == RHS->getBaseType() &&
+           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->getExtraData();
+           ExtraData == RHS->getRawExtraData();
   }
   unsigned getHashValue() const {
     return hash_combine(Tag, Name, File, Line, Scope, BaseType, SizeInBits,
@@ -368,16 +370,16 @@ template <> struct MDNodeKeyImpl<MDDerivedType> {
   }
 };
 
-template <> struct MDNodeKeyImpl<MDCompositeType> {
+template <> struct MDNodeKeyImpl<DICompositeType> {
   unsigned Tag;
   StringRef Name;
   Metadata *File;
   unsigned Line;
   Metadata *Scope;
   Metadata *BaseType;
-  unsigned SizeInBits;
-  unsigned AlignInBits;
-  unsigned OffsetInBits;
+  uint64_t SizeInBits;
+  uint64_t AlignInBits;
+  uint64_t OffsetInBits;
   unsigned Flags;
   Metadata *Elements;
   unsigned RuntimeLang;
@@ -386,8 +388,8 @@ template <> struct MDNodeKeyImpl<MDCompositeType> {
   StringRef Identifier;
 
   MDNodeKeyImpl(unsigned Tag, StringRef Name, Metadata *File, unsigned Line,
-                Metadata *Scope, Metadata *BaseType, unsigned SizeInBits,
-                unsigned AlignInBits, unsigned OffsetInBits, unsigned Flags,
+                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)
@@ -396,27 +398,27 @@ template <> struct MDNodeKeyImpl<MDCompositeType> {
         OffsetInBits(OffsetInBits), Flags(Flags), Elements(Elements),
         RuntimeLang(RuntimeLang), VTableHolder(VTableHolder),
         TemplateParams(TemplateParams), Identifier(Identifier) {}
-  MDNodeKeyImpl(const MDCompositeType *N)
-      : Tag(N->getTag()), Name(N->getName()), File(N->getFile()),
-        Line(N->getLine()), Scope(N->getScope()), BaseType(N->getBaseType()),
-        SizeInBits(N->getSizeInBits()), AlignInBits(N->getAlignInBits()),
-        OffsetInBits(N->getOffsetInBits()), Flags(N->getFlags()),
-        Elements(N->getElements()), RuntimeLang(N->getRuntimeLang()),
-        VTableHolder(N->getVTableHolder()),
-        TemplateParams(N->getTemplateParams()), Identifier(N->getIdentifier()) {
-  }
-
-  bool isKeyOf(const MDCompositeType *RHS) const {
+  MDNodeKeyImpl(const DICompositeType *N)
+      : Tag(N->getTag()), Name(N->getName()), 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()) {}
+
+  bool isKeyOf(const DICompositeType *RHS) const {
     return Tag == RHS->getTag() && Name == RHS->getName() &&
-           File == RHS->getFile() && Line == RHS->getLine() &&
-           Scope == RHS->getScope() && BaseType == RHS->getBaseType() &&
+           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->getElements() &&
+           Elements == RHS->getRawElements() &&
            RuntimeLang == RHS->getRuntimeLang() &&
-           VTableHolder == RHS->getVTableHolder() &&
-           TemplateParams == RHS->getTemplateParams() &&
+           VTableHolder == RHS->getRawVTableHolder() &&
+           TemplateParams == RHS->getRawTemplateParams() &&
            Identifier == RHS->getIdentifier();
   }
   unsigned getHashValue() const {
@@ -426,95 +428,37 @@ template <> struct MDNodeKeyImpl<MDCompositeType> {
   }
 };
 
-template <> struct MDNodeKeyImpl<MDSubroutineType> {
+template <> struct MDNodeKeyImpl<DISubroutineType> {
   unsigned Flags;
   Metadata *TypeArray;
 
   MDNodeKeyImpl(int64_t Flags, Metadata *TypeArray)
       : Flags(Flags), TypeArray(TypeArray) {}
-  MDNodeKeyImpl(const MDSubroutineType *N)
-      : Flags(N->getFlags()), TypeArray(N->getTypeArray()) {}
+  MDNodeKeyImpl(const DISubroutineType *N)
+      : Flags(N->getFlags()), TypeArray(N->getRawTypeArray()) {}
 
-  bool isKeyOf(const MDSubroutineType *RHS) const {
-    return Flags == RHS->getFlags() && TypeArray == RHS->getTypeArray();
+  bool isKeyOf(const DISubroutineType *RHS) const {
+    return Flags == RHS->getFlags() && TypeArray == RHS->getRawTypeArray();
   }
   unsigned getHashValue() const { return hash_combine(Flags, TypeArray); }
 };
 
-template <> struct MDNodeKeyImpl<MDFile> {
+template <> struct MDNodeKeyImpl<DIFile> {
   StringRef Filename;
   StringRef Directory;
 
   MDNodeKeyImpl(StringRef Filename, StringRef Directory)
       : Filename(Filename), Directory(Directory) {}
-  MDNodeKeyImpl(const MDFile *N)
+  MDNodeKeyImpl(const DIFile *N)
       : Filename(N->getFilename()), Directory(N->getDirectory()) {}
 
-  bool isKeyOf(const MDFile *RHS) const {
+  bool isKeyOf(const DIFile *RHS) const {
     return Filename == RHS->getFilename() && Directory == RHS->getDirectory();
   }
   unsigned getHashValue() const { return hash_combine(Filename, Directory); }
 };
 
-template <> struct MDNodeKeyImpl<MDCompileUnit> {
-  unsigned SourceLanguage;
-  Metadata *File;
-  StringRef Producer;
-  bool IsOptimized;
-  StringRef Flags;
-  unsigned RuntimeVersion;
-  StringRef SplitDebugFilename;
-  unsigned EmissionKind;
-  Metadata *EnumTypes;
-  Metadata *RetainedTypes;
-  Metadata *Subprograms;
-  Metadata *GlobalVariables;
-  Metadata *ImportedEntities;
-
-  MDNodeKeyImpl(unsigned SourceLanguage, Metadata *File, StringRef Producer,
-                bool IsOptimized, StringRef Flags, unsigned RuntimeVersion,
-                StringRef SplitDebugFilename, unsigned EmissionKind,
-                Metadata *EnumTypes, Metadata *RetainedTypes,
-                Metadata *Subprograms, Metadata *GlobalVariables,
-                Metadata *ImportedEntities)
-      : SourceLanguage(SourceLanguage), File(File), Producer(Producer),
-        IsOptimized(IsOptimized), Flags(Flags), RuntimeVersion(RuntimeVersion),
-        SplitDebugFilename(SplitDebugFilename), EmissionKind(EmissionKind),
-        EnumTypes(EnumTypes), RetainedTypes(RetainedTypes),
-        Subprograms(Subprograms), GlobalVariables(GlobalVariables),
-        ImportedEntities(ImportedEntities) {}
-  MDNodeKeyImpl(const MDCompileUnit *N)
-      : SourceLanguage(N->getSourceLanguage()), File(N->getFile()),
-        Producer(N->getProducer()), IsOptimized(N->isOptimized()),
-        Flags(N->getFlags()), RuntimeVersion(N->getRuntimeVersion()),
-        SplitDebugFilename(N->getSplitDebugFilename()),
-        EmissionKind(N->getEmissionKind()), EnumTypes(N->getEnumTypes()),
-        RetainedTypes(N->getRetainedTypes()), Subprograms(N->getSubprograms()),
-        GlobalVariables(N->getGlobalVariables()),
-        ImportedEntities(N->getImportedEntities()) {}
-
-  bool isKeyOf(const MDCompileUnit *RHS) const {
-    return SourceLanguage == RHS->getSourceLanguage() &&
-           File == RHS->getFile() && Producer == RHS->getProducer() &&
-           IsOptimized == RHS->isOptimized() && Flags == RHS->getFlags() &&
-           RuntimeVersion == RHS->getRuntimeVersion() &&
-           SplitDebugFilename == RHS->getSplitDebugFilename() &&
-           EmissionKind == RHS->getEmissionKind() &&
-           EnumTypes == RHS->getEnumTypes() &&
-           RetainedTypes == RHS->getRetainedTypes() &&
-           Subprograms == RHS->getSubprograms() &&
-           GlobalVariables == RHS->getGlobalVariables() &&
-           ImportedEntities == RHS->getImportedEntities();
-  }
-  unsigned getHashValue() const {
-    return hash_combine(SourceLanguage, File, Producer, IsOptimized, Flags,
-                        RuntimeVersion, SplitDebugFilename, EmissionKind,
-                        EnumTypes, RetainedTypes, Subprograms, GlobalVariables,
-                        ImportedEntities);
-  }
-};
-
-template <> struct MDNodeKeyImpl<MDSubprogram> {
+template <> struct MDNodeKeyImpl<DISubprogram> {
   Metadata *Scope;
   StringRef Name;
   StringRef LinkageName;
@@ -548,32 +492,33 @@ template <> struct MDNodeKeyImpl<MDSubprogram> {
         VirtualIndex(VirtualIndex), Flags(Flags), IsOptimized(IsOptimized),
         Function(Function), TemplateParams(TemplateParams),
         Declaration(Declaration), Variables(Variables) {}
-  MDNodeKeyImpl(const MDSubprogram *N)
-      : Scope(N->getScope()), Name(N->getName()),
-        LinkageName(N->getLinkageName()), File(N->getFile()),
-        Line(N->getLine()), Type(N->getType()),
+  MDNodeKeyImpl(const DISubprogram *N)
+      : Scope(N->getRawScope()), Name(N->getName()),
+        LinkageName(N->getLinkageName()), File(N->getRawFile()),
+        Line(N->getLine()), Type(N->getRawType()),
         IsLocalToUnit(N->isLocalToUnit()), IsDefinition(N->isDefinition()),
-        ScopeLine(N->getScopeLine()), ContainingType(N->getContainingType()),
+        ScopeLine(N->getScopeLine()), ContainingType(N->getRawContainingType()),
         Virtuality(N->getVirtuality()), VirtualIndex(N->getVirtualIndex()),
         Flags(N->getFlags()), IsOptimized(N->isOptimized()),
-        Function(N->getFunction()), TemplateParams(N->getTemplateParams()),
-        Declaration(N->getDeclaration()), Variables(N->getVariables()) {}
-
-  bool isKeyOf(const MDSubprogram *RHS) const {
-    return Scope == RHS->getScope() && Name == RHS->getName() &&
-           LinkageName == RHS->getLinkageName() && File == RHS->getFile() &&
-           Line == RHS->getLine() && Type == RHS->getType() &&
+        Function(N->getRawFunction()),
+        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() &&
            IsDefinition == RHS->isDefinition() &&
            ScopeLine == RHS->getScopeLine() &&
-           ContainingType == RHS->getContainingType() &&
+           ContainingType == RHS->getRawContainingType() &&
            Virtuality == RHS->getVirtuality() &&
            VirtualIndex == RHS->getVirtualIndex() && Flags == RHS->getFlags() &&
            IsOptimized == RHS->isOptimized() &&
-           Function == RHS->getFunction() &&
-           TemplateParams == RHS->getTemplateParams() &&
-           Declaration == RHS->getDeclaration() &&
-           Variables == RHS->getVariables();
+           Function == RHS->getRawFunction() &&
+           TemplateParams == RHS->getRawTemplateParams() &&
+           Declaration == RHS->getRawDeclaration() &&
+           Variables == RHS->getRawVariables();
   }
   unsigned getHashValue() const {
     return hash_combine(Scope, Name, LinkageName, File, Line, Type,
@@ -583,7 +528,7 @@ template <> struct MDNodeKeyImpl<MDSubprogram> {
   }
 };
 
-template <> struct MDNodeKeyImpl<MDLexicalBlock> {
+template <> struct MDNodeKeyImpl<DILexicalBlock> {
   Metadata *Scope;
   Metadata *File;
   unsigned Line;
@@ -591,12 +536,12 @@ template <> struct MDNodeKeyImpl<MDLexicalBlock> {
 
   MDNodeKeyImpl(Metadata *Scope, Metadata *File, unsigned Line, unsigned Column)
       : Scope(Scope), File(File), Line(Line), Column(Column) {}
-  MDNodeKeyImpl(const MDLexicalBlock *N)
-      : Scope(N->getScope()), File(N->getFile()), Line(N->getLine()),
+  MDNodeKeyImpl(const DILexicalBlock *N)
+      : Scope(N->getRawScope()), File(N->getRawFile()), Line(N->getLine()),
         Column(N->getColumn()) {}
 
-  bool isKeyOf(const MDLexicalBlock *RHS) const {
-    return Scope == RHS->getScope() && File == RHS->getFile() &&
+  bool isKeyOf(const DILexicalBlock *RHS) const {
+    return Scope == RHS->getRawScope() && File == RHS->getRawFile() &&
            Line == RHS->getLine() && Column == RHS->getColumn();
   }
   unsigned getHashValue() const {
@@ -604,19 +549,19 @@ template <> struct MDNodeKeyImpl<MDLexicalBlock> {
   }
 };
 
-template <> struct MDNodeKeyImpl<MDLexicalBlockFile> {
+template <> struct MDNodeKeyImpl<DILexicalBlockFile> {
   Metadata *Scope;
   Metadata *File;
   unsigned Discriminator;
 
   MDNodeKeyImpl(Metadata *Scope, Metadata *File, unsigned Discriminator)
       : Scope(Scope), File(File), Discriminator(Discriminator) {}
-  MDNodeKeyImpl(const MDLexicalBlockFile *N)
-      : Scope(N->getScope()), File(N->getFile()),
+  MDNodeKeyImpl(const DILexicalBlockFile *N)
+      : Scope(N->getRawScope()), File(N->getRawFile()),
         Discriminator(N->getDiscriminator()) {}
 
-  bool isKeyOf(const MDLexicalBlockFile *RHS) const {
-    return Scope == RHS->getScope() && File == RHS->getFile() &&
+  bool isKeyOf(const DILexicalBlockFile *RHS) const {
+    return Scope == RHS->getRawScope() && File == RHS->getRawFile() &&
            Discriminator == RHS->getDiscriminator();
   }
   unsigned getHashValue() const {
@@ -624,7 +569,7 @@ template <> struct MDNodeKeyImpl<MDLexicalBlockFile> {
   }
 };
 
-template <> struct MDNodeKeyImpl<MDNamespace> {
+template <> struct MDNodeKeyImpl<DINamespace> {
   Metadata *Scope;
   Metadata *File;
   StringRef Name;
@@ -632,12 +577,12 @@ template <> struct MDNodeKeyImpl<MDNamespace> {
 
   MDNodeKeyImpl(Metadata *Scope, Metadata *File, StringRef Name, unsigned Line)
       : Scope(Scope), File(File), Name(Name), Line(Line) {}
-  MDNodeKeyImpl(const MDNamespace *N)
-      : Scope(N->getScope()), File(N->getFile()), Name(N->getName()),
+  MDNodeKeyImpl(const DINamespace *N)
+      : Scope(N->getRawScope()), File(N->getRawFile()), Name(N->getName()),
         Line(N->getLine()) {}
 
-  bool isKeyOf(const MDNamespace *RHS) const {
-    return Scope == RHS->getScope() && File == RHS->getFile() &&
+  bool isKeyOf(const DINamespace *RHS) const {
+    return Scope == RHS->getRawScope() && File == RHS->getRawFile() &&
            Name == RHS->getName() && Line == RHS->getLine();
   }
   unsigned getHashValue() const {
@@ -645,21 +590,50 @@ template <> struct MDNodeKeyImpl<MDNamespace> {
   }
 };
 
-template <> struct MDNodeKeyImpl<MDTemplateTypeParameter> {
+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)
+    : 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()) {}
+
+  bool isKeyOf(const DIModule *RHS) const {
+    return Scope == RHS->getRawScope() && Name == RHS->getName() &&
+           ConfigurationMacros == RHS->getConfigurationMacros() &&
+           IncludePath == RHS->getIncludePath() &&
+           ISysRoot == RHS->getISysRoot();
+  }
+  unsigned getHashValue() const {
+    return hash_combine(Scope, Name,
+                        ConfigurationMacros, IncludePath, ISysRoot);
+  }
+};
+
+template <> struct MDNodeKeyImpl<DITemplateTypeParameter> {
   StringRef Name;
   Metadata *Type;
 
   MDNodeKeyImpl(StringRef Name, Metadata *Type) : Name(Name), Type(Type) {}
-  MDNodeKeyImpl(const MDTemplateTypeParameter *N)
-      : Name(N->getName()), Type(N->getType()) {}
+  MDNodeKeyImpl(const DITemplateTypeParameter *N)
+      : Name(N->getName()), Type(N->getRawType()) {}
 
-  bool isKeyOf(const MDTemplateTypeParameter *RHS) const {
-    return Name == RHS->getName() && Type == RHS->getType();
+  bool isKeyOf(const DITemplateTypeParameter *RHS) const {
+    return Name == RHS->getName() && Type == RHS->getRawType();
   }
   unsigned getHashValue() const { return hash_combine(Name, Type); }
 };
 
-template <> struct MDNodeKeyImpl<MDTemplateValueParameter> {
+template <> struct MDNodeKeyImpl<DITemplateValueParameter> {
   unsigned Tag;
   StringRef Name;
   Metadata *Type;
@@ -667,18 +641,18 @@ template <> struct MDNodeKeyImpl<MDTemplateValueParameter> {
 
   MDNodeKeyImpl(unsigned Tag, StringRef Name, Metadata *Type, Metadata *Value)
       : Tag(Tag), Name(Name), Type(Type), Value(Value) {}
-  MDNodeKeyImpl(const MDTemplateValueParameter *N)
-      : Tag(N->getTag()), Name(N->getName()), Type(N->getType()),
+  MDNodeKeyImpl(const DITemplateValueParameter *N)
+      : Tag(N->getTag()), Name(N->getName()), Type(N->getRawType()),
         Value(N->getValue()) {}
 
-  bool isKeyOf(const MDTemplateValueParameter *RHS) const {
+  bool isKeyOf(const DITemplateValueParameter *RHS) const {
     return Tag == RHS->getTag() && Name == RHS->getName() &&
-           Type == RHS->getType() && Value == RHS->getValue();
+           Type == RHS->getRawType() && Value == RHS->getValue();
   }
   unsigned getHashValue() const { return hash_combine(Tag, Name, Type, Value); }
 };
 
-template <> struct MDNodeKeyImpl<MDGlobalVariable> {
+template <> struct MDNodeKeyImpl<DIGlobalVariable> {
   Metadata *Scope;
   StringRef Name;
   StringRef LinkageName;
@@ -698,22 +672,23 @@ template <> struct MDNodeKeyImpl<MDGlobalVariable> {
         Line(Line), Type(Type), IsLocalToUnit(IsLocalToUnit),
         IsDefinition(IsDefinition), Variable(Variable),
         StaticDataMemberDeclaration(StaticDataMemberDeclaration) {}
-  MDNodeKeyImpl(const MDGlobalVariable *N)
-      : Scope(N->getScope()), Name(N->getName()),
-        LinkageName(N->getLinkageName()), File(N->getFile()),
-        Line(N->getLine()), Type(N->getType()),
+  MDNodeKeyImpl(const DIGlobalVariable *N)
+      : Scope(N->getRawScope()), Name(N->getName()),
+        LinkageName(N->getLinkageName()), File(N->getRawFile()),
+        Line(N->getLine()), Type(N->getRawType()),
         IsLocalToUnit(N->isLocalToUnit()), IsDefinition(N->isDefinition()),
-        Variable(N->getVariable()),
-        StaticDataMemberDeclaration(N->getStaticDataMemberDeclaration()) {}
+        Variable(N->getRawVariable()),
+        StaticDataMemberDeclaration(N->getRawStaticDataMemberDeclaration()) {}
 
-  bool isKeyOf(const MDGlobalVariable *RHS) const {
-    return Scope == RHS->getScope() && Name == RHS->getName() &&
-           LinkageName == RHS->getLinkageName() && File == RHS->getFile() &&
-           Line == RHS->getLine() && Type == RHS->getType() &&
+  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() &&
            IsDefinition == RHS->isDefinition() &&
-           Variable == RHS->getVariable() &&
-           StaticDataMemberDeclaration == RHS->getStaticDataMemberDeclaration();
+           Variable == RHS->getRawVariable() &&
+           StaticDataMemberDeclaration ==
+               RHS->getRawStaticDataMemberDeclaration();
   }
   unsigned getHashValue() const {
     return hash_combine(Scope, Name, LinkageName, File, Line, Type,
@@ -722,8 +697,7 @@ template <> struct MDNodeKeyImpl<MDGlobalVariable> {
   }
 };
 
-template <> struct MDNodeKeyImpl<MDLocalVariable> {
-  unsigned Tag;
+template <> struct MDNodeKeyImpl<DILocalVariable> {
   Metadata *Scope;
   StringRef Name;
   Metadata *File;
@@ -731,38 +705,34 @@ template <> struct MDNodeKeyImpl<MDLocalVariable> {
   Metadata *Type;
   unsigned Arg;
   unsigned Flags;
-  Metadata *InlinedAt;
 
-  MDNodeKeyImpl(unsigned Tag, Metadata *Scope, StringRef Name, Metadata *File,
-                unsigned Line, Metadata *Type, unsigned Arg, unsigned Flags,
-                Metadata *InlinedAt)
-      : Tag(Tag), Scope(Scope), Name(Name), File(File), Line(Line), Type(Type),
-        Arg(Arg), Flags(Flags), InlinedAt(InlinedAt) {}
-  MDNodeKeyImpl(const MDLocalVariable *N)
-      : Tag(N->getTag()), Scope(N->getScope()), Name(N->getName()),
-        File(N->getFile()), Line(N->getLine()), Type(N->getType()),
-        Arg(N->getArg()), Flags(N->getFlags()), InlinedAt(N->getInlinedAt()) {}
-
-  bool isKeyOf(const MDLocalVariable *RHS) const {
-    return Tag == RHS->getTag() && Scope == RHS->getScope() &&
-           Name == RHS->getName() && File == RHS->getFile() &&
-           Line == RHS->getLine() && Type == RHS->getType() &&
-           Arg == RHS->getArg() && Flags == RHS->getFlags() &&
-           InlinedAt == RHS->getInlinedAt();
+  MDNodeKeyImpl(Metadata *Scope, StringRef 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()),
+        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() &&
+           File == RHS->getRawFile() && Line == RHS->getLine() &&
+           Type == RHS->getRawType() && Arg == RHS->getArg() &&
+           Flags == RHS->getFlags();
   }
   unsigned getHashValue() const {
-    return hash_combine(Tag, Scope, Name, File, Line, Type, Arg, Flags,
-                        InlinedAt);
+    return hash_combine(Scope, Name, File, Line, Type, Arg, Flags);
   }
 };
 
-template <> struct MDNodeKeyImpl<MDExpression> {
+template <> struct MDNodeKeyImpl<DIExpression> {
   ArrayRef<uint64_t> Elements;
 
   MDNodeKeyImpl(ArrayRef<uint64_t> Elements) : Elements(Elements) {}
-  MDNodeKeyImpl(const MDExpression *N) : Elements(N->getElements()) {}
+  MDNodeKeyImpl(const DIExpression *N) : Elements(N->getElements()) {}
 
-  bool isKeyOf(const MDExpression *RHS) const {
+  bool isKeyOf(const DIExpression *RHS) const {
     return Elements == RHS->getElements();
   }
   unsigned getHashValue() const {
@@ -770,7 +740,7 @@ template <> struct MDNodeKeyImpl<MDExpression> {
   }
 };
 
-template <> struct MDNodeKeyImpl<MDObjCProperty> {
+template <> struct MDNodeKeyImpl<DIObjCProperty> {
   StringRef Name;
   Metadata *File;
   unsigned Line;
@@ -784,16 +754,16 @@ template <> struct MDNodeKeyImpl<MDObjCProperty> {
                 Metadata *Type)
       : Name(Name), File(File), Line(Line), GetterName(GetterName),
         SetterName(SetterName), Attributes(Attributes), Type(Type) {}
-  MDNodeKeyImpl(const MDObjCProperty *N)
-      : Name(N->getName()), File(N->getFile()), Line(N->getLine()),
+  MDNodeKeyImpl(const DIObjCProperty *N)
+      : Name(N->getName()), File(N->getRawFile()), Line(N->getLine()),
         GetterName(N->getGetterName()), SetterName(N->getSetterName()),
-        Attributes(N->getAttributes()), Type(N->getType()) {}
+        Attributes(N->getAttributes()), Type(N->getRawType()) {}
 
-  bool isKeyOf(const MDObjCProperty *RHS) const {
-    return Name == RHS->getName() && File == RHS->getFile() &&
+  bool isKeyOf(const DIObjCProperty *RHS) const {
+    return Name == RHS->getName() && File == RHS->getRawFile() &&
            Line == RHS->getLine() && GetterName == RHS->getGetterName() &&
            SetterName == RHS->getSetterName() &&
-           Attributes == RHS->getAttributes() && Type == RHS->getType();
+           Attributes == RHS->getAttributes() && Type == RHS->getRawType();
   }
   unsigned getHashValue() const {
     return hash_combine(Name, File, Line, GetterName, SetterName, Attributes,
@@ -801,7 +771,7 @@ template <> struct MDNodeKeyImpl<MDObjCProperty> {
   }
 };
 
-template <> struct MDNodeKeyImpl<MDImportedEntity> {
+template <> struct MDNodeKeyImpl<DIImportedEntity> {
   unsigned Tag;
   Metadata *Scope;
   Metadata *Entity;
@@ -811,13 +781,13 @@ template <> struct MDNodeKeyImpl<MDImportedEntity> {
   MDNodeKeyImpl(unsigned Tag, Metadata *Scope, Metadata *Entity, unsigned Line,
                 StringRef Name)
       : Tag(Tag), Scope(Scope), Entity(Entity), Line(Line), Name(Name) {}
-  MDNodeKeyImpl(const MDImportedEntity *N)
-      : Tag(N->getTag()), Scope(N->getScope()), Entity(N->getEntity()),
+  MDNodeKeyImpl(const DIImportedEntity *N)
+      : Tag(N->getTag()), Scope(N->getRawScope()), Entity(N->getRawEntity()),
         Line(N->getLine()), Name(N->getName()) {}
 
-  bool isKeyOf(const MDImportedEntity *RHS) const {
-    return Tag == RHS->getTag() && Scope == RHS->getScope() &&
-           Entity == RHS->getEntity() && Line == RHS->getLine() &&
+  bool isKeyOf(const DIImportedEntity *RHS) const {
+    return Tag == RHS->getTag() && Scope == RHS->getRawScope() &&
+           Entity == RHS->getRawEntity() && Line == RHS->getLine() &&
            Name == RHS->getName();
   }
   unsigned getHashValue() const {
@@ -851,6 +821,44 @@ template <class NodeTy> struct MDNodeInfo {
 #define HANDLE_MDNODE_LEAF(CLASS) typedef MDNodeInfo<CLASS> CLASS##Info;
 #include "llvm/IR/Metadata.def"
 
+/// \brief Map-like storage for metadata attachments.
+class MDAttachmentMap {
+  SmallVector<std::pair<unsigned, TrackingMDNodeRef>, 2> Attachments;
+
+public:
+  bool empty() const { return Attachments.empty(); }
+  size_t size() const { return Attachments.size(); }
+
+  /// \brief Get a particular attachment (if any).
+  MDNode *lookup(unsigned ID) const;
+
+  /// \brief Set an attachment to a particular node.
+  ///
+  /// Set the \c ID attachment to \c MD, replacing the current attachment at \c
+  /// ID (if anyway).
+  void set(unsigned ID, MDNode &MD);
+
+  /// \brief Remove an attachment.
+  ///
+  /// Remove the attachment at \c ID, if any.
+  void erase(unsigned ID);
+
+  /// \brief Copy out all the attachments.
+  ///
+  /// Copies all the current attachments into \c Result, sorting by attachment
+  /// ID.  This function does \em not clear \c Result.
+  void getAll(SmallVectorImpl<std::pair<unsigned, MDNode *>> &Result) const;
+
+  /// \brief Erase matching attachments.
+  ///
+  /// Erases all attachments matching the \c shouldRemove predicate.
+  template <class PredTy> void remove_if(PredTy shouldRemove) {
+    Attachments.erase(
+        std::remove_if(Attachments.begin(), Attachments.end(), shouldRemove),
+        Attachments.end());
+  }
+};
+
 class LLVMContextImpl {
 public:
   /// OwnedModules - The set of modules instantiated in this context, and which
@@ -881,7 +889,10 @@ public:
   DenseMap<Value *, ValueAsMetadata *> ValuesAsMetadata;
   DenseMap<Metadata *, MetadataAsValue *> MetadataAsValues;
 
-#define HANDLE_MDNODE_LEAF(CLASS) DenseSet<CLASS *, CLASS##Info> CLASS##s;
+  DenseMap<const Value*, ValueName*> ValueNames;
+
+#define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS)                                    \
+  DenseSet<CLASS *, CLASS##Info> CLASS##s;
 #include "llvm/IR/Metadata.def"
 
   // MDNodes may be uniqued or not uniqued.  When they're not uniqued, they
@@ -917,9 +928,9 @@ public:
   ConstantInt *TheFalseVal;
 
   // Basic type instances.
-  Type VoidTy, LabelTy, HalfTy, FloatTy, DoubleTy, MetadataTy;
+  Type VoidTy, LabelTy, HalfTy, FloatTy, DoubleTy, MetadataTy, TokenTy;
   Type X86_FP80Ty, FP128Ty, PPC_FP128Ty, X86_MMXTy;
-  IntegerType Int1Ty, Int8Ty, Int16Ty, Int32Ty, Int64Ty;
+  IntegerType Int1Ty, Int8Ty, Int16Ty, Int32Ty, Int64Ty, Int128Ty;
 
   
   /// TypeAllocator - All dynamically allocated types are allocated from this.
@@ -950,23 +961,17 @@ public:
   /// CustomMDKindNames - Map to hold the metadata string to ID mapping.
   StringMap<unsigned> CustomMDKindNames;
 
-  typedef std::pair<unsigned, TrackingMDNodeRef> MDPairTy;
-  typedef SmallVector<MDPairTy, 2> MDMapTy;
+  /// Collection of per-instruction metadata used in this context.
+  DenseMap<const Instruction *, MDAttachmentMap> InstructionMetadata;
+
+  /// Collection of per-function metadata used in this context.
+  DenseMap<const Function *, MDAttachmentMap> FunctionMetadata;
 
-  /// MetadataStore - Collection of per-instruction metadata used in this
-  /// context.
-  DenseMap<const Instruction *, MDMapTy> MetadataStore;
-  
   /// DiscriminatorTable - This table maps file:line locations to an
   /// integer representing the next DWARF path discriminator to assign to
   /// instructions in different blocks at the same location.
   DenseMap<std::pair<const char *, unsigned>, unsigned> DiscriminatorTable;
 
-  /// IntrinsicIDCache - Cache of intrinsic name (string) to numeric ID mappings
-  /// requested in this context
-  typedef DenseMap<const Function*, unsigned> IntrinsicIDCacheTy;
-  IntrinsicIDCacheTy IntrinsicIDCache;
-
   /// \brief Mapping from a function to its prefix data, which is stored as the
   /// operand of an unparented ReturnInst so that the prefix data has a Use.
   typedef DenseMap<const Function *, ReturnInst *> PrefixDataMapTy;