LCOV - code coverage report
Current view: top level - lib/IR - LLVMContextImpl.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 350 353 99.2 %
Date: 2018-06-17 00:07:59 Functions: 73 74 98.6 %
Legend: Lines: hit not hit

          Line data    Source code
       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/DenseMapInfo.h"
      25             : #include "llvm/ADT/DenseSet.h"
      26             : #include "llvm/ADT/FoldingSet.h"
      27             : #include "llvm/ADT/Hashing.h"
      28             : #include "llvm/ADT/Optional.h"
      29             : #include "llvm/ADT/STLExtras.h"
      30             : #include "llvm/ADT/SmallPtrSet.h"
      31             : #include "llvm/ADT/SmallVector.h"
      32             : #include "llvm/ADT/StringMap.h"
      33             : #include "llvm/ADT/StringRef.h"
      34             : #include "llvm/ADT/StringSet.h"
      35             : #include "llvm/BinaryFormat/Dwarf.h"
      36             : #include "llvm/IR/Constants.h"
      37             : #include "llvm/IR/DebugInfoMetadata.h"
      38             : #include "llvm/IR/DerivedTypes.h"
      39             : #include "llvm/IR/LLVMContext.h"
      40             : #include "llvm/IR/Metadata.h"
      41             : #include "llvm/IR/TrackingMDRef.h"
      42             : #include "llvm/Support/Allocator.h"
      43             : #include "llvm/Support/Casting.h"
      44             : #include "llvm/Support/YAMLTraits.h"
      45             : #include <algorithm>
      46             : #include <cassert>
      47             : #include <cstddef>
      48             : #include <cstdint>
      49             : #include <memory>
      50             : #include <string>
      51             : #include <utility>
      52             : #include <vector>
      53             : 
      54             : namespace llvm {
      55             : 
      56             : class ConstantFP;
      57             : class ConstantInt;
      58             : class Type;
      59             : class Value;
      60             : class ValueHandleBase;
      61             : 
      62             : struct DenseMapAPIntKeyInfo {
      63             :   static inline APInt getEmptyKey() {
      64             :     APInt V(nullptr, 0);
      65             :     V.U.VAL = 0;
      66             :     return V;
      67             :   }
      68             : 
      69             :   static inline APInt getTombstoneKey() {
      70             :     APInt V(nullptr, 0);
      71    47922460 :     V.U.VAL = 1;
      72             :     return V;
      73             :   }
      74             : 
      75             :   static unsigned getHashValue(const APInt &Key) {
      76    95677254 :     return static_cast<unsigned>(hash_value(Key));
      77             :   }
      78             : 
      79   232830029 :   static bool isEqual(const APInt &LHS, const APInt &RHS) {
      80   291028456 :     return LHS.getBitWidth() == RHS.getBitWidth() && LHS == RHS;
      81             :   }
      82             : };
      83             : 
      84             : struct DenseMapAPFloatKeyInfo {
      85      167646 :   static inline APFloat getEmptyKey() { return APFloat(APFloat::Bogus(), 1); }
      86             :   static inline APFloat getTombstoneKey() { return APFloat(APFloat::Bogus(), 2); }
      87             : 
      88             :   static unsigned getHashValue(const APFloat &Key) {
      89      247324 :     return static_cast<unsigned>(hash_value(Key));
      90             :   }
      91             : 
      92             :   static bool isEqual(const APFloat &LHS, const APFloat &RHS) {
      93     1071965 :     return LHS.bitwiseIsEqual(RHS);
      94             :   }
      95             : };
      96             : 
      97             : struct AnonStructTypeKeyInfo {
      98             :   struct KeyTy {
      99             :     ArrayRef<Type*> ETypes;
     100             :     bool isPacked;
     101             : 
     102       95280 :     KeyTy(const ArrayRef<Type*>& E, bool P) :
     103       95280 :       ETypes(E), isPacked(P) {}
     104             : 
     105             :     KeyTy(const StructType *ST)
     106      305028 :         : ETypes(ST->elements()), isPacked(ST->isPacked()) {}
     107             : 
     108       82022 :     bool operator==(const KeyTy& that) const {
     109       82022 :       if (isPacked != that.isPacked)
     110             :         return false;
     111       81740 :       if (ETypes != that.ETypes)
     112             :         return false;
     113       76106 :       return true;
     114             :     }
     115             :     bool operator!=(const KeyTy& that) const {
     116             :       return !this->operator==(that);
     117             :     }
     118             :   };
     119             : 
     120             :   static inline StructType* getEmptyKey() {
     121             :     return DenseMapInfo<StructType*>::getEmptyKey();
     122             :   }
     123             : 
     124             :   static inline StructType* getTombstoneKey() {
     125             :     return DenseMapInfo<StructType*>::getTombstoneKey();
     126             :   }
     127             : 
     128      105350 :   static unsigned getHashValue(const KeyTy& Key) {
     129      210700 :     return hash_combine(hash_combine_range(Key.ETypes.begin(),
     130             :                                            Key.ETypes.end()),
     131      316050 :                         Key.isPacked);
     132             :   }
     133             : 
     134       19654 :   static unsigned getHashValue(const StructType *ST) {
     135       19654 :     return getHashValue(KeyTy(ST));
     136             :   }
     137             : 
     138       91612 :   static bool isEqual(const KeyTy& LHS, const StructType *RHS) {
     139       91612 :     if (RHS == getEmptyKey() || RHS == getTombstoneKey())
     140             :       return false;
     141       82022 :     return LHS == KeyTy(RHS);
     142             :   }
     143             : 
     144             :   static bool isEqual(const StructType *LHS, const StructType *RHS) {
     145       57966 :     return LHS == RHS;
     146             :   }
     147             : };
     148             : 
     149             : struct FunctionTypeKeyInfo {
     150             :   struct KeyTy {
     151             :     const Type *ReturnType;
     152             :     ArrayRef<Type*> Params;
     153             :     bool isVarArg;
     154             : 
     155     1894952 :     KeyTy(const Type* R, const ArrayRef<Type*>& P, bool V) :
     156     1894952 :       ReturnType(R), Params(P), isVarArg(V) {}
     157             :     KeyTy(const FunctionType *FT)
     158     3164623 :         : ReturnType(FT->getReturnType()), Params(FT->params()),
     159     9493869 :           isVarArg(FT->isVarArg()) {}
     160             : 
     161     2772751 :     bool operator==(const KeyTy& that) const {
     162     2772751 :       if (ReturnType != that.ReturnType)
     163             :         return false;
     164     2049903 :       if (isVarArg != that.isVarArg)
     165             :         return false;
     166     2046110 :       if (Params != that.Params)
     167             :         return false;
     168     1585400 :       return true;
     169             :     }
     170             :     bool operator!=(const KeyTy& that) const {
     171             :       return !this->operator==(that);
     172             :     }
     173             :   };
     174             : 
     175             :   static inline FunctionType* getEmptyKey() {
     176             :     return DenseMapInfo<FunctionType*>::getEmptyKey();
     177             :   }
     178             : 
     179             :   static inline FunctionType* getTombstoneKey() {
     180             :     return DenseMapInfo<FunctionType*>::getTombstoneKey();
     181             :   }
     182             : 
     183     2242191 :   static unsigned getHashValue(const KeyTy& Key) {
     184     4484382 :     return hash_combine(Key.ReturnType,
     185     4484382 :                         hash_combine_range(Key.Params.begin(),
     186             :                                            Key.Params.end()),
     187     8968764 :                         Key.isVarArg);
     188             :   }
     189             : 
     190      391872 :   static unsigned getHashValue(const FunctionType *FT) {
     191      391872 :     return getHashValue(KeyTy(FT));
     192             :   }
     193             : 
     194     3037670 :   static bool isEqual(const KeyTy& LHS, const FunctionType *RHS) {
     195     3037670 :     if (RHS == getEmptyKey() || RHS == getTombstoneKey())
     196             :       return false;
     197     2772751 :     return LHS == KeyTy(RHS);
     198             :   }
     199             : 
     200             :   static bool isEqual(const FunctionType *LHS, const FunctionType *RHS) {
     201     2523446 :     return LHS == RHS;
     202             :   }
     203             : };
     204             : 
     205             : /// Structure for hashing arbitrary MDNode operands.
     206             : class MDNodeOpsKey {
     207             :   ArrayRef<Metadata *> RawOps;
     208             :   ArrayRef<MDOperand> Ops;
     209             :   unsigned Hash;
     210             : 
     211             : protected:
     212             :   MDNodeOpsKey(ArrayRef<Metadata *> Ops)
     213     1817078 :       : RawOps(Ops), Hash(calculateHash(Ops)) {}
     214             : 
     215             :   template <class NodeTy>
     216       20262 :   MDNodeOpsKey(const NodeTy *N, unsigned Offset = 0)
     217     1247375 :       : Ops(N->op_begin() + Offset, N->op_end()), Hash(N->getHash()) {}
     218             : 
     219             :   template <class NodeTy>
     220     1265120 :   bool compareOps(const NodeTy *RHS, unsigned Offset = 0) const {
     221     1265120 :     if (getHash() != RHS->getHash())
     222             :       return false;
     223             : 
     224             :     assert((RawOps.empty() || Ops.empty()) && "Two sets of operands?");
     225      373566 :     return RawOps.empty() ? compareOps(Ops, RHS, Offset)
     226             :                           : compareOps(RawOps, RHS, Offset);
     227             :   }
     228             : 
     229             :   static unsigned calculateHash(MDNode *N, unsigned Offset = 0);
     230             : 
     231             : private:
     232             :   template <class T>
     233             :   static bool compareOps(ArrayRef<T> Ops, const MDNode *RHS, unsigned Offset) {
     234      373566 :     if (Ops.size() != RHS->getNumOperands() - Offset)
     235             :       return false;
     236      373566 :     return std::equal(Ops.begin(), Ops.end(), RHS->op_begin() + Offset);
     237             :   }
     238             : 
     239             :   static unsigned calculateHash(ArrayRef<Metadata *> Ops);
     240             : 
     241             : public:
     242             :   unsigned getHash() const { return Hash; }
     243             : };
     244             : 
     245             : template <class NodeTy> struct MDNodeKeyImpl;
     246             : 
     247             : /// Configuration point for MDNodeInfo::isEqual().
     248             : template <class NodeTy> struct MDNodeSubsetEqualImpl {
     249             :   using KeyTy = MDNodeKeyImpl<NodeTy>;
     250             : 
     251             :   static bool isSubsetEqual(const KeyTy &LHS, const NodeTy *RHS) {
     252             :     return false;
     253             :   }
     254             : 
     255             :   static bool isSubsetEqual(const NodeTy *LHS, const NodeTy *RHS) {
     256             :     return false;
     257             :   }
     258             : };
     259             : 
     260             : /// DenseMapInfo for MDTuple.
     261             : ///
     262             : /// Note that we don't need the is-function-local bit, since that's implicit in
     263             : /// the operands.
     264             : template <> struct MDNodeKeyImpl<MDTuple> : MDNodeOpsKey {
     265             :   MDNodeKeyImpl(ArrayRef<Metadata *> Ops) : MDNodeOpsKey(Ops) {}
     266             :   MDNodeKeyImpl(const MDTuple *N) : MDNodeOpsKey(N) {}
     267             : 
     268     1265106 :   bool isKeyOf(const MDTuple *RHS) const { return compareOps(RHS); }
     269             : 
     270      910737 :   unsigned getHashValue() const { return getHash(); }
     271             : 
     272             :   static unsigned calculateHash(MDTuple *N) {
     273       20183 :     return MDNodeOpsKey::calculateHash(N);
     274             :   }
     275             : };
     276             : 
     277             : /// DenseMapInfo for DILocation.
     278             : template <> struct MDNodeKeyImpl<DILocation> {
     279             :   unsigned Line;
     280             :   unsigned Column;
     281             :   Metadata *Scope;
     282             :   Metadata *InlinedAt;
     283             : 
     284             :   MDNodeKeyImpl(unsigned Line, unsigned Column, Metadata *Scope,
     285             :                 Metadata *InlinedAt)
     286     3292192 :       : Line(Line), Column(Column), Scope(Scope), InlinedAt(InlinedAt) {}
     287             :   MDNodeKeyImpl(const DILocation *L)
     288     5994964 :       : Line(L->getLine()), Column(L->getColumn()), Scope(L->getRawScope()),
     289    11989928 :         InlinedAt(L->getRawInlinedAt()) {}
     290             : 
     291             :   bool isKeyOf(const DILocation *RHS) const {
     292    13232504 :     return Line == RHS->getLine() && Column == RHS->getColumn() &&
     293    13147972 :            Scope == RHS->getRawScope() && InlinedAt == RHS->getRawInlinedAt();
     294             :   }
     295             : 
     296             :   unsigned getHashValue() const {
     297    12571380 :     return hash_combine(Line, Column, Scope, InlinedAt);
     298             :   }
     299             : };
     300             : 
     301             : /// DenseMapInfo for GenericDINode.
     302             : template <> struct MDNodeKeyImpl<GenericDINode> : MDNodeOpsKey {
     303             :   unsigned Tag;
     304             :   MDString *Header;
     305             : 
     306             :   MDNodeKeyImpl(unsigned Tag, MDString *Header, ArrayRef<Metadata *> DwarfOps)
     307          98 :       : MDNodeOpsKey(DwarfOps), Tag(Tag), Header(Header) {}
     308             :   MDNodeKeyImpl(const GenericDINode *N)
     309         316 :       : MDNodeOpsKey(N, 1), Tag(N->getTag()), Header(N->getRawHeader()) {}
     310             : 
     311          14 :   bool isKeyOf(const GenericDINode *RHS) const {
     312          56 :     return Tag == RHS->getTag() && Header == RHS->getRawHeader() &&
     313          28 :            compareOps(RHS, 1);
     314             :   }
     315             : 
     316         228 :   unsigned getHashValue() const { return hash_combine(getHash(), Tag, Header); }
     317             : 
     318             :   static unsigned calculateHash(GenericDINode *N) {
     319          15 :     return MDNodeOpsKey::calculateHash(N, 1);
     320             :   }
     321             : };
     322             : 
     323             : template <> struct MDNodeKeyImpl<DISubrange> {
     324             :   Metadata *CountNode;
     325             :   int64_t LowerBound;
     326             : 
     327             :   MDNodeKeyImpl(Metadata *CountNode, int64_t LowerBound)
     328        4024 :       : CountNode(CountNode), LowerBound(LowerBound) {}
     329             :   MDNodeKeyImpl(const DISubrange *N)
     330        3494 :       : CountNode(N->getRawCountNode()),
     331        3494 :         LowerBound(N->getLowerBound()) {}
     332             : 
     333         823 :   bool isKeyOf(const DISubrange *RHS) const {
     334         823 :     if (LowerBound != RHS->getLowerBound())
     335             :       return false;
     336             : 
     337        1646 :     if (auto *RHSCount = RHS->getCount().dyn_cast<ConstantInt*>())
     338         821 :       if (auto *MD = dyn_cast<ConstantAsMetadata>(CountNode))
     339         821 :         if (RHSCount->getSExtValue() ==
     340             :             cast<ConstantInt>(MD->getValue())->getSExtValue())
     341             :           return true;
     342             : 
     343         346 :     return CountNode == RHS->getRawCountNode();
     344             :   }
     345             : 
     346        6556 :   unsigned getHashValue() const {
     347        6556 :     if (auto *MD = dyn_cast<ConstantAsMetadata>(CountNode))
     348       12964 :       return hash_combine(cast<ConstantInt>(MD->getValue())->getSExtValue(),
     349       12964 :                           LowerBound);
     350         148 :     return hash_combine(CountNode, LowerBound);
     351             :   }
     352             : };
     353             : 
     354             : template <> struct MDNodeKeyImpl<DIEnumerator> {
     355             :   int64_t Value;
     356             :   MDString *Name;
     357             :   bool IsUnsigned;
     358             : 
     359             :   MDNodeKeyImpl(int64_t Value, bool IsUnsigned, MDString *Name)
     360       19706 :       : Value(Value), Name(Name), IsUnsigned(IsUnsigned) {}
     361             :   MDNodeKeyImpl(const DIEnumerator *N)
     362       37599 :       : Value(N->getValue()), Name(N->getRawName()),
     363      112797 :         IsUnsigned(N->isUnsigned()) {}
     364             : 
     365             :   bool isKeyOf(const DIEnumerator *RHS) const {
     366       23542 :     return Value == RHS->getValue() && IsUnsigned == RHS->isUnsigned() &&
     367         243 :            Name == RHS->getRawName();
     368             :   }
     369             : 
     370      113662 :   unsigned getHashValue() const { return hash_combine(Value, Name); }
     371             : };
     372             : 
     373             : template <> struct MDNodeKeyImpl<DIBasicType> {
     374             :   unsigned Tag;
     375             :   MDString *Name;
     376             :   uint64_t SizeInBits;
     377             :   uint32_t AlignInBits;
     378             :   unsigned Encoding;
     379             : 
     380             :   MDNodeKeyImpl(unsigned Tag, MDString *Name, uint64_t SizeInBits,
     381             :                 uint32_t AlignInBits, unsigned Encoding)
     382       14052 :       : Tag(Tag), Name(Name), SizeInBits(SizeInBits), AlignInBits(AlignInBits),
     383       14052 :         Encoding(Encoding) {}
     384             :   MDNodeKeyImpl(const DIBasicType *N)
     385       27336 :       : Tag(N->getTag()), Name(N->getRawName()), SizeInBits(N->getSizeInBits()),
     386       41004 :         AlignInBits(N->getAlignInBits()), Encoding(N->getEncoding()) {}
     387             : 
     388        1589 :   bool isKeyOf(const DIBasicType *RHS) const {
     389        4911 :     return Tag == RHS->getTag() && Name == RHS->getRawName() &&
     390         776 :            SizeInBits == RHS->getSizeInBits() &&
     391        2365 :            AlignInBits == RHS->getAlignInBits() &&
     392        1977 :            Encoding == RHS->getEncoding();
     393             :   }
     394             : 
     395             :   unsigned getHashValue() const {
     396       47984 :     return hash_combine(Tag, Name, SizeInBits, AlignInBits, Encoding);
     397             :   }
     398             : };
     399             : 
     400             : template <> struct MDNodeKeyImpl<DIDerivedType> {
     401             :   unsigned Tag;
     402             :   MDString *Name;
     403             :   Metadata *File;
     404             :   unsigned Line;
     405             :   Metadata *Scope;
     406             :   Metadata *BaseType;
     407             :   uint64_t SizeInBits;
     408             :   uint64_t OffsetInBits;
     409             :   uint32_t AlignInBits;
     410             :   Optional<unsigned> DWARFAddressSpace;
     411             :   unsigned Flags;
     412             :   Metadata *ExtraData;
     413             : 
     414             :   MDNodeKeyImpl(unsigned Tag, MDString *Name, Metadata *File, unsigned Line,
     415             :                 Metadata *Scope, Metadata *BaseType, uint64_t SizeInBits,
     416             :                 uint32_t AlignInBits, uint64_t OffsetInBits,
     417             :                 Optional<unsigned> DWARFAddressSpace, unsigned Flags,
     418             :                 Metadata *ExtraData)
     419      434733 :       : Tag(Tag), Name(Name), File(File), Line(Line), Scope(Scope),
     420             :         BaseType(BaseType), SizeInBits(SizeInBits), OffsetInBits(OffsetInBits),
     421             :         AlignInBits(AlignInBits), DWARFAddressSpace(DWARFAddressSpace),
     422      869466 :         Flags(Flags), ExtraData(ExtraData) {}
     423      883429 :   MDNodeKeyImpl(const DIDerivedType *N)
     424      883429 :       : Tag(N->getTag()), Name(N->getRawName()), File(N->getRawFile()),
     425      883429 :         Line(N->getLine()), Scope(N->getRawScope()),
     426      883429 :         BaseType(N->getRawBaseType()), SizeInBits(N->getSizeInBits()),
     427     1766858 :         OffsetInBits(N->getOffsetInBits()), AlignInBits(N->getAlignInBits()),
     428      883429 :         DWARFAddressSpace(N->getDWARFAddressSpace()), Flags(N->getFlags()),
     429     9717719 :         ExtraData(N->getRawExtraData()) {}
     430             : 
     431     1168056 :   bool isKeyOf(const DIDerivedType *RHS) const {
     432     2728362 :     return Tag == RHS->getTag() && Name == RHS->getRawName() &&
     433     1450878 :            File == RHS->getRawFile() && Line == RHS->getLine() &&
     434     1800431 :            Scope == RHS->getRawScope() && BaseType == RHS->getRawBaseType() &&
     435      703089 :            SizeInBits == RHS->getSizeInBits() &&
     436      703064 :            AlignInBits == RHS->getAlignInBits() &&
     437      703044 :            OffsetInBits == RHS->getOffsetInBits() &&
     438     1168898 :            DWARFAddressSpace == RHS->getDWARFAddressSpace() &&
     439     1870236 :            Flags == RHS->getFlags() &&
     440     1518729 :            ExtraData == RHS->getRawExtraData();
     441             :   }
     442             : 
     443     1315479 :   unsigned getHashValue() const {
     444             :     // If this is a member inside an ODR type, only hash the type and the name.
     445             :     // Otherwise the hash will be stronger than
     446             :     // MDNodeSubsetEqualImpl::isODRMember().
     447     1315479 :     if (Tag == dwarf::DW_TAG_member && Name)
     448      226509 :       if (auto *CT = dyn_cast_or_null<DICompositeType>(Scope))
     449             :         if (CT->getRawIdentifier())
     450      431102 :           return hash_combine(Name, Scope);
     451             : 
     452             :     // Intentionally computes the hash on a subset of the operands for
     453             :     // performance reason. The subset has to be significant enough to avoid
     454             :     // collision "most of the time". There is no correctness issue in case of
     455             :     // collision because of the full check above.
     456     2199856 :     return hash_combine(Tag, Name, File, Line, Scope, BaseType, Flags);
     457             :   }
     458             : };
     459             : 
     460             : template <> struct MDNodeSubsetEqualImpl<DIDerivedType> {
     461             :   using KeyTy = MDNodeKeyImpl<DIDerivedType>;
     462             : 
     463             :   static bool isSubsetEqual(const KeyTy &LHS, const DIDerivedType *RHS) {
     464     1168148 :     return isODRMember(LHS.Tag, LHS.Scope, LHS.Name, RHS);
     465             :   }
     466             : 
     467      506417 :   static bool isSubsetEqual(const DIDerivedType *LHS, const DIDerivedType *RHS) {
     468      506417 :     return isODRMember(LHS->getTag(), LHS->getRawScope(), LHS->getRawName(),
     469      506417 :                        RHS);
     470             :   }
     471             : 
     472             :   /// Subprograms compare equal if they declare the same function in an ODR
     473             :   /// type.
     474     1674565 :   static bool isODRMember(unsigned Tag, const Metadata *Scope,
     475             :                           const MDString *Name, const DIDerivedType *RHS) {
     476             :     // Check whether the LHS is eligible.
     477     1674565 :     if (Tag != dwarf::DW_TAG_member || !Name)
     478             :       return false;
     479             : 
     480             :     auto *CT = dyn_cast_or_null<DICompositeType>(Scope);
     481             :     if (!CT || !CT->getRawIdentifier())
     482             :       return false;
     483             : 
     484             :     // Compare to the RHS.
     485      457086 :     return Tag == RHS->getTag() && Name == RHS->getRawName() &&
     486             :            Scope == RHS->getRawScope();
     487             :   }
     488             : };
     489             : 
     490             : template <> struct MDNodeKeyImpl<DICompositeType> {
     491             :   unsigned Tag;
     492             :   MDString *Name;
     493             :   Metadata *File;
     494             :   unsigned Line;
     495             :   Metadata *Scope;
     496             :   Metadata *BaseType;
     497             :   uint64_t SizeInBits;
     498             :   uint64_t OffsetInBits;
     499             :   uint32_t AlignInBits;
     500             :   unsigned Flags;
     501             :   Metadata *Elements;
     502             :   unsigned RuntimeLang;
     503             :   Metadata *VTableHolder;
     504             :   Metadata *TemplateParams;
     505             :   MDString *Identifier;
     506             :   Metadata *Discriminator;
     507             : 
     508             :   MDNodeKeyImpl(unsigned Tag, MDString *Name, Metadata *File, unsigned Line,
     509             :                 Metadata *Scope, Metadata *BaseType, uint64_t SizeInBits,
     510             :                 uint32_t AlignInBits, uint64_t OffsetInBits, unsigned Flags,
     511             :                 Metadata *Elements, unsigned RuntimeLang,
     512             :                 Metadata *VTableHolder, Metadata *TemplateParams,
     513             :                 MDString *Identifier, Metadata *Discriminator)
     514        6354 :       : Tag(Tag), Name(Name), File(File), Line(Line), Scope(Scope),
     515             :         BaseType(BaseType), SizeInBits(SizeInBits), OffsetInBits(OffsetInBits),
     516             :         AlignInBits(AlignInBits), Flags(Flags), Elements(Elements),
     517             :         RuntimeLang(RuntimeLang), VTableHolder(VTableHolder),
     518             :         TemplateParams(TemplateParams), Identifier(Identifier),
     519        6354 :         Discriminator(Discriminator) {}
     520       23810 :   MDNodeKeyImpl(const DICompositeType *N)
     521       23810 :       : Tag(N->getTag()), Name(N->getRawName()), File(N->getRawFile()),
     522       23810 :         Line(N->getLine()), Scope(N->getRawScope()),
     523       23810 :         BaseType(N->getRawBaseType()), SizeInBits(N->getSizeInBits()),
     524       47620 :         OffsetInBits(N->getOffsetInBits()), AlignInBits(N->getAlignInBits()),
     525       23810 :         Flags(N->getFlags()), Elements(N->getRawElements()),
     526       23810 :         RuntimeLang(N->getRuntimeLang()), VTableHolder(N->getRawVTableHolder()),
     527             :         TemplateParams(N->getRawTemplateParams()),
     528             :         Identifier(N->getRawIdentifier()),
     529      380960 :         Discriminator(N->getRawDiscriminator()) {}
     530             : 
     531        5770 :   bool isKeyOf(const DICompositeType *RHS) const {
     532       12523 :     return Tag == RHS->getTag() && Name == RHS->getRawName() &&
     533        1632 :            File == RHS->getRawFile() && Line == RHS->getLine() &&
     534        1972 :            Scope == RHS->getRawScope() && BaseType == RHS->getRawBaseType() &&
     535         564 :            SizeInBits == RHS->getSizeInBits() &&
     536         392 :            AlignInBits == RHS->getAlignInBits() &&
     537         556 :            OffsetInBits == RHS->getOffsetInBits() && Flags == RHS->getFlags() &&
     538         352 :            Elements == RHS->getRawElements() &&
     539         328 :            RuntimeLang == RHS->getRuntimeLang() &&
     540         306 :            VTableHolder == RHS->getRawVTableHolder() &&
     541         302 :            TemplateParams == RHS->getRawTemplateParams() &&
     542        6064 :            Identifier == RHS->getRawIdentifier() &&
     543        5913 :            Discriminator == RHS->getRawDiscriminator();
     544             :   }
     545             : 
     546             :   unsigned getHashValue() const {
     547             :     // Intentionally computes the hash on a subset of the operands for
     548             :     // performance reason. The subset has to be significant enough to avoid
     549             :     // collision "most of the time". There is no correctness issue in case of
     550             :     // collision because of the full check above.
     551       57374 :     return hash_combine(Name, File, Line, BaseType, Scope, Elements,
     552       39439 :                         TemplateParams);
     553             :   }
     554             : };
     555             : 
     556             : template <> struct MDNodeKeyImpl<DISubroutineType> {
     557             :   unsigned Flags;
     558             :   uint8_t CC;
     559             :   Metadata *TypeArray;
     560             : 
     561             :   MDNodeKeyImpl(unsigned Flags, uint8_t CC, Metadata *TypeArray)
     562      438675 :       : Flags(Flags), CC(CC), TypeArray(TypeArray) {}
     563             :   MDNodeKeyImpl(const DISubroutineType *N)
     564     1643114 :       : Flags(N->getFlags()), CC(N->getCC()), TypeArray(N->getRawTypeArray()) {}
     565             : 
     566             :   bool isKeyOf(const DISubroutineType *RHS) const {
     567     1372412 :     return Flags == RHS->getFlags() && CC == RHS->getCC() &&
     568      686164 :            TypeArray == RHS->getRawTypeArray();
     569             :   }
     570             : 
     571     2512428 :   unsigned getHashValue() const { return hash_combine(Flags, CC, TypeArray); }
     572             : };
     573             : 
     574             : template <> struct MDNodeKeyImpl<DIFile> {
     575             :   MDString *Filename;
     576             :   MDString *Directory;
     577             :   Optional<DIFile::ChecksumInfo<MDString *>> Checksum;
     578             :   Optional<MDString *> Source;
     579             : 
     580             :   MDNodeKeyImpl(MDString *Filename, MDString *Directory,
     581             :                 Optional<DIFile::ChecksumInfo<MDString *>> Checksum,
     582             :                 Optional<MDString *> Source)
     583       59955 :       : Filename(Filename), Directory(Directory), Checksum(Checksum),
     584       59955 :         Source(Source) {}
     585       46233 :   MDNodeKeyImpl(const DIFile *N)
     586       46233 :       : Filename(N->getRawFilename()), Directory(N->getRawDirectory()),
     587      138699 :         Checksum(N->getRawChecksum()), Source(N->getRawSource()) {}
     588             : 
     589       48767 :   bool isKeyOf(const DIFile *RHS) const {
     590       77086 :     return Filename == RHS->getRawFilename() &&
     591       56582 :            Directory == RHS->getRawDirectory() &&
     592       77084 :            Checksum == RHS->getRawChecksum() &&
     593       48767 :            Source == RHS->getRawSource();
     594             :   }
     595             : 
     596      101391 :   unsigned getHashValue() const {
     597      202782 :     return hash_combine(
     598      202782 :         Filename, Directory, Checksum ? Checksum->Kind : 0,
     599      405564 :         Checksum ? Checksum->Value : nullptr, Source.getValueOr(nullptr));
     600             :   }
     601             : };
     602             : 
     603             : template <> struct MDNodeKeyImpl<DISubprogram> {
     604             :   Metadata *Scope;
     605             :   MDString *Name;
     606             :   MDString *LinkageName;
     607             :   Metadata *File;
     608             :   unsigned Line;
     609             :   Metadata *Type;
     610             :   bool IsLocalToUnit;
     611             :   bool IsDefinition;
     612             :   unsigned ScopeLine;
     613             :   Metadata *ContainingType;
     614             :   unsigned Virtuality;
     615             :   unsigned VirtualIndex;
     616             :   int ThisAdjustment;
     617             :   unsigned Flags;
     618             :   bool IsOptimized;
     619             :   Metadata *Unit;
     620             :   Metadata *TemplateParams;
     621             :   Metadata *Declaration;
     622             :   Metadata *RetainedNodes;
     623             :   Metadata *ThrownTypes;
     624             : 
     625             :   MDNodeKeyImpl(Metadata *Scope, MDString *Name, MDString *LinkageName,
     626             :                 Metadata *File, unsigned Line, Metadata *Type,
     627             :                 bool IsLocalToUnit, bool IsDefinition, unsigned ScopeLine,
     628             :                 Metadata *ContainingType, unsigned Virtuality,
     629             :                 unsigned VirtualIndex, int ThisAdjustment, unsigned Flags,
     630             :                 bool IsOptimized, Metadata *Unit, Metadata *TemplateParams,
     631             :                 Metadata *Declaration, Metadata *RetainedNodes,
     632             :                 Metadata *ThrownTypes)
     633      206441 :       : Scope(Scope), Name(Name), LinkageName(LinkageName), File(File),
     634             :         Line(Line), Type(Type), IsLocalToUnit(IsLocalToUnit),
     635             :         IsDefinition(IsDefinition), ScopeLine(ScopeLine),
     636             :         ContainingType(ContainingType), Virtuality(Virtuality),
     637             :         VirtualIndex(VirtualIndex), ThisAdjustment(ThisAdjustment),
     638             :         Flags(Flags), IsOptimized(IsOptimized), Unit(Unit),
     639             :         TemplateParams(TemplateParams), Declaration(Declaration),
     640      206441 :         RetainedNodes(RetainedNodes), ThrownTypes(ThrownTypes) {}
     641      754611 :   MDNodeKeyImpl(const DISubprogram *N)
     642      754611 :       : Scope(N->getRawScope()), Name(N->getRawName()),
     643             :         LinkageName(N->getRawLinkageName()), File(N->getRawFile()),
     644      754611 :         Line(N->getLine()), Type(N->getRawType()),
     645             :         IsLocalToUnit(N->isLocalToUnit()), IsDefinition(N->isDefinition()),
     646      754611 :         ScopeLine(N->getScopeLine()), ContainingType(N->getRawContainingType()),
     647      754611 :         Virtuality(N->getVirtuality()), VirtualIndex(N->getVirtualIndex()),
     648     1509222 :         ThisAdjustment(N->getThisAdjustment()), Flags(N->getFlags()),
     649             :         IsOptimized(N->isOptimized()), Unit(N->getRawUnit()),
     650             :         TemplateParams(N->getRawTemplateParams()),
     651             :         Declaration(N->getRawDeclaration()), RetainedNodes(N->getRawRetainedNodes()),
     652    15092220 :         ThrownTypes(N->getRawThrownTypes()) {}
     653             : 
     654      437854 :   bool isKeyOf(const DISubprogram *RHS) const {
     655      559210 :     return Scope == RHS->getRawScope() && Name == RHS->getRawName() &&
     656       25564 :            LinkageName == RHS->getRawLinkageName() &&
     657       36854 :            File == RHS->getRawFile() && Line == RHS->getLine() &&
     658       47356 :            Type == RHS->getRawType() && IsLocalToUnit == RHS->isLocalToUnit() &&
     659       23649 :            IsDefinition == RHS->isDefinition() &&
     660       23628 :            ScopeLine == RHS->getScopeLine() &&
     661       23609 :            ContainingType == RHS->getRawContainingType() &&
     662       23592 :            Virtuality == RHS->getVirtuality() &&
     663       23577 :            VirtualIndex == RHS->getVirtualIndex() &&
     664       23570 :            ThisAdjustment == RHS->getThisAdjustment() &&
     665       47134 :            Flags == RHS->getFlags() && IsOptimized == RHS->isOptimized() &&
     666       23553 :            Unit == RHS->getUnit() &&
     667       23543 :            TemplateParams == RHS->getRawTemplateParams() &&
     668       23535 :            Declaration == RHS->getRawDeclaration() &&
     669      461384 :            RetainedNodes == RHS->getRawRetainedNodes() &&
     670      449618 :            ThrownTypes == RHS->getRawThrownTypes();
     671             :   }
     672             : 
     673      959925 :   unsigned getHashValue() const {
     674             :     // If this is a declaration inside an ODR type, only hash the type and the
     675             :     // name.  Otherwise the hash will be stronger than
     676             :     // MDNodeSubsetEqualImpl::isDeclarationOfODRMember().
     677      959925 :     if (!IsDefinition && LinkageName)
     678      548108 :       if (auto *CT = dyn_cast_or_null<DICompositeType>(Scope))
     679             :         if (CT->getRawIdentifier())
     680     1086038 :           return hash_combine(LinkageName, Scope);
     681             : 
     682             :     // Intentionally computes the hash on a subset of the operands for
     683             :     // performance reason. The subset has to be significant enough to avoid
     684             :     // collision "most of the time". There is no correctness issue in case of
     685             :     // collision because of the full check above.
     686      833812 :     return hash_combine(Name, Scope, File, Type, Line);
     687             :   }
     688             : };
     689             : 
     690             : template <> struct MDNodeSubsetEqualImpl<DISubprogram> {
     691             :   using KeyTy = MDNodeKeyImpl<DISubprogram>;
     692             : 
     693             :   static bool isSubsetEqual(const KeyTy &LHS, const DISubprogram *RHS) {
     694      437862 :     return isDeclarationOfODRMember(LHS.IsDefinition, LHS.Scope,
     695      875724 :                                     LHS.LinkageName, LHS.TemplateParams, RHS);
     696             :   }
     697             : 
     698      516738 :   static bool isSubsetEqual(const DISubprogram *LHS, const DISubprogram *RHS) {
     699      516738 :     return isDeclarationOfODRMember(LHS->isDefinition(), LHS->getRawScope(),
     700             :                                     LHS->getRawLinkageName(),
     701      516738 :                                     LHS->getRawTemplateParams(), RHS);
     702             :   }
     703             : 
     704             :   /// Subprograms compare equal if they declare the same function in an ODR
     705             :   /// type.
     706      954600 :   static bool isDeclarationOfODRMember(bool IsDefinition, const Metadata *Scope,
     707             :                                        const MDString *LinkageName,
     708             :                                        const Metadata *TemplateParams,
     709             :                                        const DISubprogram *RHS) {
     710             :     // Check whether the LHS is eligible.
     711      954600 :     if (IsDefinition || !Scope || !LinkageName)
     712             :       return false;
     713             : 
     714             :     auto *CT = dyn_cast_or_null<DICompositeType>(Scope);
     715             :     if (!CT || !CT->getRawIdentifier())
     716             :       return false;
     717             : 
     718             :     // Compare to the RHS.
     719             :     // FIXME: We need to compare template parameters here to avoid incorrect
     720             :     // collisions in mapMetadata when RF_MoveDistinctMDs and a ODR-DISubprogram
     721             :     // has a non-ODR template parameter (i.e., a DICompositeType that does not
     722             :     // have an identifier). Eventually we should decouple ODR logic from
     723             :     // uniquing logic.
     724      548641 :     return IsDefinition == RHS->isDefinition() && Scope == RHS->getRawScope() &&
     725      489706 :            LinkageName == RHS->getRawLinkageName() &&
     726             :            TemplateParams == RHS->getRawTemplateParams();
     727             :   }
     728             : };
     729             : 
     730             : template <> struct MDNodeKeyImpl<DILexicalBlock> {
     731             :   Metadata *Scope;
     732             :   Metadata *File;
     733             :   unsigned Line;
     734             :   unsigned Column;
     735             : 
     736             :   MDNodeKeyImpl(Metadata *Scope, Metadata *File, unsigned Line, unsigned Column)
     737          41 :       : Scope(Scope), File(File), Line(Line), Column(Column) {}
     738             :   MDNodeKeyImpl(const DILexicalBlock *N)
     739          76 :       : Scope(N->getRawScope()), File(N->getRawFile()), Line(N->getLine()),
     740         152 :         Column(N->getColumn()) {}
     741             : 
     742           5 :   bool isKeyOf(const DILexicalBlock *RHS) const {
     743          20 :     return Scope == RHS->getRawScope() && File == RHS->getRawFile() &&
     744          20 :            Line == RHS->getLine() && Column == RHS->getColumn();
     745             :   }
     746             : 
     747             :   unsigned getHashValue() const {
     748         122 :     return hash_combine(Scope, File, Line, Column);
     749             :   }
     750             : };
     751             : 
     752             : template <> struct MDNodeKeyImpl<DILexicalBlockFile> {
     753             :   Metadata *Scope;
     754             :   Metadata *File;
     755             :   unsigned Discriminator;
     756             : 
     757             :   MDNodeKeyImpl(Metadata *Scope, Metadata *File, unsigned Discriminator)
     758         920 :       : Scope(Scope), File(File), Discriminator(Discriminator) {}
     759             :   MDNodeKeyImpl(const DILexicalBlockFile *N)
     760         720 :       : Scope(N->getRawScope()), File(N->getRawFile()),
     761        1440 :         Discriminator(N->getDiscriminator()) {}
     762             : 
     763             :   bool isKeyOf(const DILexicalBlockFile *RHS) const {
     764        1895 :     return Scope == RHS->getRawScope() && File == RHS->getRawFile() &&
     765         468 :            Discriminator == RHS->getDiscriminator();
     766             :   }
     767             : 
     768             :   unsigned getHashValue() const {
     769        2894 :     return hash_combine(Scope, File, Discriminator);
     770             :   }
     771             : };
     772             : 
     773             : template <> struct MDNodeKeyImpl<DINamespace> {
     774             :   Metadata *Scope;
     775             :   MDString *Name;
     776             :   bool ExportSymbols;
     777             : 
     778             :   MDNodeKeyImpl(Metadata *Scope, MDString *Name, bool ExportSymbols)
     779       20283 :       : Scope(Scope), Name(Name), ExportSymbols(ExportSymbols) {}
     780             :   MDNodeKeyImpl(const DINamespace *N)
     781        4048 :       : Scope(N->getRawScope()), Name(N->getRawName()),
     782       12144 :         ExportSymbols(N->getExportSymbols()) {}
     783             : 
     784       16811 :   bool isKeyOf(const DINamespace *RHS) const {
     785       66493 :     return Scope == RHS->getRawScope() && Name == RHS->getRawName() &&
     786       33095 :            ExportSymbols == RHS->getExportSymbols();
     787             :   }
     788             : 
     789             :   unsigned getHashValue() const {
     790       46950 :     return hash_combine(Scope, Name);
     791             :   }
     792             : };
     793             : 
     794             : template <> struct MDNodeKeyImpl<DIModule> {
     795             :   Metadata *Scope;
     796             :   MDString *Name;
     797             :   MDString *ConfigurationMacros;
     798             :   MDString *IncludePath;
     799             :   MDString *ISysRoot;
     800             : 
     801             :   MDNodeKeyImpl(Metadata *Scope, MDString *Name, MDString *ConfigurationMacros,
     802             :                 MDString *IncludePath, MDString *ISysRoot)
     803         189 :       : Scope(Scope), Name(Name), ConfigurationMacros(ConfigurationMacros),
     804         189 :         IncludePath(IncludePath), ISysRoot(ISysRoot) {}
     805         183 :   MDNodeKeyImpl(const DIModule *N)
     806         183 :       : Scope(N->getRawScope()), Name(N->getRawName()),
     807             :         ConfigurationMacros(N->getRawConfigurationMacros()),
     808         915 :         IncludePath(N->getRawIncludePath()), ISysRoot(N->getRawISysRoot()) {}
     809             : 
     810           8 :   bool isKeyOf(const DIModule *RHS) const {
     811          32 :     return Scope == RHS->getRawScope() && Name == RHS->getRawName() &&
     812          16 :            ConfigurationMacros == RHS->getRawConfigurationMacros() &&
     813          24 :            IncludePath == RHS->getRawIncludePath() &&
     814          16 :            ISysRoot == RHS->getRawISysRoot();
     815             :   }
     816             : 
     817             :   unsigned getHashValue() const {
     818         460 :     return hash_combine(Scope, Name,
     819         278 :                         ConfigurationMacros, IncludePath, ISysRoot);
     820             :   }
     821             : };
     822             : 
     823             : template <> struct MDNodeKeyImpl<DITemplateTypeParameter> {
     824             :   MDString *Name;
     825             :   Metadata *Type;
     826             : 
     827       64297 :   MDNodeKeyImpl(MDString *Name, Metadata *Type) : Name(Name), Type(Type) {}
     828             :   MDNodeKeyImpl(const DITemplateTypeParameter *N)
     829      116889 :       : Name(N->getRawName()), Type(N->getRawType()) {}
     830             : 
     831             :   bool isKeyOf(const DITemplateTypeParameter *RHS) const {
     832      231958 :     return Name == RHS->getRawName() && Type == RHS->getRawType();
     833             :   }
     834             : 
     835      205440 :   unsigned getHashValue() const { return hash_combine(Name, Type); }
     836             : };
     837             : 
     838             : template <> struct MDNodeKeyImpl<DITemplateValueParameter> {
     839             :   unsigned Tag;
     840             :   MDString *Name;
     841             :   Metadata *Type;
     842             :   Metadata *Value;
     843             : 
     844             :   MDNodeKeyImpl(unsigned Tag, MDString *Name, Metadata *Type, Metadata *Value)
     845       25682 :       : Tag(Tag), Name(Name), Type(Type), Value(Value) {}
     846             :   MDNodeKeyImpl(const DITemplateValueParameter *N)
     847       10240 :       : Tag(N->getTag()), Name(N->getRawName()), Type(N->getRawType()),
     848       40960 :         Value(N->getValue()) {}
     849             : 
     850       27490 :   bool isKeyOf(const DITemplateValueParameter *RHS) const {
     851       93901 :     return Tag == RHS->getTag() && Name == RHS->getRawName() &&
     852       85873 :            Type == RHS->getRawType() && Value == RHS->getValue();
     853             :   }
     854             : 
     855       71038 :   unsigned getHashValue() const { return hash_combine(Tag, Name, Type, Value); }
     856             : };
     857             : 
     858             : template <> struct MDNodeKeyImpl<DIGlobalVariable> {
     859             :   Metadata *Scope;
     860             :   MDString *Name;
     861             :   MDString *LinkageName;
     862             :   Metadata *File;
     863             :   unsigned Line;
     864             :   Metadata *Type;
     865             :   bool IsLocalToUnit;
     866             :   bool IsDefinition;
     867             :   Metadata *StaticDataMemberDeclaration;
     868             :   uint32_t AlignInBits;
     869             : 
     870             :   MDNodeKeyImpl(Metadata *Scope, MDString *Name, MDString *LinkageName,
     871             :                 Metadata *File, unsigned Line, Metadata *Type,
     872             :                 bool IsLocalToUnit, bool IsDefinition,
     873             :                 Metadata *StaticDataMemberDeclaration, uint32_t AlignInBits)
     874         559 :       : Scope(Scope), Name(Name), LinkageName(LinkageName), File(File),
     875             :         Line(Line), Type(Type), IsLocalToUnit(IsLocalToUnit),
     876             :         IsDefinition(IsDefinition),
     877             :         StaticDataMemberDeclaration(StaticDataMemberDeclaration),
     878         559 :         AlignInBits(AlignInBits) {}
     879        3041 :   MDNodeKeyImpl(const DIGlobalVariable *N)
     880        3041 :       : Scope(N->getRawScope()), Name(N->getRawName()),
     881             :         LinkageName(N->getRawLinkageName()), File(N->getRawFile()),
     882        3041 :         Line(N->getLine()), Type(N->getRawType()),
     883        6082 :         IsLocalToUnit(N->isLocalToUnit()), IsDefinition(N->isDefinition()),
     884             :         StaticDataMemberDeclaration(N->getRawStaticDataMemberDeclaration()),
     885       27369 :         AlignInBits(N->getAlignInBits()) {}
     886             : 
     887         155 :   bool isKeyOf(const DIGlobalVariable *RHS) const {
     888         465 :     return Scope == RHS->getRawScope() && Name == RHS->getRawName() &&
     889           7 :            LinkageName == RHS->getRawLinkageName() &&
     890           9 :            File == RHS->getRawFile() && Line == RHS->getLine() &&
     891           9 :            Type == RHS->getRawType() && IsLocalToUnit == RHS->isLocalToUnit() &&
     892           6 :            IsDefinition == RHS->isDefinition() &&
     893           3 :            StaticDataMemberDeclaration ==
     894         158 :                RHS->getRawStaticDataMemberDeclaration() &&
     895         158 :            AlignInBits == RHS->getAlignInBits();
     896             :   }
     897             : 
     898        3082 :   unsigned getHashValue() const {
     899             :     // We do not use AlignInBits in hashing function here on purpose:
     900             :     // in most cases this param for local variable is zero (for function param
     901             :     // it is always zero). This leads to lots of hash collisions and errors on
     902             :     // cases with lots of similar variables.
     903             :     // clang/test/CodeGen/debug-info-257-args.c is an example of this problem,
     904             :     // generated IR is random for each run and test fails with Align included.
     905             :     // TODO: make hashing work fine with such situations
     906        6164 :     return hash_combine(Scope, Name, LinkageName, File, Line, Type,
     907             :                         IsLocalToUnit, IsDefinition, /* AlignInBits, */
     908        9246 :                         StaticDataMemberDeclaration);
     909             :   }
     910             : };
     911             : 
     912             : template <> struct MDNodeKeyImpl<DILocalVariable> {
     913             :   Metadata *Scope;
     914             :   MDString *Name;
     915             :   Metadata *File;
     916             :   unsigned Line;
     917             :   Metadata *Type;
     918             :   unsigned Arg;
     919             :   unsigned Flags;
     920             :   uint32_t AlignInBits;
     921             : 
     922             :   MDNodeKeyImpl(Metadata *Scope, MDString *Name, Metadata *File, unsigned Line,
     923             :                 Metadata *Type, unsigned Arg, unsigned Flags,
     924             :                 uint32_t AlignInBits)
     925       86655 :       : Scope(Scope), Name(Name), File(File), Line(Line), Type(Type), Arg(Arg),
     926       86655 :         Flags(Flags), AlignInBits(AlignInBits) {}
     927      172098 :   MDNodeKeyImpl(const DILocalVariable *N)
     928      172098 :       : Scope(N->getRawScope()), Name(N->getRawName()), File(N->getRawFile()),
     929      172098 :         Line(N->getLine()), Type(N->getRawType()), Arg(N->getArg()),
     930     1032588 :         Flags(N->getFlags()), AlignInBits(N->getAlignInBits()) {}
     931             : 
     932       96705 :   bool isKeyOf(const DILocalVariable *RHS) const {
     933      101677 :     return Scope == RHS->getRawScope() && Name == RHS->getRawName() &&
     934        1106 :            File == RHS->getRawFile() && Line == RHS->getLine() &&
     935         615 :            Type == RHS->getRawType() && Arg == RHS->getArg() &&
     936       96959 :            Flags == RHS->getFlags() && AlignInBits == RHS->getAlignInBits();
     937             :   }
     938             : 
     939             :   unsigned getHashValue() const {
     940             :     // We do not use AlignInBits in hashing function here on purpose:
     941             :     // in most cases this param for local variable is zero (for function param
     942             :     // it is always zero). This leads to lots of hash collisions and errors on
     943             :     // cases with lots of similar variables.
     944             :     // clang/test/CodeGen/debug-info-257-args.c is an example of this problem,
     945             :     // generated IR is random for each run and test fails with Align included.
     946             :     // TODO: make hashing work fine with such situations
     947      511592 :     return hash_combine(Scope, Name, File, Line, Type, Arg, Flags);
     948             :   }
     949             : };
     950             : 
     951             : template <> struct MDNodeKeyImpl<DILabel> {
     952             :   Metadata *Scope;
     953             :   MDString *Name;
     954             :   Metadata *File;
     955             :   unsigned Line;
     956             : 
     957             :   MDNodeKeyImpl(Metadata *Scope, MDString *Name, Metadata *File, unsigned Line)
     958          26 :       : Scope(Scope), Name(Name), File(File), Line(Line) {}
     959             :   MDNodeKeyImpl(const DILabel *N)
     960          26 :       : Scope(N->getRawScope()), Name(N->getRawName()), File(N->getRawFile()),
     961          78 :         Line(N->getLine()) {}
     962             : 
     963           0 :   bool isKeyOf(const DILabel *RHS) const {
     964           0 :     return Scope == RHS->getRawScope() && Name == RHS->getRawName() &&
     965           0 :            File == RHS->getRawFile() && Line == RHS->getLine();
     966             :   }
     967             : 
     968             :   /// Using name and line to get hash value. It should already be mostly unique.
     969             :   unsigned getHashValue() const {
     970          78 :     return hash_combine(Scope, Name, Line);
     971             :   }
     972             : };
     973             : 
     974             : template <> struct MDNodeKeyImpl<DIExpression> {
     975             :   ArrayRef<uint64_t> Elements;
     976             : 
     977      101097 :   MDNodeKeyImpl(ArrayRef<uint64_t> Elements) : Elements(Elements) {}
     978           2 :   MDNodeKeyImpl(const DIExpression *N) : Elements(N->getElements()) {}
     979             : 
     980             :   bool isKeyOf(const DIExpression *RHS) const {
     981             :     return Elements == RHS->getElements();
     982             :   }
     983             : 
     984             :   unsigned getHashValue() const {
     985      103310 :     return hash_combine_range(Elements.begin(), Elements.end());
     986             :   }
     987             : };
     988             : 
     989             : template <> struct MDNodeKeyImpl<DIGlobalVariableExpression> {
     990             :   Metadata *Variable;
     991             :   Metadata *Expression;
     992             : 
     993             :   MDNodeKeyImpl(Metadata *Variable, Metadata *Expression)
     994        5015 :       : Variable(Variable), Expression(Expression) {}
     995             :   MDNodeKeyImpl(const DIGlobalVariableExpression *N)
     996       25251 :       : Variable(N->getRawVariable()), Expression(N->getRawExpression()) {}
     997             : 
     998             :   bool isKeyOf(const DIGlobalVariableExpression *RHS) const {
     999        3851 :     return Variable == RHS->getRawVariable() &&
    1000           7 :            Expression == RHS->getRawExpression();
    1001             :   }
    1002             : 
    1003       24272 :   unsigned getHashValue() const { return hash_combine(Variable, Expression); }
    1004             : };
    1005             : 
    1006             : template <> struct MDNodeKeyImpl<DIObjCProperty> {
    1007             :   MDString *Name;
    1008             :   Metadata *File;
    1009             :   unsigned Line;
    1010             :   MDString *GetterName;
    1011             :   MDString *SetterName;
    1012             :   unsigned Attributes;
    1013             :   Metadata *Type;
    1014             : 
    1015             :   MDNodeKeyImpl(MDString *Name, Metadata *File, unsigned Line,
    1016             :                 MDString *GetterName, MDString *SetterName, unsigned Attributes,
    1017             :                 Metadata *Type)
    1018         122 :       : Name(Name), File(File), Line(Line), GetterName(GetterName),
    1019         122 :         SetterName(SetterName), Attributes(Attributes), Type(Type) {}
    1020          91 :   MDNodeKeyImpl(const DIObjCProperty *N)
    1021         182 :       : Name(N->getRawName()), File(N->getRawFile()), Line(N->getLine()),
    1022             :         GetterName(N->getRawGetterName()), SetterName(N->getRawSetterName()),
    1023         546 :         Attributes(N->getAttributes()), Type(N->getRawType()) {}
    1024             : 
    1025          38 :   bool isKeyOf(const DIObjCProperty *RHS) const {
    1026         137 :     return Name == RHS->getRawName() && File == RHS->getRawFile() &&
    1027         132 :            Line == RHS->getLine() && GetterName == RHS->getRawGetterName() &&
    1028          66 :            SetterName == RHS->getRawSetterName() &&
    1029         137 :            Attributes == RHS->getAttributes() && Type == RHS->getRawType();
    1030             :   }
    1031             : 
    1032             :   unsigned getHashValue() const {
    1033         334 :     return hash_combine(Name, File, Line, GetterName, SetterName, Attributes,
    1034         244 :                         Type);
    1035             :   }
    1036             : };
    1037             : 
    1038             : template <> struct MDNodeKeyImpl<DIImportedEntity> {
    1039             :   unsigned Tag;
    1040             :   Metadata *Scope;
    1041             :   Metadata *Entity;
    1042             :   Metadata *File;
    1043             :   unsigned Line;
    1044             :   MDString *Name;
    1045             : 
    1046             :   MDNodeKeyImpl(unsigned Tag, Metadata *Scope, Metadata *Entity, Metadata *File,
    1047             :                 unsigned Line, MDString *Name)
    1048      105593 :       : Tag(Tag), Scope(Scope), Entity(Entity), File(File), Line(Line),
    1049      105593 :         Name(Name) {}
    1050      281963 :   MDNodeKeyImpl(const DIImportedEntity *N)
    1051      281963 :       : Tag(N->getTag()), Scope(N->getRawScope()), Entity(N->getRawEntity()),
    1052     1409815 :         File(N->getRawFile()), Line(N->getLine()), Name(N->getRawName()) {}
    1053             : 
    1054      157240 :   bool isKeyOf(const DIImportedEntity *RHS) const {
    1055      595535 :     return Tag == RHS->getTag() && Scope == RHS->getRawScope() &&
    1056      126634 :            Entity == RHS->getRawEntity() && File == RHS->getFile() &&
    1057      157271 :            Line == RHS->getLine() && Name == RHS->getRawName();
    1058             :   }
    1059             : 
    1060             :   unsigned getHashValue() const {
    1061      773616 :     return hash_combine(Tag, Scope, Entity, File, Line, Name);
    1062             :   }
    1063             : };
    1064             : 
    1065             : template <> struct MDNodeKeyImpl<DIMacro> {
    1066             :   unsigned MIType;
    1067             :   unsigned Line;
    1068             :   MDString *Name;
    1069             :   MDString *Value;
    1070             : 
    1071             :   MDNodeKeyImpl(unsigned MIType, unsigned Line, MDString *Name, MDString *Value)
    1072        1106 :       : MIType(MIType), Line(Line), Name(Name), Value(Value) {}
    1073             :   MDNodeKeyImpl(const DIMacro *N)
    1074        4210 :       : MIType(N->getMacinfoType()), Line(N->getLine()), Name(N->getRawName()),
    1075        8420 :         Value(N->getRawValue()) {}
    1076             : 
    1077        1594 :   bool isKeyOf(const DIMacro *RHS) const {
    1078        4623 :     return MIType == RHS->getMacinfoType() && Line == RHS->getLine() &&
    1079        3105 :            Name == RHS->getRawName() && Value == RHS->getRawValue();
    1080             :   }
    1081             : 
    1082             :   unsigned getHashValue() const {
    1083        6352 :     return hash_combine(MIType, Line, Name, Value);
    1084             :   }
    1085             : };
    1086             : 
    1087             : template <> struct MDNodeKeyImpl<DIMacroFile> {
    1088             :   unsigned MIType;
    1089             :   unsigned Line;
    1090             :   Metadata *File;
    1091             :   Metadata *Elements;
    1092             : 
    1093             :   MDNodeKeyImpl(unsigned MIType, unsigned Line, Metadata *File,
    1094             :                 Metadata *Elements)
    1095          66 :       : MIType(MIType), Line(Line), File(File), Elements(Elements) {}
    1096             :   MDNodeKeyImpl(const DIMacroFile *N)
    1097         210 :       : MIType(N->getMacinfoType()), Line(N->getLine()), File(N->getRawFile()),
    1098         420 :         Elements(N->getRawElements()) {}
    1099             : 
    1100           4 :   bool isKeyOf(const DIMacroFile *RHS) const {
    1101          11 :     return MIType == RHS->getMacinfoType() && Line == RHS->getLine() &&
    1102          13 :            File == RHS->getRawFile() && Elements == RHS->getRawElements();
    1103             :   }
    1104             : 
    1105             :   unsigned getHashValue() const {
    1106         272 :     return hash_combine(MIType, Line, File, Elements);
    1107             :   }
    1108             : };
    1109             : 
    1110             : /// DenseMapInfo for MDNode subclasses.
    1111             : template <class NodeTy> struct MDNodeInfo {
    1112             :   using KeyTy = MDNodeKeyImpl<NodeTy>;
    1113             :   using SubsetEqualTy = MDNodeSubsetEqualImpl<NodeTy>;
    1114             : 
    1115             :   static inline NodeTy *getEmptyKey() {
    1116             :     return DenseMapInfo<NodeTy *>::getEmptyKey();
    1117             :   }
    1118             : 
    1119             :   static inline NodeTy *getTombstoneKey() {
    1120             :     return DenseMapInfo<NodeTy *>::getTombstoneKey();
    1121             :   }
    1122             : 
    1123      994635 :   static unsigned getHashValue(const KeyTy &Key) { return Key.getHashValue(); }
    1124             : 
    1125     4390328 :   static unsigned getHashValue(const NodeTy *N) {
    1126     6241422 :     return KeyTy(N).getHashValue();
    1127             :   }
    1128             : 
    1129    10724208 :   static bool isEqual(const KeyTy &LHS, const NodeTy *RHS) {
    1130    14204018 :     if (RHS == getEmptyKey() || RHS == getTombstoneKey())
    1131             :       return false;
    1132     5400134 :     return SubsetEqualTy::isSubsetEqual(LHS, RHS) || LHS.isKeyOf(RHS);
    1133             :   }
    1134             : 
    1135             :   static bool isEqual(const NodeTy *LHS, const NodeTy *RHS) {
    1136    61226582 :     if (LHS == RHS)
    1137             :       return true;
    1138     2360498 :     if (RHS == getEmptyKey() || RHS == getTombstoneKey())
    1139             :       return false;
    1140     1023155 :     return SubsetEqualTy::isSubsetEqual(LHS, RHS);
    1141             :   }
    1142             : };
    1143             : 
    1144             : #define HANDLE_MDNODE_LEAF(CLASS) using CLASS##Info = MDNodeInfo<CLASS>;
    1145             : #include "llvm/IR/Metadata.def"
    1146             : 
    1147             : /// Map-like storage for metadata attachments.
    1148      839008 : class MDAttachmentMap {
    1149             :   SmallVector<std::pair<unsigned, TrackingMDNodeRef>, 2> Attachments;
    1150             : 
    1151             : public:
    1152     1482951 :   bool empty() const { return Attachments.empty(); }
    1153             :   size_t size() const { return Attachments.size(); }
    1154             : 
    1155             :   /// Get a particular attachment (if any).
    1156             :   MDNode *lookup(unsigned ID) const;
    1157             : 
    1158             :   /// Set an attachment to a particular node.
    1159             :   ///
    1160             :   /// Set the \c ID attachment to \c MD, replacing the current attachment at \c
    1161             :   /// ID (if anyway).
    1162             :   void set(unsigned ID, MDNode &MD);
    1163             : 
    1164             :   /// Remove an attachment.
    1165             :   ///
    1166             :   /// Remove the attachment at \c ID, if any.
    1167             :   bool erase(unsigned ID);
    1168             : 
    1169             :   /// Copy out all the attachments.
    1170             :   ///
    1171             :   /// Copies all the current attachments into \c Result, sorting by attachment
    1172             :   /// ID.  This function does \em not clear \c Result.
    1173             :   void getAll(SmallVectorImpl<std::pair<unsigned, MDNode *>> &Result) const;
    1174             : 
    1175             :   /// Erase matching attachments.
    1176             :   ///
    1177             :   /// Erases all attachments matching the \c shouldRemove predicate.
    1178        2976 :   template <class PredTy> void remove_if(PredTy shouldRemove) {
    1179        5952 :     Attachments.erase(llvm::remove_if(Attachments, shouldRemove),
    1180             :                       Attachments.end());
    1181        2976 :   }
    1182             : };
    1183             : 
    1184             : /// Multimap-like storage for metadata attachments for globals. This differs
    1185             : /// from MDAttachmentMap in that it allows multiple attachments per metadata
    1186             : /// kind.
    1187      183292 : class MDGlobalAttachmentMap {
    1188      275362 :   struct Attachment {
    1189             :     unsigned MDKind;
    1190             :     TrackingMDNodeRef Node;
    1191             :   };
    1192             :   SmallVector<Attachment, 1> Attachments;
    1193             : 
    1194             : public:
    1195        2781 :   bool empty() const { return Attachments.empty(); }
    1196             : 
    1197             :   /// Appends all attachments with the given ID to \c Result in insertion order.
    1198             :   /// If the global has no attachments with the given ID, or if ID is invalid,
    1199             :   /// leaves Result unchanged.
    1200             :   void get(unsigned ID, SmallVectorImpl<MDNode *> &Result) const;
    1201             : 
    1202             :   /// Returns the first attachment with the given ID or nullptr if no such
    1203             :   /// attachment exists.
    1204             :   MDNode *lookup(unsigned ID) const;
    1205             : 
    1206             :   void insert(unsigned ID, MDNode &MD);
    1207             :   bool erase(unsigned ID);
    1208             : 
    1209             :   /// Appends all attachments for the global to \c Result, sorting by attachment
    1210             :   /// ID. Attachments with the same ID appear in insertion order. This function
    1211             :   /// does \em not clear \c Result.
    1212             :   void getAll(SmallVectorImpl<std::pair<unsigned, MDNode *>> &Result) const;
    1213             : };
    1214             : 
    1215             : class LLVMContextImpl {
    1216             : public:
    1217             :   /// OwnedModules - The set of modules instantiated in this context, and which
    1218             :   /// will be automatically deleted if this context is deleted.
    1219             :   SmallPtrSet<Module*, 4> OwnedModules;
    1220             :   
    1221             :   LLVMContext::InlineAsmDiagHandlerTy InlineAsmDiagHandler = nullptr;
    1222             :   void *InlineAsmDiagContext = nullptr;
    1223             : 
    1224             :   std::unique_ptr<DiagnosticHandler> DiagHandler;
    1225             :   bool RespectDiagnosticFilters = false;
    1226             :   bool DiagnosticsHotnessRequested = false;
    1227             :   uint64_t DiagnosticsHotnessThreshold = 0;
    1228             :   std::unique_ptr<yaml::Output> DiagnosticsOutputFile;
    1229             : 
    1230             :   LLVMContext::YieldCallbackTy YieldCallback = nullptr;
    1231             :   void *YieldOpaqueHandle = nullptr;
    1232             : 
    1233             :   using IntMapTy =
    1234             :       DenseMap<APInt, std::unique_ptr<ConstantInt>, DenseMapAPIntKeyInfo>;
    1235             :   IntMapTy IntConstants;
    1236             : 
    1237             :   using FPMapTy =
    1238             :       DenseMap<APFloat, std::unique_ptr<ConstantFP>, DenseMapAPFloatKeyInfo>;
    1239             :   FPMapTy FPConstants;
    1240             : 
    1241             :   FoldingSet<AttributeImpl> AttrsSet;
    1242             :   FoldingSet<AttributeListImpl> AttrsLists;
    1243             :   FoldingSet<AttributeSetNode> AttrsSetNodes;
    1244             : 
    1245             :   StringMap<MDString, BumpPtrAllocator> MDStringCache;
    1246             :   DenseMap<Value *, ValueAsMetadata *> ValuesAsMetadata;
    1247             :   DenseMap<Metadata *, MetadataAsValue *> MetadataAsValues;
    1248             : 
    1249             :   DenseMap<const Value*, ValueName*> ValueNames;
    1250             : 
    1251             : #define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS)                                    \
    1252             :   DenseSet<CLASS *, CLASS##Info> CLASS##s;
    1253             : #include "llvm/IR/Metadata.def"
    1254             : 
    1255             :   // Optional map for looking up composite types by identifier.
    1256             :   Optional<DenseMap<const MDString *, DICompositeType *>> DITypeMap;
    1257             : 
    1258             :   // MDNodes may be uniqued or not uniqued.  When they're not uniqued, they
    1259             :   // aren't in the MDNodeSet, but they're still shared between objects, so no
    1260             :   // one object can destroy them.  Keep track of them here so we can delete
    1261             :   // them on context teardown.
    1262             :   std::vector<MDNode *> DistinctMDNodes;
    1263             : 
    1264             :   DenseMap<Type *, std::unique_ptr<ConstantAggregateZero>> CAZConstants;
    1265             : 
    1266             :   using ArrayConstantsTy = ConstantUniqueMap<ConstantArray>;
    1267             :   ArrayConstantsTy ArrayConstants;
    1268             :   
    1269             :   using StructConstantsTy = ConstantUniqueMap<ConstantStruct>;
    1270             :   StructConstantsTy StructConstants;
    1271             :   
    1272             :   using VectorConstantsTy = ConstantUniqueMap<ConstantVector>;
    1273             :   VectorConstantsTy VectorConstants;
    1274             : 
    1275             :   DenseMap<PointerType *, std::unique_ptr<ConstantPointerNull>> CPNConstants;
    1276             : 
    1277             :   DenseMap<Type *, std::unique_ptr<UndefValue>> UVConstants;
    1278             : 
    1279             :   StringMap<ConstantDataSequential*> CDSConstants;
    1280             : 
    1281             :   DenseMap<std::pair<const Function *, const BasicBlock *>, BlockAddress *>
    1282             :     BlockAddresses;
    1283             :   ConstantUniqueMap<ConstantExpr> ExprConstants;
    1284             : 
    1285             :   ConstantUniqueMap<InlineAsm> InlineAsms;
    1286             : 
    1287             :   ConstantInt *TheTrueVal = nullptr;
    1288             :   ConstantInt *TheFalseVal = nullptr;
    1289             : 
    1290             :   std::unique_ptr<ConstantTokenNone> TheNoneToken;
    1291             : 
    1292             :   // Basic type instances.
    1293             :   Type VoidTy, LabelTy, HalfTy, FloatTy, DoubleTy, MetadataTy, TokenTy;
    1294             :   Type X86_FP80Ty, FP128Ty, PPC_FP128Ty, X86_MMXTy;
    1295             :   IntegerType Int1Ty, Int8Ty, Int16Ty, Int32Ty, Int64Ty, Int128Ty;
    1296             :   
    1297             :   /// TypeAllocator - All dynamically allocated types are allocated from this.
    1298             :   /// They live forever until the context is torn down.
    1299             :   BumpPtrAllocator TypeAllocator;
    1300             :   
    1301             :   DenseMap<unsigned, IntegerType*> IntegerTypes;
    1302             : 
    1303             :   using FunctionTypeSet = DenseSet<FunctionType *, FunctionTypeKeyInfo>;
    1304             :   FunctionTypeSet FunctionTypes;
    1305             :   using StructTypeSet = DenseSet<StructType *, AnonStructTypeKeyInfo>;
    1306             :   StructTypeSet AnonStructTypes;
    1307             :   StringMap<StructType*> NamedStructTypes;
    1308             :   unsigned NamedStructTypesUniqueID = 0;
    1309             :     
    1310             :   DenseMap<std::pair<Type *, uint64_t>, ArrayType*> ArrayTypes;
    1311             :   DenseMap<std::pair<Type *, unsigned>, VectorType*> VectorTypes;
    1312             :   DenseMap<Type*, PointerType*> PointerTypes;  // Pointers in AddrSpace = 0
    1313             :   DenseMap<std::pair<Type*, unsigned>, PointerType*> ASPointerTypes;
    1314             : 
    1315             :   /// ValueHandles - This map keeps track of all of the value handles that are
    1316             :   /// watching a Value*.  The Value::HasValueHandle bit is used to know
    1317             :   /// whether or not a value has an entry in this map.
    1318             :   using ValueHandlesTy = DenseMap<Value *, ValueHandleBase *>;
    1319             :   ValueHandlesTy ValueHandles;
    1320             :   
    1321             :   /// CustomMDKindNames - Map to hold the metadata string to ID mapping.
    1322             :   StringMap<unsigned> CustomMDKindNames;
    1323             : 
    1324             :   /// Collection of per-instruction metadata used in this context.
    1325             :   DenseMap<const Instruction *, MDAttachmentMap> InstructionMetadata;
    1326             : 
    1327             :   /// Collection of per-GlobalObject metadata used in this context.
    1328             :   DenseMap<const GlobalObject *, MDGlobalAttachmentMap> GlobalObjectMetadata;
    1329             : 
    1330             :   /// Collection of per-GlobalObject sections used in this context.
    1331             :   DenseMap<const GlobalObject *, StringRef> GlobalObjectSections;
    1332             : 
    1333             :   /// Stable collection of section strings.
    1334             :   StringSet<> SectionStrings;
    1335             : 
    1336             :   /// DiscriminatorTable - This table maps file:line locations to an
    1337             :   /// integer representing the next DWARF path discriminator to assign to
    1338             :   /// instructions in different blocks at the same location.
    1339             :   DenseMap<std::pair<const char *, unsigned>, unsigned> DiscriminatorTable;
    1340             : 
    1341             :   int getOrAddScopeRecordIdxEntry(MDNode *N, int ExistingIdx);
    1342             :   int getOrAddScopeInlinedAtIdxEntry(MDNode *Scope, MDNode *IA,int ExistingIdx);
    1343             : 
    1344             :   /// A set of interned tags for operand bundles.  The StringMap maps
    1345             :   /// bundle tags to their IDs.
    1346             :   ///
    1347             :   /// \see LLVMContext::getOperandBundleTagID
    1348             :   StringMap<uint32_t> BundleTagCache;
    1349             : 
    1350             :   StringMapEntry<uint32_t> *getOrInsertBundleTag(StringRef Tag);
    1351             :   void getOperandBundleTags(SmallVectorImpl<StringRef> &Tags) const;
    1352             :   uint32_t getOperandBundleTagID(StringRef Tag) const;
    1353             : 
    1354             :   /// A set of interned synchronization scopes.  The StringMap maps
    1355             :   /// synchronization scope names to their respective synchronization scope IDs.
    1356             :   StringMap<SyncScope::ID> SSC;
    1357             : 
    1358             :   /// getOrInsertSyncScopeID - Maps synchronization scope name to
    1359             :   /// synchronization scope ID.  Every synchronization scope registered with
    1360             :   /// LLVMContext has unique ID except pre-defined ones.
    1361             :   SyncScope::ID getOrInsertSyncScopeID(StringRef SSN);
    1362             : 
    1363             :   /// getSyncScopeNames - Populates client supplied SmallVector with
    1364             :   /// synchronization scope names registered with LLVMContext.  Synchronization
    1365             :   /// scope names are ordered by increasing synchronization scope IDs.
    1366             :   void getSyncScopeNames(SmallVectorImpl<StringRef> &SSNs) const;
    1367             : 
    1368             :   /// Maintain the GC name for each function.
    1369             :   ///
    1370             :   /// This saves allocating an additional word in Function for programs which
    1371             :   /// do not use GC (i.e., most programs) at the cost of increased overhead for
    1372             :   /// clients which do use GC.
    1373             :   DenseMap<const Function*, std::string> GCNames;
    1374             : 
    1375             :   /// Flag to indicate if Value (other than GlobalValue) retains their name or
    1376             :   /// not.
    1377             :   bool DiscardValueNames = false;
    1378             : 
    1379             :   LLVMContextImpl(LLVMContext &C);
    1380             :   ~LLVMContextImpl();
    1381             : 
    1382             :   /// Destroy the ConstantArrays if they are not used.
    1383             :   void dropTriviallyDeadConstantArrays();
    1384             : 
    1385             :   mutable OptPassGate *OPG = nullptr;
    1386             : 
    1387             :   /// Access the object which can disable optional passes and individual
    1388             :   /// optimizations at compile time.
    1389             :   OptPassGate &getOptPassGate() const;
    1390             : 
    1391             :   /// Set the object which can disable optional passes and individual
    1392             :   /// optimizations at compile time.
    1393             :   ///
    1394             :   /// The lifetime of the object must be guaranteed to extend as long as the
    1395             :   /// LLVMContext is used by compilation.
    1396             :   void setOptPassGate(OptPassGate&);
    1397             : };
    1398             : 
    1399             : } // end namespace llvm
    1400             : 
    1401             : #endif // LLVM_LIB_IR_LLVMCONTEXTIMPL_H

Generated by: LCOV version 1.13