1 //===-- LLVMContextImpl.h - The LLVMContextImpl opaque class ----*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 //  This file declares LLVMContextImpl, the opaque implementation
11 //  of LLVMContext.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #ifndef LLVM_LIB_IR_LLVMCONTEXTIMPL_H
16 #define LLVM_LIB_IR_LLVMCONTEXTIMPL_H
17 
18 #include "AttributeImpl.h"
19 #include "ConstantsContext.h"
20 #include "llvm/ADT/APFloat.h"
21 #include "llvm/ADT/APInt.h"
22 #include "llvm/ADT/ArrayRef.h"
23 #include "llvm/ADT/DenseMap.h"
24 #include "llvm/ADT/DenseSet.h"
25 #include "llvm/ADT/FoldingSet.h"
26 #include "llvm/ADT/Hashing.h"
27 #include "llvm/ADT/SmallPtrSet.h"
28 #include "llvm/ADT/StringMap.h"
29 #include "llvm/ADT/StringSet.h"
30 #include "llvm/IR/Constants.h"
31 #include "llvm/IR/DebugInfoMetadata.h"
32 #include "llvm/IR/DerivedTypes.h"
33 #include "llvm/IR/LLVMContext.h"
34 #include "llvm/IR/Metadata.h"
35 #include "llvm/IR/ValueHandle.h"
36 #include "llvm/Support/Dwarf.h"
37 #include "llvm/Support/YAMLTraits.h"
38 #include <vector>
39 
40 namespace llvm {
41 
42 class ConstantInt;
43 class ConstantFP;
44 class DiagnosticInfoOptimizationRemark;
45 class DiagnosticInfoOptimizationRemarkMissed;
46 class DiagnosticInfoOptimizationRemarkAnalysis;
47 class GCStrategy;
48 class LLVMContext;
49 class Type;
50 class Value;
51 
52 struct DenseMapAPIntKeyInfo {
53   static inline APInt getEmptyKey() {
54     APInt V(nullptr, 0);
55     V.VAL = 0;
56     return V;
57   }
58   static inline APInt getTombstoneKey() {
59     APInt V(nullptr, 0);
60     V.VAL = 1;
61     return V;
62   }
63   static unsigned getHashValue(const APInt &Key) {
64     return static_cast<unsigned>(hash_value(Key));
65   }
66   static bool isEqual(const APInt &LHS, const APInt &RHS) {
67     return LHS.getBitWidth() == RHS.getBitWidth() && LHS == RHS;
68   }
69 };
70 
71 struct DenseMapAPFloatKeyInfo {
72   static inline APFloat getEmptyKey() { return APFloat(APFloat::Bogus(), 1); }
73   static inline APFloat getTombstoneKey() { return APFloat(APFloat::Bogus(), 2); }
74   static unsigned getHashValue(const APFloat &Key) {
75     return static_cast<unsigned>(hash_value(Key));
76   }
77   static bool isEqual(const APFloat &LHS, const APFloat &RHS) {
78     return LHS.bitwiseIsEqual(RHS);
79   }
80 };
81 
82 struct AnonStructTypeKeyInfo {
83   struct KeyTy {
84     ArrayRef<Type*> ETypes;
85     bool isPacked;
86     KeyTy(const ArrayRef<Type*>& E, bool P) :
87       ETypes(E), isPacked(P) {}
88     KeyTy(const StructType *ST)
89         : ETypes(ST->elements()), isPacked(ST->isPacked()) {}
90     bool operator==(const KeyTy& that) const {
91       if (isPacked != that.isPacked)
92         return false;
93       if (ETypes != that.ETypes)
94         return false;
95       return true;
96     }
97     bool operator!=(const KeyTy& that) const {
98       return !this->operator==(that);
99     }
100   };
101   static inline StructType* getEmptyKey() {
102     return DenseMapInfo<StructType*>::getEmptyKey();
103   }
104   static inline StructType* getTombstoneKey() {
105     return DenseMapInfo<StructType*>::getTombstoneKey();
106   }
107   static unsigned getHashValue(const KeyTy& Key) {
108     return hash_combine(hash_combine_range(Key.ETypes.begin(),
109                                            Key.ETypes.end()),
110                         Key.isPacked);
111   }
112   static unsigned getHashValue(const StructType *ST) {
113     return getHashValue(KeyTy(ST));
114   }
115   static bool isEqual(const KeyTy& LHS, const StructType *RHS) {
116     if (RHS == getEmptyKey() || RHS == getTombstoneKey())
117       return false;
118     return LHS == KeyTy(RHS);
119   }
120   static bool isEqual(const StructType *LHS, const StructType *RHS) {
121     return LHS == RHS;
122   }
123 };
124 
125 struct FunctionTypeKeyInfo {
126   struct KeyTy {
127     const Type *ReturnType;
128     ArrayRef<Type*> Params;
129     bool isVarArg;
130     KeyTy(const Type* R, const ArrayRef<Type*>& P, bool V) :
131       ReturnType(R), Params(P), isVarArg(V) {}
132     KeyTy(const FunctionType *FT)
133         : ReturnType(FT->getReturnType()), Params(FT->params()),
134           isVarArg(FT->isVarArg()) {}
135     bool operator==(const KeyTy& that) const {
136       if (ReturnType != that.ReturnType)
137         return false;
138       if (isVarArg != that.isVarArg)
139         return false;
140       if (Params != that.Params)
141         return false;
142       return true;
143     }
144     bool operator!=(const KeyTy& that) const {
145       return !this->operator==(that);
146     }
147   };
148   static inline FunctionType* getEmptyKey() {
149     return DenseMapInfo<FunctionType*>::getEmptyKey();
150   }
151   static inline FunctionType* getTombstoneKey() {
152     return DenseMapInfo<FunctionType*>::getTombstoneKey();
153   }
154   static unsigned getHashValue(const KeyTy& Key) {
155     return hash_combine(Key.ReturnType,
156                         hash_combine_range(Key.Params.begin(),
157                                            Key.Params.end()),
158                         Key.isVarArg);
159   }
160   static unsigned getHashValue(const FunctionType *FT) {
161     return getHashValue(KeyTy(FT));
162   }
163   static bool isEqual(const KeyTy& LHS, const FunctionType *RHS) {
164     if (RHS == getEmptyKey() || RHS == getTombstoneKey())
165       return false;
166     return LHS == KeyTy(RHS);
167   }
168   static bool isEqual(const FunctionType *LHS, const FunctionType *RHS) {
169     return LHS == RHS;
170   }
171 };
172 
173 /// \brief Structure for hashing arbitrary MDNode operands.
174 class MDNodeOpsKey {
175   ArrayRef<Metadata *> RawOps;
176   ArrayRef<MDOperand> Ops;
177 
178   unsigned Hash;
179 
180 protected:
181   MDNodeOpsKey(ArrayRef<Metadata *> Ops)
182       : RawOps(Ops), Hash(calculateHash(Ops)) {}
183 
184   template <class NodeTy>
185   MDNodeOpsKey(const NodeTy *N, unsigned Offset = 0)
186       : Ops(N->op_begin() + Offset, N->op_end()), Hash(N->getHash()) {}
187 
188   template <class NodeTy>
189   bool compareOps(const NodeTy *RHS, unsigned Offset = 0) const {
190     if (getHash() != RHS->getHash())
191       return false;
192 
193     assert((RawOps.empty() || Ops.empty()) && "Two sets of operands?");
194     return RawOps.empty() ? compareOps(Ops, RHS, Offset)
195                           : compareOps(RawOps, RHS, Offset);
196   }
197 
198   static unsigned calculateHash(MDNode *N, unsigned Offset = 0);
199 
200 private:
201   template <class T>
202   static bool compareOps(ArrayRef<T> Ops, const MDNode *RHS, unsigned Offset) {
203     if (Ops.size() != RHS->getNumOperands() - Offset)
204       return false;
205     return std::equal(Ops.begin(), Ops.end(), RHS->op_begin() + Offset);
206   }
207 
208   static unsigned calculateHash(ArrayRef<Metadata *> Ops);
209 
210 public:
211   unsigned getHash() const { return Hash; }
212 };
213 
214 template <class NodeTy> struct MDNodeKeyImpl;
215 template <class NodeTy> struct MDNodeInfo;
216 
217 /// Configuration point for MDNodeInfo::isEqual().
218 template <class NodeTy> struct MDNodeSubsetEqualImpl {
219   typedef MDNodeKeyImpl<NodeTy> KeyTy;
220   static bool isSubsetEqual(const KeyTy &LHS, const NodeTy *RHS) {
221     return false;
222   }
223   static bool isSubsetEqual(const NodeTy *LHS, const NodeTy *RHS) {
224     return false;
225   }
226 };
227 
228 /// \brief DenseMapInfo for MDTuple.
229 ///
230 /// Note that we don't need the is-function-local bit, since that's implicit in
231 /// the operands.
232 template <> struct MDNodeKeyImpl<MDTuple> : MDNodeOpsKey {
233   MDNodeKeyImpl(ArrayRef<Metadata *> Ops) : MDNodeOpsKey(Ops) {}
234   MDNodeKeyImpl(const MDTuple *N) : MDNodeOpsKey(N) {}
235 
236   bool isKeyOf(const MDTuple *RHS) const { return compareOps(RHS); }
237 
238   unsigned getHashValue() const { return getHash(); }
239 
240   static unsigned calculateHash(MDTuple *N) {
241     return MDNodeOpsKey::calculateHash(N);
242   }
243 };
244 
245 /// \brief DenseMapInfo for DILocation.
246 template <> struct MDNodeKeyImpl<DILocation> {
247   unsigned Line;
248   unsigned Column;
249   Metadata *Scope;
250   Metadata *InlinedAt;
251 
252   MDNodeKeyImpl(unsigned Line, unsigned Column, Metadata *Scope,
253                 Metadata *InlinedAt)
254       : Line(Line), Column(Column), Scope(Scope), InlinedAt(InlinedAt) {}
255 
256   MDNodeKeyImpl(const DILocation *L)
257       : Line(L->getLine()), Column(L->getColumn()), Scope(L->getRawScope()),
258         InlinedAt(L->getRawInlinedAt()) {}
259 
260   bool isKeyOf(const DILocation *RHS) const {
261     return Line == RHS->getLine() && Column == RHS->getColumn() &&
262            Scope == RHS->getRawScope() && InlinedAt == RHS->getRawInlinedAt();
263   }
264   unsigned getHashValue() const {
265     return hash_combine(Line, Column, Scope, InlinedAt);
266   }
267 };
268 
269 /// \brief DenseMapInfo for GenericDINode.
270 template <> struct MDNodeKeyImpl<GenericDINode> : MDNodeOpsKey {
271   unsigned Tag;
272   MDString *Header;
273   MDNodeKeyImpl(unsigned Tag, MDString *Header, ArrayRef<Metadata *> DwarfOps)
274       : MDNodeOpsKey(DwarfOps), Tag(Tag), Header(Header) {}
275   MDNodeKeyImpl(const GenericDINode *N)
276       : MDNodeOpsKey(N, 1), Tag(N->getTag()), Header(N->getRawHeader()) {}
277 
278   bool isKeyOf(const GenericDINode *RHS) const {
279     return Tag == RHS->getTag() && Header == RHS->getRawHeader() &&
280            compareOps(RHS, 1);
281   }
282 
283   unsigned getHashValue() const { return hash_combine(getHash(), Tag, Header); }
284 
285   static unsigned calculateHash(GenericDINode *N) {
286     return MDNodeOpsKey::calculateHash(N, 1);
287   }
288 };
289 
290 template <> struct MDNodeKeyImpl<DISubrange> {
291   int64_t Count;
292   int64_t LowerBound;
293 
294   MDNodeKeyImpl(int64_t Count, int64_t LowerBound)
295       : Count(Count), LowerBound(LowerBound) {}
296   MDNodeKeyImpl(const DISubrange *N)
297       : Count(N->getCount()), LowerBound(N->getLowerBound()) {}
298 
299   bool isKeyOf(const DISubrange *RHS) const {
300     return Count == RHS->getCount() && LowerBound == RHS->getLowerBound();
301   }
302   unsigned getHashValue() const { return hash_combine(Count, LowerBound); }
303 };
304 
305 template <> struct MDNodeKeyImpl<DIEnumerator> {
306   int64_t Value;
307   MDString *Name;
308 
309   MDNodeKeyImpl(int64_t Value, MDString *Name) : Value(Value), Name(Name) {}
310   MDNodeKeyImpl(const DIEnumerator *N)
311       : Value(N->getValue()), Name(N->getRawName()) {}
312 
313   bool isKeyOf(const DIEnumerator *RHS) const {
314     return Value == RHS->getValue() && Name == RHS->getRawName();
315   }
316   unsigned getHashValue() const { return hash_combine(Value, Name); }
317 };
318 
319 template <> struct MDNodeKeyImpl<DIBasicType> {
320   unsigned Tag;
321   MDString *Name;
322   uint64_t SizeInBits;
323   uint32_t AlignInBits;
324   unsigned Encoding;
325 
326   MDNodeKeyImpl(unsigned Tag, MDString *Name, uint64_t SizeInBits,
327                 uint32_t AlignInBits, unsigned Encoding)
328       : Tag(Tag), Name(Name), SizeInBits(SizeInBits), AlignInBits(AlignInBits),
329         Encoding(Encoding) {}
330   MDNodeKeyImpl(const DIBasicType *N)
331       : Tag(N->getTag()), Name(N->getRawName()), SizeInBits(N->getSizeInBits()),
332         AlignInBits(N->getAlignInBits()), Encoding(N->getEncoding()) {}
333 
334   bool isKeyOf(const DIBasicType *RHS) const {
335     return Tag == RHS->getTag() && Name == RHS->getRawName() &&
336            SizeInBits == RHS->getSizeInBits() &&
337            AlignInBits == RHS->getAlignInBits() &&
338            Encoding == RHS->getEncoding();
339   }
340   unsigned getHashValue() const {
341     return hash_combine(Tag, Name, SizeInBits, AlignInBits, Encoding);
342   }
343 };
344 
345 template <> struct MDNodeKeyImpl<DIDerivedType> {
346   unsigned Tag;
347   MDString *Name;
348   Metadata *File;
349   unsigned Line;
350   Metadata *Scope;
351   Metadata *BaseType;
352   uint64_t SizeInBits;
353   uint64_t OffsetInBits;
354   uint32_t AlignInBits;
355   unsigned Flags;
356   Metadata *ExtraData;
357 
358   MDNodeKeyImpl(unsigned Tag, MDString *Name, Metadata *File, unsigned Line,
359                 Metadata *Scope, Metadata *BaseType, uint64_t SizeInBits,
360                 uint32_t AlignInBits, uint64_t OffsetInBits, unsigned Flags,
361                 Metadata *ExtraData)
362       : Tag(Tag), Name(Name), File(File), Line(Line), Scope(Scope),
363         BaseType(BaseType), SizeInBits(SizeInBits), OffsetInBits(OffsetInBits),
364         AlignInBits(AlignInBits), Flags(Flags), ExtraData(ExtraData) {}
365   MDNodeKeyImpl(const DIDerivedType *N)
366       : Tag(N->getTag()), Name(N->getRawName()), File(N->getRawFile()),
367         Line(N->getLine()), Scope(N->getRawScope()),
368         BaseType(N->getRawBaseType()), SizeInBits(N->getSizeInBits()),
369         OffsetInBits(N->getOffsetInBits()), AlignInBits(N->getAlignInBits()),
370         Flags(N->getFlags()), ExtraData(N->getRawExtraData()) {}
371 
372   bool isKeyOf(const DIDerivedType *RHS) const {
373     return Tag == RHS->getTag() && Name == RHS->getRawName() &&
374            File == RHS->getRawFile() && Line == RHS->getLine() &&
375            Scope == RHS->getRawScope() && BaseType == RHS->getRawBaseType() &&
376            SizeInBits == RHS->getSizeInBits() &&
377            AlignInBits == RHS->getAlignInBits() &&
378            OffsetInBits == RHS->getOffsetInBits() && Flags == RHS->getFlags() &&
379            ExtraData == RHS->getRawExtraData();
380   }
381   unsigned getHashValue() const {
382     // If this is a member inside an ODR type, only hash the type and the name.
383     // Otherwise the hash will be stronger than
384     // MDNodeSubsetEqualImpl::isODRMember().
385     if (Tag == dwarf::DW_TAG_member && Name)
386       if (auto *CT = dyn_cast_or_null<DICompositeType>(Scope))
387         if (CT->getRawIdentifier())
388           return hash_combine(Name, Scope);
389 
390     // Intentionally computes the hash on a subset of the operands for
391     // performance reason. The subset has to be significant enough to avoid
392     // collision "most of the time". There is no correctness issue in case of
393     // collision because of the full check above.
394     return hash_combine(Tag, Name, File, Line, Scope, BaseType, Flags);
395   }
396 };
397 
398 template <> struct MDNodeSubsetEqualImpl<DIDerivedType> {
399   typedef MDNodeKeyImpl<DIDerivedType> KeyTy;
400   static bool isSubsetEqual(const KeyTy &LHS, const DIDerivedType *RHS) {
401     return isODRMember(LHS.Tag, LHS.Scope, LHS.Name, RHS);
402   }
403   static bool isSubsetEqual(const DIDerivedType *LHS, const DIDerivedType *RHS) {
404     return isODRMember(LHS->getTag(), LHS->getRawScope(), LHS->getRawName(),
405                        RHS);
406   }
407 
408   /// Subprograms compare equal if they declare the same function in an ODR
409   /// type.
410   static bool isODRMember(unsigned Tag, const Metadata *Scope,
411                           const MDString *Name, const DIDerivedType *RHS) {
412     // Check whether the LHS is eligible.
413     if (Tag != dwarf::DW_TAG_member || !Name)
414       return false;
415 
416     auto *CT = dyn_cast_or_null<DICompositeType>(Scope);
417     if (!CT || !CT->getRawIdentifier())
418       return false;
419 
420     // Compare to the RHS.
421     return Tag == RHS->getTag() && Name == RHS->getRawName() &&
422            Scope == RHS->getRawScope();
423   }
424 };
425 
426 template <> struct MDNodeKeyImpl<DICompositeType> {
427   unsigned Tag;
428   MDString *Name;
429   Metadata *File;
430   unsigned Line;
431   Metadata *Scope;
432   Metadata *BaseType;
433   uint64_t SizeInBits;
434   uint64_t OffsetInBits;
435   uint32_t AlignInBits;
436   unsigned Flags;
437   Metadata *Elements;
438   unsigned RuntimeLang;
439   Metadata *VTableHolder;
440   Metadata *TemplateParams;
441   MDString *Identifier;
442 
443   MDNodeKeyImpl(unsigned Tag, MDString *Name, Metadata *File, unsigned Line,
444                 Metadata *Scope, Metadata *BaseType, uint64_t SizeInBits,
445                 uint32_t AlignInBits, uint64_t OffsetInBits, unsigned Flags,
446                 Metadata *Elements, unsigned RuntimeLang,
447                 Metadata *VTableHolder, Metadata *TemplateParams,
448                 MDString *Identifier)
449       : Tag(Tag), Name(Name), File(File), Line(Line), Scope(Scope),
450         BaseType(BaseType), SizeInBits(SizeInBits), OffsetInBits(OffsetInBits),
451         AlignInBits(AlignInBits), Flags(Flags), Elements(Elements),
452         RuntimeLang(RuntimeLang), VTableHolder(VTableHolder),
453         TemplateParams(TemplateParams), Identifier(Identifier) {}
454   MDNodeKeyImpl(const DICompositeType *N)
455       : Tag(N->getTag()), Name(N->getRawName()), File(N->getRawFile()),
456         Line(N->getLine()), Scope(N->getRawScope()),
457         BaseType(N->getRawBaseType()), SizeInBits(N->getSizeInBits()),
458         OffsetInBits(N->getOffsetInBits()), AlignInBits(N->getAlignInBits()),
459         Flags(N->getFlags()), Elements(N->getRawElements()),
460         RuntimeLang(N->getRuntimeLang()), VTableHolder(N->getRawVTableHolder()),
461         TemplateParams(N->getRawTemplateParams()),
462         Identifier(N->getRawIdentifier()) {}
463 
464   bool isKeyOf(const DICompositeType *RHS) const {
465     return Tag == RHS->getTag() && Name == RHS->getRawName() &&
466            File == RHS->getRawFile() && Line == RHS->getLine() &&
467            Scope == RHS->getRawScope() && BaseType == RHS->getRawBaseType() &&
468            SizeInBits == RHS->getSizeInBits() &&
469            AlignInBits == RHS->getAlignInBits() &&
470            OffsetInBits == RHS->getOffsetInBits() && Flags == RHS->getFlags() &&
471            Elements == RHS->getRawElements() &&
472            RuntimeLang == RHS->getRuntimeLang() &&
473            VTableHolder == RHS->getRawVTableHolder() &&
474            TemplateParams == RHS->getRawTemplateParams() &&
475            Identifier == RHS->getRawIdentifier();
476   }
477   unsigned getHashValue() const {
478     // Intentionally computes the hash on a subset of the operands for
479     // performance reason. The subset has to be significant enough to avoid
480     // collision "most of the time". There is no correctness issue in case of
481     // collision because of the full check above.
482     return hash_combine(Name, File, Line, BaseType, Scope, Elements,
483                         TemplateParams);
484   }
485 };
486 
487 template <> struct MDNodeKeyImpl<DISubroutineType> {
488   unsigned Flags;
489   uint8_t CC;
490   Metadata *TypeArray;
491 
492   MDNodeKeyImpl(unsigned Flags, uint8_t CC, Metadata *TypeArray)
493       : Flags(Flags), CC(CC), TypeArray(TypeArray) {}
494   MDNodeKeyImpl(const DISubroutineType *N)
495       : Flags(N->getFlags()), CC(N->getCC()), TypeArray(N->getRawTypeArray()) {}
496 
497   bool isKeyOf(const DISubroutineType *RHS) const {
498     return Flags == RHS->getFlags() && CC == RHS->getCC() &&
499            TypeArray == RHS->getRawTypeArray();
500   }
501   unsigned getHashValue() const { return hash_combine(Flags, CC, TypeArray); }
502 };
503 
504 template <> struct MDNodeKeyImpl<DIFile> {
505   MDString *Filename;
506   MDString *Directory;
507   DIFile::ChecksumKind CSKind;
508   MDString *Checksum;
509 
510   MDNodeKeyImpl(MDString *Filename, MDString *Directory,
511                 DIFile::ChecksumKind CSKind, MDString *Checksum)
512       : Filename(Filename), Directory(Directory), CSKind(CSKind),
513         Checksum(Checksum) {}
514   MDNodeKeyImpl(const DIFile *N)
515       : Filename(N->getRawFilename()), Directory(N->getRawDirectory()),
516         CSKind(N->getChecksumKind()), Checksum(N->getRawChecksum()) {}
517 
518   bool isKeyOf(const DIFile *RHS) const {
519     return Filename == RHS->getRawFilename() &&
520            Directory == RHS->getRawDirectory() &&
521            CSKind == RHS->getChecksumKind() &&
522            Checksum == RHS->getRawChecksum();
523   }
524   unsigned getHashValue() const {
525     return hash_combine(Filename, Directory, CSKind, Checksum);
526   }
527 };
528 
529 template <> struct MDNodeKeyImpl<DISubprogram> {
530   Metadata *Scope;
531   MDString *Name;
532   MDString *LinkageName;
533   Metadata *File;
534   unsigned Line;
535   Metadata *Type;
536   bool IsLocalToUnit;
537   bool IsDefinition;
538   unsigned ScopeLine;
539   Metadata *ContainingType;
540   unsigned Virtuality;
541   unsigned VirtualIndex;
542   int ThisAdjustment;
543   unsigned Flags;
544   bool IsOptimized;
545   Metadata *Unit;
546   Metadata *TemplateParams;
547   Metadata *Declaration;
548   Metadata *Variables;
549 
550   MDNodeKeyImpl(Metadata *Scope, MDString *Name, MDString *LinkageName,
551                 Metadata *File, unsigned Line, Metadata *Type,
552                 bool IsLocalToUnit, bool IsDefinition, unsigned ScopeLine,
553                 Metadata *ContainingType, unsigned Virtuality,
554                 unsigned VirtualIndex, int ThisAdjustment, unsigned Flags,
555                 bool IsOptimized, Metadata *Unit, Metadata *TemplateParams,
556                 Metadata *Declaration, Metadata *Variables)
557       : Scope(Scope), Name(Name), LinkageName(LinkageName), File(File),
558         Line(Line), Type(Type), IsLocalToUnit(IsLocalToUnit),
559         IsDefinition(IsDefinition), ScopeLine(ScopeLine),
560         ContainingType(ContainingType), Virtuality(Virtuality),
561         VirtualIndex(VirtualIndex), ThisAdjustment(ThisAdjustment),
562         Flags(Flags), IsOptimized(IsOptimized), Unit(Unit),
563         TemplateParams(TemplateParams), Declaration(Declaration),
564         Variables(Variables) {}
565   MDNodeKeyImpl(const DISubprogram *N)
566       : Scope(N->getRawScope()), Name(N->getRawName()),
567         LinkageName(N->getRawLinkageName()), File(N->getRawFile()),
568         Line(N->getLine()), Type(N->getRawType()),
569         IsLocalToUnit(N->isLocalToUnit()), IsDefinition(N->isDefinition()),
570         ScopeLine(N->getScopeLine()), ContainingType(N->getRawContainingType()),
571         Virtuality(N->getVirtuality()), VirtualIndex(N->getVirtualIndex()),
572         ThisAdjustment(N->getThisAdjustment()), Flags(N->getFlags()),
573         IsOptimized(N->isOptimized()), Unit(N->getRawUnit()),
574         TemplateParams(N->getRawTemplateParams()),
575         Declaration(N->getRawDeclaration()), Variables(N->getRawVariables()) {}
576 
577   bool isKeyOf(const DISubprogram *RHS) const {
578     return Scope == RHS->getRawScope() && Name == RHS->getRawName() &&
579            LinkageName == RHS->getRawLinkageName() &&
580            File == RHS->getRawFile() && Line == RHS->getLine() &&
581            Type == RHS->getRawType() && IsLocalToUnit == RHS->isLocalToUnit() &&
582            IsDefinition == RHS->isDefinition() &&
583            ScopeLine == RHS->getScopeLine() &&
584            ContainingType == RHS->getRawContainingType() &&
585            Virtuality == RHS->getVirtuality() &&
586            VirtualIndex == RHS->getVirtualIndex() &&
587            ThisAdjustment == RHS->getThisAdjustment() &&
588            Flags == RHS->getFlags() && IsOptimized == RHS->isOptimized() &&
589            Unit == RHS->getUnit() &&
590            TemplateParams == RHS->getRawTemplateParams() &&
591            Declaration == RHS->getRawDeclaration() &&
592            Variables == RHS->getRawVariables();
593   }
594   unsigned getHashValue() const {
595     // If this is a declaration inside an ODR type, only hash the type and the
596     // name.  Otherwise the hash will be stronger than
597     // MDNodeSubsetEqualImpl::isDeclarationOfODRMember().
598     if (!IsDefinition && LinkageName)
599       if (auto *CT = dyn_cast_or_null<DICompositeType>(Scope))
600         if (CT->getRawIdentifier())
601           return hash_combine(LinkageName, Scope);
602 
603     // Intentionally computes the hash on a subset of the operands for
604     // performance reason. The subset has to be significant enough to avoid
605     // collision "most of the time". There is no correctness issue in case of
606     // collision because of the full check above.
607     return hash_combine(Name, Scope, File, Type, Line);
608   }
609 };
610 
611 template <> struct MDNodeSubsetEqualImpl<DISubprogram> {
612   typedef MDNodeKeyImpl<DISubprogram> KeyTy;
613   static bool isSubsetEqual(const KeyTy &LHS, const DISubprogram *RHS) {
614     return isDeclarationOfODRMember(LHS.IsDefinition, LHS.Scope,
615                                     LHS.LinkageName, RHS);
616   }
617   static bool isSubsetEqual(const DISubprogram *LHS, const DISubprogram *RHS) {
618     return isDeclarationOfODRMember(LHS->isDefinition(), LHS->getRawScope(),
619                                     LHS->getRawLinkageName(), RHS);
620   }
621 
622   /// Subprograms compare equal if they declare the same function in an ODR
623   /// type.
624   static bool isDeclarationOfODRMember(bool IsDefinition, const Metadata *Scope,
625                                        const MDString *LinkageName,
626                                        const DISubprogram *RHS) {
627     // Check whether the LHS is eligible.
628     if (IsDefinition || !Scope || !LinkageName)
629       return false;
630 
631     auto *CT = dyn_cast_or_null<DICompositeType>(Scope);
632     if (!CT || !CT->getRawIdentifier())
633       return false;
634 
635     // Compare to the RHS.
636     return IsDefinition == RHS->isDefinition() && Scope == RHS->getRawScope() &&
637            LinkageName == RHS->getRawLinkageName();
638   }
639 };
640 
641 template <> struct MDNodeKeyImpl<DILexicalBlock> {
642   Metadata *Scope;
643   Metadata *File;
644   unsigned Line;
645   unsigned Column;
646 
647   MDNodeKeyImpl(Metadata *Scope, Metadata *File, unsigned Line, unsigned Column)
648       : Scope(Scope), File(File), Line(Line), Column(Column) {}
649   MDNodeKeyImpl(const DILexicalBlock *N)
650       : Scope(N->getRawScope()), File(N->getRawFile()), Line(N->getLine()),
651         Column(N->getColumn()) {}
652 
653   bool isKeyOf(const DILexicalBlock *RHS) const {
654     return Scope == RHS->getRawScope() && File == RHS->getRawFile() &&
655            Line == RHS->getLine() && Column == RHS->getColumn();
656   }
657   unsigned getHashValue() const {
658     return hash_combine(Scope, File, Line, Column);
659   }
660 };
661 
662 template <> struct MDNodeKeyImpl<DILexicalBlockFile> {
663   Metadata *Scope;
664   Metadata *File;
665   unsigned Discriminator;
666 
667   MDNodeKeyImpl(Metadata *Scope, Metadata *File, unsigned Discriminator)
668       : Scope(Scope), File(File), Discriminator(Discriminator) {}
669   MDNodeKeyImpl(const DILexicalBlockFile *N)
670       : Scope(N->getRawScope()), File(N->getRawFile()),
671         Discriminator(N->getDiscriminator()) {}
672 
673   bool isKeyOf(const DILexicalBlockFile *RHS) const {
674     return Scope == RHS->getRawScope() && File == RHS->getRawFile() &&
675            Discriminator == RHS->getDiscriminator();
676   }
677   unsigned getHashValue() const {
678     return hash_combine(Scope, File, Discriminator);
679   }
680 };
681 
682 template <> struct MDNodeKeyImpl<DINamespace> {
683   Metadata *Scope;
684   Metadata *File;
685   MDString *Name;
686   unsigned Line;
687   bool ExportSymbols;
688 
689   MDNodeKeyImpl(Metadata *Scope, Metadata *File, MDString *Name, unsigned Line,
690                 bool ExportSymbols)
691       : Scope(Scope), File(File), Name(Name), Line(Line),
692         ExportSymbols(ExportSymbols) {}
693   MDNodeKeyImpl(const DINamespace *N)
694       : Scope(N->getRawScope()), File(N->getRawFile()), Name(N->getRawName()),
695         Line(N->getLine()), ExportSymbols(N->getExportSymbols()) {}
696 
697   bool isKeyOf(const DINamespace *RHS) const {
698     return Scope == RHS->getRawScope() && File == RHS->getRawFile() &&
699            Name == RHS->getRawName() && Line == RHS->getLine() &&
700            ExportSymbols == RHS->getExportSymbols();
701   }
702   unsigned getHashValue() const {
703     return hash_combine(Scope, File, Name, Line);
704   }
705 };
706 
707 template <> struct MDNodeKeyImpl<DIModule> {
708   Metadata *Scope;
709   MDString *Name;
710   MDString *ConfigurationMacros;
711   MDString *IncludePath;
712   MDString *ISysRoot;
713   MDNodeKeyImpl(Metadata *Scope, MDString *Name, MDString *ConfigurationMacros,
714                 MDString *IncludePath, MDString *ISysRoot)
715       : Scope(Scope), Name(Name), ConfigurationMacros(ConfigurationMacros),
716         IncludePath(IncludePath), ISysRoot(ISysRoot) {}
717   MDNodeKeyImpl(const DIModule *N)
718       : Scope(N->getRawScope()), Name(N->getRawName()),
719         ConfigurationMacros(N->getRawConfigurationMacros()),
720         IncludePath(N->getRawIncludePath()), ISysRoot(N->getRawISysRoot()) {}
721 
722   bool isKeyOf(const DIModule *RHS) const {
723     return Scope == RHS->getRawScope() && Name == RHS->getRawName() &&
724            ConfigurationMacros == RHS->getRawConfigurationMacros() &&
725            IncludePath == RHS->getRawIncludePath() &&
726            ISysRoot == RHS->getRawISysRoot();
727   }
728   unsigned getHashValue() const {
729     return hash_combine(Scope, Name,
730                         ConfigurationMacros, IncludePath, ISysRoot);
731   }
732 };
733 
734 template <> struct MDNodeKeyImpl<DITemplateTypeParameter> {
735   MDString *Name;
736   Metadata *Type;
737 
738   MDNodeKeyImpl(MDString *Name, Metadata *Type) : Name(Name), Type(Type) {}
739   MDNodeKeyImpl(const DITemplateTypeParameter *N)
740       : Name(N->getRawName()), Type(N->getRawType()) {}
741 
742   bool isKeyOf(const DITemplateTypeParameter *RHS) const {
743     return Name == RHS->getRawName() && Type == RHS->getRawType();
744   }
745   unsigned getHashValue() const { return hash_combine(Name, Type); }
746 };
747 
748 template <> struct MDNodeKeyImpl<DITemplateValueParameter> {
749   unsigned Tag;
750   MDString *Name;
751   Metadata *Type;
752   Metadata *Value;
753 
754   MDNodeKeyImpl(unsigned Tag, MDString *Name, Metadata *Type, Metadata *Value)
755       : Tag(Tag), Name(Name), Type(Type), Value(Value) {}
756   MDNodeKeyImpl(const DITemplateValueParameter *N)
757       : Tag(N->getTag()), Name(N->getRawName()), Type(N->getRawType()),
758         Value(N->getValue()) {}
759 
760   bool isKeyOf(const DITemplateValueParameter *RHS) const {
761     return Tag == RHS->getTag() && Name == RHS->getRawName() &&
762            Type == RHS->getRawType() && Value == RHS->getValue();
763   }
764   unsigned getHashValue() const { return hash_combine(Tag, Name, Type, Value); }
765 };
766 
767 template <> struct MDNodeKeyImpl<DIGlobalVariable> {
768   Metadata *Scope;
769   MDString *Name;
770   MDString *LinkageName;
771   Metadata *File;
772   unsigned Line;
773   Metadata *Type;
774   bool IsLocalToUnit;
775   bool IsDefinition;
776   Metadata *StaticDataMemberDeclaration;
777   uint32_t AlignInBits;
778 
779   MDNodeKeyImpl(Metadata *Scope, MDString *Name, MDString *LinkageName,
780                 Metadata *File, unsigned Line, Metadata *Type,
781                 bool IsLocalToUnit, bool IsDefinition,
782                 Metadata *StaticDataMemberDeclaration, uint32_t AlignInBits)
783       : Scope(Scope), Name(Name), LinkageName(LinkageName), File(File),
784         Line(Line), Type(Type), IsLocalToUnit(IsLocalToUnit),
785         IsDefinition(IsDefinition),
786         StaticDataMemberDeclaration(StaticDataMemberDeclaration),
787         AlignInBits(AlignInBits) {}
788   MDNodeKeyImpl(const DIGlobalVariable *N)
789       : Scope(N->getRawScope()), Name(N->getRawName()),
790         LinkageName(N->getRawLinkageName()), File(N->getRawFile()),
791         Line(N->getLine()), Type(N->getRawType()),
792         IsLocalToUnit(N->isLocalToUnit()), IsDefinition(N->isDefinition()),
793         StaticDataMemberDeclaration(N->getRawStaticDataMemberDeclaration()),
794         AlignInBits(N->getAlignInBits()) {}
795 
796   bool isKeyOf(const DIGlobalVariable *RHS) const {
797     return Scope == RHS->getRawScope() && Name == RHS->getRawName() &&
798            LinkageName == RHS->getRawLinkageName() &&
799            File == RHS->getRawFile() && Line == RHS->getLine() &&
800            Type == RHS->getRawType() && IsLocalToUnit == RHS->isLocalToUnit() &&
801            IsDefinition == RHS->isDefinition() &&
802            StaticDataMemberDeclaration ==
803                RHS->getRawStaticDataMemberDeclaration() &&
804            AlignInBits == RHS->getAlignInBits();
805   }
806   unsigned getHashValue() const {
807     // We do not use AlignInBits in hashing function here on purpose:
808     // in most cases this param for local variable is zero (for function param
809     // it is always zero). This leads to lots of hash collisions and errors on
810     // cases with lots of similar variables.
811     // clang/test/CodeGen/debug-info-257-args.c is an example of this problem,
812     // generated IR is random for each run and test fails with Align included.
813     // TODO: make hashing work fine with such situations
814     return hash_combine(Scope, Name, LinkageName, File, Line, Type,
815                         IsLocalToUnit, IsDefinition, /* AlignInBits, */
816                         StaticDataMemberDeclaration);
817   }
818 };
819 
820 template <> struct MDNodeKeyImpl<DILocalVariable> {
821   Metadata *Scope;
822   MDString *Name;
823   Metadata *File;
824   unsigned Line;
825   Metadata *Type;
826   unsigned Arg;
827   unsigned Flags;
828   uint32_t AlignInBits;
829 
830   MDNodeKeyImpl(Metadata *Scope, MDString *Name, Metadata *File, unsigned Line,
831                 Metadata *Type, unsigned Arg, unsigned Flags,
832                 uint32_t AlignInBits)
833       : Scope(Scope), Name(Name), File(File), Line(Line), Type(Type), Arg(Arg),
834         Flags(Flags), AlignInBits(AlignInBits) {}
835   MDNodeKeyImpl(const DILocalVariable *N)
836       : Scope(N->getRawScope()), Name(N->getRawName()), File(N->getRawFile()),
837         Line(N->getLine()), Type(N->getRawType()), Arg(N->getArg()),
838         Flags(N->getFlags()), AlignInBits(N->getAlignInBits()) {}
839 
840   bool isKeyOf(const DILocalVariable *RHS) const {
841     return Scope == RHS->getRawScope() && Name == RHS->getRawName() &&
842            File == RHS->getRawFile() && Line == RHS->getLine() &&
843            Type == RHS->getRawType() && Arg == RHS->getArg() &&
844            Flags == RHS->getFlags() && AlignInBits == RHS->getAlignInBits();
845   }
846   unsigned getHashValue() const {
847     // We do not use AlignInBits in hashing function here on purpose:
848     // in most cases this param for local variable is zero (for function param
849     // it is always zero). This leads to lots of hash collisions and errors on
850     // cases with lots of similar variables.
851     // clang/test/CodeGen/debug-info-257-args.c is an example of this problem,
852     // generated IR is random for each run and test fails with Align included.
853     // TODO: make hashing work fine with such situations
854     return hash_combine(Scope, Name, File, Line, Type, Arg, Flags);
855   }
856 };
857 
858 template <> struct MDNodeKeyImpl<DIExpression> {
859   ArrayRef<uint64_t> Elements;
860 
861   MDNodeKeyImpl(ArrayRef<uint64_t> Elements) : Elements(Elements) {}
862   MDNodeKeyImpl(const DIExpression *N) : Elements(N->getElements()) {}
863 
864   bool isKeyOf(const DIExpression *RHS) const {
865     return Elements == RHS->getElements();
866   }
867   unsigned getHashValue() const {
868     return hash_combine_range(Elements.begin(), Elements.end());
869   }
870 };
871 
872 template <> struct MDNodeKeyImpl<DIGlobalVariableExpression> {
873   Metadata *Variable;
874   Metadata *Expression;
875 
876   MDNodeKeyImpl(Metadata *Variable, Metadata *Expression)
877       : Variable(Variable), Expression(Expression) {}
878   MDNodeKeyImpl(const DIGlobalVariableExpression *N)
879       : Variable(N->getRawVariable()), Expression(N->getRawExpression()) {}
880 
881   bool isKeyOf(const DIGlobalVariableExpression *RHS) const {
882     return Variable == RHS->getRawVariable() &&
883            Expression == RHS->getRawExpression();
884   }
885   unsigned getHashValue() const { return hash_combine(Variable, Expression); }
886 };
887 
888 template <> struct MDNodeKeyImpl<DIObjCProperty> {
889   MDString *Name;
890   Metadata *File;
891   unsigned Line;
892   MDString *GetterName;
893   MDString *SetterName;
894   unsigned Attributes;
895   Metadata *Type;
896 
897   MDNodeKeyImpl(MDString *Name, Metadata *File, unsigned Line,
898                 MDString *GetterName, MDString *SetterName, unsigned Attributes,
899                 Metadata *Type)
900       : Name(Name), File(File), Line(Line), GetterName(GetterName),
901         SetterName(SetterName), Attributes(Attributes), Type(Type) {}
902   MDNodeKeyImpl(const DIObjCProperty *N)
903       : Name(N->getRawName()), File(N->getRawFile()), Line(N->getLine()),
904         GetterName(N->getRawGetterName()), SetterName(N->getRawSetterName()),
905         Attributes(N->getAttributes()), Type(N->getRawType()) {}
906 
907   bool isKeyOf(const DIObjCProperty *RHS) const {
908     return Name == RHS->getRawName() && File == RHS->getRawFile() &&
909            Line == RHS->getLine() && GetterName == RHS->getRawGetterName() &&
910            SetterName == RHS->getRawSetterName() &&
911            Attributes == RHS->getAttributes() && Type == RHS->getRawType();
912   }
913   unsigned getHashValue() const {
914     return hash_combine(Name, File, Line, GetterName, SetterName, Attributes,
915                         Type);
916   }
917 };
918 
919 template <> struct MDNodeKeyImpl<DIImportedEntity> {
920   unsigned Tag;
921   Metadata *Scope;
922   Metadata *Entity;
923   unsigned Line;
924   MDString *Name;
925 
926   MDNodeKeyImpl(unsigned Tag, Metadata *Scope, Metadata *Entity, unsigned Line,
927                 MDString *Name)
928       : Tag(Tag), Scope(Scope), Entity(Entity), Line(Line), Name(Name) {}
929   MDNodeKeyImpl(const DIImportedEntity *N)
930       : Tag(N->getTag()), Scope(N->getRawScope()), Entity(N->getRawEntity()),
931         Line(N->getLine()), Name(N->getRawName()) {}
932 
933   bool isKeyOf(const DIImportedEntity *RHS) const {
934     return Tag == RHS->getTag() && Scope == RHS->getRawScope() &&
935            Entity == RHS->getRawEntity() && Line == RHS->getLine() &&
936            Name == RHS->getRawName();
937   }
938   unsigned getHashValue() const {
939     return hash_combine(Tag, Scope, Entity, Line, Name);
940   }
941 };
942 
943 template <> struct MDNodeKeyImpl<DIMacro> {
944   unsigned MIType;
945   unsigned Line;
946   MDString *Name;
947   MDString *Value;
948 
949   MDNodeKeyImpl(unsigned MIType, unsigned Line, MDString *Name, MDString *Value)
950       : MIType(MIType), Line(Line), Name(Name), Value(Value) {}
951   MDNodeKeyImpl(const DIMacro *N)
952       : MIType(N->getMacinfoType()), Line(N->getLine()), Name(N->getRawName()),
953         Value(N->getRawValue()) {}
954 
955   bool isKeyOf(const DIMacro *RHS) const {
956     return MIType == RHS->getMacinfoType() && Line == RHS->getLine() &&
957            Name == RHS->getRawName() && Value == RHS->getRawValue();
958   }
959   unsigned getHashValue() const {
960     return hash_combine(MIType, Line, Name, Value);
961   }
962 };
963 
964 template <> struct MDNodeKeyImpl<DIMacroFile> {
965   unsigned MIType;
966   unsigned Line;
967   Metadata *File;
968   Metadata *Elements;
969 
970   MDNodeKeyImpl(unsigned MIType, unsigned Line, Metadata *File,
971                 Metadata *Elements)
972       : MIType(MIType), Line(Line), File(File), Elements(Elements) {}
973   MDNodeKeyImpl(const DIMacroFile *N)
974       : MIType(N->getMacinfoType()), Line(N->getLine()), File(N->getRawFile()),
975         Elements(N->getRawElements()) {}
976 
977   bool isKeyOf(const DIMacroFile *RHS) const {
978     return MIType == RHS->getMacinfoType() && Line == RHS->getLine() &&
979            File == RHS->getRawFile() && Elements == RHS->getRawElements();
980   }
981   unsigned getHashValue() const {
982     return hash_combine(MIType, Line, File, Elements);
983   }
984 };
985 
986 /// \brief DenseMapInfo for MDNode subclasses.
987 template <class NodeTy> struct MDNodeInfo {
988   typedef MDNodeKeyImpl<NodeTy> KeyTy;
989   typedef MDNodeSubsetEqualImpl<NodeTy> SubsetEqualTy;
990   static inline NodeTy *getEmptyKey() {
991     return DenseMapInfo<NodeTy *>::getEmptyKey();
992   }
993   static inline NodeTy *getTombstoneKey() {
994     return DenseMapInfo<NodeTy *>::getTombstoneKey();
995   }
996   static unsigned getHashValue(const KeyTy &Key) { return Key.getHashValue(); }
997   static unsigned getHashValue(const NodeTy *N) {
998     return KeyTy(N).getHashValue();
999   }
1000   static bool isEqual(const KeyTy &LHS, const NodeTy *RHS) {
1001     if (RHS == getEmptyKey() || RHS == getTombstoneKey())
1002       return false;
1003     return SubsetEqualTy::isSubsetEqual(LHS, RHS) || LHS.isKeyOf(RHS);
1004   }
1005   static bool isEqual(const NodeTy *LHS, const NodeTy *RHS) {
1006     if (LHS == RHS)
1007       return true;
1008     if (RHS == getEmptyKey() || RHS == getTombstoneKey())
1009       return false;
1010     return SubsetEqualTy::isSubsetEqual(LHS, RHS);
1011   }
1012 };
1013 
1014 #define HANDLE_MDNODE_LEAF(CLASS) typedef MDNodeInfo<CLASS> CLASS##Info;
1015 #include "llvm/IR/Metadata.def"
1016 
1017 /// \brief Map-like storage for metadata attachments.
1018 class MDAttachmentMap {
1019   SmallVector<std::pair<unsigned, TrackingMDNodeRef>, 2> Attachments;
1020 
1021 public:
1022   bool empty() const { return Attachments.empty(); }
1023   size_t size() const { return Attachments.size(); }
1024 
1025   /// \brief Get a particular attachment (if any).
1026   MDNode *lookup(unsigned ID) const;
1027 
1028   /// \brief Set an attachment to a particular node.
1029   ///
1030   /// Set the \c ID attachment to \c MD, replacing the current attachment at \c
1031   /// ID (if anyway).
1032   void set(unsigned ID, MDNode &MD);
1033 
1034   /// \brief Remove an attachment.
1035   ///
1036   /// Remove the attachment at \c ID, if any.
1037   void erase(unsigned ID);
1038 
1039   /// \brief Copy out all the attachments.
1040   ///
1041   /// Copies all the current attachments into \c Result, sorting by attachment
1042   /// ID.  This function does \em not clear \c Result.
1043   void getAll(SmallVectorImpl<std::pair<unsigned, MDNode *>> &Result) const;
1044 
1045   /// \brief Erase matching attachments.
1046   ///
1047   /// Erases all attachments matching the \c shouldRemove predicate.
1048   template <class PredTy> void remove_if(PredTy shouldRemove) {
1049     Attachments.erase(llvm::remove_if(Attachments, shouldRemove),
1050                       Attachments.end());
1051   }
1052 };
1053 
1054 /// Multimap-like storage for metadata attachments for globals. This differs
1055 /// from MDAttachmentMap in that it allows multiple attachments per metadata
1056 /// kind.
1057 class MDGlobalAttachmentMap {
1058   struct Attachment {
1059     unsigned MDKind;
1060     TrackingMDNodeRef Node;
1061   };
1062   SmallVector<Attachment, 1> Attachments;
1063 
1064 public:
1065   bool empty() const { return Attachments.empty(); }
1066 
1067   /// Appends all attachments with the given ID to \c Result in insertion order.
1068   /// If the global has no attachments with the given ID, or if ID is invalid,
1069   /// leaves Result unchanged.
1070   void get(unsigned ID, SmallVectorImpl<MDNode *> &Result);
1071 
1072   void insert(unsigned ID, MDNode &MD);
1073   void erase(unsigned ID);
1074 
1075   /// Appends all attachments for the global to \c Result, sorting by attachment
1076   /// ID. Attachments with the same ID appear in insertion order. This function
1077   /// does \em not clear \c Result.
1078   void getAll(SmallVectorImpl<std::pair<unsigned, MDNode *>> &Result) const;
1079 };
1080 
1081 class LLVMContextImpl {
1082 public:
1083   /// OwnedModules - The set of modules instantiated in this context, and which
1084   /// will be automatically deleted if this context is deleted.
1085   SmallPtrSet<Module*, 4> OwnedModules;
1086 
1087   LLVMContext::InlineAsmDiagHandlerTy InlineAsmDiagHandler;
1088   void *InlineAsmDiagContext;
1089 
1090   LLVMContext::DiagnosticHandlerTy DiagnosticHandler;
1091   void *DiagnosticContext;
1092   bool RespectDiagnosticFilters;
1093   bool DiagnosticHotnessRequested;
1094   std::unique_ptr<yaml::Output> DiagnosticsOutputFile;
1095 
1096   LLVMContext::YieldCallbackTy YieldCallback;
1097   void *YieldOpaqueHandle;
1098 
1099   typedef DenseMap<APInt, std::unique_ptr<ConstantInt>, DenseMapAPIntKeyInfo>
1100       IntMapTy;
1101   IntMapTy IntConstants;
1102 
1103   typedef DenseMap<APFloat, std::unique_ptr<ConstantFP>, DenseMapAPFloatKeyInfo>
1104       FPMapTy;
1105   FPMapTy FPConstants;
1106 
1107   FoldingSet<AttributeImpl> AttrsSet;
1108   FoldingSet<AttributeSetImpl> AttrsLists;
1109   FoldingSet<AttributeSetNode> AttrsSetNodes;
1110 
1111   StringMap<MDString, BumpPtrAllocator> MDStringCache;
1112   DenseMap<Value *, ValueAsMetadata *> ValuesAsMetadata;
1113   DenseMap<Metadata *, MetadataAsValue *> MetadataAsValues;
1114 
1115   DenseMap<const Value*, ValueName*> ValueNames;
1116 
1117 #define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS)                                    \
1118   DenseSet<CLASS *, CLASS##Info> CLASS##s;
1119 #include "llvm/IR/Metadata.def"
1120 
1121   // Optional map for looking up composite types by identifier.
1122   Optional<DenseMap<const MDString *, DICompositeType *>> DITypeMap;
1123 
1124   // MDNodes may be uniqued or not uniqued.  When they're not uniqued, they
1125   // aren't in the MDNodeSet, but they're still shared between objects, so no
1126   // one object can destroy them.  Keep track of them here so we can delete
1127   // them on context teardown.
1128   std::vector<MDNode *> DistinctMDNodes;
1129 
1130   DenseMap<Type *, std::unique_ptr<ConstantAggregateZero>> CAZConstants;
1131 
1132   typedef ConstantUniqueMap<ConstantArray> ArrayConstantsTy;
1133   ArrayConstantsTy ArrayConstants;
1134 
1135   typedef ConstantUniqueMap<ConstantStruct> StructConstantsTy;
1136   StructConstantsTy StructConstants;
1137 
1138   typedef ConstantUniqueMap<ConstantVector> VectorConstantsTy;
1139   VectorConstantsTy VectorConstants;
1140 
1141   DenseMap<PointerType *, std::unique_ptr<ConstantPointerNull>> CPNConstants;
1142 
1143   DenseMap<Type *, std::unique_ptr<UndefValue>> UVConstants;
1144 
1145   StringMap<ConstantDataSequential*> CDSConstants;
1146 
1147   DenseMap<std::pair<const Function *, const BasicBlock *>, BlockAddress *>
1148     BlockAddresses;
1149   ConstantUniqueMap<ConstantExpr> ExprConstants;
1150 
1151   ConstantUniqueMap<InlineAsm> InlineAsms;
1152 
1153   ConstantInt *TheTrueVal;
1154   ConstantInt *TheFalseVal;
1155 
1156   std::unique_ptr<ConstantTokenNone> TheNoneToken;
1157 
1158   // Basic type instances.
1159   Type VoidTy, LabelTy, HalfTy, FloatTy, DoubleTy, MetadataTy, TokenTy;
1160   Type X86_FP80Ty, FP128Ty, PPC_FP128Ty, X86_MMXTy;
1161   IntegerType Int1Ty, Int8Ty, Int16Ty, Int32Ty, Int64Ty, Int128Ty;
1162 
1163 
1164   /// TypeAllocator - All dynamically allocated types are allocated from this.
1165   /// They live forever until the context is torn down.
1166   BumpPtrAllocator TypeAllocator;
1167 
1168   DenseMap<unsigned, IntegerType*> IntegerTypes;
1169 
1170   typedef DenseSet<FunctionType *, FunctionTypeKeyInfo> FunctionTypeSet;
1171   FunctionTypeSet FunctionTypes;
1172   typedef DenseSet<StructType *, AnonStructTypeKeyInfo> StructTypeSet;
1173   StructTypeSet AnonStructTypes;
1174   StringMap<StructType*> NamedStructTypes;
1175   unsigned NamedStructTypesUniqueID;
1176 
1177   DenseMap<std::pair<Type *, uint64_t>, ArrayType*> ArrayTypes;
1178   DenseMap<std::pair<Type *, unsigned>, VectorType*> VectorTypes;
1179   DenseMap<Type*, PointerType*> PointerTypes;  // Pointers in AddrSpace = 0
1180   DenseMap<std::pair<Type*, unsigned>, PointerType*> ASPointerTypes;
1181 
1182 
1183   /// ValueHandles - This map keeps track of all of the value handles that are
1184   /// watching a Value*.  The Value::HasValueHandle bit is used to know
1185   /// whether or not a value has an entry in this map.
1186   typedef DenseMap<Value*, ValueHandleBase*> ValueHandlesTy;
1187   ValueHandlesTy ValueHandles;
1188 
1189   /// CustomMDKindNames - Map to hold the metadata string to ID mapping.
1190   StringMap<unsigned> CustomMDKindNames;
1191 
1192   /// Collection of per-instruction metadata used in this context.
1193   DenseMap<const Instruction *, MDAttachmentMap> InstructionMetadata;
1194 
1195   /// Collection of per-GlobalObject metadata used in this context.
1196   DenseMap<const GlobalObject *, MDGlobalAttachmentMap> GlobalObjectMetadata;
1197 
1198   /// Collection of per-GlobalObject sections used in this context.
1199   DenseMap<const GlobalObject *, StringRef> GlobalObjectSections;
1200 
1201   /// Stable collection of section strings.
1202   StringSet<> SectionStrings;
1203 
1204   /// DiscriminatorTable - This table maps file:line locations to an
1205   /// integer representing the next DWARF path discriminator to assign to
1206   /// instructions in different blocks at the same location.
1207   DenseMap<std::pair<const char *, unsigned>, unsigned> DiscriminatorTable;
1208 
1209   int getOrAddScopeRecordIdxEntry(MDNode *N, int ExistingIdx);
1210   int getOrAddScopeInlinedAtIdxEntry(MDNode *Scope, MDNode *IA,int ExistingIdx);
1211 
1212   /// \brief A set of interned tags for operand bundles.  The StringMap maps
1213   /// bundle tags to their IDs.
1214   ///
1215   /// \see LLVMContext::getOperandBundleTagID
1216   StringMap<uint32_t> BundleTagCache;
1217 
1218   StringMapEntry<uint32_t> *getOrInsertBundleTag(StringRef Tag);
1219   void getOperandBundleTags(SmallVectorImpl<StringRef> &Tags) const;
1220   uint32_t getOperandBundleTagID(StringRef Tag) const;
1221 
1222   /// Maintain the GC name for each function.
1223   ///
1224   /// This saves allocating an additional word in Function for programs which
1225   /// do not use GC (i.e., most programs) at the cost of increased overhead for
1226   /// clients which do use GC.
1227   DenseMap<const Function*, std::string> GCNames;
1228 
1229   /// Flag to indicate if Value (other than GlobalValue) retains their name or
1230   /// not.
1231   bool DiscardValueNames = false;
1232 
1233   LLVMContextImpl(LLVMContext &C);
1234   ~LLVMContextImpl();
1235 
1236   /// Destroy the ConstantArrays if they are not used.
1237   void dropTriviallyDeadConstantArrays();
1238 
1239   /// \brief Access the object which manages optimization bisection for failure
1240   /// analysis.
1241   OptBisect &getOptBisect();
1242 };
1243 
1244 }
1245 
1246 #endif
1247