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/IR/Constants.h"
30 #include "llvm/IR/DebugInfoMetadata.h"
31 #include "llvm/IR/DerivedTypes.h"
32 #include "llvm/IR/LLVMContext.h"
33 #include "llvm/IR/Metadata.h"
34 #include "llvm/IR/ValueHandle.h"
35 #include <vector>
36 
37 namespace llvm {
38 
39 class ConstantInt;
40 class ConstantFP;
41 class DiagnosticInfoOptimizationRemark;
42 class DiagnosticInfoOptimizationRemarkMissed;
43 class DiagnosticInfoOptimizationRemarkAnalysis;
44 class GCStrategy;
45 class LLVMContext;
46 class Type;
47 class Value;
48 
49 struct DenseMapAPIntKeyInfo {
getEmptyKeyDenseMapAPIntKeyInfo50   static inline APInt getEmptyKey() {
51     APInt V(nullptr, 0);
52     V.VAL = 0;
53     return V;
54   }
getTombstoneKeyDenseMapAPIntKeyInfo55   static inline APInt getTombstoneKey() {
56     APInt V(nullptr, 0);
57     V.VAL = 1;
58     return V;
59   }
getHashValueDenseMapAPIntKeyInfo60   static unsigned getHashValue(const APInt &Key) {
61     return static_cast<unsigned>(hash_value(Key));
62   }
isEqualDenseMapAPIntKeyInfo63   static bool isEqual(const APInt &LHS, const APInt &RHS) {
64     return LHS.getBitWidth() == RHS.getBitWidth() && LHS == RHS;
65   }
66 };
67 
68 struct DenseMapAPFloatKeyInfo {
getEmptyKeyDenseMapAPFloatKeyInfo69   static inline APFloat getEmptyKey() { return APFloat(APFloat::Bogus, 1); }
getTombstoneKeyDenseMapAPFloatKeyInfo70   static inline APFloat getTombstoneKey() { return APFloat(APFloat::Bogus, 2); }
getHashValueDenseMapAPFloatKeyInfo71   static unsigned getHashValue(const APFloat &Key) {
72     return static_cast<unsigned>(hash_value(Key));
73   }
isEqualDenseMapAPFloatKeyInfo74   static bool isEqual(const APFloat &LHS, const APFloat &RHS) {
75     return LHS.bitwiseIsEqual(RHS);
76   }
77 };
78 
79 struct AnonStructTypeKeyInfo {
80   struct KeyTy {
81     ArrayRef<Type*> ETypes;
82     bool isPacked;
KeyTyAnonStructTypeKeyInfo::KeyTy83     KeyTy(const ArrayRef<Type*>& E, bool P) :
84       ETypes(E), isPacked(P) {}
KeyTyAnonStructTypeKeyInfo::KeyTy85     KeyTy(const StructType *ST)
86         : ETypes(ST->elements()), isPacked(ST->isPacked()) {}
87     bool operator==(const KeyTy& that) const {
88       if (isPacked != that.isPacked)
89         return false;
90       if (ETypes != that.ETypes)
91         return false;
92       return true;
93     }
94     bool operator!=(const KeyTy& that) const {
95       return !this->operator==(that);
96     }
97   };
getEmptyKeyAnonStructTypeKeyInfo98   static inline StructType* getEmptyKey() {
99     return DenseMapInfo<StructType*>::getEmptyKey();
100   }
getTombstoneKeyAnonStructTypeKeyInfo101   static inline StructType* getTombstoneKey() {
102     return DenseMapInfo<StructType*>::getTombstoneKey();
103   }
getHashValueAnonStructTypeKeyInfo104   static unsigned getHashValue(const KeyTy& Key) {
105     return hash_combine(hash_combine_range(Key.ETypes.begin(),
106                                            Key.ETypes.end()),
107                         Key.isPacked);
108   }
getHashValueAnonStructTypeKeyInfo109   static unsigned getHashValue(const StructType *ST) {
110     return getHashValue(KeyTy(ST));
111   }
isEqualAnonStructTypeKeyInfo112   static bool isEqual(const KeyTy& LHS, const StructType *RHS) {
113     if (RHS == getEmptyKey() || RHS == getTombstoneKey())
114       return false;
115     return LHS == KeyTy(RHS);
116   }
isEqualAnonStructTypeKeyInfo117   static bool isEqual(const StructType *LHS, const StructType *RHS) {
118     return LHS == RHS;
119   }
120 };
121 
122 struct FunctionTypeKeyInfo {
123   struct KeyTy {
124     const Type *ReturnType;
125     ArrayRef<Type*> Params;
126     bool isVarArg;
KeyTyFunctionTypeKeyInfo::KeyTy127     KeyTy(const Type* R, const ArrayRef<Type*>& P, bool V) :
128       ReturnType(R), Params(P), isVarArg(V) {}
KeyTyFunctionTypeKeyInfo::KeyTy129     KeyTy(const FunctionType *FT)
130         : ReturnType(FT->getReturnType()), Params(FT->params()),
131           isVarArg(FT->isVarArg()) {}
132     bool operator==(const KeyTy& that) const {
133       if (ReturnType != that.ReturnType)
134         return false;
135       if (isVarArg != that.isVarArg)
136         return false;
137       if (Params != that.Params)
138         return false;
139       return true;
140     }
141     bool operator!=(const KeyTy& that) const {
142       return !this->operator==(that);
143     }
144   };
getEmptyKeyFunctionTypeKeyInfo145   static inline FunctionType* getEmptyKey() {
146     return DenseMapInfo<FunctionType*>::getEmptyKey();
147   }
getTombstoneKeyFunctionTypeKeyInfo148   static inline FunctionType* getTombstoneKey() {
149     return DenseMapInfo<FunctionType*>::getTombstoneKey();
150   }
getHashValueFunctionTypeKeyInfo151   static unsigned getHashValue(const KeyTy& Key) {
152     return hash_combine(Key.ReturnType,
153                         hash_combine_range(Key.Params.begin(),
154                                            Key.Params.end()),
155                         Key.isVarArg);
156   }
getHashValueFunctionTypeKeyInfo157   static unsigned getHashValue(const FunctionType *FT) {
158     return getHashValue(KeyTy(FT));
159   }
isEqualFunctionTypeKeyInfo160   static bool isEqual(const KeyTy& LHS, const FunctionType *RHS) {
161     if (RHS == getEmptyKey() || RHS == getTombstoneKey())
162       return false;
163     return LHS == KeyTy(RHS);
164   }
isEqualFunctionTypeKeyInfo165   static bool isEqual(const FunctionType *LHS, const FunctionType *RHS) {
166     return LHS == RHS;
167   }
168 };
169 
170 /// \brief Structure for hashing arbitrary MDNode operands.
171 class MDNodeOpsKey {
172   ArrayRef<Metadata *> RawOps;
173   ArrayRef<MDOperand> Ops;
174 
175   unsigned Hash;
176 
177 protected:
MDNodeOpsKey(ArrayRef<Metadata * > Ops)178   MDNodeOpsKey(ArrayRef<Metadata *> Ops)
179       : RawOps(Ops), Hash(calculateHash(Ops)) {}
180 
181   template <class NodeTy>
182   MDNodeOpsKey(const NodeTy *N, unsigned Offset = 0)
183       : Ops(N->op_begin() + Offset, N->op_end()), Hash(N->getHash()) {}
184 
185   template <class NodeTy>
186   bool compareOps(const NodeTy *RHS, unsigned Offset = 0) const {
187     if (getHash() != RHS->getHash())
188       return false;
189 
190     assert((RawOps.empty() || Ops.empty()) && "Two sets of operands?");
191     return RawOps.empty() ? compareOps(Ops, RHS, Offset)
192                           : compareOps(RawOps, RHS, Offset);
193   }
194 
195   static unsigned calculateHash(MDNode *N, unsigned Offset = 0);
196 
197 private:
198   template <class T>
compareOps(ArrayRef<T> Ops,const MDNode * RHS,unsigned Offset)199   static bool compareOps(ArrayRef<T> Ops, const MDNode *RHS, unsigned Offset) {
200     if (Ops.size() != RHS->getNumOperands() - Offset)
201       return false;
202     return std::equal(Ops.begin(), Ops.end(), RHS->op_begin() + Offset);
203   }
204 
205   static unsigned calculateHash(ArrayRef<Metadata *> Ops);
206 
207 public:
getHash()208   unsigned getHash() const { return Hash; }
209 };
210 
211 template <class NodeTy> struct MDNodeKeyImpl;
212 template <class NodeTy> struct MDNodeInfo;
213 
214 /// \brief DenseMapInfo for MDTuple.
215 ///
216 /// Note that we don't need the is-function-local bit, since that's implicit in
217 /// the operands.
218 template <> struct MDNodeKeyImpl<MDTuple> : MDNodeOpsKey {
219   MDNodeKeyImpl(ArrayRef<Metadata *> Ops) : MDNodeOpsKey(Ops) {}
220   MDNodeKeyImpl(const MDTuple *N) : MDNodeOpsKey(N) {}
221 
222   bool isKeyOf(const MDTuple *RHS) const { return compareOps(RHS); }
223 
224   unsigned getHashValue() const { return getHash(); }
225 
226   static unsigned calculateHash(MDTuple *N) {
227     return MDNodeOpsKey::calculateHash(N);
228   }
229 };
230 
231 /// \brief DenseMapInfo for DILocation.
232 template <> struct MDNodeKeyImpl<DILocation> {
233   unsigned Line;
234   unsigned Column;
235   Metadata *Scope;
236   Metadata *InlinedAt;
237 
238   MDNodeKeyImpl(unsigned Line, unsigned Column, Metadata *Scope,
239                 Metadata *InlinedAt)
240       : Line(Line), Column(Column), Scope(Scope), InlinedAt(InlinedAt) {}
241 
242   MDNodeKeyImpl(const DILocation *L)
243       : Line(L->getLine()), Column(L->getColumn()), Scope(L->getRawScope()),
244         InlinedAt(L->getRawInlinedAt()) {}
245 
246   bool isKeyOf(const DILocation *RHS) const {
247     return Line == RHS->getLine() && Column == RHS->getColumn() &&
248            Scope == RHS->getRawScope() && InlinedAt == RHS->getRawInlinedAt();
249   }
250   unsigned getHashValue() const {
251     return hash_combine(Line, Column, Scope, InlinedAt);
252   }
253 };
254 
255 /// \brief DenseMapInfo for GenericDINode.
256 template <> struct MDNodeKeyImpl<GenericDINode> : MDNodeOpsKey {
257   unsigned Tag;
258   StringRef Header;
259   MDNodeKeyImpl(unsigned Tag, StringRef Header, ArrayRef<Metadata *> DwarfOps)
260       : MDNodeOpsKey(DwarfOps), Tag(Tag), Header(Header) {}
261   MDNodeKeyImpl(const GenericDINode *N)
262       : MDNodeOpsKey(N, 1), Tag(N->getTag()), Header(N->getHeader()) {}
263 
264   bool isKeyOf(const GenericDINode *RHS) const {
265     return Tag == RHS->getTag() && Header == RHS->getHeader() &&
266            compareOps(RHS, 1);
267   }
268 
269   unsigned getHashValue() const { return hash_combine(getHash(), Tag, Header); }
270 
271   static unsigned calculateHash(GenericDINode *N) {
272     return MDNodeOpsKey::calculateHash(N, 1);
273   }
274 };
275 
276 template <> struct MDNodeKeyImpl<DISubrange> {
277   int64_t Count;
278   int64_t LowerBound;
279 
280   MDNodeKeyImpl(int64_t Count, int64_t LowerBound)
281       : Count(Count), LowerBound(LowerBound) {}
282   MDNodeKeyImpl(const DISubrange *N)
283       : Count(N->getCount()), LowerBound(N->getLowerBound()) {}
284 
285   bool isKeyOf(const DISubrange *RHS) const {
286     return Count == RHS->getCount() && LowerBound == RHS->getLowerBound();
287   }
288   unsigned getHashValue() const { return hash_combine(Count, LowerBound); }
289 };
290 
291 template <> struct MDNodeKeyImpl<DIEnumerator> {
292   int64_t Value;
293   StringRef Name;
294 
295   MDNodeKeyImpl(int64_t Value, StringRef Name) : Value(Value), Name(Name) {}
296   MDNodeKeyImpl(const DIEnumerator *N)
297       : Value(N->getValue()), Name(N->getName()) {}
298 
299   bool isKeyOf(const DIEnumerator *RHS) const {
300     return Value == RHS->getValue() && Name == RHS->getName();
301   }
302   unsigned getHashValue() const { return hash_combine(Value, Name); }
303 };
304 
305 template <> struct MDNodeKeyImpl<DIBasicType> {
306   unsigned Tag;
307   StringRef Name;
308   uint64_t SizeInBits;
309   uint64_t AlignInBits;
310   unsigned Encoding;
311 
312   MDNodeKeyImpl(unsigned Tag, StringRef Name, uint64_t SizeInBits,
313                 uint64_t AlignInBits, unsigned Encoding)
314       : Tag(Tag), Name(Name), SizeInBits(SizeInBits), AlignInBits(AlignInBits),
315         Encoding(Encoding) {}
316   MDNodeKeyImpl(const DIBasicType *N)
317       : Tag(N->getTag()), Name(N->getName()), SizeInBits(N->getSizeInBits()),
318         AlignInBits(N->getAlignInBits()), Encoding(N->getEncoding()) {}
319 
320   bool isKeyOf(const DIBasicType *RHS) const {
321     return Tag == RHS->getTag() && Name == RHS->getName() &&
322            SizeInBits == RHS->getSizeInBits() &&
323            AlignInBits == RHS->getAlignInBits() &&
324            Encoding == RHS->getEncoding();
325   }
326   unsigned getHashValue() const {
327     return hash_combine(Tag, Name, SizeInBits, AlignInBits, Encoding);
328   }
329 };
330 
331 template <> struct MDNodeKeyImpl<DIDerivedType> {
332   unsigned Tag;
333   StringRef Name;
334   Metadata *File;
335   unsigned Line;
336   Metadata *Scope;
337   Metadata *BaseType;
338   uint64_t SizeInBits;
339   uint64_t AlignInBits;
340   uint64_t OffsetInBits;
341   unsigned Flags;
342   Metadata *ExtraData;
343 
344   MDNodeKeyImpl(unsigned Tag, StringRef Name, Metadata *File, unsigned Line,
345                 Metadata *Scope, Metadata *BaseType, uint64_t SizeInBits,
346                 uint64_t AlignInBits, uint64_t OffsetInBits, unsigned Flags,
347                 Metadata *ExtraData)
348       : Tag(Tag), Name(Name), File(File), Line(Line), Scope(Scope),
349         BaseType(BaseType), SizeInBits(SizeInBits), AlignInBits(AlignInBits),
350         OffsetInBits(OffsetInBits), Flags(Flags), ExtraData(ExtraData) {}
351   MDNodeKeyImpl(const DIDerivedType *N)
352       : Tag(N->getTag()), Name(N->getName()), File(N->getRawFile()),
353         Line(N->getLine()), Scope(N->getRawScope()),
354         BaseType(N->getRawBaseType()), SizeInBits(N->getSizeInBits()),
355         AlignInBits(N->getAlignInBits()), OffsetInBits(N->getOffsetInBits()),
356         Flags(N->getFlags()), ExtraData(N->getRawExtraData()) {}
357 
358   bool isKeyOf(const DIDerivedType *RHS) const {
359     return Tag == RHS->getTag() && Name == RHS->getName() &&
360            File == RHS->getRawFile() && Line == RHS->getLine() &&
361            Scope == RHS->getRawScope() && BaseType == RHS->getRawBaseType() &&
362            SizeInBits == RHS->getSizeInBits() &&
363            AlignInBits == RHS->getAlignInBits() &&
364            OffsetInBits == RHS->getOffsetInBits() && Flags == RHS->getFlags() &&
365            ExtraData == RHS->getRawExtraData();
366   }
367   unsigned getHashValue() const {
368     return hash_combine(Tag, Name, File, Line, Scope, BaseType, SizeInBits,
369                         AlignInBits, OffsetInBits, Flags, ExtraData);
370   }
371 };
372 
373 template <> struct MDNodeKeyImpl<DICompositeType> {
374   unsigned Tag;
375   StringRef Name;
376   Metadata *File;
377   unsigned Line;
378   Metadata *Scope;
379   Metadata *BaseType;
380   uint64_t SizeInBits;
381   uint64_t AlignInBits;
382   uint64_t OffsetInBits;
383   unsigned Flags;
384   Metadata *Elements;
385   unsigned RuntimeLang;
386   Metadata *VTableHolder;
387   Metadata *TemplateParams;
388   StringRef Identifier;
389 
390   MDNodeKeyImpl(unsigned Tag, StringRef Name, Metadata *File, unsigned Line,
391                 Metadata *Scope, Metadata *BaseType, uint64_t SizeInBits,
392                 uint64_t AlignInBits, uint64_t OffsetInBits, unsigned Flags,
393                 Metadata *Elements, unsigned RuntimeLang,
394                 Metadata *VTableHolder, Metadata *TemplateParams,
395                 StringRef Identifier)
396       : Tag(Tag), Name(Name), File(File), Line(Line), Scope(Scope),
397         BaseType(BaseType), SizeInBits(SizeInBits), AlignInBits(AlignInBits),
398         OffsetInBits(OffsetInBits), Flags(Flags), Elements(Elements),
399         RuntimeLang(RuntimeLang), VTableHolder(VTableHolder),
400         TemplateParams(TemplateParams), Identifier(Identifier) {}
401   MDNodeKeyImpl(const DICompositeType *N)
402       : Tag(N->getTag()), Name(N->getName()), File(N->getRawFile()),
403         Line(N->getLine()), Scope(N->getRawScope()),
404         BaseType(N->getRawBaseType()), SizeInBits(N->getSizeInBits()),
405         AlignInBits(N->getAlignInBits()), OffsetInBits(N->getOffsetInBits()),
406         Flags(N->getFlags()), Elements(N->getRawElements()),
407         RuntimeLang(N->getRuntimeLang()), VTableHolder(N->getRawVTableHolder()),
408         TemplateParams(N->getRawTemplateParams()),
409         Identifier(N->getIdentifier()) {}
410 
411   bool isKeyOf(const DICompositeType *RHS) const {
412     return Tag == RHS->getTag() && Name == RHS->getName() &&
413            File == RHS->getRawFile() && Line == RHS->getLine() &&
414            Scope == RHS->getRawScope() && BaseType == RHS->getRawBaseType() &&
415            SizeInBits == RHS->getSizeInBits() &&
416            AlignInBits == RHS->getAlignInBits() &&
417            OffsetInBits == RHS->getOffsetInBits() && Flags == RHS->getFlags() &&
418            Elements == RHS->getRawElements() &&
419            RuntimeLang == RHS->getRuntimeLang() &&
420            VTableHolder == RHS->getRawVTableHolder() &&
421            TemplateParams == RHS->getRawTemplateParams() &&
422            Identifier == RHS->getIdentifier();
423   }
424   unsigned getHashValue() const {
425     return hash_combine(Tag, Name, File, Line, Scope, BaseType, SizeInBits,
426                         AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
427                         VTableHolder, TemplateParams, Identifier);
428   }
429 };
430 
431 template <> struct MDNodeKeyImpl<DISubroutineType> {
432   unsigned Flags;
433   Metadata *TypeArray;
434 
435   MDNodeKeyImpl(int64_t Flags, Metadata *TypeArray)
436       : Flags(Flags), TypeArray(TypeArray) {}
437   MDNodeKeyImpl(const DISubroutineType *N)
438       : Flags(N->getFlags()), TypeArray(N->getRawTypeArray()) {}
439 
440   bool isKeyOf(const DISubroutineType *RHS) const {
441     return Flags == RHS->getFlags() && TypeArray == RHS->getRawTypeArray();
442   }
443   unsigned getHashValue() const { return hash_combine(Flags, TypeArray); }
444 };
445 
446 template <> struct MDNodeKeyImpl<DIFile> {
447   StringRef Filename;
448   StringRef Directory;
449 
450   MDNodeKeyImpl(StringRef Filename, StringRef Directory)
451       : Filename(Filename), Directory(Directory) {}
452   MDNodeKeyImpl(const DIFile *N)
453       : Filename(N->getFilename()), Directory(N->getDirectory()) {}
454 
455   bool isKeyOf(const DIFile *RHS) const {
456     return Filename == RHS->getFilename() && Directory == RHS->getDirectory();
457   }
458   unsigned getHashValue() const { return hash_combine(Filename, Directory); }
459 };
460 
461 template <> struct MDNodeKeyImpl<DISubprogram> {
462   Metadata *Scope;
463   StringRef Name;
464   StringRef LinkageName;
465   Metadata *File;
466   unsigned Line;
467   Metadata *Type;
468   bool IsLocalToUnit;
469   bool IsDefinition;
470   unsigned ScopeLine;
471   Metadata *ContainingType;
472   unsigned Virtuality;
473   unsigned VirtualIndex;
474   unsigned Flags;
475   bool IsOptimized;
476   Metadata *TemplateParams;
477   Metadata *Declaration;
478   Metadata *Variables;
479 
480   MDNodeKeyImpl(Metadata *Scope, StringRef Name, StringRef LinkageName,
481                 Metadata *File, unsigned Line, Metadata *Type,
482                 bool IsLocalToUnit, bool IsDefinition, unsigned ScopeLine,
483                 Metadata *ContainingType, unsigned Virtuality,
484                 unsigned VirtualIndex, unsigned Flags, bool IsOptimized,
485                 Metadata *TemplateParams, Metadata *Declaration,
486                 Metadata *Variables)
487       : Scope(Scope), Name(Name), LinkageName(LinkageName), File(File),
488         Line(Line), Type(Type), IsLocalToUnit(IsLocalToUnit),
489         IsDefinition(IsDefinition), ScopeLine(ScopeLine),
490         ContainingType(ContainingType), Virtuality(Virtuality),
491         VirtualIndex(VirtualIndex), Flags(Flags), IsOptimized(IsOptimized),
492         TemplateParams(TemplateParams), Declaration(Declaration),
493         Variables(Variables) {}
494   MDNodeKeyImpl(const DISubprogram *N)
495       : Scope(N->getRawScope()), Name(N->getName()),
496         LinkageName(N->getLinkageName()), File(N->getRawFile()),
497         Line(N->getLine()), Type(N->getRawType()),
498         IsLocalToUnit(N->isLocalToUnit()), IsDefinition(N->isDefinition()),
499         ScopeLine(N->getScopeLine()), ContainingType(N->getRawContainingType()),
500         Virtuality(N->getVirtuality()), VirtualIndex(N->getVirtualIndex()),
501         Flags(N->getFlags()), IsOptimized(N->isOptimized()),
502         TemplateParams(N->getRawTemplateParams()),
503         Declaration(N->getRawDeclaration()), Variables(N->getRawVariables()) {}
504 
505   bool isKeyOf(const DISubprogram *RHS) const {
506     return Scope == RHS->getRawScope() && Name == RHS->getName() &&
507            LinkageName == RHS->getLinkageName() && File == RHS->getRawFile() &&
508            Line == RHS->getLine() && Type == RHS->getRawType() &&
509            IsLocalToUnit == RHS->isLocalToUnit() &&
510            IsDefinition == RHS->isDefinition() &&
511            ScopeLine == RHS->getScopeLine() &&
512            ContainingType == RHS->getRawContainingType() &&
513            Virtuality == RHS->getVirtuality() &&
514            VirtualIndex == RHS->getVirtualIndex() && Flags == RHS->getFlags() &&
515            IsOptimized == RHS->isOptimized() &&
516            TemplateParams == RHS->getRawTemplateParams() &&
517            Declaration == RHS->getRawDeclaration() &&
518            Variables == RHS->getRawVariables();
519   }
520   unsigned getHashValue() const {
521     return hash_combine(Scope, Name, LinkageName, File, Line, Type,
522                         IsLocalToUnit, IsDefinition, ScopeLine, ContainingType,
523                         Virtuality, VirtualIndex, Flags, IsOptimized,
524                         TemplateParams, Declaration, Variables);
525   }
526 };
527 
528 template <> struct MDNodeKeyImpl<DILexicalBlock> {
529   Metadata *Scope;
530   Metadata *File;
531   unsigned Line;
532   unsigned Column;
533 
534   MDNodeKeyImpl(Metadata *Scope, Metadata *File, unsigned Line, unsigned Column)
535       : Scope(Scope), File(File), Line(Line), Column(Column) {}
536   MDNodeKeyImpl(const DILexicalBlock *N)
537       : Scope(N->getRawScope()), File(N->getRawFile()), Line(N->getLine()),
538         Column(N->getColumn()) {}
539 
540   bool isKeyOf(const DILexicalBlock *RHS) const {
541     return Scope == RHS->getRawScope() && File == RHS->getRawFile() &&
542            Line == RHS->getLine() && Column == RHS->getColumn();
543   }
544   unsigned getHashValue() const {
545     return hash_combine(Scope, File, Line, Column);
546   }
547 };
548 
549 template <> struct MDNodeKeyImpl<DILexicalBlockFile> {
550   Metadata *Scope;
551   Metadata *File;
552   unsigned Discriminator;
553 
554   MDNodeKeyImpl(Metadata *Scope, Metadata *File, unsigned Discriminator)
555       : Scope(Scope), File(File), Discriminator(Discriminator) {}
556   MDNodeKeyImpl(const DILexicalBlockFile *N)
557       : Scope(N->getRawScope()), File(N->getRawFile()),
558         Discriminator(N->getDiscriminator()) {}
559 
560   bool isKeyOf(const DILexicalBlockFile *RHS) const {
561     return Scope == RHS->getRawScope() && File == RHS->getRawFile() &&
562            Discriminator == RHS->getDiscriminator();
563   }
564   unsigned getHashValue() const {
565     return hash_combine(Scope, File, Discriminator);
566   }
567 };
568 
569 template <> struct MDNodeKeyImpl<DINamespace> {
570   Metadata *Scope;
571   Metadata *File;
572   StringRef Name;
573   unsigned Line;
574 
575   MDNodeKeyImpl(Metadata *Scope, Metadata *File, StringRef Name, unsigned Line)
576       : Scope(Scope), File(File), Name(Name), Line(Line) {}
577   MDNodeKeyImpl(const DINamespace *N)
578       : Scope(N->getRawScope()), File(N->getRawFile()), Name(N->getName()),
579         Line(N->getLine()) {}
580 
581   bool isKeyOf(const DINamespace *RHS) const {
582     return Scope == RHS->getRawScope() && File == RHS->getRawFile() &&
583            Name == RHS->getName() && Line == RHS->getLine();
584   }
585   unsigned getHashValue() const {
586     return hash_combine(Scope, File, Name, Line);
587   }
588 };
589 
590 template <> struct MDNodeKeyImpl<DIModule> {
591   Metadata *Scope;
592   StringRef Name;
593   StringRef ConfigurationMacros;
594   StringRef IncludePath;
595   StringRef ISysRoot;
596   MDNodeKeyImpl(Metadata *Scope, StringRef Name,
597                 StringRef ConfigurationMacros,
598                 StringRef IncludePath,
599                 StringRef ISysRoot)
600     : Scope(Scope), Name(Name), ConfigurationMacros(ConfigurationMacros),
601       IncludePath(IncludePath), ISysRoot(ISysRoot) {}
602   MDNodeKeyImpl(const DIModule *N)
603     : Scope(N->getRawScope()), Name(N->getName()),
604       ConfigurationMacros(N->getConfigurationMacros()),
605       IncludePath(N->getIncludePath()), ISysRoot(N->getISysRoot()) {}
606 
607   bool isKeyOf(const DIModule *RHS) const {
608     return Scope == RHS->getRawScope() && Name == RHS->getName() &&
609            ConfigurationMacros == RHS->getConfigurationMacros() &&
610            IncludePath == RHS->getIncludePath() &&
611            ISysRoot == RHS->getISysRoot();
612   }
613   unsigned getHashValue() const {
614     return hash_combine(Scope, Name,
615                         ConfigurationMacros, IncludePath, ISysRoot);
616   }
617 };
618 
619 template <> struct MDNodeKeyImpl<DITemplateTypeParameter> {
620   StringRef Name;
621   Metadata *Type;
622 
623   MDNodeKeyImpl(StringRef Name, Metadata *Type) : Name(Name), Type(Type) {}
624   MDNodeKeyImpl(const DITemplateTypeParameter *N)
625       : Name(N->getName()), Type(N->getRawType()) {}
626 
627   bool isKeyOf(const DITemplateTypeParameter *RHS) const {
628     return Name == RHS->getName() && Type == RHS->getRawType();
629   }
630   unsigned getHashValue() const { return hash_combine(Name, Type); }
631 };
632 
633 template <> struct MDNodeKeyImpl<DITemplateValueParameter> {
634   unsigned Tag;
635   StringRef Name;
636   Metadata *Type;
637   Metadata *Value;
638 
639   MDNodeKeyImpl(unsigned Tag, StringRef Name, Metadata *Type, Metadata *Value)
640       : Tag(Tag), Name(Name), Type(Type), Value(Value) {}
641   MDNodeKeyImpl(const DITemplateValueParameter *N)
642       : Tag(N->getTag()), Name(N->getName()), Type(N->getRawType()),
643         Value(N->getValue()) {}
644 
645   bool isKeyOf(const DITemplateValueParameter *RHS) const {
646     return Tag == RHS->getTag() && Name == RHS->getName() &&
647            Type == RHS->getRawType() && Value == RHS->getValue();
648   }
649   unsigned getHashValue() const { return hash_combine(Tag, Name, Type, Value); }
650 };
651 
652 template <> struct MDNodeKeyImpl<DIGlobalVariable> {
653   Metadata *Scope;
654   StringRef Name;
655   StringRef LinkageName;
656   Metadata *File;
657   unsigned Line;
658   Metadata *Type;
659   bool IsLocalToUnit;
660   bool IsDefinition;
661   Metadata *Variable;
662   Metadata *StaticDataMemberDeclaration;
663 
664   MDNodeKeyImpl(Metadata *Scope, StringRef Name, StringRef LinkageName,
665                 Metadata *File, unsigned Line, Metadata *Type,
666                 bool IsLocalToUnit, bool IsDefinition, Metadata *Variable,
667                 Metadata *StaticDataMemberDeclaration)
668       : Scope(Scope), Name(Name), LinkageName(LinkageName), File(File),
669         Line(Line), Type(Type), IsLocalToUnit(IsLocalToUnit),
670         IsDefinition(IsDefinition), Variable(Variable),
671         StaticDataMemberDeclaration(StaticDataMemberDeclaration) {}
672   MDNodeKeyImpl(const DIGlobalVariable *N)
673       : Scope(N->getRawScope()), Name(N->getName()),
674         LinkageName(N->getLinkageName()), File(N->getRawFile()),
675         Line(N->getLine()), Type(N->getRawType()),
676         IsLocalToUnit(N->isLocalToUnit()), IsDefinition(N->isDefinition()),
677         Variable(N->getRawVariable()),
678         StaticDataMemberDeclaration(N->getRawStaticDataMemberDeclaration()) {}
679 
680   bool isKeyOf(const DIGlobalVariable *RHS) const {
681     return Scope == RHS->getRawScope() && Name == RHS->getName() &&
682            LinkageName == RHS->getLinkageName() && File == RHS->getRawFile() &&
683            Line == RHS->getLine() && Type == RHS->getRawType() &&
684            IsLocalToUnit == RHS->isLocalToUnit() &&
685            IsDefinition == RHS->isDefinition() &&
686            Variable == RHS->getRawVariable() &&
687            StaticDataMemberDeclaration ==
688                RHS->getRawStaticDataMemberDeclaration();
689   }
690   unsigned getHashValue() const {
691     return hash_combine(Scope, Name, LinkageName, File, Line, Type,
692                         IsLocalToUnit, IsDefinition, Variable,
693                         StaticDataMemberDeclaration);
694   }
695 };
696 
697 template <> struct MDNodeKeyImpl<DILocalVariable> {
698   Metadata *Scope;
699   StringRef Name;
700   Metadata *File;
701   unsigned Line;
702   Metadata *Type;
703   unsigned Arg;
704   unsigned Flags;
705 
706   MDNodeKeyImpl(Metadata *Scope, StringRef Name, Metadata *File, unsigned Line,
707                 Metadata *Type, unsigned Arg, unsigned Flags)
708       : Scope(Scope), Name(Name), File(File), Line(Line), Type(Type), Arg(Arg),
709         Flags(Flags) {}
710   MDNodeKeyImpl(const DILocalVariable *N)
711       : Scope(N->getRawScope()), Name(N->getName()), File(N->getRawFile()),
712         Line(N->getLine()), Type(N->getRawType()), Arg(N->getArg()),
713         Flags(N->getFlags()) {}
714 
715   bool isKeyOf(const DILocalVariable *RHS) const {
716     return Scope == RHS->getRawScope() && Name == RHS->getName() &&
717            File == RHS->getRawFile() && Line == RHS->getLine() &&
718            Type == RHS->getRawType() && Arg == RHS->getArg() &&
719            Flags == RHS->getFlags();
720   }
721   unsigned getHashValue() const {
722     return hash_combine(Scope, Name, File, Line, Type, Arg, Flags);
723   }
724 };
725 
726 template <> struct MDNodeKeyImpl<DIExpression> {
727   ArrayRef<uint64_t> Elements;
728 
729   MDNodeKeyImpl(ArrayRef<uint64_t> Elements) : Elements(Elements) {}
730   MDNodeKeyImpl(const DIExpression *N) : Elements(N->getElements()) {}
731 
732   bool isKeyOf(const DIExpression *RHS) const {
733     return Elements == RHS->getElements();
734   }
735   unsigned getHashValue() const {
736     return hash_combine_range(Elements.begin(), Elements.end());
737   }
738 };
739 
740 template <> struct MDNodeKeyImpl<DIObjCProperty> {
741   StringRef Name;
742   Metadata *File;
743   unsigned Line;
744   StringRef GetterName;
745   StringRef SetterName;
746   unsigned Attributes;
747   Metadata *Type;
748 
749   MDNodeKeyImpl(StringRef Name, Metadata *File, unsigned Line,
750                 StringRef GetterName, StringRef SetterName, unsigned Attributes,
751                 Metadata *Type)
752       : Name(Name), File(File), Line(Line), GetterName(GetterName),
753         SetterName(SetterName), Attributes(Attributes), Type(Type) {}
754   MDNodeKeyImpl(const DIObjCProperty *N)
755       : Name(N->getName()), File(N->getRawFile()), Line(N->getLine()),
756         GetterName(N->getGetterName()), SetterName(N->getSetterName()),
757         Attributes(N->getAttributes()), Type(N->getRawType()) {}
758 
759   bool isKeyOf(const DIObjCProperty *RHS) const {
760     return Name == RHS->getName() && File == RHS->getRawFile() &&
761            Line == RHS->getLine() && GetterName == RHS->getGetterName() &&
762            SetterName == RHS->getSetterName() &&
763            Attributes == RHS->getAttributes() && Type == RHS->getRawType();
764   }
765   unsigned getHashValue() const {
766     return hash_combine(Name, File, Line, GetterName, SetterName, Attributes,
767                         Type);
768   }
769 };
770 
771 template <> struct MDNodeKeyImpl<DIImportedEntity> {
772   unsigned Tag;
773   Metadata *Scope;
774   Metadata *Entity;
775   unsigned Line;
776   StringRef Name;
777 
778   MDNodeKeyImpl(unsigned Tag, Metadata *Scope, Metadata *Entity, unsigned Line,
779                 StringRef Name)
780       : Tag(Tag), Scope(Scope), Entity(Entity), Line(Line), Name(Name) {}
781   MDNodeKeyImpl(const DIImportedEntity *N)
782       : Tag(N->getTag()), Scope(N->getRawScope()), Entity(N->getRawEntity()),
783         Line(N->getLine()), Name(N->getName()) {}
784 
785   bool isKeyOf(const DIImportedEntity *RHS) const {
786     return Tag == RHS->getTag() && Scope == RHS->getRawScope() &&
787            Entity == RHS->getRawEntity() && Line == RHS->getLine() &&
788            Name == RHS->getName();
789   }
790   unsigned getHashValue() const {
791     return hash_combine(Tag, Scope, Entity, Line, Name);
792   }
793 };
794 
795 template <> struct MDNodeKeyImpl<DIMacro> {
796   unsigned MIType;
797   unsigned Line;
798   StringRef Name;
799   StringRef Value;
800 
801   MDNodeKeyImpl(unsigned MIType, unsigned Line, StringRef Name, StringRef Value)
802       : MIType(MIType), Line(Line), Name(Name), Value(Value) {}
803   MDNodeKeyImpl(const DIMacro *N)
804       : MIType(N->getMacinfoType()), Line(N->getLine()), Name(N->getName()),
805         Value(N->getValue()) {}
806 
807   bool isKeyOf(const DIMacro *RHS) const {
808     return MIType == RHS->getMacinfoType() && Line == RHS->getLine() &&
809            Name == RHS->getName() && Value == RHS->getValue();
810   }
811   unsigned getHashValue() const {
812     return hash_combine(MIType, Line, Name, Value);
813   }
814 };
815 
816 template <> struct MDNodeKeyImpl<DIMacroFile> {
817   unsigned MIType;
818   unsigned Line;
819   Metadata *File;
820   Metadata *Elements;
821 
822   MDNodeKeyImpl(unsigned MIType, unsigned Line, Metadata *File,
823                 Metadata *Elements)
824       : MIType(MIType), Line(Line), File(File), Elements(Elements) {}
825   MDNodeKeyImpl(const DIMacroFile *N)
826       : MIType(N->getMacinfoType()), Line(N->getLine()), File(N->getRawFile()),
827         Elements(N->getRawElements()) {}
828 
829   bool isKeyOf(const DIMacroFile *RHS) const {
830     return MIType == RHS->getMacinfoType() && Line == RHS->getLine() &&
831            File == RHS->getRawFile() && File == RHS->getRawElements();
832   }
833   unsigned getHashValue() const {
834     return hash_combine(MIType, Line, File, Elements);
835   }
836 };
837 
838 /// \brief DenseMapInfo for MDNode subclasses.
839 template <class NodeTy> struct MDNodeInfo {
840   typedef MDNodeKeyImpl<NodeTy> KeyTy;
841   static inline NodeTy *getEmptyKey() {
842     return DenseMapInfo<NodeTy *>::getEmptyKey();
843   }
844   static inline NodeTy *getTombstoneKey() {
845     return DenseMapInfo<NodeTy *>::getTombstoneKey();
846   }
847   static unsigned getHashValue(const KeyTy &Key) { return Key.getHashValue(); }
848   static unsigned getHashValue(const NodeTy *N) {
849     return KeyTy(N).getHashValue();
850   }
851   static bool isEqual(const KeyTy &LHS, const NodeTy *RHS) {
852     if (RHS == getEmptyKey() || RHS == getTombstoneKey())
853       return false;
854     return LHS.isKeyOf(RHS);
855   }
856   static bool isEqual(const NodeTy *LHS, const NodeTy *RHS) {
857     return LHS == RHS;
858   }
859 };
860 
861 #define HANDLE_MDNODE_LEAF(CLASS) typedef MDNodeInfo<CLASS> CLASS##Info;
862 #include "llvm/IR/Metadata.def"
863 
864 /// \brief Map-like storage for metadata attachments.
865 class MDAttachmentMap {
866   SmallVector<std::pair<unsigned, TrackingMDNodeRef>, 2> Attachments;
867 
868 public:
869   bool empty() const { return Attachments.empty(); }
870   size_t size() const { return Attachments.size(); }
871 
872   /// \brief Get a particular attachment (if any).
873   MDNode *lookup(unsigned ID) const;
874 
875   /// \brief Set an attachment to a particular node.
876   ///
877   /// Set the \c ID attachment to \c MD, replacing the current attachment at \c
878   /// ID (if anyway).
879   void set(unsigned ID, MDNode &MD);
880 
881   /// \brief Remove an attachment.
882   ///
883   /// Remove the attachment at \c ID, if any.
884   void erase(unsigned ID);
885 
886   /// \brief Copy out all the attachments.
887   ///
888   /// Copies all the current attachments into \c Result, sorting by attachment
889   /// ID.  This function does \em not clear \c Result.
890   void getAll(SmallVectorImpl<std::pair<unsigned, MDNode *>> &Result) const;
891 
892   /// \brief Erase matching attachments.
893   ///
894   /// Erases all attachments matching the \c shouldRemove predicate.
895   template <class PredTy> void remove_if(PredTy shouldRemove) {
896     Attachments.erase(
897         std::remove_if(Attachments.begin(), Attachments.end(), shouldRemove),
898         Attachments.end());
899   }
900 };
901 
902 class LLVMContextImpl {
903 public:
904   /// OwnedModules - The set of modules instantiated in this context, and which
905   /// will be automatically deleted if this context is deleted.
906   SmallPtrSet<Module*, 4> OwnedModules;
907 
908   LLVMContext::InlineAsmDiagHandlerTy InlineAsmDiagHandler;
909   void *InlineAsmDiagContext;
910 
911   LLVMContext::DiagnosticHandlerTy DiagnosticHandler;
912   void *DiagnosticContext;
913   bool RespectDiagnosticFilters;
914 
915   LLVMContext::YieldCallbackTy YieldCallback;
916   void *YieldOpaqueHandle;
917 
918   typedef DenseMap<APInt, ConstantInt *, DenseMapAPIntKeyInfo> IntMapTy;
919   IntMapTy IntConstants;
920 
921   typedef DenseMap<APFloat, ConstantFP *, DenseMapAPFloatKeyInfo> FPMapTy;
922   FPMapTy FPConstants;
923 
924   FoldingSet<AttributeImpl> AttrsSet;
925   FoldingSet<AttributeSetImpl> AttrsLists;
926   FoldingSet<AttributeSetNode> AttrsSetNodes;
927 
928   StringMap<MDString> MDStringCache;
929   DenseMap<Value *, ValueAsMetadata *> ValuesAsMetadata;
930   DenseMap<Metadata *, MetadataAsValue *> MetadataAsValues;
931 
932   DenseMap<const Value*, ValueName*> ValueNames;
933 
934 #define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS)                                    \
935   DenseSet<CLASS *, CLASS##Info> CLASS##s;
936 #include "llvm/IR/Metadata.def"
937 
938   // MDNodes may be uniqued or not uniqued.  When they're not uniqued, they
939   // aren't in the MDNodeSet, but they're still shared between objects, so no
940   // one object can destroy them.  This set allows us to at least destroy them
941   // on Context destruction.
942   SmallPtrSet<MDNode *, 1> DistinctMDNodes;
943 
944   DenseMap<Type*, ConstantAggregateZero*> CAZConstants;
945 
946   typedef ConstantUniqueMap<ConstantArray> ArrayConstantsTy;
947   ArrayConstantsTy ArrayConstants;
948 
949   typedef ConstantUniqueMap<ConstantStruct> StructConstantsTy;
950   StructConstantsTy StructConstants;
951 
952   typedef ConstantUniqueMap<ConstantVector> VectorConstantsTy;
953   VectorConstantsTy VectorConstants;
954 
955   DenseMap<PointerType*, ConstantPointerNull*> CPNConstants;
956 
957   DenseMap<Type*, UndefValue*> UVConstants;
958 
959   StringMap<ConstantDataSequential*> CDSConstants;
960 
961   DenseMap<std::pair<const Function *, const BasicBlock *>, BlockAddress *>
962     BlockAddresses;
963   ConstantUniqueMap<ConstantExpr> ExprConstants;
964 
965   ConstantUniqueMap<InlineAsm> InlineAsms;
966 
967   ConstantInt *TheTrueVal;
968   ConstantInt *TheFalseVal;
969 
970   std::unique_ptr<ConstantTokenNone> TheNoneToken;
971 
972   // Basic type instances.
973   Type VoidTy, LabelTy, HalfTy, FloatTy, DoubleTy, MetadataTy, TokenTy;
974   Type X86_FP80Ty, FP128Ty, PPC_FP128Ty, X86_MMXTy;
975   IntegerType Int1Ty, Int8Ty, Int16Ty, Int32Ty, Int64Ty, Int128Ty;
976 
977 
978   /// TypeAllocator - All dynamically allocated types are allocated from this.
979   /// They live forever until the context is torn down.
980   BumpPtrAllocator TypeAllocator;
981 
982   DenseMap<unsigned, IntegerType*> IntegerTypes;
983 
984   typedef DenseSet<FunctionType *, FunctionTypeKeyInfo> FunctionTypeSet;
985   FunctionTypeSet FunctionTypes;
986   typedef DenseSet<StructType *, AnonStructTypeKeyInfo> StructTypeSet;
987   StructTypeSet AnonStructTypes;
988   StringMap<StructType*> NamedStructTypes;
989   unsigned NamedStructTypesUniqueID;
990 
991   DenseMap<std::pair<Type *, uint64_t>, ArrayType*> ArrayTypes;
992   DenseMap<std::pair<Type *, unsigned>, VectorType*> VectorTypes;
993   DenseMap<Type*, PointerType*> PointerTypes;  // Pointers in AddrSpace = 0
994   DenseMap<std::pair<Type*, unsigned>, PointerType*> ASPointerTypes;
995 
996 
997   /// ValueHandles - This map keeps track of all of the value handles that are
998   /// watching a Value*.  The Value::HasValueHandle bit is used to know
999   /// whether or not a value has an entry in this map.
1000   typedef DenseMap<Value*, ValueHandleBase*> ValueHandlesTy;
1001   ValueHandlesTy ValueHandles;
1002 
1003   /// CustomMDKindNames - Map to hold the metadata string to ID mapping.
1004   StringMap<unsigned> CustomMDKindNames;
1005 
1006   /// Collection of per-instruction metadata used in this context.
1007   DenseMap<const Instruction *, MDAttachmentMap> InstructionMetadata;
1008 
1009   /// Collection of per-function metadata used in this context.
1010   DenseMap<const Function *, MDAttachmentMap> FunctionMetadata;
1011 
1012   /// DiscriminatorTable - This table maps file:line locations to an
1013   /// integer representing the next DWARF path discriminator to assign to
1014   /// instructions in different blocks at the same location.
1015   DenseMap<std::pair<const char *, unsigned>, unsigned> DiscriminatorTable;
1016 
1017   int getOrAddScopeRecordIdxEntry(MDNode *N, int ExistingIdx);
1018   int getOrAddScopeInlinedAtIdxEntry(MDNode *Scope, MDNode *IA,int ExistingIdx);
1019 
1020   /// \brief A set of interned tags for operand bundles.  The StringMap maps
1021   /// bundle tags to their IDs.
1022   ///
1023   /// \see LLVMContext::getOperandBundleTagID
1024   StringMap<uint32_t> BundleTagCache;
1025 
1026   StringMapEntry<uint32_t> *getOrInsertBundleTag(StringRef Tag);
1027   void getOperandBundleTags(SmallVectorImpl<StringRef> &Tags) const;
1028   uint32_t getOperandBundleTagID(StringRef Tag) const;
1029 
1030   LLVMContextImpl(LLVMContext &C);
1031   ~LLVMContextImpl();
1032 
1033   /// Destroy the ConstantArrays if they are not used.
1034   void dropTriviallyDeadConstantArrays();
1035 };
1036 
1037 }
1038 
1039 #endif
1040