lib/Transforms/Scalar/DeadStoreElimination.cpp

   1 //===- DeadStoreElimination.cpp - Fast Dead Store Elimination -------------===//
   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 a trivial dead store elimination that only considers
  11 // basic-block local redundant stores.
  12 //
  13 // FIXME: This should eventually be extended to be a post-dominator tree
  14 // traversal.  Doing so would be pretty trivial.
  15 //
  16 //===----------------------------------------------------------------------===//
  17
  18 #define DEBUG_TYPE "dse"
  19 #include "llvm/Transforms/Scalar.h"
  20 #include "llvm/Constants.h"
  21 #include "llvm/Function.h"
  22 #include "llvm/Instructions.h"
  23 #include "llvm/IntrinsicInst.h"
  24 #include "llvm/Pass.h"
  25 #include "llvm/ADT/SmallPtrSet.h"
  26 #include "llvm/ADT/Statistic.h"
  27 #include "llvm/Analysis/AliasAnalysis.h"
  28 #include "llvm/Analysis/Dominators.h"
  29 #include "llvm/Analysis/MemoryBuiltins.h"
  30 #include "llvm/Analysis/MemoryDependenceAnalysis.h"
  31 #include "llvm/Target/TargetData.h"
  32 #include "llvm/Transforms/Utils/Local.h"
  33 using namespace llvm;
  34
  35 STATISTIC(NumFastStores, "Number of stores deleted");
  36 STATISTIC(NumFastOther , "Number of other instrs removed");
  37
  38 namespace {
  39   struct DSE : public FunctionPass {
  40     AliasAnalysis *AA;
  41     MemoryDependenceAnalysis *MD;
  42
  43     static char ID; // Pass identification, replacement for typeid
  44     DSE() : FunctionPass(ID), AA(0), MD(0) {
  45       initializeDSEPass(*PassRegistry::getPassRegistry());
  46     }
  47
  48     virtual bool runOnFunction(Function &F) {
  49       AA = &getAnalysis<AliasAnalysis>();
  50       MD = &getAnalysis<MemoryDependenceAnalysis>();
  51       DominatorTree &DT = getAnalysis<DominatorTree>();
  52
  53       bool Changed = false;
  54       for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I)
  55         // Only check non-dead blocks.  Dead blocks may have strange pointer
  56         // cycles that will confuse alias analysis.
  57         if (DT.isReachableFromEntry(I))
  58           Changed |= runOnBasicBlock(*I);
  59
  60       AA = 0; MD = 0;
  61       return Changed;
  62     }
  63
  64     bool runOnBasicBlock(BasicBlock &BB);
  65     bool HandleFree(CallInst *F);
  66     bool handleEndBlock(BasicBlock &BB);
  67     void RemoveAccessedObjects(const AliasAnalysis::Location &LoadedLoc,
  68                                SmallPtrSet<Value*, 16> &DeadStackObjects);
  69
  70
  71     // getAnalysisUsage - We require post dominance frontiers (aka Control
  72     // Dependence Graph)
  73     virtual void getAnalysisUsage(AnalysisUsage &AU) const {
  74       AU.setPreservesCFG();
  75       AU.addRequired<DominatorTree>();
  76       AU.addRequired<AliasAnalysis>();
  77       AU.addRequired<MemoryDependenceAnalysis>();
  78       AU.addPreserved<AliasAnalysis>();
  79       AU.addPreserved<DominatorTree>();
  80       AU.addPreserved<MemoryDependenceAnalysis>();
  81     }
  82   };
  83 }
  84
  85 char DSE::ID = 0;
  86 INITIALIZE_PASS_BEGIN(DSE, "dse", "Dead Store Elimination", false, false)
  87 INITIALIZE_PASS_DEPENDENCY(DominatorTree)
  88 INITIALIZE_PASS_DEPENDENCY(MemoryDependenceAnalysis)
  89 INITIALIZE_AG_DEPENDENCY(AliasAnalysis)
  90 INITIALIZE_PASS_END(DSE, "dse", "Dead Store Elimination", false, false)
  91
  92 FunctionPass *llvm::createDeadStoreEliminationPass() { return new DSE(); }
  93
  94 //===----------------------------------------------------------------------===//
  95 // Helper functions
  96 //===----------------------------------------------------------------------===//
  97
  98 /// DeleteDeadInstruction - Delete this instruction.  Before we do, go through
  99 /// and zero out all the operands of this instruction.  If any of them become
 100 /// dead, delete them and the computation tree that feeds them.
 101 ///
 102 /// If ValueSet is non-null, remove any deleted instructions from it as well.
 103 ///
 104 static void DeleteDeadInstruction(Instruction *I,
 105                                   MemoryDependenceAnalysis &MD,
 106                                   SmallPtrSet<Value*, 16> *ValueSet = 0) {
 107   SmallVector<Instruction*, 32> NowDeadInsts;
 108
 109   NowDeadInsts.push_back(I);
 110   --NumFastOther;
 111
 112   // Before we touch this instruction, remove it from memdep!
 113   do {
 114     Instruction *DeadInst = NowDeadInsts.pop_back_val();
 115     ++NumFastOther;
 116
 117     // This instruction is dead, zap it, in stages.  Start by removing it from
 118     // MemDep, which needs to know the operands and needs it to be in the
 119     // function.
 120     MD.removeInstruction(DeadInst);
 121
 122     for (unsigned op = 0, e = DeadInst->getNumOperands(); op != e; ++op) {
 123       Value *Op = DeadInst->getOperand(op);
 124       DeadInst->setOperand(op, 0);
 125
 126       // If this operand just became dead, add it to the NowDeadInsts list.
 127       if (!Op->use_empty()) continue;
 128
 129       if (Instruction *OpI = dyn_cast<Instruction>(Op))
 130         if (isInstructionTriviallyDead(OpI))
 131           NowDeadInsts.push_back(OpI);
 132     }
 133
 134     DeadInst->eraseFromParent();
 135
 136     if (ValueSet) ValueSet->erase(DeadInst);
 137   } while (!NowDeadInsts.empty());
 138 }
 139
 140
 141 /// hasMemoryWrite - Does this instruction write some memory?  This only returns
 142 /// true for things that we can analyze with other helpers below.
 143 static bool hasMemoryWrite(Instruction *I) {
 144   if (isa<StoreInst>(I))
 145     return true;
 146   if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(I)) {
 147     switch (II->getIntrinsicID()) {
 148     default:
 149       return false;
 150     case Intrinsic::memset:
 151     case Intrinsic::memmove:
 152     case Intrinsic::memcpy:
 153     case Intrinsic::init_trampoline:
 154     case Intrinsic::lifetime_end:
 155       return true;
 156     }
 157   }
 158   return false;
 159 }
 160
 161 /// getLocForWrite - Return a Location stored to by the specified instruction.
 162 static AliasAnalysis::Location
 163 getLocForWrite(Instruction *Inst, AliasAnalysis &AA) {
 164   if (StoreInst *SI = dyn_cast<StoreInst>(Inst))
 165     return AA.getLocation(SI);
 166
 167   if (MemIntrinsic *MI = dyn_cast<MemIntrinsic>(Inst)) {
 168     // memcpy/memmove/memset.
 169     AliasAnalysis::Location Loc = AA.getLocationForDest(MI);
 170     // If we don't have target data around, an unknown size in Location means
 171     // that we should use the size of the pointee type.  This isn't valid for
 172     // memset/memcpy, which writes more than an i8.
 173     if (Loc.Size == AliasAnalysis::UnknownSize && AA.getTargetData() == 0)
 174       return AliasAnalysis::Location();
 175     return Loc;
 176   }
 177
 178   IntrinsicInst *II = dyn_cast<IntrinsicInst>(Inst);
 179   if (II == 0) return AliasAnalysis::Location();
 180
 181   switch (II->getIntrinsicID()) {
 182   default: return AliasAnalysis::Location(); // Unhandled intrinsic.
 183   case Intrinsic::init_trampoline:
 184     // If we don't have target data around, an unknown size in Location means
 185     // that we should use the size of the pointee type.  This isn't valid for
 186     // init.trampoline, which writes more than an i8.
 187     if (AA.getTargetData() == 0) return AliasAnalysis::Location();
 188
 189     // FIXME: We don't know the size of the trampoline, so we can't really
 190     // handle it here.
 191     return AliasAnalysis::Location(II->getArgOperand(0));
 192   case Intrinsic::lifetime_end: {
 193     uint64_t Len = cast<ConstantInt>(II->getArgOperand(0))->getZExtValue();
 194     return AliasAnalysis::Location(II->getArgOperand(1), Len);
 195   }
 196   }
 197 }
 198
 199 /// isRemovable - If the value of this instruction and the memory it writes to
 200 /// is unused, may we delete this instruction?
 201 static bool isRemovable(Instruction *I) {
 202   // Don't remove volatile stores.
 203   if (StoreInst *SI = dyn_cast<StoreInst>(I))
 204     return !SI->isVolatile();
 205
 206   IntrinsicInst *II = cast<IntrinsicInst>(I);
 207   switch (II->getIntrinsicID()) {
 208   default: assert(0 && "doesn't pass 'hasMemoryWrite' predicate");
 209   case Intrinsic::lifetime_end:
 210     // Never remove dead lifetime_end's, e.g. because it is followed by a
 211     // free.
 212     return false;
 213   case Intrinsic::init_trampoline:
 214     // Always safe to remove init_trampoline.
 215     return true;
 216
 217   case Intrinsic::memset:
 218   case Intrinsic::memmove:
 219   case Intrinsic::memcpy:
 220     // Don't remove volatile memory intrinsics.
 221     return !cast<MemIntrinsic>(II)->isVolatile();
 222   }
 223 }
 224
 225 /// getStoredPointerOperand - Return the pointer that is being written to.
 226 static Value *getStoredPointerOperand(Instruction *I) {
 227   if (StoreInst *SI = dyn_cast<StoreInst>(I))
 228     return SI->getPointerOperand();
 229   if (MemIntrinsic *MI = dyn_cast<MemIntrinsic>(I))
 230     return MI->getDest();
 231
 232   IntrinsicInst *II = cast<IntrinsicInst>(I);
 233   switch (II->getIntrinsicID()) {
 234   default: assert(false && "Unexpected intrinsic!");
 235   case Intrinsic::init_trampoline:
 236     return II->getArgOperand(0);
 237   }
 238 }
 239
 240 static uint64_t getPointerSize(Value *V, AliasAnalysis &AA) {
 241   const TargetData *TD = AA.getTargetData();
 242   if (TD == 0)
 243     return AliasAnalysis::UnknownSize;
 244
 245   if (AllocaInst *A = dyn_cast<AllocaInst>(V)) {
 246     // Get size information for the alloca
 247     if (ConstantInt *C = dyn_cast<ConstantInt>(A->getArraySize()))
 248       return C->getZExtValue() * TD->getTypeAllocSize(A->getAllocatedType());
 249     return AliasAnalysis::UnknownSize;
 250   }
 251
 252   assert(isa<Argument>(V) && "Expected AllocaInst or Argument!");
 253   const PointerType *PT = cast<PointerType>(V->getType());
 254   return TD->getTypeAllocSize(PT->getElementType());
 255 }
 256
 257
 258 /// isCompleteOverwrite - Return true if a store to the 'Later' location
 259 /// completely overwrites a store to the 'Earlier' location.
 260 static bool isCompleteOverwrite(const AliasAnalysis::Location &Later,
 261                                 const AliasAnalysis::Location &Earlier,
 262                                 AliasAnalysis &AA) {
 263   const Value *P1 = Later.Ptr->stripPointerCasts();
 264   const Value *P2 = Earlier.Ptr->stripPointerCasts();
 265
 266   // Make sure that the start pointers are the same.
 267   if (P1 != P2)
 268     return false;
 269
 270   // If we don't know the sizes of either access, then we can't do a comparison.
 271   if (Later.Size == AliasAnalysis::UnknownSize ||
 272       Earlier.Size == AliasAnalysis::UnknownSize) {
 273     // If we have no TargetData information around, then the size of the store
 274     // is inferrable from the pointee type.  If they are the same type, then we
 275     // know that the store is safe.
 276     if (AA.getTargetData() == 0)
 277       return Later.Ptr->getType() == Earlier.Ptr->getType();
 278     return false;
 279   }
 280
 281   // Make sure that the Later size is >= the Earlier size.
 282   if (Later.Size < Earlier.Size)
 283     return false;
 284
 285   return true;
 286 }
 287
 288
 289 //===----------------------------------------------------------------------===//
 290 // DSE Pass
 291 //===----------------------------------------------------------------------===//
 292
 293 bool DSE::runOnBasicBlock(BasicBlock &BB) {
 294   bool MadeChange = false;
 295
 296   // Do a top-down walk on the BB.
 297   for (BasicBlock::iterator BBI = BB.begin(), BBE = BB.end(); BBI != BBE; ) {
 298     Instruction *Inst = BBI++;
 299
 300     // Handle 'free' calls specially.
 301     if (CallInst *F = isFreeCall(Inst)) {
 302       MadeChange |= HandleFree(F);
 303       continue;
 304     }
 305
 306     // If we find something that writes memory, get its memory dependence.
 307     if (!hasMemoryWrite(Inst))
 308       continue;
 309
 310     MemDepResult InstDep = MD->getDependency(Inst);
 311
 312     // Ignore non-local store liveness.
 313     // FIXME: cross-block DSE would be fun. :)
 314     if (InstDep.isNonLocal() ||
 315         // Ignore self dependence, which happens in the entry block of the
 316         // function.
 317         InstDep.getInst() == Inst)
 318       continue;
 319
 320     // If we're storing the same value back to a pointer that we just
 321     // loaded from, then the store can be removed.
 322     if (StoreInst *SI = dyn_cast<StoreInst>(Inst)) {
 323       if (LoadInst *DepLoad = dyn_cast<LoadInst>(InstDep.getInst())) {
 324         if (SI->getPointerOperand() == DepLoad->getPointerOperand() &&
 325             SI->getOperand(0) == DepLoad && !SI->isVolatile()) {
 326           // DeleteDeadInstruction can delete the current instruction.  Save BBI
 327           // in case we need it.
 328           WeakVH NextInst(BBI);
 329
 330           DeleteDeadInstruction(SI, *MD);
 331
 332           if (NextInst == 0)  // Next instruction deleted.
 333             BBI = BB.begin();
 334           else if (BBI != BB.begin())  // Revisit this instruction if possible.
 335             --BBI;
 336           ++NumFastStores;
 337           MadeChange = true;
 338           continue;
 339         }
 340       }
 341     }
 342
 343     // Figure out what location is being stored to.
 344     AliasAnalysis::Location Loc = getLocForWrite(Inst, *AA);
 345
 346     // If we didn't get a useful location, fail.
 347     if (Loc.Ptr == 0)
 348       continue;
 349
 350     while (!InstDep.isNonLocal()) {
 351       // Get the memory clobbered by the instruction we depend on.  MemDep will
 352       // skip any instructions that 'Loc' clearly doesn't interact with.  If we
 353       // end up depending on a may- or must-aliased load, then we can't optimize
 354       // away the store and we bail out.  However, if we depend on on something
 355       // that overwrites the memory location we *can* potentially optimize it.
 356       //
 357       // Find out what memory location the dependant instruction stores.
 358       Instruction *DepWrite = InstDep.getInst();
 359       AliasAnalysis::Location DepLoc = getLocForWrite(DepWrite, *AA);
 360       // If we didn't get a useful location, or if it isn't a size, bail out.
 361       if (DepLoc.Ptr == 0)
 362         break;
 363
 364       // If we find a removable write that is completely obliterated by the
 365       // store to 'Loc' then we can remove it.
 366       if (isRemovable(DepWrite) && isCompleteOverwrite(Loc, DepLoc, *AA)) {
 367         // Delete the store and now-dead instructions that feed it.
 368         DeleteDeadInstruction(DepWrite, *MD);
 369         ++NumFastStores;
 370         MadeChange = true;
 371
 372         // DeleteDeadInstruction can delete the current instruction in loop
 373         // cases, reset BBI.
 374         BBI = Inst;
 375         if (BBI != BB.begin())
 376           --BBI;
 377         break;
 378       }
 379
 380       // If this is a may-aliased store that is clobbering the store value, we
 381       // can keep searching past it for another must-aliased pointer that stores
 382       // to the same location.  For example, in:
 383       //   store -> P
 384       //   store -> Q
 385       //   store -> P
 386       // we can remove the first store to P even though we don't know if P and Q
 387       // alias.
 388       if (DepWrite == &BB.front()) break;
 389
 390       // Can't look past this instruction if it might read 'Loc'.
 391       if (AA->getModRefInfo(DepWrite, Loc) & AliasAnalysis::Ref)
 392         break;
 393
 394       InstDep = MD->getPointerDependencyFrom(Loc, false, DepWrite, &BB);
 395     }
 396   }
 397
 398   // If this block ends in a return, unwind, or unreachable, all allocas are
 399   // dead at its end, which means stores to them are also dead.
 400   if (BB.getTerminator()->getNumSuccessors() == 0)
 401     MadeChange |= handleEndBlock(BB);
 402
 403   return MadeChange;
 404 }
 405
 406 /// HandleFree - Handle frees of entire structures whose dependency is a store
 407 /// to a field of that structure.
 408 bool DSE::HandleFree(CallInst *F) {
 409   MemDepResult Dep = MD->getDependency(F);
 410   do {
 411     if (Dep.isNonLocal()) return false;
 412
 413     Instruction *Dependency = Dep.getInst();
 414     if (!hasMemoryWrite(Dependency) || !isRemovable(Dependency))
 415       return false;
 416
 417     Value *DepPointer =
 418       getStoredPointerOperand(Dependency)->getUnderlyingObject();
 419
 420     // Check for aliasing.
 421     if (AA->alias(F->getArgOperand(0), 1, DepPointer, 1) !=
 422           AliasAnalysis::MustAlias)
 423       return false;
 424
 425     // DCE instructions only used to calculate that store
 426     DeleteDeadInstruction(Dependency, *MD);
 427     ++NumFastStores;
 428
 429     // Inst's old Dependency is now deleted. Compute the next dependency,
 430     // which may also be dead, as in
 431     //    s[0] = 0;
 432     //    s[1] = 0; // This has just been deleted.
 433     //    free(s);
 434     Dep = MD->getDependency(F);
 435   } while (!Dep.isNonLocal());
 436
 437   return true;
 438 }
 439
 440 /// handleEndBlock - Remove dead stores to stack-allocated locations in the
 441 /// function end block.  Ex:
 442 /// %A = alloca i32
 443 /// ...
 444 /// store i32 1, i32* %A
 445 /// ret void
 446 bool DSE::handleEndBlock(BasicBlock &BB) {
 447   bool MadeChange = false;
 448
 449   // Keep track of all of the stack objects that are dead at the end of the
 450   // function.
 451   SmallPtrSet<Value*, 16> DeadStackObjects;
 452
 453   // Find all of the alloca'd pointers in the entry block.
 454   BasicBlock *Entry = BB.getParent()->begin();
 455   for (BasicBlock::iterator I = Entry->begin(), E = Entry->end(); I != E; ++I)
 456     if (AllocaInst *AI = dyn_cast<AllocaInst>(I))
 457       DeadStackObjects.insert(AI);
 458
 459   // Treat byval arguments the same, stores to them are dead at the end of the
 460   // function.
 461   for (Function::arg_iterator AI = BB.getParent()->arg_begin(),
 462        AE = BB.getParent()->arg_end(); AI != AE; ++AI)
 463     if (AI->hasByValAttr())
 464       DeadStackObjects.insert(AI);
 465
 466   // Scan the basic block backwards
 467   for (BasicBlock::iterator BBI = BB.end(); BBI != BB.begin(); ){
 468     --BBI;
 469
 470     // If we find a store, check to see if it points into a dead stack value.
 471     if (hasMemoryWrite(BBI) && isRemovable(BBI)) {
 472       // See through pointer-to-pointer bitcasts
 473       Value *Pointer = getStoredPointerOperand(BBI)->getUnderlyingObject();
 474
 475       // Stores to stack values are valid candidates for removal.
 476       if (DeadStackObjects.count(Pointer)) {
 477         // DCE instructions only used to calculate that store.
 478         Instruction *Dead = BBI++;
 479         DeleteDeadInstruction(Dead, *MD, &DeadStackObjects);
 480         ++NumFastStores;
 481         MadeChange = true;
 482         continue;
 483       }
 484     }
 485
 486     // Remove any dead non-memory-mutating instructions.
 487     if (isInstructionTriviallyDead(BBI)) {
 488       Instruction *Inst = BBI++;
 489       DeleteDeadInstruction(Inst, *MD, &DeadStackObjects);
 490       ++NumFastOther;
 491       MadeChange = true;
 492       continue;
 493     }
 494
 495     if (AllocaInst *A = dyn_cast<AllocaInst>(BBI)) {
 496       DeadStackObjects.erase(A);
 497       continue;
 498     }
 499
 500     if (CallSite CS = cast<Value>(BBI)) {
 501       // If this call does not access memory, it can't be loading any of our
 502       // pointers.
 503       if (AA->doesNotAccessMemory(CS))
 504         continue;
 505
 506       unsigned NumModRef = 0, NumOther = 0;
 507
 508       // If the call might load from any of our allocas, then any store above
 509       // the call is live.
 510       SmallVector<Value*, 8> LiveAllocas;
 511       for (SmallPtrSet<Value*, 16>::iterator I = DeadStackObjects.begin(),
 512            E = DeadStackObjects.end(); I != E; ++I) {
 513         // If we detect that our AA is imprecise, it's not worth it to scan the
 514         // rest of the DeadPointers set.  Just assume that the AA will return
 515         // ModRef for everything, and go ahead and bail out.
 516         if (NumModRef >= 16 && NumOther == 0)
 517           return MadeChange;
 518
 519         // See if the call site touches it.
 520         AliasAnalysis::ModRefResult A =
 521           AA->getModRefInfo(CS, *I, getPointerSize(*I, *AA));
 522
 523         if (A == AliasAnalysis::ModRef)
 524           ++NumModRef;
 525         else
 526           ++NumOther;
 527
 528         if (A == AliasAnalysis::ModRef || A == AliasAnalysis::Ref)
 529           LiveAllocas.push_back(*I);
 530       }
 531
 532       for (SmallVector<Value*, 8>::iterator I = LiveAllocas.begin(),
 533            E = LiveAllocas.end(); I != E; ++I)
 534         DeadStackObjects.erase(*I);
 535
 536       // If all of the allocas were clobbered by the call then we're not going
 537       // to find anything else to process.
 538       if (DeadStackObjects.empty())
 539         return MadeChange;
 540
 541       continue;
 542     }
 543
 544     AliasAnalysis::Location LoadedLoc;
 545
 546     // If we encounter a use of the pointer, it is no longer considered dead
 547     if (LoadInst *L = dyn_cast<LoadInst>(BBI)) {
 548       LoadedLoc = AA->getLocation(L);
 549     } else if (VAArgInst *V = dyn_cast<VAArgInst>(BBI)) {
 550       LoadedLoc = AA->getLocation(V);
 551     } else if (MemTransferInst *MTI = dyn_cast<MemTransferInst>(BBI)) {
 552       LoadedLoc = AA->getLocationForSource(MTI);
 553     } else {
 554       // Not a loading instruction.
 555       continue;
 556     }
 557
 558     // Remove any allocas from the DeadPointer set that are loaded, as this
 559     // makes any stores above the access live.
 560     RemoveAccessedObjects(LoadedLoc, DeadStackObjects);
 561
 562     // If all of the allocas were clobbered by the access then we're not going
 563     // to find anything else to process.
 564     if (DeadStackObjects.empty())
 565       break;
 566   }
 567
 568   return MadeChange;
 569 }
 570
 571 /// RemoveAccessedObjects - Check to see if the specified location may alias any
 572 /// of the stack objects in the DeadStackObjects set.  If so, they become live
 573 /// because the location is being loaded.
 574 void DSE::RemoveAccessedObjects(const AliasAnalysis::Location &LoadedLoc,
 575                                 SmallPtrSet<Value*, 16> &DeadStackObjects) {
 576   const Value *UnderlyingPointer = LoadedLoc.Ptr->getUnderlyingObject();
 577
 578   // A constant can't be in the dead pointer set.
 579   if (isa<Constant>(UnderlyingPointer))
 580     return;
 581
 582   // If the kill pointer can be easily reduced to an alloca, don't bother doing
 583   // extraneous AA queries.
 584   if (isa<AllocaInst>(UnderlyingPointer) || isa<Argument>(UnderlyingPointer)) {
 585     DeadStackObjects.erase(const_cast<Value*>(UnderlyingPointer));
 586     return;
 587   }
 588
 589   SmallVector<Value*, 16> NowLive;
 590   for (SmallPtrSet<Value*, 16>::iterator I = DeadStackObjects.begin(),
 591        E = DeadStackObjects.end(); I != E; ++I) {
 592     // See if the loaded location could alias the stack location.
 593     AliasAnalysis::Location StackLoc(*I, getPointerSize(*I, *AA));
 594     if (!AA->isNoAlias(StackLoc, LoadedLoc))
 595       NowLive.push_back(*I);
 596   }
 597
 598   for (SmallVector<Value*, 16>::iterator I = NowLive.begin(), E = NowLive.end();
 599        I != E; ++I)
 600     DeadStackObjects.erase(*I);
 601 }
 602