LLVM  4.0.0
Value.cpp
Go to the documentation of this file.
1 //===-- Value.cpp - Implement the Value class -----------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the Value, ValueHandle, and User classes.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "llvm/IR/Value.h"
15 #include "LLVMContextImpl.h"
16 #include "llvm/ADT/DenseMap.h"
17 #include "llvm/ADT/SmallString.h"
18 #include "llvm/IR/CallSite.h"
19 #include "llvm/IR/Constant.h"
20 #include "llvm/IR/Constants.h"
21 #include "llvm/IR/DataLayout.h"
22 #include "llvm/IR/DerivedTypes.h"
24 #include "llvm/IR/InstrTypes.h"
25 #include "llvm/IR/Instructions.h"
26 #include "llvm/IR/IntrinsicInst.h"
27 #include "llvm/IR/Module.h"
28 #include "llvm/IR/Operator.h"
29 #include "llvm/IR/Statepoint.h"
30 #include "llvm/IR/ValueHandle.h"
32 #include "llvm/Support/Debug.h"
36 #include <algorithm>
37 
38 using namespace llvm;
39 
40 //===----------------------------------------------------------------------===//
41 // Value Class
42 //===----------------------------------------------------------------------===//
43 static inline Type *checkType(Type *Ty) {
44  assert(Ty && "Value defined with a null type: Error!");
45  return Ty;
46 }
47 
48 Value::Value(Type *ty, unsigned scid)
49  : VTy(checkType(ty)), UseList(nullptr), SubclassID(scid),
50  HasValueHandle(0), SubclassOptionalData(0), SubclassData(0),
51  NumUserOperands(0), IsUsedByMD(false), HasName(false) {
52  // FIXME: Why isn't this in the subclass gunk??
53  // Note, we cannot call isa<CallInst> before the CallInst has been
54  // constructed.
55  if (SubclassID == Instruction::Call || SubclassID == Instruction::Invoke)
56  assert((VTy->isFirstClassType() || VTy->isVoidTy() || VTy->isStructTy()) &&
57  "invalid CallInst type!");
58  else if (SubclassID != BasicBlockVal &&
59  (SubclassID < ConstantFirstVal || SubclassID > ConstantLastVal))
60  assert((VTy->isFirstClassType() || VTy->isVoidTy()) &&
61  "Cannot create non-first-class values except for constants!");
62  static_assert(sizeof(Value) == 3 * sizeof(void *) + 2 * sizeof(unsigned),
63  "Value too big");
64 }
65 
67  // Notify all ValueHandles (if present) that this value is going away.
68  if (HasValueHandle)
70  if (isUsedByMetadata())
72 
73 #ifndef NDEBUG // Only in -g mode...
74  // Check to make sure that there are no uses of this value that are still
75  // around when the value is destroyed. If there are, then we have a dangling
76  // reference and something is wrong. This code is here to print out where
77  // the value is still being referenced.
78  //
79  if (!use_empty()) {
80  dbgs() << "While deleting: " << *VTy << " %" << getName() << "\n";
81  for (auto *U : users())
82  dbgs() << "Use still stuck around after Def is destroyed:" << *U << "\n";
83  }
84 #endif
85  assert(use_empty() && "Uses remain when a value is destroyed!");
86 
87  // If this value is named, destroy the name. This should not be in a symtab
88  // at this point.
89  destroyValueName();
90 }
91 
92 void Value::destroyValueName() {
94  if (Name)
95  Name->Destroy();
96  setValueName(nullptr);
97 }
98 
99 bool Value::hasNUses(unsigned N) const {
101 
102  for (; N; --N, ++UI)
103  if (UI == E) return false; // Too few.
104  return UI == E;
105 }
106 
107 bool Value::hasNUsesOrMore(unsigned N) const {
109 
110  for (; N; --N, ++UI)
111  if (UI == E) return false; // Too few.
112 
113  return true;
114 }
115 
116 bool Value::isUsedInBasicBlock(const BasicBlock *BB) const {
117  // This can be computed either by scanning the instructions in BB, or by
118  // scanning the use list of this Value. Both lists can be very long, but
119  // usually one is quite short.
120  //
121  // Scan both lists simultaneously until one is exhausted. This limits the
122  // search to the shorter list.
123  BasicBlock::const_iterator BI = BB->begin(), BE = BB->end();
124  const_user_iterator UI = user_begin(), UE = user_end();
125  for (; BI != BE && UI != UE; ++BI, ++UI) {
126  // Scan basic block: Check if this Value is used by the instruction at BI.
127  if (is_contained(BI->operands(), this))
128  return true;
129  // Scan use list: Check if the use at UI is in BB.
130  const auto *User = dyn_cast<Instruction>(*UI);
131  if (User && User->getParent() == BB)
132  return true;
133  }
134  return false;
135 }
136 
137 unsigned Value::getNumUses() const {
138  return (unsigned)std::distance(use_begin(), use_end());
139 }
140 
141 static bool getSymTab(Value *V, ValueSymbolTable *&ST) {
142  ST = nullptr;
143  if (Instruction *I = dyn_cast<Instruction>(V)) {
144  if (BasicBlock *P = I->getParent())
145  if (Function *PP = P->getParent())
146  ST = PP->getValueSymbolTable();
147  } else if (BasicBlock *BB = dyn_cast<BasicBlock>(V)) {
148  if (Function *P = BB->getParent())
149  ST = P->getValueSymbolTable();
150  } else if (GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
151  if (Module *P = GV->getParent())
152  ST = &P->getValueSymbolTable();
153  } else if (Argument *A = dyn_cast<Argument>(V)) {
154  if (Function *P = A->getParent())
155  ST = P->getValueSymbolTable();
156  } else {
157  assert(isa<Constant>(V) && "Unknown value type!");
158  return true; // no name is setable for this.
159  }
160  return false;
161 }
162 
164  if (!HasName) return nullptr;
165 
166  LLVMContext &Ctx = getContext();
167  auto I = Ctx.pImpl->ValueNames.find(this);
168  assert(I != Ctx.pImpl->ValueNames.end() &&
169  "No name entry found!");
170 
171  return I->second;
172 }
173 
175  LLVMContext &Ctx = getContext();
176 
177  assert(HasName == Ctx.pImpl->ValueNames.count(this) &&
178  "HasName bit out of sync!");
179 
180  if (!VN) {
181  if (HasName)
182  Ctx.pImpl->ValueNames.erase(this);
183  HasName = false;
184  return;
185  }
186 
187  HasName = true;
188  Ctx.pImpl->ValueNames[this] = VN;
189 }
190 
192  // Make sure the empty string is still a C string. For historical reasons,
193  // some clients want to call .data() on the result and expect it to be null
194  // terminated.
195  if (!hasName())
196  return StringRef("", 0);
197  return getValueName()->getKey();
198 }
199 
200 void Value::setNameImpl(const Twine &NewName) {
201  // Fast-path: LLVMContext can be set to strip out non-GlobalValue names
202  if (getContext().shouldDiscardValueNames() && !isa<GlobalValue>(this))
203  return;
204 
205  // Fast path for common IRBuilder case of setName("") when there is no name.
206  if (NewName.isTriviallyEmpty() && !hasName())
207  return;
208 
209  SmallString<256> NameData;
210  StringRef NameRef = NewName.toStringRef(NameData);
211  assert(NameRef.find_first_of(0) == StringRef::npos &&
212  "Null bytes are not allowed in names");
213 
214  // Name isn't changing?
215  if (getName() == NameRef)
216  return;
217 
218  assert(!getType()->isVoidTy() && "Cannot assign a name to void values!");
219 
220  // Get the symbol table to update for this object.
222  if (getSymTab(this, ST))
223  return; // Cannot set a name on this value (e.g. constant).
224 
225  if (!ST) { // No symbol table to update? Just do the change.
226  if (NameRef.empty()) {
227  // Free the name for this value.
228  destroyValueName();
229  return;
230  }
231 
232  // NOTE: Could optimize for the case the name is shrinking to not deallocate
233  // then reallocated.
234  destroyValueName();
235 
236  // Create the new name.
238  getValueName()->setValue(this);
239  return;
240  }
241 
242  // NOTE: Could optimize for the case the name is shrinking to not deallocate
243  // then reallocated.
244  if (hasName()) {
245  // Remove old name.
246  ST->removeValueName(getValueName());
247  destroyValueName();
248 
249  if (NameRef.empty())
250  return;
251  }
252 
253  // Name is changing to something new.
254  setValueName(ST->createValueName(NameRef, this));
255 }
256 
257 void Value::setName(const Twine &NewName) {
258  setNameImpl(NewName);
259  if (Function *F = dyn_cast<Function>(this))
260  F->recalculateIntrinsicID();
261 }
262 
264  ValueSymbolTable *ST = nullptr;
265  // If this value has a name, drop it.
266  if (hasName()) {
267  // Get the symtab this is in.
268  if (getSymTab(this, ST)) {
269  // We can't set a name on this value, but we need to clear V's name if
270  // it has one.
271  if (V->hasName()) V->setName("");
272  return; // Cannot set a name on this value (e.g. constant).
273  }
274 
275  // Remove old name.
276  if (ST)
277  ST->removeValueName(getValueName());
278  destroyValueName();
279  }
280 
281  // Now we know that this has no name.
282 
283  // If V has no name either, we're done.
284  if (!V->hasName()) return;
285 
286  // Get this's symtab if we didn't before.
287  if (!ST) {
288  if (getSymTab(this, ST)) {
289  // Clear V's name.
290  V->setName("");
291  return; // Cannot set a name on this value (e.g. constant).
292  }
293  }
294 
295  // Get V's ST, this should always succed, because V has a name.
296  ValueSymbolTable *VST;
297  bool Failure = getSymTab(V, VST);
298  assert(!Failure && "V has a name, so it should have a ST!"); (void)Failure;
299 
300  // If these values are both in the same symtab, we can do this very fast.
301  // This works even if both values have no symtab yet.
302  if (ST == VST) {
303  // Take the name!
305  V->setValueName(nullptr);
306  getValueName()->setValue(this);
307  return;
308  }
309 
310  // Otherwise, things are slightly more complex. Remove V's name from VST and
311  // then reinsert it into ST.
312 
313  if (VST)
314  VST->removeValueName(V->getValueName());
316  V->setValueName(nullptr);
317  getValueName()->setValue(this);
318 
319  if (ST)
320  ST->reinsertValue(this);
321 }
322 
324 #ifndef NDEBUG
325  const GlobalValue *GV = dyn_cast<GlobalValue>(this);
326  if (!GV)
327  return;
328  const Module *M = GV->getParent();
329  if (!M)
330  return;
331  assert(M->isMaterialized());
332 #endif
333 }
334 
335 #ifndef NDEBUG
337  Constant *C) {
338  if (!Cache.insert(Expr).second)
339  return false;
340 
341  for (auto &O : Expr->operands()) {
342  if (O == C)
343  return true;
344  auto *CE = dyn_cast<ConstantExpr>(O);
345  if (!CE)
346  continue;
347  if (contains(Cache, CE, C))
348  return true;
349  }
350  return false;
351 }
352 
353 static bool contains(Value *Expr, Value *V) {
354  if (Expr == V)
355  return true;
356 
357  auto *C = dyn_cast<Constant>(V);
358  if (!C)
359  return false;
360 
361  auto *CE = dyn_cast<ConstantExpr>(Expr);
362  if (!CE)
363  return false;
364 
366  return contains(Cache, CE, C);
367 }
368 #endif // NDEBUG
369 
370 void Value::doRAUW(Value *New, bool NoMetadata) {
371  assert(New && "Value::replaceAllUsesWith(<null>) is invalid!");
372  assert(!contains(New, this) &&
373  "this->replaceAllUsesWith(expr(this)) is NOT valid!");
374  assert(New->getType() == getType() &&
375  "replaceAllUses of value with new value of different type!");
376 
377  // Notify all ValueHandles (if present) that this value is going away.
378  if (HasValueHandle)
380  if (!NoMetadata && isUsedByMetadata())
381  ValueAsMetadata::handleRAUW(this, New);
382 
383  while (!use_empty()) {
384  Use &U = *UseList;
385  // Must handle Constants specially, we cannot call replaceUsesOfWith on a
386  // constant because they are uniqued.
387  if (auto *C = dyn_cast<Constant>(U.getUser())) {
388  if (!isa<GlobalValue>(C)) {
389  C->handleOperandChange(this, New);
390  continue;
391  }
392  }
393 
394  U.set(New);
395  }
396 
397  if (BasicBlock *BB = dyn_cast<BasicBlock>(this))
398  BB->replaceSuccessorsPhiUsesWith(cast<BasicBlock>(New));
399 }
400 
402  doRAUW(New, false /* NoMetadata */);
403 }
404 
406  doRAUW(New, true /* NoMetadata */);
407 }
408 
409 // Like replaceAllUsesWith except it does not handle constants or basic blocks.
410 // This routine leaves uses within BB.
412  assert(New && "Value::replaceUsesOutsideBlock(<null>, BB) is invalid!");
413  assert(!contains(New, this) &&
414  "this->replaceUsesOutsideBlock(expr(this), BB) is NOT valid!");
415  assert(New->getType() == getType() &&
416  "replaceUses of value with new value of different type!");
417  assert(BB && "Basic block that may contain a use of 'New' must be defined\n");
418 
419  use_iterator UI = use_begin(), E = use_end();
420  for (; UI != E;) {
421  Use &U = *UI;
422  ++UI;
423  auto *Usr = dyn_cast<Instruction>(U.getUser());
424  if (Usr && Usr->getParent() == BB)
425  continue;
426  U.set(New);
427  }
428 }
429 
430 namespace {
431 // Various metrics for how much to strip off of pointers.
433  PSK_ZeroIndices,
434  PSK_ZeroIndicesAndAliases,
435  PSK_InBoundsConstantIndices,
436  PSK_InBounds
437 };
438 
439 template <PointerStripKind StripKind>
440 static Value *stripPointerCastsAndOffsets(Value *V) {
441  if (!V->getType()->isPointerTy())
442  return V;
443 
444  // Even though we don't look through PHI nodes, we could be called on an
445  // instruction in an unreachable block, which may be on a cycle.
446  SmallPtrSet<Value *, 4> Visited;
447 
448  Visited.insert(V);
449  do {
450  if (GEPOperator *GEP = dyn_cast<GEPOperator>(V)) {
451  switch (StripKind) {
452  case PSK_ZeroIndicesAndAliases:
453  case PSK_ZeroIndices:
454  if (!GEP->hasAllZeroIndices())
455  return V;
456  break;
457  case PSK_InBoundsConstantIndices:
458  if (!GEP->hasAllConstantIndices())
459  return V;
461  case PSK_InBounds:
462  if (!GEP->isInBounds())
463  return V;
464  break;
465  }
466  V = GEP->getPointerOperand();
467  } else if (Operator::getOpcode(V) == Instruction::BitCast ||
468  Operator::getOpcode(V) == Instruction::AddrSpaceCast) {
469  V = cast<Operator>(V)->getOperand(0);
470  } else if (GlobalAlias *GA = dyn_cast<GlobalAlias>(V)) {
471  if (StripKind == PSK_ZeroIndices || GA->isInterposable())
472  return V;
473  V = GA->getAliasee();
474  } else {
475  if (auto CS = CallSite(V))
476  if (Value *RV = CS.getReturnedArgOperand()) {
477  V = RV;
478  continue;
479  }
480 
481  return V;
482  }
483  assert(V->getType()->isPointerTy() && "Unexpected operand type!");
484  } while (Visited.insert(V).second);
485 
486  return V;
487 }
488 } // end anonymous namespace
489 
491  return stripPointerCastsAndOffsets<PSK_ZeroIndicesAndAliases>(this);
492 }
493 
495  return stripPointerCastsAndOffsets<PSK_ZeroIndices>(this);
496 }
497 
499  return stripPointerCastsAndOffsets<PSK_InBoundsConstantIndices>(this);
500 }
501 
503  APInt &Offset) {
504  if (!getType()->isPointerTy())
505  return this;
506 
507  assert(Offset.getBitWidth() == DL.getPointerSizeInBits(cast<PointerType>(
508  getType())->getAddressSpace()) &&
509  "The offset must have exactly as many bits as our pointer.");
510 
511  // Even though we don't look through PHI nodes, we could be called on an
512  // instruction in an unreachable block, which may be on a cycle.
513  SmallPtrSet<Value *, 4> Visited;
514  Visited.insert(this);
515  Value *V = this;
516  do {
517  if (GEPOperator *GEP = dyn_cast<GEPOperator>(V)) {
518  if (!GEP->isInBounds())
519  return V;
520  APInt GEPOffset(Offset);
521  if (!GEP->accumulateConstantOffset(DL, GEPOffset))
522  return V;
523  Offset = GEPOffset;
524  V = GEP->getPointerOperand();
525  } else if (Operator::getOpcode(V) == Instruction::BitCast) {
526  V = cast<Operator>(V)->getOperand(0);
527  } else if (GlobalAlias *GA = dyn_cast<GlobalAlias>(V)) {
528  V = GA->getAliasee();
529  } else {
530  if (auto CS = CallSite(V))
531  if (Value *RV = CS.getReturnedArgOperand()) {
532  V = RV;
533  continue;
534  }
535 
536  return V;
537  }
538  assert(V->getType()->isPointerTy() && "Unexpected operand type!");
539  } while (Visited.insert(V).second);
540 
541  return V;
542 }
543 
545  return stripPointerCastsAndOffsets<PSK_InBounds>(this);
546 }
547 
549  bool &CanBeNull) const {
550  assert(getType()->isPointerTy() && "must be pointer");
551 
552  unsigned DerefBytes = 0;
553  CanBeNull = false;
554  if (const Argument *A = dyn_cast<Argument>(this)) {
555  DerefBytes = A->getDereferenceableBytes();
556  if (DerefBytes == 0 && A->hasByValAttr() && A->getType()->isSized()) {
557  DerefBytes = DL.getTypeStoreSize(A->getType());
558  CanBeNull = false;
559  }
560  if (DerefBytes == 0) {
561  DerefBytes = A->getDereferenceableOrNullBytes();
562  CanBeNull = true;
563  }
564  } else if (auto CS = ImmutableCallSite(this)) {
565  DerefBytes = CS.getDereferenceableBytes(0);
566  if (DerefBytes == 0) {
567  DerefBytes = CS.getDereferenceableOrNullBytes(0);
568  CanBeNull = true;
569  }
570  } else if (const LoadInst *LI = dyn_cast<LoadInst>(this)) {
571  if (MDNode *MD = LI->getMetadata(LLVMContext::MD_dereferenceable)) {
572  ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(0));
573  DerefBytes = CI->getLimitedValue();
574  }
575  if (DerefBytes == 0) {
576  if (MDNode *MD =
577  LI->getMetadata(LLVMContext::MD_dereferenceable_or_null)) {
578  ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(0));
579  DerefBytes = CI->getLimitedValue();
580  }
581  CanBeNull = true;
582  }
583  } else if (auto *AI = dyn_cast<AllocaInst>(this)) {
584  if (AI->getAllocatedType()->isSized()) {
585  DerefBytes = DL.getTypeStoreSize(AI->getAllocatedType());
586  CanBeNull = false;
587  }
588  } else if (auto *GV = dyn_cast<GlobalVariable>(this)) {
589  if (GV->getValueType()->isSized() && !GV->hasExternalWeakLinkage()) {
590  // TODO: Don't outright reject hasExternalWeakLinkage but set the
591  // CanBeNull flag.
592  DerefBytes = DL.getTypeStoreSize(GV->getValueType());
593  CanBeNull = false;
594  }
595  }
596  return DerefBytes;
597 }
598 
599 unsigned Value::getPointerAlignment(const DataLayout &DL) const {
600  assert(getType()->isPointerTy() && "must be pointer");
601 
602  unsigned Align = 0;
603  if (auto *GO = dyn_cast<GlobalObject>(this)) {
604  Align = GO->getAlignment();
605  if (Align == 0) {
606  if (auto *GVar = dyn_cast<GlobalVariable>(GO)) {
607  Type *ObjectType = GVar->getValueType();
608  if (ObjectType->isSized()) {
609  // If the object is defined in the current Module, we'll be giving
610  // it the preferred alignment. Otherwise, we have to assume that it
611  // may only have the minimum ABI alignment.
612  if (GVar->isStrongDefinitionForLinker())
613  Align = DL.getPreferredAlignment(GVar);
614  else
615  Align = DL.getABITypeAlignment(ObjectType);
616  }
617  }
618  }
619  } else if (const Argument *A = dyn_cast<Argument>(this)) {
620  Align = A->getParamAlignment();
621 
622  if (!Align && A->hasStructRetAttr()) {
623  // An sret parameter has at least the ABI alignment of the return type.
624  Type *EltTy = cast<PointerType>(A->getType())->getElementType();
625  if (EltTy->isSized())
626  Align = DL.getABITypeAlignment(EltTy);
627  }
628  } else if (const AllocaInst *AI = dyn_cast<AllocaInst>(this)) {
629  Align = AI->getAlignment();
630  if (Align == 0) {
631  Type *AllocatedType = AI->getAllocatedType();
632  if (AllocatedType->isSized())
633  Align = DL.getPrefTypeAlignment(AllocatedType);
634  }
635  } else if (auto CS = ImmutableCallSite(this))
636  Align = CS.getAttributes().getParamAlignment(AttributeSet::ReturnIndex);
637  else if (const LoadInst *LI = dyn_cast<LoadInst>(this))
638  if (MDNode *MD = LI->getMetadata(LLVMContext::MD_align)) {
639  ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(0));
640  Align = CI->getLimitedValue();
641  }
642 
643  return Align;
644 }
645 
647  const BasicBlock *PredBB) {
648  PHINode *PN = dyn_cast<PHINode>(this);
649  if (PN && PN->getParent() == CurBB)
650  return PN->getIncomingValueForBlock(PredBB);
651  return this;
652 }
653 
654 LLVMContext &Value::getContext() const { return VTy->getContext(); }
655 
657  if (!UseList || !UseList->Next)
658  // No need to reverse 0 or 1 uses.
659  return;
660 
661  Use *Head = UseList;
662  Use *Current = UseList->Next;
663  Head->Next = nullptr;
664  while (Current) {
665  Use *Next = Current->Next;
666  Current->Next = Head;
667  Head->setPrev(&Current->Next);
668  Head = Current;
669  Current = Next;
670  }
671  UseList = Head;
672  Head->setPrev(&UseList);
673 }
674 
675 bool Value::isSwiftError() const {
676  auto *Arg = dyn_cast<Argument>(this);
677  if (Arg)
678  return Arg->hasSwiftErrorAttr();
679  auto *Alloca = dyn_cast<AllocaInst>(this);
680  if (!Alloca)
681  return false;
682  return Alloca->isSwiftError();
683 }
684 
685 //===----------------------------------------------------------------------===//
686 // ValueHandleBase Class
687 //===----------------------------------------------------------------------===//
688 
689 void ValueHandleBase::AddToExistingUseList(ValueHandleBase **List) {
690  assert(List && "Handle list is null?");
691 
692  // Splice ourselves into the list.
693  Next = *List;
694  *List = this;
695  setPrevPtr(List);
696  if (Next) {
697  Next->setPrevPtr(&Next);
698  assert(V == Next->V && "Added to wrong list?");
699  }
700 }
701 
702 void ValueHandleBase::AddToExistingUseListAfter(ValueHandleBase *List) {
703  assert(List && "Must insert after existing node");
704 
705  Next = List->Next;
706  setPrevPtr(&List->Next);
707  List->Next = this;
708  if (Next)
709  Next->setPrevPtr(&Next);
710 }
711 
712 void ValueHandleBase::AddToUseList() {
713  assert(V && "Null pointer doesn't have a use list!");
714 
715  LLVMContextImpl *pImpl = V->getContext().pImpl;
716 
717  if (V->HasValueHandle) {
718  // If this value already has a ValueHandle, then it must be in the
719  // ValueHandles map already.
720  ValueHandleBase *&Entry = pImpl->ValueHandles[V];
721  assert(Entry && "Value doesn't have any handles?");
722  AddToExistingUseList(&Entry);
723  return;
724  }
725 
726  // Ok, it doesn't have any handles yet, so we must insert it into the
727  // DenseMap. However, doing this insertion could cause the DenseMap to
728  // reallocate itself, which would invalidate all of the PrevP pointers that
729  // point into the old table. Handle this by checking for reallocation and
730  // updating the stale pointers only if needed.
732  const void *OldBucketPtr = Handles.getPointerIntoBucketsArray();
733 
734  ValueHandleBase *&Entry = Handles[V];
735  assert(!Entry && "Value really did already have handles?");
736  AddToExistingUseList(&Entry);
737  V->HasValueHandle = true;
738 
739  // If reallocation didn't happen or if this was the first insertion, don't
740  // walk the table.
741  if (Handles.isPointerIntoBucketsArray(OldBucketPtr) ||
742  Handles.size() == 1) {
743  return;
744  }
745 
746  // Okay, reallocation did happen. Fix the Prev Pointers.
748  E = Handles.end(); I != E; ++I) {
749  assert(I->second && I->first == I->second->V &&
750  "List invariant broken!");
751  I->second->setPrevPtr(&I->second);
752  }
753 }
754 
755 void ValueHandleBase::RemoveFromUseList() {
756  assert(V && V->HasValueHandle &&
757  "Pointer doesn't have a use list!");
758 
759  // Unlink this from its use list.
760  ValueHandleBase **PrevPtr = getPrevPtr();
761  assert(*PrevPtr == this && "List invariant broken");
762 
763  *PrevPtr = Next;
764  if (Next) {
765  assert(Next->getPrevPtr() == &Next && "List invariant broken");
766  Next->setPrevPtr(PrevPtr);
767  return;
768  }
769 
770  // If the Next pointer was null, then it is possible that this was the last
771  // ValueHandle watching VP. If so, delete its entry from the ValueHandles
772  // map.
773  LLVMContextImpl *pImpl = V->getContext().pImpl;
775  if (Handles.isPointerIntoBucketsArray(PrevPtr)) {
776  Handles.erase(V);
777  V->HasValueHandle = false;
778  }
779 }
780 
782  assert(V->HasValueHandle && "Should only be called if ValueHandles present");
783 
784  // Get the linked list base, which is guaranteed to exist since the
785  // HasValueHandle flag is set.
786  LLVMContextImpl *pImpl = V->getContext().pImpl;
787  ValueHandleBase *Entry = pImpl->ValueHandles[V];
788  assert(Entry && "Value bit set but no entries exist");
789 
790  // We use a local ValueHandleBase as an iterator so that ValueHandles can add
791  // and remove themselves from the list without breaking our iteration. This
792  // is not really an AssertingVH; we just have to give ValueHandleBase a kind.
793  // Note that we deliberately do not the support the case when dropping a value
794  // handle results in a new value handle being permanently added to the list
795  // (as might occur in theory for CallbackVH's): the new value handle will not
796  // be processed and the checking code will mete out righteous punishment if
797  // the handle is still present once we have finished processing all the other
798  // value handles (it is fine to momentarily add then remove a value handle).
799  for (ValueHandleBase Iterator(Assert, *Entry); Entry; Entry = Iterator.Next) {
800  Iterator.RemoveFromUseList();
801  Iterator.AddToExistingUseListAfter(Entry);
802  assert(Entry->Next == &Iterator && "Loop invariant broken.");
803 
804  switch (Entry->getKind()) {
805  case Assert:
806  break;
807  case Tracking:
808  // Mark that this value has been deleted by setting it to an invalid Value
809  // pointer.
810  Entry->operator=(DenseMapInfo<Value *>::getTombstoneKey());
811  break;
812  case Weak:
813  // Weak just goes to null, which will unlink it from the list.
814  Entry->operator=(nullptr);
815  break;
816  case Callback:
817  // Forward to the subclass's implementation.
818  static_cast<CallbackVH*>(Entry)->deleted();
819  break;
820  }
821  }
822 
823  // All callbacks, weak references, and assertingVHs should be dropped by now.
824  if (V->HasValueHandle) {
825 #ifndef NDEBUG // Only in +Asserts mode...
826  dbgs() << "While deleting: " << *V->getType() << " %" << V->getName()
827  << "\n";
828  if (pImpl->ValueHandles[V]->getKind() == Assert)
829  llvm_unreachable("An asserting value handle still pointed to this"
830  " value!");
831 
832 #endif
833  llvm_unreachable("All references to V were not removed?");
834  }
835 }
836 
838  assert(Old->HasValueHandle &&"Should only be called if ValueHandles present");
839  assert(Old != New && "Changing value into itself!");
840  assert(Old->getType() == New->getType() &&
841  "replaceAllUses of value with new value of different type!");
842 
843  // Get the linked list base, which is guaranteed to exist since the
844  // HasValueHandle flag is set.
845  LLVMContextImpl *pImpl = Old->getContext().pImpl;
846  ValueHandleBase *Entry = pImpl->ValueHandles[Old];
847 
848  assert(Entry && "Value bit set but no entries exist");
849 
850  // We use a local ValueHandleBase as an iterator so that
851  // ValueHandles can add and remove themselves from the list without
852  // breaking our iteration. This is not really an AssertingVH; we
853  // just have to give ValueHandleBase some kind.
854  for (ValueHandleBase Iterator(Assert, *Entry); Entry; Entry = Iterator.Next) {
855  Iterator.RemoveFromUseList();
856  Iterator.AddToExistingUseListAfter(Entry);
857  assert(Entry->Next == &Iterator && "Loop invariant broken.");
858 
859  switch (Entry->getKind()) {
860  case Assert:
861  // Asserting handle does not follow RAUW implicitly.
862  break;
863  case Tracking:
864  // Tracking goes to new value like a WeakVH. Note that this may make it
865  // something incompatible with its templated type. We don't want to have a
866  // virtual (or inline) interface to handle this though, so instead we make
867  // the TrackingVH accessors guarantee that a client never sees this value.
868 
870  case Weak:
871  // Weak goes to the new value, which will unlink it from Old's list.
872  Entry->operator=(New);
873  break;
874  case Callback:
875  // Forward to the subclass's implementation.
876  static_cast<CallbackVH*>(Entry)->allUsesReplacedWith(New);
877  break;
878  }
879  }
880 
881 #ifndef NDEBUG
882  // If any new tracking or weak value handles were added while processing the
883  // list, then complain about it now.
884  if (Old->HasValueHandle)
885  for (Entry = pImpl->ValueHandles[Old]; Entry; Entry = Entry->Next)
886  switch (Entry->getKind()) {
887  case Tracking:
888  case Weak:
889  dbgs() << "After RAUW from " << *Old->getType() << " %"
890  << Old->getName() << " to " << *New->getType() << " %"
891  << New->getName() << "\n";
892  llvm_unreachable("A tracking or weak value handle still pointed to the"
893  " old value!\n");
894  default:
895  break;
896  }
897 #endif
898 }
899 
900 // Pin the vtable to this file.
901 void CallbackVH::anchor() {}
This is the common base class of value handles.
Definition: ValueHandle.h:30
use_iterator use_end()
Definition: Value.h:318
use_iterator_impl< Use > use_iterator
Definition: Value.h:304
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:102
This class provides a symbol table of name/value pairs.
static void ValueIsDeleted(Value *V)
Definition: Value.cpp:781
Value * stripInBoundsConstantOffsets()
Strip off pointer casts and all-constant inbounds GEPs.
Definition: Value.cpp:498
LLVM Argument representation.
Definition: Argument.h:34
bool hasName() const
Definition: Value.h:236
StringMapEntry - This is used to represent one value that is inserted into a StringMap.
Definition: StringMap.h:36
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:52
void setValue(const ValueTy &V)
Definition: StringMap.h:146
bool hasNUses(unsigned N) const
Return true if this Value has exactly N users.
Definition: Value.cpp:99
unsigned getPrefTypeAlignment(Type *Ty) const
Returns the preferred stack/global alignment for the specified type.
Definition: DataLayout.cpp:699
Metadata node.
Definition: Metadata.h:830
An instruction for reading from memory.
Definition: Instructions.h:164
Hexagon Common GEP
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:191
A templated base class for SmallPtrSet which provides the typesafe interface that is common across al...
Definition: SmallPtrSet.h:345
iterator begin()
Instruction iterator methods.
Definition: BasicBlock.h:228
static Type * checkType(Type *Ty)
Definition: Value.cpp:43
unsigned getPointerAlignment(const DataLayout &DL) const
Returns an alignment of the pointer value.
Definition: Value.cpp:599
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
bool hasSwiftErrorAttr() const
Return true if this argument has the swifterror attribute.
Definition: Function.cpp:95
A Use represents the edge between a Value definition and its users.
Definition: Use.h:56
const void * getPointerIntoBucketsArray() const
getPointerIntoBucketsArray() - Return an opaque pointer into the buckets array.
Definition: DenseMap.h:296
void setName(const Twine &Name)
Change the name of the value.
Definition: Value.cpp:257
static bool contains(SmallPtrSetImpl< ConstantExpr * > &Cache, ConstantExpr *Expr, Constant *C)
Definition: Value.cpp:336
DenseMap< const Value *, ValueName * > ValueNames
Value * stripAndAccumulateInBoundsConstantOffsets(const DataLayout &DL, APInt &Offset)
Accumulate offsets from stripInBoundsConstantOffsets().
Definition: Value.cpp:502
void Destroy(AllocatorTy &Allocator)
Destroy - Destroy this StringMapEntry, releasing memory back to the specified allocator.
Definition: StringMap.h:203
A constant value that is initialized with an expression using other constant values.
Definition: Constants.h:873
static void handleRAUW(Value *From, Value *To)
Definition: Metadata.cpp:352
#define F(x, y, z)
Definition: MD5.cpp:51
LLVMContext & getContext() const
Return the LLVMContext in which this type was uniqued.
Definition: Type.h:128
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:256
Function Alias Analysis false
bool isFirstClassType() const
Return true if the type is "first class", meaning it is a valid type for a Value. ...
Definition: Type.h:233
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
Definition: Value.cpp:401
static void ValueIsRAUWd(Value *Old, Value *New)
Definition: Value.cpp:837
void takeName(Value *V)
Transfer the name from V to this value.
Definition: Value.cpp:263
ValueName * getValueName() const
Definition: Value.cpp:163
static GCRegistry::Add< CoreCLRGC > E("coreclr","CoreCLR-compatible GC")
bool isSized(SmallPtrSetImpl< Type * > *Visited=nullptr) const
Return true if it makes sense to take the size of this type.
Definition: Type.h:254
Value * stripPointerCastsNoFollowAliases()
Strip off pointer casts and all-zero GEPs.
Definition: Value.cpp:494
#define P(N)
bool erase(const KeyT &Val)
Definition: DenseMap.h:243
void set(Value *Val)
Definition: Value.h:624
LLVM Basic Block Representation.
Definition: BasicBlock.h:51
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:48
This is an important base class in LLVM.
Definition: Constant.h:42
void replaceNonMetadataUsesWith(Value *V)
Change non-metadata uses of this to point to a new Value.
Definition: Value.cpp:405
This file contains the declarations for the subclasses of Constant, which represent the different fla...
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:368
Value * stripInBoundsOffsets()
Strip off pointer casts and inbounds GEPs.
Definition: Value.cpp:544
bool isUsedByMetadata() const
Return true if there is metadata referencing this value.
Definition: Value.h:459
uint32_t Offset
unsigned getBitWidth() const
Return the number of bits in the APInt.
Definition: APInt.h:1255
ValueHandlesTy ValueHandles
User * getUser() const
Returns the User that contains this Use.
Definition: Use.cpp:41
op_range operands()
Definition: User.h:213
bool isPointerTy() const
True if this is an instance of PointerType.
Definition: Type.h:213
Value(Type *Ty, unsigned scid)
Definition: Value.cpp:48
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:654
use_iterator_impl< const Use > const_use_iterator
Definition: Value.h:305
bool isUsedInBasicBlock(const BasicBlock *BB) const
Check if this value is used in the specified basic block.
Definition: Value.cpp:116
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
unsigned getPreferredAlignment(const GlobalVariable *GV) const
Returns the preferred alignment of the specified global.
Definition: DataLayout.cpp:767
static StringMapEntry * Create(StringRef Key, AllocatorTy &Allocator, InitTy &&...InitVals)
Create a StringMapEntry for the specified key construct the value using InitiVals.
Definition: StringMap.h:158
LLVMContextImpl *const pImpl
Definition: LLVMContext.h:50
unsigned getABITypeAlignment(Type *Ty) const
Returns the minimum ABI-required alignment for the specified type.
Definition: DataLayout.cpp:689
Iterator for intrusive lists based on ilist_node.
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements...
Definition: SmallPtrSet.h:425
bool isSwiftError() const
Return true if this alloca is used as a swifterror argument to a call.
Definition: Instructions.h:132
This is the shared class of boolean and integer constants.
Definition: Constants.h:88
Value * DoPHITranslation(const BasicBlock *CurBB, const BasicBlock *PredBB)
Translate PHI node to its predecessor from the given basic block.
Definition: Value.cpp:646
iterator end()
Definition: BasicBlock.h:230
StringRef toStringRef(SmallVectorImpl< char > &Out) const
This returns the twine as a single StringRef if it can be represented as such.
Definition: Twine.h:463
bool isMaterialized() const
Definition: Module.h:455
Module.h This file contains the declarations for the Module class.
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:230
bool isSwiftError() const
Return true if this value is a swifterror value.
Definition: Value.cpp:675
PointerStripKind
Definition: Value.cpp:432
Value * stripPointerCasts()
Strip off pointer casts, all-zero GEPs, and aliases.
Definition: Value.cpp:490
static GCRegistry::Add< ShadowStackGC > C("shadow-stack","Very portable GC for uncooperative code generators")
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
Class for arbitrary precision integers.
Definition: APInt.h:77
StringRef getKey() const
Definition: StringMap.h:139
Value * getIncomingValueForBlock(const BasicBlock *BB) const
iterator_range< user_iterator > users()
Definition: Value.h:370
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:130
bool isPointerIntoBucketsArray(const void *Ptr) const
isPointerIntoBucketsArray - Return true if the specified pointer points somewhere into the DenseMap's...
Definition: DenseMap.h:289
bool isStructTy() const
True if this is an instance of StructType.
Definition: Type.h:207
unsigned getOpcode() const
Return the opcode for this Instruction or ConstantExpr.
Definition: Operator.h:49
void reverseUseList()
Reverse the use-list.
Definition: Value.cpp:656
use_iterator use_begin()
Definition: Value.h:310
void assertModuleIsMaterialized() const
Definition: Value.cpp:323
unsigned HasName
Definition: Value.h:115
user_iterator_impl< const User > const_user_iterator
Definition: Value.h:341
unsigned size() const
Definition: DenseMap.h:83
static const size_t npos
Definition: StringRef.h:51
unsigned getPointerDereferenceableBytes(const DataLayout &DL, bool &CanBeNull) const
Returns the number of bytes known to be dereferenceable for the pointer value.
Definition: Value.cpp:548
iterator begin()
Definition: DenseMap.h:65
ImmutableCallSite - establish a view to a call site for examination.
Definition: CallSite.h:665
const NodeList & List
Definition: RDFGraph.cpp:205
#define I(x, y, z)
Definition: MD5.cpp:54
#define N
unsigned getPointerSizeInBits(unsigned AS=0) const
Layout pointer size, in bits FIXME: The defaults need to be removed once all of the backends/clients ...
Definition: DataLayout.h:349
static bool getSymTab(Value *V, ValueSymbolTable *&ST)
Definition: Value.cpp:141
iterator end()
Definition: DenseMap.h:69
LLVM_NODISCARD std::enable_if<!is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:287
uint64_t getTypeStoreSize(Type *Ty) const
Returns the maximum number of bytes that may be overwritten by storing the specified type...
Definition: DataLayout.h:391
bool hasNUsesOrMore(unsigned N) const
Return true if this value has N users or more.
Definition: Value.cpp:107
virtual ~Value()
Definition: Value.cpp:66
bool use_empty() const
Definition: Value.h:299
LLVM_NODISCARD 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:392
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
user_iterator user_begin()
Definition: Value.h:346
static void handleDeletion(Value *V)
Definition: Metadata.cpp:333
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:537
LLVM Value Representation.
Definition: Value.h:71
#define LLVM_FALLTHROUGH
LLVM_FALLTHROUGH - Mark fallthrough cases in switch statements.
Definition: Compiler.h:239
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:408
void setValueName(ValueName *VN)
Definition: Value.cpp:174
Value handle with callbacks on RAUW and destruction.
Definition: ValueHandle.h:333
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:47
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:411
unsigned getNumUses() const
This method computes the number of uses of this Value.
Definition: Value.cpp:137
static GCRegistry::Add< ErlangGC > A("erlang","erlang-compatible garbage collector")
const BasicBlock * getParent() const
Definition: Instruction.h:62
bool isVoidTy() const
Return true if this is 'void'.
Definition: Type.h:139
an instruction to allocate memory on the stack
Definition: Instructions.h:60
bool is_contained(R &&Range, const E &Element)
Wrapper function around std::find to detect if an element exists in a container.
Definition: STLExtras.h:783
user_iterator user_end()
Definition: Value.h:354