LLVM  4.0.0
DeadStoreElimination.cpp
Go to the documentation of this file.
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 
19 #include "llvm/ADT/DenseMap.h"
20 #include "llvm/ADT/STLExtras.h"
21 #include "llvm/ADT/SetVector.h"
22 #include "llvm/ADT/Statistic.h"
30 #include "llvm/IR/Constants.h"
31 #include "llvm/IR/DataLayout.h"
32 #include "llvm/IR/Dominators.h"
33 #include "llvm/IR/Function.h"
34 #include "llvm/IR/GlobalVariable.h"
35 #include "llvm/IR/Instructions.h"
36 #include "llvm/IR/IntrinsicInst.h"
37 #include "llvm/Pass.h"
39 #include "llvm/Support/Debug.h"
41 #include "llvm/Transforms/Scalar.h"
43 #include <map>
44 using namespace llvm;
45 
46 #define DEBUG_TYPE "dse"
47 
48 STATISTIC(NumRedundantStores, "Number of redundant stores deleted");
49 STATISTIC(NumFastStores, "Number of stores deleted");
50 STATISTIC(NumFastOther , "Number of other instrs removed");
51 STATISTIC(NumCompletePartials, "Number of stores dead by later partials");
52 
53 static cl::opt<bool>
54 EnablePartialOverwriteTracking("enable-dse-partial-overwrite-tracking",
55  cl::init(true), cl::Hidden,
56  cl::desc("Enable partial-overwrite tracking in DSE"));
57 
58 
59 //===----------------------------------------------------------------------===//
60 // Helper functions
61 //===----------------------------------------------------------------------===//
62 typedef std::map<int64_t, int64_t> OverlapIntervalsTy;
64 
65 /// Delete this instruction. Before we do, go through and zero out all the
66 /// operands of this instruction. If any of them become dead, delete them and
67 /// the computation tree that feeds them.
68 /// If ValueSet is non-null, remove any deleted instructions from it as well.
69 static void
73  DenseMap<Instruction*, size_t> *InstrOrdering,
74  SmallSetVector<Value *, 16> *ValueSet = nullptr) {
75  SmallVector<Instruction*, 32> NowDeadInsts;
76 
77  NowDeadInsts.push_back(I);
78  --NumFastOther;
79 
80  // Keeping the iterator straight is a pain, so we let this routine tell the
81  // caller what the next instruction is after we're done mucking about.
82  BasicBlock::iterator NewIter = *BBI;
83 
84  // Before we touch this instruction, remove it from memdep!
85  do {
86  Instruction *DeadInst = NowDeadInsts.pop_back_val();
87  ++NumFastOther;
88 
89  // This instruction is dead, zap it, in stages. Start by removing it from
90  // MemDep, which needs to know the operands and needs it to be in the
91  // function.
92  MD.removeInstruction(DeadInst);
93 
94  for (unsigned op = 0, e = DeadInst->getNumOperands(); op != e; ++op) {
95  Value *Op = DeadInst->getOperand(op);
96  DeadInst->setOperand(op, nullptr);
97 
98  // If this operand just became dead, add it to the NowDeadInsts list.
99  if (!Op->use_empty()) continue;
100 
101  if (Instruction *OpI = dyn_cast<Instruction>(Op))
102  if (isInstructionTriviallyDead(OpI, &TLI))
103  NowDeadInsts.push_back(OpI);
104  }
105 
106  if (ValueSet) ValueSet->remove(DeadInst);
107  InstrOrdering->erase(DeadInst);
108  IOL.erase(DeadInst);
109 
110  if (NewIter == DeadInst->getIterator())
111  NewIter = DeadInst->eraseFromParent();
112  else
113  DeadInst->eraseFromParent();
114  } while (!NowDeadInsts.empty());
115  *BBI = NewIter;
116 }
117 
118 /// Does this instruction write some memory? This only returns true for things
119 /// that we can analyze with other helpers below.
120 static bool hasMemoryWrite(Instruction *I, const TargetLibraryInfo &TLI) {
121  if (isa<StoreInst>(I))
122  return true;
123  if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(I)) {
124  switch (II->getIntrinsicID()) {
125  default:
126  return false;
127  case Intrinsic::memset:
128  case Intrinsic::memmove:
129  case Intrinsic::memcpy:
130  case Intrinsic::init_trampoline:
131  case Intrinsic::lifetime_end:
132  return true;
133  }
134  }
135  if (auto CS = CallSite(I)) {
136  if (Function *F = CS.getCalledFunction()) {
137  StringRef FnName = F->getName();
138  if (TLI.has(LibFunc::strcpy) && FnName == TLI.getName(LibFunc::strcpy))
139  return true;
140  if (TLI.has(LibFunc::strncpy) && FnName == TLI.getName(LibFunc::strncpy))
141  return true;
142  if (TLI.has(LibFunc::strcat) && FnName == TLI.getName(LibFunc::strcat))
143  return true;
144  if (TLI.has(LibFunc::strncat) && FnName == TLI.getName(LibFunc::strncat))
145  return true;
146  }
147  }
148  return false;
149 }
150 
151 /// Return a Location stored to by the specified instruction. If isRemovable
152 /// returns true, this function and getLocForRead completely describe the memory
153 /// operations for this instruction.
155  if (StoreInst *SI = dyn_cast<StoreInst>(Inst))
156  return MemoryLocation::get(SI);
157 
158  if (MemIntrinsic *MI = dyn_cast<MemIntrinsic>(Inst)) {
159  // memcpy/memmove/memset.
161  return Loc;
162  }
163 
164  IntrinsicInst *II = dyn_cast<IntrinsicInst>(Inst);
165  if (!II)
166  return MemoryLocation();
167 
168  switch (II->getIntrinsicID()) {
169  default:
170  return MemoryLocation(); // Unhandled intrinsic.
171  case Intrinsic::init_trampoline:
172  // FIXME: We don't know the size of the trampoline, so we can't really
173  // handle it here.
174  return MemoryLocation(II->getArgOperand(0));
175  case Intrinsic::lifetime_end: {
176  uint64_t Len = cast<ConstantInt>(II->getArgOperand(0))->getZExtValue();
177  return MemoryLocation(II->getArgOperand(1), Len);
178  }
179  }
180 }
181 
182 /// Return the location read by the specified "hasMemoryWrite" instruction if
183 /// any.
185  const TargetLibraryInfo &TLI) {
186  assert(hasMemoryWrite(Inst, TLI) && "Unknown instruction case");
187 
188  // The only instructions that both read and write are the mem transfer
189  // instructions (memcpy/memmove).
190  if (MemTransferInst *MTI = dyn_cast<MemTransferInst>(Inst))
191  return MemoryLocation::getForSource(MTI);
192  return MemoryLocation();
193 }
194 
195 /// If the value of this instruction and the memory it writes to is unused, may
196 /// we delete this instruction?
197 static bool isRemovable(Instruction *I) {
198  // Don't remove volatile/atomic stores.
199  if (StoreInst *SI = dyn_cast<StoreInst>(I))
200  return SI->isUnordered();
201 
202  if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(I)) {
203  switch (II->getIntrinsicID()) {
204  default: llvm_unreachable("doesn't pass 'hasMemoryWrite' predicate");
205  case Intrinsic::lifetime_end:
206  // Never remove dead lifetime_end's, e.g. because it is followed by a
207  // free.
208  return false;
209  case Intrinsic::init_trampoline:
210  // Always safe to remove init_trampoline.
211  return true;
212 
213  case Intrinsic::memset:
214  case Intrinsic::memmove:
215  case Intrinsic::memcpy:
216  // Don't remove volatile memory intrinsics.
217  return !cast<MemIntrinsic>(II)->isVolatile();
218  }
219  }
220 
221  if (auto CS = CallSite(I))
222  return CS.getInstruction()->use_empty();
223 
224  return false;
225 }
226 
227 
228 /// Returns true if the end of this instruction can be safely shortened in
229 /// length.
231  // Don't shorten stores for now
232  if (isa<StoreInst>(I))
233  return false;
234 
235  if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(I)) {
236  switch (II->getIntrinsicID()) {
237  default: return false;
238  case Intrinsic::memset:
239  case Intrinsic::memcpy:
240  // Do shorten memory intrinsics.
241  // FIXME: Add memmove if it's also safe to transform.
242  return true;
243  }
244  }
245 
246  // Don't shorten libcalls calls for now.
247 
248  return false;
249 }
250 
251 /// Returns true if the beginning of this instruction can be safely shortened
252 /// in length.
254  // FIXME: Handle only memset for now. Supporting memcpy/memmove should be
255  // easily done by offsetting the source address.
257  return II && II->getIntrinsicID() == Intrinsic::memset;
258 }
259 
260 /// Return the pointer that is being written to.
262  if (StoreInst *SI = dyn_cast<StoreInst>(I))
263  return SI->getPointerOperand();
264  if (MemIntrinsic *MI = dyn_cast<MemIntrinsic>(I))
265  return MI->getDest();
266 
267  if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(I)) {
268  switch (II->getIntrinsicID()) {
269  default: llvm_unreachable("Unexpected intrinsic!");
270  case Intrinsic::init_trampoline:
271  return II->getArgOperand(0);
272  }
273  }
274 
275  CallSite CS(I);
276  // All the supported functions so far happen to have dest as their first
277  // argument.
278  return CS.getArgument(0);
279 }
280 
281 static uint64_t getPointerSize(const Value *V, const DataLayout &DL,
282  const TargetLibraryInfo &TLI) {
283  uint64_t Size;
284  if (getObjectSize(V, Size, DL, &TLI))
285  return Size;
287 }
288 
289 namespace {
291  OverwriteBegin,
292  OverwriteComplete,
293  OverwriteEnd,
294  OverwriteUnknown
295 };
296 }
297 
298 /// Return 'OverwriteComplete' if a store to the 'Later' location completely
299 /// overwrites a store to the 'Earlier' location, 'OverwriteEnd' if the end of
300 /// the 'Earlier' location is completely overwritten by 'Later',
301 /// 'OverwriteBegin' if the beginning of the 'Earlier' location is overwritten
302 /// by 'Later', or 'OverwriteUnknown' if nothing can be determined.
304  const MemoryLocation &Earlier,
305  const DataLayout &DL,
306  const TargetLibraryInfo &TLI,
307  int64_t &EarlierOff, int64_t &LaterOff,
308  Instruction *DepWrite,
309  InstOverlapIntervalsTy &IOL) {
310  // If we don't know the sizes of either access, then we can't do a comparison.
311  if (Later.Size == MemoryLocation::UnknownSize ||
313  return OverwriteUnknown;
314 
315  const Value *P1 = Earlier.Ptr->stripPointerCasts();
316  const Value *P2 = Later.Ptr->stripPointerCasts();
317 
318  // If the start pointers are the same, we just have to compare sizes to see if
319  // the later store was larger than the earlier store.
320  if (P1 == P2) {
321  // Make sure that the Later size is >= the Earlier size.
322  if (Later.Size >= Earlier.Size)
323  return OverwriteComplete;
324  }
325 
326  // Check to see if the later store is to the entire object (either a global,
327  // an alloca, or a byval/inalloca argument). If so, then it clearly
328  // overwrites any other store to the same object.
329  const Value *UO1 = GetUnderlyingObject(P1, DL),
330  *UO2 = GetUnderlyingObject(P2, DL);
331 
332  // If we can't resolve the same pointers to the same object, then we can't
333  // analyze them at all.
334  if (UO1 != UO2)
335  return OverwriteUnknown;
336 
337  // If the "Later" store is to a recognizable object, get its size.
338  uint64_t ObjectSize = getPointerSize(UO2, DL, TLI);
339  if (ObjectSize != MemoryLocation::UnknownSize)
340  if (ObjectSize == Later.Size && ObjectSize >= Earlier.Size)
341  return OverwriteComplete;
342 
343  // Okay, we have stores to two completely different pointers. Try to
344  // decompose the pointer into a "base + constant_offset" form. If the base
345  // pointers are equal, then we can reason about the two stores.
346  EarlierOff = 0;
347  LaterOff = 0;
348  const Value *BP1 = GetPointerBaseWithConstantOffset(P1, EarlierOff, DL);
349  const Value *BP2 = GetPointerBaseWithConstantOffset(P2, LaterOff, DL);
350 
351  // If the base pointers still differ, we have two completely different stores.
352  if (BP1 != BP2)
353  return OverwriteUnknown;
354 
355  // The later store completely overlaps the earlier store if:
356  //
357  // 1. Both start at the same offset and the later one's size is greater than
358  // or equal to the earlier one's, or
359  //
360  // |--earlier--|
361  // |-- later --|
362  //
363  // 2. The earlier store has an offset greater than the later offset, but which
364  // still lies completely within the later store.
365  //
366  // |--earlier--|
367  // |----- later ------|
368  //
369  // We have to be careful here as *Off is signed while *.Size is unsigned.
370  if (EarlierOff >= LaterOff &&
371  Later.Size >= Earlier.Size &&
372  uint64_t(EarlierOff - LaterOff) + Earlier.Size <= Later.Size)
373  return OverwriteComplete;
374 
375  // We may now overlap, although the overlap is not complete. There might also
376  // be other incomplete overlaps, and together, they might cover the complete
377  // earlier write.
378  // Note: The correctness of this logic depends on the fact that this function
379  // is not even called providing DepWrite when there are any intervening reads.
381  LaterOff < int64_t(EarlierOff + Earlier.Size) &&
382  int64_t(LaterOff + Later.Size) >= EarlierOff) {
383 
384  // Insert our part of the overlap into the map.
385  auto &IM = IOL[DepWrite];
386  DEBUG(dbgs() << "DSE: Partial overwrite: Earlier [" << EarlierOff << ", " <<
387  int64_t(EarlierOff + Earlier.Size) << ") Later [" <<
388  LaterOff << ", " << int64_t(LaterOff + Later.Size) << ")\n");
389 
390  // Make sure that we only insert non-overlapping intervals and combine
391  // adjacent intervals. The intervals are stored in the map with the ending
392  // offset as the key (in the half-open sense) and the starting offset as
393  // the value.
394  int64_t LaterIntStart = LaterOff, LaterIntEnd = LaterOff + Later.Size;
395 
396  // Find any intervals ending at, or after, LaterIntStart which start
397  // before LaterIntEnd.
398  auto ILI = IM.lower_bound(LaterIntStart);
399  if (ILI != IM.end() && ILI->second <= LaterIntEnd) {
400  // This existing interval is overlapped with the current store somewhere
401  // in [LaterIntStart, LaterIntEnd]. Merge them by erasing the existing
402  // intervals and adjusting our start and end.
403  LaterIntStart = std::min(LaterIntStart, ILI->second);
404  LaterIntEnd = std::max(LaterIntEnd, ILI->first);
405  ILI = IM.erase(ILI);
406 
407  // Continue erasing and adjusting our end in case other previous
408  // intervals are also overlapped with the current store.
409  //
410  // |--- ealier 1 ---| |--- ealier 2 ---|
411  // |------- later---------|
412  //
413  while (ILI != IM.end() && ILI->second <= LaterIntEnd) {
414  assert(ILI->second > LaterIntStart && "Unexpected interval");
415  LaterIntEnd = std::max(LaterIntEnd, ILI->first);
416  ILI = IM.erase(ILI);
417  }
418  }
419 
420  IM[LaterIntEnd] = LaterIntStart;
421 
422  ILI = IM.begin();
423  if (ILI->second <= EarlierOff &&
424  ILI->first >= int64_t(EarlierOff + Earlier.Size)) {
425  DEBUG(dbgs() << "DSE: Full overwrite from partials: Earlier [" <<
426  EarlierOff << ", " <<
427  int64_t(EarlierOff + Earlier.Size) <<
428  ") Composite Later [" <<
429  ILI->second << ", " << ILI->first << ")\n");
430  ++NumCompletePartials;
431  return OverwriteComplete;
432  }
433  }
434 
435  // Another interesting case is if the later store overwrites the end of the
436  // earlier store.
437  //
438  // |--earlier--|
439  // |-- later --|
440  //
441  // In this case we may want to trim the size of earlier to avoid generating
442  // writes to addresses which will definitely be overwritten later
444  (LaterOff > EarlierOff && LaterOff < int64_t(EarlierOff + Earlier.Size) &&
445  int64_t(LaterOff + Later.Size) >= int64_t(EarlierOff + Earlier.Size)))
446  return OverwriteEnd;
447 
448  // Finally, we also need to check if the later store overwrites the beginning
449  // of the earlier store.
450  //
451  // |--earlier--|
452  // |-- later --|
453  //
454  // In this case we may want to move the destination address and trim the size
455  // of earlier to avoid generating writes to addresses which will definitely
456  // be overwritten later.
458  (LaterOff <= EarlierOff && int64_t(LaterOff + Later.Size) > EarlierOff)) {
459  assert(int64_t(LaterOff + Later.Size) <
460  int64_t(EarlierOff + Earlier.Size) &&
461  "Expect to be handled as OverwriteComplete");
462  return OverwriteBegin;
463  }
464  // Otherwise, they don't completely overlap.
465  return OverwriteUnknown;
466 }
467 
468 /// If 'Inst' might be a self read (i.e. a noop copy of a
469 /// memory region into an identical pointer) then it doesn't actually make its
470 /// input dead in the traditional sense. Consider this case:
471 ///
472 /// memcpy(A <- B)
473 /// memcpy(A <- A)
474 ///
475 /// In this case, the second store to A does not make the first store to A dead.
476 /// The usual situation isn't an explicit A<-A store like this (which can be
477 /// trivially removed) but a case where two pointers may alias.
478 ///
479 /// This function detects when it is unsafe to remove a dependent instruction
480 /// because the DSE inducing instruction may be a self-read.
481 static bool isPossibleSelfRead(Instruction *Inst,
482  const MemoryLocation &InstStoreLoc,
483  Instruction *DepWrite,
484  const TargetLibraryInfo &TLI,
485  AliasAnalysis &AA) {
486  // Self reads can only happen for instructions that read memory. Get the
487  // location read.
488  MemoryLocation InstReadLoc = getLocForRead(Inst, TLI);
489  if (!InstReadLoc.Ptr) return false; // Not a reading instruction.
490 
491  // If the read and written loc obviously don't alias, it isn't a read.
492  if (AA.isNoAlias(InstReadLoc, InstStoreLoc)) return false;
493 
494  // Okay, 'Inst' may copy over itself. However, we can still remove a the
495  // DepWrite instruction if we can prove that it reads from the same location
496  // as Inst. This handles useful cases like:
497  // memcpy(A <- B)
498  // memcpy(A <- B)
499  // Here we don't know if A/B may alias, but we do know that B/B are must
500  // aliases, so removing the first memcpy is safe (assuming it writes <= #
501  // bytes as the second one.
502  MemoryLocation DepReadLoc = getLocForRead(DepWrite, TLI);
503 
504  if (DepReadLoc.Ptr && AA.isMustAlias(InstReadLoc.Ptr, DepReadLoc.Ptr))
505  return false;
506 
507  // If DepWrite doesn't read memory or if we can't prove it is a must alias,
508  // then it can't be considered dead.
509  return true;
510 }
511 
512 /// Returns true if the memory which is accessed by the second instruction is not
513 /// modified between the first and the second instruction.
514 /// Precondition: Second instruction must be dominated by the first
515 /// instruction.
517  Instruction *SecondI,
518  AliasAnalysis *AA) {
521  BasicBlock::iterator FirstBBI(FirstI);
522  ++FirstBBI;
523  BasicBlock::iterator SecondBBI(SecondI);
524  BasicBlock *FirstBB = FirstI->getParent();
525  BasicBlock *SecondBB = SecondI->getParent();
526  MemoryLocation MemLoc = MemoryLocation::get(SecondI);
527 
528  // Start checking the store-block.
529  WorkList.push_back(SecondBB);
530  bool isFirstBlock = true;
531 
532  // Check all blocks going backward until we reach the load-block.
533  while (!WorkList.empty()) {
534  BasicBlock *B = WorkList.pop_back_val();
535 
536  // Ignore instructions before LI if this is the FirstBB.
537  BasicBlock::iterator BI = (B == FirstBB ? FirstBBI : B->begin());
538 
540  if (isFirstBlock) {
541  // Ignore instructions after SI if this is the first visit of SecondBB.
542  assert(B == SecondBB && "first block is not the store block");
543  EI = SecondBBI;
544  isFirstBlock = false;
545  } else {
546  // It's not SecondBB or (in case of a loop) the second visit of SecondBB.
547  // In this case we also have to look at instructions after SI.
548  EI = B->end();
549  }
550  for (; BI != EI; ++BI) {
551  Instruction *I = &*BI;
552  if (I->mayWriteToMemory() && I != SecondI) {
553  auto Res = AA->getModRefInfo(I, MemLoc);
554  if (Res != MRI_NoModRef)
555  return false;
556  }
557  }
558  if (B != FirstBB) {
559  assert(B != &FirstBB->getParent()->getEntryBlock() &&
560  "Should not hit the entry block because SI must be dominated by LI");
561  for (auto PredI = pred_begin(B), PE = pred_end(B); PredI != PE; ++PredI) {
562  if (!Visited.insert(*PredI).second)
563  continue;
564  WorkList.push_back(*PredI);
565  }
566  }
567  }
568  return true;
569 }
570 
571 /// Find all blocks that will unconditionally lead to the block BB and append
572 /// them to F.
574  BasicBlock *BB, DominatorTree *DT) {
575  for (pred_iterator I = pred_begin(BB), E = pred_end(BB); I != E; ++I) {
576  BasicBlock *Pred = *I;
577  if (Pred == BB) continue;
578  TerminatorInst *PredTI = Pred->getTerminator();
579  if (PredTI->getNumSuccessors() != 1)
580  continue;
581 
582  if (DT->isReachableFromEntry(Pred))
583  Blocks.push_back(Pred);
584  }
585 }
586 
587 /// Handle frees of entire structures whose dependency is a store
588 /// to a field of that structure.
589 static bool handleFree(CallInst *F, AliasAnalysis *AA,
591  const TargetLibraryInfo *TLI,
593  DenseMap<Instruction*, size_t> *InstrOrdering) {
594  bool MadeChange = false;
595 
598  Blocks.push_back(F->getParent());
599  const DataLayout &DL = F->getModule()->getDataLayout();
600 
601  while (!Blocks.empty()) {
602  BasicBlock *BB = Blocks.pop_back_val();
603  Instruction *InstPt = BB->getTerminator();
604  if (BB == F->getParent()) InstPt = F;
605 
606  MemDepResult Dep =
607  MD->getPointerDependencyFrom(Loc, false, InstPt->getIterator(), BB);
608  while (Dep.isDef() || Dep.isClobber()) {
609  Instruction *Dependency = Dep.getInst();
610  if (!hasMemoryWrite(Dependency, *TLI) || !isRemovable(Dependency))
611  break;
612 
613  Value *DepPointer =
615 
616  // Check for aliasing.
617  if (!AA->isMustAlias(F->getArgOperand(0), DepPointer))
618  break;
619 
620  DEBUG(dbgs() << "DSE: Dead Store to soon to be freed memory:\n DEAD: "
621  << *Dependency << '\n');
622 
623  // DCE instructions only used to calculate that store.
624  BasicBlock::iterator BBI(Dependency);
625  deleteDeadInstruction(Dependency, &BBI, *MD, *TLI, IOL, InstrOrdering);
626  ++NumFastStores;
627  MadeChange = true;
628 
629  // Inst's old Dependency is now deleted. Compute the next dependency,
630  // which may also be dead, as in
631  // s[0] = 0;
632  // s[1] = 0; // This has just been deleted.
633  // free(s);
634  Dep = MD->getPointerDependencyFrom(Loc, false, BBI, BB);
635  }
636 
637  if (Dep.isNonLocal())
638  findUnconditionalPreds(Blocks, BB, DT);
639  }
640 
641  return MadeChange;
642 }
643 
644 /// Check to see if the specified location may alias any of the stack objects in
645 /// the DeadStackObjects set. If so, they become live because the location is
646 /// being loaded.
647 static void removeAccessedObjects(const MemoryLocation &LoadedLoc,
648  SmallSetVector<Value *, 16> &DeadStackObjects,
649  const DataLayout &DL, AliasAnalysis *AA,
650  const TargetLibraryInfo *TLI) {
651  const Value *UnderlyingPointer = GetUnderlyingObject(LoadedLoc.Ptr, DL);
652 
653  // A constant can't be in the dead pointer set.
654  if (isa<Constant>(UnderlyingPointer))
655  return;
656 
657  // If the kill pointer can be easily reduced to an alloca, don't bother doing
658  // extraneous AA queries.
659  if (isa<AllocaInst>(UnderlyingPointer) || isa<Argument>(UnderlyingPointer)) {
660  DeadStackObjects.remove(const_cast<Value*>(UnderlyingPointer));
661  return;
662  }
663 
664  // Remove objects that could alias LoadedLoc.
665  DeadStackObjects.remove_if([&](Value *I) {
666  // See if the loaded location could alias the stack location.
667  MemoryLocation StackLoc(I, getPointerSize(I, DL, *TLI));
668  return !AA->isNoAlias(StackLoc, LoadedLoc);
669  });
670 }
671 
672 /// Remove dead stores to stack-allocated locations in the function end block.
673 /// Ex:
674 /// %A = alloca i32
675 /// ...
676 /// store i32 1, i32* %A
677 /// ret void
680  const TargetLibraryInfo *TLI,
682  DenseMap<Instruction*, size_t> *InstrOrdering) {
683  bool MadeChange = false;
684 
685  // Keep track of all of the stack objects that are dead at the end of the
686  // function.
687  SmallSetVector<Value*, 16> DeadStackObjects;
688 
689  // Find all of the alloca'd pointers in the entry block.
690  BasicBlock &Entry = BB.getParent()->front();
691  for (Instruction &I : Entry) {
692  if (isa<AllocaInst>(&I))
693  DeadStackObjects.insert(&I);
694 
695  // Okay, so these are dead heap objects, but if the pointer never escapes
696  // then it's leaked by this function anyways.
697  else if (isAllocLikeFn(&I, TLI) && !PointerMayBeCaptured(&I, true, true))
698  DeadStackObjects.insert(&I);
699  }
700 
701  // Treat byval or inalloca arguments the same, stores to them are dead at the
702  // end of the function.
703  for (Argument &AI : BB.getParent()->args())
704  if (AI.hasByValOrInAllocaAttr())
705  DeadStackObjects.insert(&AI);
706 
707  const DataLayout &DL = BB.getModule()->getDataLayout();
708 
709  // Scan the basic block backwards
710  for (BasicBlock::iterator BBI = BB.end(); BBI != BB.begin(); ){
711  --BBI;
712 
713  // If we find a store, check to see if it points into a dead stack value.
714  if (hasMemoryWrite(&*BBI, *TLI) && isRemovable(&*BBI)) {
715  // See through pointer-to-pointer bitcasts
716  SmallVector<Value *, 4> Pointers;
717  GetUnderlyingObjects(getStoredPointerOperand(&*BBI), Pointers, DL);
718 
719  // Stores to stack values are valid candidates for removal.
720  bool AllDead = true;
721  for (Value *Pointer : Pointers)
722  if (!DeadStackObjects.count(Pointer)) {
723  AllDead = false;
724  break;
725  }
726 
727  if (AllDead) {
728  Instruction *Dead = &*BBI;
729 
730  DEBUG(dbgs() << "DSE: Dead Store at End of Block:\n DEAD: "
731  << *Dead << "\n Objects: ";
732  for (SmallVectorImpl<Value *>::iterator I = Pointers.begin(),
733  E = Pointers.end(); I != E; ++I) {
734  dbgs() << **I;
735  if (std::next(I) != E)
736  dbgs() << ", ";
737  }
738  dbgs() << '\n');
739 
740  // DCE instructions only used to calculate that store.
741  deleteDeadInstruction(Dead, &BBI, *MD, *TLI, IOL, InstrOrdering, &DeadStackObjects);
742  ++NumFastStores;
743  MadeChange = true;
744  continue;
745  }
746  }
747 
748  // Remove any dead non-memory-mutating instructions.
749  if (isInstructionTriviallyDead(&*BBI, TLI)) {
750  DEBUG(dbgs() << "DSE: Removing trivially dead instruction:\n DEAD: "
751  << *&*BBI << '\n');
752  deleteDeadInstruction(&*BBI, &BBI, *MD, *TLI, IOL, InstrOrdering, &DeadStackObjects);
753  ++NumFastOther;
754  MadeChange = true;
755  continue;
756  }
757 
758  if (isa<AllocaInst>(BBI)) {
759  // Remove allocas from the list of dead stack objects; there can't be
760  // any references before the definition.
761  DeadStackObjects.remove(&*BBI);
762  continue;
763  }
764 
765  if (auto CS = CallSite(&*BBI)) {
766  // Remove allocation function calls from the list of dead stack objects;
767  // there can't be any references before the definition.
768  if (isAllocLikeFn(&*BBI, TLI))
769  DeadStackObjects.remove(&*BBI);
770 
771  // If this call does not access memory, it can't be loading any of our
772  // pointers.
773  if (AA->doesNotAccessMemory(CS))
774  continue;
775 
776  // If the call might load from any of our allocas, then any store above
777  // the call is live.
778  DeadStackObjects.remove_if([&](Value *I) {
779  // See if the call site touches the value.
780  ModRefInfo A = AA->getModRefInfo(CS, I, getPointerSize(I, DL, *TLI));
781 
782  return A == MRI_ModRef || A == MRI_Ref;
783  });
784 
785  // If all of the allocas were clobbered by the call then we're not going
786  // to find anything else to process.
787  if (DeadStackObjects.empty())
788  break;
789 
790  continue;
791  }
792 
793  // We can remove the dead stores, irrespective of the fence and its ordering
794  // (release/acquire/seq_cst). Fences only constraints the ordering of
795  // already visible stores, it does not make a store visible to other
796  // threads. So, skipping over a fence does not change a store from being
797  // dead.
798  if (isa<FenceInst>(*BBI))
799  continue;
800 
801  MemoryLocation LoadedLoc;
802 
803  // If we encounter a use of the pointer, it is no longer considered dead
804  if (LoadInst *L = dyn_cast<LoadInst>(BBI)) {
805  if (!L->isUnordered()) // Be conservative with atomic/volatile load
806  break;
807  LoadedLoc = MemoryLocation::get(L);
808  } else if (VAArgInst *V = dyn_cast<VAArgInst>(BBI)) {
809  LoadedLoc = MemoryLocation::get(V);
810  } else if (MemTransferInst *MTI = dyn_cast<MemTransferInst>(BBI)) {
811  LoadedLoc = MemoryLocation::getForSource(MTI);
812  } else if (!BBI->mayReadFromMemory()) {
813  // Instruction doesn't read memory. Note that stores that weren't removed
814  // above will hit this case.
815  continue;
816  } else {
817  // Unknown inst; assume it clobbers everything.
818  break;
819  }
820 
821  // Remove any allocas from the DeadPointer set that are loaded, as this
822  // makes any stores above the access live.
823  removeAccessedObjects(LoadedLoc, DeadStackObjects, DL, AA, TLI);
824 
825  // If all of the allocas were clobbered by the access then we're not going
826  // to find anything else to process.
827  if (DeadStackObjects.empty())
828  break;
829  }
830 
831  return MadeChange;
832 }
833 
834 static bool tryToShorten(Instruction *EarlierWrite, int64_t &EarlierOffset,
835  int64_t &EarlierSize, int64_t LaterOffset,
836  int64_t LaterSize, bool IsOverwriteEnd) {
837  // TODO: base this on the target vector size so that if the earlier
838  // store was too small to get vector writes anyway then its likely
839  // a good idea to shorten it
840  // Power of 2 vector writes are probably always a bad idea to optimize
841  // as any store/memset/memcpy is likely using vector instructions so
842  // shortening it to not vector size is likely to be slower
843  MemIntrinsic *EarlierIntrinsic = cast<MemIntrinsic>(EarlierWrite);
844  unsigned EarlierWriteAlign = EarlierIntrinsic->getAlignment();
845  if (!IsOverwriteEnd)
846  LaterOffset = int64_t(LaterOffset + LaterSize);
847 
848  if (!(llvm::isPowerOf2_64(LaterOffset) && EarlierWriteAlign <= LaterOffset) &&
849  !((EarlierWriteAlign != 0) && LaterOffset % EarlierWriteAlign == 0))
850  return false;
851 
852  DEBUG(dbgs() << "DSE: Remove Dead Store:\n OW "
853  << (IsOverwriteEnd ? "END" : "BEGIN") << ": " << *EarlierWrite
854  << "\n KILLER (offset " << LaterOffset << ", " << EarlierSize
855  << ")\n");
856 
857  int64_t NewLength = IsOverwriteEnd
858  ? LaterOffset - EarlierOffset
859  : EarlierSize - (LaterOffset - EarlierOffset);
860 
861  Value *EarlierWriteLength = EarlierIntrinsic->getLength();
862  Value *TrimmedLength =
863  ConstantInt::get(EarlierWriteLength->getType(), NewLength);
864  EarlierIntrinsic->setLength(TrimmedLength);
865 
866  EarlierSize = NewLength;
867  if (!IsOverwriteEnd) {
868  int64_t OffsetMoved = (LaterOffset - EarlierOffset);
869  Value *Indices[1] = {
870  ConstantInt::get(EarlierWriteLength->getType(), OffsetMoved)};
872  EarlierIntrinsic->getRawDest(), Indices, "", EarlierWrite);
873  EarlierIntrinsic->setDest(NewDestGEP);
874  EarlierOffset = EarlierOffset + OffsetMoved;
875  }
876  return true;
877 }
878 
879 static bool tryToShortenEnd(Instruction *EarlierWrite,
881  int64_t &EarlierStart, int64_t &EarlierSize) {
882  if (IntervalMap.empty() || !isShortenableAtTheEnd(EarlierWrite))
883  return false;
884 
885  OverlapIntervalsTy::iterator OII = --IntervalMap.end();
886  int64_t LaterStart = OII->second;
887  int64_t LaterSize = OII->first - LaterStart;
888 
889  if (LaterStart > EarlierStart && LaterStart < EarlierStart + EarlierSize &&
890  LaterStart + LaterSize >= EarlierStart + EarlierSize) {
891  if (tryToShorten(EarlierWrite, EarlierStart, EarlierSize, LaterStart,
892  LaterSize, true)) {
893  IntervalMap.erase(OII);
894  return true;
895  }
896  }
897  return false;
898 }
899 
900 static bool tryToShortenBegin(Instruction *EarlierWrite,
902  int64_t &EarlierStart, int64_t &EarlierSize) {
903  if (IntervalMap.empty() || !isShortenableAtTheBeginning(EarlierWrite))
904  return false;
905 
906  OverlapIntervalsTy::iterator OII = IntervalMap.begin();
907  int64_t LaterStart = OII->second;
908  int64_t LaterSize = OII->first - LaterStart;
909 
910  if (LaterStart <= EarlierStart && LaterStart + LaterSize > EarlierStart) {
911  assert(LaterStart + LaterSize < EarlierStart + EarlierSize &&
912  "Should have been handled as OverwriteComplete");
913  if (tryToShorten(EarlierWrite, EarlierStart, EarlierSize, LaterStart,
914  LaterSize, false)) {
915  IntervalMap.erase(OII);
916  return true;
917  }
918  }
919  return false;
920 }
921 
923  const DataLayout &DL,
924  InstOverlapIntervalsTy &IOL) {
925  bool Changed = false;
926  for (auto OI : IOL) {
927  Instruction *EarlierWrite = OI.first;
928  MemoryLocation Loc = getLocForWrite(EarlierWrite, *AA);
929  assert(isRemovable(EarlierWrite) && "Expect only removable instruction");
930  assert(Loc.Size != MemoryLocation::UnknownSize && "Unexpected mem loc");
931 
932  const Value *Ptr = Loc.Ptr->stripPointerCasts();
933  int64_t EarlierStart = 0;
934  int64_t EarlierSize = int64_t(Loc.Size);
935  GetPointerBaseWithConstantOffset(Ptr, EarlierStart, DL);
936  OverlapIntervalsTy &IntervalMap = OI.second;
937  Changed |=
938  tryToShortenEnd(EarlierWrite, IntervalMap, EarlierStart, EarlierSize);
939  if (IntervalMap.empty())
940  continue;
941  Changed |=
942  tryToShortenBegin(EarlierWrite, IntervalMap, EarlierStart, EarlierSize);
943  }
944  return Changed;
945 }
946 
949  const DataLayout &DL,
950  const TargetLibraryInfo *TLI,
952  DenseMap<Instruction*, size_t> *InstrOrdering) {
953  // Must be a store instruction.
954  StoreInst *SI = dyn_cast<StoreInst>(Inst);
955  if (!SI)
956  return false;
957 
958  // If we're storing the same value back to a pointer that we just loaded from,
959  // then the store can be removed.
960  if (LoadInst *DepLoad = dyn_cast<LoadInst>(SI->getValueOperand())) {
961  if (SI->getPointerOperand() == DepLoad->getPointerOperand() &&
962  isRemovable(SI) && memoryIsNotModifiedBetween(DepLoad, SI, AA)) {
963 
964  DEBUG(dbgs() << "DSE: Remove Store Of Load from same pointer:\n LOAD: "
965  << *DepLoad << "\n STORE: " << *SI << '\n');
966 
967  deleteDeadInstruction(SI, &BBI, *MD, *TLI, IOL, InstrOrdering);
968  ++NumRedundantStores;
969  return true;
970  }
971  }
972 
973  // Remove null stores into the calloc'ed objects
974  Constant *StoredConstant = dyn_cast<Constant>(SI->getValueOperand());
975  if (StoredConstant && StoredConstant->isNullValue() && isRemovable(SI)) {
976  Instruction *UnderlyingPointer =
978 
979  if (UnderlyingPointer && isCallocLikeFn(UnderlyingPointer, TLI) &&
980  memoryIsNotModifiedBetween(UnderlyingPointer, SI, AA)) {
981  DEBUG(
982  dbgs() << "DSE: Remove null store to the calloc'ed object:\n DEAD: "
983  << *Inst << "\n OBJECT: " << *UnderlyingPointer << '\n');
984 
985  deleteDeadInstruction(SI, &BBI, *MD, *TLI, IOL, InstrOrdering);
986  ++NumRedundantStores;
987  return true;
988  }
989  }
990  return false;
991 }
992 
995  const TargetLibraryInfo *TLI) {
996  const DataLayout &DL = BB.getModule()->getDataLayout();
997  bool MadeChange = false;
998 
999  // FIXME: Maybe change this to use some abstraction like OrderedBasicBlock?
1000  // The current OrderedBasicBlock can't deal with mutation at the moment.
1001  size_t LastThrowingInstIndex = 0;
1002  DenseMap<Instruction*, size_t> InstrOrdering;
1003  size_t InstrIndex = 1;
1004 
1005  // A map of interval maps representing partially-overwritten value parts.
1007 
1008  // Do a top-down walk on the BB.
1009  for (BasicBlock::iterator BBI = BB.begin(), BBE = BB.end(); BBI != BBE; ) {
1010  // Handle 'free' calls specially.
1011  if (CallInst *F = isFreeCall(&*BBI, TLI)) {
1012  MadeChange |= handleFree(F, AA, MD, DT, TLI, IOL, &InstrOrdering);
1013  // Increment BBI after handleFree has potentially deleted instructions.
1014  // This ensures we maintain a valid iterator.
1015  ++BBI;
1016  continue;
1017  }
1018 
1019  Instruction *Inst = &*BBI++;
1020 
1021  size_t CurInstNumber = InstrIndex++;
1022  InstrOrdering.insert(std::make_pair(Inst, CurInstNumber));
1023  if (Inst->mayThrow()) {
1024  LastThrowingInstIndex = CurInstNumber;
1025  continue;
1026  }
1027 
1028  // Check to see if Inst writes to memory. If not, continue.
1029  if (!hasMemoryWrite(Inst, *TLI))
1030  continue;
1031 
1032  // eliminateNoopStore will update in iterator, if necessary.
1033  if (eliminateNoopStore(Inst, BBI, AA, MD, DL, TLI, IOL, &InstrOrdering)) {
1034  MadeChange = true;
1035  continue;
1036  }
1037 
1038  // If we find something that writes memory, get its memory dependence.
1039  MemDepResult InstDep = MD->getDependency(Inst);
1040 
1041  // Ignore any store where we can't find a local dependence.
1042  // FIXME: cross-block DSE would be fun. :)
1043  if (!InstDep.isDef() && !InstDep.isClobber())
1044  continue;
1045 
1046  // Figure out what location is being stored to.
1047  MemoryLocation Loc = getLocForWrite(Inst, *AA);
1048 
1049  // If we didn't get a useful location, fail.
1050  if (!Loc.Ptr)
1051  continue;
1052 
1053  // Loop until we find a store we can eliminate or a load that
1054  // invalidates the analysis. Without an upper bound on the number of
1055  // instructions examined, this analysis can become very time-consuming.
1056  // However, the potential gain diminishes as we process more instructions
1057  // without eliminating any of them. Therefore, we limit the number of
1058  // instructions we look at.
1059  auto Limit = MD->getDefaultBlockScanLimit();
1060  while (InstDep.isDef() || InstDep.isClobber()) {
1061  // Get the memory clobbered by the instruction we depend on. MemDep will
1062  // skip any instructions that 'Loc' clearly doesn't interact with. If we
1063  // end up depending on a may- or must-aliased load, then we can't optimize
1064  // away the store and we bail out. However, if we depend on something
1065  // that overwrites the memory location we *can* potentially optimize it.
1066  //
1067  // Find out what memory location the dependent instruction stores.
1068  Instruction *DepWrite = InstDep.getInst();
1069  MemoryLocation DepLoc = getLocForWrite(DepWrite, *AA);
1070  // If we didn't get a useful location, or if it isn't a size, bail out.
1071  if (!DepLoc.Ptr)
1072  break;
1073 
1074  // Make sure we don't look past a call which might throw. This is an
1075  // issue because MemoryDependenceAnalysis works in the wrong direction:
1076  // it finds instructions which dominate the current instruction, rather than
1077  // instructions which are post-dominated by the current instruction.
1078  //
1079  // If the underlying object is a non-escaping memory allocation, any store
1080  // to it is dead along the unwind edge. Otherwise, we need to preserve
1081  // the store.
1082  size_t DepIndex = InstrOrdering.lookup(DepWrite);
1083  assert(DepIndex && "Unexpected instruction");
1084  if (DepIndex <= LastThrowingInstIndex) {
1085  const Value* Underlying = GetUnderlyingObject(DepLoc.Ptr, DL);
1086  bool IsStoreDeadOnUnwind = isa<AllocaInst>(Underlying);
1087  if (!IsStoreDeadOnUnwind) {
1088  // We're looking for a call to an allocation function
1089  // where the allocation doesn't escape before the last
1090  // throwing instruction; PointerMayBeCaptured
1091  // reasonably fast approximation.
1092  IsStoreDeadOnUnwind = isAllocLikeFn(Underlying, TLI) &&
1093  !PointerMayBeCaptured(Underlying, false, true);
1094  }
1095  if (!IsStoreDeadOnUnwind)
1096  break;
1097  }
1098 
1099  // If we find a write that is a) removable (i.e., non-volatile), b) is
1100  // completely obliterated by the store to 'Loc', and c) which we know that
1101  // 'Inst' doesn't load from, then we can remove it.
1102  if (isRemovable(DepWrite) &&
1103  !isPossibleSelfRead(Inst, Loc, DepWrite, *TLI, *AA)) {
1104  int64_t InstWriteOffset, DepWriteOffset;
1106  isOverwrite(Loc, DepLoc, DL, *TLI, DepWriteOffset, InstWriteOffset,
1107  DepWrite, IOL);
1108  if (OR == OverwriteComplete) {
1109  DEBUG(dbgs() << "DSE: Remove Dead Store:\n DEAD: "
1110  << *DepWrite << "\n KILLER: " << *Inst << '\n');
1111 
1112  // Delete the store and now-dead instructions that feed it.
1113  deleteDeadInstruction(DepWrite, &BBI, *MD, *TLI, IOL, &InstrOrdering);
1114  ++NumFastStores;
1115  MadeChange = true;
1116 
1117  // We erased DepWrite; start over.
1118  InstDep = MD->getDependency(Inst);
1119  continue;
1120  } else if ((OR == OverwriteEnd && isShortenableAtTheEnd(DepWrite)) ||
1121  ((OR == OverwriteBegin &&
1122  isShortenableAtTheBeginning(DepWrite)))) {
1123  assert(!EnablePartialOverwriteTracking && "Do not expect to perform "
1124  "when partial-overwrite "
1125  "tracking is enabled");
1126  int64_t EarlierSize = DepLoc.Size;
1127  int64_t LaterSize = Loc.Size;
1128  bool IsOverwriteEnd = (OR == OverwriteEnd);
1129  MadeChange |= tryToShorten(DepWrite, DepWriteOffset, EarlierSize,
1130  InstWriteOffset, LaterSize, IsOverwriteEnd);
1131  }
1132  }
1133 
1134  // If this is a may-aliased store that is clobbering the store value, we
1135  // can keep searching past it for another must-aliased pointer that stores
1136  // to the same location. For example, in:
1137  // store -> P
1138  // store -> Q
1139  // store -> P
1140  // we can remove the first store to P even though we don't know if P and Q
1141  // alias.
1142  if (DepWrite == &BB.front()) break;
1143 
1144  // Can't look past this instruction if it might read 'Loc'.
1145  if (AA->getModRefInfo(DepWrite, Loc) & MRI_Ref)
1146  break;
1147 
1148  InstDep = MD->getPointerDependencyFrom(Loc, /*isLoad=*/ false,
1149  DepWrite->getIterator(), &BB,
1150  /*QueryInst=*/ nullptr, &Limit);
1151  }
1152  }
1153 
1155  MadeChange |= removePartiallyOverlappedStores(AA, DL, IOL);
1156 
1157  // If this block ends in a return, unwind, or unreachable, all allocas are
1158  // dead at its end, which means stores to them are also dead.
1159  if (BB.getTerminator()->getNumSuccessors() == 0)
1160  MadeChange |= handleEndBlock(BB, AA, MD, TLI, IOL, &InstrOrdering);
1161 
1162  return MadeChange;
1163 }
1164 
1167  const TargetLibraryInfo *TLI) {
1168  bool MadeChange = false;
1169  for (BasicBlock &BB : F)
1170  // Only check non-dead blocks. Dead blocks may have strange pointer
1171  // cycles that will confuse alias analysis.
1172  if (DT->isReachableFromEntry(&BB))
1173  MadeChange |= eliminateDeadStores(BB, AA, MD, DT, TLI);
1174 
1175  return MadeChange;
1176 }
1177 
1178 //===----------------------------------------------------------------------===//
1179 // DSE Pass
1180 //===----------------------------------------------------------------------===//
1182  AliasAnalysis *AA = &AM.getResult<AAManager>(F);
1186 
1187  if (!eliminateDeadStores(F, AA, MD, DT, TLI))
1188  return PreservedAnalyses::all();
1189  PreservedAnalyses PA;
1191  PA.preserve<GlobalsAA>();
1193  return PA;
1194 }
1195 
1196 namespace {
1197 /// A legacy pass for the legacy pass manager that wraps \c DSEPass.
1198 class DSELegacyPass : public FunctionPass {
1199 public:
1200  DSELegacyPass() : FunctionPass(ID) {
1202  }
1203 
1204  bool runOnFunction(Function &F) override {
1205  if (skipFunction(F))
1206  return false;
1207 
1208  DominatorTree *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
1209  AliasAnalysis *AA = &getAnalysis<AAResultsWrapperPass>().getAAResults();
1211  &getAnalysis<MemoryDependenceWrapperPass>().getMemDep();
1212  const TargetLibraryInfo *TLI =
1213  &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI();
1214 
1215  return eliminateDeadStores(F, AA, MD, DT, TLI);
1216  }
1217 
1218  void getAnalysisUsage(AnalysisUsage &AU) const override {
1219  AU.setPreservesCFG();
1227  }
1228 
1229  static char ID; // Pass identification, replacement for typeid
1230 };
1231 } // end anonymous namespace
1232 
1233 char DSELegacyPass::ID = 0;
1234 INITIALIZE_PASS_BEGIN(DSELegacyPass, "dse", "Dead Store Elimination", false,
1235  false)
1242  false)
1243 
1245  return new DSELegacyPass();
1246 }
unsigned getAlignment() const
Legacy wrapper pass to provide the GlobalsAAResult object.
MachineLoop * L
Value * getValueOperand()
Definition: Instructions.h:391
SymbolTableList< Instruction >::iterator eraseFromParent()
This method unlinks 'this' from the containing basic block and deletes it.
Definition: Instruction.cpp:76
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:102
AnalysisUsage & addPreserved()
Add the specified Pass class to the set of analyses preserved by this pass.
Provides a lazy, caching interface for making common memory aliasing information queries, backed by LLVM's alias analysis passes.
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
static MemoryLocation getLocForWrite(Instruction *Inst, AliasAnalysis &AA)
Return a Location stored to by the specified instruction.
LLVM Argument representation.
Definition: Argument.h:34
bool isDef() const
Tests if this MemDepResult represents a query that is an instruction definition dependency.
STATISTIC(NumFunctions,"Total number of functions")
ValueT lookup(const KeyT &Val) const
lookup - Return the entry for the specified key, or a default constructed value if no such entry exis...
Definition: DenseMap.h:162
This is the interface for a simple mod/ref and alias analysis over globals.
std::map< int64_t, int64_t > OverlapIntervalsTy
Intrinsic::ID getIntrinsicID() const
Return the intrinsic ID of this intrinsic.
Definition: IntrinsicInst.h:51
void initializeDSELegacyPassPass(PassRegistry &)
unsigned getNumOperands() const
Definition: User.h:167
bool isNoAlias(const MemoryLocation &LocA, const MemoryLocation &LocB)
A trivial helper function to check to see if the specified pointers are no-alias. ...
This class represents a function call, abstracting a target machine's calling convention.
const Function * getParent() const
Return the enclosing method, or null if none.
Definition: BasicBlock.h:100
const Instruction & front() const
Definition: BasicBlock.h:240
Analysis pass which computes a DominatorTree.
Definition: Dominators.h:189
static bool handleFree(CallInst *F, AliasAnalysis *AA, MemoryDependenceResults *MD, DominatorTree *DT, const TargetLibraryInfo *TLI, InstOverlapIntervalsTy &IOL, DenseMap< Instruction *, size_t > *InstrOrdering)
Handle frees of entire structures whose dependency is a store to a field of that structure.
An instruction for reading from memory.
Definition: Instructions.h:164
void GetUnderlyingObjects(Value *V, SmallVectorImpl< Value * > &Objects, const DataLayout &DL, LoopInfo *LI=nullptr, unsigned MaxLookup=6)
This method is similar to GetUnderlyingObject except that it can look through phi and select instruct...
static bool isPossibleSelfRead(Instruction *Inst, const MemoryLocation &InstStoreLoc, Instruction *DepWrite, const TargetLibraryInfo &TLI, AliasAnalysis &AA)
If 'Inst' might be a self read (i.e.
#define op(i)
void setDest(Value *Ptr)
Set the specified arguments of the instruction.
bool isClobber() const
Tests if this MemDepResult represents a query that is an instruction clobber dependency.
PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM)
const CallInst * isFreeCall(const Value *I, const TargetLibraryInfo *TLI)
isFreeCall - Returns non-null if the value is a call to the builtin free()
INITIALIZE_PASS_BEGIN(DSELegacyPass,"dse","Dead Store Elimination", false, false) INITIALIZE_PASS_END(DSELegacyPass
iterator begin()
Instruction iterator methods.
Definition: BasicBlock.h:228
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
Definition: DenseMap.h:172
AnalysisUsage & addRequired()
#define INITIALIZE_PASS_DEPENDENCY(depName)
Definition: PassSupport.h:53
static void findUnconditionalPreds(SmallVectorImpl< BasicBlock * > &Blocks, BasicBlock *BB, DominatorTree *DT)
Find all blocks that will unconditionally lead to the block BB and append them to F...
static OverwriteResult isOverwrite(const MemoryLocation &Later, const MemoryLocation &Earlier, const DataLayout &DL, const TargetLibraryInfo &TLI, int64_t &EarlierOff, int64_t &LaterOff, Instruction *DepWrite, InstOverlapIntervalsTy &IOL)
Return 'OverwriteComplete' if a store to the 'Later' location completely overwrites a store to the 'E...
ModRefInfo
Flags indicating whether a memory access modifies or references memory.
Definition: AliasAnalysis.h:94
bool has(LibFunc::Func F) const
Tests whether a library function is available.
const Module * getModule() const
Return the module owning the function this basic block belongs to, or nullptr it the function does no...
Definition: BasicBlock.cpp:116
static bool handleEndBlock(BasicBlock &BB, AliasAnalysis *AA, MemoryDependenceResults *MD, const TargetLibraryInfo *TLI, InstOverlapIntervalsTy &IOL, DenseMap< Instruction *, size_t > *InstrOrdering)
Remove dead stores to stack-allocated locations in the function end block.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:32
An analysis that produces MemoryDependenceResults for a function.
The access references the value stored in memory.
Definition: AliasAnalysis.h:98
bool remove(const value_type &X)
Remove an item from the set vector.
Definition: SetVector.h:152
LLVM_NODISCARD bool empty() const
Definition: SmallVector.h:60
static void removeAccessedObjects(const MemoryLocation &LoadedLoc, SmallSetVector< Value *, 16 > &DeadStackObjects, const DataLayout &DL, AliasAnalysis *AA, const TargetLibraryInfo *TLI)
Check to see if the specified location may alias any of the stack objects in the DeadStackObjects set...
static GetElementPtrInst * CreateInBounds(Value *Ptr, ArrayRef< Value * > IdxList, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Create an "inbounds" getelementptr.
Definition: Instructions.h:891
#define F(x, y, z)
Definition: MD5.cpp:51
bool insert(const value_type &X)
Insert a new element into the SetVector.
Definition: SetVector.h:136
static Value * getStoredPointerOperand(Instruction *I)
Return the pointer that is being written to.
static MemoryLocation getForDest(const MemIntrinsic *MI)
Return a location representing the destination of a memory set or transfer.
Value * GetPointerBaseWithConstantOffset(Value *Ptr, int64_t &Offset, const DataLayout &DL)
Analyze the specified pointer to see if it can be expressed as a base pointer plus a constant offset...
bool isReachableFromEntry(const Use &U) const
Provide an overload for a Use.
Definition: Dominators.cpp:269
bool empty() const
Determine if the SetVector is empty or not.
Definition: SetVector.h:73
static GCRegistry::Add< OcamlGC > B("ocaml","ocaml 3.10-compatible GC")
bool getObjectSize(const Value *Ptr, uint64_t &Size, const DataLayout &DL, const TargetLibraryInfo *TLI, bool RoundToAlign=false, ObjSizeMode Mode=ObjSizeMode::Exact)
Compute the size of the object pointed by Ptr.
An instruction for storing to memory.
Definition: Instructions.h:300
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree...
Definition: Dominators.h:96
Maximum length of the test input libFuzzer tries to guess a good value based on the corpus and reports it always prefer smaller inputs during the corpus shuffle When libFuzzer itself reports a bug this exit code will be used If indicates the maximal total time in seconds to run the fuzzer minimizes the provided crash input Use with etc Experimental Use value profile to guide fuzzing Number of simultaneous worker processes to run the jobs If min(jobs, NumberOfCpuCores()/2)\" is used.") FUZZER_FLAG_INT(reload
static GCRegistry::Add< CoreCLRGC > E("coreclr","CoreCLR-compatible GC")
unsigned getNumSuccessors() const
Return the number of successors that this terminator has.
Definition: InstrTypes.h:74
an instruction for type-safe pointer arithmetic to access elements of arrays and structs ...
Definition: Instructions.h:830
The access neither references nor modifies the value stored in memory.
Definition: AliasAnalysis.h:96
static MemoryLocation get(const LoadInst *LI)
Return a location with information about the memory reference by the given instruction.
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:395
Dead Store false
static bool isShortenableAtTheBeginning(Instruction *I)
Returns true if the beginning of this instruction can be safely shortened in length.
Subclasses of this class are all able to terminate a basic block.
Definition: InstrTypes.h:52
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:107
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs...ExtraArgs)
Get the result of an analysis pass for a given IR unit.
Definition: PassManager.h:653
LLVM Basic Block Representation.
Definition: BasicBlock.h:51
static bool removePartiallyOverlappedStores(AliasAnalysis *AA, const DataLayout &DL, InstOverlapIntervalsTy &IOL)
This is an important base class in LLVM.
Definition: Constant.h:42
This file contains the declarations for the subclasses of Constant, which represent the different fla...
DenseMap< Instruction *, OverlapIntervalsTy > InstOverlapIntervalsTy
A manager for alias analyses.
static ManagedStatic< OptionRegistry > OR
Definition: Options.cpp:31
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
static bool hasMemoryWrite(Instruction *I, const TargetLibraryInfo &TLI)
Does this instruction write some memory? This only returns true for things that we can analyze with o...
Value * getRawDest() const
Interval::pred_iterator pred_begin(Interval *I)
pred_begin/pred_end - define methods so that Intervals may be used just like BasicBlocks can with the...
Definition: Interval.h:116
static bool isShortenableAtTheEnd(Instruction *I)
Returns true if the end of this instruction can be safely shortened in length.
Represent the analysis usage information of a pass.
constexpr bool isPowerOf2_64(uint64_t Value)
isPowerOf2_64 - This function returns true if the argument is a power of two 0 (64 bit edition...
Definition: MathExtras.h:405
FunctionPass * createDeadStoreEliminationPass()
static bool memoryIsNotModifiedBetween(Instruction *FirstI, Instruction *SecondI, AliasAnalysis *AA)
Returns true if the memory which is accessed by the second instruction is not modified between the fi...
std::underlying_type< E >::type Underlying(E Val)
Check that Val is in range for E, and return Val cast to E's underlying type.
Definition: BitmaskEnum.h:91
Analysis pass providing a never-invalidated alias analysis result.
INITIALIZE_PASS_END(RegBankSelect, DEBUG_TYPE,"Assign register bank of generic virtual registers", false, false) RegBankSelect
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:298
Value * getOperand(unsigned i) const
Definition: User.h:145
Interval::pred_iterator pred_end(Interval *I)
Definition: Interval.h:119
self_iterator getIterator()
Definition: ilist_node.h:81
This class represents the va_arg llvm instruction, which returns an argument of the specified type gi...
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Definition: PassManager.h:113
bool PointerMayBeCaptured(const Value *V, bool ReturnCaptures, bool StoreCaptures)
PointerMayBeCaptured - Return true if this pointer value may be captured by the enclosing function (w...
Dead Store Elimination
A wrapper analysis pass for the legacy pass manager that exposes a MemoryDepnedenceResults instance...
Value * GetUnderlyingObject(Value *V, const DataLayout &DL, unsigned MaxLookup=6)
This method strips off any GEP address adjustments and pointer casts from the specified value...
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
bool mayWriteToMemory() const
Return true if this instruction may modify memory.
A memory dependence query can return one of three different answers.
unsigned getDefaultBlockScanLimit() const
Some methods limit the number of instructions they will examine.
const Value * Ptr
The address of the start of the location.
Representation for a specific memory location.
static cl::opt< bool > EnablePartialOverwriteTracking("enable-dse-partial-overwrite-tracking", cl::init(true), cl::Hidden, cl::desc("Enable partial-overwrite tracking in DSE"))
MemDepResult getPointerDependencyFrom(const MemoryLocation &Loc, bool isLoad, BasicBlock::iterator ScanIt, BasicBlock *BB, Instruction *QueryInst=nullptr, unsigned *Limit=nullptr)
Returns the instruction on which a memory location depends.
static void deleteDeadInstruction(Instruction *I, BasicBlock::iterator *BBI, MemoryDependenceResults &MD, const TargetLibraryInfo &TLI, InstOverlapIntervalsTy &IOL, DenseMap< Instruction *, size_t > *InstrOrdering, SmallSetVector< Value *, 16 > *ValueSet=nullptr)
Delete this instruction.
A SetVector that performs no allocations if smaller than a certain size.
Definition: SetVector.h:292
bool doesNotAccessMemory(ImmutableCallSite CS)
Checks if the specified call is known to never read or write memory.
This is the common base class for memset/memcpy/memmove.
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
iterator end()
Definition: BasicBlock.h:230
ValTy * getArgument(unsigned ArgNo) const
Definition: CallSite.h:178
const Module * getModule() const
Return the module owning the function this instruction belongs to or nullptr it the function does not...
Definition: Instruction.cpp:58
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:843
Provides information about what library functions are available for the current target.
Value * getLength() const
LLVM_NODISCARD T pop_back_val()
Definition: SmallVector.h:382
bool isNonLocal() const
Tests if this MemDepResult represents a query that is transparent to the start of the block...
Value * stripPointerCasts()
Strip off pointer casts, all-zero GEPs, and aliases.
Definition: Value.cpp:490
static Constant * get(Type *Ty, uint64_t V, bool isSigned=false)
If Ty is a vector type, return a Constant with a splat of the given value.
Definition: Constants.cpp:558
void setPreservesCFG()
This function should be called by the pass, iff they do not:
Definition: Pass.cpp:276
const BasicBlock & getEntryBlock() const
Definition: Function.h:519
static bool eliminateNoopStore(Instruction *Inst, BasicBlock::iterator &BBI, AliasAnalysis *AA, MemoryDependenceResults *MD, const DataLayout &DL, const TargetLibraryInfo *TLI, InstOverlapIntervalsTy &IOL, DenseMap< Instruction *, size_t > *InstrOrdering)
bool isNullValue() const
Return true if this is the value that would be returned by getNullValue.
Definition: Constants.cpp:90
void setOperand(unsigned i, Value *Val)
Definition: User.h:150
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
Value * getArgOperand(unsigned i) const
getArgOperand/setArgOperand - Return/set the i-th call argument.
ModRefInfo getModRefInfo(ImmutableCallSite CS, const MemoryLocation &Loc)
getModRefInfo (for call sites) - Return information about whether a particular call site modifies or ...
bool isMustAlias(const MemoryLocation &LocA, const MemoryLocation &LocB)
A trivial helper function to check to see if the specified pointers are must-alias.
void setLength(Value *L)
bool mayThrow() const
Return true if this instruction may throw an exception.
This class wraps the llvm.memcpy/memmove intrinsics.
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
Definition: Module.cpp:384
Instruction * getInst() const
If this is a normal dependency, returns the instruction that is depended on.
static bool tryToShortenBegin(Instruction *EarlierWrite, OverlapIntervalsTy &IntervalMap, int64_t &EarlierStart, int64_t &EarlierSize)
size_type count(const key_type &key) const
Count the number of elements of a given key in the SetVector.
Definition: SetVector.h:205
static MemoryLocation getLocForRead(Instruction *Inst, const TargetLibraryInfo &TLI)
Return the location read by the specified "hasMemoryWrite" instruction if any.
StringRef getName(LibFunc::Func F) const
bool isCallocLikeFn(const Value *V, const TargetLibraryInfo *TLI, bool LookThroughBitCast=false)
Tests if a value is a call or invoke to a library function that allocates zero-filled memory (such as...
The access both references and modifies the value stored in memory.
#define I(x, y, z)
Definition: MD5.cpp:54
TerminatorInst * getTerminator()
Returns the terminator instruction if the block is well formed or null if the block is not well forme...
Definition: BasicBlock.cpp:124
bool isAllocLikeFn(const Value *V, const TargetLibraryInfo *TLI, bool LookThroughBitCast=false)
Tests if a value is a call or invoke to a library function that allocates memory (either malloc...
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
void preserve()
Mark an analysis as preserved.
Definition: PassManager.h:120
Analysis pass providing the TargetLibraryInfo.
bool use_empty() const
Definition: Value.h:299
static bool eliminateDeadStores(BasicBlock &BB, AliasAnalysis *AA, MemoryDependenceResults *MD, DominatorTree *DT, const TargetLibraryInfo *TLI)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
const BasicBlock & front() const
Definition: Function.h:542
bool isInstructionTriviallyDead(Instruction *I, const TargetLibraryInfo *TLI=nullptr)
Return true if the result produced by the instruction is not used, and the instruction has no side ef...
Definition: Local.cpp:288
LLVM Value Representation.
Definition: Value.h:71
void removeInstruction(Instruction *InstToRemove)
Removes an instruction from the dependence analysis, updating the dependence of instructions that pre...
bool remove_if(UnaryPredicate P)
Remove items from the set vector based on a predicate function.
Definition: SetVector.h:194
static bool isRemovable(Instruction *I)
If the value of this instruction and the memory it writes to is unused, may we delete this instructio...
#define DEBUG(X)
Definition: Debug.h:100
IRTranslator LLVM IR MI
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:47
A container for analyses that lazily runs them and caches their results.
Legacy analysis pass which computes a DominatorTree.
Definition: Dominators.h:217
static bool isVolatile(Instruction *Inst)
int * Ptr
A wrapper pass to provide the legacy pass manager access to a suitably prepared AAResults object...
static uint64_t getPointerSize(const Value *V, const DataLayout &DL, const TargetLibraryInfo &TLI)
static GCRegistry::Add< ErlangGC > A("erlang","erlang-compatible garbage collector")
Value * getPointerOperand()
Definition: Instructions.h:394
const BasicBlock * getParent() const
Definition: Instruction.h:62
static bool tryToShorten(Instruction *EarlierWrite, int64_t &EarlierOffset, int64_t &EarlierSize, int64_t LaterOffset, int64_t LaterSize, bool IsOverwriteEnd)
iterator_range< arg_iterator > args()
Definition: Function.h:568
A wrapper class for inspecting calls to intrinsic functions.
Definition: IntrinsicInst.h:44
static bool tryToShortenEnd(Instruction *EarlierWrite, OverlapIntervalsTy &IntervalMap, int64_t &EarlierStart, int64_t &EarlierSize)
uint64_t Size
The maximum size of the location, in address-units, or UnknownSize if the size is not known...
MemDepResult getDependency(Instruction *QueryInst)
Returns the instruction on which a memory operation depends.
static MemoryLocation getForSource(const MemTransferInst *MTI)
Return a location representing the source of a memory transfer.