xref: /freebsd/contrib/llvm-project/llvm/lib/IR/Metadata.cpp (revision 0b57cec536236d46e3dba9bd041533462f33dbb7)
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