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