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