contrib/llvm/lib/IR/LLVMContextImpl.h

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