LLVM  3.7.0
LLVMContextImpl.h
Go to the documentation of this file.
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"
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 
50  static inline APInt getEmptyKey() {
51  APInt V(nullptr, 0);
52  V.VAL = 0;
53  return V;
54  }
55  static inline APInt getTombstoneKey() {
56  APInt V(nullptr, 0);
57  V.VAL = 1;
58  return V;
59  }
60  static unsigned getHashValue(const APInt &Key) {
61  return static_cast<unsigned>(hash_value(Key));
62  }
63  static bool isEqual(const APInt &LHS, const APInt &RHS) {
64  return LHS.getBitWidth() == RHS.getBitWidth() && LHS == RHS;
65  }
66 };
67 
69  static inline APFloat getEmptyKey() { return APFloat(APFloat::Bogus, 1); }
70  static inline APFloat getTombstoneKey() { return APFloat(APFloat::Bogus, 2); }
71  static unsigned getHashValue(const APFloat &Key) {
72  return static_cast<unsigned>(hash_value(Key));
73  }
74  static bool isEqual(const APFloat &LHS, const APFloat &RHS) {
75  return LHS.bitwiseIsEqual(RHS);
76  }
77 };
78 
80  struct KeyTy {
82  bool isPacked;
83  KeyTy(const ArrayRef<Type*>& E, bool P) :
84  ETypes(E), isPacked(P) {}
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  };
98  static inline StructType* getEmptyKey() {
100  }
101  static inline StructType* getTombstoneKey() {
103  }
104  static unsigned getHashValue(const KeyTy& Key) {
105  return hash_combine(hash_combine_range(Key.ETypes.begin(),
106  Key.ETypes.end()),
107  Key.isPacked);
108  }
109  static unsigned getHashValue(const StructType *ST) {
110  return getHashValue(KeyTy(ST));
111  }
112  static bool isEqual(const KeyTy& LHS, const StructType *RHS) {
113  if (RHS == getEmptyKey() || RHS == getTombstoneKey())
114  return false;
115  return LHS == KeyTy(RHS);
116  }
117  static bool isEqual(const StructType *LHS, const StructType *RHS) {
118  return LHS == RHS;
119  }
120 };
121 
123  struct KeyTy {
124  const Type *ReturnType;
126  bool isVarArg;
127  KeyTy(const Type* R, const ArrayRef<Type*>& P, bool V) :
128  ReturnType(R), Params(P), isVarArg(V) {}
129  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  };
145  static inline FunctionType* getEmptyKey() {
147  }
148  static inline FunctionType* getTombstoneKey() {
150  }
151  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  }
157  static unsigned getHashValue(const FunctionType *FT) {
158  return getHashValue(KeyTy(FT));
159  }
160  static bool isEqual(const KeyTy& LHS, const FunctionType *RHS) {
161  if (RHS == getEmptyKey() || RHS == getTombstoneKey())
162  return false;
163  return LHS == KeyTy(RHS);
164  }
165  static bool isEqual(const FunctionType *LHS, const FunctionType *RHS) {
166  return LHS == RHS;
167  }
168 };
169 
170 /// \brief Structure for hashing arbitrary MDNode operands.
172  ArrayRef<Metadata *> RawOps;
174 
175  unsigned Hash;
176 
177 protected:
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>
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:
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 {
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;
237 
238  MDNodeKeyImpl(unsigned Line, unsigned Column, Metadata *Scope,
239  Metadata *InlinedAt)
240  : Line(Line), Column(Column), Scope(Scope), InlinedAt(InlinedAt) {}
241 
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;
259  MDNodeKeyImpl(unsigned Tag, StringRef Header, ArrayRef<Metadata *> DwarfOps)
260  : MDNodeOpsKey(DwarfOps), Tag(Tag), Header(Header) {}
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) {}
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;
294 
295  MDNodeKeyImpl(int64_t Value, StringRef Name) : Value(Value), Name(Name) {}
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;
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) {}
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;
335  unsigned Line;
338  uint64_t SizeInBits;
339  uint64_t AlignInBits;
340  uint64_t OffsetInBits;
341  unsigned Flags;
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) {}
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;
377  unsigned Line;
380  uint64_t SizeInBits;
381  uint64_t AlignInBits;
382  uint64_t OffsetInBits;
383  unsigned Flags;
385  unsigned RuntimeLang;
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) {}
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;
434 
435  MDNodeKeyImpl(int64_t Flags, Metadata *TypeArray)
436  : Flags(Flags), TypeArray(TypeArray) {}
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> {
449 
450  MDNodeKeyImpl(StringRef Filename, StringRef Directory)
451  : Filename(Filename), Directory(Directory) {}
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<DICompileUnit> {
462  unsigned SourceLanguage;
467  unsigned RuntimeVersion;
469  unsigned EmissionKind;
475  uint64_t DWOId;
476 
478  bool IsOptimized, StringRef Flags, unsigned RuntimeVersion,
479  StringRef SplitDebugFilename, unsigned EmissionKind,
480  Metadata *EnumTypes, Metadata *RetainedTypes,
481  Metadata *Subprograms, Metadata *GlobalVariables,
482  Metadata *ImportedEntities, uint64_t DWOId)
483  : SourceLanguage(SourceLanguage), File(File), Producer(Producer),
484  IsOptimized(IsOptimized), Flags(Flags), RuntimeVersion(RuntimeVersion),
485  SplitDebugFilename(SplitDebugFilename), EmissionKind(EmissionKind),
486  EnumTypes(EnumTypes), RetainedTypes(RetainedTypes),
487  Subprograms(Subprograms), GlobalVariables(GlobalVariables),
488  ImportedEntities(ImportedEntities), DWOId(DWOId) {}
490  : SourceLanguage(N->getSourceLanguage()), File(N->getRawFile()),
491  Producer(N->getProducer()), IsOptimized(N->isOptimized()),
492  Flags(N->getFlags()), RuntimeVersion(N->getRuntimeVersion()),
493  SplitDebugFilename(N->getSplitDebugFilename()),
494  EmissionKind(N->getEmissionKind()), EnumTypes(N->getRawEnumTypes()),
495  RetainedTypes(N->getRawRetainedTypes()),
496  Subprograms(N->getRawSubprograms()),
497  GlobalVariables(N->getRawGlobalVariables()),
498  ImportedEntities(N->getRawImportedEntities()), DWOId(N->getDWOId()) {}
499 
500  bool isKeyOf(const DICompileUnit *RHS) const {
501  return SourceLanguage == RHS->getSourceLanguage() &&
502  File == RHS->getRawFile() && Producer == RHS->getProducer() &&
503  IsOptimized == RHS->isOptimized() && Flags == RHS->getFlags() &&
504  RuntimeVersion == RHS->getRuntimeVersion() &&
505  SplitDebugFilename == RHS->getSplitDebugFilename() &&
506  EmissionKind == RHS->getEmissionKind() &&
507  EnumTypes == RHS->getRawEnumTypes() &&
508  RetainedTypes == RHS->getRawRetainedTypes() &&
509  Subprograms == RHS->getRawSubprograms() &&
510  GlobalVariables == RHS->getRawGlobalVariables() &&
511  ImportedEntities == RHS->getRawImportedEntities() &&
512  DWOId == RHS->getDWOId();
513  }
514  unsigned getHashValue() const {
515  return hash_combine(SourceLanguage, File, Producer, IsOptimized, Flags,
516  RuntimeVersion, SplitDebugFilename, EmissionKind,
517  EnumTypes, RetainedTypes, Subprograms, GlobalVariables,
518  ImportedEntities, DWOId);
519  }
520 };
521 
522 template <> struct MDNodeKeyImpl<DISubprogram> {
527  unsigned Line;
531  unsigned ScopeLine;
533  unsigned Virtuality;
534  unsigned VirtualIndex;
535  unsigned Flags;
541 
543  Metadata *File, unsigned Line, Metadata *Type,
544  bool IsLocalToUnit, bool IsDefinition, unsigned ScopeLine,
545  Metadata *ContainingType, unsigned Virtuality,
546  unsigned VirtualIndex, unsigned Flags, bool IsOptimized,
547  Metadata *Function, Metadata *TemplateParams,
548  Metadata *Declaration, Metadata *Variables)
549  : Scope(Scope), Name(Name), LinkageName(LinkageName), File(File),
550  Line(Line), Type(Type), IsLocalToUnit(IsLocalToUnit),
551  IsDefinition(IsDefinition), ScopeLine(ScopeLine),
552  ContainingType(ContainingType), Virtuality(Virtuality),
553  VirtualIndex(VirtualIndex), Flags(Flags), IsOptimized(IsOptimized),
554  Function(Function), TemplateParams(TemplateParams),
555  Declaration(Declaration), Variables(Variables) {}
557  : Scope(N->getRawScope()), Name(N->getName()),
558  LinkageName(N->getLinkageName()), File(N->getRawFile()),
559  Line(N->getLine()), Type(N->getRawType()),
560  IsLocalToUnit(N->isLocalToUnit()), IsDefinition(N->isDefinition()),
561  ScopeLine(N->getScopeLine()), ContainingType(N->getRawContainingType()),
562  Virtuality(N->getVirtuality()), VirtualIndex(N->getVirtualIndex()),
563  Flags(N->getFlags()), IsOptimized(N->isOptimized()),
564  Function(N->getRawFunction()),
565  TemplateParams(N->getRawTemplateParams()),
566  Declaration(N->getRawDeclaration()), Variables(N->getRawVariables()) {}
567 
568  bool isKeyOf(const DISubprogram *RHS) const {
569  return Scope == RHS->getRawScope() && Name == RHS->getName() &&
570  LinkageName == RHS->getLinkageName() && File == RHS->getRawFile() &&
571  Line == RHS->getLine() && Type == RHS->getRawType() &&
572  IsLocalToUnit == RHS->isLocalToUnit() &&
573  IsDefinition == RHS->isDefinition() &&
574  ScopeLine == RHS->getScopeLine() &&
575  ContainingType == RHS->getRawContainingType() &&
576  Virtuality == RHS->getVirtuality() &&
577  VirtualIndex == RHS->getVirtualIndex() && Flags == RHS->getFlags() &&
578  IsOptimized == RHS->isOptimized() &&
579  Function == RHS->getRawFunction() &&
580  TemplateParams == RHS->getRawTemplateParams() &&
581  Declaration == RHS->getRawDeclaration() &&
582  Variables == RHS->getRawVariables();
583  }
584  unsigned getHashValue() const {
585  return hash_combine(Scope, Name, LinkageName, File, Line, Type,
586  IsLocalToUnit, IsDefinition, ScopeLine, ContainingType,
587  Virtuality, VirtualIndex, Flags, IsOptimized, Function,
588  TemplateParams, Declaration, Variables);
589  }
590 };
591 
592 template <> struct MDNodeKeyImpl<DILexicalBlock> {
595  unsigned Line;
596  unsigned Column;
597 
598  MDNodeKeyImpl(Metadata *Scope, Metadata *File, unsigned Line, unsigned Column)
599  : Scope(Scope), File(File), Line(Line), Column(Column) {}
601  : Scope(N->getRawScope()), File(N->getRawFile()), Line(N->getLine()),
602  Column(N->getColumn()) {}
603 
604  bool isKeyOf(const DILexicalBlock *RHS) const {
605  return Scope == RHS->getRawScope() && File == RHS->getRawFile() &&
606  Line == RHS->getLine() && Column == RHS->getColumn();
607  }
608  unsigned getHashValue() const {
609  return hash_combine(Scope, File, Line, Column);
610  }
611 };
612 
613 template <> struct MDNodeKeyImpl<DILexicalBlockFile> {
616  unsigned Discriminator;
617 
618  MDNodeKeyImpl(Metadata *Scope, Metadata *File, unsigned Discriminator)
619  : Scope(Scope), File(File), Discriminator(Discriminator) {}
621  : Scope(N->getRawScope()), File(N->getRawFile()),
622  Discriminator(N->getDiscriminator()) {}
623 
624  bool isKeyOf(const DILexicalBlockFile *RHS) const {
625  return Scope == RHS->getRawScope() && File == RHS->getRawFile() &&
626  Discriminator == RHS->getDiscriminator();
627  }
628  unsigned getHashValue() const {
629  return hash_combine(Scope, File, Discriminator);
630  }
631 };
632 
633 template <> struct MDNodeKeyImpl<DINamespace> {
637  unsigned Line;
638 
639  MDNodeKeyImpl(Metadata *Scope, Metadata *File, StringRef Name, unsigned Line)
640  : Scope(Scope), File(File), Name(Name), Line(Line) {}
642  : Scope(N->getRawScope()), File(N->getRawFile()), Name(N->getName()),
643  Line(N->getLine()) {}
644 
645  bool isKeyOf(const DINamespace *RHS) const {
646  return Scope == RHS->getRawScope() && File == RHS->getRawFile() &&
647  Name == RHS->getName() && Line == RHS->getLine();
648  }
649  unsigned getHashValue() const {
650  return hash_combine(Scope, File, Name, Line);
651  }
652 };
653 
654 template <> struct MDNodeKeyImpl<DIModule> {
661  StringRef ConfigurationMacros,
662  StringRef IncludePath,
663  StringRef ISysRoot)
664  : Scope(Scope), Name(Name), ConfigurationMacros(ConfigurationMacros),
665  IncludePath(IncludePath), ISysRoot(ISysRoot) {}
667  : Scope(N->getRawScope()), Name(N->getName()),
668  ConfigurationMacros(N->getConfigurationMacros()),
669  IncludePath(N->getIncludePath()), ISysRoot(N->getISysRoot()) {}
670 
671  bool isKeyOf(const DIModule *RHS) const {
672  return Scope == RHS->getRawScope() && Name == RHS->getName() &&
673  ConfigurationMacros == RHS->getConfigurationMacros() &&
674  IncludePath == RHS->getIncludePath() &&
675  ISysRoot == RHS->getISysRoot();
676  }
677  unsigned getHashValue() const {
678  return hash_combine(Scope, Name,
679  ConfigurationMacros, IncludePath, ISysRoot);
680  }
681 };
682 
686 
687  MDNodeKeyImpl(StringRef Name, Metadata *Type) : Name(Name), Type(Type) {}
689  : Name(N->getName()), Type(N->getRawType()) {}
690 
691  bool isKeyOf(const DITemplateTypeParameter *RHS) const {
692  return Name == RHS->getName() && Type == RHS->getRawType();
693  }
694  unsigned getHashValue() const { return hash_combine(Name, Type); }
695 };
696 
698  unsigned Tag;
702 
704  : Tag(Tag), Name(Name), Type(Type), Value(Value) {}
706  : Tag(N->getTag()), Name(N->getName()), Type(N->getRawType()),
707  Value(N->getValue()) {}
708 
709  bool isKeyOf(const DITemplateValueParameter *RHS) const {
710  return Tag == RHS->getTag() && Name == RHS->getName() &&
711  Type == RHS->getRawType() && Value == RHS->getValue();
712  }
713  unsigned getHashValue() const { return hash_combine(Tag, Name, Type, Value); }
714 };
715 
716 template <> struct MDNodeKeyImpl<DIGlobalVariable> {
721  unsigned Line;
727 
729  Metadata *File, unsigned Line, Metadata *Type,
730  bool IsLocalToUnit, bool IsDefinition, Metadata *Variable,
731  Metadata *StaticDataMemberDeclaration)
732  : Scope(Scope), Name(Name), LinkageName(LinkageName), File(File),
733  Line(Line), Type(Type), IsLocalToUnit(IsLocalToUnit),
734  IsDefinition(IsDefinition), Variable(Variable),
735  StaticDataMemberDeclaration(StaticDataMemberDeclaration) {}
737  : Scope(N->getRawScope()), Name(N->getName()),
738  LinkageName(N->getLinkageName()), File(N->getRawFile()),
739  Line(N->getLine()), Type(N->getRawType()),
740  IsLocalToUnit(N->isLocalToUnit()), IsDefinition(N->isDefinition()),
741  Variable(N->getRawVariable()),
742  StaticDataMemberDeclaration(N->getRawStaticDataMemberDeclaration()) {}
743 
744  bool isKeyOf(const DIGlobalVariable *RHS) const {
745  return Scope == RHS->getRawScope() && Name == RHS->getName() &&
746  LinkageName == RHS->getLinkageName() && File == RHS->getRawFile() &&
747  Line == RHS->getLine() && Type == RHS->getRawType() &&
748  IsLocalToUnit == RHS->isLocalToUnit() &&
749  IsDefinition == RHS->isDefinition() &&
750  Variable == RHS->getRawVariable() &&
751  StaticDataMemberDeclaration ==
753  }
754  unsigned getHashValue() const {
755  return hash_combine(Scope, Name, LinkageName, File, Line, Type,
756  IsLocalToUnit, IsDefinition, Variable,
757  StaticDataMemberDeclaration);
758  }
759 };
760 
761 template <> struct MDNodeKeyImpl<DILocalVariable> {
762  unsigned Tag;
766  unsigned Line;
768  unsigned Arg;
769  unsigned Flags;
770 
772  unsigned Line, Metadata *Type, unsigned Arg, unsigned Flags)
773  : Tag(Tag), Scope(Scope), Name(Name), File(File), Line(Line), Type(Type),
774  Arg(Arg), Flags(Flags) {}
776  : Tag(N->getTag()), Scope(N->getRawScope()), Name(N->getName()),
777  File(N->getRawFile()), Line(N->getLine()), Type(N->getRawType()),
778  Arg(N->getArg()), Flags(N->getFlags()) {}
779 
780  bool isKeyOf(const DILocalVariable *RHS) const {
781  return Tag == RHS->getTag() && Scope == RHS->getRawScope() &&
782  Name == RHS->getName() && File == RHS->getRawFile() &&
783  Line == RHS->getLine() && Type == RHS->getRawType() &&
784  Arg == RHS->getArg() && Flags == RHS->getFlags();
785  }
786  unsigned getHashValue() const {
787  return hash_combine(Tag, Scope, Name, File, Line, Type, Arg, Flags);
788  }
789 };
790 
791 template <> struct MDNodeKeyImpl<DIExpression> {
793 
794  MDNodeKeyImpl(ArrayRef<uint64_t> Elements) : Elements(Elements) {}
795  MDNodeKeyImpl(const DIExpression *N) : Elements(N->getElements()) {}
796 
797  bool isKeyOf(const DIExpression *RHS) const {
798  return Elements == RHS->getElements();
799  }
800  unsigned getHashValue() const {
801  return hash_combine_range(Elements.begin(), Elements.end());
802  }
803 };
804 
805 template <> struct MDNodeKeyImpl<DIObjCProperty> {
808  unsigned Line;
811  unsigned Attributes;
813 
815  StringRef GetterName, StringRef SetterName, unsigned Attributes,
816  Metadata *Type)
817  : Name(Name), File(File), Line(Line), GetterName(GetterName),
818  SetterName(SetterName), Attributes(Attributes), Type(Type) {}
820  : Name(N->getName()), File(N->getRawFile()), Line(N->getLine()),
821  GetterName(N->getGetterName()), SetterName(N->getSetterName()),
822  Attributes(N->getAttributes()), Type(N->getRawType()) {}
823 
824  bool isKeyOf(const DIObjCProperty *RHS) const {
825  return Name == RHS->getName() && File == RHS->getRawFile() &&
826  Line == RHS->getLine() && GetterName == RHS->getGetterName() &&
827  SetterName == RHS->getSetterName() &&
828  Attributes == RHS->getAttributes() && Type == RHS->getRawType();
829  }
830  unsigned getHashValue() const {
831  return hash_combine(Name, File, Line, GetterName, SetterName, Attributes,
832  Type);
833  }
834 };
835 
836 template <> struct MDNodeKeyImpl<DIImportedEntity> {
837  unsigned Tag;
840  unsigned Line;
842 
843  MDNodeKeyImpl(unsigned Tag, Metadata *Scope, Metadata *Entity, unsigned Line,
844  StringRef Name)
845  : Tag(Tag), Scope(Scope), Entity(Entity), Line(Line), Name(Name) {}
847  : Tag(N->getTag()), Scope(N->getRawScope()), Entity(N->getRawEntity()),
848  Line(N->getLine()), Name(N->getName()) {}
849 
850  bool isKeyOf(const DIImportedEntity *RHS) const {
851  return Tag == RHS->getTag() && Scope == RHS->getRawScope() &&
852  Entity == RHS->getRawEntity() && Line == RHS->getLine() &&
853  Name == RHS->getName();
854  }
855  unsigned getHashValue() const {
856  return hash_combine(Tag, Scope, Entity, Line, Name);
857  }
858 };
859 
860 /// \brief DenseMapInfo for MDNode subclasses.
861 template <class NodeTy> struct MDNodeInfo {
863  static inline NodeTy *getEmptyKey() {
865  }
866  static inline NodeTy *getTombstoneKey() {
868  }
869  static unsigned getHashValue(const KeyTy &Key) { return Key.getHashValue(); }
870  static unsigned getHashValue(const NodeTy *N) {
871  return KeyTy(N).getHashValue();
872  }
873  static bool isEqual(const KeyTy &LHS, const NodeTy *RHS) {
874  if (RHS == getEmptyKey() || RHS == getTombstoneKey())
875  return false;
876  return LHS.isKeyOf(RHS);
877  }
878  static bool isEqual(const NodeTy *LHS, const NodeTy *RHS) {
879  return LHS == RHS;
880  }
881 };
882 
883 #define HANDLE_MDNODE_LEAF(CLASS) typedef MDNodeInfo<CLASS> CLASS##Info;
884 #include "llvm/IR/Metadata.def"
885 
886 /// \brief Map-like storage for metadata attachments.
889 
890 public:
891  bool empty() const { return Attachments.empty(); }
892  size_t size() const { return Attachments.size(); }
893 
894  /// \brief Get a particular attachment (if any).
895  MDNode *lookup(unsigned ID) const;
896 
897  /// \brief Set an attachment to a particular node.
898  ///
899  /// Set the \c ID attachment to \c MD, replacing the current attachment at \c
900  /// ID (if anyway).
901  void set(unsigned ID, MDNode &MD);
902 
903  /// \brief Remove an attachment.
904  ///
905  /// Remove the attachment at \c ID, if any.
906  void erase(unsigned ID);
907 
908  /// \brief Copy out all the attachments.
909  ///
910  /// Copies all the current attachments into \c Result, sorting by attachment
911  /// ID. This function does \em not clear \c Result.
912  void getAll(SmallVectorImpl<std::pair<unsigned, MDNode *>> &Result) const;
913 
914  /// \brief Erase matching attachments.
915  ///
916  /// Erases all attachments matching the \c shouldRemove predicate.
917  template <class PredTy> void remove_if(PredTy shouldRemove) {
918  Attachments.erase(
919  std::remove_if(Attachments.begin(), Attachments.end(), shouldRemove),
920  Attachments.end());
921  }
922 };
923 
925 public:
926  /// OwnedModules - The set of modules instantiated in this context, and which
927  /// will be automatically deleted if this context is deleted.
929 
932 
936 
939 
942 
945 
949 
953 
955 
956 #define HANDLE_MDNODE_LEAF(CLASS) DenseSet<CLASS *, CLASS##Info> CLASS##s;
957 #include "llvm/IR/Metadata.def"
958 
959  // MDNodes may be uniqued or not uniqued. When they're not uniqued, they
960  // aren't in the MDNodeSet, but they're still shared between objects, so no
961  // one object can destroy them. This set allows us to at least destroy them
962  // on Context destruction.
964 
966 
969 
972 
975 
977 
979 
981 
985 
987 
990 
991  // Basic type instances.
995 
996 
997  /// TypeAllocator - All dynamically allocated types are allocated from this.
998  /// They live forever until the context is torn down.
1000 
1002 
1009 
1012  DenseMap<Type*, PointerType*> PointerTypes; // Pointers in AddrSpace = 0
1014 
1015 
1016  /// ValueHandles - This map keeps track of all of the value handles that are
1017  /// watching a Value*. The Value::HasValueHandle bit is used to know
1018  /// whether or not a value has an entry in this map.
1021 
1022  /// CustomMDKindNames - Map to hold the metadata string to ID mapping.
1024 
1025  /// Collection of per-instruction metadata used in this context.
1027 
1028  /// Collection of per-function metadata used in this context.
1030 
1031  /// DiscriminatorTable - This table maps file:line locations to an
1032  /// integer representing the next DWARF path discriminator to assign to
1033  /// instructions in different blocks at the same location.
1035 
1036  /// \brief Mapping from a function to its prefix data, which is stored as the
1037  /// operand of an unparented ReturnInst so that the prefix data has a Use.
1040 
1041  /// \brief Mapping from a function to its prologue data, which is stored as
1042  /// the operand of an unparented ReturnInst so that the prologue data has a
1043  /// Use.
1046 
1047  int getOrAddScopeRecordIdxEntry(MDNode *N, int ExistingIdx);
1048  int getOrAddScopeInlinedAtIdxEntry(MDNode *Scope, MDNode *IA,int ExistingIdx);
1049 
1051  ~LLVMContextImpl();
1052 
1053  /// Destroy the ConstantArrays if they are not used.
1055 };
1056 
1057 }
1058 
1059 #endif
static unsigned calculateHash(MDNode *N, unsigned Offset=0)
Metadata * getRawScope() const
bool operator!=(const KeyTy &that) const
StringRef getName() const
static APInt getTombstoneKey()
MDNodeKeyImpl(StringRef Name, Metadata *Type)
static bool isEqual(const KeyTy &LHS, const FunctionType *RHS)
static APFloat getTombstoneKey()
bool isKeyOf(const GenericDINode *RHS) const
DenseMap< unsigned, IntegerType * > IntegerTypes
DenseMap< const Function *, MDAttachmentMap > FunctionMetadata
Collection of per-function metadata used in this context.
static bool isEqual(const NodeTy *LHS, const NodeTy *RHS)
bool isKeyOf(const DILexicalBlock *RHS) const
StringRef getIdentifier() const
static unsigned getHashValue(const KeyTy &Key)
FoldingSet< AttributeImpl > AttrsSet
KeyTy(const Type *R, const ArrayRef< Type * > &P, bool V)
StringRef getName() const
StringRef getDirectory() const
static unsigned getHashValue(const KeyTy &Key)
bool isKeyOf(const MDTuple *RHS) const
Metadata * getRawBaseType() const
Structure for hashing arbitrary MDNode operands.
MDNodeOpsKey(ArrayRef< Metadata * > Ops)
MDNodeKeyImpl(unsigned Tag, StringRef Name, uint64_t SizeInBits, uint64_t AlignInBits, unsigned Encoding)
DenseMap< std::pair< const Function *, const BasicBlock * >, BlockAddress * > BlockAddresses
KeyTy(const ArrayRef< Type * > &E, bool P)
StringRef getFlags() const
PrefixDataMapTy PrefixDataMap
bool compareOps(const NodeTy *RHS, unsigned Offset=0) const
Metadata * getRawSubprograms() const
void(* DiagnosticHandlerTy)(const DiagnosticInfo &DI, void *Context)
Defines the type of a diagnostic handler.
Definition: LLVMContext.h:81
static StructType * getTombstoneKey()
unsigned getNumOperands() const
Return number of MDNode operands.
Definition: Metadata.h:942
DenseMap< Value *, ValueAsMetadata * > ValuesAsMetadata
uint64_t getAlignInBits() const
iterator end() const
Definition: ArrayRef.h:123
int64_t getCount() const
MDNodeKeyImpl(const GenericDINode *N)
Metadata * getRawFile() const
Return the raw underlying file.
bool operator==(const KeyTy &that) const
static bool isEqual(const KeyTy &LHS, const StructType *RHS)
Metadata * getRawType() const
This file contains the declarations for metadata subclasses.
static unsigned getHashValue(const StructType *ST)
MDNodeKeyImpl(unsigned Tag, Metadata *Scope, StringRef Name, Metadata *File, unsigned Line, Metadata *Type, unsigned Arg, unsigned Flags)
ConstantInt * TheFalseVal
unsigned getEmissionKind() const
op_iterator op_begin() const
Definition: Metadata.h:928
MDNodeKeyImpl(const DICompileUnit *N)
StringRef getName() const
Metadata node.
Definition: Metadata.h:740
MDNodeOpsKey(const NodeTy *N, unsigned Offset=0)
bool isKeyOf(const DINamespace *RHS) const
MDNodeKeyImpl(unsigned Tag, StringRef Name, Metadata *File, unsigned Line, Metadata *Scope, Metadata *BaseType, uint64_t SizeInBits, uint64_t AlignInBits, uint64_t OffsetInBits, unsigned Flags, Metadata *ExtraData)
DenseMap< std::pair< Type *, unsigned >, PointerType * > ASPointerTypes
MDNodeKeyImpl(const DISubrange *N)
LLVMContext::InlineAsmDiagHandlerTy InlineAsmDiagHandler
MDNodeKeyImpl(const DITemplateTypeParameter *N)
unsigned getVirtuality(StringRef VirtualityString)
Definition: Dwarf.cpp:333
Metadata * getRawScope() const
static const fltSemantics Bogus
A Pseudo fltsemantic used to construct APFloats that cannot conflict with anything real...
Definition: APFloat.h:140
void dropTriviallyDeadConstantArrays()
Destroy the ConstantArrays if they are not used.
MDNodeKeyImpl(ArrayRef< uint64_t > Elements)
MDNodeKeyImpl(Metadata *Scope, Metadata *File, unsigned Line, unsigned Column)
static unsigned calculateHash(GenericDINode *N)
bool bitwiseIsEqual(const APFloat &) const
Bitwise comparison for equality (QNaNs compare equal, 0!=-0).
Definition: APFloat.cpp:771
Tuple of metadata.
Definition: Metadata.h:972
unsigned getColumn() const
MDNodeKeyImpl(const DIEnumerator *N)
bool isKeyOf(const DIBasicType *RHS) const
Metadata * getRawType() const
MDNodeKeyImpl(int64_t Flags, Metadata *TypeArray)
ConstantInt * TheTrueVal
ConstantUniqueMap< ConstantVector > VectorConstantsTy
static NodeTy * getEmptyKey()
void set(unsigned ID, MDNode &MD)
Set an attachment to a particular node.
Definition: Metadata.cpp:993
BlockAddress - The address of a basic block.
Definition: Constants.h:802
DenseMap< APInt, ConstantInt *, DenseMapAPIntKeyInfo > IntMapTy
DenseMap< const Instruction *, MDAttachmentMap > InstructionMetadata
Collection of per-instruction metadata used in this context.
MDNodeKeyImpl(const DIGlobalVariable *N)
StringRef getName() const
static unsigned getHashValue(const APFloat &Key)
static bool isEqual(const APInt &LHS, const APInt &RHS)
unsigned getTag() const
StructType - Class to represent struct types.
Definition: DerivedTypes.h:191
Array subrange.
KeyTy(const FunctionType *FT)
FoldingSet< AttributeSetImpl > AttrsLists
uint64_t VAL
Used to store the <= 64 bits integer value.
Definition: APInt.h:79
MDNodeKeyImpl(int64_t Value, StringRef Name)
MDNodeKeyImpl(const DIBasicType *N)
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APInt.h:33
Metadata * getRawRetainedTypes() const
StringRef getName() const
unsigned getLine() const
MDNodeKeyImpl(Metadata *Scope, StringRef Name, StringRef ConfigurationMacros, StringRef IncludePath, StringRef ISysRoot)
ConstantUniqueMap< ConstantArray > ArrayConstantsTy
DenseMap< std::pair< Type *, uint64_t >, ArrayType * > ArrayTypes
static StringRef getName(Value *V)
DenseMap< const Value *, ValueName * > ValueNames
StringRef getName() const
BumpPtrAllocator TypeAllocator
TypeAllocator - All dynamically allocated types are allocated from this.
This file implements a class to represent arbitrary precision integral constant values and operations...
static unsigned getHashValue(const FunctionType *FT)
static StructType * getEmptyKey()
ConstantUniqueMap< InlineAsm > InlineAsms
Metadata * getRawFile() const
MDNodeKeyImpl(const DISubprogram *N)
Metadata * getRawStaticDataMemberDeclaration() const
Subprogram description.
PrologueDataMapTy PrologueDataMap
FunctionType - Class to represent function types.
Definition: DerivedTypes.h:96
int getOrAddScopeInlinedAtIdxEntry(MDNode *Scope, MDNode *IA, int ExistingIdx)
MDNodeKeyImpl(unsigned Tag, Metadata *Scope, Metadata *Entity, unsigned Line, StringRef Name)
bool isKeyOf(const DIObjCProperty *RHS) const
LLVMContextImpl(LLVMContext &C)
ArrayType - Class to represent array types.
Definition: DerivedTypes.h:336
Enumeration value.
MDNodeKeyImpl(StringRef Filename, StringRef Directory)
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: ArrayRef.h:31
hash_code hash_value(const APFloat &Arg)
See friend declarations above.
Definition: APFloat.cpp:2848
ArrayConstantsTy ArrayConstants
DenseMap< PointerType *, ConstantPointerNull * > CPNConstants
Metadata * getRawVTableHolder() const
StringRef getConfigurationMacros() const
Metadata * getRawEnumTypes() const
MDNodeKeyImpl(Metadata *Scope, StringRef Name, StringRef LinkageName, Metadata *File, unsigned Line, Metadata *Type, bool IsLocalToUnit, bool IsDefinition, unsigned ScopeLine, Metadata *ContainingType, unsigned Virtuality, unsigned VirtualIndex, unsigned Flags, bool IsOptimized, Metadata *Function, Metadata *TemplateParams, Metadata *Declaration, Metadata *Variables)
Debug location.
DenseMap< std::pair< Type *, unsigned >, VectorType * > VectorTypes
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:134
unsigned getLine() const
DenseSet< FunctionType *, FunctionTypeKeyInfo > FunctionTypeSet
PointerType - Class to represent pointers.
Definition: DerivedTypes.h:449
size_t size() const
MDNodeKeyImpl(ArrayRef< Metadata * > Ops)
void getAll(SmallVectorImpl< std::pair< unsigned, MDNode * >> &Result) const
Copy out all the attachments.
Definition: Metadata.cpp:1029
LLVMContext::YieldCallbackTy YieldCallback
Metadata * getRawScope() const
unsigned getRuntimeVersion() const
unsigned getLine() const
DenseMap< Type *, ConstantAggregateZero * > CAZConstants
A self-contained host- and target-independent arbitrary-precision floating-point software implementat...
Definition: APFloat.h:122
StringRef getIncludePath() const
#define P(N)
Metadata * getRawElements() const
StringMap< unsigned > CustomMDKindNames
CustomMDKindNames - Map to hold the metadata string to ID mapping.
Metadata * getRawFile() const
MDNodeKeyImpl< NodeTy > KeyTy
StringRef getName() const
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:41
Allocate memory in an ever growing pool, as if by bump-pointer.
Definition: Allocator.h:135
ConstantUniqueMap< ConstantStruct > StructConstantsTy
bool isKeyOf(const DIExpression *RHS) const
Metadata * getRawType() const
This file contains the declarations for the subclasses of Constant, which represent the different fla...
unsigned getHash() const
SourceLanguage
Definition: Dwarf.h:352
bool isKeyOf(const DILocalVariable *RHS) const
MDNodeKeyImpl(const DIExpression *N)
static unsigned calculateHash(MDTuple *N)
unsigned getLine() const
static bool isEqual(const FunctionType *LHS, const FunctionType *RHS)
unsigned getSourceLanguage() const
MDNodeKeyImpl(const DIObjCProperty *N)
StringRef getFilename() const
Metadata * getRawTemplateParams() const
MDNodeKeyImpl(const DISubroutineType *N)
This file declares a class to represent arbitrary precision floating point values and provide a varie...
MDNodeKeyImpl(unsigned Tag, StringRef Header, ArrayRef< Metadata * > DwarfOps)
MDNodeKeyImpl(Metadata *Scope, Metadata *File, StringRef Name, unsigned Line)
bool operator!=(const KeyTy &that) const
unsigned getBitWidth() const
Return the number of bits in the APInt.
Definition: APInt.h:1273
This file defines various helper methods and classes used by LLVMContextImpl for creating and managin...
ValueHandlesTy ValueHandles
iterator begin() const
Definition: ArrayRef.h:122
MDNodeKeyImpl(const DILexicalBlockFile *N)
MDNodeKeyImpl(const DICompositeType *N)
unsigned getDWOId() const
unsigned getEncoding() const
unsigned getArg() const
Class to represent integer types.
Definition: DerivedTypes.h:37
uint64_t getOffsetInBits() const
static FunctionType * getEmptyKey()
MDNodeKeyImpl(const DIDerivedType *N)
unsigned getAttributes() const
StringRef getGetterName() const
bool isKeyOf(const DICompileUnit *RHS) const
static unsigned getHashValue(const NodeTy *N)
bool isKeyOf(const DIImportedEntity *RHS) const
DenseSet< StructType *, AnonStructTypeKeyInfo > StructTypeSet
static bool isEqual(const APFloat &LHS, const APFloat &RHS)
SmallPtrSet< MDNode *, 1 > DistinctMDNodes
DenseMap< const Function *, ReturnInst * > PrefixDataMapTy
Mapping from a function to its prefix data, which is stored as the operand of an unparented ReturnIns...
FoldingSet - This template class is used to instantiate a specialized implementation of the folding s...
Definition: FoldingSet.h:396
VectorConstantsTy VectorConstants
bool isKeyOf(const DIModule *RHS) const
An imported module (C++ using directive or similar).
unsigned getTag(StringRef TagString)
Definition: Dwarf.cpp:31
static bool isEqual(const KeyTy &LHS, const NodeTy *RHS)
bool isKeyOf(const DISubprogram *RHS) const
Metadata * getRawScope() const
DenseMap< Metadata *, MetadataAsValue * > MetadataAsValues
ArrayRef< uint64_t > getElements() const
StringRef getISysRoot() const
unsigned getTag() const
This is the shared class of boolean and integer constants.
Definition: Constants.h:47
static NodeTy * getTombstoneKey()
Metadata * getRawInlinedAt() const
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:861
MDNode * lookup(unsigned ID) const
Get a particular attachment (if any).
Definition: Metadata.cpp:1022
FunctionTypeSet FunctionTypes
int getOrAddScopeRecordIdxEntry(MDNode *N, int ExistingIdx)
int64_t getValue() const
bool isKeyOf(const DILocation *RHS) const
Metadata * getRawEntity() const
DWARF expression.
SmallPtrSet< Module *, 4 > OwnedModules
OwnedModules - The set of modules instantiated in this context, and which will be automatically delet...
MDNodeKeyImpl(const DITemplateValueParameter *N)
void(* InlineAsmDiagHandlerTy)(const SMDiagnostic &, void *Context, unsigned LocCookie)
Definition: LLVMContext.h:75
bool isKeyOf(const DITemplateTypeParameter *RHS) const
StringMap - This is an unconventional map that is specialized for handling keys that are "strings"...
Definition: StringMap.h:214
MDNodeKeyImpl(const DINamespace *N)
VectorType - Class to represent vector types.
Definition: DerivedTypes.h:362
static bool isEqual(const StructType *LHS, const StructType *RHS)
Class for arbitrary precision integers.
Definition: APInt.h:73
unsigned getDiscriminator() const
void erase(unsigned ID)
Remove an attachment.
Definition: Metadata.cpp:1003
hash_code hash_combine(const Ts &...args)
Combine values into a single hash_code.
Definition: Hashing.h:603
A (clang) module that has been imported by the compile unit.
StringRef getHeader() const
MDNodeKeyImpl(int64_t Count, int64_t LowerBound)
DenseMapInfo for MDNode subclasses.
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last)
Compute a hash_code for a sequence of values.
Definition: Hashing.h:481
Generic tagged DWARF-like metadata node.
MDNodeKeyImpl(const DILocalVariable *N)
bool isKeyOf(const DIDerivedType *RHS) const
DenseMap< Type *, UndefValue * > UVConstants
bool isKeyOf(const DIEnumerator *RHS) const
MDNodeKeyImpl(const DIImportedEntity *N)
Metadata * getRawVariable() const
static FunctionType * getTombstoneKey()
MDNodeKeyImpl(const DILocation *L)
Type array for a subprogram.
Metadata * getRawImportedEntities() const
StructTypeSet AnonStructTypes
DenseMap< APFloat, ConstantFP *, DenseMapAPFloatKeyInfo > FPMapTy
Metadata * getRawScope() const
unsigned getRuntimeLang() const
DenseMap< Value *, ValueHandleBase * > ValueHandlesTy
ValueHandles - This map keeps track of all of the value handles that are watching a Value*...
Metadata * getRawScope() const
StringMap< MDString > MDStringCache
MDNodeKeyImpl(Metadata *Scope, StringRef Name, StringRef LinkageName, Metadata *File, unsigned Line, Metadata *Type, bool IsLocalToUnit, bool IsDefinition, Metadata *Variable, Metadata *StaticDataMemberDeclaration)
static unsigned getHashValue(const APInt &Key)
DenseMap< std::pair< const char *, unsigned >, unsigned > DiscriminatorTable
DiscriminatorTable - This table maps file:line locations to an integer representing the next DWARF pa...
StringMap< StructType * > NamedStructTypes
MDNodeKeyImpl(StringRef Name, Metadata *File, unsigned Line, StringRef GetterName, StringRef SetterName, unsigned Attributes, Metadata *Type)
#define N
bool isKeyOf(const DICompositeType *RHS) const
bool isKeyOf(const DIGlobalVariable *RHS) const
uint64_t getSizeInBits() const
bool operator==(const KeyTy &that) const
bool isKeyOf(const DITemplateValueParameter *RHS) const
MDNodeKeyImpl(unsigned Line, unsigned Column, Metadata *Scope, Metadata *InlinedAt)
ConstantUniqueMap< ConstantExpr > ExprConstants
AttributeSet getAttributes(LLVMContext &C, ID id)
Return the attributes for an intrinsic.
StringRef getSetterName() const
Metadata * getRawScope() const
bool isKeyOf(const DIFile *RHS) const
unsigned getFlags() const
StructConstantsTy StructConstants
StringRef getName() const
LLVM Value Representation.
Definition: Value.h:69
DenseMap< const Function *, ReturnInst * > PrologueDataMapTy
Mapping from a function to its prologue data, which is stored as the operand of an unparented ReturnI...
void remove_if(PredTy shouldRemove)
Erase matching attachments.
unsigned getLine() const
MDNodeKeyImpl(const DILexicalBlock *N)
MDNodeKeyImpl(unsigned Tag, StringRef Name, Metadata *File, unsigned Line, Metadata *Scope, Metadata *BaseType, uint64_t SizeInBits, uint64_t AlignInBits, uint64_t OffsetInBits, unsigned Flags, Metadata *Elements, unsigned RuntimeLang, Metadata *VTableHolder, Metadata *TemplateParams, StringRef Identifier)
unsigned getLine() const
bool isKeyOf(const DILexicalBlockFile *RHS) const
FoldingSet< AttributeSetNode > AttrsSetNodes
LLVMContext::DiagnosticHandlerTy DiagnosticHandler
void(* YieldCallbackTy)(LLVMContext *Context, void *OpaqueHandle)
Defines the type of a yield callback.
Definition: LLVMContext.h:85
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:40
int64_t getLowerBound() const
DenseMap< Type *, PointerType * > PointerTypes
unsigned getFlags() const
bool isKeyOf(const DISubrange *RHS) const
Map-like storage for metadata attachments.
StringMap< ConstantDataSequential * > CDSConstants
StringRef getProducer() const
MDNodeKeyImpl(unsigned Tag, StringRef Name, Metadata *Type, Metadata *Value)
Root of the metadata hierarchy.
Definition: Metadata.h:45
MDNodeKeyImpl(Metadata *Scope, Metadata *File, unsigned Discriminator)
bool isKeyOf(const DISubroutineType *RHS) const
StringRef getLinkageName() const
static unsigned getHashValue(const KeyTy &Key)
MDNodeKeyImpl(unsigned SourceLanguage, Metadata *File, StringRef Producer, bool IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef SplitDebugFilename, unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes, Metadata *Subprograms, Metadata *GlobalVariables, Metadata *ImportedEntities, uint64_t DWOId)
Metadata * getRawGlobalVariables() const
Basic type, like 'int' or 'float'.
Metadata * getRawTypeArray() const
StringRef getSplitDebugFilename() const