1//===-- Value.cpp - Implement the Value class -----------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements the Value, ValueHandle, and User classes.
10//
11//===----------------------------------------------------------------------===//
12
13#include "llvm/IR/Value.h"
14#include "LLVMContextImpl.h"
15#include "llvm/ADT/DenseMap.h"
16#include "llvm/ADT/STLExtras.h"
17#include "llvm/ADT/SmallString.h"
18#include "llvm/IR/Constant.h"
19#include "llvm/IR/Constants.h"
20#include "llvm/IR/DataLayout.h"
21#include "llvm/IR/DebugInfo.h"
22#include "llvm/IR/DerivedTypes.h"
23#include "llvm/IR/DerivedUser.h"
24#include "llvm/IR/GetElementPtrTypeIterator.h"
25#include "llvm/IR/InstrTypes.h"
26#include "llvm/IR/Instructions.h"
27#include "llvm/IR/IntrinsicInst.h"
28#include "llvm/IR/Module.h"
29#include "llvm/IR/Operator.h"
30#include "llvm/IR/TypedPointerType.h"
31#include "llvm/IR/ValueHandle.h"
32#include "llvm/IR/ValueSymbolTable.h"
33#include "llvm/Support/CommandLine.h"
34#include "llvm/Support/ErrorHandling.h"
35#include "llvm/Support/raw_ostream.h"
36#include <algorithm>
37
38using namespace llvm;
39
40static cl::opt<bool> UseDerefAtPointSemantics(
41 "use-dereferenceable-at-point-semantics", cl::Hidden, cl::init(Val: false),
42 cl::desc("Deref attributes and metadata infer facts at definition only"));
43
44//===----------------------------------------------------------------------===//
45// Value Class
46//===----------------------------------------------------------------------===//
47static inline Type *checkType(Type *Ty) {
48 assert(Ty && "Value defined with a null type: Error!");
49 assert(!isa<TypedPointerType>(Ty->getScalarType()) &&
50 "Cannot have values with typed pointer types");
51 return Ty;
52}
53
54Value::Value(Type *ty, unsigned scid)
55 : SubclassID(scid), HasValueHandle(0), SubclassOptionalData(0),
56 SubclassData(0), NumUserOperands(0), IsUsedByMD(false), HasName(false),
57 VTy(checkType(Ty: ty)) {
58 static_assert(ConstantFirstVal == 0, "!(SubclassID < ConstantFirstVal)");
59 // FIXME: Why isn't this in the subclass gunk??
60 // Note, we cannot call isa<CallInst> before the CallInst has been
61 // constructed.
62 unsigned OpCode = 0;
63 if (SubclassID >= InstructionVal)
64 OpCode = SubclassID - InstructionVal;
65 if (OpCode == Instruction::Call || OpCode == Instruction::Invoke ||
66 OpCode == Instruction::CallBr)
67 assert((VTy->isFirstClassType() || VTy->isVoidTy() || VTy->isStructTy()) &&
68 "invalid CallBase type!");
69 else if (SubclassID != BasicBlockVal &&
70 (/*SubclassID < ConstantFirstVal ||*/ SubclassID > ConstantLastVal))
71 assert((VTy->isFirstClassType() || VTy->isVoidTy()) &&
72 "Cannot create non-first-class values except for constants!");
73 static_assert(sizeof(Value) == 2 * sizeof(void *) + 2 * sizeof(unsigned),
74 "Value too big");
75}
76
77Value::~Value() {
78 // Notify all ValueHandles (if present) that this value is going away.
79 if (HasValueHandle)
80 ValueHandleBase::ValueIsDeleted(V: this);
81 if (isUsedByMetadata())
82 ValueAsMetadata::handleDeletion(V: this);
83
84#ifndef NDEBUG // Only in -g mode...
85 // Check to make sure that there are no uses of this value that are still
86 // around when the value is destroyed. If there are, then we have a dangling
87 // reference and something is wrong. This code is here to print out where
88 // the value is still being referenced.
89 //
90 // Note that use_empty() cannot be called here, as it eventually downcasts
91 // 'this' to GlobalValue (derived class of Value), but GlobalValue has already
92 // been destructed, so accessing it is UB.
93 //
94 if (!materialized_use_empty()) {
95 dbgs() << "While deleting: " << *VTy << " %" << getName() << "\n";
96 for (auto *U : users())
97 dbgs() << "Use still stuck around after Def is destroyed:" << *U << "\n";
98
99 llvm_unreachable("Uses remain when a value is destroyed!");
100 }
101#endif
102
103 // If this value is named, destroy the name. This should not be in a symtab
104 // at this point.
105 destroyValueName();
106}
107
108void Value::deleteValue() {
109 switch (getValueID()) {
110#define HANDLE_VALUE(Name) \
111 case Value::Name##Val: \
112 delete static_cast<Name *>(this); \
113 break;
114#define HANDLE_MEMORY_VALUE(Name) \
115 case Value::Name##Val: \
116 static_cast<DerivedUser *>(this)->DeleteValue( \
117 static_cast<DerivedUser *>(this)); \
118 break;
119#define HANDLE_CONSTANT(Name) \
120 case Value::Name##Val: \
121 llvm_unreachable("constants should be destroyed with destroyConstant"); \
122 break;
123#define HANDLE_INSTRUCTION(Name) /* nothing */
124#include "llvm/IR/Value.def"
125
126#define HANDLE_INST(N, OPC, CLASS) \
127 case addEnumValues(Value::InstructionVal, Instruction::OPC): \
128 delete static_cast<CLASS *>(this); \
129 break;
130#define HANDLE_USER_INST(N, OPC, CLASS)
131#include "llvm/IR/Instruction.def"
132
133 default:
134 llvm_unreachable("attempting to delete unknown value kind");
135 }
136}
137
138void Value::destroyValueName() {
139 ValueName *Name = getValueName();
140 if (Name) {
141 MallocAllocator Allocator;
142 Name->Destroy(allocator&: Allocator);
143 }
144 setValueName(nullptr);
145}
146
147bool Value::hasNUses(unsigned N) const {
148 if (!UseList)
149 return N == 0;
150
151 // TODO: Disallow for ConstantData and remove !UseList check?
152 return hasNItems(Begin: use_begin(), End: use_end(), N);
153}
154
155bool Value::hasNUsesOrMore(unsigned N) const {
156 // TODO: Disallow for ConstantData and remove !UseList check?
157 if (!UseList)
158 return N == 0;
159
160 return hasNItemsOrMore(Begin: use_begin(), End: use_end(), N);
161}
162
163bool Value::hasOneUser() const {
164 if (use_empty())
165 return false;
166 if (hasOneUse())
167 return true;
168 return std::equal(first1: ++user_begin(), last1: user_end(), first2: user_begin());
169}
170
171static bool isUnDroppableUser(const User *U) { return !U->isDroppable(); }
172
173Use *Value::getSingleUndroppableUse() {
174 Use *Result = nullptr;
175 for (Use &U : uses()) {
176 if (!U.getUser()->isDroppable()) {
177 if (Result)
178 return nullptr;
179 Result = &U;
180 }
181 }
182 return Result;
183}
184
185User *Value::getUniqueUndroppableUser() {
186 User *Result = nullptr;
187 for (auto *U : users()) {
188 if (!U->isDroppable()) {
189 if (Result && Result != U)
190 return nullptr;
191 Result = U;
192 }
193 }
194 return Result;
195}
196
197bool Value::hasNUndroppableUses(unsigned int N) const {
198 return hasNItems(Begin: user_begin(), End: user_end(), N, ShouldBeCounted&: isUnDroppableUser);
199}
200
201bool Value::hasNUndroppableUsesOrMore(unsigned int N) const {
202 return hasNItemsOrMore(Begin: user_begin(), End: user_end(), N, ShouldBeCounted&: isUnDroppableUser);
203}
204
205void Value::dropDroppableUses(
206 llvm::function_ref<bool(const Use *)> ShouldDrop) {
207 SmallVector<Use *, 8> ToBeEdited;
208 for (Use &U : uses())
209 if (U.getUser()->isDroppable() && ShouldDrop(&U))
210 ToBeEdited.push_back(Elt: &U);
211 for (Use *U : ToBeEdited)
212 dropDroppableUse(U&: *U);
213}
214
215void Value::dropDroppableUsesIn(User &Usr) {
216 assert(Usr.isDroppable() && "Expected a droppable user!");
217 for (Use &UsrOp : Usr.operands()) {
218 if (UsrOp.get() == this)
219 dropDroppableUse(U&: UsrOp);
220 }
221}
222
223void Value::dropDroppableUse(Use &U) {
224 if (auto *Assume = dyn_cast<AssumeInst>(Val: U.getUser())) {
225 unsigned OpNo = U.getOperandNo();
226 if (OpNo == 0)
227 U.set(ConstantInt::getTrue(Context&: Assume->getContext()));
228 else {
229 U.set(PoisonValue::get(T: U.get()->getType()));
230 CallInst::BundleOpInfo &BOI = Assume->getBundleOpInfoForOperand(OpIdx: OpNo);
231 BOI.Tag = Assume->getContext().pImpl->getOrInsertBundleTag(Tag: "ignore");
232 }
233 return;
234 }
235
236 llvm_unreachable("unknown droppable use");
237}
238
239bool Value::isUsedInBasicBlock(const BasicBlock *BB) const {
240 assert(hasUseList() && "ConstantData has no use-list");
241
242 // This can be computed either by scanning the instructions in BB, or by
243 // scanning the use list of this Value. Both lists can be very long, but
244 // usually one is quite short.
245 //
246 // Scan both lists simultaneously until one is exhausted. This limits the
247 // search to the shorter list.
248 BasicBlock::const_iterator BI = BB->begin(), BE = BB->end();
249 const_user_iterator UI = user_begin(), UE = user_end();
250 for (; BI != BE && UI != UE; ++BI, ++UI) {
251 // Scan basic block: Check if this Value is used by the instruction at BI.
252 if (is_contained(Range: BI->operands(), Element: this))
253 return true;
254 // Scan use list: Check if the use at UI is in BB.
255 const auto *User = dyn_cast<Instruction>(Val: *UI);
256 if (User && User->getParent() == BB)
257 return true;
258 }
259 return false;
260}
261
262unsigned Value::getNumUses() const {
263 // TODO: Disallow for ConstantData and remove !UseList check?
264 if (!UseList)
265 return 0;
266 return (unsigned)std::distance(first: use_begin(), last: use_end());
267}
268
269static bool getSymTab(Value *V, ValueSymbolTable *&ST) {
270 ST = nullptr;
271 if (Instruction *I = dyn_cast<Instruction>(Val: V)) {
272 if (BasicBlock *P = I->getParent())
273 if (Function *PP = P->getParent())
274 ST = PP->getValueSymbolTable();
275 } else if (BasicBlock *BB = dyn_cast<BasicBlock>(Val: V)) {
276 if (Function *P = BB->getParent())
277 ST = P->getValueSymbolTable();
278 } else if (GlobalValue *GV = dyn_cast<GlobalValue>(Val: V)) {
279 if (Module *P = GV->getParent())
280 ST = &P->getValueSymbolTable();
281 } else if (Argument *A = dyn_cast<Argument>(Val: V)) {
282 if (Function *P = A->getParent())
283 ST = P->getValueSymbolTable();
284 } else {
285 assert(isa<Constant>(V) && "Unknown value type!");
286 return true; // no name is setable for this.
287 }
288 return false;
289}
290
291ValueName *Value::getValueName() const {
292 if (!HasName) return nullptr;
293
294 LLVMContext &Ctx = getContext();
295 auto I = Ctx.pImpl->ValueNames.find(Val: this);
296 assert(I != Ctx.pImpl->ValueNames.end() &&
297 "No name entry found!");
298
299 return I->second;
300}
301
302void Value::setValueName(ValueName *VN) {
303 LLVMContext &Ctx = getContext();
304
305 assert(HasName == Ctx.pImpl->ValueNames.count(this) &&
306 "HasName bit out of sync!");
307
308 if (!VN) {
309 if (HasName)
310 Ctx.pImpl->ValueNames.erase(Val: this);
311 HasName = false;
312 return;
313 }
314
315 HasName = true;
316 Ctx.pImpl->ValueNames[this] = VN;
317}
318
319StringRef Value::getName() const {
320 // Make sure the empty string is still a C string. For historical reasons,
321 // some clients want to call .data() on the result and expect it to be null
322 // terminated.
323 if (!hasName())
324 return StringRef("", 0);
325 return getValueName()->getKey();
326}
327
328void Value::setNameImpl(const Twine &NewName) {
329 bool NeedNewName =
330 !getContext().shouldDiscardValueNames() || isa<GlobalValue>(Val: this);
331
332 // Fast-path: LLVMContext can be set to strip out non-GlobalValue names
333 // and there is no need to delete the old name.
334 if (!NeedNewName && !hasName())
335 return;
336
337 // Fast path for common IRBuilder case of setName("") when there is no name.
338 if (NewName.isTriviallyEmpty() && !hasName())
339 return;
340
341 SmallString<256> NameData;
342 StringRef NameRef = NeedNewName ? NewName.toStringRef(Out&: NameData) : "";
343 assert(!NameRef.contains(0) && "Null bytes are not allowed in names");
344
345 // Name isn't changing?
346 if (getName() == NameRef)
347 return;
348
349 assert(!getType()->isVoidTy() && "Cannot assign a name to void values!");
350
351 // Get the symbol table to update for this object.
352 ValueSymbolTable *ST;
353 if (getSymTab(V: this, ST))
354 return; // Cannot set a name on this value (e.g. constant).
355
356 ValueName *NewValueName = nullptr;
357 if (!ST) { // No symbol table to update? Just do the change.
358 if (!NameRef.empty()) {
359 // Create the new name.
360 MallocAllocator Allocator;
361 NewValueName = ValueName::create(key: NameRef, allocator&: Allocator);
362 }
363 // NOTE: Could optimize for the case the name is shrinking to not deallocate
364 // then reallocated.
365 destroyValueName();
366
367 if (NewValueName) {
368 assert(NeedNewName);
369 setValueName(NewValueName);
370 getValueName()->setValue(this);
371 }
372 return;
373 }
374
375 if (!NameRef.empty())
376 NewValueName = ST->createValueName(Name: NameRef, V: this);
377
378 // NOTE: Could optimize for the case the name is shrinking to not deallocate
379 // then reallocated.
380 if (hasName()) {
381 // Remove old name.
382 ST->removeValueName(V: getValueName());
383 destroyValueName();
384
385 if (NameRef.empty())
386 return;
387 }
388
389 // Name is changing to something new.
390 assert(NeedNewName && NewValueName != nullptr);
391 setValueName(NewValueName);
392}
393
394void Value::setName(const Twine &NewName) {
395 setNameImpl(NewName);
396 if (Function *F = dyn_cast<Function>(Val: this))
397 F->updateAfterNameChange();
398}
399
400void Value::takeName(Value *V) {
401 assert(V != this && "Illegal call to this->takeName(this)!");
402 ValueSymbolTable *ST = nullptr;
403 // If this value has a name, drop it.
404 if (hasName()) {
405 // Get the symtab this is in.
406 if (getSymTab(V: this, ST)) {
407 // We can't set a name on this value, but we need to clear V's name if
408 // it has one.
409 if (V->hasName()) V->setName("");
410 return; // Cannot set a name on this value (e.g. constant).
411 }
412
413 // Remove old name.
414 if (ST)
415 ST->removeValueName(V: getValueName());
416 destroyValueName();
417 }
418
419 // Now we know that this has no name.
420
421 // If V has no name either, we're done.
422 if (!V->hasName()) return;
423
424 // Get this's symtab if we didn't before.
425 if (!ST) {
426 if (getSymTab(V: this, ST)) {
427 // Clear V's name.
428 V->setName("");
429 return; // Cannot set a name on this value (e.g. constant).
430 }
431 }
432
433 // Get V's ST, this should always succeed, because V has a name.
434 ValueSymbolTable *VST;
435 bool Failure = getSymTab(V, ST&: VST);
436 assert(!Failure && "V has a name, so it should have a ST!"); (void)Failure;
437
438 // If these values are both in the same symtab, we can do this very fast.
439 // This works even if both values have no symtab yet.
440 if (ST == VST) {
441 // Take the name!
442 setValueName(V->getValueName());
443 V->setValueName(nullptr);
444 getValueName()->setValue(this);
445 return;
446 }
447
448 // Otherwise, things are slightly more complex. Remove V's name from VST and
449 // then reinsert it into ST.
450
451 if (VST)
452 VST->removeValueName(V: V->getValueName());
453 setValueName(V->getValueName());
454 V->setValueName(nullptr);
455 getValueName()->setValue(this);
456
457 if (ST)
458 ST->reinsertValue(V: this);
459}
460
461std::string Value::getNameOrAsOperand() const {
462 if (!getName().empty())
463 return std::string(getName());
464
465 std::string BBName;
466 raw_string_ostream OS(BBName);
467 printAsOperand(O&: OS, PrintType: false);
468 return OS.str();
469}
470
471void Value::assertModuleIsMaterializedImpl() const {
472#ifndef NDEBUG
473 const GlobalValue *GV = dyn_cast<GlobalValue>(this);
474 if (!GV)
475 return;
476 const Module *M = GV->getParent();
477 if (!M)
478 return;
479 assert(M->isMaterialized());
480#endif
481}
482
483#ifndef NDEBUG
484static bool contains(SmallPtrSetImpl<ConstantExpr *> &Cache, ConstantExpr *Expr,
485 Constant *C) {
486 if (!Cache.insert(Expr).second)
487 return false;
488
489 for (auto &O : Expr->operands()) {
490 if (O == C)
491 return true;
492 auto *CE = dyn_cast<ConstantExpr>(O);
493 if (!CE)
494 continue;
495 if (contains(Cache, CE, C))
496 return true;
497 }
498 return false;
499}
500
501static bool contains(Value *Expr, Value *V) {
502 if (Expr == V)
503 return true;
504
505 auto *C = dyn_cast<Constant>(V);
506 if (!C)
507 return false;
508
509 auto *CE = dyn_cast<ConstantExpr>(Expr);
510 if (!CE)
511 return false;
512
513 SmallPtrSet<ConstantExpr *, 4> Cache;
514 return contains(Cache, CE, C);
515}
516#endif // NDEBUG
517
518void Value::doRAUW(Value *New, ReplaceMetadataUses ReplaceMetaUses) {
519 assert(hasUseList() && "Cannot replace constant data");
520 assert(New && "Value::replaceAllUsesWith(<null>) is invalid!");
521 assert(!contains(New, this) &&
522 "this->replaceAllUsesWith(expr(this)) is NOT valid!");
523 assert(New->getType() == getType() &&
524 "replaceAllUses of value with new value of different type!");
525
526 // Notify all ValueHandles (if present) that this value is going away.
527 if (HasValueHandle)
528 ValueHandleBase::ValueIsRAUWd(Old: this, New);
529 if (ReplaceMetaUses == ReplaceMetadataUses::Yes && isUsedByMetadata())
530 ValueAsMetadata::handleRAUW(From: this, To: New);
531
532 while (!materialized_use_empty()) {
533 Use &U = *UseList;
534 // Must handle Constants specially, we cannot call replaceUsesOfWith on a
535 // constant because they are uniqued.
536 if (auto *C = dyn_cast<Constant>(Val: U.getUser())) {
537 if (!isa<GlobalValue>(Val: C)) {
538 C->handleOperandChange(this, New);
539 continue;
540 }
541 }
542
543 U.set(New);
544 }
545
546 if (BasicBlock *BB = dyn_cast<BasicBlock>(Val: this)) {
547 BB->replaceSuccessorsPhiUsesWith(New: cast<BasicBlock>(Val: New));
548 if (BB->hasAddressTaken())
549 BlockAddress::lookup(BB)->handleOperandChange(this, New);
550 }
551}
552
553void Value::replaceAllUsesWith(Value *New) {
554 doRAUW(New, ReplaceMetaUses: ReplaceMetadataUses::Yes);
555}
556
557void Value::replaceNonMetadataUsesWith(Value *New) {
558 doRAUW(New, ReplaceMetaUses: ReplaceMetadataUses::No);
559}
560
561bool Value::replaceUsesWithIf(Value *New,
562 llvm::function_ref<bool(Use &U)> ShouldReplace) {
563 assert(New && "Value::replaceUsesWithIf(<null>) is invalid!");
564 assert(New->getType() == getType() &&
565 "replaceUses of value with new value of different type!");
566
567 SmallVector<TrackingVH<Constant>, 8> Consts;
568 SmallPtrSet<Constant *, 8> Visited;
569
570 bool Changed = false;
571 for (Use &U : llvm::make_early_inc_range(Range: uses())) {
572 if (!ShouldReplace(U))
573 continue;
574 Changed = true;
575
576 // Must handle Constants specially, we cannot call replaceUsesOfWith on a
577 // constant because they are uniqued.
578 if (auto *C = dyn_cast<Constant>(Val: U.getUser())) {
579 if (!isa<GlobalValue>(Val: C)) {
580 if (Visited.insert(Ptr: C).second)
581 Consts.push_back(Elt: TrackingVH<Constant>(C));
582 continue;
583 }
584 }
585 U.set(New);
586 }
587
588 while (!Consts.empty()) {
589 // FIXME: handleOperandChange() updates all the uses in a given Constant,
590 // not just the one passed to ShouldReplace
591 Consts.pop_back_val()->handleOperandChange(this, New);
592 }
593
594 return Changed;
595}
596
597/// Replace debug record uses of MetadataAsValue(ValueAsMetadata(V)) outside BB
598/// with New.
599static void replaceDbgUsesOutsideBlock(Value *V, Value *New, BasicBlock *BB) {
600 SmallVector<DbgVariableRecord *> DPUsers;
601 findDbgUsers(V, DbgVariableRecords&: DPUsers);
602 for (auto *DVR : DPUsers) {
603 DbgMarker *Marker = DVR->getMarker();
604 if (Marker->getParent() != BB)
605 DVR->replaceVariableLocationOp(OldValue: V, NewValue: New);
606 }
607}
608
609// Like replaceAllUsesWith except it does not handle constants or basic blocks.
610// This routine leaves uses within BB.
611void Value::replaceUsesOutsideBlock(Value *New, BasicBlock *BB) {
612 assert(New && "Value::replaceUsesOutsideBlock(<null>, BB) is invalid!");
613 assert(!contains(New, this) &&
614 "this->replaceUsesOutsideBlock(expr(this), BB) is NOT valid!");
615 assert(New->getType() == getType() &&
616 "replaceUses of value with new value of different type!");
617 assert(BB && "Basic block that may contain a use of 'New' must be defined\n");
618
619 replaceDbgUsesOutsideBlock(V: this, New, BB);
620 replaceUsesWithIf(New, ShouldReplace: [BB](Use &U) {
621 auto *I = dyn_cast<Instruction>(Val: U.getUser());
622 // Don't replace if it's an instruction in the BB basic block.
623 return !I || I->getParent() != BB;
624 });
625}
626
627namespace {
628// Various metrics for how much to strip off of pointers.
629enum PointerStripKind {
630 PSK_ZeroIndices,
631 PSK_ZeroIndicesAndAliases,
632 PSK_ZeroIndicesSameRepresentation,
633 PSK_ForAliasAnalysis,
634 PSK_InBoundsConstantIndices,
635 PSK_InBounds
636};
637} // end anonymous namespace
638
639template <PointerStripKind StripKind> static void NoopCallback(const Value *) {}
640
641template <PointerStripKind StripKind>
642static const Value *stripPointerCastsAndOffsets(
643 const Value *V,
644 function_ref<void(const Value *)> Func = NoopCallback<StripKind>) {
645 if (!V->getType()->isPointerTy())
646 return V;
647
648 // Even though we don't look through PHI nodes, we could be called on an
649 // instruction in an unreachable block, which may be on a cycle.
650 SmallPtrSet<const Value *, 4> Visited;
651
652 Visited.insert(Ptr: V);
653 do {
654 Func(V);
655 if (auto *GEP = dyn_cast<GEPOperator>(Val: V)) {
656 switch (StripKind) {
657 case PSK_ZeroIndices:
658 case PSK_ZeroIndicesAndAliases:
659 case PSK_ZeroIndicesSameRepresentation:
660 case PSK_ForAliasAnalysis:
661 if (!GEP->hasAllZeroIndices())
662 return V;
663 break;
664 case PSK_InBoundsConstantIndices:
665 if (!GEP->hasAllConstantIndices())
666 return V;
667 [[fallthrough]];
668 case PSK_InBounds:
669 if (!GEP->isInBounds())
670 return V;
671 break;
672 }
673 V = GEP->getPointerOperand();
674 } else if (Operator::getOpcode(V) == Instruction::BitCast) {
675 Value *NewV = cast<Operator>(Val: V)->getOperand(i: 0);
676 if (!NewV->getType()->isPointerTy())
677 return V;
678 V = NewV;
679 } else if (StripKind != PSK_ZeroIndicesSameRepresentation &&
680 Operator::getOpcode(V) == Instruction::AddrSpaceCast) {
681 // TODO: If we know an address space cast will not change the
682 // representation we could look through it here as well.
683 V = cast<Operator>(Val: V)->getOperand(i: 0);
684 } else if (StripKind == PSK_ZeroIndicesAndAliases && isa<GlobalAlias>(Val: V)) {
685 V = cast<GlobalAlias>(Val: V)->getAliasee();
686 } else if (StripKind == PSK_ForAliasAnalysis && isa<PHINode>(Val: V) &&
687 cast<PHINode>(Val: V)->getNumIncomingValues() == 1) {
688 V = cast<PHINode>(Val: V)->getIncomingValue(i: 0);
689 } else {
690 if (const auto *Call = dyn_cast<CallBase>(Val: V)) {
691 if (const Value *RV = Call->getReturnedArgOperand()) {
692 V = RV;
693 continue;
694 }
695 // The result of launder.invariant.group must alias it's argument,
696 // but it can't be marked with returned attribute, that's why it needs
697 // special case.
698 if (StripKind == PSK_ForAliasAnalysis &&
699 (Call->getIntrinsicID() == Intrinsic::launder_invariant_group ||
700 Call->getIntrinsicID() == Intrinsic::strip_invariant_group)) {
701 V = Call->getArgOperand(i: 0);
702 continue;
703 }
704 }
705 return V;
706 }
707 assert(V->getType()->isPointerTy() && "Unexpected operand type!");
708 } while (Visited.insert(Ptr: V).second);
709
710 return V;
711}
712
713const Value *Value::stripPointerCasts() const {
714 return stripPointerCastsAndOffsets<PSK_ZeroIndices>(V: this);
715}
716
717const Value *Value::stripPointerCastsAndAliases() const {
718 return stripPointerCastsAndOffsets<PSK_ZeroIndicesAndAliases>(V: this);
719}
720
721const Value *Value::stripPointerCastsSameRepresentation() const {
722 return stripPointerCastsAndOffsets<PSK_ZeroIndicesSameRepresentation>(V: this);
723}
724
725const Value *Value::stripInBoundsConstantOffsets() const {
726 return stripPointerCastsAndOffsets<PSK_InBoundsConstantIndices>(V: this);
727}
728
729const Value *Value::stripPointerCastsForAliasAnalysis() const {
730 return stripPointerCastsAndOffsets<PSK_ForAliasAnalysis>(V: this);
731}
732
733const Value *Value::stripAndAccumulateConstantOffsets(
734 const DataLayout &DL, APInt &Offset, bool AllowNonInbounds,
735 bool AllowInvariantGroup,
736 function_ref<bool(Value &, APInt &)> ExternalAnalysis,
737 bool LookThroughIntToPtr) const {
738 if (!getType()->isPtrOrPtrVectorTy())
739 return this;
740
741 unsigned BitWidth = Offset.getBitWidth();
742 assert(BitWidth == DL.getIndexTypeSizeInBits(getType()) &&
743 "The offset bit width does not match the DL specification.");
744
745 // Even though we don't look through PHI nodes, we could be called on an
746 // instruction in an unreachable block, which may be on a cycle.
747 SmallPtrSet<const Value *, 4> Visited;
748 Visited.insert(Ptr: this);
749 const Value *V = this;
750 do {
751 if (auto *GEP = dyn_cast<GEPOperator>(Val: V)) {
752 // If in-bounds was requested, we do not strip non-in-bounds GEPs.
753 if (!AllowNonInbounds && !GEP->isInBounds())
754 return V;
755
756 // If one of the values we have visited is an addrspacecast, then
757 // the pointer type of this GEP may be different from the type
758 // of the Ptr parameter which was passed to this function. This
759 // means when we construct GEPOffset, we need to use the size
760 // of GEP's pointer type rather than the size of the original
761 // pointer type.
762 APInt GEPOffset(DL.getIndexTypeSizeInBits(Ty: V->getType()), 0);
763 if (!GEP->accumulateConstantOffset(DL, Offset&: GEPOffset, ExternalAnalysis))
764 return V;
765
766 // Stop traversal if the pointer offset wouldn't fit in the bit-width
767 // provided by the Offset argument. This can happen due to AddrSpaceCast
768 // stripping.
769 if (GEPOffset.getSignificantBits() > BitWidth)
770 return V;
771
772 // External Analysis can return a result higher/lower than the value
773 // represents. We need to detect overflow/underflow.
774 APInt GEPOffsetST = GEPOffset.sextOrTrunc(width: BitWidth);
775 if (!ExternalAnalysis) {
776 Offset += GEPOffsetST;
777 } else {
778 bool Overflow = false;
779 APInt OldOffset = Offset;
780 Offset = Offset.sadd_ov(RHS: GEPOffsetST, Overflow);
781 if (Overflow) {
782 Offset = std::move(OldOffset);
783 return V;
784 }
785 }
786 V = GEP->getPointerOperand();
787 } else if (Operator::getOpcode(V) == Instruction::BitCast) {
788 const Value *Src = cast<Operator>(Val: V)->getOperand(i: 0);
789 if (!Src->getType()->isPtrOrPtrVectorTy())
790 return V;
791 V = Src;
792 } else if (Operator::getOpcode(V) == Instruction::AddrSpaceCast) {
793 V = cast<Operator>(Val: V)->getOperand(i: 0);
794 } else if (auto *GA = dyn_cast<GlobalAlias>(Val: V)) {
795 if (!GA->isInterposable())
796 V = GA->getAliasee();
797 } else if (const auto *Call = dyn_cast<CallBase>(Val: V)) {
798 if (const Value *RV = Call->getReturnedArgOperand())
799 V = RV;
800 if (AllowInvariantGroup && Call->isLaunderOrStripInvariantGroup())
801 V = Call->getArgOperand(i: 0);
802 } else if (auto *Int2Ptr = dyn_cast<Operator>(Val: V)) {
803 // Try to accumulate across (inttoptr (add (ptrtoint p), off)).
804 if (!AllowNonInbounds || !LookThroughIntToPtr || !Int2Ptr ||
805 Int2Ptr->getOpcode() != Instruction::IntToPtr ||
806 Int2Ptr->getOperand(i: 0)->getType()->getScalarSizeInBits() != BitWidth)
807 return V;
808
809 auto *Add = dyn_cast<AddOperator>(Val: Int2Ptr->getOperand(i: 0));
810 if (!Add)
811 return V;
812
813 auto *Ptr2Int = dyn_cast<PtrToIntOperator>(Val: Add->getOperand(i_nocapture: 0));
814 auto *CI = dyn_cast<ConstantInt>(Val: Add->getOperand(i_nocapture: 1));
815 if (!Ptr2Int || !CI)
816 return V;
817
818 Offset += CI->getValue();
819 V = Ptr2Int->getOperand(i_nocapture: 0);
820 }
821 assert(V->getType()->isPtrOrPtrVectorTy() && "Unexpected operand type!");
822 } while (Visited.insert(Ptr: V).second);
823
824 return V;
825}
826
827const Value *
828Value::stripInBoundsOffsets(function_ref<void(const Value *)> Func) const {
829 return stripPointerCastsAndOffsets<PSK_InBounds>(V: this, Func);
830}
831
832bool Value::canBeFreed() const {
833 assert(getType()->isPointerTy());
834
835 // Cases that can simply never be deallocated
836 // *) Constants aren't allocated per se, thus not deallocated either.
837 if (isa<Constant>(Val: this))
838 return false;
839
840 // Allocas cannot be freed: They remain dereferenceable after lifetime.end,
841 // in the sense that they can be loaded from without UB. They only become
842 // non-writable, which is not tracked by this API.
843 if (isa<AllocaInst>(Val: this))
844 return false;
845
846 // Handle byval/byref/sret/inalloca/preallocated arguments. The storage
847 // lifetime is guaranteed to be longer than the callee's lifetime.
848 if (auto *A = dyn_cast<Argument>(Val: this)) {
849 if (A->hasPointeeInMemoryValueAttr())
850 return false;
851 // A nofree function can not free (including via synchronization) any
852 // allocations that existed prior to the call, but may free allocations
853 // created inside the function. This logic is limited to argument pointers,
854 // as they definitely exist prior to the call.
855 const Function *F = A->getParent();
856 if (F->doesNotFreeMemory())
857 return false;
858
859 // nofree on the argument ensures that it cannot be freed through that
860 // pointer. noalias additionally ensures that it can't be freed through
861 // another pointer to the same allocation. Readonly implies nofree.
862 if ((A->hasNoFreeAttr() || A->onlyReadsMemory()) && A->hasNoAliasAttr())
863 return false;
864 }
865
866 if (auto *ITP = dyn_cast<IntToPtrInst>(Val: this);
867 ITP && ITP->hasMetadata(KindID: LLVMContext::MD_nofree))
868 return false;
869
870 const Function *F = nullptr;
871 if (auto *I = dyn_cast<Instruction>(Val: this))
872 F = I->getFunction();
873 if (auto *A = dyn_cast<Argument>(Val: this))
874 F = A->getParent();
875
876 if (!F)
877 return true;
878
879 // With garbage collection, deallocation typically occurs solely at or after
880 // safepoints. If we're compiling for a collector which uses the
881 // gc.statepoint infrastructure, safepoints aren't explicitly present
882 // in the IR until after lowering from abstract to physical machine model.
883 // The collector could chose to mix explicit deallocation and gc'd objects
884 // which is why we need the explicit opt in on a per collector basis.
885 if (!F->hasGC())
886 return true;
887
888 const auto &GCName = F->getGC();
889 if (GCName == "statepoint-example") {
890 auto *PT = cast<PointerType>(Val: this->getType());
891 if (PT->getAddressSpace() != 1)
892 // For the sake of this example GC, we arbitrarily pick addrspace(1) as
893 // our GC managed heap. This must match the same check in
894 // RewriteStatepointsForGC (and probably needs better factored.)
895 return true;
896
897 // It is cheaper to scan for a declaration than to scan for a use in this
898 // function. Note that gc.statepoint is a type overloaded function so the
899 // usual trick of requesting declaration of the intrinsic from the module
900 // doesn't work.
901 for (auto &Fn : *F->getParent())
902 if (Fn.getIntrinsicID() == Intrinsic::experimental_gc_statepoint)
903 return true;
904 return false;
905 }
906 return true;
907}
908
909uint64_t Value::getPointerDereferenceableBytes(const DataLayout &DL,
910 bool &CanBeNull,
911 bool *CanBeFreed) const {
912 assert(getType()->isPointerTy() && "must be pointer");
913
914 uint64_t DerefBytes = 0;
915 CanBeNull = false;
916 bool CanNotBeFreed = false;
917 if (const Argument *A = dyn_cast<Argument>(Val: this)) {
918 DerefBytes = A->getDereferenceableBytes();
919 if (DerefBytes == 0) {
920 // Handle byval/byref/inalloca/preallocated arguments
921 if (Type *ArgMemTy = A->getPointeeInMemoryValueType()) {
922 if (ArgMemTy->isSized()) {
923 // FIXME: Why isn't this the type alloc size?
924 DerefBytes = DL.getTypeStoreSize(Ty: ArgMemTy).getKnownMinValue();
925 }
926 }
927 }
928
929 if (DerefBytes == 0) {
930 DerefBytes = A->getDereferenceableOrNullBytes();
931 CanBeNull = true;
932 }
933 } else if (const auto *Call = dyn_cast<CallBase>(Val: this)) {
934 DerefBytes = Call->getRetDereferenceableBytes();
935 if (DerefBytes == 0) {
936 DerefBytes = Call->getRetDereferenceableOrNullBytes();
937 CanBeNull = true;
938 }
939 } else if (const LoadInst *LI = dyn_cast<LoadInst>(Val: this)) {
940 if (MDNode *MD = LI->getMetadata(KindID: LLVMContext::MD_dereferenceable)) {
941 ConstantInt *CI = mdconst::extract<ConstantInt>(MD: MD->getOperand(I: 0));
942 DerefBytes = CI->getLimitedValue();
943 }
944 if (DerefBytes == 0) {
945 if (MDNode *MD =
946 LI->getMetadata(KindID: LLVMContext::MD_dereferenceable_or_null)) {
947 ConstantInt *CI = mdconst::extract<ConstantInt>(MD: MD->getOperand(I: 0));
948 DerefBytes = CI->getLimitedValue();
949 }
950 CanBeNull = true;
951 }
952 } else if (auto *IP = dyn_cast<IntToPtrInst>(Val: this)) {
953 if (MDNode *MD = IP->getMetadata(KindID: LLVMContext::MD_dereferenceable)) {
954 ConstantInt *CI = mdconst::extract<ConstantInt>(MD: MD->getOperand(I: 0));
955 DerefBytes = CI->getLimitedValue();
956 }
957 if (DerefBytes == 0) {
958 if (MDNode *MD =
959 IP->getMetadata(KindID: LLVMContext::MD_dereferenceable_or_null)) {
960 ConstantInt *CI = mdconst::extract<ConstantInt>(MD: MD->getOperand(I: 0));
961 DerefBytes = CI->getLimitedValue();
962 }
963 CanBeNull = true;
964 }
965 } else if (auto *AI = dyn_cast<AllocaInst>(Val: this)) {
966 if (std::optional<TypeSize> Size = AI->getAllocationSize(DL)) {
967 DerefBytes = Size->getKnownMinValue();
968 CanBeNull = false;
969 CanNotBeFreed = true;
970 }
971 } else if (auto *GV = dyn_cast<GlobalVariable>(Val: this)) {
972 if (GV->getValueType()->isSized() && !GV->hasExternalWeakLinkage()) {
973 // TODO: Don't outright reject hasExternalWeakLinkage but set the
974 // CanBeNull flag.
975 DerefBytes = DL.getTypeStoreSize(Ty: GV->getValueType()).getFixedValue();
976 CanBeNull = false;
977 CanNotBeFreed = true;
978 }
979 }
980
981 if (CanBeFreed) {
982 // Call canBeFreed() only if there are dereferenceable bytes and it's not
983 // one of the cases that can never be freed.
984 if (!CanNotBeFreed && DerefBytes != 0)
985 *CanBeFreed = UseDerefAtPointSemantics && canBeFreed();
986 else
987 *CanBeFreed = false;
988 }
989
990 return DerefBytes;
991}
992
993Align Value::getPointerAlignment(const DataLayout &DL) const {
994 assert(getType()->isPointerTy() && "must be pointer");
995 if (const Function *F = dyn_cast<Function>(Val: this)) {
996 Align FunctionPtrAlign = DL.getFunctionPtrAlign().valueOrOne();
997 switch (DL.getFunctionPtrAlignType()) {
998 case DataLayout::FunctionPtrAlignType::Independent:
999 return FunctionPtrAlign;
1000 case DataLayout::FunctionPtrAlignType::MultipleOfFunctionAlign:
1001 return std::max(a: FunctionPtrAlign, b: F->getAlign().valueOrOne());
1002 }
1003 llvm_unreachable("Unhandled FunctionPtrAlignType");
1004 } else if (auto *GVar = dyn_cast<GlobalVariable>(Val: this)) {
1005 const MaybeAlign Alignment(GVar->getAlign());
1006 if (!Alignment) {
1007 Type *ObjectType = GVar->getValueType();
1008 if (ObjectType->isSized()) {
1009 // If the object is defined in the current Module, we'll be giving
1010 // it the preferred alignment. Otherwise, we have to assume that it
1011 // may only have the minimum ABI alignment.
1012 if (GVar->isStrongDefinitionForLinker())
1013 return DL.getPreferredAlign(GV: GVar);
1014 else
1015 return DL.getABITypeAlign(Ty: ObjectType);
1016 }
1017 }
1018 return Alignment.valueOrOne();
1019 } else if (const Argument *A = dyn_cast<Argument>(Val: this)) {
1020 const MaybeAlign Alignment = A->getParamAlign();
1021 if (!Alignment && A->hasStructRetAttr()) {
1022 // An sret parameter has at least the ABI alignment of the return type.
1023 Type *EltTy = A->getParamStructRetType();
1024 if (EltTy->isSized())
1025 return DL.getABITypeAlign(Ty: EltTy);
1026 }
1027 return Alignment.valueOrOne();
1028 } else if (const AllocaInst *AI = dyn_cast<AllocaInst>(Val: this)) {
1029 return AI->getAlign();
1030 } else if (const auto *Call = dyn_cast<CallBase>(Val: this)) {
1031 MaybeAlign Alignment = Call->getRetAlign();
1032 if (!Alignment && Call->getCalledFunction())
1033 Alignment = Call->getCalledFunction()->getAttributes().getRetAlignment();
1034 return Alignment.valueOrOne();
1035 } else if (const LoadInst *LI = dyn_cast<LoadInst>(Val: this)) {
1036 if (MDNode *MD = LI->getMetadata(KindID: LLVMContext::MD_align)) {
1037 ConstantInt *CI = mdconst::extract<ConstantInt>(MD: MD->getOperand(I: 0));
1038 return Align(CI->getLimitedValue());
1039 }
1040 } else if (auto *CE = dyn_cast<ConstantExpr>(Val: this)) {
1041 // Determine the alignment of inttoptr(C).
1042 if (CE->getOpcode() == Instruction::IntToPtr &&
1043 isa<ConstantInt>(Val: CE->getOperand(i_nocapture: 0))) {
1044 ConstantInt *IntPtr = cast<ConstantInt>(Val: CE->getOperand(i_nocapture: 0));
1045 size_t TrailingZeros = IntPtr->getValue().countr_zero();
1046 // While the actual alignment may be large, elsewhere we have
1047 // an arbitrary upper alignmet limit, so let's clamp to it.
1048 return Align(TrailingZeros < Value::MaxAlignmentExponent
1049 ? uint64_t(1) << TrailingZeros
1050 : Value::MaximumAlignment);
1051 }
1052 }
1053 return Align(1);
1054}
1055
1056static std::optional<int64_t>
1057getOffsetFromIndex(const GEPOperator *GEP, unsigned Idx, const DataLayout &DL) {
1058 // Skip over the first indices.
1059 gep_type_iterator GTI = gep_type_begin(GEP);
1060 for (unsigned i = 1; i != Idx; ++i, ++GTI)
1061 /*skip along*/;
1062
1063 // Compute the offset implied by the rest of the indices.
1064 int64_t Offset = 0;
1065 for (unsigned i = Idx, e = GEP->getNumOperands(); i != e; ++i, ++GTI) {
1066 ConstantInt *OpC = dyn_cast<ConstantInt>(Val: GEP->getOperand(i_nocapture: i));
1067 if (!OpC)
1068 return std::nullopt;
1069 if (OpC->isZero())
1070 continue; // No offset.
1071
1072 // Handle struct indices, which add their field offset to the pointer.
1073 if (StructType *STy = GTI.getStructTypeOrNull()) {
1074 Offset += DL.getStructLayout(Ty: STy)->getElementOffset(Idx: OpC->getZExtValue());
1075 continue;
1076 }
1077
1078 // Otherwise, we have a sequential type like an array or fixed-length
1079 // vector. Multiply the index by the ElementSize.
1080 TypeSize Size = GTI.getSequentialElementStride(DL);
1081 if (Size.isScalable())
1082 return std::nullopt;
1083 Offset += Size.getFixedValue() * OpC->getSExtValue();
1084 }
1085
1086 return Offset;
1087}
1088
1089std::optional<int64_t> Value::getPointerOffsetFrom(const Value *Other,
1090 const DataLayout &DL) const {
1091 const Value *Ptr1 = Other;
1092 const Value *Ptr2 = this;
1093 APInt Offset1(DL.getIndexTypeSizeInBits(Ty: Ptr1->getType()), 0);
1094 APInt Offset2(DL.getIndexTypeSizeInBits(Ty: Ptr2->getType()), 0);
1095 Ptr1 = Ptr1->stripAndAccumulateConstantOffsets(DL, Offset&: Offset1, AllowNonInbounds: true);
1096 Ptr2 = Ptr2->stripAndAccumulateConstantOffsets(DL, Offset&: Offset2, AllowNonInbounds: true);
1097
1098 // Handle the trivial case first.
1099 if (Ptr1 == Ptr2)
1100 return Offset2.getSExtValue() - Offset1.getSExtValue();
1101
1102 const GEPOperator *GEP1 = dyn_cast<GEPOperator>(Val: Ptr1);
1103 const GEPOperator *GEP2 = dyn_cast<GEPOperator>(Val: Ptr2);
1104
1105 // Right now we handle the case when Ptr1/Ptr2 are both GEPs with an identical
1106 // base. After that base, they may have some number of common (and
1107 // potentially variable) indices. After that they handle some constant
1108 // offset, which determines their offset from each other. At this point, we
1109 // handle no other case.
1110 if (!GEP1 || !GEP2 || GEP1->getOperand(i_nocapture: 0) != GEP2->getOperand(i_nocapture: 0) ||
1111 GEP1->getSourceElementType() != GEP2->getSourceElementType())
1112 return std::nullopt;
1113
1114 // Skip any common indices and track the GEP types.
1115 unsigned Idx = 1;
1116 for (; Idx != GEP1->getNumOperands() && Idx != GEP2->getNumOperands(); ++Idx)
1117 if (GEP1->getOperand(i_nocapture: Idx) != GEP2->getOperand(i_nocapture: Idx))
1118 break;
1119
1120 auto IOffset1 = getOffsetFromIndex(GEP: GEP1, Idx, DL);
1121 auto IOffset2 = getOffsetFromIndex(GEP: GEP2, Idx, DL);
1122 if (!IOffset1 || !IOffset2)
1123 return std::nullopt;
1124 return *IOffset2 - *IOffset1 + Offset2.getSExtValue() -
1125 Offset1.getSExtValue();
1126}
1127
1128const Value *Value::DoPHITranslation(const BasicBlock *CurBB,
1129 const BasicBlock *PredBB) const {
1130 auto *PN = dyn_cast<PHINode>(Val: this);
1131 if (PN && PN->getParent() == CurBB)
1132 return PN->getIncomingValueForBlock(BB: PredBB);
1133 return this;
1134}
1135
1136void Value::reverseUseList() {
1137 if (!UseList || !UseList->Next)
1138 // No need to reverse 0 or 1 uses.
1139 return;
1140
1141 Use *Head = UseList;
1142 Use *Current = UseList->Next;
1143 Head->Next = nullptr;
1144 while (Current) {
1145 Use *Next = Current->Next;
1146 Current->Next = Head;
1147 Head->Prev = &Current->Next;
1148 Head = Current;
1149 Current = Next;
1150 }
1151 UseList = Head;
1152 Head->Prev = &UseList;
1153}
1154
1155bool Value::isSwiftError() const {
1156 auto *Arg = dyn_cast<Argument>(Val: this);
1157 if (Arg)
1158 return Arg->hasSwiftErrorAttr();
1159 auto *Alloca = dyn_cast<AllocaInst>(Val: this);
1160 if (!Alloca)
1161 return false;
1162 return Alloca->isSwiftError();
1163}
1164
1165//===----------------------------------------------------------------------===//
1166// ValueHandleBase Class
1167//===----------------------------------------------------------------------===//
1168
1169void ValueHandleBase::AddToExistingUseList(ValueHandleBase **List) {
1170 assert(List && "Handle list is null?");
1171
1172 // Splice ourselves into the list.
1173 Next = *List;
1174 *List = this;
1175 setPrevPtr(List);
1176 if (Next) {
1177 Next->setPrevPtr(&Next);
1178 assert(getValPtr() == Next->getValPtr() && "Added to wrong list?");
1179 }
1180}
1181
1182void ValueHandleBase::AddToExistingUseListAfter(ValueHandleBase *List) {
1183 assert(List && "Must insert after existing node");
1184
1185 Next = List->Next;
1186 setPrevPtr(&List->Next);
1187 List->Next = this;
1188 if (Next)
1189 Next->setPrevPtr(&Next);
1190}
1191
1192void ValueHandleBase::AddToUseList() {
1193 assert(getValPtr() && "Null pointer doesn't have a use list!");
1194
1195 LLVMContextImpl *pImpl = getValPtr()->getContext().pImpl;
1196
1197 if (getValPtr()->HasValueHandle) {
1198 // If this value already has a ValueHandle, then it must be in the
1199 // ValueHandles map already.
1200 ValueHandleBase *&Entry = pImpl->ValueHandles[getValPtr()];
1201 assert(Entry && "Value doesn't have any handles?");
1202 AddToExistingUseList(List: &Entry);
1203 return;
1204 }
1205
1206 // Ok, it doesn't have any handles yet, so we must insert it into the
1207 // DenseMap. However, doing this insertion could cause the DenseMap to
1208 // reallocate itself, which would invalidate all of the PrevP pointers that
1209 // point into the old table. Handle this by checking for reallocation and
1210 // updating the stale pointers only if needed.
1211 DenseMap<Value*, ValueHandleBase*> &Handles = pImpl->ValueHandles;
1212 const void *OldBucketPtr = Handles.getPointerIntoBucketsArray();
1213
1214 ValueHandleBase *&Entry = Handles[getValPtr()];
1215 assert(!Entry && "Value really did already have handles?");
1216 AddToExistingUseList(List: &Entry);
1217 getValPtr()->HasValueHandle = true;
1218
1219 // If reallocation didn't happen or if this was the first insertion, don't
1220 // walk the table.
1221 if (Handles.isPointerIntoBucketsArray(Ptr: OldBucketPtr) ||
1222 Handles.size() == 1) {
1223 return;
1224 }
1225
1226 // Okay, reallocation did happen. Fix the Prev Pointers.
1227 for (auto I = Handles.begin(), E = Handles.end(); I != E; ++I) {
1228 assert(I->second && I->first == I->second->getValPtr() &&
1229 "List invariant broken!");
1230 I->second->setPrevPtr(&I->second);
1231 }
1232}
1233
1234void ValueHandleBase::RemoveFromUseList() {
1235 assert(getValPtr() && getValPtr()->HasValueHandle &&
1236 "Pointer doesn't have a use list!");
1237
1238 // Unlink this from its use list.
1239 ValueHandleBase **PrevPtr = getPrevPtr();
1240 assert(*PrevPtr == this && "List invariant broken");
1241
1242 *PrevPtr = Next;
1243 if (Next) {
1244 assert(Next->getPrevPtr() == &Next && "List invariant broken");
1245 Next->setPrevPtr(PrevPtr);
1246 return;
1247 }
1248
1249 // If the Next pointer was null, then it is possible that this was the last
1250 // ValueHandle watching VP. If so, delete its entry from the ValueHandles
1251 // map.
1252 LLVMContextImpl *pImpl = getValPtr()->getContext().pImpl;
1253 DenseMap<Value*, ValueHandleBase*> &Handles = pImpl->ValueHandles;
1254 if (Handles.isPointerIntoBucketsArray(Ptr: PrevPtr)) {
1255 // TODO: Remove the only user of DenseMap's callback erase.
1256 Handles.erase(Val: getValPtr(), OnMoved: [](auto &Bucket) {
1257 Bucket.second->setPrevPtr(&Bucket.second);
1258 });
1259 getValPtr()->HasValueHandle = false;
1260 }
1261}
1262
1263void ValueHandleBase::ValueIsDeleted(Value *V) {
1264 assert(V->HasValueHandle && "Should only be called if ValueHandles present");
1265
1266 // Get the linked list base, which is guaranteed to exist since the
1267 // HasValueHandle flag is set.
1268 LLVMContextImpl *pImpl = V->getContext().pImpl;
1269 ValueHandleBase *Entry = pImpl->ValueHandles[V];
1270 assert(Entry && "Value bit set but no entries exist");
1271
1272 // We use a local ValueHandleBase as an iterator so that ValueHandles can add
1273 // and remove themselves from the list without breaking our iteration. This
1274 // is not really an AssertingVH; we just have to give ValueHandleBase a kind.
1275 // Note that we deliberately do not the support the case when dropping a value
1276 // handle results in a new value handle being permanently added to the list
1277 // (as might occur in theory for CallbackVH's): the new value handle will not
1278 // be processed and the checking code will mete out righteous punishment if
1279 // the handle is still present once we have finished processing all the other
1280 // value handles (it is fine to momentarily add then remove a value handle).
1281 for (ValueHandleBase Iterator(Assert, *Entry); Entry; Entry = Iterator.Next) {
1282 Iterator.RemoveFromUseList();
1283 Iterator.AddToExistingUseListAfter(List: Entry);
1284 assert(Entry->Next == &Iterator && "Loop invariant broken.");
1285
1286 switch (Entry->getKind()) {
1287 case Assert:
1288 break;
1289 case Weak:
1290 case WeakTracking:
1291 // WeakTracking and Weak just go to null, which unlinks them
1292 // from the list.
1293 Entry->operator=(RHS: nullptr);
1294 break;
1295 case Callback:
1296 // Forward to the subclass's implementation.
1297 static_cast<CallbackVH*>(Entry)->deleted();
1298 break;
1299 }
1300 }
1301
1302 // All callbacks, weak references, and assertingVHs should be dropped by now.
1303 if (V->HasValueHandle) {
1304#ifndef NDEBUG // Only in +Asserts mode...
1305 dbgs() << "While deleting: " << *V->getType() << " %" << V->getName()
1306 << "\n";
1307 if (pImpl->ValueHandles[V]->getKind() == Assert)
1308 llvm_unreachable("An asserting value handle still pointed to this"
1309 " value!");
1310
1311#endif
1312 llvm_unreachable("All references to V were not removed?");
1313 }
1314}
1315
1316void ValueHandleBase::ValueIsRAUWd(Value *Old, Value *New) {
1317 assert(Old->HasValueHandle &&"Should only be called if ValueHandles present");
1318 assert(Old != New && "Changing value into itself!");
1319 assert(Old->getType() == New->getType() &&
1320 "replaceAllUses of value with new value of different type!");
1321
1322 // Get the linked list base, which is guaranteed to exist since the
1323 // HasValueHandle flag is set.
1324 LLVMContextImpl *pImpl = Old->getContext().pImpl;
1325 ValueHandleBase *Entry = pImpl->ValueHandles[Old];
1326
1327 assert(Entry && "Value bit set but no entries exist");
1328
1329 // We use a local ValueHandleBase as an iterator so that
1330 // ValueHandles can add and remove themselves from the list without
1331 // breaking our iteration. This is not really an AssertingVH; we
1332 // just have to give ValueHandleBase some kind.
1333 for (ValueHandleBase Iterator(Assert, *Entry); Entry; Entry = Iterator.Next) {
1334 Iterator.RemoveFromUseList();
1335 Iterator.AddToExistingUseListAfter(List: Entry);
1336 assert(Entry->Next == &Iterator && "Loop invariant broken.");
1337
1338 switch (Entry->getKind()) {
1339 case Assert:
1340 case Weak:
1341 // Asserting and Weak handles do not follow RAUW implicitly.
1342 break;
1343 case WeakTracking:
1344 // Weak goes to the new value, which will unlink it from Old's list.
1345 Entry->operator=(RHS: New);
1346 break;
1347 case Callback:
1348 // Forward to the subclass's implementation.
1349 static_cast<CallbackVH*>(Entry)->allUsesReplacedWith(New);
1350 break;
1351 }
1352 }
1353
1354#ifndef NDEBUG
1355 // If any new weak value handles were added while processing the
1356 // list, then complain about it now.
1357 if (Old->HasValueHandle)
1358 for (Entry = pImpl->ValueHandles[Old]; Entry; Entry = Entry->Next)
1359 switch (Entry->getKind()) {
1360 case WeakTracking:
1361 dbgs() << "After RAUW from " << *Old->getType() << " %"
1362 << Old->getName() << " to " << *New->getType() << " %"
1363 << New->getName() << "\n";
1364 llvm_unreachable(
1365 "A weak tracking value handle still pointed to the old value!\n");
1366 default:
1367 break;
1368 }
1369#endif
1370}
1371
1372// Pin the vtable to this file.
1373void CallbackVH::anchor() {}
1374