Value.cpp revision 36b56886974eae4f9c5ebc96befd3e7bfe5de338
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/Constant.h" 19#include "llvm/IR/Constants.h" 20#include "llvm/IR/DerivedTypes.h" 21#include "llvm/IR/GetElementPtrTypeIterator.h" 22#include "llvm/IR/InstrTypes.h" 23#include "llvm/IR/Instructions.h" 24#include "llvm/IR/LeakDetector.h" 25#include "llvm/IR/Module.h" 26#include "llvm/IR/Operator.h" 27#include "llvm/IR/ValueHandle.h" 28#include "llvm/IR/ValueSymbolTable.h" 29#include "llvm/Support/Debug.h" 30#include "llvm/Support/ErrorHandling.h" 31#include "llvm/Support/ManagedStatic.h" 32#include <algorithm> 33using namespace llvm; 34 35//===----------------------------------------------------------------------===// 36// Value Class 37//===----------------------------------------------------------------------===// 38 39static inline Type *checkType(Type *Ty) { 40 assert(Ty && "Value defined with a null type: Error!"); 41 return const_cast<Type*>(Ty); 42} 43 44Value::Value(Type *ty, unsigned scid) 45 : SubclassID(scid), HasValueHandle(0), 46 SubclassOptionalData(0), SubclassData(0), VTy((Type*)checkType(ty)), 47 UseList(0), Name(0) { 48 // FIXME: Why isn't this in the subclass gunk?? 49 // Note, we cannot call isa<CallInst> before the CallInst has been 50 // constructed. 51 if (SubclassID == Instruction::Call || SubclassID == Instruction::Invoke) 52 assert((VTy->isFirstClassType() || VTy->isVoidTy() || VTy->isStructTy()) && 53 "invalid CallInst type!"); 54 else if (SubclassID != BasicBlockVal && 55 (SubclassID < ConstantFirstVal || SubclassID > ConstantLastVal)) 56 assert((VTy->isFirstClassType() || VTy->isVoidTy()) && 57 "Cannot create non-first-class values except for constants!"); 58} 59 60Value::~Value() { 61 // Notify all ValueHandles (if present) that this value is going away. 62 if (HasValueHandle) 63 ValueHandleBase::ValueIsDeleted(this); 64 65#ifndef NDEBUG // Only in -g mode... 66 // Check to make sure that there are no uses of this value that are still 67 // around when the value is destroyed. If there are, then we have a dangling 68 // reference and something is wrong. This code is here to print out what is 69 // still being referenced. The value in question should be printed as 70 // a <badref> 71 // 72 if (!use_empty()) { 73 dbgs() << "While deleting: " << *VTy << " %" << getName() << "\n"; 74 for (use_iterator I = use_begin(), E = use_end(); I != E; ++I) 75 dbgs() << "Use still stuck around after Def is destroyed:" 76 << **I << "\n"; 77 } 78#endif 79 assert(use_empty() && "Uses remain when a value is destroyed!"); 80 81 // If this value is named, destroy the name. This should not be in a symtab 82 // at this point. 83 if (Name && SubclassID != MDStringVal) 84 Name->Destroy(); 85 86 // There should be no uses of this object anymore, remove it. 87 LeakDetector::removeGarbageObject(this); 88} 89 90/// hasNUses - Return true if this Value has exactly N users. 91/// 92bool Value::hasNUses(unsigned N) const { 93 const_use_iterator UI = use_begin(), E = use_end(); 94 95 for (; N; --N, ++UI) 96 if (UI == E) return false; // Too few. 97 return UI == E; 98} 99 100/// hasNUsesOrMore - Return true if this value has N users or more. This is 101/// logically equivalent to getNumUses() >= N. 102/// 103bool Value::hasNUsesOrMore(unsigned N) const { 104 const_use_iterator UI = use_begin(), E = use_end(); 105 106 for (; N; --N, ++UI) 107 if (UI == E) return false; // Too few. 108 109 return true; 110} 111 112/// isUsedInBasicBlock - Return true if this value is used in the specified 113/// basic block. 114bool Value::isUsedInBasicBlock(const BasicBlock *BB) const { 115 // This can be computed either by scanning the instructions in BB, or by 116 // scanning the use list of this Value. Both lists can be very long, but 117 // usually one is quite short. 118 // 119 // Scan both lists simultaneously until one is exhausted. This limits the 120 // search to the shorter list. 121 BasicBlock::const_iterator BI = BB->begin(), BE = BB->end(); 122 const_user_iterator UI = user_begin(), UE = user_end(); 123 for (; BI != BE && UI != UE; ++BI, ++UI) { 124 // Scan basic block: Check if this Value is used by the instruction at BI. 125 if (std::find(BI->op_begin(), BI->op_end(), this) != BI->op_end()) 126 return true; 127 // Scan use list: Check if the use at UI is in BB. 128 const Instruction *User = dyn_cast<Instruction>(*UI); 129 if (User && User->getParent() == BB) 130 return true; 131 } 132 return false; 133} 134 135 136/// getNumUses - This method computes the number of uses of this Value. This 137/// is a linear time operation. Use hasOneUse or hasNUses to check for specific 138/// values. 139unsigned Value::getNumUses() const { 140 return (unsigned)std::distance(use_begin(), use_end()); 141} 142 143static bool getSymTab(Value *V, ValueSymbolTable *&ST) { 144 ST = 0; 145 if (Instruction *I = dyn_cast<Instruction>(V)) { 146 if (BasicBlock *P = I->getParent()) 147 if (Function *PP = P->getParent()) 148 ST = &PP->getValueSymbolTable(); 149 } else if (BasicBlock *BB = dyn_cast<BasicBlock>(V)) { 150 if (Function *P = BB->getParent()) 151 ST = &P->getValueSymbolTable(); 152 } else if (GlobalValue *GV = dyn_cast<GlobalValue>(V)) { 153 if (Module *P = GV->getParent()) 154 ST = &P->getValueSymbolTable(); 155 } else if (Argument *A = dyn_cast<Argument>(V)) { 156 if (Function *P = A->getParent()) 157 ST = &P->getValueSymbolTable(); 158 } else if (isa<MDString>(V)) 159 return true; 160 else { 161 assert(isa<Constant>(V) && "Unknown value type!"); 162 return true; // no name is setable for this. 163 } 164 return false; 165} 166 167StringRef Value::getName() const { 168 // Make sure the empty string is still a C string. For historical reasons, 169 // some clients want to call .data() on the result and expect it to be null 170 // terminated. 171 if (!Name) return StringRef("", 0); 172 return Name->getKey(); 173} 174 175void Value::setName(const Twine &NewName) { 176 assert(SubclassID != MDStringVal && 177 "Cannot set the name of MDString with this method!"); 178 179 // Fast path for common IRBuilder case of setName("") when there is no name. 180 if (NewName.isTriviallyEmpty() && !hasName()) 181 return; 182 183 SmallString<256> NameData; 184 StringRef NameRef = NewName.toStringRef(NameData); 185 assert(NameRef.find_first_of(0) == StringRef::npos && 186 "Null bytes are not allowed in names"); 187 188 // Name isn't changing? 189 if (getName() == NameRef) 190 return; 191 192 assert(!getType()->isVoidTy() && "Cannot assign a name to void values!"); 193 194 // Get the symbol table to update for this object. 195 ValueSymbolTable *ST; 196 if (getSymTab(this, ST)) 197 return; // Cannot set a name on this value (e.g. constant). 198 199 if (Function *F = dyn_cast<Function>(this)) 200 getContext().pImpl->IntrinsicIDCache.erase(F); 201 202 if (!ST) { // No symbol table to update? Just do the change. 203 if (NameRef.empty()) { 204 // Free the name for this value. 205 Name->Destroy(); 206 Name = 0; 207 return; 208 } 209 210 if (Name) 211 Name->Destroy(); 212 213 // NOTE: Could optimize for the case the name is shrinking to not deallocate 214 // then reallocated. 215 216 // Create the new name. 217 Name = ValueName::Create(NameRef.begin(), NameRef.end()); 218 Name->setValue(this); 219 return; 220 } 221 222 // NOTE: Could optimize for the case the name is shrinking to not deallocate 223 // then reallocated. 224 if (hasName()) { 225 // Remove old name. 226 ST->removeValueName(Name); 227 Name->Destroy(); 228 Name = 0; 229 230 if (NameRef.empty()) 231 return; 232 } 233 234 // Name is changing to something new. 235 Name = ST->createValueName(NameRef, this); 236} 237 238 239/// takeName - transfer the name from V to this value, setting V's name to 240/// empty. It is an error to call V->takeName(V). 241void Value::takeName(Value *V) { 242 assert(SubclassID != MDStringVal && "Cannot take the name of an MDString!"); 243 244 ValueSymbolTable *ST = 0; 245 // If this value has a name, drop it. 246 if (hasName()) { 247 // Get the symtab this is in. 248 if (getSymTab(this, ST)) { 249 // We can't set a name on this value, but we need to clear V's name if 250 // it has one. 251 if (V->hasName()) V->setName(""); 252 return; // Cannot set a name on this value (e.g. constant). 253 } 254 255 // Remove old name. 256 if (ST) 257 ST->removeValueName(Name); 258 Name->Destroy(); 259 Name = 0; 260 } 261 262 // Now we know that this has no name. 263 264 // If V has no name either, we're done. 265 if (!V->hasName()) return; 266 267 // Get this's symtab if we didn't before. 268 if (!ST) { 269 if (getSymTab(this, ST)) { 270 // Clear V's name. 271 V->setName(""); 272 return; // Cannot set a name on this value (e.g. constant). 273 } 274 } 275 276 // Get V's ST, this should always succed, because V has a name. 277 ValueSymbolTable *VST; 278 bool Failure = getSymTab(V, VST); 279 assert(!Failure && "V has a name, so it should have a ST!"); (void)Failure; 280 281 // If these values are both in the same symtab, we can do this very fast. 282 // This works even if both values have no symtab yet. 283 if (ST == VST) { 284 // Take the name! 285 Name = V->Name; 286 V->Name = 0; 287 Name->setValue(this); 288 return; 289 } 290 291 // Otherwise, things are slightly more complex. Remove V's name from VST and 292 // then reinsert it into ST. 293 294 if (VST) 295 VST->removeValueName(V->Name); 296 Name = V->Name; 297 V->Name = 0; 298 Name->setValue(this); 299 300 if (ST) 301 ST->reinsertValue(this); 302} 303 304 305void Value::replaceAllUsesWith(Value *New) { 306 assert(New && "Value::replaceAllUsesWith(<null>) is invalid!"); 307 assert(New != this && "this->replaceAllUsesWith(this) is NOT valid!"); 308 assert(New->getType() == getType() && 309 "replaceAllUses of value with new value of different type!"); 310 311 // Notify all ValueHandles (if present) that this value is going away. 312 if (HasValueHandle) 313 ValueHandleBase::ValueIsRAUWd(this, New); 314 315 while (!use_empty()) { 316 Use &U = *UseList; 317 // Must handle Constants specially, we cannot call replaceUsesOfWith on a 318 // constant because they are uniqued. 319 if (Constant *C = dyn_cast<Constant>(U.getUser())) { 320 if (!isa<GlobalValue>(C)) { 321 C->replaceUsesOfWithOnConstant(this, New, &U); 322 continue; 323 } 324 } 325 326 U.set(New); 327 } 328 329 if (BasicBlock *BB = dyn_cast<BasicBlock>(this)) 330 BB->replaceSuccessorsPhiUsesWith(cast<BasicBlock>(New)); 331} 332 333namespace { 334// Various metrics for how much to strip off of pointers. 335enum PointerStripKind { 336 PSK_ZeroIndices, 337 PSK_ZeroIndicesAndAliases, 338 PSK_InBoundsConstantIndices, 339 PSK_InBounds 340}; 341 342template <PointerStripKind StripKind> 343static Value *stripPointerCastsAndOffsets(Value *V) { 344 if (!V->getType()->isPointerTy()) 345 return V; 346 347 // Even though we don't look through PHI nodes, we could be called on an 348 // instruction in an unreachable block, which may be on a cycle. 349 SmallPtrSet<Value *, 4> Visited; 350 351 Visited.insert(V); 352 do { 353 if (GEPOperator *GEP = dyn_cast<GEPOperator>(V)) { 354 switch (StripKind) { 355 case PSK_ZeroIndicesAndAliases: 356 case PSK_ZeroIndices: 357 if (!GEP->hasAllZeroIndices()) 358 return V; 359 break; 360 case PSK_InBoundsConstantIndices: 361 if (!GEP->hasAllConstantIndices()) 362 return V; 363 // fallthrough 364 case PSK_InBounds: 365 if (!GEP->isInBounds()) 366 return V; 367 break; 368 } 369 V = GEP->getPointerOperand(); 370 } else if (Operator::getOpcode(V) == Instruction::BitCast || 371 Operator::getOpcode(V) == Instruction::AddrSpaceCast) { 372 V = cast<Operator>(V)->getOperand(0); 373 } else if (GlobalAlias *GA = dyn_cast<GlobalAlias>(V)) { 374 if (StripKind == PSK_ZeroIndices || GA->mayBeOverridden()) 375 return V; 376 V = GA->getAliasee(); 377 } else { 378 return V; 379 } 380 assert(V->getType()->isPointerTy() && "Unexpected operand type!"); 381 } while (Visited.insert(V)); 382 383 return V; 384} 385} // namespace 386 387Value *Value::stripPointerCasts() { 388 return stripPointerCastsAndOffsets<PSK_ZeroIndicesAndAliases>(this); 389} 390 391Value *Value::stripPointerCastsNoFollowAliases() { 392 return stripPointerCastsAndOffsets<PSK_ZeroIndices>(this); 393} 394 395Value *Value::stripInBoundsConstantOffsets() { 396 return stripPointerCastsAndOffsets<PSK_InBoundsConstantIndices>(this); 397} 398 399Value *Value::stripAndAccumulateInBoundsConstantOffsets(const DataLayout &DL, 400 APInt &Offset) { 401 if (!getType()->isPointerTy()) 402 return this; 403 404 assert(Offset.getBitWidth() == DL.getPointerSizeInBits(cast<PointerType>( 405 getType())->getAddressSpace()) && 406 "The offset must have exactly as many bits as our pointer."); 407 408 // Even though we don't look through PHI nodes, we could be called on an 409 // instruction in an unreachable block, which may be on a cycle. 410 SmallPtrSet<Value *, 4> Visited; 411 Visited.insert(this); 412 Value *V = this; 413 do { 414 if (GEPOperator *GEP = dyn_cast<GEPOperator>(V)) { 415 if (!GEP->isInBounds()) 416 return V; 417 APInt GEPOffset(Offset); 418 if (!GEP->accumulateConstantOffset(DL, GEPOffset)) 419 return V; 420 Offset = GEPOffset; 421 V = GEP->getPointerOperand(); 422 } else if (Operator::getOpcode(V) == Instruction::BitCast) { 423 V = cast<Operator>(V)->getOperand(0); 424 } else if (GlobalAlias *GA = dyn_cast<GlobalAlias>(V)) { 425 V = GA->getAliasee(); 426 } else { 427 return V; 428 } 429 assert(V->getType()->isPointerTy() && "Unexpected operand type!"); 430 } while (Visited.insert(V)); 431 432 return V; 433} 434 435Value *Value::stripInBoundsOffsets() { 436 return stripPointerCastsAndOffsets<PSK_InBounds>(this); 437} 438 439/// isDereferenceablePointer - Test if this value is always a pointer to 440/// allocated and suitably aligned memory for a simple load or store. 441static bool isDereferenceablePointer(const Value *V, 442 SmallPtrSet<const Value *, 32> &Visited) { 443 // Note that it is not safe to speculate into a malloc'd region because 444 // malloc may return null. 445 // It's also not always safe to follow a bitcast, for example: 446 // bitcast i8* (alloca i8) to i32* 447 // would result in a 4-byte load from a 1-byte alloca. Some cases could 448 // be handled using DataLayout to check sizes and alignments though. 449 450 // These are obviously ok. 451 if (isa<AllocaInst>(V)) return true; 452 453 // Global variables which can't collapse to null are ok. 454 if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(V)) 455 return !GV->hasExternalWeakLinkage(); 456 457 // byval arguments are ok. 458 if (const Argument *A = dyn_cast<Argument>(V)) 459 return A->hasByValAttr(); 460 461 // For GEPs, determine if the indexing lands within the allocated object. 462 if (const GEPOperator *GEP = dyn_cast<GEPOperator>(V)) { 463 // Conservatively require that the base pointer be fully dereferenceable. 464 if (!Visited.insert(GEP->getOperand(0))) 465 return false; 466 if (!isDereferenceablePointer(GEP->getOperand(0), Visited)) 467 return false; 468 // Check the indices. 469 gep_type_iterator GTI = gep_type_begin(GEP); 470 for (User::const_op_iterator I = GEP->op_begin()+1, 471 E = GEP->op_end(); I != E; ++I) { 472 Value *Index = *I; 473 Type *Ty = *GTI++; 474 // Struct indices can't be out of bounds. 475 if (isa<StructType>(Ty)) 476 continue; 477 ConstantInt *CI = dyn_cast<ConstantInt>(Index); 478 if (!CI) 479 return false; 480 // Zero is always ok. 481 if (CI->isZero()) 482 continue; 483 // Check to see that it's within the bounds of an array. 484 ArrayType *ATy = dyn_cast<ArrayType>(Ty); 485 if (!ATy) 486 return false; 487 if (CI->getValue().getActiveBits() > 64) 488 return false; 489 if (CI->getZExtValue() >= ATy->getNumElements()) 490 return false; 491 } 492 // Indices check out; this is dereferenceable. 493 return true; 494 } 495 496 // If we don't know, assume the worst. 497 return false; 498} 499 500/// isDereferenceablePointer - Test if this value is always a pointer to 501/// allocated and suitably aligned memory for a simple load or store. 502bool Value::isDereferenceablePointer() const { 503 SmallPtrSet<const Value *, 32> Visited; 504 return ::isDereferenceablePointer(this, Visited); 505} 506 507/// DoPHITranslation - If this value is a PHI node with CurBB as its parent, 508/// return the value in the PHI node corresponding to PredBB. If not, return 509/// ourself. This is useful if you want to know the value something has in a 510/// predecessor block. 511Value *Value::DoPHITranslation(const BasicBlock *CurBB, 512 const BasicBlock *PredBB) { 513 PHINode *PN = dyn_cast<PHINode>(this); 514 if (PN && PN->getParent() == CurBB) 515 return PN->getIncomingValueForBlock(PredBB); 516 return this; 517} 518 519LLVMContext &Value::getContext() const { return VTy->getContext(); } 520 521//===----------------------------------------------------------------------===// 522// ValueHandleBase Class 523//===----------------------------------------------------------------------===// 524 525/// AddToExistingUseList - Add this ValueHandle to the use list for VP, where 526/// List is known to point into the existing use list. 527void ValueHandleBase::AddToExistingUseList(ValueHandleBase **List) { 528 assert(List && "Handle list is null?"); 529 530 // Splice ourselves into the list. 531 Next = *List; 532 *List = this; 533 setPrevPtr(List); 534 if (Next) { 535 Next->setPrevPtr(&Next); 536 assert(VP.getPointer() == Next->VP.getPointer() && "Added to wrong list?"); 537 } 538} 539 540void ValueHandleBase::AddToExistingUseListAfter(ValueHandleBase *List) { 541 assert(List && "Must insert after existing node"); 542 543 Next = List->Next; 544 setPrevPtr(&List->Next); 545 List->Next = this; 546 if (Next) 547 Next->setPrevPtr(&Next); 548} 549 550/// AddToUseList - Add this ValueHandle to the use list for VP. 551void ValueHandleBase::AddToUseList() { 552 assert(VP.getPointer() && "Null pointer doesn't have a use list!"); 553 554 LLVMContextImpl *pImpl = VP.getPointer()->getContext().pImpl; 555 556 if (VP.getPointer()->HasValueHandle) { 557 // If this value already has a ValueHandle, then it must be in the 558 // ValueHandles map already. 559 ValueHandleBase *&Entry = pImpl->ValueHandles[VP.getPointer()]; 560 assert(Entry != 0 && "Value doesn't have any handles?"); 561 AddToExistingUseList(&Entry); 562 return; 563 } 564 565 // Ok, it doesn't have any handles yet, so we must insert it into the 566 // DenseMap. However, doing this insertion could cause the DenseMap to 567 // reallocate itself, which would invalidate all of the PrevP pointers that 568 // point into the old table. Handle this by checking for reallocation and 569 // updating the stale pointers only if needed. 570 DenseMap<Value*, ValueHandleBase*> &Handles = pImpl->ValueHandles; 571 const void *OldBucketPtr = Handles.getPointerIntoBucketsArray(); 572 573 ValueHandleBase *&Entry = Handles[VP.getPointer()]; 574 assert(Entry == 0 && "Value really did already have handles?"); 575 AddToExistingUseList(&Entry); 576 VP.getPointer()->HasValueHandle = true; 577 578 // If reallocation didn't happen or if this was the first insertion, don't 579 // walk the table. 580 if (Handles.isPointerIntoBucketsArray(OldBucketPtr) || 581 Handles.size() == 1) { 582 return; 583 } 584 585 // Okay, reallocation did happen. Fix the Prev Pointers. 586 for (DenseMap<Value*, ValueHandleBase*>::iterator I = Handles.begin(), 587 E = Handles.end(); I != E; ++I) { 588 assert(I->second && I->first == I->second->VP.getPointer() && 589 "List invariant broken!"); 590 I->second->setPrevPtr(&I->second); 591 } 592} 593 594/// RemoveFromUseList - Remove this ValueHandle from its current use list. 595void ValueHandleBase::RemoveFromUseList() { 596 assert(VP.getPointer() && VP.getPointer()->HasValueHandle && 597 "Pointer doesn't have a use list!"); 598 599 // Unlink this from its use list. 600 ValueHandleBase **PrevPtr = getPrevPtr(); 601 assert(*PrevPtr == this && "List invariant broken"); 602 603 *PrevPtr = Next; 604 if (Next) { 605 assert(Next->getPrevPtr() == &Next && "List invariant broken"); 606 Next->setPrevPtr(PrevPtr); 607 return; 608 } 609 610 // If the Next pointer was null, then it is possible that this was the last 611 // ValueHandle watching VP. If so, delete its entry from the ValueHandles 612 // map. 613 LLVMContextImpl *pImpl = VP.getPointer()->getContext().pImpl; 614 DenseMap<Value*, ValueHandleBase*> &Handles = pImpl->ValueHandles; 615 if (Handles.isPointerIntoBucketsArray(PrevPtr)) { 616 Handles.erase(VP.getPointer()); 617 VP.getPointer()->HasValueHandle = false; 618 } 619} 620 621 622void ValueHandleBase::ValueIsDeleted(Value *V) { 623 assert(V->HasValueHandle && "Should only be called if ValueHandles present"); 624 625 // Get the linked list base, which is guaranteed to exist since the 626 // HasValueHandle flag is set. 627 LLVMContextImpl *pImpl = V->getContext().pImpl; 628 ValueHandleBase *Entry = pImpl->ValueHandles[V]; 629 assert(Entry && "Value bit set but no entries exist"); 630 631 // We use a local ValueHandleBase as an iterator so that ValueHandles can add 632 // and remove themselves from the list without breaking our iteration. This 633 // is not really an AssertingVH; we just have to give ValueHandleBase a kind. 634 // Note that we deliberately do not the support the case when dropping a value 635 // handle results in a new value handle being permanently added to the list 636 // (as might occur in theory for CallbackVH's): the new value handle will not 637 // be processed and the checking code will mete out righteous punishment if 638 // the handle is still present once we have finished processing all the other 639 // value handles (it is fine to momentarily add then remove a value handle). 640 for (ValueHandleBase Iterator(Assert, *Entry); Entry; Entry = Iterator.Next) { 641 Iterator.RemoveFromUseList(); 642 Iterator.AddToExistingUseListAfter(Entry); 643 assert(Entry->Next == &Iterator && "Loop invariant broken."); 644 645 switch (Entry->getKind()) { 646 case Assert: 647 break; 648 case Tracking: 649 // Mark that this value has been deleted by setting it to an invalid Value 650 // pointer. 651 Entry->operator=(DenseMapInfo<Value *>::getTombstoneKey()); 652 break; 653 case Weak: 654 // Weak just goes to null, which will unlink it from the list. 655 Entry->operator=(0); 656 break; 657 case Callback: 658 // Forward to the subclass's implementation. 659 static_cast<CallbackVH*>(Entry)->deleted(); 660 break; 661 } 662 } 663 664 // All callbacks, weak references, and assertingVHs should be dropped by now. 665 if (V->HasValueHandle) { 666#ifndef NDEBUG // Only in +Asserts mode... 667 dbgs() << "While deleting: " << *V->getType() << " %" << V->getName() 668 << "\n"; 669 if (pImpl->ValueHandles[V]->getKind() == Assert) 670 llvm_unreachable("An asserting value handle still pointed to this" 671 " value!"); 672 673#endif 674 llvm_unreachable("All references to V were not removed?"); 675 } 676} 677 678 679void ValueHandleBase::ValueIsRAUWd(Value *Old, Value *New) { 680 assert(Old->HasValueHandle &&"Should only be called if ValueHandles present"); 681 assert(Old != New && "Changing value into itself!"); 682 683 // Get the linked list base, which is guaranteed to exist since the 684 // HasValueHandle flag is set. 685 LLVMContextImpl *pImpl = Old->getContext().pImpl; 686 ValueHandleBase *Entry = pImpl->ValueHandles[Old]; 687 688 assert(Entry && "Value bit set but no entries exist"); 689 690 // We use a local ValueHandleBase as an iterator so that 691 // ValueHandles can add and remove themselves from the list without 692 // breaking our iteration. This is not really an AssertingVH; we 693 // just have to give ValueHandleBase some kind. 694 for (ValueHandleBase Iterator(Assert, *Entry); Entry; Entry = Iterator.Next) { 695 Iterator.RemoveFromUseList(); 696 Iterator.AddToExistingUseListAfter(Entry); 697 assert(Entry->Next == &Iterator && "Loop invariant broken."); 698 699 switch (Entry->getKind()) { 700 case Assert: 701 // Asserting handle does not follow RAUW implicitly. 702 break; 703 case Tracking: 704 // Tracking goes to new value like a WeakVH. Note that this may make it 705 // something incompatible with its templated type. We don't want to have a 706 // virtual (or inline) interface to handle this though, so instead we make 707 // the TrackingVH accessors guarantee that a client never sees this value. 708 709 // FALLTHROUGH 710 case Weak: 711 // Weak goes to the new value, which will unlink it from Old's list. 712 Entry->operator=(New); 713 break; 714 case Callback: 715 // Forward to the subclass's implementation. 716 static_cast<CallbackVH*>(Entry)->allUsesReplacedWith(New); 717 break; 718 } 719 } 720 721#ifndef NDEBUG 722 // If any new tracking or weak value handles were added while processing the 723 // list, then complain about it now. 724 if (Old->HasValueHandle) 725 for (Entry = pImpl->ValueHandles[Old]; Entry; Entry = Entry->Next) 726 switch (Entry->getKind()) { 727 case Tracking: 728 case Weak: 729 dbgs() << "After RAUW from " << *Old->getType() << " %" 730 << Old->getName() << " to " << *New->getType() << " %" 731 << New->getName() << "\n"; 732 llvm_unreachable("A tracking or weak value handle still pointed to the" 733 " old value!\n"); 734 default: 735 break; 736 } 737#endif 738} 739 740// Pin the vtable to this file. 741void CallbackVH::anchor() {} 742