109467b48Spatrick //===- Metadata.cpp - Implement Metadata classes --------------------------===//
209467b48Spatrick //
309467b48Spatrick // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
409467b48Spatrick // See https://llvm.org/LICENSE.txt for license information.
509467b48Spatrick // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
609467b48Spatrick //
709467b48Spatrick //===----------------------------------------------------------------------===//
809467b48Spatrick //
909467b48Spatrick // This file implements the Metadata classes.
1009467b48Spatrick //
1109467b48Spatrick //===----------------------------------------------------------------------===//
1209467b48Spatrick
1373471bf0Spatrick #include "llvm/IR/Metadata.h"
1409467b48Spatrick #include "LLVMContextImpl.h"
1509467b48Spatrick #include "MetadataImpl.h"
1609467b48Spatrick #include "llvm/ADT/APFloat.h"
1709467b48Spatrick #include "llvm/ADT/APInt.h"
1809467b48Spatrick #include "llvm/ADT/ArrayRef.h"
1909467b48Spatrick #include "llvm/ADT/DenseSet.h"
2009467b48Spatrick #include "llvm/ADT/STLExtras.h"
2109467b48Spatrick #include "llvm/ADT/SetVector.h"
2209467b48Spatrick #include "llvm/ADT/SmallPtrSet.h"
2309467b48Spatrick #include "llvm/ADT/SmallSet.h"
2409467b48Spatrick #include "llvm/ADT/SmallVector.h"
2509467b48Spatrick #include "llvm/ADT/StringMap.h"
2609467b48Spatrick #include "llvm/ADT/StringRef.h"
2709467b48Spatrick #include "llvm/ADT/Twine.h"
2809467b48Spatrick #include "llvm/IR/Argument.h"
2909467b48Spatrick #include "llvm/IR/BasicBlock.h"
3009467b48Spatrick #include "llvm/IR/Constant.h"
3109467b48Spatrick #include "llvm/IR/ConstantRange.h"
3209467b48Spatrick #include "llvm/IR/Constants.h"
3309467b48Spatrick #include "llvm/IR/DebugInfoMetadata.h"
3409467b48Spatrick #include "llvm/IR/DebugLoc.h"
3509467b48Spatrick #include "llvm/IR/Function.h"
3609467b48Spatrick #include "llvm/IR/GlobalObject.h"
3709467b48Spatrick #include "llvm/IR/GlobalVariable.h"
3809467b48Spatrick #include "llvm/IR/Instruction.h"
3909467b48Spatrick #include "llvm/IR/LLVMContext.h"
4073471bf0Spatrick #include "llvm/IR/MDBuilder.h"
4109467b48Spatrick #include "llvm/IR/Module.h"
42*d415bd75Srobert #include "llvm/IR/ProfDataUtils.h"
4309467b48Spatrick #include "llvm/IR/TrackingMDRef.h"
4409467b48Spatrick #include "llvm/IR/Type.h"
4509467b48Spatrick #include "llvm/IR/Value.h"
4609467b48Spatrick #include "llvm/Support/Casting.h"
4709467b48Spatrick #include "llvm/Support/ErrorHandling.h"
4809467b48Spatrick #include "llvm/Support/MathExtras.h"
4909467b48Spatrick #include <algorithm>
5009467b48Spatrick #include <cassert>
5109467b48Spatrick #include <cstddef>
5209467b48Spatrick #include <cstdint>
5309467b48Spatrick #include <type_traits>
5409467b48Spatrick #include <utility>
5509467b48Spatrick #include <vector>
5609467b48Spatrick
5709467b48Spatrick using namespace llvm;
5809467b48Spatrick
MetadataAsValue(Type * Ty,Metadata * MD)5909467b48Spatrick MetadataAsValue::MetadataAsValue(Type *Ty, Metadata *MD)
6009467b48Spatrick : Value(Ty, MetadataAsValueVal), MD(MD) {
6109467b48Spatrick track();
6209467b48Spatrick }
6309467b48Spatrick
~MetadataAsValue()6409467b48Spatrick MetadataAsValue::~MetadataAsValue() {
6509467b48Spatrick getType()->getContext().pImpl->MetadataAsValues.erase(MD);
6609467b48Spatrick untrack();
6709467b48Spatrick }
6809467b48Spatrick
6909467b48Spatrick /// Canonicalize metadata arguments to intrinsics.
7009467b48Spatrick ///
7109467b48Spatrick /// To support bitcode upgrades (and assembly semantic sugar) for \a
7209467b48Spatrick /// MetadataAsValue, we need to canonicalize certain metadata.
7309467b48Spatrick ///
7409467b48Spatrick /// - nullptr is replaced by an empty MDNode.
7509467b48Spatrick /// - An MDNode with a single null operand is replaced by an empty MDNode.
7609467b48Spatrick /// - An MDNode whose only operand is a \a ConstantAsMetadata gets skipped.
7709467b48Spatrick ///
7809467b48Spatrick /// This maintains readability of bitcode from when metadata was a type of
7909467b48Spatrick /// value, and these bridges were unnecessary.
canonicalizeMetadataForValue(LLVMContext & Context,Metadata * MD)8009467b48Spatrick static Metadata *canonicalizeMetadataForValue(LLVMContext &Context,
8109467b48Spatrick Metadata *MD) {
8209467b48Spatrick if (!MD)
8309467b48Spatrick // !{}
84*d415bd75Srobert return MDNode::get(Context, std::nullopt);
8509467b48Spatrick
8609467b48Spatrick // Return early if this isn't a single-operand MDNode.
8709467b48Spatrick auto *N = dyn_cast<MDNode>(MD);
8809467b48Spatrick if (!N || N->getNumOperands() != 1)
8909467b48Spatrick return MD;
9009467b48Spatrick
9109467b48Spatrick if (!N->getOperand(0))
9209467b48Spatrick // !{}
93*d415bd75Srobert return MDNode::get(Context, std::nullopt);
9409467b48Spatrick
9509467b48Spatrick if (auto *C = dyn_cast<ConstantAsMetadata>(N->getOperand(0)))
9609467b48Spatrick // Look through the MDNode.
9709467b48Spatrick return C;
9809467b48Spatrick
9909467b48Spatrick return MD;
10009467b48Spatrick }
10109467b48Spatrick
get(LLVMContext & Context,Metadata * MD)10209467b48Spatrick MetadataAsValue *MetadataAsValue::get(LLVMContext &Context, Metadata *MD) {
10309467b48Spatrick MD = canonicalizeMetadataForValue(Context, MD);
10409467b48Spatrick auto *&Entry = Context.pImpl->MetadataAsValues[MD];
10509467b48Spatrick if (!Entry)
10609467b48Spatrick Entry = new MetadataAsValue(Type::getMetadataTy(Context), MD);
10709467b48Spatrick return Entry;
10809467b48Spatrick }
10909467b48Spatrick
getIfExists(LLVMContext & Context,Metadata * MD)11009467b48Spatrick MetadataAsValue *MetadataAsValue::getIfExists(LLVMContext &Context,
11109467b48Spatrick Metadata *MD) {
11209467b48Spatrick MD = canonicalizeMetadataForValue(Context, MD);
11309467b48Spatrick auto &Store = Context.pImpl->MetadataAsValues;
11409467b48Spatrick return Store.lookup(MD);
11509467b48Spatrick }
11609467b48Spatrick
handleChangedMetadata(Metadata * MD)11709467b48Spatrick void MetadataAsValue::handleChangedMetadata(Metadata *MD) {
11809467b48Spatrick LLVMContext &Context = getContext();
11909467b48Spatrick MD = canonicalizeMetadataForValue(Context, MD);
12009467b48Spatrick auto &Store = Context.pImpl->MetadataAsValues;
12109467b48Spatrick
12209467b48Spatrick // Stop tracking the old metadata.
12309467b48Spatrick Store.erase(this->MD);
12409467b48Spatrick untrack();
12509467b48Spatrick this->MD = nullptr;
12609467b48Spatrick
12709467b48Spatrick // Start tracking MD, or RAUW if necessary.
12809467b48Spatrick auto *&Entry = Store[MD];
12909467b48Spatrick if (Entry) {
13009467b48Spatrick replaceAllUsesWith(Entry);
13109467b48Spatrick delete this;
13209467b48Spatrick return;
13309467b48Spatrick }
13409467b48Spatrick
13509467b48Spatrick this->MD = MD;
13609467b48Spatrick track();
13709467b48Spatrick Entry = this;
13809467b48Spatrick }
13909467b48Spatrick
track()14009467b48Spatrick void MetadataAsValue::track() {
14109467b48Spatrick if (MD)
14209467b48Spatrick MetadataTracking::track(&MD, *MD, *this);
14309467b48Spatrick }
14409467b48Spatrick
untrack()14509467b48Spatrick void MetadataAsValue::untrack() {
14609467b48Spatrick if (MD)
14709467b48Spatrick MetadataTracking::untrack(MD);
14809467b48Spatrick }
14909467b48Spatrick
track(void * Ref,Metadata & MD,OwnerTy Owner)15009467b48Spatrick bool MetadataTracking::track(void *Ref, Metadata &MD, OwnerTy Owner) {
15109467b48Spatrick assert(Ref && "Expected live reference");
15209467b48Spatrick assert((Owner || *static_cast<Metadata **>(Ref) == &MD) &&
15309467b48Spatrick "Reference without owner must be direct");
15409467b48Spatrick if (auto *R = ReplaceableMetadataImpl::getOrCreate(MD)) {
15509467b48Spatrick R->addRef(Ref, Owner);
15609467b48Spatrick return true;
15709467b48Spatrick }
15809467b48Spatrick if (auto *PH = dyn_cast<DistinctMDOperandPlaceholder>(&MD)) {
15909467b48Spatrick assert(!PH->Use && "Placeholders can only be used once");
16009467b48Spatrick assert(!Owner && "Unexpected callback to owner");
16109467b48Spatrick PH->Use = static_cast<Metadata **>(Ref);
16209467b48Spatrick return true;
16309467b48Spatrick }
16409467b48Spatrick return false;
16509467b48Spatrick }
16609467b48Spatrick
untrack(void * Ref,Metadata & MD)16709467b48Spatrick void MetadataTracking::untrack(void *Ref, Metadata &MD) {
16809467b48Spatrick assert(Ref && "Expected live reference");
16909467b48Spatrick if (auto *R = ReplaceableMetadataImpl::getIfExists(MD))
17009467b48Spatrick R->dropRef(Ref);
17109467b48Spatrick else if (auto *PH = dyn_cast<DistinctMDOperandPlaceholder>(&MD))
17209467b48Spatrick PH->Use = nullptr;
17309467b48Spatrick }
17409467b48Spatrick
retrack(void * Ref,Metadata & MD,void * New)17509467b48Spatrick bool MetadataTracking::retrack(void *Ref, Metadata &MD, void *New) {
17609467b48Spatrick assert(Ref && "Expected live reference");
17709467b48Spatrick assert(New && "Expected live reference");
17809467b48Spatrick assert(Ref != New && "Expected change");
17909467b48Spatrick if (auto *R = ReplaceableMetadataImpl::getIfExists(MD)) {
18009467b48Spatrick R->moveRef(Ref, New, MD);
18109467b48Spatrick return true;
18209467b48Spatrick }
18309467b48Spatrick assert(!isa<DistinctMDOperandPlaceholder>(MD) &&
18409467b48Spatrick "Unexpected move of an MDOperand");
18509467b48Spatrick assert(!isReplaceable(MD) &&
18609467b48Spatrick "Expected un-replaceable metadata, since we didn't move a reference");
18709467b48Spatrick return false;
18809467b48Spatrick }
18909467b48Spatrick
isReplaceable(const Metadata & MD)19009467b48Spatrick bool MetadataTracking::isReplaceable(const Metadata &MD) {
19109467b48Spatrick return ReplaceableMetadataImpl::isReplaceable(MD);
19209467b48Spatrick }
19309467b48Spatrick
getAllArgListUsers()19473471bf0Spatrick SmallVector<Metadata *> ReplaceableMetadataImpl::getAllArgListUsers() {
19573471bf0Spatrick SmallVector<std::pair<OwnerTy, uint64_t> *> MDUsersWithID;
19673471bf0Spatrick for (auto Pair : UseMap) {
19773471bf0Spatrick OwnerTy Owner = Pair.second.first;
19873471bf0Spatrick if (!Owner.is<Metadata *>())
19973471bf0Spatrick continue;
20073471bf0Spatrick Metadata *OwnerMD = Owner.get<Metadata *>();
20173471bf0Spatrick if (OwnerMD->getMetadataID() == Metadata::DIArgListKind)
20273471bf0Spatrick MDUsersWithID.push_back(&UseMap[Pair.first]);
20373471bf0Spatrick }
20473471bf0Spatrick llvm::sort(MDUsersWithID, [](auto UserA, auto UserB) {
20573471bf0Spatrick return UserA->second < UserB->second;
20673471bf0Spatrick });
20773471bf0Spatrick SmallVector<Metadata *> MDUsers;
208*d415bd75Srobert for (auto *UserWithID : MDUsersWithID)
20973471bf0Spatrick MDUsers.push_back(UserWithID->first.get<Metadata *>());
21073471bf0Spatrick return MDUsers;
21173471bf0Spatrick }
21273471bf0Spatrick
addRef(void * Ref,OwnerTy Owner)21309467b48Spatrick void ReplaceableMetadataImpl::addRef(void *Ref, OwnerTy Owner) {
21409467b48Spatrick bool WasInserted =
21509467b48Spatrick UseMap.insert(std::make_pair(Ref, std::make_pair(Owner, NextIndex)))
21609467b48Spatrick .second;
21709467b48Spatrick (void)WasInserted;
21809467b48Spatrick assert(WasInserted && "Expected to add a reference");
21909467b48Spatrick
22009467b48Spatrick ++NextIndex;
22109467b48Spatrick assert(NextIndex != 0 && "Unexpected overflow");
22209467b48Spatrick }
22309467b48Spatrick
dropRef(void * Ref)22409467b48Spatrick void ReplaceableMetadataImpl::dropRef(void *Ref) {
22509467b48Spatrick bool WasErased = UseMap.erase(Ref);
22609467b48Spatrick (void)WasErased;
22709467b48Spatrick assert(WasErased && "Expected to drop a reference");
22809467b48Spatrick }
22909467b48Spatrick
moveRef(void * Ref,void * New,const Metadata & MD)23009467b48Spatrick void ReplaceableMetadataImpl::moveRef(void *Ref, void *New,
23109467b48Spatrick const Metadata &MD) {
23209467b48Spatrick auto I = UseMap.find(Ref);
23309467b48Spatrick assert(I != UseMap.end() && "Expected to move a reference");
23409467b48Spatrick auto OwnerAndIndex = I->second;
23509467b48Spatrick UseMap.erase(I);
23609467b48Spatrick bool WasInserted = UseMap.insert(std::make_pair(New, OwnerAndIndex)).second;
23709467b48Spatrick (void)WasInserted;
23809467b48Spatrick assert(WasInserted && "Expected to add a reference");
23909467b48Spatrick
24009467b48Spatrick // Check that the references are direct if there's no owner.
24109467b48Spatrick (void)MD;
24209467b48Spatrick assert((OwnerAndIndex.first || *static_cast<Metadata **>(Ref) == &MD) &&
24309467b48Spatrick "Reference without owner must be direct");
24409467b48Spatrick assert((OwnerAndIndex.first || *static_cast<Metadata **>(New) == &MD) &&
24509467b48Spatrick "Reference without owner must be direct");
24609467b48Spatrick }
24709467b48Spatrick
SalvageDebugInfo(const Constant & C)248*d415bd75Srobert void ReplaceableMetadataImpl::SalvageDebugInfo(const Constant &C) {
249*d415bd75Srobert if (!C.isUsedByMetadata()) {
250*d415bd75Srobert return;
251*d415bd75Srobert }
252*d415bd75Srobert
253*d415bd75Srobert LLVMContext &Context = C.getType()->getContext();
254*d415bd75Srobert auto &Store = Context.pImpl->ValuesAsMetadata;
255*d415bd75Srobert auto I = Store.find(&C);
256*d415bd75Srobert ValueAsMetadata *MD = I->second;
257*d415bd75Srobert using UseTy =
258*d415bd75Srobert std::pair<void *, std::pair<MetadataTracking::OwnerTy, uint64_t>>;
259*d415bd75Srobert // Copy out uses and update value of Constant used by debug info metadata with undef below
260*d415bd75Srobert SmallVector<UseTy, 8> Uses(MD->UseMap.begin(), MD->UseMap.end());
261*d415bd75Srobert
262*d415bd75Srobert for (const auto &Pair : Uses) {
263*d415bd75Srobert MetadataTracking::OwnerTy Owner = Pair.second.first;
264*d415bd75Srobert if (!Owner)
265*d415bd75Srobert continue;
266*d415bd75Srobert if (!Owner.is<Metadata *>())
267*d415bd75Srobert continue;
268*d415bd75Srobert auto *OwnerMD = dyn_cast<MDNode>(Owner.get<Metadata *>());
269*d415bd75Srobert if (!OwnerMD)
270*d415bd75Srobert continue;
271*d415bd75Srobert if (isa<DINode>(OwnerMD)) {
272*d415bd75Srobert OwnerMD->handleChangedOperand(
273*d415bd75Srobert Pair.first, ValueAsMetadata::get(UndefValue::get(C.getType())));
274*d415bd75Srobert }
275*d415bd75Srobert }
276*d415bd75Srobert }
277*d415bd75Srobert
replaceAllUsesWith(Metadata * MD)27809467b48Spatrick void ReplaceableMetadataImpl::replaceAllUsesWith(Metadata *MD) {
27909467b48Spatrick if (UseMap.empty())
28009467b48Spatrick return;
28109467b48Spatrick
28209467b48Spatrick // Copy out uses since UseMap will get touched below.
28309467b48Spatrick using UseTy = std::pair<void *, std::pair<OwnerTy, uint64_t>>;
28409467b48Spatrick SmallVector<UseTy, 8> Uses(UseMap.begin(), UseMap.end());
285*d415bd75Srobert llvm::sort(Uses, llvm::less_second());
28609467b48Spatrick for (const auto &Pair : Uses) {
28709467b48Spatrick // Check that this Ref hasn't disappeared after RAUW (when updating a
28809467b48Spatrick // previous Ref).
28909467b48Spatrick if (!UseMap.count(Pair.first))
29009467b48Spatrick continue;
29109467b48Spatrick
29209467b48Spatrick OwnerTy Owner = Pair.second.first;
29309467b48Spatrick if (!Owner) {
29409467b48Spatrick // Update unowned tracking references directly.
29509467b48Spatrick Metadata *&Ref = *static_cast<Metadata **>(Pair.first);
29609467b48Spatrick Ref = MD;
29709467b48Spatrick if (MD)
29809467b48Spatrick MetadataTracking::track(Ref);
29909467b48Spatrick UseMap.erase(Pair.first);
30009467b48Spatrick continue;
30109467b48Spatrick }
30209467b48Spatrick
30309467b48Spatrick // Check for MetadataAsValue.
30409467b48Spatrick if (Owner.is<MetadataAsValue *>()) {
30509467b48Spatrick Owner.get<MetadataAsValue *>()->handleChangedMetadata(MD);
30609467b48Spatrick continue;
30709467b48Spatrick }
30809467b48Spatrick
30909467b48Spatrick // There's a Metadata owner -- dispatch.
31009467b48Spatrick Metadata *OwnerMD = Owner.get<Metadata *>();
31109467b48Spatrick switch (OwnerMD->getMetadataID()) {
31209467b48Spatrick #define HANDLE_METADATA_LEAF(CLASS) \
31309467b48Spatrick case Metadata::CLASS##Kind: \
31409467b48Spatrick cast<CLASS>(OwnerMD)->handleChangedOperand(Pair.first, MD); \
31509467b48Spatrick continue;
31609467b48Spatrick #include "llvm/IR/Metadata.def"
31709467b48Spatrick default:
31809467b48Spatrick llvm_unreachable("Invalid metadata subclass");
31909467b48Spatrick }
32009467b48Spatrick }
32109467b48Spatrick assert(UseMap.empty() && "Expected all uses to be replaced");
32209467b48Spatrick }
32309467b48Spatrick
resolveAllUses(bool ResolveUsers)32409467b48Spatrick void ReplaceableMetadataImpl::resolveAllUses(bool ResolveUsers) {
32509467b48Spatrick if (UseMap.empty())
32609467b48Spatrick return;
32709467b48Spatrick
32809467b48Spatrick if (!ResolveUsers) {
32909467b48Spatrick UseMap.clear();
33009467b48Spatrick return;
33109467b48Spatrick }
33209467b48Spatrick
33309467b48Spatrick // Copy out uses since UseMap could get touched below.
33409467b48Spatrick using UseTy = std::pair<void *, std::pair<OwnerTy, uint64_t>>;
33509467b48Spatrick SmallVector<UseTy, 8> Uses(UseMap.begin(), UseMap.end());
33609467b48Spatrick llvm::sort(Uses, [](const UseTy &L, const UseTy &R) {
33709467b48Spatrick return L.second.second < R.second.second;
33809467b48Spatrick });
33909467b48Spatrick UseMap.clear();
34009467b48Spatrick for (const auto &Pair : Uses) {
34109467b48Spatrick auto Owner = Pair.second.first;
34209467b48Spatrick if (!Owner)
34309467b48Spatrick continue;
34409467b48Spatrick if (Owner.is<MetadataAsValue *>())
34509467b48Spatrick continue;
34609467b48Spatrick
34709467b48Spatrick // Resolve MDNodes that point at this.
34809467b48Spatrick auto *OwnerMD = dyn_cast<MDNode>(Owner.get<Metadata *>());
34909467b48Spatrick if (!OwnerMD)
35009467b48Spatrick continue;
35109467b48Spatrick if (OwnerMD->isResolved())
35209467b48Spatrick continue;
35309467b48Spatrick OwnerMD->decrementUnresolvedOperandCount();
35409467b48Spatrick }
35509467b48Spatrick }
35609467b48Spatrick
getOrCreate(Metadata & MD)35709467b48Spatrick ReplaceableMetadataImpl *ReplaceableMetadataImpl::getOrCreate(Metadata &MD) {
35809467b48Spatrick if (auto *N = dyn_cast<MDNode>(&MD))
35909467b48Spatrick return N->isResolved() ? nullptr : N->Context.getOrCreateReplaceableUses();
36009467b48Spatrick return dyn_cast<ValueAsMetadata>(&MD);
36109467b48Spatrick }
36209467b48Spatrick
getIfExists(Metadata & MD)36309467b48Spatrick ReplaceableMetadataImpl *ReplaceableMetadataImpl::getIfExists(Metadata &MD) {
36409467b48Spatrick if (auto *N = dyn_cast<MDNode>(&MD))
36509467b48Spatrick return N->isResolved() ? nullptr : N->Context.getReplaceableUses();
36609467b48Spatrick return dyn_cast<ValueAsMetadata>(&MD);
36709467b48Spatrick }
36809467b48Spatrick
isReplaceable(const Metadata & MD)36909467b48Spatrick bool ReplaceableMetadataImpl::isReplaceable(const Metadata &MD) {
37009467b48Spatrick if (auto *N = dyn_cast<MDNode>(&MD))
37109467b48Spatrick return !N->isResolved();
372*d415bd75Srobert return isa<ValueAsMetadata>(&MD);
37309467b48Spatrick }
37409467b48Spatrick
getLocalFunctionMetadata(Value * V)37509467b48Spatrick static DISubprogram *getLocalFunctionMetadata(Value *V) {
37609467b48Spatrick assert(V && "Expected value");
37709467b48Spatrick if (auto *A = dyn_cast<Argument>(V)) {
37809467b48Spatrick if (auto *Fn = A->getParent())
37909467b48Spatrick return Fn->getSubprogram();
38009467b48Spatrick return nullptr;
38109467b48Spatrick }
38209467b48Spatrick
38309467b48Spatrick if (BasicBlock *BB = cast<Instruction>(V)->getParent()) {
38409467b48Spatrick if (auto *Fn = BB->getParent())
38509467b48Spatrick return Fn->getSubprogram();
38609467b48Spatrick return nullptr;
38709467b48Spatrick }
38809467b48Spatrick
38909467b48Spatrick return nullptr;
39009467b48Spatrick }
39109467b48Spatrick
get(Value * V)39209467b48Spatrick ValueAsMetadata *ValueAsMetadata::get(Value *V) {
39309467b48Spatrick assert(V && "Unexpected null Value");
39409467b48Spatrick
39509467b48Spatrick auto &Context = V->getContext();
39609467b48Spatrick auto *&Entry = Context.pImpl->ValuesAsMetadata[V];
39709467b48Spatrick if (!Entry) {
39809467b48Spatrick assert((isa<Constant>(V) || isa<Argument>(V) || isa<Instruction>(V)) &&
39909467b48Spatrick "Expected constant or function-local value");
40009467b48Spatrick assert(!V->IsUsedByMD && "Expected this to be the only metadata use");
40109467b48Spatrick V->IsUsedByMD = true;
40209467b48Spatrick if (auto *C = dyn_cast<Constant>(V))
40309467b48Spatrick Entry = new ConstantAsMetadata(C);
40409467b48Spatrick else
40509467b48Spatrick Entry = new LocalAsMetadata(V);
40609467b48Spatrick }
40709467b48Spatrick
40809467b48Spatrick return Entry;
40909467b48Spatrick }
41009467b48Spatrick
getIfExists(Value * V)41109467b48Spatrick ValueAsMetadata *ValueAsMetadata::getIfExists(Value *V) {
41209467b48Spatrick assert(V && "Unexpected null Value");
41309467b48Spatrick return V->getContext().pImpl->ValuesAsMetadata.lookup(V);
41409467b48Spatrick }
41509467b48Spatrick
handleDeletion(Value * V)41609467b48Spatrick void ValueAsMetadata::handleDeletion(Value *V) {
41709467b48Spatrick assert(V && "Expected valid value");
41809467b48Spatrick
41909467b48Spatrick auto &Store = V->getType()->getContext().pImpl->ValuesAsMetadata;
42009467b48Spatrick auto I = Store.find(V);
42109467b48Spatrick if (I == Store.end())
42209467b48Spatrick return;
42309467b48Spatrick
42409467b48Spatrick // Remove old entry from the map.
42509467b48Spatrick ValueAsMetadata *MD = I->second;
42609467b48Spatrick assert(MD && "Expected valid metadata");
42709467b48Spatrick assert(MD->getValue() == V && "Expected valid mapping");
42809467b48Spatrick Store.erase(I);
42909467b48Spatrick
43009467b48Spatrick // Delete the metadata.
43109467b48Spatrick MD->replaceAllUsesWith(nullptr);
43209467b48Spatrick delete MD;
43309467b48Spatrick }
43409467b48Spatrick
handleRAUW(Value * From,Value * To)43509467b48Spatrick void ValueAsMetadata::handleRAUW(Value *From, Value *To) {
43609467b48Spatrick assert(From && "Expected valid value");
43709467b48Spatrick assert(To && "Expected valid value");
43809467b48Spatrick assert(From != To && "Expected changed value");
43909467b48Spatrick assert(From->getType() == To->getType() && "Unexpected type change");
44009467b48Spatrick
44109467b48Spatrick LLVMContext &Context = From->getType()->getContext();
44209467b48Spatrick auto &Store = Context.pImpl->ValuesAsMetadata;
44309467b48Spatrick auto I = Store.find(From);
44409467b48Spatrick if (I == Store.end()) {
44509467b48Spatrick assert(!From->IsUsedByMD && "Expected From not to be used by metadata");
44609467b48Spatrick return;
44709467b48Spatrick }
44809467b48Spatrick
44909467b48Spatrick // Remove old entry from the map.
45009467b48Spatrick assert(From->IsUsedByMD && "Expected From to be used by metadata");
45109467b48Spatrick From->IsUsedByMD = false;
45209467b48Spatrick ValueAsMetadata *MD = I->second;
45309467b48Spatrick assert(MD && "Expected valid metadata");
45409467b48Spatrick assert(MD->getValue() == From && "Expected valid mapping");
45509467b48Spatrick Store.erase(I);
45609467b48Spatrick
45709467b48Spatrick if (isa<LocalAsMetadata>(MD)) {
45809467b48Spatrick if (auto *C = dyn_cast<Constant>(To)) {
45909467b48Spatrick // Local became a constant.
46009467b48Spatrick MD->replaceAllUsesWith(ConstantAsMetadata::get(C));
46109467b48Spatrick delete MD;
46209467b48Spatrick return;
46309467b48Spatrick }
46409467b48Spatrick if (getLocalFunctionMetadata(From) && getLocalFunctionMetadata(To) &&
46509467b48Spatrick getLocalFunctionMetadata(From) != getLocalFunctionMetadata(To)) {
46609467b48Spatrick // DISubprogram changed.
46709467b48Spatrick MD->replaceAllUsesWith(nullptr);
46809467b48Spatrick delete MD;
46909467b48Spatrick return;
47009467b48Spatrick }
47109467b48Spatrick } else if (!isa<Constant>(To)) {
47209467b48Spatrick // Changed to function-local value.
47309467b48Spatrick MD->replaceAllUsesWith(nullptr);
47409467b48Spatrick delete MD;
47509467b48Spatrick return;
47609467b48Spatrick }
47709467b48Spatrick
47809467b48Spatrick auto *&Entry = Store[To];
47909467b48Spatrick if (Entry) {
48009467b48Spatrick // The target already exists.
48109467b48Spatrick MD->replaceAllUsesWith(Entry);
48209467b48Spatrick delete MD;
48309467b48Spatrick return;
48409467b48Spatrick }
48509467b48Spatrick
48609467b48Spatrick // Update MD in place (and update the map entry).
48709467b48Spatrick assert(!To->IsUsedByMD && "Expected this to be the only metadata use");
48809467b48Spatrick To->IsUsedByMD = true;
48909467b48Spatrick MD->V = To;
49009467b48Spatrick Entry = MD;
49109467b48Spatrick }
49209467b48Spatrick
49309467b48Spatrick //===----------------------------------------------------------------------===//
49409467b48Spatrick // MDString implementation.
49509467b48Spatrick //
49609467b48Spatrick
get(LLVMContext & Context,StringRef Str)49709467b48Spatrick MDString *MDString::get(LLVMContext &Context, StringRef Str) {
49809467b48Spatrick auto &Store = Context.pImpl->MDStringCache;
49909467b48Spatrick auto I = Store.try_emplace(Str);
50009467b48Spatrick auto &MapEntry = I.first->getValue();
50109467b48Spatrick if (!I.second)
50209467b48Spatrick return &MapEntry;
50309467b48Spatrick MapEntry.Entry = &*I.first;
50409467b48Spatrick return &MapEntry;
50509467b48Spatrick }
50609467b48Spatrick
getString() const50709467b48Spatrick StringRef MDString::getString() const {
50809467b48Spatrick assert(Entry && "Expected to find string map entry");
50909467b48Spatrick return Entry->first();
51009467b48Spatrick }
51109467b48Spatrick
51209467b48Spatrick //===----------------------------------------------------------------------===//
51309467b48Spatrick // MDNode implementation.
51409467b48Spatrick //
51509467b48Spatrick
51609467b48Spatrick // Assert that the MDNode types will not be unaligned by the objects
51709467b48Spatrick // prepended to them.
51809467b48Spatrick #define HANDLE_MDNODE_LEAF(CLASS) \
51909467b48Spatrick static_assert( \
52009467b48Spatrick alignof(uint64_t) >= alignof(CLASS), \
52109467b48Spatrick "Alignment is insufficient after objects prepended to " #CLASS);
52209467b48Spatrick #include "llvm/IR/Metadata.def"
52309467b48Spatrick
operator new(size_t Size,size_t NumOps,StorageType Storage)524*d415bd75Srobert void *MDNode::operator new(size_t Size, size_t NumOps, StorageType Storage) {
52509467b48Spatrick // uint64_t is the most aligned type we need support (ensured by static_assert
52609467b48Spatrick // above)
527*d415bd75Srobert size_t AllocSize =
528*d415bd75Srobert alignTo(Header::getAllocSize(Storage, NumOps), alignof(uint64_t));
529*d415bd75Srobert char *Mem = reinterpret_cast<char *>(::operator new(AllocSize + Size));
530*d415bd75Srobert Header *H = new (Mem + AllocSize - sizeof(Header)) Header(NumOps, Storage);
531*d415bd75Srobert return reinterpret_cast<void *>(H + 1);
53209467b48Spatrick }
53309467b48Spatrick
operator delete(void * N)534*d415bd75Srobert void MDNode::operator delete(void *N) {
535*d415bd75Srobert Header *H = reinterpret_cast<Header *>(N) - 1;
536*d415bd75Srobert void *Mem = H->getAllocation();
537*d415bd75Srobert H->~Header();
538*d415bd75Srobert ::operator delete(Mem);
53909467b48Spatrick }
54009467b48Spatrick
MDNode(LLVMContext & Context,unsigned ID,StorageType Storage,ArrayRef<Metadata * > Ops1,ArrayRef<Metadata * > Ops2)54109467b48Spatrick MDNode::MDNode(LLVMContext &Context, unsigned ID, StorageType Storage,
54209467b48Spatrick ArrayRef<Metadata *> Ops1, ArrayRef<Metadata *> Ops2)
543*d415bd75Srobert : Metadata(ID, Storage), Context(Context) {
54409467b48Spatrick unsigned Op = 0;
54509467b48Spatrick for (Metadata *MD : Ops1)
54609467b48Spatrick setOperand(Op++, MD);
54709467b48Spatrick for (Metadata *MD : Ops2)
54809467b48Spatrick setOperand(Op++, MD);
54909467b48Spatrick
55009467b48Spatrick if (!isUniqued())
55109467b48Spatrick return;
55209467b48Spatrick
55309467b48Spatrick // Count the unresolved operands. If there are any, RAUW support will be
55409467b48Spatrick // added lazily on first reference.
55509467b48Spatrick countUnresolvedOperands();
55609467b48Spatrick }
55709467b48Spatrick
clone() const55809467b48Spatrick TempMDNode MDNode::clone() const {
55909467b48Spatrick switch (getMetadataID()) {
56009467b48Spatrick default:
56109467b48Spatrick llvm_unreachable("Invalid MDNode subclass");
56209467b48Spatrick #define HANDLE_MDNODE_LEAF(CLASS) \
56309467b48Spatrick case CLASS##Kind: \
56409467b48Spatrick return cast<CLASS>(this)->cloneImpl();
56509467b48Spatrick #include "llvm/IR/Metadata.def"
56609467b48Spatrick }
56709467b48Spatrick }
56809467b48Spatrick
Header(size_t NumOps,StorageType Storage)569*d415bd75Srobert MDNode::Header::Header(size_t NumOps, StorageType Storage) {
570*d415bd75Srobert IsLarge = isLarge(NumOps);
571*d415bd75Srobert IsResizable = isResizable(Storage);
572*d415bd75Srobert SmallSize = getSmallSize(NumOps, IsResizable, IsLarge);
573*d415bd75Srobert if (IsLarge) {
574*d415bd75Srobert SmallNumOps = 0;
575*d415bd75Srobert new (getLargePtr()) LargeStorageVector();
576*d415bd75Srobert getLarge().resize(NumOps);
577*d415bd75Srobert return;
578*d415bd75Srobert }
579*d415bd75Srobert SmallNumOps = NumOps;
580*d415bd75Srobert MDOperand *O = reinterpret_cast<MDOperand *>(this) - SmallSize;
581*d415bd75Srobert for (MDOperand *E = O + SmallSize; O != E;)
582*d415bd75Srobert (void)new (O++) MDOperand();
583*d415bd75Srobert }
584*d415bd75Srobert
~Header()585*d415bd75Srobert MDNode::Header::~Header() {
586*d415bd75Srobert if (IsLarge) {
587*d415bd75Srobert getLarge().~LargeStorageVector();
588*d415bd75Srobert return;
589*d415bd75Srobert }
590*d415bd75Srobert MDOperand *O = reinterpret_cast<MDOperand *>(this);
591*d415bd75Srobert for (MDOperand *E = O - SmallSize; O != E; --O)
592*d415bd75Srobert (void)(O - 1)->~MDOperand();
593*d415bd75Srobert }
594*d415bd75Srobert
getSmallPtr()595*d415bd75Srobert void *MDNode::Header::getSmallPtr() {
596*d415bd75Srobert static_assert(alignof(MDOperand) <= alignof(Header),
597*d415bd75Srobert "MDOperand too strongly aligned");
598*d415bd75Srobert return reinterpret_cast<char *>(const_cast<Header *>(this)) -
599*d415bd75Srobert sizeof(MDOperand) * SmallSize;
600*d415bd75Srobert }
601*d415bd75Srobert
resize(size_t NumOps)602*d415bd75Srobert void MDNode::Header::resize(size_t NumOps) {
603*d415bd75Srobert assert(IsResizable && "Node is not resizable");
604*d415bd75Srobert if (operands().size() == NumOps)
605*d415bd75Srobert return;
606*d415bd75Srobert
607*d415bd75Srobert if (IsLarge)
608*d415bd75Srobert getLarge().resize(NumOps);
609*d415bd75Srobert else if (NumOps <= SmallSize)
610*d415bd75Srobert resizeSmall(NumOps);
611*d415bd75Srobert else
612*d415bd75Srobert resizeSmallToLarge(NumOps);
613*d415bd75Srobert }
614*d415bd75Srobert
resizeSmall(size_t NumOps)615*d415bd75Srobert void MDNode::Header::resizeSmall(size_t NumOps) {
616*d415bd75Srobert assert(!IsLarge && "Expected a small MDNode");
617*d415bd75Srobert assert(NumOps <= SmallSize && "NumOps too large for small resize");
618*d415bd75Srobert
619*d415bd75Srobert MutableArrayRef<MDOperand> ExistingOps = operands();
620*d415bd75Srobert assert(NumOps != ExistingOps.size() && "Expected a different size");
621*d415bd75Srobert
622*d415bd75Srobert int NumNew = (int)NumOps - (int)ExistingOps.size();
623*d415bd75Srobert MDOperand *O = ExistingOps.end();
624*d415bd75Srobert for (int I = 0, E = NumNew; I < E; ++I)
625*d415bd75Srobert (O++)->reset();
626*d415bd75Srobert for (int I = 0, E = NumNew; I > E; --I)
627*d415bd75Srobert (--O)->reset();
628*d415bd75Srobert SmallNumOps = NumOps;
629*d415bd75Srobert assert(O == operands().end() && "Operands not (un)initialized until the end");
630*d415bd75Srobert }
631*d415bd75Srobert
resizeSmallToLarge(size_t NumOps)632*d415bd75Srobert void MDNode::Header::resizeSmallToLarge(size_t NumOps) {
633*d415bd75Srobert assert(!IsLarge && "Expected a small MDNode");
634*d415bd75Srobert assert(NumOps > SmallSize && "Expected NumOps to be larger than allocation");
635*d415bd75Srobert LargeStorageVector NewOps;
636*d415bd75Srobert NewOps.resize(NumOps);
637*d415bd75Srobert llvm::move(operands(), NewOps.begin());
638*d415bd75Srobert resizeSmall(0);
639*d415bd75Srobert new (getLargePtr()) LargeStorageVector(std::move(NewOps));
640*d415bd75Srobert IsLarge = true;
641*d415bd75Srobert }
642*d415bd75Srobert
isOperandUnresolved(Metadata * Op)64309467b48Spatrick static bool isOperandUnresolved(Metadata *Op) {
64409467b48Spatrick if (auto *N = dyn_cast_or_null<MDNode>(Op))
64509467b48Spatrick return !N->isResolved();
64609467b48Spatrick return false;
64709467b48Spatrick }
64809467b48Spatrick
countUnresolvedOperands()64909467b48Spatrick void MDNode::countUnresolvedOperands() {
650*d415bd75Srobert assert(getNumUnresolved() == 0 && "Expected unresolved ops to be uncounted");
65109467b48Spatrick assert(isUniqued() && "Expected this to be uniqued");
652*d415bd75Srobert setNumUnresolved(count_if(operands(), isOperandUnresolved));
65309467b48Spatrick }
65409467b48Spatrick
makeUniqued()65509467b48Spatrick void MDNode::makeUniqued() {
65609467b48Spatrick assert(isTemporary() && "Expected this to be temporary");
65709467b48Spatrick assert(!isResolved() && "Expected this to be unresolved");
65809467b48Spatrick
65909467b48Spatrick // Enable uniquing callbacks.
66009467b48Spatrick for (auto &Op : mutable_operands())
66109467b48Spatrick Op.reset(Op.get(), this);
66209467b48Spatrick
66309467b48Spatrick // Make this 'uniqued'.
66409467b48Spatrick Storage = Uniqued;
66509467b48Spatrick countUnresolvedOperands();
666*d415bd75Srobert if (!getNumUnresolved()) {
66709467b48Spatrick dropReplaceableUses();
66809467b48Spatrick assert(isResolved() && "Expected this to be resolved");
66909467b48Spatrick }
67009467b48Spatrick
67109467b48Spatrick assert(isUniqued() && "Expected this to be uniqued");
67209467b48Spatrick }
67309467b48Spatrick
makeDistinct()67409467b48Spatrick void MDNode::makeDistinct() {
67509467b48Spatrick assert(isTemporary() && "Expected this to be temporary");
67609467b48Spatrick assert(!isResolved() && "Expected this to be unresolved");
67709467b48Spatrick
67809467b48Spatrick // Drop RAUW support and store as a distinct node.
67909467b48Spatrick dropReplaceableUses();
68009467b48Spatrick storeDistinctInContext();
68109467b48Spatrick
68209467b48Spatrick assert(isDistinct() && "Expected this to be distinct");
68309467b48Spatrick assert(isResolved() && "Expected this to be resolved");
68409467b48Spatrick }
68509467b48Spatrick
resolve()68609467b48Spatrick void MDNode::resolve() {
68709467b48Spatrick assert(isUniqued() && "Expected this to be uniqued");
68809467b48Spatrick assert(!isResolved() && "Expected this to be unresolved");
68909467b48Spatrick
690*d415bd75Srobert setNumUnresolved(0);
69109467b48Spatrick dropReplaceableUses();
69209467b48Spatrick
69309467b48Spatrick assert(isResolved() && "Expected this to be resolved");
69409467b48Spatrick }
69509467b48Spatrick
dropReplaceableUses()69609467b48Spatrick void MDNode::dropReplaceableUses() {
697*d415bd75Srobert assert(!getNumUnresolved() && "Unexpected unresolved operand");
69809467b48Spatrick
69909467b48Spatrick // Drop any RAUW support.
70009467b48Spatrick if (Context.hasReplaceableUses())
70109467b48Spatrick Context.takeReplaceableUses()->resolveAllUses();
70209467b48Spatrick }
70309467b48Spatrick
resolveAfterOperandChange(Metadata * Old,Metadata * New)70409467b48Spatrick void MDNode::resolveAfterOperandChange(Metadata *Old, Metadata *New) {
70509467b48Spatrick assert(isUniqued() && "Expected this to be uniqued");
706*d415bd75Srobert assert(getNumUnresolved() != 0 && "Expected unresolved operands");
70709467b48Spatrick
70809467b48Spatrick // Check if an operand was resolved.
70909467b48Spatrick if (!isOperandUnresolved(Old)) {
71009467b48Spatrick if (isOperandUnresolved(New))
71109467b48Spatrick // An operand was un-resolved!
712*d415bd75Srobert setNumUnresolved(getNumUnresolved() + 1);
71309467b48Spatrick } else if (!isOperandUnresolved(New))
71409467b48Spatrick decrementUnresolvedOperandCount();
71509467b48Spatrick }
71609467b48Spatrick
decrementUnresolvedOperandCount()71709467b48Spatrick void MDNode::decrementUnresolvedOperandCount() {
71809467b48Spatrick assert(!isResolved() && "Expected this to be unresolved");
71909467b48Spatrick if (isTemporary())
72009467b48Spatrick return;
72109467b48Spatrick
72209467b48Spatrick assert(isUniqued() && "Expected this to be uniqued");
723*d415bd75Srobert setNumUnresolved(getNumUnresolved() - 1);
724*d415bd75Srobert if (getNumUnresolved())
72509467b48Spatrick return;
72609467b48Spatrick
72709467b48Spatrick // Last unresolved operand has just been resolved.
72809467b48Spatrick dropReplaceableUses();
72909467b48Spatrick assert(isResolved() && "Expected this to become resolved");
73009467b48Spatrick }
73109467b48Spatrick
resolveCycles()73209467b48Spatrick void MDNode::resolveCycles() {
73309467b48Spatrick if (isResolved())
73409467b48Spatrick return;
73509467b48Spatrick
73609467b48Spatrick // Resolve this node immediately.
73709467b48Spatrick resolve();
73809467b48Spatrick
73909467b48Spatrick // Resolve all operands.
74009467b48Spatrick for (const auto &Op : operands()) {
74109467b48Spatrick auto *N = dyn_cast_or_null<MDNode>(Op);
74209467b48Spatrick if (!N)
74309467b48Spatrick continue;
74409467b48Spatrick
74509467b48Spatrick assert(!N->isTemporary() &&
74609467b48Spatrick "Expected all forward declarations to be resolved");
74709467b48Spatrick if (!N->isResolved())
74809467b48Spatrick N->resolveCycles();
74909467b48Spatrick }
75009467b48Spatrick }
75109467b48Spatrick
hasSelfReference(MDNode * N)75209467b48Spatrick static bool hasSelfReference(MDNode *N) {
75373471bf0Spatrick return llvm::is_contained(N->operands(), N);
75409467b48Spatrick }
75509467b48Spatrick
replaceWithPermanentImpl()75609467b48Spatrick MDNode *MDNode::replaceWithPermanentImpl() {
75709467b48Spatrick switch (getMetadataID()) {
75809467b48Spatrick default:
75909467b48Spatrick // If this type isn't uniquable, replace with a distinct node.
76009467b48Spatrick return replaceWithDistinctImpl();
76109467b48Spatrick
76209467b48Spatrick #define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS) \
76309467b48Spatrick case CLASS##Kind: \
76409467b48Spatrick break;
76509467b48Spatrick #include "llvm/IR/Metadata.def"
76609467b48Spatrick }
76709467b48Spatrick
76809467b48Spatrick // Even if this type is uniquable, self-references have to be distinct.
76909467b48Spatrick if (hasSelfReference(this))
77009467b48Spatrick return replaceWithDistinctImpl();
77109467b48Spatrick return replaceWithUniquedImpl();
77209467b48Spatrick }
77309467b48Spatrick
replaceWithUniquedImpl()77409467b48Spatrick MDNode *MDNode::replaceWithUniquedImpl() {
77509467b48Spatrick // Try to uniquify in place.
77609467b48Spatrick MDNode *UniquedNode = uniquify();
77709467b48Spatrick
77809467b48Spatrick if (UniquedNode == this) {
77909467b48Spatrick makeUniqued();
78009467b48Spatrick return this;
78109467b48Spatrick }
78209467b48Spatrick
78309467b48Spatrick // Collision, so RAUW instead.
78409467b48Spatrick replaceAllUsesWith(UniquedNode);
78509467b48Spatrick deleteAsSubclass();
78609467b48Spatrick return UniquedNode;
78709467b48Spatrick }
78809467b48Spatrick
replaceWithDistinctImpl()78909467b48Spatrick MDNode *MDNode::replaceWithDistinctImpl() {
79009467b48Spatrick makeDistinct();
79109467b48Spatrick return this;
79209467b48Spatrick }
79309467b48Spatrick
recalculateHash()79409467b48Spatrick void MDTuple::recalculateHash() {
79509467b48Spatrick setHash(MDTupleInfo::KeyTy::calculateHash(this));
79609467b48Spatrick }
79709467b48Spatrick
dropAllReferences()79809467b48Spatrick void MDNode::dropAllReferences() {
799*d415bd75Srobert for (unsigned I = 0, E = getNumOperands(); I != E; ++I)
80009467b48Spatrick setOperand(I, nullptr);
80109467b48Spatrick if (Context.hasReplaceableUses()) {
80209467b48Spatrick Context.getReplaceableUses()->resolveAllUses(/* ResolveUsers */ false);
80309467b48Spatrick (void)Context.takeReplaceableUses();
80409467b48Spatrick }
80509467b48Spatrick }
80609467b48Spatrick
handleChangedOperand(void * Ref,Metadata * New)80709467b48Spatrick void MDNode::handleChangedOperand(void *Ref, Metadata *New) {
80809467b48Spatrick unsigned Op = static_cast<MDOperand *>(Ref) - op_begin();
80909467b48Spatrick assert(Op < getNumOperands() && "Expected valid operand");
81009467b48Spatrick
81109467b48Spatrick if (!isUniqued()) {
81209467b48Spatrick // This node is not uniqued. Just set the operand and be done with it.
81309467b48Spatrick setOperand(Op, New);
81409467b48Spatrick return;
81509467b48Spatrick }
81609467b48Spatrick
81709467b48Spatrick // This node is uniqued.
81809467b48Spatrick eraseFromStore();
81909467b48Spatrick
82009467b48Spatrick Metadata *Old = getOperand(Op);
82109467b48Spatrick setOperand(Op, New);
82209467b48Spatrick
82309467b48Spatrick // Drop uniquing for self-reference cycles and deleted constants.
82409467b48Spatrick if (New == this || (!New && Old && isa<ConstantAsMetadata>(Old))) {
82509467b48Spatrick if (!isResolved())
82609467b48Spatrick resolve();
82709467b48Spatrick storeDistinctInContext();
82809467b48Spatrick return;
82909467b48Spatrick }
83009467b48Spatrick
83109467b48Spatrick // Re-unique the node.
83209467b48Spatrick auto *Uniqued = uniquify();
83309467b48Spatrick if (Uniqued == this) {
83409467b48Spatrick if (!isResolved())
83509467b48Spatrick resolveAfterOperandChange(Old, New);
83609467b48Spatrick return;
83709467b48Spatrick }
83809467b48Spatrick
83909467b48Spatrick // Collision.
84009467b48Spatrick if (!isResolved()) {
84109467b48Spatrick // Still unresolved, so RAUW.
84209467b48Spatrick //
84309467b48Spatrick // First, clear out all operands to prevent any recursion (similar to
84409467b48Spatrick // dropAllReferences(), but we still need the use-list).
84509467b48Spatrick for (unsigned O = 0, E = getNumOperands(); O != E; ++O)
84609467b48Spatrick setOperand(O, nullptr);
84709467b48Spatrick if (Context.hasReplaceableUses())
84809467b48Spatrick Context.getReplaceableUses()->replaceAllUsesWith(Uniqued);
84909467b48Spatrick deleteAsSubclass();
85009467b48Spatrick return;
85109467b48Spatrick }
85209467b48Spatrick
85309467b48Spatrick // Store in non-uniqued form if RAUW isn't possible.
85409467b48Spatrick storeDistinctInContext();
85509467b48Spatrick }
85609467b48Spatrick
deleteAsSubclass()85709467b48Spatrick void MDNode::deleteAsSubclass() {
85809467b48Spatrick switch (getMetadataID()) {
85909467b48Spatrick default:
86009467b48Spatrick llvm_unreachable("Invalid subclass of MDNode");
86109467b48Spatrick #define HANDLE_MDNODE_LEAF(CLASS) \
86209467b48Spatrick case CLASS##Kind: \
86309467b48Spatrick delete cast<CLASS>(this); \
86409467b48Spatrick break;
86509467b48Spatrick #include "llvm/IR/Metadata.def"
86609467b48Spatrick }
86709467b48Spatrick }
86809467b48Spatrick
86909467b48Spatrick template <class T, class InfoT>
uniquifyImpl(T * N,DenseSet<T *,InfoT> & Store)87009467b48Spatrick static T *uniquifyImpl(T *N, DenseSet<T *, InfoT> &Store) {
87109467b48Spatrick if (T *U = getUniqued(Store, N))
87209467b48Spatrick return U;
87309467b48Spatrick
87409467b48Spatrick Store.insert(N);
87509467b48Spatrick return N;
87609467b48Spatrick }
87709467b48Spatrick
87809467b48Spatrick template <class NodeTy> struct MDNode::HasCachedHash {
87909467b48Spatrick using Yes = char[1];
88009467b48Spatrick using No = char[2];
88109467b48Spatrick template <class U, U Val> struct SFINAE {};
88209467b48Spatrick
88309467b48Spatrick template <class U>
88409467b48Spatrick static Yes &check(SFINAE<void (U::*)(unsigned), &U::setHash> *);
88509467b48Spatrick template <class U> static No &check(...);
88609467b48Spatrick
88709467b48Spatrick static const bool value = sizeof(check<NodeTy>(nullptr)) == sizeof(Yes);
88809467b48Spatrick };
88909467b48Spatrick
uniquify()89009467b48Spatrick MDNode *MDNode::uniquify() {
89109467b48Spatrick assert(!hasSelfReference(this) && "Cannot uniquify a self-referencing node");
89209467b48Spatrick
89309467b48Spatrick // Try to insert into uniquing store.
89409467b48Spatrick switch (getMetadataID()) {
89509467b48Spatrick default:
89609467b48Spatrick llvm_unreachable("Invalid or non-uniquable subclass of MDNode");
89709467b48Spatrick #define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS) \
89809467b48Spatrick case CLASS##Kind: { \
89909467b48Spatrick CLASS *SubclassThis = cast<CLASS>(this); \
90009467b48Spatrick std::integral_constant<bool, HasCachedHash<CLASS>::value> \
90109467b48Spatrick ShouldRecalculateHash; \
90209467b48Spatrick dispatchRecalculateHash(SubclassThis, ShouldRecalculateHash); \
90309467b48Spatrick return uniquifyImpl(SubclassThis, getContext().pImpl->CLASS##s); \
90409467b48Spatrick }
90509467b48Spatrick #include "llvm/IR/Metadata.def"
90609467b48Spatrick }
90709467b48Spatrick }
90809467b48Spatrick
eraseFromStore()90909467b48Spatrick void MDNode::eraseFromStore() {
91009467b48Spatrick switch (getMetadataID()) {
91109467b48Spatrick default:
91209467b48Spatrick llvm_unreachable("Invalid or non-uniquable subclass of MDNode");
91309467b48Spatrick #define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS) \
91409467b48Spatrick case CLASS##Kind: \
91509467b48Spatrick getContext().pImpl->CLASS##s.erase(cast<CLASS>(this)); \
91609467b48Spatrick break;
91709467b48Spatrick #include "llvm/IR/Metadata.def"
91809467b48Spatrick }
91909467b48Spatrick }
92009467b48Spatrick
getImpl(LLVMContext & Context,ArrayRef<Metadata * > MDs,StorageType Storage,bool ShouldCreate)92109467b48Spatrick MDTuple *MDTuple::getImpl(LLVMContext &Context, ArrayRef<Metadata *> MDs,
92209467b48Spatrick StorageType Storage, bool ShouldCreate) {
92309467b48Spatrick unsigned Hash = 0;
92409467b48Spatrick if (Storage == Uniqued) {
92509467b48Spatrick MDTupleInfo::KeyTy Key(MDs);
92609467b48Spatrick if (auto *N = getUniqued(Context.pImpl->MDTuples, Key))
92709467b48Spatrick return N;
92809467b48Spatrick if (!ShouldCreate)
92909467b48Spatrick return nullptr;
93009467b48Spatrick Hash = Key.getHash();
93109467b48Spatrick } else {
93209467b48Spatrick assert(ShouldCreate && "Expected non-uniqued nodes to always be created");
93309467b48Spatrick }
93409467b48Spatrick
935*d415bd75Srobert return storeImpl(new (MDs.size(), Storage)
936*d415bd75Srobert MDTuple(Context, Storage, Hash, MDs),
93709467b48Spatrick Storage, Context.pImpl->MDTuples);
93809467b48Spatrick }
93909467b48Spatrick
deleteTemporary(MDNode * N)94009467b48Spatrick void MDNode::deleteTemporary(MDNode *N) {
94109467b48Spatrick assert(N->isTemporary() && "Expected temporary node");
94209467b48Spatrick N->replaceAllUsesWith(nullptr);
94309467b48Spatrick N->deleteAsSubclass();
94409467b48Spatrick }
94509467b48Spatrick
storeDistinctInContext()94609467b48Spatrick void MDNode::storeDistinctInContext() {
94709467b48Spatrick assert(!Context.hasReplaceableUses() && "Unexpected replaceable uses");
948*d415bd75Srobert assert(!getNumUnresolved() && "Unexpected unresolved nodes");
94909467b48Spatrick Storage = Distinct;
95009467b48Spatrick assert(isResolved() && "Expected this to be resolved");
95109467b48Spatrick
95209467b48Spatrick // Reset the hash.
95309467b48Spatrick switch (getMetadataID()) {
95409467b48Spatrick default:
95509467b48Spatrick llvm_unreachable("Invalid subclass of MDNode");
95609467b48Spatrick #define HANDLE_MDNODE_LEAF(CLASS) \
95709467b48Spatrick case CLASS##Kind: { \
95809467b48Spatrick std::integral_constant<bool, HasCachedHash<CLASS>::value> ShouldResetHash; \
95909467b48Spatrick dispatchResetHash(cast<CLASS>(this), ShouldResetHash); \
96009467b48Spatrick break; \
96109467b48Spatrick }
96209467b48Spatrick #include "llvm/IR/Metadata.def"
96309467b48Spatrick }
96409467b48Spatrick
96509467b48Spatrick getContext().pImpl->DistinctMDNodes.push_back(this);
96609467b48Spatrick }
96709467b48Spatrick
replaceOperandWith(unsigned I,Metadata * New)96809467b48Spatrick void MDNode::replaceOperandWith(unsigned I, Metadata *New) {
96909467b48Spatrick if (getOperand(I) == New)
97009467b48Spatrick return;
97109467b48Spatrick
97209467b48Spatrick if (!isUniqued()) {
97309467b48Spatrick setOperand(I, New);
97409467b48Spatrick return;
97509467b48Spatrick }
97609467b48Spatrick
97709467b48Spatrick handleChangedOperand(mutable_begin() + I, New);
97809467b48Spatrick }
97909467b48Spatrick
setOperand(unsigned I,Metadata * New)98009467b48Spatrick void MDNode::setOperand(unsigned I, Metadata *New) {
981*d415bd75Srobert assert(I < getNumOperands());
98209467b48Spatrick mutable_begin()[I].reset(New, isUniqued() ? this : nullptr);
98309467b48Spatrick }
98409467b48Spatrick
98509467b48Spatrick /// Get a node or a self-reference that looks like it.
98609467b48Spatrick ///
98709467b48Spatrick /// Special handling for finding self-references, for use by \a
98809467b48Spatrick /// MDNode::concatenate() and \a MDNode::intersect() to maintain behaviour from
98909467b48Spatrick /// when self-referencing nodes were still uniqued. If the first operand has
99009467b48Spatrick /// the same operands as \c Ops, return the first operand instead.
getOrSelfReference(LLVMContext & Context,ArrayRef<Metadata * > Ops)99109467b48Spatrick static MDNode *getOrSelfReference(LLVMContext &Context,
99209467b48Spatrick ArrayRef<Metadata *> Ops) {
99309467b48Spatrick if (!Ops.empty())
99409467b48Spatrick if (MDNode *N = dyn_cast_or_null<MDNode>(Ops[0]))
99509467b48Spatrick if (N->getNumOperands() == Ops.size() && N == N->getOperand(0)) {
99609467b48Spatrick for (unsigned I = 1, E = Ops.size(); I != E; ++I)
99709467b48Spatrick if (Ops[I] != N->getOperand(I))
99809467b48Spatrick return MDNode::get(Context, Ops);
99909467b48Spatrick return N;
100009467b48Spatrick }
100109467b48Spatrick
100209467b48Spatrick return MDNode::get(Context, Ops);
100309467b48Spatrick }
100409467b48Spatrick
concatenate(MDNode * A,MDNode * B)100509467b48Spatrick MDNode *MDNode::concatenate(MDNode *A, MDNode *B) {
100609467b48Spatrick if (!A)
100709467b48Spatrick return B;
100809467b48Spatrick if (!B)
100909467b48Spatrick return A;
101009467b48Spatrick
101109467b48Spatrick SmallSetVector<Metadata *, 4> MDs(A->op_begin(), A->op_end());
101209467b48Spatrick MDs.insert(B->op_begin(), B->op_end());
101309467b48Spatrick
101409467b48Spatrick // FIXME: This preserves long-standing behaviour, but is it really the right
101509467b48Spatrick // behaviour? Or was that an unintended side-effect of node uniquing?
101609467b48Spatrick return getOrSelfReference(A->getContext(), MDs.getArrayRef());
101709467b48Spatrick }
101809467b48Spatrick
intersect(MDNode * A,MDNode * B)101909467b48Spatrick MDNode *MDNode::intersect(MDNode *A, MDNode *B) {
102009467b48Spatrick if (!A || !B)
102109467b48Spatrick return nullptr;
102209467b48Spatrick
102309467b48Spatrick SmallSetVector<Metadata *, 4> MDs(A->op_begin(), A->op_end());
102409467b48Spatrick SmallPtrSet<Metadata *, 4> BSet(B->op_begin(), B->op_end());
1025097a140dSpatrick MDs.remove_if([&](Metadata *MD) { return !BSet.count(MD); });
102609467b48Spatrick
102709467b48Spatrick // FIXME: This preserves long-standing behaviour, but is it really the right
102809467b48Spatrick // behaviour? Or was that an unintended side-effect of node uniquing?
102909467b48Spatrick return getOrSelfReference(A->getContext(), MDs.getArrayRef());
103009467b48Spatrick }
103109467b48Spatrick
getMostGenericAliasScope(MDNode * A,MDNode * B)103209467b48Spatrick MDNode *MDNode::getMostGenericAliasScope(MDNode *A, MDNode *B) {
103309467b48Spatrick if (!A || !B)
103409467b48Spatrick return nullptr;
103509467b48Spatrick
103673471bf0Spatrick // Take the intersection of domains then union the scopes
103773471bf0Spatrick // within those domains
103873471bf0Spatrick SmallPtrSet<const MDNode *, 16> ADomains;
103973471bf0Spatrick SmallPtrSet<const MDNode *, 16> IntersectDomains;
104073471bf0Spatrick SmallSetVector<Metadata *, 4> MDs;
104173471bf0Spatrick for (const MDOperand &MDOp : A->operands())
104273471bf0Spatrick if (const MDNode *NAMD = dyn_cast<MDNode>(MDOp))
104373471bf0Spatrick if (const MDNode *Domain = AliasScopeNode(NAMD).getDomain())
104473471bf0Spatrick ADomains.insert(Domain);
104573471bf0Spatrick
104673471bf0Spatrick for (const MDOperand &MDOp : B->operands())
104773471bf0Spatrick if (const MDNode *NAMD = dyn_cast<MDNode>(MDOp))
104873471bf0Spatrick if (const MDNode *Domain = AliasScopeNode(NAMD).getDomain())
104973471bf0Spatrick if (ADomains.contains(Domain)) {
105073471bf0Spatrick IntersectDomains.insert(Domain);
105173471bf0Spatrick MDs.insert(MDOp);
105273471bf0Spatrick }
105373471bf0Spatrick
105473471bf0Spatrick for (const MDOperand &MDOp : A->operands())
105573471bf0Spatrick if (const MDNode *NAMD = dyn_cast<MDNode>(MDOp))
105673471bf0Spatrick if (const MDNode *Domain = AliasScopeNode(NAMD).getDomain())
105773471bf0Spatrick if (IntersectDomains.contains(Domain))
105873471bf0Spatrick MDs.insert(MDOp);
105973471bf0Spatrick
106073471bf0Spatrick return MDs.empty() ? nullptr
106173471bf0Spatrick : getOrSelfReference(A->getContext(), MDs.getArrayRef());
106209467b48Spatrick }
106309467b48Spatrick
getMostGenericFPMath(MDNode * A,MDNode * B)106409467b48Spatrick MDNode *MDNode::getMostGenericFPMath(MDNode *A, MDNode *B) {
106509467b48Spatrick if (!A || !B)
106609467b48Spatrick return nullptr;
106709467b48Spatrick
106809467b48Spatrick APFloat AVal = mdconst::extract<ConstantFP>(A->getOperand(0))->getValueAPF();
106909467b48Spatrick APFloat BVal = mdconst::extract<ConstantFP>(B->getOperand(0))->getValueAPF();
1070097a140dSpatrick if (AVal < BVal)
107109467b48Spatrick return A;
107209467b48Spatrick return B;
107309467b48Spatrick }
107409467b48Spatrick
isContiguous(const ConstantRange & A,const ConstantRange & B)107509467b48Spatrick static bool isContiguous(const ConstantRange &A, const ConstantRange &B) {
107609467b48Spatrick return A.getUpper() == B.getLower() || A.getLower() == B.getUpper();
107709467b48Spatrick }
107809467b48Spatrick
canBeMerged(const ConstantRange & A,const ConstantRange & B)107909467b48Spatrick static bool canBeMerged(const ConstantRange &A, const ConstantRange &B) {
108009467b48Spatrick return !A.intersectWith(B).isEmptySet() || isContiguous(A, B);
108109467b48Spatrick }
108209467b48Spatrick
tryMergeRange(SmallVectorImpl<ConstantInt * > & EndPoints,ConstantInt * Low,ConstantInt * High)108309467b48Spatrick static bool tryMergeRange(SmallVectorImpl<ConstantInt *> &EndPoints,
108409467b48Spatrick ConstantInt *Low, ConstantInt *High) {
108509467b48Spatrick ConstantRange NewRange(Low->getValue(), High->getValue());
108609467b48Spatrick unsigned Size = EndPoints.size();
108709467b48Spatrick APInt LB = EndPoints[Size - 2]->getValue();
108809467b48Spatrick APInt LE = EndPoints[Size - 1]->getValue();
108909467b48Spatrick ConstantRange LastRange(LB, LE);
109009467b48Spatrick if (canBeMerged(NewRange, LastRange)) {
109109467b48Spatrick ConstantRange Union = LastRange.unionWith(NewRange);
109209467b48Spatrick Type *Ty = High->getType();
109309467b48Spatrick EndPoints[Size - 2] =
109409467b48Spatrick cast<ConstantInt>(ConstantInt::get(Ty, Union.getLower()));
109509467b48Spatrick EndPoints[Size - 1] =
109609467b48Spatrick cast<ConstantInt>(ConstantInt::get(Ty, Union.getUpper()));
109709467b48Spatrick return true;
109809467b48Spatrick }
109909467b48Spatrick return false;
110009467b48Spatrick }
110109467b48Spatrick
addRange(SmallVectorImpl<ConstantInt * > & EndPoints,ConstantInt * Low,ConstantInt * High)110209467b48Spatrick static void addRange(SmallVectorImpl<ConstantInt *> &EndPoints,
110309467b48Spatrick ConstantInt *Low, ConstantInt *High) {
110409467b48Spatrick if (!EndPoints.empty())
110509467b48Spatrick if (tryMergeRange(EndPoints, Low, High))
110609467b48Spatrick return;
110709467b48Spatrick
110809467b48Spatrick EndPoints.push_back(Low);
110909467b48Spatrick EndPoints.push_back(High);
111009467b48Spatrick }
111109467b48Spatrick
getMostGenericRange(MDNode * A,MDNode * B)111209467b48Spatrick MDNode *MDNode::getMostGenericRange(MDNode *A, MDNode *B) {
111309467b48Spatrick // Given two ranges, we want to compute the union of the ranges. This
111409467b48Spatrick // is slightly complicated by having to combine the intervals and merge
111509467b48Spatrick // the ones that overlap.
111609467b48Spatrick
111709467b48Spatrick if (!A || !B)
111809467b48Spatrick return nullptr;
111909467b48Spatrick
112009467b48Spatrick if (A == B)
112109467b48Spatrick return A;
112209467b48Spatrick
112309467b48Spatrick // First, walk both lists in order of the lower boundary of each interval.
112409467b48Spatrick // At each step, try to merge the new interval to the last one we adedd.
112509467b48Spatrick SmallVector<ConstantInt *, 4> EndPoints;
112609467b48Spatrick int AI = 0;
112709467b48Spatrick int BI = 0;
112809467b48Spatrick int AN = A->getNumOperands() / 2;
112909467b48Spatrick int BN = B->getNumOperands() / 2;
113009467b48Spatrick while (AI < AN && BI < BN) {
113109467b48Spatrick ConstantInt *ALow = mdconst::extract<ConstantInt>(A->getOperand(2 * AI));
113209467b48Spatrick ConstantInt *BLow = mdconst::extract<ConstantInt>(B->getOperand(2 * BI));
113309467b48Spatrick
113409467b48Spatrick if (ALow->getValue().slt(BLow->getValue())) {
113509467b48Spatrick addRange(EndPoints, ALow,
113609467b48Spatrick mdconst::extract<ConstantInt>(A->getOperand(2 * AI + 1)));
113709467b48Spatrick ++AI;
113809467b48Spatrick } else {
113909467b48Spatrick addRange(EndPoints, BLow,
114009467b48Spatrick mdconst::extract<ConstantInt>(B->getOperand(2 * BI + 1)));
114109467b48Spatrick ++BI;
114209467b48Spatrick }
114309467b48Spatrick }
114409467b48Spatrick while (AI < AN) {
114509467b48Spatrick addRange(EndPoints, mdconst::extract<ConstantInt>(A->getOperand(2 * AI)),
114609467b48Spatrick mdconst::extract<ConstantInt>(A->getOperand(2 * AI + 1)));
114709467b48Spatrick ++AI;
114809467b48Spatrick }
114909467b48Spatrick while (BI < BN) {
115009467b48Spatrick addRange(EndPoints, mdconst::extract<ConstantInt>(B->getOperand(2 * BI)),
115109467b48Spatrick mdconst::extract<ConstantInt>(B->getOperand(2 * BI + 1)));
115209467b48Spatrick ++BI;
115309467b48Spatrick }
115409467b48Spatrick
115509467b48Spatrick // If we have more than 2 ranges (4 endpoints) we have to try to merge
115609467b48Spatrick // the last and first ones.
115709467b48Spatrick unsigned Size = EndPoints.size();
115809467b48Spatrick if (Size > 4) {
115909467b48Spatrick ConstantInt *FB = EndPoints[0];
116009467b48Spatrick ConstantInt *FE = EndPoints[1];
116109467b48Spatrick if (tryMergeRange(EndPoints, FB, FE)) {
116209467b48Spatrick for (unsigned i = 0; i < Size - 2; ++i) {
116309467b48Spatrick EndPoints[i] = EndPoints[i + 2];
116409467b48Spatrick }
116509467b48Spatrick EndPoints.resize(Size - 2);
116609467b48Spatrick }
116709467b48Spatrick }
116809467b48Spatrick
116909467b48Spatrick // If in the end we have a single range, it is possible that it is now the
117009467b48Spatrick // full range. Just drop the metadata in that case.
117109467b48Spatrick if (EndPoints.size() == 2) {
117209467b48Spatrick ConstantRange Range(EndPoints[0]->getValue(), EndPoints[1]->getValue());
117309467b48Spatrick if (Range.isFullSet())
117409467b48Spatrick return nullptr;
117509467b48Spatrick }
117609467b48Spatrick
117709467b48Spatrick SmallVector<Metadata *, 4> MDs;
117809467b48Spatrick MDs.reserve(EndPoints.size());
117909467b48Spatrick for (auto *I : EndPoints)
118009467b48Spatrick MDs.push_back(ConstantAsMetadata::get(I));
118109467b48Spatrick return MDNode::get(A->getContext(), MDs);
118209467b48Spatrick }
118309467b48Spatrick
getMostGenericAlignmentOrDereferenceable(MDNode * A,MDNode * B)118409467b48Spatrick MDNode *MDNode::getMostGenericAlignmentOrDereferenceable(MDNode *A, MDNode *B) {
118509467b48Spatrick if (!A || !B)
118609467b48Spatrick return nullptr;
118709467b48Spatrick
118809467b48Spatrick ConstantInt *AVal = mdconst::extract<ConstantInt>(A->getOperand(0));
118909467b48Spatrick ConstantInt *BVal = mdconst::extract<ConstantInt>(B->getOperand(0));
119009467b48Spatrick if (AVal->getZExtValue() < BVal->getZExtValue())
119109467b48Spatrick return A;
119209467b48Spatrick return B;
119309467b48Spatrick }
119409467b48Spatrick
119509467b48Spatrick //===----------------------------------------------------------------------===//
119609467b48Spatrick // NamedMDNode implementation.
119709467b48Spatrick //
119809467b48Spatrick
getNMDOps(void * Operands)119909467b48Spatrick static SmallVector<TrackingMDRef, 4> &getNMDOps(void *Operands) {
120009467b48Spatrick return *(SmallVector<TrackingMDRef, 4> *)Operands;
120109467b48Spatrick }
120209467b48Spatrick
NamedMDNode(const Twine & N)120309467b48Spatrick NamedMDNode::NamedMDNode(const Twine &N)
120409467b48Spatrick : Name(N.str()), Operands(new SmallVector<TrackingMDRef, 4>()) {}
120509467b48Spatrick
~NamedMDNode()120609467b48Spatrick NamedMDNode::~NamedMDNode() {
120709467b48Spatrick dropAllReferences();
120809467b48Spatrick delete &getNMDOps(Operands);
120909467b48Spatrick }
121009467b48Spatrick
getNumOperands() const121109467b48Spatrick unsigned NamedMDNode::getNumOperands() const {
121209467b48Spatrick return (unsigned)getNMDOps(Operands).size();
121309467b48Spatrick }
121409467b48Spatrick
getOperand(unsigned i) const121509467b48Spatrick MDNode *NamedMDNode::getOperand(unsigned i) const {
121609467b48Spatrick assert(i < getNumOperands() && "Invalid Operand number!");
121709467b48Spatrick auto *N = getNMDOps(Operands)[i].get();
121809467b48Spatrick return cast_or_null<MDNode>(N);
121909467b48Spatrick }
122009467b48Spatrick
addOperand(MDNode * M)122109467b48Spatrick void NamedMDNode::addOperand(MDNode *M) { getNMDOps(Operands).emplace_back(M); }
122209467b48Spatrick
setOperand(unsigned I,MDNode * New)122309467b48Spatrick void NamedMDNode::setOperand(unsigned I, MDNode *New) {
122409467b48Spatrick assert(I < getNumOperands() && "Invalid operand number");
122509467b48Spatrick getNMDOps(Operands)[I].reset(New);
122609467b48Spatrick }
122709467b48Spatrick
eraseFromParent()122809467b48Spatrick void NamedMDNode::eraseFromParent() { getParent()->eraseNamedMetadata(this); }
122909467b48Spatrick
clearOperands()123009467b48Spatrick void NamedMDNode::clearOperands() { getNMDOps(Operands).clear(); }
123109467b48Spatrick
getName() const123209467b48Spatrick StringRef NamedMDNode::getName() const { return StringRef(Name); }
123309467b48Spatrick
123409467b48Spatrick //===----------------------------------------------------------------------===//
123509467b48Spatrick // Instruction Metadata method implementations.
123609467b48Spatrick //
123709467b48Spatrick
lookup(unsigned ID) const123873471bf0Spatrick MDNode *MDAttachments::lookup(unsigned ID) const {
123909467b48Spatrick for (const auto &A : Attachments)
124009467b48Spatrick if (A.MDKind == ID)
124109467b48Spatrick return A.Node;
124209467b48Spatrick return nullptr;
124309467b48Spatrick }
124409467b48Spatrick
get(unsigned ID,SmallVectorImpl<MDNode * > & Result) const124573471bf0Spatrick void MDAttachments::get(unsigned ID, SmallVectorImpl<MDNode *> &Result) const {
124609467b48Spatrick for (const auto &A : Attachments)
124709467b48Spatrick if (A.MDKind == ID)
124809467b48Spatrick Result.push_back(A.Node);
124909467b48Spatrick }
125009467b48Spatrick
getAll(SmallVectorImpl<std::pair<unsigned,MDNode * >> & Result) const125173471bf0Spatrick void MDAttachments::getAll(
125209467b48Spatrick SmallVectorImpl<std::pair<unsigned, MDNode *>> &Result) const {
125309467b48Spatrick for (const auto &A : Attachments)
125409467b48Spatrick Result.emplace_back(A.MDKind, A.Node);
125509467b48Spatrick
125609467b48Spatrick // Sort the resulting array so it is stable with respect to metadata IDs. We
125709467b48Spatrick // need to preserve the original insertion order though.
125873471bf0Spatrick if (Result.size() > 1)
125909467b48Spatrick llvm::stable_sort(Result, less_first());
126009467b48Spatrick }
126109467b48Spatrick
set(unsigned ID,MDNode * MD)126273471bf0Spatrick void MDAttachments::set(unsigned ID, MDNode *MD) {
126373471bf0Spatrick erase(ID);
126473471bf0Spatrick if (MD)
126573471bf0Spatrick insert(ID, *MD);
126673471bf0Spatrick }
126773471bf0Spatrick
insert(unsigned ID,MDNode & MD)126873471bf0Spatrick void MDAttachments::insert(unsigned ID, MDNode &MD) {
126973471bf0Spatrick Attachments.push_back({ID, TrackingMDNodeRef(&MD)});
127073471bf0Spatrick }
127173471bf0Spatrick
erase(unsigned ID)127273471bf0Spatrick bool MDAttachments::erase(unsigned ID) {
127373471bf0Spatrick if (empty())
127473471bf0Spatrick return false;
127573471bf0Spatrick
127673471bf0Spatrick // Common case is one value.
127773471bf0Spatrick if (Attachments.size() == 1 && Attachments.back().MDKind == ID) {
127873471bf0Spatrick Attachments.pop_back();
127973471bf0Spatrick return true;
128073471bf0Spatrick }
128173471bf0Spatrick
128273471bf0Spatrick auto OldSize = Attachments.size();
128373471bf0Spatrick llvm::erase_if(Attachments,
128473471bf0Spatrick [ID](const Attachment &A) { return A.MDKind == ID; });
128573471bf0Spatrick return OldSize != Attachments.size();
128673471bf0Spatrick }
128773471bf0Spatrick
getMetadata(unsigned KindID) const128873471bf0Spatrick MDNode *Value::getMetadata(unsigned KindID) const {
128973471bf0Spatrick if (!hasMetadata())
129073471bf0Spatrick return nullptr;
129173471bf0Spatrick const auto &Info = getContext().pImpl->ValueMetadata[this];
129273471bf0Spatrick assert(!Info.empty() && "bit out of sync with hash table");
129373471bf0Spatrick return Info.lookup(KindID);
129473471bf0Spatrick }
129573471bf0Spatrick
getMetadata(StringRef Kind) const129673471bf0Spatrick MDNode *Value::getMetadata(StringRef Kind) const {
129773471bf0Spatrick if (!hasMetadata())
129873471bf0Spatrick return nullptr;
129973471bf0Spatrick const auto &Info = getContext().pImpl->ValueMetadata[this];
130073471bf0Spatrick assert(!Info.empty() && "bit out of sync with hash table");
130173471bf0Spatrick return Info.lookup(getContext().getMDKindID(Kind));
130273471bf0Spatrick }
130373471bf0Spatrick
getMetadata(unsigned KindID,SmallVectorImpl<MDNode * > & MDs) const130473471bf0Spatrick void Value::getMetadata(unsigned KindID, SmallVectorImpl<MDNode *> &MDs) const {
130573471bf0Spatrick if (hasMetadata())
130673471bf0Spatrick getContext().pImpl->ValueMetadata[this].get(KindID, MDs);
130773471bf0Spatrick }
130873471bf0Spatrick
getMetadata(StringRef Kind,SmallVectorImpl<MDNode * > & MDs) const130973471bf0Spatrick void Value::getMetadata(StringRef Kind, SmallVectorImpl<MDNode *> &MDs) const {
131073471bf0Spatrick if (hasMetadata())
131173471bf0Spatrick getMetadata(getContext().getMDKindID(Kind), MDs);
131273471bf0Spatrick }
131373471bf0Spatrick
getAllMetadata(SmallVectorImpl<std::pair<unsigned,MDNode * >> & MDs) const131473471bf0Spatrick void Value::getAllMetadata(
131573471bf0Spatrick SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs) const {
131673471bf0Spatrick if (hasMetadata()) {
131773471bf0Spatrick assert(getContext().pImpl->ValueMetadata.count(this) &&
131873471bf0Spatrick "bit out of sync with hash table");
131973471bf0Spatrick const auto &Info = getContext().pImpl->ValueMetadata.find(this)->second;
132073471bf0Spatrick assert(!Info.empty() && "Shouldn't have called this");
132173471bf0Spatrick Info.getAll(MDs);
132273471bf0Spatrick }
132373471bf0Spatrick }
132473471bf0Spatrick
setMetadata(unsigned KindID,MDNode * Node)132573471bf0Spatrick void Value::setMetadata(unsigned KindID, MDNode *Node) {
132673471bf0Spatrick assert(isa<Instruction>(this) || isa<GlobalObject>(this));
132773471bf0Spatrick
132873471bf0Spatrick // Handle the case when we're adding/updating metadata on a value.
132973471bf0Spatrick if (Node) {
133073471bf0Spatrick auto &Info = getContext().pImpl->ValueMetadata[this];
133173471bf0Spatrick assert(!Info.empty() == HasMetadata && "bit out of sync with hash table");
133273471bf0Spatrick if (Info.empty())
133373471bf0Spatrick HasMetadata = true;
133473471bf0Spatrick Info.set(KindID, Node);
133573471bf0Spatrick return;
133673471bf0Spatrick }
133773471bf0Spatrick
133873471bf0Spatrick // Otherwise, we're removing metadata from an instruction.
133973471bf0Spatrick assert((HasMetadata == (getContext().pImpl->ValueMetadata.count(this) > 0)) &&
134073471bf0Spatrick "bit out of sync with hash table");
134173471bf0Spatrick if (!HasMetadata)
134273471bf0Spatrick return; // Nothing to remove!
134373471bf0Spatrick auto &Info = getContext().pImpl->ValueMetadata[this];
134473471bf0Spatrick
134573471bf0Spatrick // Handle removal of an existing value.
134673471bf0Spatrick Info.erase(KindID);
134773471bf0Spatrick if (!Info.empty())
134873471bf0Spatrick return;
134973471bf0Spatrick getContext().pImpl->ValueMetadata.erase(this);
135073471bf0Spatrick HasMetadata = false;
135173471bf0Spatrick }
135273471bf0Spatrick
setMetadata(StringRef Kind,MDNode * Node)135373471bf0Spatrick void Value::setMetadata(StringRef Kind, MDNode *Node) {
135473471bf0Spatrick if (!Node && !HasMetadata)
135573471bf0Spatrick return;
135673471bf0Spatrick setMetadata(getContext().getMDKindID(Kind), Node);
135773471bf0Spatrick }
135873471bf0Spatrick
addMetadata(unsigned KindID,MDNode & MD)135973471bf0Spatrick void Value::addMetadata(unsigned KindID, MDNode &MD) {
136073471bf0Spatrick assert(isa<Instruction>(this) || isa<GlobalObject>(this));
136173471bf0Spatrick if (!HasMetadata)
136273471bf0Spatrick HasMetadata = true;
136373471bf0Spatrick getContext().pImpl->ValueMetadata[this].insert(KindID, MD);
136473471bf0Spatrick }
136573471bf0Spatrick
addMetadata(StringRef Kind,MDNode & MD)136673471bf0Spatrick void Value::addMetadata(StringRef Kind, MDNode &MD) {
136773471bf0Spatrick addMetadata(getContext().getMDKindID(Kind), MD);
136873471bf0Spatrick }
136973471bf0Spatrick
eraseMetadata(unsigned KindID)137073471bf0Spatrick bool Value::eraseMetadata(unsigned KindID) {
137173471bf0Spatrick // Nothing to unset.
137273471bf0Spatrick if (!HasMetadata)
137373471bf0Spatrick return false;
137473471bf0Spatrick
137573471bf0Spatrick auto &Store = getContext().pImpl->ValueMetadata[this];
137673471bf0Spatrick bool Changed = Store.erase(KindID);
137773471bf0Spatrick if (Store.empty())
137873471bf0Spatrick clearMetadata();
137973471bf0Spatrick return Changed;
138073471bf0Spatrick }
138173471bf0Spatrick
clearMetadata()138273471bf0Spatrick void Value::clearMetadata() {
138373471bf0Spatrick if (!HasMetadata)
138473471bf0Spatrick return;
138573471bf0Spatrick assert(getContext().pImpl->ValueMetadata.count(this) &&
138673471bf0Spatrick "bit out of sync with hash table");
138773471bf0Spatrick getContext().pImpl->ValueMetadata.erase(this);
138873471bf0Spatrick HasMetadata = false;
138973471bf0Spatrick }
139073471bf0Spatrick
setMetadata(StringRef Kind,MDNode * Node)139109467b48Spatrick void Instruction::setMetadata(StringRef Kind, MDNode *Node) {
139209467b48Spatrick if (!Node && !hasMetadata())
139309467b48Spatrick return;
139409467b48Spatrick setMetadata(getContext().getMDKindID(Kind), Node);
139509467b48Spatrick }
139609467b48Spatrick
getMetadataImpl(StringRef Kind) const139709467b48Spatrick MDNode *Instruction::getMetadataImpl(StringRef Kind) const {
139809467b48Spatrick return getMetadataImpl(getContext().getMDKindID(Kind));
139909467b48Spatrick }
140009467b48Spatrick
dropUnknownNonDebugMetadata(ArrayRef<unsigned> KnownIDs)140109467b48Spatrick void Instruction::dropUnknownNonDebugMetadata(ArrayRef<unsigned> KnownIDs) {
140273471bf0Spatrick if (!Value::hasMetadata())
140309467b48Spatrick return; // Nothing to remove!
140409467b48Spatrick
140573471bf0Spatrick SmallSet<unsigned, 4> KnownSet;
140673471bf0Spatrick KnownSet.insert(KnownIDs.begin(), KnownIDs.end());
140773471bf0Spatrick
1408*d415bd75Srobert // A DIAssignID attachment is debug metadata, don't drop it.
1409*d415bd75Srobert KnownSet.insert(LLVMContext::MD_DIAssignID);
1410*d415bd75Srobert
141173471bf0Spatrick auto &MetadataStore = getContext().pImpl->ValueMetadata;
141273471bf0Spatrick auto &Info = MetadataStore[this];
141373471bf0Spatrick assert(!Info.empty() && "bit out of sync with hash table");
141473471bf0Spatrick Info.remove_if([&KnownSet](const MDAttachments::Attachment &I) {
141573471bf0Spatrick return !KnownSet.count(I.MDKind);
141609467b48Spatrick });
141709467b48Spatrick
141809467b48Spatrick if (Info.empty()) {
141909467b48Spatrick // Drop our entry at the store.
142073471bf0Spatrick clearMetadata();
142109467b48Spatrick }
142209467b48Spatrick }
142309467b48Spatrick
updateDIAssignIDMapping(DIAssignID * ID)1424*d415bd75Srobert void Instruction::updateDIAssignIDMapping(DIAssignID *ID) {
1425*d415bd75Srobert auto &IDToInstrs = getContext().pImpl->AssignmentIDToInstrs;
1426*d415bd75Srobert if (const DIAssignID *CurrentID =
1427*d415bd75Srobert cast_or_null<DIAssignID>(getMetadata(LLVMContext::MD_DIAssignID))) {
1428*d415bd75Srobert // Nothing to do if the ID isn't changing.
1429*d415bd75Srobert if (ID == CurrentID)
1430*d415bd75Srobert return;
1431*d415bd75Srobert
1432*d415bd75Srobert // Unmap this instruction from its current ID.
1433*d415bd75Srobert auto InstrsIt = IDToInstrs.find(CurrentID);
1434*d415bd75Srobert assert(InstrsIt != IDToInstrs.end() &&
1435*d415bd75Srobert "Expect existing attachment to be mapped");
1436*d415bd75Srobert
1437*d415bd75Srobert auto &InstVec = InstrsIt->second;
1438*d415bd75Srobert auto *InstIt = std::find(InstVec.begin(), InstVec.end(), this);
1439*d415bd75Srobert assert(InstIt != InstVec.end() &&
1440*d415bd75Srobert "Expect instruction to be mapped to attachment");
1441*d415bd75Srobert // The vector contains a ptr to this. If this is the only element in the
1442*d415bd75Srobert // vector, remove the ID:vector entry, otherwise just remove the
1443*d415bd75Srobert // instruction from the vector.
1444*d415bd75Srobert if (InstVec.size() == 1)
1445*d415bd75Srobert IDToInstrs.erase(InstrsIt);
1446*d415bd75Srobert else
1447*d415bd75Srobert InstVec.erase(InstIt);
1448*d415bd75Srobert }
1449*d415bd75Srobert
1450*d415bd75Srobert // Map this instruction to the new ID.
1451*d415bd75Srobert if (ID)
1452*d415bd75Srobert IDToInstrs[ID].push_back(this);
1453*d415bd75Srobert }
1454*d415bd75Srobert
setMetadata(unsigned KindID,MDNode * Node)145509467b48Spatrick void Instruction::setMetadata(unsigned KindID, MDNode *Node) {
145609467b48Spatrick if (!Node && !hasMetadata())
145709467b48Spatrick return;
145809467b48Spatrick
145909467b48Spatrick // Handle 'dbg' as a special case since it is not stored in the hash table.
146009467b48Spatrick if (KindID == LLVMContext::MD_dbg) {
146109467b48Spatrick DbgLoc = DebugLoc(Node);
146209467b48Spatrick return;
146309467b48Spatrick }
146409467b48Spatrick
1465*d415bd75Srobert // Update DIAssignID to Instruction(s) mapping.
1466*d415bd75Srobert if (KindID == LLVMContext::MD_DIAssignID) {
1467*d415bd75Srobert // The DIAssignID tracking infrastructure doesn't support RAUWing temporary
1468*d415bd75Srobert // nodes with DIAssignIDs. The cast_or_null below would also catch this, but
1469*d415bd75Srobert // having a dedicated assert helps make this obvious.
1470*d415bd75Srobert assert((!Node || !Node->isTemporary()) &&
1471*d415bd75Srobert "Temporary DIAssignIDs are invalid");
1472*d415bd75Srobert updateDIAssignIDMapping(cast_or_null<DIAssignID>(Node));
1473*d415bd75Srobert }
1474*d415bd75Srobert
147573471bf0Spatrick Value::setMetadata(KindID, Node);
147609467b48Spatrick }
147709467b48Spatrick
addAnnotationMetadata(StringRef Name)147873471bf0Spatrick void Instruction::addAnnotationMetadata(StringRef Name) {
147973471bf0Spatrick MDBuilder MDB(getContext());
148009467b48Spatrick
148173471bf0Spatrick auto *Existing = getMetadata(LLVMContext::MD_annotation);
148273471bf0Spatrick SmallVector<Metadata *, 4> Names;
148373471bf0Spatrick bool AppendName = true;
148473471bf0Spatrick if (Existing) {
148573471bf0Spatrick auto *Tuple = cast<MDTuple>(Existing);
148673471bf0Spatrick for (auto &N : Tuple->operands()) {
148773471bf0Spatrick if (cast<MDString>(N.get())->getString() == Name)
148873471bf0Spatrick AppendName = false;
148973471bf0Spatrick Names.push_back(N.get());
149073471bf0Spatrick }
149173471bf0Spatrick }
149273471bf0Spatrick if (AppendName)
149373471bf0Spatrick Names.push_back(MDB.createString(Name));
149409467b48Spatrick
149573471bf0Spatrick MDNode *MD = MDTuple::get(getContext(), Names);
149673471bf0Spatrick setMetadata(LLVMContext::MD_annotation, MD);
149709467b48Spatrick }
149809467b48Spatrick
getAAMetadata() const1499*d415bd75Srobert AAMDNodes Instruction::getAAMetadata() const {
1500*d415bd75Srobert AAMDNodes Result;
1501*d415bd75Srobert // Not using Instruction::hasMetadata() because we're not interested in
1502*d415bd75Srobert // DebugInfoMetadata.
1503*d415bd75Srobert if (Value::hasMetadata()) {
1504*d415bd75Srobert const auto &Info = getContext().pImpl->ValueMetadata[this];
1505*d415bd75Srobert Result.TBAA = Info.lookup(LLVMContext::MD_tbaa);
1506*d415bd75Srobert Result.TBAAStruct = Info.lookup(LLVMContext::MD_tbaa_struct);
1507*d415bd75Srobert Result.Scope = Info.lookup(LLVMContext::MD_alias_scope);
1508*d415bd75Srobert Result.NoAlias = Info.lookup(LLVMContext::MD_noalias);
1509*d415bd75Srobert }
1510*d415bd75Srobert return Result;
1511*d415bd75Srobert }
1512*d415bd75Srobert
setAAMetadata(const AAMDNodes & N)151309467b48Spatrick void Instruction::setAAMetadata(const AAMDNodes &N) {
151409467b48Spatrick setMetadata(LLVMContext::MD_tbaa, N.TBAA);
151509467b48Spatrick setMetadata(LLVMContext::MD_tbaa_struct, N.TBAAStruct);
151609467b48Spatrick setMetadata(LLVMContext::MD_alias_scope, N.Scope);
151709467b48Spatrick setMetadata(LLVMContext::MD_noalias, N.NoAlias);
151809467b48Spatrick }
151909467b48Spatrick
getMetadataImpl(unsigned KindID) const152009467b48Spatrick MDNode *Instruction::getMetadataImpl(unsigned KindID) const {
152109467b48Spatrick // Handle 'dbg' as a special case since it is not stored in the hash table.
152209467b48Spatrick if (KindID == LLVMContext::MD_dbg)
152309467b48Spatrick return DbgLoc.getAsMDNode();
152473471bf0Spatrick return Value::getMetadata(KindID);
152509467b48Spatrick }
152609467b48Spatrick
getAllMetadataImpl(SmallVectorImpl<std::pair<unsigned,MDNode * >> & Result) const152709467b48Spatrick void Instruction::getAllMetadataImpl(
152809467b48Spatrick SmallVectorImpl<std::pair<unsigned, MDNode *>> &Result) const {
152909467b48Spatrick Result.clear();
153009467b48Spatrick
153109467b48Spatrick // Handle 'dbg' as a special case since it is not stored in the hash table.
153209467b48Spatrick if (DbgLoc) {
153309467b48Spatrick Result.push_back(
153409467b48Spatrick std::make_pair((unsigned)LLVMContext::MD_dbg, DbgLoc.getAsMDNode()));
153509467b48Spatrick }
153673471bf0Spatrick Value::getAllMetadata(Result);
153709467b48Spatrick }
153809467b48Spatrick
extractProfTotalWeight(uint64_t & TotalVal) const153909467b48Spatrick bool Instruction::extractProfTotalWeight(uint64_t &TotalVal) const {
154073471bf0Spatrick assert(
154173471bf0Spatrick (getOpcode() == Instruction::Br || getOpcode() == Instruction::Select ||
154273471bf0Spatrick getOpcode() == Instruction::Call || getOpcode() == Instruction::Invoke ||
154373471bf0Spatrick getOpcode() == Instruction::IndirectBr ||
154409467b48Spatrick getOpcode() == Instruction::Switch) &&
154509467b48Spatrick "Looking for branch weights on something besides branch");
154609467b48Spatrick
1547*d415bd75Srobert return ::extractProfTotalWeight(*this, TotalVal);
154809467b48Spatrick }
154909467b48Spatrick
copyMetadata(const GlobalObject * Other,unsigned Offset)155009467b48Spatrick void GlobalObject::copyMetadata(const GlobalObject *Other, unsigned Offset) {
155109467b48Spatrick SmallVector<std::pair<unsigned, MDNode *>, 8> MDs;
155209467b48Spatrick Other->getAllMetadata(MDs);
155309467b48Spatrick for (auto &MD : MDs) {
155409467b48Spatrick // We need to adjust the type metadata offset.
155509467b48Spatrick if (Offset != 0 && MD.first == LLVMContext::MD_type) {
155609467b48Spatrick auto *OffsetConst = cast<ConstantInt>(
155709467b48Spatrick cast<ConstantAsMetadata>(MD.second->getOperand(0))->getValue());
155809467b48Spatrick Metadata *TypeId = MD.second->getOperand(1);
155909467b48Spatrick auto *NewOffsetMD = ConstantAsMetadata::get(ConstantInt::get(
156009467b48Spatrick OffsetConst->getType(), OffsetConst->getValue() + Offset));
156109467b48Spatrick addMetadata(LLVMContext::MD_type,
156209467b48Spatrick *MDNode::get(getContext(), {NewOffsetMD, TypeId}));
156309467b48Spatrick continue;
156409467b48Spatrick }
156509467b48Spatrick // If an offset adjustment was specified we need to modify the DIExpression
156609467b48Spatrick // to prepend the adjustment:
156709467b48Spatrick // !DIExpression(DW_OP_plus, Offset, [original expr])
156809467b48Spatrick auto *Attachment = MD.second;
156909467b48Spatrick if (Offset != 0 && MD.first == LLVMContext::MD_dbg) {
157009467b48Spatrick DIGlobalVariable *GV = dyn_cast<DIGlobalVariable>(Attachment);
157109467b48Spatrick DIExpression *E = nullptr;
157209467b48Spatrick if (!GV) {
157309467b48Spatrick auto *GVE = cast<DIGlobalVariableExpression>(Attachment);
157409467b48Spatrick GV = GVE->getVariable();
157509467b48Spatrick E = GVE->getExpression();
157609467b48Spatrick }
157709467b48Spatrick ArrayRef<uint64_t> OrigElements;
157809467b48Spatrick if (E)
157909467b48Spatrick OrigElements = E->getElements();
158009467b48Spatrick std::vector<uint64_t> Elements(OrigElements.size() + 2);
158109467b48Spatrick Elements[0] = dwarf::DW_OP_plus_uconst;
158209467b48Spatrick Elements[1] = Offset;
158309467b48Spatrick llvm::copy(OrigElements, Elements.begin() + 2);
158409467b48Spatrick E = DIExpression::get(getContext(), Elements);
158509467b48Spatrick Attachment = DIGlobalVariableExpression::get(getContext(), GV, E);
158609467b48Spatrick }
158709467b48Spatrick addMetadata(MD.first, *Attachment);
158809467b48Spatrick }
158909467b48Spatrick }
159009467b48Spatrick
addTypeMetadata(unsigned Offset,Metadata * TypeID)159109467b48Spatrick void GlobalObject::addTypeMetadata(unsigned Offset, Metadata *TypeID) {
159209467b48Spatrick addMetadata(
159309467b48Spatrick LLVMContext::MD_type,
159409467b48Spatrick *MDTuple::get(getContext(),
159509467b48Spatrick {ConstantAsMetadata::get(ConstantInt::get(
159609467b48Spatrick Type::getInt64Ty(getContext()), Offset)),
159709467b48Spatrick TypeID}));
159809467b48Spatrick }
159909467b48Spatrick
setVCallVisibilityMetadata(VCallVisibility Visibility)1600097a140dSpatrick void GlobalObject::setVCallVisibilityMetadata(VCallVisibility Visibility) {
1601097a140dSpatrick // Remove any existing vcall visibility metadata first in case we are
1602097a140dSpatrick // updating.
1603097a140dSpatrick eraseMetadata(LLVMContext::MD_vcall_visibility);
160409467b48Spatrick addMetadata(LLVMContext::MD_vcall_visibility,
160509467b48Spatrick *MDNode::get(getContext(),
160609467b48Spatrick {ConstantAsMetadata::get(ConstantInt::get(
160709467b48Spatrick Type::getInt64Ty(getContext()), Visibility))}));
160809467b48Spatrick }
160909467b48Spatrick
getVCallVisibility() const161009467b48Spatrick GlobalObject::VCallVisibility GlobalObject::getVCallVisibility() const {
161109467b48Spatrick if (MDNode *MD = getMetadata(LLVMContext::MD_vcall_visibility)) {
161209467b48Spatrick uint64_t Val = cast<ConstantInt>(
161309467b48Spatrick cast<ConstantAsMetadata>(MD->getOperand(0))->getValue())
161409467b48Spatrick ->getZExtValue();
161509467b48Spatrick assert(Val <= 2 && "unknown vcall visibility!");
161609467b48Spatrick return (VCallVisibility)Val;
161709467b48Spatrick }
161809467b48Spatrick return VCallVisibility::VCallVisibilityPublic;
161909467b48Spatrick }
162009467b48Spatrick
setSubprogram(DISubprogram * SP)162109467b48Spatrick void Function::setSubprogram(DISubprogram *SP) {
162209467b48Spatrick setMetadata(LLVMContext::MD_dbg, SP);
162309467b48Spatrick }
162409467b48Spatrick
getSubprogram() const162509467b48Spatrick DISubprogram *Function::getSubprogram() const {
162609467b48Spatrick return cast_or_null<DISubprogram>(getMetadata(LLVMContext::MD_dbg));
162709467b48Spatrick }
162809467b48Spatrick
shouldEmitDebugInfoForProfiling() const1629*d415bd75Srobert bool Function::shouldEmitDebugInfoForProfiling() const {
163009467b48Spatrick if (DISubprogram *SP = getSubprogram()) {
163109467b48Spatrick if (DICompileUnit *CU = SP->getUnit()) {
163209467b48Spatrick return CU->getDebugInfoForProfiling();
163309467b48Spatrick }
163409467b48Spatrick }
163509467b48Spatrick return false;
163609467b48Spatrick }
163709467b48Spatrick
addDebugInfo(DIGlobalVariableExpression * GV)163809467b48Spatrick void GlobalVariable::addDebugInfo(DIGlobalVariableExpression *GV) {
163909467b48Spatrick addMetadata(LLVMContext::MD_dbg, *GV);
164009467b48Spatrick }
164109467b48Spatrick
getDebugInfo(SmallVectorImpl<DIGlobalVariableExpression * > & GVs) const164209467b48Spatrick void GlobalVariable::getDebugInfo(
164309467b48Spatrick SmallVectorImpl<DIGlobalVariableExpression *> &GVs) const {
164409467b48Spatrick SmallVector<MDNode *, 1> MDs;
164509467b48Spatrick getMetadata(LLVMContext::MD_dbg, MDs);
164609467b48Spatrick for (MDNode *MD : MDs)
164709467b48Spatrick GVs.push_back(cast<DIGlobalVariableExpression>(MD));
164809467b48Spatrick }
1649