LLVM  14.0.0git
AliasAnalysis.cpp
Go to the documentation of this file.
1 //==- AliasAnalysis.cpp - Generic Alias Analysis Interface Implementation --==//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements the generic AliasAnalysis interface which is used as the
10 // common interface used by all clients and implementations of alias analysis.
11 //
12 // This file also implements the default version of the AliasAnalysis interface
13 // that is to be used when no other implementation is specified. This does some
14 // simple tests that detect obvious cases: two different global pointers cannot
15 // alias, a global cannot alias a malloc, two different mallocs cannot alias,
16 // etc.
17 //
18 // This alias analysis implementation really isn't very good for anything, but
19 // it is very fast, and makes a nice clean default implementation. Because it
20 // handles lots of little corner cases, other, more complex, alias analysis
21 // implementations may choose to rely on this pass to resolve these simple and
22 // easy cases.
23 //
24 //===----------------------------------------------------------------------===//
25 
27 #include "llvm/ADT/Statistic.h"
40 #include "llvm/IR/Argument.h"
41 #include "llvm/IR/Attributes.h"
42 #include "llvm/IR/BasicBlock.h"
43 #include "llvm/IR/Instruction.h"
44 #include "llvm/IR/Instructions.h"
45 #include "llvm/IR/Module.h"
46 #include "llvm/IR/Type.h"
47 #include "llvm/IR/Value.h"
48 #include "llvm/InitializePasses.h"
49 #include "llvm/Pass.h"
51 #include "llvm/Support/Casting.h"
53 #include <algorithm>
54 #include <cassert>
55 #include <functional>
56 #include <iterator>
57 
58 #define DEBUG_TYPE "aa"
59 
60 using namespace llvm;
61 
62 STATISTIC(NumNoAlias, "Number of NoAlias results");
63 STATISTIC(NumMayAlias, "Number of MayAlias results");
64 STATISTIC(NumMustAlias, "Number of MustAlias results");
65 
66 namespace llvm {
67 /// Allow disabling BasicAA from the AA results. This is particularly useful
68 /// when testing to isolate a single AA implementation.
69 cl::opt<bool> DisableBasicAA("disable-basic-aa", cl::Hidden, cl::init(false));
70 } // namespace llvm
71 
72 #ifndef NDEBUG
73 /// Print a trace of alias analysis queries and their results.
74 static cl::opt<bool> EnableAATrace("aa-trace", cl::Hidden, cl::init(false));
75 #else
76 static const bool EnableAATrace = false;
77 #endif
78 
80  : TLI(Arg.TLI), AAs(std::move(Arg.AAs)), AADeps(std::move(Arg.AADeps)) {
81  for (auto &AA : AAs)
82  AA->setAAResults(this);
83 }
84 
86 // FIXME; It would be nice to at least clear out the pointers back to this
87 // aggregation here, but we end up with non-nesting lifetimes in the legacy
88 // pass manager that prevent this from working. In the legacy pass manager
89 // we'll end up with dangling references here in some cases.
90 #if 0
91  for (auto &AA : AAs)
92  AA->setAAResults(nullptr);
93 #endif
94 }
95 
98  // AAResults preserves the AAManager by default, due to the stateless nature
99  // of AliasAnalysis. There is no need to check whether it has been preserved
100  // explicitly. Check if any module dependency was invalidated and caused the
101  // AAManager to be invalidated. Invalidate ourselves in that case.
102  auto PAC = PA.getChecker<AAManager>();
103  if (!PAC.preservedWhenStateless())
104  return true;
105 
106  // Check if any of the function dependencies were invalidated, and invalidate
107  // ourselves in that case.
108  for (AnalysisKey *ID : AADeps)
109  if (Inv.invalidate(ID, F, PA))
110  return true;
111 
112  // Everything we depend on is still fine, so are we. Nothing to invalidate.
113  return false;
114 }
115 
116 //===----------------------------------------------------------------------===//
117 // Default chaining methods
118 //===----------------------------------------------------------------------===//
119 
121  const MemoryLocation &LocB) {
122  SimpleAAQueryInfo AAQIP;
123  return alias(LocA, LocB, AAQIP);
124 }
125 
127  const MemoryLocation &LocB, AAQueryInfo &AAQI) {
129 
130  if (EnableAATrace) {
131  for (unsigned I = 0; I < AAQI.Depth; ++I)
132  dbgs() << " ";
133  dbgs() << "Start " << *LocA.Ptr << " @ " << LocA.Size << ", "
134  << *LocB.Ptr << " @ " << LocB.Size << "\n";
135  }
136 
137  AAQI.Depth++;
138  for (const auto &AA : AAs) {
139  Result = AA->alias(LocA, LocB, AAQI);
140  if (Result != AliasResult::MayAlias)
141  break;
142  }
143  AAQI.Depth--;
144 
145  if (EnableAATrace) {
146  for (unsigned I = 0; I < AAQI.Depth; ++I)
147  dbgs() << " ";
148  dbgs() << "End " << *LocA.Ptr << " @ " << LocA.Size << ", "
149  << *LocB.Ptr << " @ " << LocB.Size << " = " << Result << "\n";
150  }
151 
152  if (AAQI.Depth == 0) {
153  if (Result == AliasResult::NoAlias)
154  ++NumNoAlias;
155  else if (Result == AliasResult::MustAlias)
156  ++NumMustAlias;
157  else
158  ++NumMayAlias;
159  }
160  return Result;
161 }
162 
164  bool OrLocal) {
165  SimpleAAQueryInfo AAQIP;
166  return pointsToConstantMemory(Loc, AAQIP, OrLocal);
167 }
168 
170  AAQueryInfo &AAQI, bool OrLocal) {
171  for (const auto &AA : AAs)
172  if (AA->pointsToConstantMemory(Loc, AAQI, OrLocal))
173  return true;
174 
175  return false;
176 }
177 
178 ModRefInfo AAResults::getArgModRefInfo(const CallBase *Call, unsigned ArgIdx) {
180 
181  for (const auto &AA : AAs) {
182  Result = intersectModRef(Result, AA->getArgModRefInfo(Call, ArgIdx));
183 
184  // Early-exit the moment we reach the bottom of the lattice.
185  if (isNoModRef(Result))
186  return ModRefInfo::NoModRef;
187  }
188 
189  return Result;
190 }
191 
193  SimpleAAQueryInfo AAQIP;
194  return getModRefInfo(I, Call2, AAQIP);
195 }
196 
198  AAQueryInfo &AAQI) {
199  // We may have two calls.
200  if (const auto *Call1 = dyn_cast<CallBase>(I)) {
201  // Check if the two calls modify the same memory.
202  return getModRefInfo(Call1, Call2, AAQI);
203  }
204  // If this is a fence, just return ModRef.
205  if (I->isFenceLike())
206  return ModRefInfo::ModRef;
207  // Otherwise, check if the call modifies or references the
208  // location this memory access defines. The best we can say
209  // is that if the call references what this instruction
210  // defines, it must be clobbered by this location.
211  const MemoryLocation DefLoc = MemoryLocation::get(I);
212  ModRefInfo MR = getModRefInfo(Call2, DefLoc, AAQI);
213  if (isModOrRefSet(MR))
214  return setModAndRef(MR);
215  return ModRefInfo::NoModRef;
216 }
217 
219  const MemoryLocation &Loc) {
220  SimpleAAQueryInfo AAQIP;
221  return getModRefInfo(Call, Loc, AAQIP);
222 }
223 
225  const MemoryLocation &Loc,
226  AAQueryInfo &AAQI) {
228 
229  for (const auto &AA : AAs) {
230  Result = intersectModRef(Result, AA->getModRefInfo(Call, Loc, AAQI));
231 
232  // Early-exit the moment we reach the bottom of the lattice.
233  if (isNoModRef(Result))
234  return ModRefInfo::NoModRef;
235  }
236 
237  // Try to refine the mod-ref info further using other API entry points to the
238  // aggregate set of AA results.
239  auto MRB = getModRefBehavior(Call);
241  return ModRefInfo::NoModRef;
242 
243  if (onlyReadsMemory(MRB))
244  Result = clearMod(Result);
245  else if (doesNotReadMemory(MRB))
246  Result = clearRef(Result);
247 
249  bool IsMustAlias = true;
250  ModRefInfo AllArgsMask = ModRefInfo::NoModRef;
251  if (doesAccessArgPointees(MRB)) {
252  for (auto AI = Call->arg_begin(), AE = Call->arg_end(); AI != AE; ++AI) {
253  const Value *Arg = *AI;
254  if (!Arg->getType()->isPointerTy())
255  continue;
256  unsigned ArgIdx = std::distance(Call->arg_begin(), AI);
257  MemoryLocation ArgLoc =
258  MemoryLocation::getForArgument(Call, ArgIdx, TLI);
259  AliasResult ArgAlias = alias(ArgLoc, Loc, AAQI);
260  if (ArgAlias != AliasResult::NoAlias) {
261  ModRefInfo ArgMask = getArgModRefInfo(Call, ArgIdx);
262  AllArgsMask = unionModRef(AllArgsMask, ArgMask);
263  }
264  // Conservatively clear IsMustAlias unless only MustAlias is found.
265  IsMustAlias &= (ArgAlias == AliasResult::MustAlias);
266  }
267  }
268  // Return NoModRef if no alias found with any argument.
269  if (isNoModRef(AllArgsMask))
270  return ModRefInfo::NoModRef;
271  // Logical & between other AA analyses and argument analysis.
272  Result = intersectModRef(Result, AllArgsMask);
273  // If only MustAlias found above, set Must bit.
274  Result = IsMustAlias ? setMust(Result) : clearMust(Result);
275  }
276 
277  // If Loc is a constant memory location, the call definitely could not
278  // modify the memory location.
279  if (isModSet(Result) && pointsToConstantMemory(Loc, AAQI, /*OrLocal*/ false))
280  Result = clearMod(Result);
281 
282  return Result;
283 }
284 
286  const CallBase *Call2) {
287  SimpleAAQueryInfo AAQIP;
288  return getModRefInfo(Call1, Call2, AAQIP);
289 }
290 
292  const CallBase *Call2, AAQueryInfo &AAQI) {
294 
295  for (const auto &AA : AAs) {
296  Result = intersectModRef(Result, AA->getModRefInfo(Call1, Call2, AAQI));
297 
298  // Early-exit the moment we reach the bottom of the lattice.
299  if (isNoModRef(Result))
300  return ModRefInfo::NoModRef;
301  }
302 
303  // Try to refine the mod-ref info further using other API entry points to the
304  // aggregate set of AA results.
305 
306  // If Call1 or Call2 are readnone, they don't interact.
307  auto Call1B = getModRefBehavior(Call1);
308  if (Call1B == FMRB_DoesNotAccessMemory)
309  return ModRefInfo::NoModRef;
310 
311  auto Call2B = getModRefBehavior(Call2);
312  if (Call2B == FMRB_DoesNotAccessMemory)
313  return ModRefInfo::NoModRef;
314 
315  // If they both only read from memory, there is no dependence.
316  if (onlyReadsMemory(Call1B) && onlyReadsMemory(Call2B))
317  return ModRefInfo::NoModRef;
318 
319  // If Call1 only reads memory, the only dependence on Call2 can be
320  // from Call1 reading memory written by Call2.
321  if (onlyReadsMemory(Call1B))
322  Result = clearMod(Result);
323  else if (doesNotReadMemory(Call1B))
324  Result = clearRef(Result);
325 
326  // If Call2 only access memory through arguments, accumulate the mod/ref
327  // information from Call1's references to the memory referenced by
328  // Call2's arguments.
329  if (onlyAccessesArgPointees(Call2B)) {
330  if (!doesAccessArgPointees(Call2B))
331  return ModRefInfo::NoModRef;
333  bool IsMustAlias = true;
334  for (auto I = Call2->arg_begin(), E = Call2->arg_end(); I != E; ++I) {
335  const Value *Arg = *I;
336  if (!Arg->getType()->isPointerTy())
337  continue;
338  unsigned Call2ArgIdx = std::distance(Call2->arg_begin(), I);
339  auto Call2ArgLoc =
340  MemoryLocation::getForArgument(Call2, Call2ArgIdx, TLI);
341 
342  // ArgModRefC2 indicates what Call2 might do to Call2ArgLoc, and the
343  // dependence of Call1 on that location is the inverse:
344  // - If Call2 modifies location, dependence exists if Call1 reads or
345  // writes.
346  // - If Call2 only reads location, dependence exists if Call1 writes.
347  ModRefInfo ArgModRefC2 = getArgModRefInfo(Call2, Call2ArgIdx);
349  if (isModSet(ArgModRefC2))
350  ArgMask = ModRefInfo::ModRef;
351  else if (isRefSet(ArgModRefC2))
352  ArgMask = ModRefInfo::Mod;
353 
354  // ModRefC1 indicates what Call1 might do to Call2ArgLoc, and we use
355  // above ArgMask to update dependence info.
356  ModRefInfo ModRefC1 = getModRefInfo(Call1, Call2ArgLoc, AAQI);
357  ArgMask = intersectModRef(ArgMask, ModRefC1);
358 
359  // Conservatively clear IsMustAlias unless only MustAlias is found.
360  IsMustAlias &= isMustSet(ModRefC1);
361 
362  R = intersectModRef(unionModRef(R, ArgMask), Result);
363  if (R == Result) {
364  // On early exit, not all args were checked, cannot set Must.
365  if (I + 1 != E)
366  IsMustAlias = false;
367  break;
368  }
369  }
370 
371  if (isNoModRef(R))
372  return ModRefInfo::NoModRef;
373 
374  // If MustAlias found above, set Must bit.
375  return IsMustAlias ? setMust(R) : clearMust(R);
376  }
377 
378  // If Call1 only accesses memory through arguments, check if Call2 references
379  // any of the memory referenced by Call1's arguments. If not, return NoModRef.
380  if (onlyAccessesArgPointees(Call1B)) {
381  if (!doesAccessArgPointees(Call1B))
382  return ModRefInfo::NoModRef;
384  bool IsMustAlias = true;
385  for (auto I = Call1->arg_begin(), E = Call1->arg_end(); I != E; ++I) {
386  const Value *Arg = *I;
387  if (!Arg->getType()->isPointerTy())
388  continue;
389  unsigned Call1ArgIdx = std::distance(Call1->arg_begin(), I);
390  auto Call1ArgLoc =
391  MemoryLocation::getForArgument(Call1, Call1ArgIdx, TLI);
392 
393  // ArgModRefC1 indicates what Call1 might do to Call1ArgLoc; if Call1
394  // might Mod Call1ArgLoc, then we care about either a Mod or a Ref by
395  // Call2. If Call1 might Ref, then we care only about a Mod by Call2.
396  ModRefInfo ArgModRefC1 = getArgModRefInfo(Call1, Call1ArgIdx);
397  ModRefInfo ModRefC2 = getModRefInfo(Call2, Call1ArgLoc, AAQI);
398  if ((isModSet(ArgModRefC1) && isModOrRefSet(ModRefC2)) ||
399  (isRefSet(ArgModRefC1) && isModSet(ModRefC2)))
400  R = intersectModRef(unionModRef(R, ArgModRefC1), Result);
401 
402  // Conservatively clear IsMustAlias unless only MustAlias is found.
403  IsMustAlias &= isMustSet(ModRefC2);
404 
405  if (R == Result) {
406  // On early exit, not all args were checked, cannot set Must.
407  if (I + 1 != E)
408  IsMustAlias = false;
409  break;
410  }
411  }
412 
413  if (isNoModRef(R))
414  return ModRefInfo::NoModRef;
415 
416  // If MustAlias found above, set Must bit.
417  return IsMustAlias ? setMust(R) : clearMust(R);
418  }
419 
420  return Result;
421 }
422 
425 
426  for (const auto &AA : AAs) {
427  Result = FunctionModRefBehavior(Result & AA->getModRefBehavior(Call));
428 
429  // Early-exit the moment we reach the bottom of the lattice.
430  if (Result == FMRB_DoesNotAccessMemory)
431  return Result;
432  }
433 
434  return Result;
435 }
436 
439 
440  for (const auto &AA : AAs) {
441  Result = FunctionModRefBehavior(Result & AA->getModRefBehavior(F));
442 
443  // Early-exit the moment we reach the bottom of the lattice.
444  if (Result == FMRB_DoesNotAccessMemory)
445  return Result;
446  }
447 
448  return Result;
449 }
450 
452  switch (AR) {
454  OS << "NoAlias";
455  break;
457  OS << "MustAlias";
458  break;
460  OS << "MayAlias";
461  break;
463  OS << "PartialAlias";
464  if (AR.hasOffset())
465  OS << " (off " << AR.getOffset() << ")";
466  break;
467  }
468  return OS;
469 }
470 
471 //===----------------------------------------------------------------------===//
472 // Helper method implementation
473 //===----------------------------------------------------------------------===//
474 
476  const MemoryLocation &Loc) {
477  SimpleAAQueryInfo AAQIP;
478  return getModRefInfo(L, Loc, AAQIP);
479 }
481  const MemoryLocation &Loc,
482  AAQueryInfo &AAQI) {
483  // Be conservative in the face of atomic.
485  return ModRefInfo::ModRef;
486 
487  // If the load address doesn't alias the given address, it doesn't read
488  // or write the specified memory.
489  if (Loc.Ptr) {
490  AliasResult AR = alias(MemoryLocation::get(L), Loc, AAQI);
491  if (AR == AliasResult::NoAlias)
492  return ModRefInfo::NoModRef;
493  if (AR == AliasResult::MustAlias)
494  return ModRefInfo::MustRef;
495  }
496  // Otherwise, a load just reads.
497  return ModRefInfo::Ref;
498 }
499 
501  const MemoryLocation &Loc) {
502  SimpleAAQueryInfo AAQIP;
503  return getModRefInfo(S, Loc, AAQIP);
504 }
506  const MemoryLocation &Loc,
507  AAQueryInfo &AAQI) {
508  // Be conservative in the face of atomic.
509  if (isStrongerThan(S->getOrdering(), AtomicOrdering::Unordered))
510  return ModRefInfo::ModRef;
511 
512  if (Loc.Ptr) {
513  AliasResult AR = alias(MemoryLocation::get(S), Loc, AAQI);
514  // If the store address cannot alias the pointer in question, then the
515  // specified memory cannot be modified by the store.
516  if (AR == AliasResult::NoAlias)
517  return ModRefInfo::NoModRef;
518 
519  // If the pointer is a pointer to constant memory, then it could not have
520  // been modified by this store.
521  if (pointsToConstantMemory(Loc, AAQI))
522  return ModRefInfo::NoModRef;
523 
524  // If the store address aliases the pointer as must alias, set Must.
525  if (AR == AliasResult::MustAlias)
526  return ModRefInfo::MustMod;
527  }
528 
529  // Otherwise, a store just writes.
530  return ModRefInfo::Mod;
531 }
532 
534  SimpleAAQueryInfo AAQIP;
535  return getModRefInfo(S, Loc, AAQIP);
536 }
537 
539  const MemoryLocation &Loc,
540  AAQueryInfo &AAQI) {
541  // If we know that the location is a constant memory location, the fence
542  // cannot modify this location.
543  if (Loc.Ptr && pointsToConstantMemory(Loc, AAQI))
544  return ModRefInfo::Ref;
545  return ModRefInfo::ModRef;
546 }
547 
549  const MemoryLocation &Loc) {
550  SimpleAAQueryInfo AAQIP;
551  return getModRefInfo(V, Loc, AAQIP);
552 }
553 
555  const MemoryLocation &Loc,
556  AAQueryInfo &AAQI) {
557  if (Loc.Ptr) {
558  AliasResult AR = alias(MemoryLocation::get(V), Loc, AAQI);
559  // If the va_arg address cannot alias the pointer in question, then the
560  // specified memory cannot be accessed by the va_arg.
561  if (AR == AliasResult::NoAlias)
562  return ModRefInfo::NoModRef;
563 
564  // If the pointer is a pointer to constant memory, then it could not have
565  // been modified by this va_arg.
566  if (pointsToConstantMemory(Loc, AAQI))
567  return ModRefInfo::NoModRef;
568 
569  // If the va_arg aliases the pointer as must alias, set Must.
570  if (AR == AliasResult::MustAlias)
571  return ModRefInfo::MustModRef;
572  }
573 
574  // Otherwise, a va_arg reads and writes.
575  return ModRefInfo::ModRef;
576 }
577 
579  const MemoryLocation &Loc) {
580  SimpleAAQueryInfo AAQIP;
581  return getModRefInfo(CatchPad, Loc, AAQIP);
582 }
583 
585  const MemoryLocation &Loc,
586  AAQueryInfo &AAQI) {
587  if (Loc.Ptr) {
588  // If the pointer is a pointer to constant memory,
589  // then it could not have been modified by this catchpad.
590  if (pointsToConstantMemory(Loc, AAQI))
591  return ModRefInfo::NoModRef;
592  }
593 
594  // Otherwise, a catchpad reads and writes.
595  return ModRefInfo::ModRef;
596 }
597 
599  const MemoryLocation &Loc) {
600  SimpleAAQueryInfo AAQIP;
601  return getModRefInfo(CatchRet, Loc, AAQIP);
602 }
603 
605  const MemoryLocation &Loc,
606  AAQueryInfo &AAQI) {
607  if (Loc.Ptr) {
608  // If the pointer is a pointer to constant memory,
609  // then it could not have been modified by this catchpad.
610  if (pointsToConstantMemory(Loc, AAQI))
611  return ModRefInfo::NoModRef;
612  }
613 
614  // Otherwise, a catchret reads and writes.
615  return ModRefInfo::ModRef;
616 }
617 
619  const MemoryLocation &Loc) {
620  SimpleAAQueryInfo AAQIP;
621  return getModRefInfo(CX, Loc, AAQIP);
622 }
623 
625  const MemoryLocation &Loc,
626  AAQueryInfo &AAQI) {
627  // Acquire/Release cmpxchg has properties that matter for arbitrary addresses.
629  return ModRefInfo::ModRef;
630 
631  if (Loc.Ptr) {
632  AliasResult AR = alias(MemoryLocation::get(CX), Loc, AAQI);
633  // If the cmpxchg address does not alias the location, it does not access
634  // it.
635  if (AR == AliasResult::NoAlias)
636  return ModRefInfo::NoModRef;
637 
638  // If the cmpxchg address aliases the pointer as must alias, set Must.
639  if (AR == AliasResult::MustAlias)
640  return ModRefInfo::MustModRef;
641  }
642 
643  return ModRefInfo::ModRef;
644 }
645 
647  const MemoryLocation &Loc) {
648  SimpleAAQueryInfo AAQIP;
649  return getModRefInfo(RMW, Loc, AAQIP);
650 }
651 
653  const MemoryLocation &Loc,
654  AAQueryInfo &AAQI) {
655  // Acquire/Release atomicrmw has properties that matter for arbitrary addresses.
657  return ModRefInfo::ModRef;
658 
659  if (Loc.Ptr) {
660  AliasResult AR = alias(MemoryLocation::get(RMW), Loc, AAQI);
661  // If the atomicrmw address does not alias the location, it does not access
662  // it.
663  if (AR == AliasResult::NoAlias)
664  return ModRefInfo::NoModRef;
665 
666  // If the atomicrmw address aliases the pointer as must alias, set Must.
667  if (AR == AliasResult::MustAlias)
668  return ModRefInfo::MustModRef;
669  }
670 
671  return ModRefInfo::ModRef;
672 }
673 
675  const Optional<MemoryLocation> &OptLoc,
676  AAQueryInfo &AAQIP) {
677  if (OptLoc == None) {
678  if (const auto *Call = dyn_cast<CallBase>(I)) {
679  return createModRefInfo(getModRefBehavior(Call));
680  }
681  }
682 
683  const MemoryLocation &Loc = OptLoc.getValueOr(MemoryLocation());
684 
685  switch (I->getOpcode()) {
686  case Instruction::VAArg:
687  return getModRefInfo((const VAArgInst *)I, Loc, AAQIP);
688  case Instruction::Load:
689  return getModRefInfo((const LoadInst *)I, Loc, AAQIP);
690  case Instruction::Store:
691  return getModRefInfo((const StoreInst *)I, Loc, AAQIP);
692  case Instruction::Fence:
693  return getModRefInfo((const FenceInst *)I, Loc, AAQIP);
694  case Instruction::AtomicCmpXchg:
695  return getModRefInfo((const AtomicCmpXchgInst *)I, Loc, AAQIP);
696  case Instruction::AtomicRMW:
697  return getModRefInfo((const AtomicRMWInst *)I, Loc, AAQIP);
698  case Instruction::Call:
699  return getModRefInfo((const CallInst *)I, Loc, AAQIP);
700  case Instruction::Invoke:
701  return getModRefInfo((const InvokeInst *)I, Loc, AAQIP);
702  case Instruction::CatchPad:
703  return getModRefInfo((const CatchPadInst *)I, Loc, AAQIP);
704  case Instruction::CatchRet:
705  return getModRefInfo((const CatchReturnInst *)I, Loc, AAQIP);
706  default:
707  return ModRefInfo::NoModRef;
708  }
709 }
710 
711 /// Return information about whether a particular call site modifies
712 /// or reads the specified memory location \p MemLoc before instruction \p I
713 /// in a BasicBlock.
714 /// FIXME: this is really just shoring-up a deficiency in alias analysis.
715 /// BasicAA isn't willing to spend linear time determining whether an alloca
716 /// was captured before or after this particular call, while we are. However,
717 /// with a smarter AA in place, this test is just wasting compile time.
719  const MemoryLocation &MemLoc,
720  DominatorTree *DT,
721  AAQueryInfo &AAQI) {
722  if (!DT)
723  return ModRefInfo::ModRef;
724 
725  const Value *Object = getUnderlyingObject(MemLoc.Ptr);
726  if (!isIdentifiedFunctionLocal(Object))
727  return ModRefInfo::ModRef;
728 
729  const auto *Call = dyn_cast<CallBase>(I);
730  if (!Call || Call == Object)
731  return ModRefInfo::ModRef;
732 
733  if (PointerMayBeCapturedBefore(Object, /* ReturnCaptures */ true,
734  /* StoreCaptures */ true, I, DT,
735  /* include Object */ true))
736  return ModRefInfo::ModRef;
737 
738  unsigned ArgNo = 0;
740  bool IsMustAlias = true;
741  // Set flag only if no May found and all operands processed.
742  for (auto CI = Call->data_operands_begin(), CE = Call->data_operands_end();
743  CI != CE; ++CI, ++ArgNo) {
744  // Only look at the no-capture or byval pointer arguments. If this
745  // pointer were passed to arguments that were neither of these, then it
746  // couldn't be no-capture.
747  if (!(*CI)->getType()->isPointerTy() ||
748  (!Call->doesNotCapture(ArgNo) && ArgNo < Call->arg_size() &&
749  !Call->isByValArgument(ArgNo)))
750  continue;
751 
752  AliasResult AR = alias(
754  MemoryLocation::getBeforeOrAfter(Object), AAQI);
755  // If this is a no-capture pointer argument, see if we can tell that it
756  // is impossible to alias the pointer we're checking. If not, we have to
757  // assume that the call could touch the pointer, even though it doesn't
758  // escape.
759  if (AR != AliasResult::MustAlias)
760  IsMustAlias = false;
761  if (AR == AliasResult::NoAlias)
762  continue;
763  if (Call->doesNotAccessMemory(ArgNo))
764  continue;
765  if (Call->onlyReadsMemory(ArgNo)) {
766  R = ModRefInfo::Ref;
767  continue;
768  }
769  // Not returning MustModRef since we have not seen all the arguments.
770  return ModRefInfo::ModRef;
771  }
772  return IsMustAlias ? setMust(R) : clearMust(R);
773 }
774 
775 /// canBasicBlockModify - Return true if it is possible for execution of the
776 /// specified basic block to modify the location Loc.
777 ///
779  const MemoryLocation &Loc) {
780  return canInstructionRangeModRef(BB.front(), BB.back(), Loc, ModRefInfo::Mod);
781 }
782 
783 /// canInstructionRangeModRef - Return true if it is possible for the
784 /// execution of the specified instructions to mod\ref (according to the
785 /// mode) the location Loc. The instructions to consider are all
786 /// of the instructions in the range of [I1,I2] INCLUSIVE.
787 /// I1 and I2 must be in the same basic block.
789  const Instruction &I2,
790  const MemoryLocation &Loc,
791  const ModRefInfo Mode) {
792  assert(I1.getParent() == I2.getParent() &&
793  "Instructions not in same basic block!");
796  ++E; // Convert from inclusive to exclusive range.
797 
798  for (; I != E; ++I) // Check every instruction in range
800  return true;
801  return false;
802 }
803 
804 // Provide a definition for the root virtual destructor.
805 AAResults::Concept::~Concept() = default;
806 
807 // Provide a definition for the static object used to identify passes.
808 AnalysisKey AAManager::Key;
809 
812 }
813 
815  : ImmutablePass(ID), CB(std::move(CB)) {
817 }
818 
820 
821 INITIALIZE_PASS(ExternalAAWrapperPass, "external-aa", "External Alias Analysis",
822  false, true)
823 
826  return new ExternalAAWrapperPass(std::move(Callback));
827 }
828 
831 }
832 
833 char AAResultsWrapperPass::ID = 0;
834 
836  "Function Alias Analysis Results", false, true)
842 INITIALIZE_PASS_DEPENDENCY(ObjCARCAAWrapperPass)
847  "Function Alias Analysis Results", false, true)
848 
850  return new AAResultsWrapperPass();
851 }
852 
853 /// Run the wrapper pass to rebuild an aggregation over known AA passes.
854 ///
855 /// This is the legacy pass manager's interface to the new-style AA results
856 /// aggregation object. Because this is somewhat shoe-horned into the legacy
857 /// pass manager, we hard code all the specific alias analyses available into
858 /// it. While the particular set enabled is configured via commandline flags,
859 /// adding a new alias analysis to LLVM will require adding support for it to
860 /// this list.
862  // NB! This *must* be reset before adding new AA results to the new
863  // AAResults object because in the legacy pass manager, each instance
864  // of these will refer to the *same* immutable analyses, registering and
865  // unregistering themselves with them. We need to carefully tear down the
866  // previous object first, in this case replacing it with an empty one, before
867  // registering new results.
868  AAR.reset(
869  new AAResults(getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(F)));
870 
871  // BasicAA is always available for function analyses. Also, we add it first
872  // so that it can trump TBAA results when it proves MustAlias.
873  // FIXME: TBAA should have an explicit mode to support this and then we
874  // should reconsider the ordering here.
875  if (!DisableBasicAA)
876  AAR->addAAResult(getAnalysis<BasicAAWrapperPass>().getResult());
877 
878  // Populate the results with the currently available AAs.
879  if (auto *WrapperPass = getAnalysisIfAvailable<ScopedNoAliasAAWrapperPass>())
880  AAR->addAAResult(WrapperPass->getResult());
881  if (auto *WrapperPass = getAnalysisIfAvailable<TypeBasedAAWrapperPass>())
882  AAR->addAAResult(WrapperPass->getResult());
883  if (auto *WrapperPass =
884  getAnalysisIfAvailable<objcarc::ObjCARCAAWrapperPass>())
885  AAR->addAAResult(WrapperPass->getResult());
886  if (auto *WrapperPass = getAnalysisIfAvailable<GlobalsAAWrapperPass>())
887  AAR->addAAResult(WrapperPass->getResult());
888  if (auto *WrapperPass = getAnalysisIfAvailable<SCEVAAWrapperPass>())
889  AAR->addAAResult(WrapperPass->getResult());
890  if (auto *WrapperPass = getAnalysisIfAvailable<CFLAndersAAWrapperPass>())
891  AAR->addAAResult(WrapperPass->getResult());
892  if (auto *WrapperPass = getAnalysisIfAvailable<CFLSteensAAWrapperPass>())
893  AAR->addAAResult(WrapperPass->getResult());
894 
895  // If available, run an external AA providing callback over the results as
896  // well.
897  if (auto *WrapperPass = getAnalysisIfAvailable<ExternalAAWrapperPass>())
898  if (WrapperPass->CB)
899  WrapperPass->CB(*this, F, *AAR);
900 
901  // Analyses don't mutate the IR, so return false.
902  return false;
903 }
904 
906  AU.setPreservesAll();
909 
910  // We also need to mark all the alias analysis passes we will potentially
911  // probe in runOnFunction as used here to ensure the legacy pass manager
912  // preserves them. This hard coding of lists of alias analyses is specific to
913  // the legacy pass manager.
922 }
923 
926  for (auto &Getter : ResultGetters)
927  (*Getter)(F, AM, R);
928  return R;
929 }
930 
932  BasicAAResult &BAR) {
933  AAResults AAR(P.getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(F));
934 
935  // Add in our explicitly constructed BasicAA results.
936  if (!DisableBasicAA)
937  AAR.addAAResult(BAR);
938 
939  // Populate the results with the other currently available AAs.
940  if (auto *WrapperPass =
941  P.getAnalysisIfAvailable<ScopedNoAliasAAWrapperPass>())
942  AAR.addAAResult(WrapperPass->getResult());
943  if (auto *WrapperPass = P.getAnalysisIfAvailable<TypeBasedAAWrapperPass>())
944  AAR.addAAResult(WrapperPass->getResult());
945  if (auto *WrapperPass =
946  P.getAnalysisIfAvailable<objcarc::ObjCARCAAWrapperPass>())
947  AAR.addAAResult(WrapperPass->getResult());
948  if (auto *WrapperPass = P.getAnalysisIfAvailable<GlobalsAAWrapperPass>())
949  AAR.addAAResult(WrapperPass->getResult());
950  if (auto *WrapperPass = P.getAnalysisIfAvailable<CFLAndersAAWrapperPass>())
951  AAR.addAAResult(WrapperPass->getResult());
952  if (auto *WrapperPass = P.getAnalysisIfAvailable<CFLSteensAAWrapperPass>())
953  AAR.addAAResult(WrapperPass->getResult());
954  if (auto *WrapperPass = P.getAnalysisIfAvailable<ExternalAAWrapperPass>())
955  if (WrapperPass->CB)
956  WrapperPass->CB(P, F, AAR);
957 
958  return AAR;
959 }
960 
961 bool llvm::isNoAliasCall(const Value *V) {
962  if (const auto *Call = dyn_cast<CallBase>(V))
963  return Call->hasRetAttr(Attribute::NoAlias);
964  return false;
965 }
966 
967 static bool isNoAliasOrByValArgument(const Value *V) {
968  if (const Argument *A = dyn_cast<Argument>(V))
969  return A->hasNoAliasAttr() || A->hasByValAttr();
970  return false;
971 }
972 
974  if (isa<AllocaInst>(V))
975  return true;
976  if (isa<GlobalValue>(V) && !isa<GlobalAlias>(V))
977  return true;
978  if (isNoAliasCall(V))
979  return true;
981  return true;
982  return false;
983 }
984 
986  return isa<AllocaInst>(V) || isNoAliasCall(V) || isNoAliasOrByValArgument(V);
987 }
988 
990  // This function needs to be in sync with llvm::createLegacyPMAAResults -- if
991  // more alias analyses are added to llvm::createLegacyPMAAResults, they need
992  // to be added here also.
1001 }
llvm::AAResults::addAAResult
void addAAResult(AAResultT &AAResult)
Register a specific AA result.
Definition: AliasAnalysis.h:517
llvm::PreservedAnalyses
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:155
TypeBasedAliasAnalysis.h
llvm::ModRefInfo::NoModRef
@ NoModRef
The access neither references nor modifies the value stored in memory.
llvm::Argument
This class represents an incoming formal argument to a Function.
Definition: Argument.h:29
llvm::AAManager
A manager for alias analyses.
Definition: AliasAnalysis.h:1288
llvm::AliasResult::MayAlias
@ MayAlias
The two locations may or may not alias.
Definition: AliasAnalysis.h:103
llvm::AliasResult::PartialAlias
@ PartialAlias
The two locations alias, but only due to a partial overlap.
Definition: AliasAnalysis.h:105
llvm::MemoryLocation::get
static MemoryLocation get(const LoadInst *LI)
Return a location with information about the memory reference by the given instruction.
Definition: MemoryLocation.cpp:37
llvm
This file implements support for optimizing divisions by a constant.
Definition: AllocatorList.h:23
llvm::ExternalAAWrapperPass::ExternalAAWrapperPass
ExternalAAWrapperPass()
Definition: AliasAnalysis.cpp:810
llvm::VAArgInst
This class represents the va_arg llvm instruction, which returns an argument of the specified type gi...
Definition: Instructions.h:1833
llvm::isModOrRefSet
LLVM_NODISCARD bool isModOrRefSet(const ModRefInfo MRI)
Definition: AliasAnalysis.h:190
llvm::ImmutablePass
ImmutablePass class - This class is used to provide information that does not need to be run.
Definition: Pass.h:269
AtomicOrdering.h
llvm::AnalysisManager::getResult
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
Definition: PassManager.h:783
llvm::MemoryLocation::Ptr
const Value * Ptr
The address of the start of the location.
Definition: MemoryLocation.h:217
aa
aa
Definition: AliasAnalysis.cpp:846
llvm::Function
Definition: Function.h:62
llvm::AnalysisManager::Invalidator::invalidate
bool invalidate(IRUnitT &IR, const PreservedAnalyses &PA)
Trigger the invalidation of some other analysis pass if not already handled and return whether it was...
Definition: PassManager.h:688
P
This currently compiles esp xmm0 movsd esp eax eax esp ret We should use not the dag combiner This is because dagcombine2 needs to be able to see through the X86ISD::Wrapper which DAGCombine can t really do The code for turning x load into a single vector load is target independent and should be moved to the dag combiner The code for turning x load into a vector load can only handle a direct load from a global or a direct load from the stack It should be generalized to handle any load from P
Definition: README-SSE.txt:411
Pass.h
llvm::AAResults::invalidate
bool invalidate(Function &F, const PreservedAnalyses &PA, FunctionAnalysisManager::Invalidator &Inv)
Handle invalidation events in the new pass manager.
Definition: AliasAnalysis.cpp:96
llvm::createAAResultsWrapperPass
FunctionPass * createAAResultsWrapperPass()
Definition: AliasAnalysis.cpp:849
Statistic.h
CaptureTracking.h
llvm::AtomicCmpXchgInst::getSuccessOrdering
AtomicOrdering getSuccessOrdering() const
Returns the success ordering constraint of this cmpxchg instruction.
Definition: Instructions.h:604
llvm::AAResults::Concept::~Concept
virtual ~Concept()=0
llvm::createModRefInfo
LLVM_NODISCARD ModRefInfo createModRefInfo(const FunctionModRefBehavior FMRB)
Definition: AliasAnalysis.h:378
ValueTracking.h
llvm::DominatorTree
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
Definition: Dominators.h:151
GlobalsModRef.h
isNoAliasOrByValArgument
static bool isNoAliasOrByValArgument(const Value *V)
Definition: AliasAnalysis.cpp:967
llvm::cl::Hidden
@ Hidden
Definition: CommandLine.h:143
llvm::AAResults::onlyAccessesArgPointees
static bool onlyAccessesArgPointees(FunctionModRefBehavior MRB)
Checks if functions with the specified behavior are known to read and write at most from objects poin...
Definition: AliasAnalysis.h:689
llvm::SimpleAAQueryInfo
AAQueryInfo that uses SimpleCaptureInfo.
Definition: AliasAnalysis.h:499
llvm::SPII::Load
@ Load
Definition: SparcInstrInfo.h:32
llvm::MemoryLocation::Size
LocationSize Size
The maximum size of the location, in address-units, or UnknownSize if the size is not known.
Definition: MemoryLocation.h:226
Module.h
llvm::Optional
Definition: APInt.h:33
llvm::FenceInst
An instruction for ordering other memory operations.
Definition: Instructions.h:444
llvm::AliasResult
The possible results of an alias query.
Definition: AliasAnalysis.h:82
Results
Function Alias Analysis Results
Definition: AliasAnalysis.cpp:847
llvm::CallBase::arg_begin
User::op_iterator arg_begin()
Return the iterator pointing to the beginning of the argument list.
Definition: InstrTypes.h:1303
BasicAliasAnalysis.h
llvm::FMRB_UnknownModRefBehavior
@ FMRB_UnknownModRefBehavior
This indicates that the function could not be classified into one of the behaviors above.
Definition: AliasAnalysis.h:369
llvm::getAAResultsAnalysisUsage
void getAAResultsAnalysisUsage(AnalysisUsage &AU)
A helper for the legacy pass manager to populate AU to add uses to make sure the analyses required by...
Definition: AliasAnalysis.cpp:989
F
#define F(x, y, z)
Definition: MD5.cpp:56
llvm::RISCVFenceField::R
@ R
Definition: RISCVBaseInfo.h:198
llvm::BasicBlock
LLVM Basic Block Representation.
Definition: BasicBlock.h:58
AliasAnalysis.h
llvm::dbgs
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
llvm::isIdentifiedFunctionLocal
bool isIdentifiedFunctionLocal(const Value *V)
Return true if V is umabigously identified at the function-level.
Definition: AliasAnalysis.cpp:985
llvm::AAResults::AAResults
AAResults(const TargetLibraryInfo &TLI)
Definition: AliasAnalysis.h:512
llvm::objcarc::ObjCARCAAWrapperPass
Legacy wrapper pass to provide the ObjCARCAAResult object.
Definition: ObjCARCAliasAnalysis.h:80
Arg
amdgpu Simplify well known AMD library false FunctionCallee Value * Arg
Definition: AMDGPULibCalls.cpp:206
llvm::AAQueryInfo
This class stores info we want to provide to or retain within an alias query.
Definition: AliasAnalysis.h:459
Instruction.h
CommandLine.h
llvm::ModRefInfo::MustRef
@ MustRef
The access may reference the value stored in memory, a mustAlias relation was found,...
llvm::isNoAliasCall
bool isNoAliasCall(const Value *V)
Return true if this pointer is returned by a noalias function.
Definition: AliasAnalysis.cpp:961
llvm::AAResultsWrapperPass::getAnalysisUsage
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...
Definition: AliasAnalysis.cpp:905
llvm::PassRegistry::getPassRegistry
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
Definition: PassRegistry.cpp:31
llvm::AAResults::onlyReadsMemory
bool onlyReadsMemory(const CallBase *Call)
Checks if the specified call is known to only read from non-volatile memory (or not access memory at ...
Definition: AliasAnalysis.h:657
llvm::ModRefInfo::Ref
@ Ref
The access may reference the value stored in memory.
llvm::AAResults
Definition: AliasAnalysis.h:508
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
llvm::ModRefInfo::MustModRef
@ MustModRef
The access may reference, modify or both the value stored in memory, a mustAlias relation was found,...
llvm::ModRefInfo::MustMod
@ MustMod
The access may modify the value stored in memory, a mustAlias relation was found, and no mayAlias or ...
llvm::AnalysisUsage
Represent the analysis usage information of a pass.
Definition: PassAnalysisSupport.h:47
llvm::AliasResult::hasOffset
constexpr bool hasOffset() const
Definition: AliasAnalysis.h:118
llvm::ms_demangle::QualifierMangleMode::Result
@ Result
TargetLibraryInfo.h
false
Definition: StackSlotColoring.cpp:142
INITIALIZE_PASS_BEGIN
INITIALIZE_PASS_BEGIN(AAResultsWrapperPass, "aa", "Function Alias Analysis Results", false, true) INITIALIZE_PASS_END(AAResultsWrapperPass
INITIALIZE_PASS
INITIALIZE_PASS(ExternalAAWrapperPass, "external-aa", "External Alias Analysis", false, true) ImmutablePass *llvm
Definition: AliasAnalysis.cpp:821
llvm::Instruction
Definition: Instruction.h:45
llvm::ExternalAAWrapperPass::CallbackT
std::function< void(Pass &, Function &, AAResults &)> CallbackT
Definition: AliasAnalysis.h:1355
llvm::STATISTIC
STATISTIC(NumFunctions, "Total number of functions")
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:53
llvm::AAManager::run
Result run(Function &F, FunctionAnalysisManager &AM)
Definition: AliasAnalysis.cpp:924
llvm::operator<<
raw_ostream & operator<<(raw_ostream &OS, const APFixedPoint &FX)
Definition: APFixedPoint.h:230
llvm::clearRef
LLVM_NODISCARD ModRefInfo clearRef(const ModRefInfo MRI)
Definition: AliasAnalysis.h:226
llvm::getUnderlyingObject
const Value * getUnderlyingObject(const Value *V, unsigned MaxLookup=6)
This method strips off any GEP address adjustments and pointer casts from the specified value,...
Definition: ValueTracking.cpp:4376
llvm::AnalysisManager::Invalidator
API to communicate dependencies between analyses during invalidation.
Definition: PassManager.h:670
CFLAndersAliasAnalysis.h
llvm::MCID::Call
@ Call
Definition: MCInstrDesc.h:153
llvm::isModSet
LLVM_NODISCARD bool isModSet(const ModRefInfo MRI)
Definition: AliasAnalysis.h:197
ScopedNoAliasAA.h
llvm::None
const NoneType None
Definition: None.h:23
Type.h
llvm::createLegacyPMAAResults
AAResults createLegacyPMAAResults(Pass &P, Function &F, BasicAAResult &BAR)
A helper for the legacy pass manager to create a AAResults object populated to the best of our abilit...
Definition: AliasAnalysis.cpp:931
llvm::AliasResult::getOffset
constexpr int32_t getOffset() const
Definition: AliasAnalysis.h:119
INITIALIZE_PASS_END
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:58
llvm::clearMod
LLVM_NODISCARD ModRefInfo clearMod(const ModRefInfo MRI)
Definition: AliasAnalysis.h:223
llvm::InvokeInst
Invoke instruction.
Definition: Instructions.h:3749
llvm::OutputFileType::Object
@ Object
llvm::clearMust
LLVM_NODISCARD ModRefInfo clearMust(const ModRefInfo MRI)
Definition: AliasAnalysis.h:229
llvm::TypeBasedAAWrapperPass
Legacy wrapper pass to provide the TypeBasedAAResult object.
Definition: TypeBasedAliasAnalysis.h:71
llvm::Optional::getValueOr
constexpr T getValueOr(U &&value) const LLVM_LVALUE_FUNCTION
Definition: Optional.h:297
BasicBlock.h
llvm::cl::opt< bool >
llvm::ExternalAAWrapperPass::ID
static char ID
Definition: AliasAnalysis.h:1359
llvm::StoreInst
An instruction for storing to memory.
Definition: Instructions.h:304
llvm::isNoModRef
LLVM_NODISCARD bool isNoModRef(const ModRefInfo MRI)
Definition: AliasAnalysis.h:186
llvm::SCEVAAWrapperPass
Legacy wrapper pass to provide the SCEVAAResult object.
Definition: ScalarEvolutionAliasAnalysis.h:55
llvm::TargetLibraryInfoWrapperPass
Definition: TargetLibraryInfo.h:465
llvm::CatchReturnInst
Definition: Instructions.h:4524
INITIALIZE_PASS_DEPENDENCY
INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
llvm::BasicAAWrapperPass
Legacy wrapper pass to provide the BasicAAResult object.
Definition: BasicAliasAnalysis.h:176
move
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional move
Definition: README.txt:546
MemoryLocation.h
llvm::AtomicRMWInst::getOrdering
AtomicOrdering getOrdering() const
Returns the ordering constraint of this rmw instruction.
Definition: Instructions.h:844
llvm::CFLAndersAAWrapperPass
Legacy wrapper pass to provide the CFLAndersAAResult object.
Definition: CFLAndersAliasAnalysis.h:106
llvm::AnalysisKey
A special type used by analysis passes to provide an address that identifies that particular analysis...
Definition: PassManager.h:72
llvm::AAResults::canInstructionRangeModRef
bool canInstructionRangeModRef(const Instruction &I1, const Instruction &I2, const MemoryLocation &Loc, const ModRefInfo Mode)
Check if it is possible for the execution of the specified instructions to mod(according to the mode)...
Definition: AliasAnalysis.cpp:788
llvm::AtomicOrdering::Unordered
@ Unordered
I
#define I(x, y, z)
Definition: MD5.cpp:59
llvm::cl::init
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:441
llvm::unionModRef
LLVM_NODISCARD ModRefInfo unionModRef(const ModRefInfo MRI1, const ModRefInfo MRI2)
Definition: AliasAnalysis.h:233
llvm::createExternalAAWrapperPass
ImmutablePass * createExternalAAWrapperPass(std::function< void(Pass &, Function &, AAResults &)> Callback)
A wrapper pass around a callback which can be used to populate the AAResults in the AAResultsWrapperP...
llvm::CFLSteensAAWrapperPass
Legacy wrapper pass to provide the CFLSteensAAResult object.
Definition: CFLSteensAliasAnalysis.h:123
llvm::SPII::Store
@ Store
Definition: SparcInstrInfo.h:33
llvm::ModRefInfo
ModRefInfo
Flags indicating whether a memory access modifies or references memory.
Definition: AliasAnalysis.h:149
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::move
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1609
llvm::MemoryLocation::getForArgument
static MemoryLocation getForArgument(const CallBase *Call, unsigned ArgIdx, const TargetLibraryInfo *TLI)
Return a location representing a particular argument of a call.
Definition: MemoryLocation.cpp:131
llvm::AAResults::doesAccessArgPointees
static bool doesAccessArgPointees(FunctionModRefBehavior MRB)
Checks if functions with the specified behavior are known to potentially read or write from objects p...
Definition: AliasAnalysis.h:696
Mode
SI Whole Quad Mode
Definition: SIWholeQuadMode.cpp:262
ObjCARCAliasAnalysis.h
llvm::FMRB_DoesNotAccessMemory
@ FMRB_DoesNotAccessMemory
This function does not perform any non-local loads or stores to memory.
Definition: AliasAnalysis.h:269
llvm::CallBase::arg_end
User::op_iterator arg_end()
Return the iterator pointing to the end of the argument list.
Definition: InstrTypes.h:1309
llvm::AAResultsWrapperPass::ID
static char ID
Definition: AliasAnalysis.h:1340
llvm::initializeAAResultsWrapperPassPass
void initializeAAResultsWrapperPassPass(PassRegistry &)
llvm::AAResults::~AAResults
~AAResults()
Definition: AliasAnalysis.cpp:85
llvm::AliasResult::NoAlias
@ NoAlias
The two locations do not alias at all.
Definition: AliasAnalysis.h:100
llvm::ModRefInfo::Mod
@ Mod
The access may modify the value stored in memory.
llvm::ilist_node_impl::getIterator
self_iterator getIterator()
Definition: ilist_node.h:81
llvm::setModAndRef
LLVM_NODISCARD ModRefInfo setModAndRef(const ModRefInfo MRI)
Definition: AliasAnalysis.h:219
llvm::AliasResult::MustAlias
@ MustAlias
The two locations precisely alias each other.
Definition: AliasAnalysis.h:107
S
add sub stmia L5 ldr r0 bl L_printf $stub Instead of a and a wouldn t it be better to do three moves *Return an aggregate type is even return S
Definition: README.txt:210
llvm::TargetLibraryInfoWrapperPass::getTLI
TargetLibraryInfo & getTLI(const Function &F)
Definition: TargetLibraryInfo.h:477
llvm::FunctionModRefBehavior
FunctionModRefBehavior
Summary of how a function affects memory in the program.
Definition: AliasAnalysis.h:263
llvm::LoadInst::getOrdering
AtomicOrdering getOrdering() const
Returns the ordering constraint of this load instruction.
Definition: Instructions.h:232
llvm::BasicAAResult
This is the AA result object for the basic, local, and stateless alias analysis.
Definition: BasicAliasAnalysis.h:47
llvm::LoadInst
An instruction for reading from memory.
Definition: Instructions.h:175
llvm::AAResults::getModRefBehavior
FunctionModRefBehavior getModRefBehavior(const CallBase *Call)
Return the behavior of the given call site.
Definition: AliasAnalysis.cpp:423
llvm::AAResults::onlyAccessesInaccessibleOrArgMem
static bool onlyAccessesInaccessibleOrArgMem(FunctionModRefBehavior MRB)
Checks if functions with the specified behavior are known to read and write at most from memory that ...
Definition: AliasAnalysis.h:717
llvm::AtomicRMWInst
an instruction that atomically reads a memory location, combines it with another value,...
Definition: Instructions.h:726
Argument.h
Attributes.h
std
Definition: BitVector.h:838
llvm::isIdentifiedObject
bool isIdentifiedObject(const Value *V)
Return true if this pointer refers to a distinct and identifiable object.
Definition: AliasAnalysis.cpp:973
llvm::AnalysisUsage::setPreservesAll
void setPreservesAll()
Set by analyses that do not transform their input at all.
Definition: PassAnalysisSupport.h:130
llvm::isMustSet
LLVM_NODISCARD bool isMustSet(const ModRefInfo MRI)
Definition: AliasAnalysis.h:203
llvm::AAResults::doesNotReadMemory
static bool doesNotReadMemory(FunctionModRefBehavior MRB)
Checks if functions with the specified behavior are known to only write memory (or not access memory ...
Definition: AliasAnalysis.h:682
llvm::AAResults::onlyAccessesInaccessibleMem
static bool onlyAccessesInaccessibleMem(FunctionModRefBehavior MRB)
Checks if functions with the specified behavior are known to read and write at most from memory that ...
Definition: AliasAnalysis.h:703
llvm::AAResultsWrapperPass::runOnFunction
bool runOnFunction(Function &F) override
Run the wrapper pass to rebuild an aggregation over known AA passes.
Definition: AliasAnalysis.cpp:861
Casting.h
llvm::AAResults::alias
AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB)
The main low level interface to the alias analysis implementation.
Definition: AliasAnalysis.cpp:120
EnableAATrace
static cl::opt< bool > EnableAATrace("aa-trace", cl::Hidden, cl::init(false))
Print a trace of alias analysis queries and their results.
ScalarEvolutionAliasAnalysis.h
llvm::AAResults::pointsToConstantMemory
bool pointsToConstantMemory(const MemoryLocation &Loc, bool OrLocal=false)
Checks whether the given location points to constant memory, or if OrLocal is true whether it points ...
Definition: AliasAnalysis.cpp:163
llvm::ScopedNoAliasAAWrapperPass
Legacy wrapper pass to provide the ScopedNoAliasAAResult object.
Definition: ScopedNoAliasAA.h:65
llvm::isStrongerThan
bool isStrongerThan(AtomicOrdering AO, AtomicOrdering Other)
Returns true if ao is stronger than other as defined by the AtomicOrdering lattice,...
Definition: AtomicOrdering.h:90
llvm::CatchPadInst
Definition: Instructions.h:4473
llvm::AAResultsWrapperPass::AAResultsWrapperPass
AAResultsWrapperPass()
Definition: AliasAnalysis.cpp:829
llvm::AAResults::getArgModRefInfo
ModRefInfo getArgModRefInfo(const CallBase *Call, unsigned ArgIdx)
Get the ModRef info associated with a pointer argument of a call.
Definition: AliasAnalysis.cpp:178
llvm::Pass
Pass interface - Implemented by all 'passes'.
Definition: Pass.h:91
Instructions.h
llvm::isRefSet
LLVM_NODISCARD bool isRefSet(const ModRefInfo MRI)
Definition: AliasAnalysis.h:200
llvm::DisableBasicAA
cl::opt< bool > DisableBasicAA("disable-basic-aa", cl::Hidden, cl::init(false))
Allow disabling BasicAA from the AA results.
llvm::AAResultsWrapperPass
A wrapper pass to provide the legacy pass manager access to a suitably prepared AAResults object.
Definition: AliasAnalysis.h:1336
llvm::Instruction::getParent
const BasicBlock * getParent() const
Definition: Instruction.h:94
llvm::ExternalAAWrapperPass
A wrapper pass for external alias analyses.
Definition: AliasAnalysis.h:1354
llvm::GlobalsAAWrapperPass
Legacy wrapper pass to provide the GlobalsAAResult object.
Definition: GlobalsModRef.h:143
llvm::isStrongerThanMonotonic
bool isStrongerThanMonotonic(AtomicOrdering AO)
Definition: AtomicOrdering.h:124
llvm::setMust
LLVM_NODISCARD ModRefInfo setMust(const ModRefInfo MRI)
Definition: AliasAnalysis.h:215
llvm::AAResults::canBasicBlockModify
bool canBasicBlockModify(const BasicBlock &BB, const MemoryLocation &Loc)
Check if it is possible for execution of the specified basic block to modify the location Loc.
Definition: AliasAnalysis.cpp:778
llvm::AAResults::callCapturesBefore
ModRefInfo callCapturesBefore(const Instruction *I, const MemoryLocation &MemLoc, DominatorTree *DT)
Return information about whether a particular call site modifies or reads the specified memory locati...
Definition: AliasAnalysis.h:849
llvm::MemoryLocation::getBeforeOrAfter
static MemoryLocation getBeforeOrAfter(const Value *Ptr, const AAMDNodes &AATags=AAMDNodes())
Return a location that may access any location before or after Ptr, while remaining within the underl...
Definition: MemoryLocation.h:275
llvm::CallBase
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Definition: InstrTypes.h:1161
llvm::AnalysisUsage::addRequiredTransitive
AnalysisUsage & addRequiredTransitive()
Definition: PassAnalysisSupport.h:81
llvm::PreservedAnalyses::getChecker
PreservedAnalysisChecker getChecker() const
Build a checker for this PreservedAnalyses and the specified analysis type.
Definition: PassManager.h:313
llvm::AnalysisManager
A container for analyses that lazily runs them and caches their results.
Definition: InstructionSimplify.h:44
llvm::AnalysisUsage::addUsedIfAvailable
AnalysisUsage & addUsedIfAvailable()
Add the specified Pass class to the set of analyses used by this pass.
Definition: PassAnalysisSupport.h:117
llvm::FunctionPass
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:298
llvm::CallInst
This class represents a function call, abstracting a target machine's calling convention.
Definition: Instructions.h:1475
BB
Common register allocation spilling lr str ldr sxth r3 ldr mla r4 can lr mov lr str ldr sxth r3 mla r4 and then merge mul and lr str ldr sxth r3 mla r4 It also increase the likelihood the store may become dead bb27 Successors according to LLVM BB
Definition: README.txt:39
llvm::AnalysisUsage::addRequired
AnalysisUsage & addRequired()
Definition: PassAnalysisSupport.h:75
llvm::intersectModRef
LLVM_NODISCARD ModRefInfo intersectModRef(const ModRefInfo MRI1, const ModRefInfo MRI2)
Definition: AliasAnalysis.h:237
true
basic Basic Alias true
Definition: BasicAliasAnalysis.cpp:1903
llvm::initializeExternalAAWrapperPassPass
void initializeExternalAAWrapperPassPass(PassRegistry &)
Value.h
InitializePasses.h
llvm::PointerMayBeCapturedBefore
bool PointerMayBeCapturedBefore(const Value *V, bool ReturnCaptures, bool StoreCaptures, const Instruction *I, const DominatorTree *DT, bool IncludeI=false, unsigned MaxUsesToExplore=0, const LoopInfo *LI=nullptr)
PointerMayBeCapturedBefore - Return true if this pointer value may be captured by the enclosing funct...
Definition: CaptureTracking.cpp:245
llvm::Value
LLVM Value Representation.
Definition: Value.h:74
llvm::AtomicCmpXchgInst
An instruction that atomically checks whether a specified value is in a memory location,...
Definition: Instructions.h:521
llvm::TargetLibraryAnalysis
Analysis pass providing the TargetLibraryInfo.
Definition: TargetLibraryInfo.h:440
llvm::AAResults::getModRefInfo
ModRefInfo getModRefInfo(const CallBase *Call, const MemoryLocation &Loc)
getModRefInfo (for call sites) - Return information about whether a particular call site modifies or ...
Definition: AliasAnalysis.cpp:218
CFLSteensAliasAnalysis.h
llvm::ModRefInfo::ModRef
@ ModRef
The access may reference and may modify the value stored in memory.
llvm::MemoryLocation
Representation for a specific memory location.
Definition: MemoryLocation.h:209
llvm::BasicBlock::const_iterator
InstListType::const_iterator const_iterator
Definition: BasicBlock.h:91
llvm::AAQueryInfo::Depth
unsigned Depth
Query depth used to distinguish recursive queries.
Definition: AliasAnalysis.h:476
llvm::Intrinsic::ID
unsigned ID
Definition: TargetTransformInfo.h:37