LCOV - code coverage report
Current view: top level - lib/IR - Metadata.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 601 636 94.5 %
Date: 2018-07-13 00:08:38 Functions: 133 138 96.4 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- Metadata.cpp - Implement Metadata classes --------------------------===//
       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 implements the Metadata classes.
      11             : //
      12             : //===----------------------------------------------------------------------===//
      13             : 
      14             : #include "LLVMContextImpl.h"
      15             : #include "MetadataImpl.h"
      16             : #include "SymbolTableListTraitsImpl.h"
      17             : #include "llvm/ADT/APFloat.h"
      18             : #include "llvm/ADT/APInt.h"
      19             : #include "llvm/ADT/ArrayRef.h"
      20             : #include "llvm/ADT/DenseSet.h"
      21             : #include "llvm/ADT/None.h"
      22             : #include "llvm/ADT/STLExtras.h"
      23             : #include "llvm/ADT/SetVector.h"
      24             : #include "llvm/ADT/SmallPtrSet.h"
      25             : #include "llvm/ADT/SmallSet.h"
      26             : #include "llvm/ADT/SmallVector.h"
      27             : #include "llvm/ADT/StringMap.h"
      28             : #include "llvm/ADT/StringRef.h"
      29             : #include "llvm/ADT/Twine.h"
      30             : #include "llvm/IR/Argument.h"
      31             : #include "llvm/IR/BasicBlock.h"
      32             : #include "llvm/IR/Constant.h"
      33             : #include "llvm/IR/ConstantRange.h"
      34             : #include "llvm/IR/Constants.h"
      35             : #include "llvm/IR/DebugInfoMetadata.h"
      36             : #include "llvm/IR/DebugLoc.h"
      37             : #include "llvm/IR/Function.h"
      38             : #include "llvm/IR/GlobalObject.h"
      39             : #include "llvm/IR/GlobalVariable.h"
      40             : #include "llvm/IR/Instruction.h"
      41             : #include "llvm/IR/LLVMContext.h"
      42             : #include "llvm/IR/Metadata.h"
      43             : #include "llvm/IR/Module.h"
      44             : #include "llvm/IR/TrackingMDRef.h"
      45             : #include "llvm/IR/Type.h"
      46             : #include "llvm/IR/Value.h"
      47             : #include "llvm/IR/ValueHandle.h"
      48             : #include "llvm/Support/Casting.h"
      49             : #include "llvm/Support/ErrorHandling.h"
      50             : #include "llvm/Support/MathExtras.h"
      51             : #include <algorithm>
      52             : #include <cassert>
      53             : #include <cstddef>
      54             : #include <cstdint>
      55             : #include <iterator>
      56             : #include <tuple>
      57             : #include <type_traits>
      58             : #include <utility>
      59             : #include <vector>
      60             : 
      61             : using namespace llvm;
      62             : 
      63      181961 : MetadataAsValue::MetadataAsValue(Type *Ty, Metadata *MD)
      64      181961 :     : Value(Ty, MetadataAsValueVal), MD(MD) {
      65      181961 :   track();
      66      181961 : }
      67             : 
      68      107552 : MetadataAsValue::~MetadataAsValue() {
      69       53776 :   getType()->getContext().pImpl->MetadataAsValues.erase(MD);
      70       53776 :   untrack();
      71       53776 : }
      72             : 
      73             : /// Canonicalize metadata arguments to intrinsics.
      74             : ///
      75             : /// To support bitcode upgrades (and assembly semantic sugar) for \a
      76             : /// MetadataAsValue, we need to canonicalize certain metadata.
      77             : ///
      78             : ///   - nullptr is replaced by an empty MDNode.
      79             : ///   - An MDNode with a single null operand is replaced by an empty MDNode.
      80             : ///   - An MDNode whose only operand is a \a ConstantAsMetadata gets skipped.
      81             : ///
      82             : /// This maintains readability of bitcode from when metadata was a type of
      83             : /// value, and these bridges were unnecessary.
      84      442417 : static Metadata *canonicalizeMetadataForValue(LLVMContext &Context,
      85             :                                               Metadata *MD) {
      86      442417 :   if (!MD)
      87             :     // !{}
      88             :     return MDNode::get(Context, None);
      89             : 
      90             :   // Return early if this isn't a single-operand MDNode.
      91             :   auto *N = dyn_cast<MDNode>(MD);
      92      191067 :   if (!N || N->getNumOperands() != 1)
      93             :     return MD;
      94             : 
      95         748 :   if (!N->getOperand(0))
      96             :     // !{}
      97             :     return MDNode::get(Context, None);
      98             : 
      99             :   if (auto *C = dyn_cast<ConstantAsMetadata>(N->getOperand(0)))
     100             :     // Look through the MDNode.
     101             :     return C;
     102             : 
     103         488 :   return MD;
     104             : }
     105             : 
     106      356531 : MetadataAsValue *MetadataAsValue::get(LLVMContext &Context, Metadata *MD) {
     107      356531 :   MD = canonicalizeMetadataForValue(Context, MD);
     108      356531 :   auto *&Entry = Context.pImpl->MetadataAsValues[MD];
     109      356531 :   if (!Entry)
     110      181961 :     Entry = new MetadataAsValue(Type::getMetadataTy(Context), MD);
     111      356531 :   return Entry;
     112             : }
     113             : 
     114       39286 : MetadataAsValue *MetadataAsValue::getIfExists(LLVMContext &Context,
     115             :                                               Metadata *MD) {
     116       39286 :   MD = canonicalizeMetadataForValue(Context, MD);
     117       39286 :   auto &Store = Context.pImpl->MetadataAsValues;
     118       39286 :   return Store.lookup(MD);
     119             : }
     120             : 
     121       46600 : void MetadataAsValue::handleChangedMetadata(Metadata *MD) {
     122       46600 :   LLVMContext &Context = getContext();
     123       46600 :   MD = canonicalizeMetadataForValue(Context, MD);
     124       46600 :   auto &Store = Context.pImpl->MetadataAsValues;
     125             : 
     126             :   // Stop tracking the old metadata.
     127       46600 :   Store.erase(this->MD);
     128       46600 :   untrack();
     129       46600 :   this->MD = nullptr;
     130             : 
     131             :   // Start tracking MD, or RAUW if necessary.
     132             :   auto *&Entry = Store[MD];
     133       46600 :   if (Entry) {
     134       42179 :     replaceAllUsesWith(Entry);
     135       42179 :     delete this;
     136             :     return;
     137             :   }
     138             : 
     139        4421 :   this->MD = MD;
     140        4421 :   track();
     141        4421 :   Entry = this;
     142             : }
     143             : 
     144      186382 : void MetadataAsValue::track() {
     145      186382 :   if (MD)
     146      186382 :     MetadataTracking::track(&MD, *MD, *this);
     147      186382 : }
     148             : 
     149      100376 : void MetadataAsValue::untrack() {
     150      100376 :   if (MD)
     151       46600 :     MetadataTracking::untrack(MD);
     152      100376 : }
     153             : 
     154   119070127 : bool MetadataTracking::track(void *Ref, Metadata &MD, OwnerTy Owner) {
     155             :   assert(Ref && "Expected live reference");
     156             :   assert((Owner || *static_cast<Metadata **>(Ref) == &MD) &&
     157             :          "Reference without owner must be direct");
     158   119070127 :   if (auto *R = ReplaceableMetadataImpl::getOrCreate(MD)) {
     159     1273712 :     R->addRef(Ref, Owner);
     160     1273712 :     return true;
     161             :   }
     162             :   if (auto *PH = dyn_cast<DistinctMDOperandPlaceholder>(&MD)) {
     163             :     assert(!PH->Use && "Placeholders can only be used once");
     164             :     assert(!Owner && "Unexpected callback to owner");
     165        2604 :     PH->Use = static_cast<Metadata **>(Ref);
     166        2604 :     return true;
     167             :   }
     168             :   return false;
     169             : }
     170             : 
     171    99753747 : void MetadataTracking::untrack(void *Ref, Metadata &MD) {
     172             :   assert(Ref && "Expected live reference");
     173    99753747 :   if (auto *R = ReplaceableMetadataImpl::getIfExists(MD))
     174      365027 :     R->dropRef(Ref);
     175             :   else if (auto *PH = dyn_cast<DistinctMDOperandPlaceholder>(&MD))
     176        2604 :     PH->Use = nullptr;
     177    99753747 : }
     178             : 
     179    69791046 : bool MetadataTracking::retrack(void *Ref, Metadata &MD, void *New) {
     180             :   assert(Ref && "Expected live reference");
     181             :   assert(New && "Expected live reference");
     182             :   assert(Ref != New && "Expected change");
     183    69791046 :   if (auto *R = ReplaceableMetadataImpl::getIfExists(MD)) {
     184      277415 :     R->moveRef(Ref, New, MD);
     185      277415 :     return true;
     186             :   }
     187             :   assert(!isa<DistinctMDOperandPlaceholder>(MD) &&
     188             :          "Unexpected move of an MDOperand");
     189             :   assert(!isReplaceable(MD) &&
     190             :          "Expected un-replaceable metadata, since we didn't move a reference");
     191             :   return false;
     192             : }
     193             : 
     194           0 : bool MetadataTracking::isReplaceable(const Metadata &MD) {
     195           0 :   return ReplaceableMetadataImpl::isReplaceable(MD);
     196             : }
     197             : 
     198     1273712 : void ReplaceableMetadataImpl::addRef(void *Ref, OwnerTy Owner) {
     199             :   bool WasInserted =
     200     2547424 :       UseMap.insert(std::make_pair(Ref, std::make_pair(Owner, NextIndex)))
     201             :           .second;
     202             :   (void)WasInserted;
     203             :   assert(WasInserted && "Expected to add a reference");
     204             : 
     205     1273712 :   ++NextIndex;
     206             :   assert(NextIndex != 0 && "Unexpected overflow");
     207     1273712 : }
     208             : 
     209      365027 : void ReplaceableMetadataImpl::dropRef(void *Ref) {
     210      365027 :   bool WasErased = UseMap.erase(Ref);
     211             :   (void)WasErased;
     212             :   assert(WasErased && "Expected to drop a reference");
     213      365027 : }
     214             : 
     215      277415 : void ReplaceableMetadataImpl::moveRef(void *Ref, void *New,
     216             :                                       const Metadata &MD) {
     217      277415 :   auto I = UseMap.find(Ref);
     218             :   assert(I != UseMap.end() && "Expected to move a reference");
     219      277415 :   auto OwnerAndIndex = I->second;
     220             :   UseMap.erase(I);
     221      277415 :   bool WasInserted = UseMap.insert(std::make_pair(New, OwnerAndIndex)).second;
     222             :   (void)WasInserted;
     223             :   assert(WasInserted && "Expected to add a reference");
     224             : 
     225             :   // Check that the references are direct if there's no owner.
     226             :   (void)MD;
     227             :   assert((OwnerAndIndex.first || *static_cast<Metadata **>(Ref) == &MD) &&
     228             :          "Reference without owner must be direct");
     229             :   assert((OwnerAndIndex.first || *static_cast<Metadata **>(New) == &MD) &&
     230             :          "Reference without owner must be direct");
     231      277415 : }
     232             : 
     233      392783 : void ReplaceableMetadataImpl::replaceAllUsesWith(Metadata *MD) {
     234      392783 :   if (UseMap.empty())
     235      212876 :     return;
     236             : 
     237             :   // Copy out uses since UseMap will get touched below.
     238             :   using UseTy = std::pair<void *, std::pair<OwnerTy, uint64_t>>;
     239      179907 :   SmallVector<UseTy, 8> Uses(UseMap.begin(), UseMap.end());
     240             :   llvm::sort(Uses.begin(), Uses.end(), [](const UseTy &L, const UseTy &R) {
     241             :     return L.second.second < R.second.second;
     242             :   });
     243      744215 :   for (const auto &Pair : Uses) {
     244             :     // Check that this Ref hasn't disappeared after RAUW (when updating a
     245             :     // previous Ref).
     246      282154 :     if (!UseMap.count(Pair.first))
     247           0 :       continue;
     248             : 
     249      282154 :     OwnerTy Owner = Pair.second.first;
     250      282154 :     if (!Owner) {
     251             :       // Update unowned tracking references directly.
     252      187529 :       Metadata *&Ref = *static_cast<Metadata **>(Pair.first);
     253      187529 :       Ref = MD;
     254      187529 :       if (MD)
     255             :         MetadataTracking::track(Ref);
     256      187529 :       UseMap.erase(Pair.first);
     257      187529 :       continue;
     258             :     }
     259             : 
     260             :     // Check for MetadataAsValue.
     261      141225 :     if (Owner.is<MetadataAsValue *>()) {
     262       46600 :       Owner.get<MetadataAsValue *>()->handleChangedMetadata(MD);
     263       46600 :       continue;
     264             :     }
     265             : 
     266             :     // There's a Metadata owner -- dispatch.
     267             :     Metadata *OwnerMD = Owner.get<Metadata *>();
     268      144075 :     switch (OwnerMD->getMetadataID()) {
     269             : #define HANDLE_METADATA_LEAF(CLASS)                                            \
     270             :   case Metadata::CLASS##Kind:                                                  \
     271             :     cast<CLASS>(OwnerMD)->handleChangedOperand(Pair.first, MD);                \
     272             :     continue;
     273             : #include "llvm/IR/Metadata.def"
     274           0 :     default:
     275           0 :       llvm_unreachable("Invalid metadata subclass");
     276             :     }
     277             :   }
     278             :   assert(UseMap.empty() && "Expected all uses to be replaced");
     279             : }
     280             : 
     281      570731 : void ReplaceableMetadataImpl::resolveAllUses(bool ResolveUsers) {
     282      570731 :   if (UseMap.empty())
     283      211902 :     return;
     284             : 
     285      359247 :   if (!ResolveUsers) {
     286         418 :     UseMap.clear();
     287         418 :     return;
     288             :   }
     289             : 
     290             :   // Copy out uses since UseMap could get touched below.
     291             :   using UseTy = std::pair<void *, std::pair<OwnerTy, uint64_t>>;
     292      358829 :   SmallVector<UseTy, 8> Uses(UseMap.begin(), UseMap.end());
     293             :   llvm::sort(Uses.begin(), Uses.end(), [](const UseTy &L, const UseTy &R) {
     294             :     return L.second.second < R.second.second;
     295             :   });
     296      358829 :   UseMap.clear();
     297     1593523 :   for (const auto &Pair : Uses) {
     298      617347 :     auto Owner = Pair.second.first;
     299      617347 :     if (!Owner)
     300      348094 :       continue;
     301      269253 :     if (Owner.is<MetadataAsValue *>())
     302        3324 :       continue;
     303             : 
     304             :     // Resolve MDNodes that point at this.
     305             :     auto *OwnerMD = dyn_cast<MDNode>(Owner.get<Metadata *>());
     306           0 :     if (!OwnerMD)
     307           0 :       continue;
     308       30378 :     if (OwnerMD->isResolved())
     309       30378 :       continue;
     310      235551 :     OwnerMD->decrementUnresolvedOperandCount();
     311             :   }
     312             : }
     313             : 
     314   119070127 : ReplaceableMetadataImpl *ReplaceableMetadataImpl::getOrCreate(Metadata &MD) {
     315             :   if (auto *N = dyn_cast<MDNode>(&MD))
     316     1004680 :     return N->isResolved() ? nullptr : N->Context.getOrCreateReplaceableUses();
     317      269032 :   return dyn_cast<ValueAsMetadata>(&MD);
     318             : }
     319             : 
     320   169544793 : ReplaceableMetadataImpl *ReplaceableMetadataImpl::getIfExists(Metadata &MD) {
     321             :   if (auto *N = dyn_cast<MDNode>(&MD))
     322             :     return N->isResolved() ? nullptr : N->Context.getReplaceableUses();
     323      172302 :   return dyn_cast<ValueAsMetadata>(&MD);
     324             : }
     325             : 
     326           0 : bool ReplaceableMetadataImpl::isReplaceable(const Metadata &MD) {
     327             :   if (auto *N = dyn_cast<MDNode>(&MD))
     328           0 :     return !N->isResolved();
     329           0 :   return dyn_cast<ValueAsMetadata>(&MD);
     330             : }
     331             : 
     332       25033 : static DISubprogram *getLocalFunctionMetadata(Value *V) {
     333             :   assert(V && "Expected value");
     334             :   if (auto *A = dyn_cast<Argument>(V)) {
     335        1714 :     if (auto *Fn = A->getParent())
     336        1092 :       return Fn->getSubprogram();
     337             :     return nullptr;
     338             :   }
     339             : 
     340       23319 :   if (BasicBlock *BB = cast<Instruction>(V)->getParent()) {
     341       22630 :     if (auto *Fn = BB->getParent())
     342       22630 :       return Fn->getSubprogram();
     343             :     return nullptr;
     344             :   }
     345             : 
     346             :   return nullptr;
     347             : }
     348             : 
     349      373899 : ValueAsMetadata *ValueAsMetadata::get(Value *V) {
     350             :   assert(V && "Unexpected null Value");
     351             : 
     352      373899 :   auto &Context = V->getContext();
     353      373899 :   auto *&Entry = Context.pImpl->ValuesAsMetadata[V];
     354      373899 :   if (!Entry) {
     355             :     assert((isa<Constant>(V) || isa<Argument>(V) || isa<Instruction>(V)) &&
     356             :            "Expected constant or function-local value");
     357             :     assert(!V->IsUsedByMD && "Expected this to be the only metadata use");
     358      185544 :     V->IsUsedByMD = true;
     359             :     if (auto *C = dyn_cast<Constant>(V))
     360      162044 :       Entry = new ConstantAsMetadata(C);
     361             :     else
     362      209044 :       Entry = new LocalAsMetadata(V);
     363             :   }
     364             : 
     365      373899 :   return Entry;
     366             : }
     367             : 
     368       39573 : ValueAsMetadata *ValueAsMetadata::getIfExists(Value *V) {
     369             :   assert(V && "Unexpected null Value");
     370       79146 :   return V->getContext().pImpl->ValuesAsMetadata.lookup(V);
     371             : }
     372             : 
     373      103083 : void ValueAsMetadata::handleDeletion(Value *V) {
     374             :   assert(V && "Expected valid value");
     375             : 
     376      103083 :   auto &Store = V->getType()->getContext().pImpl->ValuesAsMetadata;
     377      103083 :   auto I = Store.find(V);
     378      103083 :   if (I == Store.end())
     379           1 :     return;
     380             : 
     381             :   // Remove old entry from the map.
     382      103082 :   ValueAsMetadata *MD = I->second;
     383             :   assert(MD && "Expected valid metadata");
     384             :   assert(MD->getValue() == V && "Expected valid mapping");
     385             :   Store.erase(I);
     386             : 
     387             :   // Delete the metadata.
     388             :   MD->replaceAllUsesWith(nullptr);
     389      206164 :   delete MD;
     390             : }
     391             : 
     392        9907 : void ValueAsMetadata::handleRAUW(Value *From, Value *To) {
     393             :   assert(From && "Expected valid value");
     394             :   assert(To && "Expected valid value");
     395             :   assert(From != To && "Expected changed value");
     396             :   assert(From->getType() == To->getType() && "Unexpected type change");
     397             : 
     398        9907 :   LLVMContext &Context = From->getType()->getContext();
     399        9907 :   auto &Store = Context.pImpl->ValuesAsMetadata;
     400        9907 :   auto I = Store.find(From);
     401        9907 :   if (I == Store.end()) {
     402             :     assert(!From->IsUsedByMD && "Expected From not to be used by metadata");
     403        5074 :     return;
     404             :   }
     405             : 
     406             :   // Remove old entry from the map.
     407             :   assert(From->IsUsedByMD && "Expected From to be used by metadata");
     408        9907 :   From->IsUsedByMD = false;
     409        9907 :   ValueAsMetadata *MD = I->second;
     410             :   assert(MD && "Expected valid metadata");
     411             :   assert(MD->getValue() == From && "Expected valid mapping");
     412             :   Store.erase(I);
     413             : 
     414        9907 :   if (isa<LocalAsMetadata>(MD)) {
     415        9752 :     if (auto *C = dyn_cast<Constant>(To)) {
     416             :       // Local became a constant.
     417             :       MD->replaceAllUsesWith(ConstantAsMetadata::get(C));
     418        2596 :       delete MD;
     419             :       return;
     420             :     }
     421       12876 :     if (getLocalFunctionMetadata(From) && getLocalFunctionMetadata(To) &&
     422        5720 :         getLocalFunctionMetadata(From) != getLocalFunctionMetadata(To)) {
     423             :       // DISubprogram changed.
     424             :       MD->replaceAllUsesWith(nullptr);
     425           0 :       delete MD;
     426             :       return;
     427             :     }
     428         310 :   } else if (!isa<Constant>(To)) {
     429             :     // Changed to function-local value.
     430             :     MD->replaceAllUsesWith(nullptr);
     431           1 :     delete MD;
     432             :     return;
     433             :   }
     434             : 
     435             :   auto *&Entry = Store[To];
     436        7310 :   if (Entry) {
     437             :     // The target already exists.
     438             :     MD->replaceAllUsesWith(Entry);
     439        2477 :     delete MD;
     440             :     return;
     441             :   }
     442             : 
     443             :   // Update MD in place (and update the map entry).
     444             :   assert(!To->IsUsedByMD && "Expected this to be the only metadata use");
     445        4833 :   To->IsUsedByMD = true;
     446        4833 :   MD->V = To;
     447        4833 :   Entry = MD;
     448             : }
     449             : 
     450             : //===----------------------------------------------------------------------===//
     451             : // MDString implementation.
     452             : //
     453             : 
     454     1095830 : MDString *MDString::get(LLVMContext &Context, StringRef Str) {
     455     1095830 :   auto &Store = Context.pImpl->MDStringCache;
     456     1095830 :   auto I = Store.try_emplace(Str);
     457             :   auto &MapEntry = I.first->getValue();
     458     1095830 :   if (!I.second)
     459             :     return &MapEntry;
     460      652822 :   MapEntry.Entry = &*I.first;
     461      652822 :   return &MapEntry;
     462             : }
     463             : 
     464    14150298 : StringRef MDString::getString() const {
     465             :   assert(Entry && "Expected to find string map entry");
     466    28300596 :   return Entry->first();
     467             : }
     468             : 
     469             : //===----------------------------------------------------------------------===//
     470             : // MDNode implementation.
     471             : //
     472             : 
     473             : // Assert that the MDNode types will not be unaligned by the objects
     474             : // prepended to them.
     475             : #define HANDLE_MDNODE_LEAF(CLASS)                                              \
     476             :   static_assert(                                                               \
     477             :       alignof(uint64_t) >= alignof(CLASS),                                     \
     478             :       "Alignment is insufficient after objects prepended to " #CLASS);
     479             : #include "llvm/IR/Metadata.def"
     480             : 
     481     3318130 : void *MDNode::operator new(size_t Size, unsigned NumOps) {
     482     3318130 :   size_t OpSize = NumOps * sizeof(MDOperand);
     483             :   // uint64_t is the most aligned type we need support (ensured by static_assert
     484             :   // above)
     485             :   OpSize = alignTo(OpSize, alignof(uint64_t));
     486     3318130 :   void *Ptr = reinterpret_cast<char *>(::operator new(OpSize + Size)) + OpSize;
     487             :   MDOperand *O = static_cast<MDOperand *>(Ptr);
     488     3318130 :   for (MDOperand *E = O - NumOps; O != E; --O)
     489    10659162 :     (void)new (O - 1) MDOperand;
     490     3318130 :   return Ptr;
     491             : }
     492             : 
     493      491362 : void MDNode::operator delete(void *Mem) {
     494             :   MDNode *N = static_cast<MDNode *>(Mem);
     495      491362 :   size_t OpSize = N->NumOperands * sizeof(MDOperand);
     496             :   OpSize = alignTo(OpSize, alignof(uint64_t));
     497             : 
     498             :   MDOperand *O = static_cast<MDOperand *>(Mem);
     499     1904669 :   for (MDOperand *E = O - N->NumOperands; O != E; --O)
     500     1413307 :     (O - 1)->~MDOperand();
     501      491362 :   ::operator delete(reinterpret_cast<char *>(Mem) - OpSize);
     502      491362 : }
     503             : 
     504     3318130 : MDNode::MDNode(LLVMContext &Context, unsigned ID, StorageType Storage,
     505     3318130 :                ArrayRef<Metadata *> Ops1, ArrayRef<Metadata *> Ops2)
     506     3318130 :     : Metadata(ID, Storage), NumOperands(Ops1.size() + Ops2.size()),
     507     3318130 :       NumUnresolved(0), Context(Context) {
     508             :   unsigned Op = 0;
     509    24636384 :   for (Metadata *MD : Ops1)
     510    10659127 :     setOperand(Op++, MD);
     511     3318200 :   for (Metadata *MD : Ops2)
     512          35 :     setOperand(Op++, MD);
     513             : 
     514     3318130 :   if (!isUniqued())
     515             :     return;
     516             : 
     517             :   // Count the unresolved operands.  If there are any, RAUW support will be
     518             :   // added lazily on first reference.
     519     2611096 :   countUnresolvedOperands();
     520             : }
     521             : 
     522      178077 : TempMDNode MDNode::clone() const {
     523      356154 :   switch (getMetadataID()) {
     524           0 :   default:
     525           0 :     llvm_unreachable("Invalid MDNode subclass");
     526             : #define HANDLE_MDNODE_LEAF(CLASS)                                              \
     527             :   case CLASS##Kind:                                                            \
     528             :     return cast<CLASS>(this)->cloneImpl();
     529             : #include "llvm/IR/Metadata.def"
     530             :   }
     531             : }
     532             : 
     533     8568100 : static bool isOperandUnresolved(Metadata *Op) {
     534             :   if (auto *N = dyn_cast_or_null<MDNode>(Op))
     535     4853261 :     return !N->isResolved();
     536             :   return false;
     537             : }
     538             : 
     539     2706782 : void MDNode::countUnresolvedOperands() {
     540             :   assert(NumUnresolved == 0 && "Expected unresolved ops to be uncounted");
     541             :   assert(isUniqued() && "Expected this to be uniqued");
     542     2706782 :   NumUnresolved = count_if(operands(), isOperandUnresolved);
     543     2706782 : }
     544             : 
     545       95686 : void MDNode::makeUniqued() {
     546             :   assert(isTemporary() && "Expected this to be temporary");
     547             :   assert(!isResolved() && "Expected this to be unresolved");
     548             : 
     549             :   // Enable uniquing callbacks.
     550     1503498 :   for (auto &Op : mutable_operands())
     551     1407812 :     Op.reset(Op.get(), this);
     552             : 
     553             :   // Make this 'uniqued'.
     554       95686 :   Storage = Uniqued;
     555       95686 :   countUnresolvedOperands();
     556       95686 :   if (!NumUnresolved) {
     557       95416 :     dropReplaceableUses();
     558             :     assert(isResolved() && "Expected this to be resolved");
     559             :   }
     560             : 
     561             :   assert(isUniqued() && "Expected this to be uniqued");
     562       95686 : }
     563             : 
     564       31974 : void MDNode::makeDistinct() {
     565             :   assert(isTemporary() && "Expected this to be temporary");
     566             :   assert(!isResolved() && "Expected this to be unresolved");
     567             : 
     568             :   // Drop RAUW support and store as a distinct node.
     569       31974 :   dropReplaceableUses();
     570       31974 :   storeDistinctInContext();
     571             : 
     572             :   assert(isDistinct() && "Expected this to be distinct");
     573             :   assert(isResolved() && "Expected this to be resolved");
     574       31974 : }
     575             : 
     576       30298 : void MDNode::resolve() {
     577             :   assert(isUniqued() && "Expected this to be uniqued");
     578             :   assert(!isResolved() && "Expected this to be unresolved");
     579             : 
     580       30298 :   NumUnresolved = 0;
     581       30298 :   dropReplaceableUses();
     582             : 
     583             :   assert(isResolved() && "Expected this to be resolved");
     584       30298 : }
     585             : 
     586      380420 : void MDNode::dropReplaceableUses() {
     587             :   assert(!NumUnresolved && "Unexpected unresolved operand");
     588             : 
     589             :   // Drop any RAUW support.
     590      380420 :   if (Context.hasReplaceableUses())
     591      358829 :     Context.takeReplaceableUses()->resolveAllUses();
     592      380420 : }
     593             : 
     594       39462 : void MDNode::resolveAfterOperandChange(Metadata *Old, Metadata *New) {
     595             :   assert(isUniqued() && "Expected this to be uniqued");
     596             :   assert(NumUnresolved != 0 && "Expected unresolved operands");
     597             : 
     598             :   // Check if an operand was resolved.
     599       39461 :   if (!isOperandUnresolved(Old)) {
     600           2 :     if (isOperandUnresolved(New))
     601             :       // An operand was un-resolved!
     602           1 :       ++NumUnresolved;
     603       39228 :   } else if (!isOperandUnresolved(New))
     604       29222 :     decrementUnresolvedOperandCount();
     605       39462 : }
     606             : 
     607      264773 : void MDNode::decrementUnresolvedOperandCount() {
     608             :   assert(!isResolved() && "Expected this to be unresolved");
     609      264773 :   if (isTemporary())
     610             :     return;
     611             : 
     612             :   assert(isUniqued() && "Expected this to be uniqued");
     613      264773 :   if (--NumUnresolved)
     614             :     return;
     615             : 
     616             :   // Last unresolved operand has just been resolved.
     617      222732 :   dropReplaceableUses();
     618             :   assert(isResolved() && "Expected this to become resolved");
     619             : }
     620             : 
     621        1989 : void MDNode::resolveCycles() {
     622             :   if (isResolved())
     623             :     return;
     624             : 
     625             :   // Resolve this node immediately.
     626         642 :   resolve();
     627             : 
     628             :   // Resolve all operands.
     629        8614 :   for (const auto &Op : operands()) {
     630             :     auto *N = dyn_cast_or_null<MDNode>(Op);
     631        2531 :     if (!N)
     632        2531 :       continue;
     633             : 
     634             :     assert(!N->isTemporary() &&
     635             :            "Expected all forward declarations to be resolved");
     636             :     if (!N->isResolved())
     637         449 :       N->resolveCycles();
     638             :   }
     639             : }
     640             : 
     641             : static bool hasSelfReference(MDNode *N) {
     642           7 :   for (Metadata *MD : N->operands())
     643           3 :     if (MD == N)
     644             :       return true;
     645             :   return false;
     646             : }
     647             : 
     648           4 : MDNode *MDNode::replaceWithPermanentImpl() {
     649           4 :   switch (getMetadataID()) {
     650           1 :   default:
     651             :     // If this type isn't uniquable, replace with a distinct node.
     652           1 :     return replaceWithDistinctImpl();
     653             : 
     654             : #define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS)                                    \
     655             :   case CLASS##Kind:                                                            \
     656             :     break;
     657             : #include "llvm/IR/Metadata.def"
     658             :   }
     659             : 
     660             :   // Even if this type is uniquable, self-references have to be distinct.
     661           3 :   if (hasSelfReference(this))
     662           1 :     return replaceWithDistinctImpl();
     663           2 :   return replaceWithUniquedImpl();
     664             : }
     665             : 
     666      262126 : MDNode *MDNode::replaceWithUniquedImpl() {
     667             :   // Try to uniquify in place.
     668      262126 :   MDNode *UniquedNode = uniquify();
     669             : 
     670      262126 :   if (UniquedNode == this) {
     671       95686 :     makeUniqued();
     672       95686 :     return this;
     673             :   }
     674             : 
     675             :   // Collision, so RAUW instead.
     676             :   replaceAllUsesWith(UniquedNode);
     677      166440 :   deleteAsSubclass();
     678      166440 :   return UniquedNode;
     679             : }
     680             : 
     681       31974 : MDNode *MDNode::replaceWithDistinctImpl() {
     682       31974 :   makeDistinct();
     683       31974 :   return this;
     684             : }
     685             : 
     686       20197 : void MDTuple::recalculateHash() {
     687             :   setHash(MDTupleInfo::KeyTy::calculateHash(this));
     688       20197 : }
     689             : 
     690      444758 : void MDNode::dropAllReferences() {
     691     1277061 :   for (unsigned I = 0, E = NumOperands; I != E; ++I)
     692      832303 :     setOperand(I, nullptr);
     693      444758 :   if (Context.hasReplaceableUses()) {
     694      148510 :     Context.getReplaceableUses()->resolveAllUses(/* ResolveUsers */ false);
     695             :     (void)Context.takeReplaceableUses();
     696             :   }
     697      444758 : }
     698             : 
     699       75450 : void MDNode::handleChangedOperand(void *Ref, Metadata *New) {
     700      150900 :   unsigned Op = static_cast<MDOperand *>(Ref) - op_begin();
     701             :   assert(Op < getNumOperands() && "Expected valid operand");
     702             : 
     703       75450 :   if (!isUniqued()) {
     704             :     // This node is not uniqued.  Just set the operand and be done with it.
     705        2506 :     setOperand(Op, New);
     706        2506 :     return;
     707             :   }
     708             : 
     709             :   // This node is uniqued.
     710       72944 :   eraseFromStore();
     711             : 
     712             :   Metadata *Old = getOperand(Op);
     713       72944 :   setOperand(Op, New);
     714             : 
     715             :   // Drop uniquing for self-reference cycles and deleted constants.
     716       73899 :   if (New == this || (!New && Old && isa<ConstantAsMetadata>(Old))) {
     717             :     if (!isResolved())
     718       29656 :       resolve();
     719       33152 :     storeDistinctInContext();
     720       33152 :     return;
     721             :   }
     722             : 
     723             :   // Re-unique the node.
     724       39792 :   auto *Uniqued = uniquify();
     725       39792 :   if (Uniqued == this) {
     726             :     if (!isResolved())
     727       39462 :       resolveAfterOperandChange(Old, New);
     728             :     return;
     729             :   }
     730             : 
     731             :   // Collision.
     732             :   if (!isResolved()) {
     733             :     // Still unresolved, so RAUW.
     734             :     //
     735             :     // First, clear out all operands to prevent any recursion (similar to
     736             :     // dropAllReferences(), but we still need the use-list).
     737        1504 :     for (unsigned O = 0, E = getNumOperands(); O != E; ++O)
     738         585 :       setOperand(O, nullptr);
     739         167 :     if (Context.hasReplaceableUses())
     740         167 :       Context.getReplaceableUses()->replaceAllUsesWith(Uniqued);
     741         167 :     deleteAsSubclass();
     742         167 :     return;
     743             :   }
     744             : 
     745             :   // Store in non-uniqued form if RAUW isn't possible.
     746           7 :   storeDistinctInContext();
     747             : }
     748             : 
     749      346627 : void MDNode::deleteAsSubclass() {
     750      693254 :   switch (getMetadataID()) {
     751           0 :   default:
     752           0 :     llvm_unreachable("Invalid subclass of MDNode");
     753             : #define HANDLE_MDNODE_LEAF(CLASS)                                              \
     754             :   case CLASS##Kind:                                                            \
     755             :     delete cast<CLASS>(this);                                                  \
     756             :     break;
     757             : #include "llvm/IR/Metadata.def"
     758             :   }
     759      346627 : }
     760             : 
     761             : template <class T, class InfoT>
     762      301918 : static T *uniquifyImpl(T *N, DenseSet<T *, InfoT> &Store) {
     763      603836 :   if (T *U = getUniqued(Store, N))
     764             :     return U;
     765             : 
     766             :   Store.insert(N);
     767      135304 :   return N;
     768             : }
     769             : 
     770             : template <class NodeTy> struct MDNode::HasCachedHash {
     771             :   using Yes = char[1];
     772             :   using No = char[2];
     773             :   template <class U, U Val> struct SFINAE {};
     774             : 
     775             :   template <class U>
     776             :   static Yes &check(SFINAE<void (U::*)(unsigned), &U::setHash> *);
     777             :   template <class U> static No &check(...);
     778             : 
     779             :   static const bool value = sizeof(check<NodeTy>(nullptr)) == sizeof(Yes);
     780             : };
     781             : 
     782      301918 : MDNode *MDNode::uniquify() {
     783             :   assert(!hasSelfReference(this) && "Cannot uniquify a self-referencing node");
     784             : 
     785             :   // Try to insert into uniquing store.
     786      603836 :   switch (getMetadataID()) {
     787           0 :   default:
     788           0 :     llvm_unreachable("Invalid or non-uniquable subclass of MDNode");
     789             : #define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS)                                    \
     790             :   case CLASS##Kind: {                                                          \
     791             :     CLASS *SubclassThis = cast<CLASS>(this);                                   \
     792             :     std::integral_constant<bool, HasCachedHash<CLASS>::value>                  \
     793             :         ShouldRecalculateHash;                                                 \
     794             :     dispatchRecalculateHash(SubclassThis, ShouldRecalculateHash);              \
     795             :     return uniquifyImpl(SubclassThis, getContext().pImpl->CLASS##s);           \
     796             :   }
     797             : #include "llvm/IR/Metadata.def"
     798             :   }
     799             : }
     800             : 
     801       72944 : void MDNode::eraseFromStore() {
     802      145888 :   switch (getMetadataID()) {
     803           0 :   default:
     804           0 :     llvm_unreachable("Invalid or non-uniquable subclass of MDNode");
     805             : #define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS)                                    \
     806             :   case CLASS##Kind:                                                            \
     807             :     getContext().pImpl->CLASS##s.erase(cast<CLASS>(this));                     \
     808             :     break;
     809             : #include "llvm/IR/Metadata.def"
     810             :   }
     811       72944 : }
     812             : 
     813     1055302 : MDTuple *MDTuple::getImpl(LLVMContext &Context, ArrayRef<Metadata *> MDs,
     814             :                           StorageType Storage, bool ShouldCreate) {
     815             :   unsigned Hash = 0;
     816     1055302 :   if (Storage == Uniqued) {
     817             :     MDTupleInfo::KeyTy Key(MDs);
     818     1328474 :     if (auto *N = getUniqued(Context.pImpl->MDTuples, Key))
     819      424017 :       return N;
     820      480442 :     if (!ShouldCreate)
     821             :       return nullptr;
     822      480441 :     Hash = Key.getHash();
     823             :   } else {
     824             :     assert(ShouldCreate && "Expected non-uniqued nodes to always be created");
     825             :   }
     826             : 
     827      631285 :   return storeImpl(new (MDs.size()) MDTuple(Context, Storage, Hash, MDs),
     828     1262570 :                    Storage, Context.pImpl->MDTuples);
     829             : }
     830             : 
     831      149522 : void MDNode::deleteTemporary(MDNode *N) {
     832             :   assert(N->isTemporary() && "Expected temporary node");
     833             :   N->replaceAllUsesWith(nullptr);
     834      149522 :   N->deleteAsSubclass();
     835      149522 : }
     836             : 
     837      328545 : void MDNode::storeDistinctInContext() {
     838             :   assert(!Context.hasReplaceableUses() && "Unexpected replaceable uses");
     839             :   assert(!NumUnresolved && "Unexpected unresolved nodes");
     840      328545 :   Storage = Distinct;
     841             :   assert(isResolved() && "Expected this to be resolved");
     842             : 
     843             :   // Reset the hash.
     844      328545 :   switch (getMetadataID()) {
     845           0 :   default:
     846           0 :     llvm_unreachable("Invalid subclass of MDNode");
     847             : #define HANDLE_MDNODE_LEAF(CLASS)                                              \
     848             :   case CLASS##Kind: {                                                          \
     849             :     std::integral_constant<bool, HasCachedHash<CLASS>::value> ShouldResetHash; \
     850             :     dispatchResetHash(cast<CLASS>(this), ShouldResetHash);                     \
     851             :     break;                                                                     \
     852             :   }
     853             : #include "llvm/IR/Metadata.def"
     854             :   }
     855             : 
     856      657090 :   getContext().pImpl->DistinctMDNodes.push_back(this);
     857      328545 : }
     858             : 
     859      115025 : void MDNode::replaceOperandWith(unsigned I, Metadata *New) {
     860      115025 :   if (getOperand(I) == New)
     861             :     return;
     862             : 
     863       84650 :   if (!isUniqued()) {
     864       57225 :     setOperand(I, New);
     865       57225 :     return;
     866             :   }
     867             : 
     868       27425 :   handleChangedOperand(mutable_begin() + I, New);
     869             : }
     870             : 
     871    11624736 : void MDNode::setOperand(unsigned I, Metadata *New) {
     872             :   assert(I < NumOperands);
     873    11624736 :   mutable_begin()[I].reset(New, isUniqued() ? this : nullptr);
     874    11624736 : }
     875             : 
     876             : /// Get a node or a self-reference that looks like it.
     877             : ///
     878             : /// Special handling for finding self-references, for use by \a
     879             : /// MDNode::concatenate() and \a MDNode::intersect() to maintain behaviour from
     880             : /// when self-referencing nodes were still uniqued.  If the first operand has
     881             : /// the same operands as \c Ops, return the first operand instead.
     882       35415 : static MDNode *getOrSelfReference(LLVMContext &Context,
     883             :                                   ArrayRef<Metadata *> Ops) {
     884       35415 :   if (!Ops.empty())
     885       25041 :     if (MDNode *N = dyn_cast_or_null<MDNode>(Ops[0]))
     886       25220 :       if (N->getNumOperands() == Ops.size() && N == N->getOperand(0)) {
     887         205 :         for (unsigned I = 1, E = Ops.size(); I != E; ++I)
     888         585 :           if (Ops[I] != N->getOperand(I))
     889         175 :             return MDNode::get(Context, Ops);
     890             :         return N;
     891             :       }
     892             : 
     893       35230 :   return MDNode::get(Context, Ops);
     894             : }
     895             : 
     896       50241 : MDNode *MDNode::concatenate(MDNode *A, MDNode *B) {
     897       50241 :   if (!A)
     898             :     return B;
     899       13870 :   if (!B)
     900             :     return A;
     901             : 
     902       13866 :   SmallSetVector<Metadata *, 4> MDs(A->op_begin(), A->op_end());
     903       13866 :   MDs.insert(B->op_begin(), B->op_end());
     904             : 
     905             :   // FIXME: This preserves long-standing behaviour, but is it really the right
     906             :   // behaviour?  Or was that an unintended side-effect of node uniquing?
     907       13866 :   return getOrSelfReference(A->getContext(), MDs.getArrayRef());
     908             : }
     909             : 
     910       21735 : MDNode *MDNode::intersect(MDNode *A, MDNode *B) {
     911       21735 :   if (!A || !B)
     912             :     return nullptr;
     913             : 
     914       21549 :   SmallSetVector<Metadata *, 4> MDs(A->op_begin(), A->op_end());
     915       21549 :   SmallPtrSet<Metadata *, 4> BSet(B->op_begin(), B->op_end());
     916       34317 :   MDs.remove_if([&](Metadata *MD) { return !is_contained(BSet, MD); });
     917             : 
     918             :   // FIXME: This preserves long-standing behaviour, but is it really the right
     919             :   // behaviour?  Or was that an unintended side-effect of node uniquing?
     920       21549 :   return getOrSelfReference(A->getContext(), MDs.getArrayRef());
     921             : }
     922             : 
     923         189 : MDNode *MDNode::getMostGenericAliasScope(MDNode *A, MDNode *B) {
     924         189 :   if (!A || !B)
     925             :     return nullptr;
     926             : 
     927           7 :   return concatenate(A, B);
     928             : }
     929             : 
     930          10 : MDNode *MDNode::getMostGenericFPMath(MDNode *A, MDNode *B) {
     931          10 :   if (!A || !B)
     932             :     return nullptr;
     933             : 
     934             :   APFloat AVal = mdconst::extract<ConstantFP>(A->getOperand(0))->getValueAPF();
     935             :   APFloat BVal = mdconst::extract<ConstantFP>(B->getOperand(0))->getValueAPF();
     936           8 :   if (AVal.compare(BVal) == APFloat::cmpLessThan)
     937             :     return A;
     938           6 :   return B;
     939             : }
     940             : 
     941          19 : static bool isContiguous(const ConstantRange &A, const ConstantRange &B) {
     942          36 :   return A.getUpper() == B.getLower() || A.getLower() == B.getUpper();
     943             : }
     944             : 
     945          22 : static bool canBeMerged(const ConstantRange &A, const ConstantRange &B) {
     946          22 :   return !A.intersectWith(B).isEmptySet() || isContiguous(A, B);
     947             : }
     948             : 
     949          22 : static bool tryMergeRange(SmallVectorImpl<ConstantInt *> &EndPoints,
     950             :                           ConstantInt *Low, ConstantInt *High) {
     951          88 :   ConstantRange NewRange(Low->getValue(), High->getValue());
     952          22 :   unsigned Size = EndPoints.size();
     953          44 :   APInt LB = EndPoints[Size - 2]->getValue();
     954          44 :   APInt LE = EndPoints[Size - 1]->getValue();
     955          88 :   ConstantRange LastRange(LB, LE);
     956          22 :   if (canBeMerged(NewRange, LastRange)) {
     957          18 :     ConstantRange Union = LastRange.unionWith(NewRange);
     958             :     Type *Ty = High->getType();
     959           9 :     EndPoints[Size - 2] =
     960           9 :         cast<ConstantInt>(ConstantInt::get(Ty, Union.getLower()));
     961           9 :     EndPoints[Size - 1] =
     962           9 :         cast<ConstantInt>(ConstantInt::get(Ty, Union.getUpper()));
     963             :     return true;
     964             :   }
     965             :   return false;
     966             : }
     967             : 
     968          38 : static void addRange(SmallVectorImpl<ConstantInt *> &EndPoints,
     969             :                      ConstantInt *Low, ConstantInt *High) {
     970          38 :   if (!EndPoints.empty())
     971          20 :     if (tryMergeRange(EndPoints, Low, High))
     972             :       return;
     973             : 
     974          31 :   EndPoints.push_back(Low);
     975          31 :   EndPoints.push_back(High);
     976             : }
     977             : 
     978          26 : MDNode *MDNode::getMostGenericRange(MDNode *A, MDNode *B) {
     979             :   // Given two ranges, we want to compute the union of the ranges. This
     980             :   // is slightly complicated by having to combine the intervals and merge
     981             :   // the ones that overlap.
     982             : 
     983          26 :   if (!A || !B)
     984             :     return nullptr;
     985             : 
     986          22 :   if (A == B)
     987             :     return A;
     988             : 
     989             :   // First, walk both lists in order of the lower boundary of each interval.
     990             :   // At each step, try to merge the new interval to the last one we adedd.
     991             :   SmallVector<ConstantInt *, 4> EndPoints;
     992             :   int AI = 0;
     993             :   int BI = 0;
     994          18 :   int AN = A->getNumOperands() / 2;
     995          18 :   int BN = B->getNumOperands() / 2;
     996          38 :   while (AI < AN && BI < BN) {
     997          20 :     ConstantInt *ALow = mdconst::extract<ConstantInt>(A->getOperand(2 * AI));
     998          20 :     ConstantInt *BLow = mdconst::extract<ConstantInt>(B->getOperand(2 * BI));
     999             : 
    1000          20 :     if (ALow->getValue().slt(BLow->getValue())) {
    1001           0 :       addRange(EndPoints, ALow,
    1002           0 :                mdconst::extract<ConstantInt>(A->getOperand(2 * AI + 1)));
    1003           0 :       ++AI;
    1004             :     } else {
    1005          40 :       addRange(EndPoints, BLow,
    1006          20 :                mdconst::extract<ConstantInt>(B->getOperand(2 * BI + 1)));
    1007          20 :       ++BI;
    1008             :     }
    1009             :   }
    1010          54 :   while (AI < AN) {
    1011          54 :     addRange(EndPoints, mdconst::extract<ConstantInt>(A->getOperand(2 * AI)),
    1012          18 :              mdconst::extract<ConstantInt>(A->getOperand(2 * AI + 1)));
    1013          18 :     ++AI;
    1014             :   }
    1015          18 :   while (BI < BN) {
    1016           0 :     addRange(EndPoints, mdconst::extract<ConstantInt>(B->getOperand(2 * BI)),
    1017           0 :              mdconst::extract<ConstantInt>(B->getOperand(2 * BI + 1)));
    1018           0 :     ++BI;
    1019             :   }
    1020             : 
    1021             :   // If we have more than 2 ranges (4 endpoints) we have to try to merge
    1022             :   // the last and first ones.
    1023          18 :   unsigned Size = EndPoints.size();
    1024          18 :   if (Size > 4) {
    1025           2 :     ConstantInt *FB = EndPoints[0];
    1026           2 :     ConstantInt *FE = EndPoints[1];
    1027           2 :     if (tryMergeRange(EndPoints, FB, FE)) {
    1028          18 :       for (unsigned i = 0; i < Size - 2; ++i) {
    1029          24 :         EndPoints[i] = EndPoints[i + 2];
    1030             :       }
    1031           2 :       EndPoints.resize(Size - 2);
    1032             :     }
    1033             :   }
    1034             : 
    1035             :   // If in the end we have a single range, it is possible that it is now the
    1036             :   // full range. Just drop the metadata in that case.
    1037          18 :   if (EndPoints.size() == 2) {
    1038          40 :     ConstantRange Range(EndPoints[0]->getValue(), EndPoints[1]->getValue());
    1039           7 :     if (Range.isFullSet())
    1040           2 :       return nullptr;
    1041             :   }
    1042             : 
    1043             :   SmallVector<Metadata *, 4> MDs;
    1044          16 :   MDs.reserve(EndPoints.size());
    1045         124 :   for (auto *I : EndPoints)
    1046          54 :     MDs.push_back(ConstantAsMetadata::get(I));
    1047             :   return MDNode::get(A->getContext(), MDs);
    1048             : }
    1049             : 
    1050           9 : MDNode *MDNode::getMostGenericAlignmentOrDereferenceable(MDNode *A, MDNode *B) {
    1051           9 :   if (!A || !B)
    1052             :     return nullptr;
    1053             : 
    1054             :   ConstantInt *AVal = mdconst::extract<ConstantInt>(A->getOperand(0));
    1055             :   ConstantInt *BVal = mdconst::extract<ConstantInt>(B->getOperand(0));
    1056           9 :   if (AVal->getZExtValue() < BVal->getZExtValue())
    1057             :     return A;
    1058           9 :   return B;
    1059             : }
    1060             : 
    1061             : //===----------------------------------------------------------------------===//
    1062             : // NamedMDNode implementation.
    1063             : //
    1064             : 
    1065             : static SmallVector<TrackingMDRef, 4> &getNMDOps(void *Operands) {
    1066             :   return *(SmallVector<TrackingMDRef, 4> *)Operands;
    1067             : }
    1068             : 
    1069       33672 : NamedMDNode::NamedMDNode(const Twine &N)
    1070       67344 :     : Name(N.str()), Operands(new SmallVector<TrackingMDRef, 4>()) {}
    1071             : 
    1072       56152 : NamedMDNode::~NamedMDNode() {
    1073             :   dropAllReferences();
    1074       28076 :   delete &getNMDOps(Operands);
    1075       28076 : }
    1076             : 
    1077     1535261 : unsigned NamedMDNode::getNumOperands() const {
    1078     3070522 :   return (unsigned)getNMDOps(Operands).size();
    1079             : }
    1080             : 
    1081     6024601 : MDNode *NamedMDNode::getOperand(unsigned i) const {
    1082             :   assert(i < getNumOperands() && "Invalid Operand number!");
    1083     6024601 :   auto *N = getNMDOps(Operands)[i].get();
    1084     6024601 :   return cast_or_null<MDNode>(N);
    1085             : }
    1086             : 
    1087       56571 : void NamedMDNode::addOperand(MDNode *M) { getNMDOps(Operands).emplace_back(M); }
    1088             : 
    1089         339 : void NamedMDNode::setOperand(unsigned I, MDNode *New) {
    1090             :   assert(I < getNumOperands() && "Invalid operand number");
    1091         678 :   getNMDOps(Operands)[I].reset(New);
    1092         339 : }
    1093             : 
    1094         703 : void NamedMDNode::eraseFromParent() { getParent()->eraseNamedMetadata(this); }
    1095             : 
    1096       28098 : void NamedMDNode::clearOperands() { getNMDOps(Operands).clear(); }
    1097             : 
    1098      280408 : StringRef NamedMDNode::getName() const { return StringRef(Name); }
    1099             : 
    1100             : //===----------------------------------------------------------------------===//
    1101             : // Instruction Metadata method implementations.
    1102             : //
    1103      686823 : void MDAttachmentMap::set(unsigned ID, MDNode &MD) {
    1104      789425 :   for (auto &I : Attachments)
    1105       82532 :     if (I.first == ID) {
    1106             :       I.second.reset(&MD);
    1107             :       return;
    1108             :     }
    1109     1311184 :   Attachments.emplace_back(std::piecewise_construct, std::make_tuple(ID),
    1110      655592 :                            std::make_tuple(&MD));
    1111             : }
    1112             : 
    1113      465894 : bool MDAttachmentMap::erase(unsigned ID) {
    1114      465894 :   if (empty())
    1115             :     return false;
    1116             : 
    1117             :   // Common case is one/last value.
    1118      465894 :   if (Attachments.back().first == ID) {
    1119             :     Attachments.pop_back();
    1120         184 :     return true;
    1121             :   }
    1122             : 
    1123      491666 :   for (auto I = Attachments.begin(), E = std::prev(Attachments.end()); I != E;
    1124             :        ++I)
    1125       12986 :     if (I->first == ID) {
    1126             :       *I = std::move(Attachments.back());
    1127             :       Attachments.pop_back();
    1128           8 :       return true;
    1129             :     }
    1130             : 
    1131             :   return false;
    1132             : }
    1133             : 
    1134    17240544 : MDNode *MDAttachmentMap::lookup(unsigned ID) const {
    1135    46338232 :   for (const auto &I : Attachments)
    1136    18038112 :     if (I.first == ID)
    1137     3489268 :       return I.second;
    1138             :   return nullptr;
    1139             : }
    1140             : 
    1141      558394 : void MDAttachmentMap::getAll(
    1142             :     SmallVectorImpl<std::pair<unsigned, MDNode *>> &Result) const {
    1143      558394 :   Result.append(Attachments.begin(), Attachments.end());
    1144             : 
    1145             :   // Sort the resulting array so it is stable.
    1146      558394 :   if (Result.size() > 1)
    1147             :     array_pod_sort(Result.begin(), Result.end());
    1148      558394 : }
    1149             : 
    1150       72909 : void MDGlobalAttachmentMap::insert(unsigned ID, MDNode &MD) {
    1151      218727 :   Attachments.push_back({ID, TrackingMDNodeRef(&MD)});
    1152       72909 : }
    1153             : 
    1154     3235549 : MDNode *MDGlobalAttachmentMap::lookup(unsigned ID) const {
    1155     4005425 :   for (const auto &A : Attachments)
    1156     3256666 :     if (A.MDKind == ID)
    1157     2871728 :       return A.Node;
    1158             :   return nullptr;
    1159             : }
    1160             : 
    1161        7458 : void MDGlobalAttachmentMap::get(unsigned ID,
    1162             :                                 SmallVectorImpl<MDNode *> &Result) const {
    1163       24392 :   for (const auto &A : Attachments)
    1164        8467 :     if (A.MDKind == ID)
    1165       13730 :       Result.push_back(A.Node);
    1166        7458 : }
    1167             : 
    1168        2783 : bool MDGlobalAttachmentMap::erase(unsigned ID) {
    1169             :   auto I = std::remove_if(Attachments.begin(), Attachments.end(),
    1170          14 :                           [ID](const Attachment &A) { return A.MDKind == ID; });
    1171        2783 :   bool Changed = I != Attachments.end();
    1172        2783 :   Attachments.erase(I, Attachments.end());
    1173        2783 :   return Changed;
    1174             : }
    1175             : 
    1176       23219 : void MDGlobalAttachmentMap::getAll(
    1177             :     SmallVectorImpl<std::pair<unsigned, MDNode *>> &Result) const {
    1178       86601 :   for (const auto &A : Attachments)
    1179       31691 :     Result.emplace_back(A.MDKind, A.Node);
    1180             : 
    1181             :   // Sort the resulting array so it is stable with respect to metadata IDs. We
    1182             :   // need to preserve the original insertion order though.
    1183             :   std::stable_sort(
    1184             :       Result.begin(), Result.end(),
    1185             :       [](const std::pair<unsigned, MDNode *> &A,
    1186             :          const std::pair<unsigned, MDNode *> &B) { return A.first < B.first; });
    1187       23219 : }
    1188             : 
    1189       86627 : void Instruction::setMetadata(StringRef Kind, MDNode *Node) {
    1190       86627 :   if (!Node && !hasMetadata())
    1191             :     return;
    1192       86163 :   setMetadata(getContext().getMDKindID(Kind), Node);
    1193             : }
    1194             : 
    1195        4353 : MDNode *Instruction::getMetadataImpl(StringRef Kind) const {
    1196        4353 :   return getMetadataImpl(getContext().getMDKindID(Kind));
    1197             : }
    1198             : 
    1199       18302 : void Instruction::dropUnknownNonDebugMetadata(ArrayRef<unsigned> KnownIDs) {
    1200       18302 :   if (!hasMetadataHashEntry())
    1201       15339 :     return; // Nothing to remove!
    1202             : 
    1203        3292 :   auto &InstructionMetadata = getContext().pImpl->InstructionMetadata;
    1204             : 
    1205        2963 :   SmallSet<unsigned, 4> KnownSet;
    1206             :   KnownSet.insert(KnownIDs.begin(), KnownIDs.end());
    1207             :   if (KnownSet.empty()) {
    1208             :     // Just drop our entry at the store.
    1209         329 :     InstructionMetadata.erase(this);
    1210             :     setHasMetadataHashEntry(false);
    1211         329 :     return;
    1212             :   }
    1213             : 
    1214        5926 :   auto &Info = InstructionMetadata[this];
    1215        2963 :   Info.remove_if([&KnownSet](const std::pair<unsigned, TrackingMDNodeRef> &I) {
    1216        2990 :     return !KnownSet.count(I.first);
    1217             :   });
    1218             : 
    1219        2963 :   if (Info.empty()) {
    1220             :     // Drop our entry at the store.
    1221          99 :     InstructionMetadata.erase(this);
    1222             :     setHasMetadataHashEntry(false);
    1223             :   }
    1224             : }
    1225             : 
    1226     3922582 : void Instruction::setMetadata(unsigned KindID, MDNode *Node) {
    1227     3922582 :   if (!Node && !hasMetadata())
    1228             :     return;
    1229             : 
    1230             :   // Handle 'dbg' as a special case since it is not stored in the hash table.
    1231     3112473 :   if (KindID == LLVMContext::MD_dbg) {
    1232       42422 :     DbgLoc = DebugLoc(Node);
    1233       21211 :     return;
    1234             :   }
    1235             : 
    1236             :   // Handle the case when we're adding/updating metadata on an instruction.
    1237     3091262 :   if (Node) {
    1238     1373646 :     auto &Info = getContext().pImpl->InstructionMetadata[this];
    1239             :     assert(!Info.empty() == hasMetadataHashEntry() &&
    1240             :            "HasMetadata bit is wonked");
    1241      686823 :     if (Info.empty())
    1242             :       setHasMetadataHashEntry(true);
    1243      686823 :     Info.set(KindID, *Node);
    1244      686823 :     return;
    1245             :   }
    1246             : 
    1247             :   // Otherwise, we're removing metadata from an instruction.
    1248             :   assert((hasMetadataHashEntry() ==
    1249             :           (getContext().pImpl->InstructionMetadata.count(this) > 0)) &&
    1250             :          "HasMetadata bit out of date!");
    1251     2404439 :   if (!hasMetadataHashEntry())
    1252             :     return; // Nothing to remove!
    1253      931788 :   auto &Info = getContext().pImpl->InstructionMetadata[this];
    1254             : 
    1255             :   // Handle removal of an existing value.
    1256      465894 :   Info.erase(KindID);
    1257             : 
    1258      465894 :   if (!Info.empty())
    1259             :     return;
    1260             : 
    1261         179 :   getContext().pImpl->InstructionMetadata.erase(this);
    1262             :   setHasMetadataHashEntry(false);
    1263             : }
    1264             : 
    1265      282765 : void Instruction::setAAMetadata(const AAMDNodes &N) {
    1266      282765 :   setMetadata(LLVMContext::MD_tbaa, N.TBAA);
    1267      282765 :   setMetadata(LLVMContext::MD_alias_scope, N.Scope);
    1268      282765 :   setMetadata(LLVMContext::MD_noalias, N.NoAlias);
    1269      282765 : }
    1270             : 
    1271    93684972 : MDNode *Instruction::getMetadataImpl(unsigned KindID) const {
    1272             :   // Handle 'dbg' as a special case since it is not stored in the hash table.
    1273    93684972 :   if (KindID == LLVMContext::MD_dbg)
    1274           0 :     return DbgLoc.getAsMDNode();
    1275             : 
    1276    93684972 :   if (!hasMetadataHashEntry())
    1277             :     return nullptr;
    1278    34481088 :   auto &Info = getContext().pImpl->InstructionMetadata[this];
    1279             :   assert(!Info.empty() && "bit out of sync with hash table");
    1280             : 
    1281    17240544 :   return Info.lookup(KindID);
    1282             : }
    1283             : 
    1284     1688708 : void Instruction::getAllMetadataImpl(
    1285             :     SmallVectorImpl<std::pair<unsigned, MDNode *>> &Result) const {
    1286             :   Result.clear();
    1287             : 
    1288             :   // Handle 'dbg' as a special case since it is not stored in the hash table.
    1289     1688708 :   if (DbgLoc) {
    1290     3013800 :     Result.push_back(
    1291     3013800 :         std::make_pair((unsigned)LLVMContext::MD_dbg, DbgLoc.getAsMDNode()));
    1292     1506900 :     if (!hasMetadataHashEntry())
    1293             :       return;
    1294             :   }
    1295             : 
    1296             :   assert(hasMetadataHashEntry() &&
    1297             :          getContext().pImpl->InstructionMetadata.count(this) &&
    1298             :          "Shouldn't have called this");
    1299      283468 :   const auto &Info = getContext().pImpl->InstructionMetadata.find(this)->second;
    1300             :   assert(!Info.empty() && "Shouldn't have called this");
    1301      283468 :   Info.getAll(Result);
    1302             : }
    1303             : 
    1304      274926 : void Instruction::getAllMetadataOtherThanDebugLocImpl(
    1305             :     SmallVectorImpl<std::pair<unsigned, MDNode *>> &Result) const {
    1306             :   Result.clear();
    1307             :   assert(hasMetadataHashEntry() &&
    1308             :          getContext().pImpl->InstructionMetadata.count(this) &&
    1309             :          "Shouldn't have called this");
    1310      274926 :   const auto &Info = getContext().pImpl->InstructionMetadata.find(this)->second;
    1311             :   assert(!Info.empty() && "Shouldn't have called this");
    1312      274926 :   Info.getAll(Result);
    1313      274926 : }
    1314             : 
    1315       55763 : bool Instruction::extractProfMetadata(uint64_t &TrueVal,
    1316             :                                       uint64_t &FalseVal) const {
    1317             :   assert(
    1318             :       (getOpcode() == Instruction::Br || getOpcode() == Instruction::Select) &&
    1319             :       "Looking for branch weights on something besides branch or select");
    1320             : 
    1321             :   auto *ProfileData = getMetadata(LLVMContext::MD_prof);
    1322       51312 :   if (!ProfileData || ProfileData->getNumOperands() != 3)
    1323             :     return false;
    1324             : 
    1325             :   auto *ProfDataName = dyn_cast<MDString>(ProfileData->getOperand(0));
    1326         370 :   if (!ProfDataName || !ProfDataName->getString().equals("branch_weights"))
    1327             :     return false;
    1328             : 
    1329             :   auto *CITrue = mdconst::dyn_extract<ConstantInt>(ProfileData->getOperand(1));
    1330             :   auto *CIFalse = mdconst::dyn_extract<ConstantInt>(ProfileData->getOperand(2));
    1331         184 :   if (!CITrue || !CIFalse)
    1332             :     return false;
    1333             : 
    1334         184 :   TrueVal = CITrue->getValue().getZExtValue();
    1335         184 :   FalseVal = CIFalse->getValue().getZExtValue();
    1336             : 
    1337         184 :   return true;
    1338             : }
    1339             : 
    1340        2307 : bool Instruction::extractProfTotalWeight(uint64_t &TotalVal) const {
    1341             :   assert((getOpcode() == Instruction::Br ||
    1342             :           getOpcode() == Instruction::Select ||
    1343             :           getOpcode() == Instruction::Call ||
    1344             :           getOpcode() == Instruction::Invoke ||
    1345             :           getOpcode() == Instruction::Switch) &&
    1346             :          "Looking for branch weights on something besides branch");
    1347             : 
    1348        2307 :   TotalVal = 0;
    1349             :   auto *ProfileData = getMetadata(LLVMContext::MD_prof);
    1350        1871 :   if (!ProfileData)
    1351             :     return false;
    1352             : 
    1353             :   auto *ProfDataName = dyn_cast<MDString>(ProfileData->getOperand(0));
    1354             :   if (!ProfDataName)
    1355             :     return false;
    1356             : 
    1357          56 :   if (ProfDataName->getString().equals("branch_weights")) {
    1358          50 :     TotalVal = 0;
    1359         158 :     for (unsigned i = 1; i < ProfileData->getNumOperands(); i++) {
    1360             :       auto *V = mdconst::dyn_extract<ConstantInt>(ProfileData->getOperand(i));
    1361             :       if (!V)
    1362             :         return false;
    1363          54 :       TotalVal += V->getValue().getZExtValue();
    1364             :     }
    1365             :     return true;
    1366           6 :   } else if (ProfDataName->getString().equals("VP") &&
    1367           3 :              ProfileData->getNumOperands() > 3) {
    1368           3 :     TotalVal = mdconst::dyn_extract<ConstantInt>(ProfileData->getOperand(2))
    1369             :                    ->getValue()
    1370             :                    .getZExtValue();
    1371           3 :     return true;
    1372             :   }
    1373             :   return false;
    1374             : }
    1375             : 
    1376      527366 : void Instruction::clearMetadataHashEntries() {
    1377             :   assert(hasMetadataHashEntry() && "Caller should check");
    1378      527366 :   getContext().pImpl->InstructionMetadata.erase(this);
    1379             :   setHasMetadataHashEntry(false);
    1380      527366 : }
    1381             : 
    1382      248384 : void GlobalObject::getMetadata(unsigned KindID,
    1383             :                                SmallVectorImpl<MDNode *> &MDs) const {
    1384      248384 :   if (hasMetadata())
    1385       14916 :     getContext().pImpl->GlobalObjectMetadata[this].get(KindID, MDs);
    1386      248384 : }
    1387             : 
    1388           0 : void GlobalObject::getMetadata(StringRef Kind,
    1389             :                                SmallVectorImpl<MDNode *> &MDs) const {
    1390           0 :   if (hasMetadata())
    1391           0 :     getMetadata(getContext().getMDKindID(Kind), MDs);
    1392           0 : }
    1393             : 
    1394       72909 : void GlobalObject::addMetadata(unsigned KindID, MDNode &MD) {
    1395       72909 :   if (!hasMetadata())
    1396             :     setHasMetadataHashEntry(true);
    1397             : 
    1398      145818 :   getContext().pImpl->GlobalObjectMetadata[this].insert(KindID, MD);
    1399       72909 : }
    1400             : 
    1401           0 : void GlobalObject::addMetadata(StringRef Kind, MDNode &MD) {
    1402           0 :   addMetadata(getContext().getMDKindID(Kind), MD);
    1403           0 : }
    1404             : 
    1405      104080 : bool GlobalObject::eraseMetadata(unsigned KindID) {
    1406             :   // Nothing to unset.
    1407      104080 :   if (!hasMetadata())
    1408             :     return false;
    1409             : 
    1410        5566 :   auto &Store = getContext().pImpl->GlobalObjectMetadata[this];
    1411        2783 :   bool Changed = Store.erase(KindID);
    1412        2783 :   if (Store.empty())
    1413         839 :     clearMetadata();
    1414             :   return Changed;
    1415             : }
    1416             : 
    1417     1703488 : void GlobalObject::getAllMetadata(
    1418             :     SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs) const {
    1419             :   MDs.clear();
    1420             : 
    1421     1703488 :   if (!hasMetadata())
    1422             :     return;
    1423             : 
    1424       46438 :   getContext().pImpl->GlobalObjectMetadata[this].getAll(MDs);
    1425             : }
    1426             : 
    1427     1318027 : void GlobalObject::clearMetadata() {
    1428     1318027 :   if (!hasMetadata())
    1429             :     return;
    1430       32193 :   getContext().pImpl->GlobalObjectMetadata.erase(this);
    1431             :   setHasMetadataHashEntry(false);
    1432             : }
    1433             : 
    1434       64785 : void GlobalObject::setMetadata(unsigned KindID, MDNode *N) {
    1435       64785 :   eraseMetadata(KindID);
    1436       64785 :   if (N)
    1437       63916 :     addMetadata(KindID, *N);
    1438       64785 : }
    1439             : 
    1440        1615 : void GlobalObject::setMetadata(StringRef Kind, MDNode *N) {
    1441        1615 :   setMetadata(getContext().getMDKindID(Kind), N);
    1442        1615 : }
    1443             : 
    1444     8398637 : MDNode *GlobalObject::getMetadata(unsigned KindID) const {
    1445     8398637 :   if (hasMetadata())
    1446     6471098 :     return getContext().pImpl->GlobalObjectMetadata[this].lookup(KindID);
    1447             :   return nullptr;
    1448             : }
    1449             : 
    1450       35329 : MDNode *GlobalObject::getMetadata(StringRef Kind) const {
    1451       35329 :   return getMetadata(getContext().getMDKindID(Kind));
    1452             : }
    1453             : 
    1454        2076 : void GlobalObject::copyMetadata(const GlobalObject *Other, unsigned Offset) {
    1455             :   SmallVector<std::pair<unsigned, MDNode *>, 8> MDs;
    1456        2076 :   Other->getAllMetadata(MDs);
    1457        2500 :   for (auto &MD : MDs) {
    1458             :     // We need to adjust the type metadata offset.
    1459         212 :     if (Offset != 0 && MD.first == LLVMContext::MD_type) {
    1460             :       auto *OffsetConst = cast<ConstantInt>(
    1461          28 :           cast<ConstantAsMetadata>(MD.second->getOperand(0))->getValue());
    1462             :       Metadata *TypeId = MD.second->getOperand(1);
    1463          28 :       auto *NewOffsetMD = ConstantAsMetadata::get(ConstantInt::get(
    1464          84 :           OffsetConst->getType(), OffsetConst->getValue() + Offset));
    1465          28 :       addMetadata(LLVMContext::MD_type,
    1466          56 :                   *MDNode::get(getContext(), {NewOffsetMD, TypeId}));
    1467          28 :       continue;
    1468             :     }
    1469             :     // If an offset adjustment was specified we need to modify the DIExpression
    1470             :     // to prepend the adjustment:
    1471             :     // !DIExpression(DW_OP_plus, Offset, [original expr])
    1472         184 :     auto *Attachment = MD.second;
    1473         184 :     if (Offset != 0 && MD.first == LLVMContext::MD_dbg) {
    1474             :       DIGlobalVariable *GV = dyn_cast<DIGlobalVariable>(Attachment);
    1475             :       DIExpression *E = nullptr;
    1476             :       if (!GV) {
    1477             :         auto *GVE = cast<DIGlobalVariableExpression>(Attachment);
    1478             :         GV = GVE->getVariable();
    1479             :         E = GVE->getExpression();
    1480             :       }
    1481             :       ArrayRef<uint64_t> OrigElements;
    1482           5 :       if (E)
    1483             :         OrigElements = E->getElements();
    1484           5 :       std::vector<uint64_t> Elements(OrigElements.size() + 2);
    1485           5 :       Elements[0] = dwarf::DW_OP_plus_uconst;
    1486           5 :       Elements[1] = Offset;
    1487             :       std::copy(OrigElements.begin(), OrigElements.end(), Elements.begin() + 2);
    1488           5 :       E = DIExpression::get(getContext(), Elements);
    1489           5 :       Attachment = DIGlobalVariableExpression::get(getContext(), GV, E);
    1490             :     }
    1491         184 :     addMetadata(MD.first, *Attachment);
    1492             :   }
    1493        2076 : }
    1494             : 
    1495         442 : void GlobalObject::addTypeMetadata(unsigned Offset, Metadata *TypeID) {
    1496         442 :   addMetadata(
    1497             :       LLVMContext::MD_type,
    1498         884 :       *MDTuple::get(getContext(),
    1499         442 :                     {ConstantAsMetadata::get(ConstantInt::get(
    1500             :                          Type::getInt64Ty(getContext()), Offset)),
    1501             :                      TypeID}));
    1502         442 : }
    1503             : 
    1504       62565 : void Function::setSubprogram(DISubprogram *SP) {
    1505       62565 :   setMetadata(LLVMContext::MD_dbg, SP);
    1506       62565 : }
    1507             : 
    1508     5194557 : DISubprogram *Function::getSubprogram() const {
    1509    10389114 :   return cast_or_null<DISubprogram>(getMetadata(LLVMContext::MD_dbg));
    1510             : }
    1511             : 
    1512         956 : bool Function::isDebugInfoForProfiling() const {
    1513         956 :   if (DISubprogram *SP = getSubprogram()) {
    1514             :     if (DICompileUnit *CU = SP->getUnit()) {
    1515         570 :       return CU->getDebugInfoForProfiling();
    1516             :     }
    1517             :   }
    1518             :   return false;
    1519             : }
    1520             : 
    1521        2574 : void GlobalVariable::addDebugInfo(DIGlobalVariableExpression *GV) {
    1522        2574 :   addMetadata(LLVMContext::MD_dbg, *GV);
    1523        2574 : }
    1524             : 
    1525       92424 : void GlobalVariable::getDebugInfo(
    1526             :     SmallVectorImpl<DIGlobalVariableExpression *> &GVs) const {
    1527             :   SmallVector<MDNode *, 1> MDs;
    1528       92424 :   getMetadata(LLVMContext::MD_dbg, MDs);
    1529       97856 :   for (MDNode *MD : MDs)
    1530        2716 :     GVs.push_back(cast<DIGlobalVariableExpression>(MD));
    1531       92424 : }

Generated by: LCOV version 1.13