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