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