LLVM  3.7.0
MemoryDependenceAnalysis.cpp
Go to the documentation of this file.
1 //===- MemoryDependenceAnalysis.cpp - Mem Deps Implementation -------------===//
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 an analysis that determines, for a given memory
11 // operation, what preceding memory operations it depends on. It builds on
12 // alias analysis information, and tries to provide a lazy, caching interface to
13 // a common kind of alias information query.
14 //
15 //===----------------------------------------------------------------------===//
16 
18 #include "llvm/ADT/STLExtras.h"
19 #include "llvm/ADT/Statistic.h"
26 #include "llvm/IR/DataLayout.h"
27 #include "llvm/IR/Dominators.h"
28 #include "llvm/IR/Function.h"
29 #include "llvm/IR/Instructions.h"
30 #include "llvm/IR/IntrinsicInst.h"
31 #include "llvm/IR/LLVMContext.h"
33 #include "llvm/Support/Debug.h"
34 using namespace llvm;
35 
36 #define DEBUG_TYPE "memdep"
37 
38 STATISTIC(NumCacheNonLocal, "Number of fully cached non-local responses");
39 STATISTIC(NumCacheDirtyNonLocal, "Number of dirty cached non-local responses");
40 STATISTIC(NumUncacheNonLocal, "Number of uncached non-local responses");
41 
42 STATISTIC(NumCacheNonLocalPtr,
43  "Number of fully cached non-local ptr responses");
44 STATISTIC(NumCacheDirtyNonLocalPtr,
45  "Number of cached, but dirty, non-local ptr responses");
46 STATISTIC(NumUncacheNonLocalPtr,
47  "Number of uncached non-local ptr responses");
48 STATISTIC(NumCacheCompleteNonLocalPtr,
49  "Number of block queries that were completely cached");
50 
51 // Limit for the number of instructions to scan in a block.
52 static const unsigned int BlockScanLimit = 100;
53 
54 // Limit on the number of memdep results to process.
55 static const unsigned int NumResultsLimit = 100;
56 
58 
59 // Register this pass...
61  "Memory Dependence Analysis", false, true)
66 
67 MemoryDependenceAnalysis::MemoryDependenceAnalysis()
68  : FunctionPass(ID) {
70 }
72 }
73 
74 /// Clean up memory in between runs
76  LocalDeps.clear();
77  NonLocalDeps.clear();
78  NonLocalPointerDeps.clear();
79  ReverseLocalDeps.clear();
80  ReverseNonLocalDeps.clear();
81  ReverseNonLocalPtrDeps.clear();
82  PredCache.clear();
83 }
84 
85 /// getAnalysisUsage - Does not modify anything. It uses Alias Analysis.
86 ///
88  AU.setPreservesAll();
91 }
92 
94  AA = &getAnalysis<AliasAnalysis>();
95  AC = &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
97  getAnalysisIfAvailable<DominatorTreeWrapperPass>();
98  DT = DTWP ? &DTWP->getDomTree() : nullptr;
99  return false;
100 }
101 
102 /// RemoveFromReverseMap - This is a helper function that removes Val from
103 /// 'Inst's set in ReverseMap. If the set becomes empty, remove Inst's entry.
104 template <typename KeyTy>
106  SmallPtrSet<KeyTy, 4> > &ReverseMap,
107  Instruction *Inst, KeyTy Val) {
109  InstIt = ReverseMap.find(Inst);
110  assert(InstIt != ReverseMap.end() && "Reverse map out of sync?");
111  bool Found = InstIt->second.erase(Val);
112  assert(Found && "Invalid reverse map!"); (void)Found;
113  if (InstIt->second.empty())
114  ReverseMap.erase(InstIt);
115 }
116 
117 /// GetLocation - If the given instruction references a specific memory
118 /// location, fill in Loc with the details, otherwise set Loc.Ptr to null.
119 /// Return a ModRefInfo value describing the general behavior of the
120 /// instruction.
123  if (const LoadInst *LI = dyn_cast<LoadInst>(Inst)) {
124  if (LI->isUnordered()) {
125  Loc = MemoryLocation::get(LI);
126  return AliasAnalysis::Ref;
127  }
128  if (LI->getOrdering() == Monotonic) {
129  Loc = MemoryLocation::get(LI);
130  return AliasAnalysis::ModRef;
131  }
132  Loc = MemoryLocation();
133  return AliasAnalysis::ModRef;
134  }
135 
136  if (const StoreInst *SI = dyn_cast<StoreInst>(Inst)) {
137  if (SI->isUnordered()) {
138  Loc = MemoryLocation::get(SI);
139  return AliasAnalysis::Mod;
140  }
141  if (SI->getOrdering() == Monotonic) {
142  Loc = MemoryLocation::get(SI);
143  return AliasAnalysis::ModRef;
144  }
145  Loc = MemoryLocation();
146  return AliasAnalysis::ModRef;
147  }
148 
149  if (const VAArgInst *V = dyn_cast<VAArgInst>(Inst)) {
150  Loc = MemoryLocation::get(V);
151  return AliasAnalysis::ModRef;
152  }
153 
154  if (const CallInst *CI = isFreeCall(Inst, AA->getTargetLibraryInfo())) {
155  // calls to free() deallocate the entire structure
156  Loc = MemoryLocation(CI->getArgOperand(0));
157  return AliasAnalysis::Mod;
158  }
159 
160  if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(Inst)) {
161  AAMDNodes AAInfo;
162 
163  switch (II->getIntrinsicID()) {
164  case Intrinsic::lifetime_start:
165  case Intrinsic::lifetime_end:
166  case Intrinsic::invariant_start:
167  II->getAAMetadata(AAInfo);
168  Loc = MemoryLocation(
169  II->getArgOperand(1),
170  cast<ConstantInt>(II->getArgOperand(0))->getZExtValue(), AAInfo);
171  // These intrinsics don't really modify the memory, but returning Mod
172  // will allow them to be handled conservatively.
173  return AliasAnalysis::Mod;
174  case Intrinsic::invariant_end:
175  II->getAAMetadata(AAInfo);
176  Loc = MemoryLocation(
177  II->getArgOperand(2),
178  cast<ConstantInt>(II->getArgOperand(1))->getZExtValue(), AAInfo);
179  // These intrinsics don't really modify the memory, but returning Mod
180  // will allow them to be handled conservatively.
181  return AliasAnalysis::Mod;
182  default:
183  break;
184  }
185  }
186 
187  // Otherwise, just do the coarse-grained thing that always works.
188  if (Inst->mayWriteToMemory())
189  return AliasAnalysis::ModRef;
190  if (Inst->mayReadFromMemory())
191  return AliasAnalysis::Ref;
193 }
194 
195 /// getCallSiteDependencyFrom - Private helper for finding the local
196 /// dependencies of a call site.
197 MemDepResult MemoryDependenceAnalysis::
198 getCallSiteDependencyFrom(CallSite CS, bool isReadOnlyCall,
199  BasicBlock::iterator ScanIt, BasicBlock *BB) {
200  unsigned Limit = BlockScanLimit;
201 
202  // Walk backwards through the block, looking for dependencies
203  while (ScanIt != BB->begin()) {
204  // Limit the amount of scanning we do so we don't end up with quadratic
205  // running time on extreme testcases.
206  --Limit;
207  if (!Limit)
208  return MemDepResult::getUnknown();
209 
210  Instruction *Inst = --ScanIt;
211 
212  // If this inst is a memory op, get the pointer it accessed
213  MemoryLocation Loc;
214  AliasAnalysis::ModRefResult MR = GetLocation(Inst, Loc, AA);
215  if (Loc.Ptr) {
216  // A simple instruction.
217  if (AA->getModRefInfo(CS, Loc) != AliasAnalysis::NoModRef)
218  return MemDepResult::getClobber(Inst);
219  continue;
220  }
221 
222  if (auto InstCS = CallSite(Inst)) {
223  // Debug intrinsics don't cause dependences.
224  if (isa<DbgInfoIntrinsic>(Inst)) continue;
225  // If these two calls do not interfere, look past it.
226  switch (AA->getModRefInfo(CS, InstCS)) {
228  // If the two calls are the same, return InstCS as a Def, so that
229  // CS can be found redundant and eliminated.
230  if (isReadOnlyCall && !(MR & AliasAnalysis::Mod) &&
232  return MemDepResult::getDef(Inst);
233 
234  // Otherwise if the two calls don't interact (e.g. InstCS is readnone)
235  // keep scanning.
236  continue;
237  default:
238  return MemDepResult::getClobber(Inst);
239  }
240  }
241 
242  // If we could not obtain a pointer for the instruction and the instruction
243  // touches memory then assume that this is a dependency.
244  if (MR != AliasAnalysis::NoModRef)
245  return MemDepResult::getClobber(Inst);
246  }
247 
248  // No dependence found. If this is the entry block of the function, it is
249  // unknown, otherwise it is non-local.
250  if (BB != &BB->getParent()->getEntryBlock())
251  return MemDepResult::getNonLocal();
253 }
254 
255 /// isLoadLoadClobberIfExtendedToFullWidth - Return true if LI is a load that
256 /// would fully overlap MemLoc if done as a wider legal integer load.
257 ///
258 /// MemLocBase, MemLocOffset are lazily computed here the first time the
259 /// base/offs of memloc is needed.
261  const Value *&MemLocBase,
262  int64_t &MemLocOffs,
263  const LoadInst *LI) {
264  const DataLayout &DL = LI->getModule()->getDataLayout();
265 
266  // If we haven't already computed the base/offset of MemLoc, do so now.
267  if (!MemLocBase)
268  MemLocBase = GetPointerBaseWithConstantOffset(MemLoc.Ptr, MemLocOffs, DL);
269 
271  MemLocBase, MemLocOffs, MemLoc.Size, LI);
272  return Size != 0;
273 }
274 
275 /// getLoadLoadClobberFullWidthSize - This is a little bit of analysis that
276 /// looks at a memory location for a load (specified by MemLocBase, Offs,
277 /// and Size) and compares it against a load. If the specified load could
278 /// be safely widened to a larger integer load that is 1) still efficient,
279 /// 2) safe for the target, and 3) would provide the specified memory
280 /// location value, then this function returns the size in bytes of the
281 /// load width to use. If not, this returns zero.
283  const Value *MemLocBase, int64_t MemLocOffs, unsigned MemLocSize,
284  const LoadInst *LI) {
285  // We can only extend simple integer loads.
286  if (!isa<IntegerType>(LI->getType()) || !LI->isSimple()) return 0;
287 
288  // Load widening is hostile to ThreadSanitizer: it may cause false positives
289  // or make the reports more cryptic (access sizes are wrong).
291  return 0;
292 
293  const DataLayout &DL = LI->getModule()->getDataLayout();
294 
295  // Get the base of this load.
296  int64_t LIOffs = 0;
297  const Value *LIBase =
299 
300  // If the two pointers are not based on the same pointer, we can't tell that
301  // they are related.
302  if (LIBase != MemLocBase) return 0;
303 
304  // Okay, the two values are based on the same pointer, but returned as
305  // no-alias. This happens when we have things like two byte loads at "P+1"
306  // and "P+3". Check to see if increasing the size of the "LI" load up to its
307  // alignment (or the largest native integer type) will allow us to load all
308  // the bits required by MemLoc.
309 
310  // If MemLoc is before LI, then no widening of LI will help us out.
311  if (MemLocOffs < LIOffs) return 0;
312 
313  // Get the alignment of the load in bytes. We assume that it is safe to load
314  // any legal integer up to this size without a problem. For example, if we're
315  // looking at an i8 load on x86-32 that is known 1024 byte aligned, we can
316  // widen it up to an i32 load. If it is known 2-byte aligned, we can widen it
317  // to i16.
318  unsigned LoadAlign = LI->getAlignment();
319 
320  int64_t MemLocEnd = MemLocOffs+MemLocSize;
321 
322  // If no amount of rounding up will let MemLoc fit into LI, then bail out.
323  if (LIOffs+LoadAlign < MemLocEnd) return 0;
324 
325  // This is the size of the load to try. Start with the next larger power of
326  // two.
327  unsigned NewLoadByteSize = LI->getType()->getPrimitiveSizeInBits()/8U;
328  NewLoadByteSize = NextPowerOf2(NewLoadByteSize);
329 
330  while (1) {
331  // If this load size is bigger than our known alignment or would not fit
332  // into a native integer register, then we fail.
333  if (NewLoadByteSize > LoadAlign ||
334  !DL.fitsInLegalInteger(NewLoadByteSize*8))
335  return 0;
336 
337  if (LIOffs + NewLoadByteSize > MemLocEnd &&
340  // We will be reading past the location accessed by the original program.
341  // While this is safe in a regular build, Address Safety analysis tools
342  // may start reporting false warnings. So, don't do widening.
343  return 0;
344 
345  // If a load of this width would include all of MemLoc, then we succeed.
346  if (LIOffs+NewLoadByteSize >= MemLocEnd)
347  return NewLoadByteSize;
348 
349  NewLoadByteSize <<= 1;
350  }
351 }
352 
353 static bool isVolatile(Instruction *Inst) {
354  if (LoadInst *LI = dyn_cast<LoadInst>(Inst))
355  return LI->isVolatile();
356  else if (StoreInst *SI = dyn_cast<StoreInst>(Inst))
357  return SI->isVolatile();
358  else if (AtomicCmpXchgInst *AI = dyn_cast<AtomicCmpXchgInst>(Inst))
359  return AI->isVolatile();
360  return false;
361 }
362 
363 
364 /// getPointerDependencyFrom - Return the instruction on which a memory
365 /// location depends. If isLoad is true, this routine ignores may-aliases with
366 /// read-only operations. If isLoad is false, this routine ignores may-aliases
367 /// with reads from read-only locations. If possible, pass the query
368 /// instruction as well; this function may take advantage of the metadata
369 /// annotated to the query instruction to refine the result.
371  const MemoryLocation &MemLoc, bool isLoad, BasicBlock::iterator ScanIt,
372  BasicBlock *BB, Instruction *QueryInst) {
373 
374  const Value *MemLocBase = nullptr;
375  int64_t MemLocOffset = 0;
376  unsigned Limit = BlockScanLimit;
377  bool isInvariantLoad = false;
378 
379  // We must be careful with atomic accesses, as they may allow another thread
380  // to touch this location, cloberring it. We are conservative: if the
381  // QueryInst is not a simple (non-atomic) memory access, we automatically
382  // return getClobber.
383  // If it is simple, we know based on the results of
384  // "Compiler testing via a theory of sound optimisations in the C11/C++11
385  // memory model" in PLDI 2013, that a non-atomic location can only be
386  // clobbered between a pair of a release and an acquire action, with no
387  // access to the location in between.
388  // Here is an example for giving the general intuition behind this rule.
389  // In the following code:
390  // store x 0;
391  // release action; [1]
392  // acquire action; [4]
393  // %val = load x;
394  // It is unsafe to replace %val by 0 because another thread may be running:
395  // acquire action; [2]
396  // store x 42;
397  // release action; [3]
398  // with synchronization from 1 to 2 and from 3 to 4, resulting in %val
399  // being 42. A key property of this program however is that if either
400  // 1 or 4 were missing, there would be a race between the store of 42
401  // either the store of 0 or the load (making the whole progam racy).
402  // The paper mentionned above shows that the same property is respected
403  // by every program that can detect any optimisation of that kind: either
404  // it is racy (undefined) or there is a release followed by an acquire
405  // between the pair of accesses under consideration.
406 
407  // If the load is invariant, we "know" that it doesn't alias *any* write. We
408  // do want to respect mustalias results since defs are useful for value
409  // forwarding, but any mayalias write can be assumed to be noalias.
410  // Arguably, this logic should be pushed inside AliasAnalysis itself.
411  if (isLoad && QueryInst) {
412  LoadInst *LI = dyn_cast<LoadInst>(QueryInst);
413  if (LI && LI->getMetadata(LLVMContext::MD_invariant_load) != nullptr)
414  isInvariantLoad = true;
415  }
416 
417  const DataLayout &DL = BB->getModule()->getDataLayout();
418 
419  // Walk backwards through the basic block, looking for dependencies.
420  while (ScanIt != BB->begin()) {
421  Instruction *Inst = --ScanIt;
422 
423  if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(Inst))
424  // Debug intrinsics don't (and can't) cause dependencies.
425  if (isa<DbgInfoIntrinsic>(II)) continue;
426 
427  // Limit the amount of scanning we do so we don't end up with quadratic
428  // running time on extreme testcases.
429  --Limit;
430  if (!Limit)
431  return MemDepResult::getUnknown();
432 
433  if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(Inst)) {
434  // If we reach a lifetime begin or end marker, then the query ends here
435  // because the value is undefined.
436  if (II->getIntrinsicID() == Intrinsic::lifetime_start) {
437  // FIXME: This only considers queries directly on the invariant-tagged
438  // pointer, not on query pointers that are indexed off of them. It'd
439  // be nice to handle that at some point (the right approach is to use
440  // GetPointerBaseWithConstantOffset).
441  if (AA->isMustAlias(MemoryLocation(II->getArgOperand(1)), MemLoc))
442  return MemDepResult::getDef(II);
443  continue;
444  }
445  }
446 
447  // Values depend on loads if the pointers are must aliased. This means that
448  // a load depends on another must aliased load from the same value.
449  // One exception is atomic loads: a value can depend on an atomic load that it
450  // does not alias with when this atomic load indicates that another thread may
451  // be accessing the location.
452  if (LoadInst *LI = dyn_cast<LoadInst>(Inst)) {
453 
454  // While volatile access cannot be eliminated, they do not have to clobber
455  // non-aliasing locations, as normal accesses, for example, can be safely
456  // reordered with volatile accesses.
457  if (LI->isVolatile()) {
458  if (!QueryInst)
459  // Original QueryInst *may* be volatile
460  return MemDepResult::getClobber(LI);
461  if (isVolatile(QueryInst))
462  // Ordering required if QueryInst is itself volatile
463  return MemDepResult::getClobber(LI);
464  // Otherwise, volatile doesn't imply any special ordering
465  }
466 
467  // Atomic loads have complications involved.
468  // A Monotonic (or higher) load is OK if the query inst is itself not atomic.
469  // FIXME: This is overly conservative.
470  if (LI->isAtomic() && LI->getOrdering() > Unordered) {
471  if (!QueryInst)
472  return MemDepResult::getClobber(LI);
473  if (LI->getOrdering() != Monotonic)
474  return MemDepResult::getClobber(LI);
475  if (auto *QueryLI = dyn_cast<LoadInst>(QueryInst)) {
476  if (!QueryLI->isSimple())
477  return MemDepResult::getClobber(LI);
478  } else if (auto *QuerySI = dyn_cast<StoreInst>(QueryInst)) {
479  if (!QuerySI->isSimple())
480  return MemDepResult::getClobber(LI);
481  } else if (QueryInst->mayReadOrWriteMemory()) {
482  return MemDepResult::getClobber(LI);
483  }
484  }
485 
486  MemoryLocation LoadLoc = MemoryLocation::get(LI);
487 
488  // If we found a pointer, check if it could be the same as our pointer.
489  AliasResult R = AA->alias(LoadLoc, MemLoc);
490 
491  if (isLoad) {
492  if (R == NoAlias) {
493  // If this is an over-aligned integer load (for example,
494  // "load i8* %P, align 4") see if it would obviously overlap with the
495  // queried location if widened to a larger load (e.g. if the queried
496  // location is 1 byte at P+1). If so, return it as a load/load
497  // clobber result, allowing the client to decide to widen the load if
498  // it wants to.
499  if (IntegerType *ITy = dyn_cast<IntegerType>(LI->getType())) {
500  if (LI->getAlignment() * 8 > ITy->getPrimitiveSizeInBits() &&
501  isLoadLoadClobberIfExtendedToFullWidth(MemLoc, MemLocBase,
502  MemLocOffset, LI))
503  return MemDepResult::getClobber(Inst);
504  }
505  continue;
506  }
507 
508  // Must aliased loads are defs of each other.
509  if (R == MustAlias)
510  return MemDepResult::getDef(Inst);
511 
512 #if 0 // FIXME: Temporarily disabled. GVN is cleverly rewriting loads
513  // in terms of clobbering loads, but since it does this by looking
514  // at the clobbering load directly, it doesn't know about any
515  // phi translation that may have happened along the way.
516 
517  // If we have a partial alias, then return this as a clobber for the
518  // client to handle.
519  if (R == PartialAlias)
520  return MemDepResult::getClobber(Inst);
521 #endif
522 
523  // Random may-alias loads don't depend on each other without a
524  // dependence.
525  continue;
526  }
527 
528  // Stores don't depend on other no-aliased accesses.
529  if (R == NoAlias)
530  continue;
531 
532  // Stores don't alias loads from read-only memory.
533  if (AA->pointsToConstantMemory(LoadLoc))
534  continue;
535 
536  // Stores depend on may/must aliased loads.
537  return MemDepResult::getDef(Inst);
538  }
539 
540  if (StoreInst *SI = dyn_cast<StoreInst>(Inst)) {
541  // Atomic stores have complications involved.
542  // A Monotonic store is OK if the query inst is itself not atomic.
543  // FIXME: This is overly conservative.
544  if (!SI->isUnordered()) {
545  if (!QueryInst)
547  if (SI->getOrdering() != Monotonic)
549  if (auto *QueryLI = dyn_cast<LoadInst>(QueryInst)) {
550  if (!QueryLI->isSimple())
552  } else if (auto *QuerySI = dyn_cast<StoreInst>(QueryInst)) {
553  if (!QuerySI->isSimple())
555  } else if (QueryInst->mayReadOrWriteMemory()) {
557  }
558  }
559 
560  // FIXME: this is overly conservative.
561  // While volatile access cannot be eliminated, they do not have to clobber
562  // non-aliasing locations, as normal accesses can for example be reordered
563  // with volatile accesses.
564  if (SI->isVolatile())
566 
567  // If alias analysis can tell that this store is guaranteed to not modify
568  // the query pointer, ignore it. Use getModRefInfo to handle cases where
569  // the query pointer points to constant memory etc.
570  if (AA->getModRefInfo(SI, MemLoc) == AliasAnalysis::NoModRef)
571  continue;
572 
573  // Ok, this store might clobber the query pointer. Check to see if it is
574  // a must alias: in this case, we want to return this as a def.
576 
577  // If we found a pointer, check if it could be the same as our pointer.
578  AliasResult R = AA->alias(StoreLoc, MemLoc);
579 
580  if (R == NoAlias)
581  continue;
582  if (R == MustAlias)
583  return MemDepResult::getDef(Inst);
584  if (isInvariantLoad)
585  continue;
586  return MemDepResult::getClobber(Inst);
587  }
588 
589  // If this is an allocation, and if we know that the accessed pointer is to
590  // the allocation, return Def. This means that there is no dependence and
591  // the access can be optimized based on that. For example, a load could
592  // turn into undef.
593  // Note: Only determine this to be a malloc if Inst is the malloc call, not
594  // a subsequent bitcast of the malloc call result. There can be stores to
595  // the malloced memory between the malloc call and its bitcast uses, and we
596  // need to continue scanning until the malloc call.
597  const TargetLibraryInfo *TLI = AA->getTargetLibraryInfo();
598  if (isa<AllocaInst>(Inst) || isNoAliasFn(Inst, TLI)) {
599  const Value *AccessPtr = GetUnderlyingObject(MemLoc.Ptr, DL);
600 
601  if (AccessPtr == Inst || AA->isMustAlias(Inst, AccessPtr))
602  return MemDepResult::getDef(Inst);
603  if (isInvariantLoad)
604  continue;
605  // Be conservative if the accessed pointer may alias the allocation.
606  if (AA->alias(Inst, AccessPtr) != NoAlias)
607  return MemDepResult::getClobber(Inst);
608  // If the allocation is not aliased and does not read memory (like
609  // strdup), it is safe to ignore.
610  if (isa<AllocaInst>(Inst) ||
611  isMallocLikeFn(Inst, TLI) || isCallocLikeFn(Inst, TLI))
612  continue;
613  }
614 
615  if (isInvariantLoad)
616  continue;
617 
618  // See if this instruction (e.g. a call or vaarg) mod/ref's the pointer.
619  AliasAnalysis::ModRefResult MR = AA->getModRefInfo(Inst, MemLoc);
620  // If necessary, perform additional analysis.
621  if (MR == AliasAnalysis::ModRef)
622  MR = AA->callCapturesBefore(Inst, MemLoc, DT);
623  switch (MR) {
625  // If the call has no effect on the queried pointer, just ignore it.
626  continue;
627  case AliasAnalysis::Mod:
628  return MemDepResult::getClobber(Inst);
629  case AliasAnalysis::Ref:
630  // If the call is known to never store to the pointer, and if this is a
631  // load query, we can safely ignore it (scan past it).
632  if (isLoad)
633  continue;
634  default:
635  // Otherwise, there is a potential dependence. Return a clobber.
636  return MemDepResult::getClobber(Inst);
637  }
638  }
639 
640  // No dependence found. If this is the entry block of the function, it is
641  // unknown, otherwise it is non-local.
642  if (BB != &BB->getParent()->getEntryBlock())
643  return MemDepResult::getNonLocal();
645 }
646 
647 /// getDependency - Return the instruction on which a memory operation
648 /// depends.
650  Instruction *ScanPos = QueryInst;
651 
652  // Check for a cached result
653  MemDepResult &LocalCache = LocalDeps[QueryInst];
654 
655  // If the cached entry is non-dirty, just return it. Note that this depends
656  // on MemDepResult's default constructing to 'dirty'.
657  if (!LocalCache.isDirty())
658  return LocalCache;
659 
660  // Otherwise, if we have a dirty entry, we know we can start the scan at that
661  // instruction, which may save us some work.
662  if (Instruction *Inst = LocalCache.getInst()) {
663  ScanPos = Inst;
664 
665  RemoveFromReverseMap(ReverseLocalDeps, Inst, QueryInst);
666  }
667 
668  BasicBlock *QueryParent = QueryInst->getParent();
669 
670  // Do the scan.
671  if (BasicBlock::iterator(QueryInst) == QueryParent->begin()) {
672  // No dependence found. If this is the entry block of the function, it is
673  // unknown, otherwise it is non-local.
674  if (QueryParent != &QueryParent->getParent()->getEntryBlock())
675  LocalCache = MemDepResult::getNonLocal();
676  else
677  LocalCache = MemDepResult::getNonFuncLocal();
678  } else {
679  MemoryLocation MemLoc;
680  AliasAnalysis::ModRefResult MR = GetLocation(QueryInst, MemLoc, AA);
681  if (MemLoc.Ptr) {
682  // If we can do a pointer scan, make it happen.
683  bool isLoad = !(MR & AliasAnalysis::Mod);
684  if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(QueryInst))
685  isLoad |= II->getIntrinsicID() == Intrinsic::lifetime_start;
686 
687  LocalCache = getPointerDependencyFrom(MemLoc, isLoad, ScanPos,
688  QueryParent, QueryInst);
689  } else if (isa<CallInst>(QueryInst) || isa<InvokeInst>(QueryInst)) {
690  CallSite QueryCS(QueryInst);
691  bool isReadOnly = AA->onlyReadsMemory(QueryCS);
692  LocalCache = getCallSiteDependencyFrom(QueryCS, isReadOnly, ScanPos,
693  QueryParent);
694  } else
695  // Non-memory instruction.
696  LocalCache = MemDepResult::getUnknown();
697  }
698 
699  // Remember the result!
700  if (Instruction *I = LocalCache.getInst())
701  ReverseLocalDeps[I].insert(QueryInst);
702 
703  return LocalCache;
704 }
705 
706 #ifndef NDEBUG
707 /// AssertSorted - This method is used when -debug is specified to verify that
708 /// cache arrays are properly kept sorted.
710  int Count = -1) {
711  if (Count == -1) Count = Cache.size();
712  if (Count == 0) return;
713 
714  for (unsigned i = 1; i != unsigned(Count); ++i)
715  assert(!(Cache[i] < Cache[i-1]) && "Cache isn't sorted!");
716 }
717 #endif
718 
719 /// getNonLocalCallDependency - Perform a full dependency query for the
720 /// specified call, returning the set of blocks that the value is
721 /// potentially live across. The returned set of results will include a
722 /// "NonLocal" result for all blocks where the value is live across.
723 ///
724 /// This method assumes the instruction returns a "NonLocal" dependency
725 /// within its own block.
726 ///
727 /// This returns a reference to an internal data structure that may be
728 /// invalidated on the next non-local query or when an instruction is
729 /// removed. Clients must copy this data if they want it around longer than
730 /// that.
733  assert(getDependency(QueryCS.getInstruction()).isNonLocal() &&
734  "getNonLocalCallDependency should only be used on calls with non-local deps!");
735  PerInstNLInfo &CacheP = NonLocalDeps[QueryCS.getInstruction()];
736  NonLocalDepInfo &Cache = CacheP.first;
737 
738  /// DirtyBlocks - This is the set of blocks that need to be recomputed. In
739  /// the cached case, this can happen due to instructions being deleted etc. In
740  /// the uncached case, this starts out as the set of predecessors we care
741  /// about.
742  SmallVector<BasicBlock*, 32> DirtyBlocks;
743 
744  if (!Cache.empty()) {
745  // Okay, we have a cache entry. If we know it is not dirty, just return it
746  // with no computation.
747  if (!CacheP.second) {
748  ++NumCacheNonLocal;
749  return Cache;
750  }
751 
752  // If we already have a partially computed set of results, scan them to
753  // determine what is dirty, seeding our initial DirtyBlocks worklist.
754  for (NonLocalDepInfo::iterator I = Cache.begin(), E = Cache.end();
755  I != E; ++I)
756  if (I->getResult().isDirty())
757  DirtyBlocks.push_back(I->getBB());
758 
759  // Sort the cache so that we can do fast binary search lookups below.
760  std::sort(Cache.begin(), Cache.end());
761 
762  ++NumCacheDirtyNonLocal;
763  //cerr << "CACHED CASE: " << DirtyBlocks.size() << " dirty: "
764  // << Cache.size() << " cached: " << *QueryInst;
765  } else {
766  // Seed DirtyBlocks with each of the preds of QueryInst's block.
767  BasicBlock *QueryBB = QueryCS.getInstruction()->getParent();
768  for (BasicBlock *Pred : PredCache.get(QueryBB))
769  DirtyBlocks.push_back(Pred);
770  ++NumUncacheNonLocal;
771  }
772 
773  // isReadonlyCall - If this is a read-only call, we can be more aggressive.
774  bool isReadonlyCall = AA->onlyReadsMemory(QueryCS);
775 
777 
778  unsigned NumSortedEntries = Cache.size();
779  DEBUG(AssertSorted(Cache));
780 
781  // Iterate while we still have blocks to update.
782  while (!DirtyBlocks.empty()) {
783  BasicBlock *DirtyBB = DirtyBlocks.back();
784  DirtyBlocks.pop_back();
785 
786  // Already processed this block?
787  if (!Visited.insert(DirtyBB).second)
788  continue;
789 
790  // Do a binary search to see if we already have an entry for this block in
791  // the cache set. If so, find it.
792  DEBUG(AssertSorted(Cache, NumSortedEntries));
793  NonLocalDepInfo::iterator Entry =
794  std::upper_bound(Cache.begin(), Cache.begin()+NumSortedEntries,
795  NonLocalDepEntry(DirtyBB));
796  if (Entry != Cache.begin() && std::prev(Entry)->getBB() == DirtyBB)
797  --Entry;
798 
799  NonLocalDepEntry *ExistingResult = nullptr;
800  if (Entry != Cache.begin()+NumSortedEntries &&
801  Entry->getBB() == DirtyBB) {
802  // If we already have an entry, and if it isn't already dirty, the block
803  // is done.
804  if (!Entry->getResult().isDirty())
805  continue;
806 
807  // Otherwise, remember this slot so we can update the value.
808  ExistingResult = &*Entry;
809  }
810 
811  // If the dirty entry has a pointer, start scanning from it so we don't have
812  // to rescan the entire block.
813  BasicBlock::iterator ScanPos = DirtyBB->end();
814  if (ExistingResult) {
815  if (Instruction *Inst = ExistingResult->getResult().getInst()) {
816  ScanPos = Inst;
817  // We're removing QueryInst's use of Inst.
818  RemoveFromReverseMap(ReverseNonLocalDeps, Inst,
819  QueryCS.getInstruction());
820  }
821  }
822 
823  // Find out if this block has a local dependency for QueryInst.
824  MemDepResult Dep;
825 
826  if (ScanPos != DirtyBB->begin()) {
827  Dep = getCallSiteDependencyFrom(QueryCS, isReadonlyCall,ScanPos, DirtyBB);
828  } else if (DirtyBB != &DirtyBB->getParent()->getEntryBlock()) {
829  // No dependence found. If this is the entry block of the function, it is
830  // a clobber, otherwise it is unknown.
832  } else {
834  }
835 
836  // If we had a dirty entry for the block, update it. Otherwise, just add
837  // a new entry.
838  if (ExistingResult)
839  ExistingResult->setResult(Dep);
840  else
841  Cache.push_back(NonLocalDepEntry(DirtyBB, Dep));
842 
843  // If the block has a dependency (i.e. it isn't completely transparent to
844  // the value), remember the association!
845  if (!Dep.isNonLocal()) {
846  // Keep the ReverseNonLocalDeps map up to date so we can efficiently
847  // update this when we remove instructions.
848  if (Instruction *Inst = Dep.getInst())
849  ReverseNonLocalDeps[Inst].insert(QueryCS.getInstruction());
850  } else {
851 
852  // If the block *is* completely transparent to the load, we need to check
853  // the predecessors of this block. Add them to our worklist.
854  for (BasicBlock *Pred : PredCache.get(DirtyBB))
855  DirtyBlocks.push_back(Pred);
856  }
857  }
858 
859  return Cache;
860 }
861 
862 /// getNonLocalPointerDependency - Perform a full dependency query for an
863 /// access to the specified (non-volatile) memory location, returning the
864 /// set of instructions that either define or clobber the value.
865 ///
866 /// This method assumes the pointer has a "NonLocal" dependency within its
867 /// own block.
868 ///
872  const MemoryLocation Loc = MemoryLocation::get(QueryInst);
873  bool isLoad = isa<LoadInst>(QueryInst);
874  BasicBlock *FromBB = QueryInst->getParent();
875  assert(FromBB);
876 
877  assert(Loc.Ptr->getType()->isPointerTy() &&
878  "Can't get pointer deps of a non-pointer!");
879  Result.clear();
880 
881  // This routine does not expect to deal with volatile instructions.
882  // Doing so would require piping through the QueryInst all the way through.
883  // TODO: volatiles can't be elided, but they can be reordered with other
884  // non-volatile accesses.
885 
886  // We currently give up on any instruction which is ordered, but we do handle
887  // atomic instructions which are unordered.
888  // TODO: Handle ordered instructions
889  auto isOrdered = [](Instruction *Inst) {
890  if (LoadInst *LI = dyn_cast<LoadInst>(Inst)) {
891  return !LI->isUnordered();
892  } else if (StoreInst *SI = dyn_cast<StoreInst>(Inst)) {
893  return !SI->isUnordered();
894  }
895  return false;
896  };
897  if (isVolatile(QueryInst) || isOrdered(QueryInst)) {
898  Result.push_back(NonLocalDepResult(FromBB,
900  const_cast<Value *>(Loc.Ptr)));
901  return;
902  }
903  const DataLayout &DL = FromBB->getModule()->getDataLayout();
904  PHITransAddr Address(const_cast<Value *>(Loc.Ptr), DL, AC);
905 
906  // This is the set of blocks we've inspected, and the pointer we consider in
907  // each block. Because of critical edges, we currently bail out if querying
908  // a block with multiple different pointers. This can happen during PHI
909  // translation.
911  if (!getNonLocalPointerDepFromBB(QueryInst, Address, Loc, isLoad, FromBB,
912  Result, Visited, true))
913  return;
914  Result.clear();
915  Result.push_back(NonLocalDepResult(FromBB,
917  const_cast<Value *>(Loc.Ptr)));
918 }
919 
920 /// GetNonLocalInfoForBlock - Compute the memdep value for BB with
921 /// Pointer/PointeeSize using either cached information in Cache or by doing a
922 /// lookup (which may use dirty cache info if available). If we do a lookup,
923 /// add the result to the cache.
924 MemDepResult MemoryDependenceAnalysis::GetNonLocalInfoForBlock(
925  Instruction *QueryInst, const MemoryLocation &Loc, bool isLoad,
926  BasicBlock *BB, NonLocalDepInfo *Cache, unsigned NumSortedEntries) {
927 
928  // Do a binary search to see if we already have an entry for this block in
929  // the cache set. If so, find it.
930  NonLocalDepInfo::iterator Entry =
931  std::upper_bound(Cache->begin(), Cache->begin()+NumSortedEntries,
932  NonLocalDepEntry(BB));
933  if (Entry != Cache->begin() && (Entry-1)->getBB() == BB)
934  --Entry;
935 
936  NonLocalDepEntry *ExistingResult = nullptr;
937  if (Entry != Cache->begin()+NumSortedEntries && Entry->getBB() == BB)
938  ExistingResult = &*Entry;
939 
940  // If we have a cached entry, and it is non-dirty, use it as the value for
941  // this dependency.
942  if (ExistingResult && !ExistingResult->getResult().isDirty()) {
943  ++NumCacheNonLocalPtr;
944  return ExistingResult->getResult();
945  }
946 
947  // Otherwise, we have to scan for the value. If we have a dirty cache
948  // entry, start scanning from its position, otherwise we scan from the end
949  // of the block.
950  BasicBlock::iterator ScanPos = BB->end();
951  if (ExistingResult && ExistingResult->getResult().getInst()) {
952  assert(ExistingResult->getResult().getInst()->getParent() == BB &&
953  "Instruction invalidated?");
954  ++NumCacheDirtyNonLocalPtr;
955  ScanPos = ExistingResult->getResult().getInst();
956 
957  // Eliminating the dirty entry from 'Cache', so update the reverse info.
958  ValueIsLoadPair CacheKey(Loc.Ptr, isLoad);
959  RemoveFromReverseMap(ReverseNonLocalPtrDeps, ScanPos, CacheKey);
960  } else {
961  ++NumUncacheNonLocalPtr;
962  }
963 
964  // Scan the block for the dependency.
965  MemDepResult Dep = getPointerDependencyFrom(Loc, isLoad, ScanPos, BB,
966  QueryInst);
967 
968  // If we had a dirty entry for the block, update it. Otherwise, just add
969  // a new entry.
970  if (ExistingResult)
971  ExistingResult->setResult(Dep);
972  else
973  Cache->push_back(NonLocalDepEntry(BB, Dep));
974 
975  // If the block has a dependency (i.e. it isn't completely transparent to
976  // the value), remember the reverse association because we just added it
977  // to Cache!
978  if (!Dep.isDef() && !Dep.isClobber())
979  return Dep;
980 
981  // Keep the ReverseNonLocalPtrDeps map up to date so we can efficiently
982  // update MemDep when we remove instructions.
983  Instruction *Inst = Dep.getInst();
984  assert(Inst && "Didn't depend on anything?");
985  ValueIsLoadPair CacheKey(Loc.Ptr, isLoad);
986  ReverseNonLocalPtrDeps[Inst].insert(CacheKey);
987  return Dep;
988 }
989 
990 /// SortNonLocalDepInfoCache - Sort the NonLocalDepInfo cache, given a certain
991 /// number of elements in the array that are already properly ordered. This is
992 /// optimized for the case when only a few entries are added.
993 static void
995  unsigned NumSortedEntries) {
996  switch (Cache.size() - NumSortedEntries) {
997  case 0:
998  // done, no new entries.
999  break;
1000  case 2: {
1001  // Two new entries, insert the last one into place.
1002  NonLocalDepEntry Val = Cache.back();
1003  Cache.pop_back();
1004  MemoryDependenceAnalysis::NonLocalDepInfo::iterator Entry =
1005  std::upper_bound(Cache.begin(), Cache.end()-1, Val);
1006  Cache.insert(Entry, Val);
1007  // FALL THROUGH.
1008  }
1009  case 1:
1010  // One new entry, Just insert the new value at the appropriate position.
1011  if (Cache.size() != 1) {
1012  NonLocalDepEntry Val = Cache.back();
1013  Cache.pop_back();
1014  MemoryDependenceAnalysis::NonLocalDepInfo::iterator Entry =
1015  std::upper_bound(Cache.begin(), Cache.end(), Val);
1016  Cache.insert(Entry, Val);
1017  }
1018  break;
1019  default:
1020  // Added many values, do a full scale sort.
1021  std::sort(Cache.begin(), Cache.end());
1022  break;
1023  }
1024 }
1025 
1026 /// getNonLocalPointerDepFromBB - Perform a dependency query based on
1027 /// pointer/pointeesize starting at the end of StartBB. Add any clobber/def
1028 /// results to the results vector and keep track of which blocks are visited in
1029 /// 'Visited'.
1030 ///
1031 /// This has special behavior for the first block queries (when SkipFirstBlock
1032 /// is true). In this special case, it ignores the contents of the specified
1033 /// block and starts returning dependence info for its predecessors.
1034 ///
1035 /// This function returns false on success, or true to indicate that it could
1036 /// not compute dependence information for some reason. This should be treated
1037 /// as a clobber dependence on the first instruction in the predecessor block.
1038 bool MemoryDependenceAnalysis::getNonLocalPointerDepFromBB(
1039  Instruction *QueryInst, const PHITransAddr &Pointer,
1040  const MemoryLocation &Loc, bool isLoad, BasicBlock *StartBB,
1042  DenseMap<BasicBlock *, Value *> &Visited, bool SkipFirstBlock) {
1043  // Look up the cached info for Pointer.
1044  ValueIsLoadPair CacheKey(Pointer.getAddr(), isLoad);
1045 
1046  // Set up a temporary NLPI value. If the map doesn't yet have an entry for
1047  // CacheKey, this value will be inserted as the associated value. Otherwise,
1048  // it'll be ignored, and we'll have to check to see if the cached size and
1049  // aa tags are consistent with the current query.
1050  NonLocalPointerInfo InitialNLPI;
1051  InitialNLPI.Size = Loc.Size;
1052  InitialNLPI.AATags = Loc.AATags;
1053 
1054  // Get the NLPI for CacheKey, inserting one into the map if it doesn't
1055  // already have one.
1056  std::pair<CachedNonLocalPointerInfo::iterator, bool> Pair =
1057  NonLocalPointerDeps.insert(std::make_pair(CacheKey, InitialNLPI));
1058  NonLocalPointerInfo *CacheInfo = &Pair.first->second;
1059 
1060  // If we already have a cache entry for this CacheKey, we may need to do some
1061  // work to reconcile the cache entry and the current query.
1062  if (!Pair.second) {
1063  if (CacheInfo->Size < Loc.Size) {
1064  // The query's Size is greater than the cached one. Throw out the
1065  // cached data and proceed with the query at the greater size.
1066  CacheInfo->Pair = BBSkipFirstBlockPair();
1067  CacheInfo->Size = Loc.Size;
1068  for (NonLocalDepInfo::iterator DI = CacheInfo->NonLocalDeps.begin(),
1069  DE = CacheInfo->NonLocalDeps.end(); DI != DE; ++DI)
1070  if (Instruction *Inst = DI->getResult().getInst())
1071  RemoveFromReverseMap(ReverseNonLocalPtrDeps, Inst, CacheKey);
1072  CacheInfo->NonLocalDeps.clear();
1073  } else if (CacheInfo->Size > Loc.Size) {
1074  // This query's Size is less than the cached one. Conservatively restart
1075  // the query using the greater size.
1076  return getNonLocalPointerDepFromBB(QueryInst, Pointer,
1077  Loc.getWithNewSize(CacheInfo->Size),
1078  isLoad, StartBB, Result, Visited,
1079  SkipFirstBlock);
1080  }
1081 
1082  // If the query's AATags are inconsistent with the cached one,
1083  // conservatively throw out the cached data and restart the query with
1084  // no tag if needed.
1085  if (CacheInfo->AATags != Loc.AATags) {
1086  if (CacheInfo->AATags) {
1087  CacheInfo->Pair = BBSkipFirstBlockPair();
1088  CacheInfo->AATags = AAMDNodes();
1089  for (NonLocalDepInfo::iterator DI = CacheInfo->NonLocalDeps.begin(),
1090  DE = CacheInfo->NonLocalDeps.end(); DI != DE; ++DI)
1091  if (Instruction *Inst = DI->getResult().getInst())
1092  RemoveFromReverseMap(ReverseNonLocalPtrDeps, Inst, CacheKey);
1093  CacheInfo->NonLocalDeps.clear();
1094  }
1095  if (Loc.AATags)
1096  return getNonLocalPointerDepFromBB(QueryInst,
1097  Pointer, Loc.getWithoutAATags(),
1098  isLoad, StartBB, Result, Visited,
1099  SkipFirstBlock);
1100  }
1101  }
1102 
1103  NonLocalDepInfo *Cache = &CacheInfo->NonLocalDeps;
1104 
1105  // If we have valid cached information for exactly the block we are
1106  // investigating, just return it with no recomputation.
1107  if (CacheInfo->Pair == BBSkipFirstBlockPair(StartBB, SkipFirstBlock)) {
1108  // We have a fully cached result for this query then we can just return the
1109  // cached results and populate the visited set. However, we have to verify
1110  // that we don't already have conflicting results for these blocks. Check
1111  // to ensure that if a block in the results set is in the visited set that
1112  // it was for the same pointer query.
1113  if (!Visited.empty()) {
1114  for (NonLocalDepInfo::iterator I = Cache->begin(), E = Cache->end();
1115  I != E; ++I) {
1116  DenseMap<BasicBlock*, Value*>::iterator VI = Visited.find(I->getBB());
1117  if (VI == Visited.end() || VI->second == Pointer.getAddr())
1118  continue;
1119 
1120  // We have a pointer mismatch in a block. Just return clobber, saying
1121  // that something was clobbered in this result. We could also do a
1122  // non-fully cached query, but there is little point in doing this.
1123  return true;
1124  }
1125  }
1126 
1127  Value *Addr = Pointer.getAddr();
1128  for (NonLocalDepInfo::iterator I = Cache->begin(), E = Cache->end();
1129  I != E; ++I) {
1130  Visited.insert(std::make_pair(I->getBB(), Addr));
1131  if (I->getResult().isNonLocal()) {
1132  continue;
1133  }
1134 
1135  if (!DT) {
1136  Result.push_back(NonLocalDepResult(I->getBB(),
1138  Addr));
1139  } else if (DT->isReachableFromEntry(I->getBB())) {
1140  Result.push_back(NonLocalDepResult(I->getBB(), I->getResult(), Addr));
1141  }
1142  }
1143  ++NumCacheCompleteNonLocalPtr;
1144  return false;
1145  }
1146 
1147  // Otherwise, either this is a new block, a block with an invalid cache
1148  // pointer or one that we're about to invalidate by putting more info into it
1149  // than its valid cache info. If empty, the result will be valid cache info,
1150  // otherwise it isn't.
1151  if (Cache->empty())
1152  CacheInfo->Pair = BBSkipFirstBlockPair(StartBB, SkipFirstBlock);
1153  else
1154  CacheInfo->Pair = BBSkipFirstBlockPair();
1155 
1157  Worklist.push_back(StartBB);
1158 
1159  // PredList used inside loop.
1161 
1162  // Keep track of the entries that we know are sorted. Previously cached
1163  // entries will all be sorted. The entries we add we only sort on demand (we
1164  // don't insert every element into its sorted position). We know that we
1165  // won't get any reuse from currently inserted values, because we don't
1166  // revisit blocks after we insert info for them.
1167  unsigned NumSortedEntries = Cache->size();
1168  DEBUG(AssertSorted(*Cache));
1169 
1170  while (!Worklist.empty()) {
1171  BasicBlock *BB = Worklist.pop_back_val();
1172 
1173  // If we do process a large number of blocks it becomes very expensive and
1174  // likely it isn't worth worrying about
1175  if (Result.size() > NumResultsLimit) {
1176  Worklist.clear();
1177  // Sort it now (if needed) so that recursive invocations of
1178  // getNonLocalPointerDepFromBB and other routines that could reuse the
1179  // cache value will only see properly sorted cache arrays.
1180  if (Cache && NumSortedEntries != Cache->size()) {
1181  SortNonLocalDepInfoCache(*Cache, NumSortedEntries);
1182  }
1183  // Since we bail out, the "Cache" set won't contain all of the
1184  // results for the query. This is ok (we can still use it to accelerate
1185  // specific block queries) but we can't do the fastpath "return all
1186  // results from the set". Clear out the indicator for this.
1187  CacheInfo->Pair = BBSkipFirstBlockPair();
1188  return true;
1189  }
1190 
1191  // Skip the first block if we have it.
1192  if (!SkipFirstBlock) {
1193  // Analyze the dependency of *Pointer in FromBB. See if we already have
1194  // been here.
1195  assert(Visited.count(BB) && "Should check 'visited' before adding to WL");
1196 
1197  // Get the dependency info for Pointer in BB. If we have cached
1198  // information, we will use it, otherwise we compute it.
1199  DEBUG(AssertSorted(*Cache, NumSortedEntries));
1200  MemDepResult Dep = GetNonLocalInfoForBlock(QueryInst,
1201  Loc, isLoad, BB, Cache,
1202  NumSortedEntries);
1203 
1204  // If we got a Def or Clobber, add this to the list of results.
1205  if (!Dep.isNonLocal()) {
1206  if (!DT) {
1207  Result.push_back(NonLocalDepResult(BB,
1209  Pointer.getAddr()));
1210  continue;
1211  } else if (DT->isReachableFromEntry(BB)) {
1212  Result.push_back(NonLocalDepResult(BB, Dep, Pointer.getAddr()));
1213  continue;
1214  }
1215  }
1216  }
1217 
1218  // If 'Pointer' is an instruction defined in this block, then we need to do
1219  // phi translation to change it into a value live in the predecessor block.
1220  // If not, we just add the predecessors to the worklist and scan them with
1221  // the same Pointer.
1222  if (!Pointer.NeedsPHITranslationFromBlock(BB)) {
1223  SkipFirstBlock = false;
1224  SmallVector<BasicBlock*, 16> NewBlocks;
1225  for (BasicBlock *Pred : PredCache.get(BB)) {
1226  // Verify that we haven't looked at this block yet.
1227  std::pair<DenseMap<BasicBlock*,Value*>::iterator, bool>
1228  InsertRes = Visited.insert(std::make_pair(Pred, Pointer.getAddr()));
1229  if (InsertRes.second) {
1230  // First time we've looked at *PI.
1231  NewBlocks.push_back(Pred);
1232  continue;
1233  }
1234 
1235  // If we have seen this block before, but it was with a different
1236  // pointer then we have a phi translation failure and we have to treat
1237  // this as a clobber.
1238  if (InsertRes.first->second != Pointer.getAddr()) {
1239  // Make sure to clean up the Visited map before continuing on to
1240  // PredTranslationFailure.
1241  for (unsigned i = 0; i < NewBlocks.size(); i++)
1242  Visited.erase(NewBlocks[i]);
1243  goto PredTranslationFailure;
1244  }
1245  }
1246  Worklist.append(NewBlocks.begin(), NewBlocks.end());
1247  continue;
1248  }
1249 
1250  // We do need to do phi translation, if we know ahead of time we can't phi
1251  // translate this value, don't even try.
1252  if (!Pointer.IsPotentiallyPHITranslatable())
1253  goto PredTranslationFailure;
1254 
1255  // We may have added values to the cache list before this PHI translation.
1256  // If so, we haven't done anything to ensure that the cache remains sorted.
1257  // Sort it now (if needed) so that recursive invocations of
1258  // getNonLocalPointerDepFromBB and other routines that could reuse the cache
1259  // value will only see properly sorted cache arrays.
1260  if (Cache && NumSortedEntries != Cache->size()) {
1261  SortNonLocalDepInfoCache(*Cache, NumSortedEntries);
1262  NumSortedEntries = Cache->size();
1263  }
1264  Cache = nullptr;
1265 
1266  PredList.clear();
1267  for (BasicBlock *Pred : PredCache.get(BB)) {
1268  PredList.push_back(std::make_pair(Pred, Pointer));
1269 
1270  // Get the PHI translated pointer in this predecessor. This can fail if
1271  // not translatable, in which case the getAddr() returns null.
1272  PHITransAddr &PredPointer = PredList.back().second;
1273  PredPointer.PHITranslateValue(BB, Pred, DT, /*MustDominate=*/false);
1274  Value *PredPtrVal = PredPointer.getAddr();
1275 
1276  // Check to see if we have already visited this pred block with another
1277  // pointer. If so, we can't do this lookup. This failure can occur
1278  // with PHI translation when a critical edge exists and the PHI node in
1279  // the successor translates to a pointer value different than the
1280  // pointer the block was first analyzed with.
1281  std::pair<DenseMap<BasicBlock*,Value*>::iterator, bool>
1282  InsertRes = Visited.insert(std::make_pair(Pred, PredPtrVal));
1283 
1284  if (!InsertRes.second) {
1285  // We found the pred; take it off the list of preds to visit.
1286  PredList.pop_back();
1287 
1288  // If the predecessor was visited with PredPtr, then we already did
1289  // the analysis and can ignore it.
1290  if (InsertRes.first->second == PredPtrVal)
1291  continue;
1292 
1293  // Otherwise, the block was previously analyzed with a different
1294  // pointer. We can't represent the result of this case, so we just
1295  // treat this as a phi translation failure.
1296 
1297  // Make sure to clean up the Visited map before continuing on to
1298  // PredTranslationFailure.
1299  for (unsigned i = 0, n = PredList.size(); i < n; ++i)
1300  Visited.erase(PredList[i].first);
1301 
1302  goto PredTranslationFailure;
1303  }
1304  }
1305 
1306  // Actually process results here; this need to be a separate loop to avoid
1307  // calling getNonLocalPointerDepFromBB for blocks we don't want to return
1308  // any results for. (getNonLocalPointerDepFromBB will modify our
1309  // datastructures in ways the code after the PredTranslationFailure label
1310  // doesn't expect.)
1311  for (unsigned i = 0, n = PredList.size(); i < n; ++i) {
1312  BasicBlock *Pred = PredList[i].first;
1313  PHITransAddr &PredPointer = PredList[i].second;
1314  Value *PredPtrVal = PredPointer.getAddr();
1315 
1316  bool CanTranslate = true;
1317  // If PHI translation was unable to find an available pointer in this
1318  // predecessor, then we have to assume that the pointer is clobbered in
1319  // that predecessor. We can still do PRE of the load, which would insert
1320  // a computation of the pointer in this predecessor.
1321  if (!PredPtrVal)
1322  CanTranslate = false;
1323 
1324  // FIXME: it is entirely possible that PHI translating will end up with
1325  // the same value. Consider PHI translating something like:
1326  // X = phi [x, bb1], [y, bb2]. PHI translating for bb1 doesn't *need*
1327  // to recurse here, pedantically speaking.
1328 
1329  // If getNonLocalPointerDepFromBB fails here, that means the cached
1330  // result conflicted with the Visited list; we have to conservatively
1331  // assume it is unknown, but this also does not block PRE of the load.
1332  if (!CanTranslate ||
1333  getNonLocalPointerDepFromBB(QueryInst, PredPointer,
1334  Loc.getWithNewPtr(PredPtrVal),
1335  isLoad, Pred,
1336  Result, Visited)) {
1337  // Add the entry to the Result list.
1338  NonLocalDepResult Entry(Pred, MemDepResult::getUnknown(), PredPtrVal);
1339  Result.push_back(Entry);
1340 
1341  // Since we had a phi translation failure, the cache for CacheKey won't
1342  // include all of the entries that we need to immediately satisfy future
1343  // queries. Mark this in NonLocalPointerDeps by setting the
1344  // BBSkipFirstBlockPair pointer to null. This requires reuse of the
1345  // cached value to do more work but not miss the phi trans failure.
1346  NonLocalPointerInfo &NLPI = NonLocalPointerDeps[CacheKey];
1347  NLPI.Pair = BBSkipFirstBlockPair();
1348  continue;
1349  }
1350  }
1351 
1352  // Refresh the CacheInfo/Cache pointer so that it isn't invalidated.
1353  CacheInfo = &NonLocalPointerDeps[CacheKey];
1354  Cache = &CacheInfo->NonLocalDeps;
1355  NumSortedEntries = Cache->size();
1356 
1357  // Since we did phi translation, the "Cache" set won't contain all of the
1358  // results for the query. This is ok (we can still use it to accelerate
1359  // specific block queries) but we can't do the fastpath "return all
1360  // results from the set" Clear out the indicator for this.
1361  CacheInfo->Pair = BBSkipFirstBlockPair();
1362  SkipFirstBlock = false;
1363  continue;
1364 
1365  PredTranslationFailure:
1366  // The following code is "failure"; we can't produce a sane translation
1367  // for the given block. It assumes that we haven't modified any of
1368  // our datastructures while processing the current block.
1369 
1370  if (!Cache) {
1371  // Refresh the CacheInfo/Cache pointer if it got invalidated.
1372  CacheInfo = &NonLocalPointerDeps[CacheKey];
1373  Cache = &CacheInfo->NonLocalDeps;
1374  NumSortedEntries = Cache->size();
1375  }
1376 
1377  // Since we failed phi translation, the "Cache" set won't contain all of the
1378  // results for the query. This is ok (we can still use it to accelerate
1379  // specific block queries) but we can't do the fastpath "return all
1380  // results from the set". Clear out the indicator for this.
1381  CacheInfo->Pair = BBSkipFirstBlockPair();
1382 
1383  // If *nothing* works, mark the pointer as unknown.
1384  //
1385  // If this is the magic first block, return this as a clobber of the whole
1386  // incoming value. Since we can't phi translate to one of the predecessors,
1387  // we have to bail out.
1388  if (SkipFirstBlock)
1389  return true;
1390 
1391  for (NonLocalDepInfo::reverse_iterator I = Cache->rbegin(); ; ++I) {
1392  assert(I != Cache->rend() && "Didn't find current block??");
1393  if (I->getBB() != BB)
1394  continue;
1395 
1396  assert((I->getResult().isNonLocal() || !DT->isReachableFromEntry(BB)) &&
1397  "Should only be here with transparent block");
1398  I->setResult(MemDepResult::getUnknown());
1399  Result.push_back(NonLocalDepResult(I->getBB(), I->getResult(),
1400  Pointer.getAddr()));
1401  break;
1402  }
1403  }
1404 
1405  // Okay, we're done now. If we added new values to the cache, re-sort it.
1406  SortNonLocalDepInfoCache(*Cache, NumSortedEntries);
1407  DEBUG(AssertSorted(*Cache));
1408  return false;
1409 }
1410 
1411 /// RemoveCachedNonLocalPointerDependencies - If P exists in
1412 /// CachedNonLocalPointerInfo, remove it.
1413 void MemoryDependenceAnalysis::
1414 RemoveCachedNonLocalPointerDependencies(ValueIsLoadPair P) {
1416  NonLocalPointerDeps.find(P);
1417  if (It == NonLocalPointerDeps.end()) return;
1418 
1419  // Remove all of the entries in the BB->val map. This involves removing
1420  // instructions from the reverse map.
1421  NonLocalDepInfo &PInfo = It->second.NonLocalDeps;
1422 
1423  for (unsigned i = 0, e = PInfo.size(); i != e; ++i) {
1424  Instruction *Target = PInfo[i].getResult().getInst();
1425  if (!Target) continue; // Ignore non-local dep results.
1426  assert(Target->getParent() == PInfo[i].getBB());
1427 
1428  // Eliminating the dirty entry from 'Cache', so update the reverse info.
1429  RemoveFromReverseMap(ReverseNonLocalPtrDeps, Target, P);
1430  }
1431 
1432  // Remove P from NonLocalPointerDeps (which deletes NonLocalDepInfo).
1433  NonLocalPointerDeps.erase(It);
1434 }
1435 
1436 
1437 /// invalidateCachedPointerInfo - This method is used to invalidate cached
1438 /// information about the specified pointer, because it may be too
1439 /// conservative in memdep. This is an optional call that can be used when
1440 /// the client detects an equivalence between the pointer and some other
1441 /// value and replaces the other value with ptr. This can make Ptr available
1442 /// in more places that cached info does not necessarily keep.
1444  // If Ptr isn't really a pointer, just ignore it.
1445  if (!Ptr->getType()->isPointerTy()) return;
1446  // Flush store info for the pointer.
1447  RemoveCachedNonLocalPointerDependencies(ValueIsLoadPair(Ptr, false));
1448  // Flush load info for the pointer.
1449  RemoveCachedNonLocalPointerDependencies(ValueIsLoadPair(Ptr, true));
1450 }
1451 
1452 /// invalidateCachedPredecessors - Clear the PredIteratorCache info.
1453 /// This needs to be done when the CFG changes, e.g., due to splitting
1454 /// critical edges.
1456  PredCache.clear();
1457 }
1458 
1459 /// removeInstruction - Remove an instruction from the dependence analysis,
1460 /// updating the dependence of instructions that previously depended on it.
1461 /// This method attempts to keep the cache coherent using the reverse map.
1463  // Walk through the Non-local dependencies, removing this one as the value
1464  // for any cached queries.
1465  NonLocalDepMapType::iterator NLDI = NonLocalDeps.find(RemInst);
1466  if (NLDI != NonLocalDeps.end()) {
1467  NonLocalDepInfo &BlockMap = NLDI->second.first;
1468  for (NonLocalDepInfo::iterator DI = BlockMap.begin(), DE = BlockMap.end();
1469  DI != DE; ++DI)
1470  if (Instruction *Inst = DI->getResult().getInst())
1471  RemoveFromReverseMap(ReverseNonLocalDeps, Inst, RemInst);
1472  NonLocalDeps.erase(NLDI);
1473  }
1474 
1475  // If we have a cached local dependence query for this instruction, remove it.
1476  //
1477  LocalDepMapType::iterator LocalDepEntry = LocalDeps.find(RemInst);
1478  if (LocalDepEntry != LocalDeps.end()) {
1479  // Remove us from DepInst's reverse set now that the local dep info is gone.
1480  if (Instruction *Inst = LocalDepEntry->second.getInst())
1481  RemoveFromReverseMap(ReverseLocalDeps, Inst, RemInst);
1482 
1483  // Remove this local dependency info.
1484  LocalDeps.erase(LocalDepEntry);
1485  }
1486 
1487  // If we have any cached pointer dependencies on this instruction, remove
1488  // them. If the instruction has non-pointer type, then it can't be a pointer
1489  // base.
1490 
1491  // Remove it from both the load info and the store info. The instruction
1492  // can't be in either of these maps if it is non-pointer.
1493  if (RemInst->getType()->isPointerTy()) {
1494  RemoveCachedNonLocalPointerDependencies(ValueIsLoadPair(RemInst, false));
1495  RemoveCachedNonLocalPointerDependencies(ValueIsLoadPair(RemInst, true));
1496  }
1497 
1498  // Loop over all of the things that depend on the instruction we're removing.
1499  //
1501 
1502  // If we find RemInst as a clobber or Def in any of the maps for other values,
1503  // we need to replace its entry with a dirty version of the instruction after
1504  // it. If RemInst is a terminator, we use a null dirty value.
1505  //
1506  // Using a dirty version of the instruction after RemInst saves having to scan
1507  // the entire block to get to this point.
1508  MemDepResult NewDirtyVal;
1509  if (!RemInst->isTerminator())
1510  NewDirtyVal = MemDepResult::getDirty(++BasicBlock::iterator(RemInst));
1511 
1512  ReverseDepMapType::iterator ReverseDepIt = ReverseLocalDeps.find(RemInst);
1513  if (ReverseDepIt != ReverseLocalDeps.end()) {
1514  // RemInst can't be the terminator if it has local stuff depending on it.
1515  assert(!ReverseDepIt->second.empty() && !isa<TerminatorInst>(RemInst) &&
1516  "Nothing can locally depend on a terminator");
1517 
1518  for (Instruction *InstDependingOnRemInst : ReverseDepIt->second) {
1519  assert(InstDependingOnRemInst != RemInst &&
1520  "Already removed our local dep info");
1521 
1522  LocalDeps[InstDependingOnRemInst] = NewDirtyVal;
1523 
1524  // Make sure to remember that new things depend on NewDepInst.
1525  assert(NewDirtyVal.getInst() && "There is no way something else can have "
1526  "a local dep on this if it is a terminator!");
1527  ReverseDepsToAdd.push_back(std::make_pair(NewDirtyVal.getInst(),
1528  InstDependingOnRemInst));
1529  }
1530 
1531  ReverseLocalDeps.erase(ReverseDepIt);
1532 
1533  // Add new reverse deps after scanning the set, to avoid invalidating the
1534  // 'ReverseDeps' reference.
1535  while (!ReverseDepsToAdd.empty()) {
1536  ReverseLocalDeps[ReverseDepsToAdd.back().first]
1537  .insert(ReverseDepsToAdd.back().second);
1538  ReverseDepsToAdd.pop_back();
1539  }
1540  }
1541 
1542  ReverseDepIt = ReverseNonLocalDeps.find(RemInst);
1543  if (ReverseDepIt != ReverseNonLocalDeps.end()) {
1544  for (Instruction *I : ReverseDepIt->second) {
1545  assert(I != RemInst && "Already removed NonLocalDep info for RemInst");
1546 
1547  PerInstNLInfo &INLD = NonLocalDeps[I];
1548  // The information is now dirty!
1549  INLD.second = true;
1550 
1551  for (NonLocalDepInfo::iterator DI = INLD.first.begin(),
1552  DE = INLD.first.end(); DI != DE; ++DI) {
1553  if (DI->getResult().getInst() != RemInst) continue;
1554 
1555  // Convert to a dirty entry for the subsequent instruction.
1556  DI->setResult(NewDirtyVal);
1557 
1558  if (Instruction *NextI = NewDirtyVal.getInst())
1559  ReverseDepsToAdd.push_back(std::make_pair(NextI, I));
1560  }
1561  }
1562 
1563  ReverseNonLocalDeps.erase(ReverseDepIt);
1564 
1565  // Add new reverse deps after scanning the set, to avoid invalidating 'Set'
1566  while (!ReverseDepsToAdd.empty()) {
1567  ReverseNonLocalDeps[ReverseDepsToAdd.back().first]
1568  .insert(ReverseDepsToAdd.back().second);
1569  ReverseDepsToAdd.pop_back();
1570  }
1571  }
1572 
1573  // If the instruction is in ReverseNonLocalPtrDeps then it appears as a
1574  // value in the NonLocalPointerDeps info.
1575  ReverseNonLocalPtrDepTy::iterator ReversePtrDepIt =
1576  ReverseNonLocalPtrDeps.find(RemInst);
1577  if (ReversePtrDepIt != ReverseNonLocalPtrDeps.end()) {
1579 
1580  for (ValueIsLoadPair P : ReversePtrDepIt->second) {
1581  assert(P.getPointer() != RemInst &&
1582  "Already removed NonLocalPointerDeps info for RemInst");
1583 
1584  NonLocalDepInfo &NLPDI = NonLocalPointerDeps[P].NonLocalDeps;
1585 
1586  // The cache is not valid for any specific block anymore.
1587  NonLocalPointerDeps[P].Pair = BBSkipFirstBlockPair();
1588 
1589  // Update any entries for RemInst to use the instruction after it.
1590  for (NonLocalDepInfo::iterator DI = NLPDI.begin(), DE = NLPDI.end();
1591  DI != DE; ++DI) {
1592  if (DI->getResult().getInst() != RemInst) continue;
1593 
1594  // Convert to a dirty entry for the subsequent instruction.
1595  DI->setResult(NewDirtyVal);
1596 
1597  if (Instruction *NewDirtyInst = NewDirtyVal.getInst())
1598  ReversePtrDepsToAdd.push_back(std::make_pair(NewDirtyInst, P));
1599  }
1600 
1601  // Re-sort the NonLocalDepInfo. Changing the dirty entry to its
1602  // subsequent value may invalidate the sortedness.
1603  std::sort(NLPDI.begin(), NLPDI.end());
1604  }
1605 
1606  ReverseNonLocalPtrDeps.erase(ReversePtrDepIt);
1607 
1608  while (!ReversePtrDepsToAdd.empty()) {
1609  ReverseNonLocalPtrDeps[ReversePtrDepsToAdd.back().first]
1610  .insert(ReversePtrDepsToAdd.back().second);
1611  ReversePtrDepsToAdd.pop_back();
1612  }
1613  }
1614 
1615 
1616  assert(!NonLocalDeps.count(RemInst) && "RemInst got reinserted?");
1617  AA->deleteValue(RemInst);
1618  DEBUG(verifyRemoved(RemInst));
1619 }
1620 /// verifyRemoved - Verify that the specified instruction does not occur
1621 /// in our internal data structures. This function verifies by asserting in
1622 /// debug builds.
1623 void MemoryDependenceAnalysis::verifyRemoved(Instruction *D) const {
1624 #ifndef NDEBUG
1625  for (LocalDepMapType::const_iterator I = LocalDeps.begin(),
1626  E = LocalDeps.end(); I != E; ++I) {
1627  assert(I->first != D && "Inst occurs in data structures");
1628  assert(I->second.getInst() != D &&
1629  "Inst occurs in data structures");
1630  }
1631 
1632  for (CachedNonLocalPointerInfo::const_iterator I =NonLocalPointerDeps.begin(),
1633  E = NonLocalPointerDeps.end(); I != E; ++I) {
1634  assert(I->first.getPointer() != D && "Inst occurs in NLPD map key");
1635  const NonLocalDepInfo &Val = I->second.NonLocalDeps;
1636  for (NonLocalDepInfo::const_iterator II = Val.begin(), E = Val.end();
1637  II != E; ++II)
1638  assert(II->getResult().getInst() != D && "Inst occurs as NLPD value");
1639  }
1640 
1641  for (NonLocalDepMapType::const_iterator I = NonLocalDeps.begin(),
1642  E = NonLocalDeps.end(); I != E; ++I) {
1643  assert(I->first != D && "Inst occurs in data structures");
1644  const PerInstNLInfo &INLD = I->second;
1645  for (NonLocalDepInfo::const_iterator II = INLD.first.begin(),
1646  EE = INLD.first.end(); II != EE; ++II)
1647  assert(II->getResult().getInst() != D && "Inst occurs in data structures");
1648  }
1649 
1650  for (ReverseDepMapType::const_iterator I = ReverseLocalDeps.begin(),
1651  E = ReverseLocalDeps.end(); I != E; ++I) {
1652  assert(I->first != D && "Inst occurs in data structures");
1653  for (Instruction *Inst : I->second)
1654  assert(Inst != D && "Inst occurs in data structures");
1655  }
1656 
1657  for (ReverseDepMapType::const_iterator I = ReverseNonLocalDeps.begin(),
1658  E = ReverseNonLocalDeps.end();
1659  I != E; ++I) {
1660  assert(I->first != D && "Inst occurs in data structures");
1661  for (Instruction *Inst : I->second)
1662  assert(Inst != D && "Inst occurs in data structures");
1663  }
1664 
1666  I = ReverseNonLocalPtrDeps.begin(),
1667  E = ReverseNonLocalPtrDeps.end(); I != E; ++I) {
1668  assert(I->first != D && "Inst occurs in rev NLPD map");
1669 
1670  for (ValueIsLoadPair P : I->second)
1671  assert(P != ValueIsLoadPair(D, false) &&
1672  P != ValueIsLoadPair(D, true) &&
1673  "Inst occurs in ReverseNonLocalPtrDeps map");
1674  }
1675 #endif
1676 }
The two locations precisely alias each other.
Definition: AliasAnalysis.h:84
static AliasAnalysis::ModRefResult GetLocation(const Instruction *Inst, MemoryLocation &Loc, AliasAnalysis *AA)
GetLocation - If the given instruction references a specific memory location, fill in Loc with the de...
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:104
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
void invalidateCachedPointerInfo(Value *Ptr)
invalidateCachedPointerInfo - This method is used to invalidate cached information about the specifie...
bool isDef() const
isDef - Return true if this MemDepResult represents a query that is an instruction definition depende...
STATISTIC(NumFunctions,"Total number of functions")
static void Found()
ModRefResult callCapturesBefore(const Instruction *I, const MemoryLocation &MemLoc, DominatorTree *DT)
callCapturesBefore - Return information about whether a particular call site modifies or reads the sp...
InstrTy * getInstruction() const
Definition: CallSite.h:82
AtomicCmpXchgInst - an instruction that atomically checks whether a specified value is in a memory lo...
Definition: Instructions.h:515
static void RemoveFromReverseMap(DenseMap< Instruction *, SmallPtrSet< KeyTy, 4 > > &ReverseMap, Instruction *Inst, KeyTy Val)
RemoveFromReverseMap - This is a helper function that removes Val from 'Inst's set in ReverseMap...
This class provides various memory handling functions that manipulate MemoryBlock instances...
Definition: Memory.h:45
The two locations alias, but only due to a partial overlap.
Definition: AliasAnalysis.h:82
CallInst - This class represents a function call, abstracting a target machine's calling convention...
static void AssertSorted(MemoryDependenceAnalysis::NonLocalDepInfo &Cache, int Count=-1)
AssertSorted - This method is used when -debug is specified to verify that cache arrays are properly ...
An immutable pass that tracks lazily created AssumptionCache objects.
const Function * getParent() const
Return the enclosing method, or null if none.
Definition: BasicBlock.h:111
The two locations do not alias at all.
Definition: AliasAnalysis.h:78
F(f)
LoadInst - an instruction for reading from memory.
Definition: Instructions.h:177
bool isSimple() const
Definition: Instructions.h:279
bool isClobber() const
isClobber - Return true if this MemDepResult represents a query that is an instruction clobber depend...
MemoryLocation getWithNewSize(uint64_t NewSize) const
virtual bool pointsToConstantMemory(const MemoryLocation &Loc, bool OrLocal=false)
pointsToConstantMemory - If the specified memory location is known to be constant, return true.
const CallInst * isFreeCall(const Value *I, const TargetLibraryInfo *TLI)
isFreeCall - Returns non-null if the value is a call to the builtin free()
bool isMustAlias(const MemoryLocation &LocA, const MemoryLocation &LocB)
isMustAlias - A convenience wrapper.
iterator begin()
Instruction iterator methods.
Definition: BasicBlock.h:231
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
Definition: DenseMap.h:169
AnalysisUsage & addRequired()
ArrayRef< BasicBlock * > get(BasicBlock *BB)
#define INITIALIZE_PASS_DEPENDENCY(depName)
Definition: PassSupport.h:70
bool NeedsPHITranslationFromBlock(BasicBlock *BB) const
NeedsPHITranslationFromBlock - Return true if moving from the specified BasicBlock to its predecessor...
Definition: PHITransAddr.h:63
MemoryLocation getWithoutAATags() const
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
bool runOnFunction(Function &) override
Pass Implementation stuff. This doesn't do any analysis eagerly.
T LLVM_ATTRIBUTE_UNUSED_RESULT pop_back_val()
Definition: SmallVector.h:406
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APInt.h:33
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:75
static MemDepResult getDef(Instruction *Inst)
get methods: These are static ctor methods for creating various MemDepResult kinds.
MemoryLocation getWithNewPtr(const Value *NewPtr) const
MemoryDependenceAnalysis - This is an analysis that determines, for a given memory operation...
DominatorTree & getDomTree()
Definition: Dominators.h:213
bool isNoAliasFn(const Value *V, const TargetLibraryInfo *TLI, bool LookThroughBitCast=false)
Tests if a value is a call or invoke to a function that returns a NoAlias pointer (including malloc/c...
bool mayReadFromMemory() const
mayReadFromMemory - Return true if this instruction may read memory.
void releaseMemory() override
Clean up memory in between runs.
bool LLVM_ATTRIBUTE_UNUSED_RESULT empty() const
Definition: SmallVector.h:57
Value * GetPointerBaseWithConstantOffset(Value *Ptr, int64_t &Offset, const DataLayout &DL)
GetPointerBaseWithConstantOffset - Analyze the specified pointer to see if it can be expressed as a b...
bool isReachableFromEntry(const Use &U) const
Provide an overload for a Use.
Definition: Dominators.cpp:265
StoreInst - an instruction for storing to memory.
Definition: Instructions.h:316
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - Does not modify anything.
bool onlyReadsMemory(ImmutableCallSite CS)
onlyReadsMemory - If the specified call is known to only read from non-volatile memory (or not access...
bool mayReadOrWriteMemory() const
mayReadOrWriteMemory - Return true if this instruction may read or write memory.
Definition: Instruction.h:362
static MemDepResult getUnknown()
MemDepResult getPointerDependencyFrom(const MemoryLocation &Loc, bool isLoad, BasicBlock::iterator ScanIt, BasicBlock *BB, Instruction *QueryInst=nullptr)
getPointerDependencyFrom - Return the instruction on which a memory location depends.
#define P(N)
static MemoryLocation get(const LoadInst *LI)
Return a location with information about the memory reference by the given instruction.
#define true
Definition: ConvertUTF.c:66
bool isIdenticalToWhenDefined(const Instruction *I) const
isIdenticalToWhenDefined - This is like isIdenticalTo, except that it ignores the SubclassOptionalDat...
LLVM Basic Block Representation.
Definition: BasicBlock.h:65
PointerIntPair - This class implements a pair of a pointer and small integer.
PHITransAddr - An address value which tracks and handles phi translation.
Definition: PHITransAddr.h:36
size_type size() const
Definition: SmallPtrSet.h:79
NonLocalDepResult - This is a result from a NonLocal dependence query.
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:264
AliasResult
The possible results of an alias query.
Definition: AliasAnalysis.h:72
Represent the analysis usage information of a pass.
static MemDepResult getNonFuncLocal()
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:294
Value * getPointerOperand()
Definition: Instructions.h:284
const MemDepResult & getResult() const
Class to represent integer types.
Definition: DerivedTypes.h:37
void setResult(const MemDepResult &R)
#define INITIALIZE_AG_DEPENDENCY(depName)
Definition: PassSupport.h:72
void append(in_iter in_start, in_iter in_end)
Add the specified range to the end of the SmallVector.
Definition: SmallVector.h:416
bool isPointerTy() const
isPointerTy - True if this is an instance of PointerType.
Definition: Type.h:217
uint64_t NextPowerOf2(uint64_t A)
NextPowerOf2 - Returns the next power of two (in 64-bits) that is strictly greater than A...
Definition: MathExtras.h:582
VAArgInst - This class represents the va_arg llvm instruction, which returns an argument of the speci...
virtual void deleteValue(Value *V)
Methods that clients should call when they transform the program to allow alias analyses to update th...
Value * GetUnderlyingObject(Value *V, const DataLayout &DL, unsigned MaxLookup=6)
GetUnderlyingObject - This method strips off any GEP address adjustments and pointer casts from the s...
bool IsPotentiallyPHITranslatable() const
IsPotentiallyPHITranslatable - If this needs PHI translation, return true if we have some hope of doi...
bool mayWriteToMemory() const
mayWriteToMemory - Return true if this instruction may modify memory.
MemDepResult - A memory dependence query can return one of three different answers, described below.
void clear()
clear - Remove all information.
bool isTerminator() const
Definition: Instruction.h:115
const Value * Ptr
The address of the start of the location.
Representation for a specific memory location.
PointerTy getPointer() const
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements...
Definition: SmallPtrSet.h:299
bool fitsInLegalInteger(unsigned Width) const
Returns true if the specified type fits in a native integer type supported by the CPU...
Definition: DataLayout.h:304
iterator end()
Definition: BasicBlock.h:233
bool PHITranslateValue(BasicBlock *CurBB, BasicBlock *PredBB, const DominatorTree *DT, bool MustDominate)
PHITranslateValue - PHI translate the current address up the CFG from CurBB to Pred, updating our state to reflect any needed changes.
virtual AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB)
Alias Queries...
const Module * getModule() const
Return the module owning the function this instruction belongs to or nullptr it the function does not...
Definition: Instruction.cpp:57
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:861
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:222
static const unsigned int BlockScanLimit
Provides information about what library functions are available for the current target.
static MemDepResult getClobber(Instruction *Inst)
MDNode * getMetadata(unsigned KindID) const
getMetadata - Get the metadata of given kind attached to this Instruction.
Definition: Instruction.h:167
ModRefResult getModRefInfo(const Instruction *I)
getModRefInfo - Return information about whether or not an instruction may read or write memory (with...
A collection of metadata nodes that might be associated with a memory access used by the alias-analys...
Definition: Metadata.h:548
bool isNonLocal() const
isNonLocal - Return true if this MemDepResult represents a query that is transparent to the start of ...
std::vector< NonLocalDepEntry > NonLocalDepInfo
const BasicBlock & getEntryBlock() const
Definition: Function.h:442
size_type count(const KeyT &Val) const
Return 1 if the specified key is in the map, 0 otherwise.
Definition: DenseMap.h:119
Target - Wrapper for Target specific information.
void setPreservesAll()
Set by analyses that do not transform their input at all.
LLVM_ATTRIBUTE_UNUSED_RESULT 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:285
bool isMallocLikeFn(const Value *V, const TargetLibraryInfo *TLI, bool LookThroughBitCast=false)
Tests if a value is a call or invoke to a library function that allocates uninitialized memory (such ...
INITIALIZE_PASS_BEGIN(MemoryDependenceAnalysis,"memdep","Memory Dependence Analysis", false, true) INITIALIZE_PASS_END(MemoryDependenceAnalysis
ThreadSanitizer is on.
Definition: Attributes.h:116
void initializeMemoryDependenceAnalysisPass(PassRegistry &)
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
Definition: Module.cpp:372
Instruction * getInst() const
getInst() - If this is a normal dependency, return the instruction that is depended on...
AAMDNodes AATags
The metadata nodes which describes the aliasing of the location (each member is null if that kind of ...
static void SortNonLocalDepInfoCache(MemoryDependenceAnalysis::NonLocalDepInfo &Cache, unsigned NumSortedEntries)
SortNonLocalDepInfoCache - Sort the NonLocalDepInfo cache, given a certain number of elements in the ...
bool hasFnAttribute(Attribute::AttrKind Kind) const
Return true if the function has the attribute.
Definition: Function.h:217
MemDepResult getDependency(Instruction *QueryInst)
getDependency - Return the instruction on which a memory operation depends.
iterator begin()
Definition: DenseMap.h:64
void invalidateCachedPredecessors()
invalidateCachedPredecessors - Clear the PredIteratorCache info.
unsigned getAlignment() const
getAlignment - Return the alignment of the access that is being performed
Definition: Instructions.h:243
Memory Dependence false
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...
AddressSanitizer is on.
Definition: Attributes.h:115
#define I(x, y, z)
Definition: MD5.cpp:54
iterator find(const KeyT &Val)
Definition: DenseMap.h:124
const NonLocalDepInfo & getNonLocalCallDependency(CallSite QueryCS)
getNonLocalCallDependency - Perform a full dependency query for the specified call, returning the set of blocks that the value is potentially live across.
AnalysisUsage & addRequiredTransitive()
Memory Dependence Analysis
unsigned getPrimitiveSizeInBits() const LLVM_READONLY
getPrimitiveSizeInBits - Return the basic size of this type if it is a primitive type.
Definition: Type.cpp:121
LLVM Value Representation.
Definition: Value.h:69
ModRefResult
Simple mod/ref information...
#define DEBUG(X)
Definition: Debug.h:92
const TargetLibraryInfo * getTargetLibraryInfo() const
getTargetLibraryInfo - Return a pointer to the current TargetLibraryInfo object, or null if no Target...
NonLocalDepEntry - This is an entry in the NonLocalDepInfo cache.
static bool isLoadLoadClobberIfExtendedToFullWidth(const MemoryLocation &MemLoc, const Value *&MemLocBase, int64_t &MemLocOffs, const LoadInst *LI)
isLoadLoadClobberIfExtendedToFullWidth - Return true if LI is a load that would fully overlap MemLoc ...
Legacy analysis pass which computes a DominatorTree.
Definition: Dominators.h:203
static bool isVolatile(Instruction *Inst)
Dependence - This class represents a dependence between two memory memory references in a function...
Value * getAddr() const
Definition: PHITransAddr.h:59
static MemDepResult getNonLocal()
static unsigned getLoadLoadClobberFullWidthSize(const Value *MemLocBase, int64_t MemLocOffs, unsigned MemLocSize, const LoadInst *LI)
getLoadLoadClobberFullWidthSize - This is a little bit of analysis that looks at a memory location fo...
static const unsigned int NumResultsLimit
const BasicBlock * getParent() const
Definition: Instruction.h:72
void removeInstruction(Instruction *InstToRemove)
removeInstruction - Remove an instruction from the dependence analysis, updating the dependence of in...
void getNonLocalPointerDependency(Instruction *QueryInst, SmallVectorImpl< NonLocalDepResult > &Result)
getNonLocalPointerDependency - Perform a full dependency query for an access to the QueryInst's speci...
IntrinsicInst - A useful wrapper class for inspecting calls to intrinsic functions.
Definition: IntrinsicInst.h:37
uint64_t Size
The maximum size of the location, in address-units, or UnknownSize if the size is not known...