LLVM  15.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/Type.h"
46 #include "llvm/IR/Value.h"
47 #include "llvm/InitializePasses.h"
48 #include "llvm/Pass.h"
50 #include "llvm/Support/Casting.h"
52 #include <algorithm>
53 #include <cassert>
54 #include <functional>
55 #include <iterator>
56 
57 #define DEBUG_TYPE "aa"
58 
59 using namespace llvm;
60 
61 STATISTIC(NumNoAlias, "Number of NoAlias results");
62 STATISTIC(NumMayAlias, "Number of MayAlias results");
63 STATISTIC(NumMustAlias, "Number of MustAlias results");
64 
65 namespace llvm {
66 /// Allow disabling BasicAA from the AA results. This is particularly useful
67 /// when testing to isolate a single AA implementation.
68 cl::opt<bool> DisableBasicAA("disable-basic-aa", cl::Hidden, cl::init(false));
69 } // namespace llvm
70 
71 #ifndef NDEBUG
72 /// Print a trace of alias analysis queries and their results.
73 static cl::opt<bool> EnableAATrace("aa-trace", cl::Hidden, cl::init(false));
74 #else
75 static const bool EnableAATrace = false;
76 #endif
77 
79  : TLI(Arg.TLI), AAs(std::move(Arg.AAs)), AADeps(std::move(Arg.AADeps)) {
80  for (auto &AA : AAs)
81  AA->setAAResults(this);
82 }
83 
85 // FIXME; It would be nice to at least clear out the pointers back to this
86 // aggregation here, but we end up with non-nesting lifetimes in the legacy
87 // pass manager that prevent this from working. In the legacy pass manager
88 // we'll end up with dangling references here in some cases.
89 #if 0
90  for (auto &AA : AAs)
91  AA->setAAResults(nullptr);
92 #endif
93 }
94 
97  // AAResults preserves the AAManager by default, due to the stateless nature
98  // of AliasAnalysis. There is no need to check whether it has been preserved
99  // explicitly. Check if any module dependency was invalidated and caused the
100  // AAManager to be invalidated. Invalidate ourselves in that case.
101  auto PAC = PA.getChecker<AAManager>();
102  if (!PAC.preservedWhenStateless())
103  return true;
104 
105  // Check if any of the function dependencies were invalidated, and invalidate
106  // ourselves in that case.
107  for (AnalysisKey *ID : AADeps)
108  if (Inv.invalidate(ID, F, PA))
109  return true;
110 
111  // Everything we depend on is still fine, so are we. Nothing to invalidate.
112  return false;
113 }
114 
115 //===----------------------------------------------------------------------===//
116 // Default chaining methods
117 //===----------------------------------------------------------------------===//
118 
120  const MemoryLocation &LocB) {
121  SimpleAAQueryInfo AAQIP;
122  return alias(LocA, LocB, AAQIP);
123 }
124 
126  const MemoryLocation &LocB, AAQueryInfo &AAQI) {
128 
129  if (EnableAATrace) {
130  for (unsigned I = 0; I < AAQI.Depth; ++I)
131  dbgs() << " ";
132  dbgs() << "Start " << *LocA.Ptr << " @ " << LocA.Size << ", "
133  << *LocB.Ptr << " @ " << LocB.Size << "\n";
134  }
135 
136  AAQI.Depth++;
137  for (const auto &AA : AAs) {
138  Result = AA->alias(LocA, LocB, AAQI);
139  if (Result != AliasResult::MayAlias)
140  break;
141  }
142  AAQI.Depth--;
143 
144  if (EnableAATrace) {
145  for (unsigned I = 0; I < AAQI.Depth; ++I)
146  dbgs() << " ";
147  dbgs() << "End " << *LocA.Ptr << " @ " << LocA.Size << ", "
148  << *LocB.Ptr << " @ " << LocB.Size << " = " << Result << "\n";
149  }
150 
151  if (AAQI.Depth == 0) {
152  if (Result == AliasResult::NoAlias)
153  ++NumNoAlias;
154  else if (Result == AliasResult::MustAlias)
155  ++NumMustAlias;
156  else
157  ++NumMayAlias;
158  }
159  return Result;
160 }
161 
163  bool OrLocal) {
164  SimpleAAQueryInfo AAQIP;
165  return pointsToConstantMemory(Loc, AAQIP, OrLocal);
166 }
167 
169  AAQueryInfo &AAQI, bool OrLocal) {
170  for (const auto &AA : AAs)
171  if (AA->pointsToConstantMemory(Loc, AAQI, OrLocal))
172  return true;
173 
174  return false;
175 }
176 
177 ModRefInfo AAResults::getArgModRefInfo(const CallBase *Call, unsigned ArgIdx) {
179 
180  for (const auto &AA : AAs) {
181  Result = intersectModRef(Result, AA->getArgModRefInfo(Call, ArgIdx));
182 
183  // Early-exit the moment we reach the bottom of the lattice.
184  if (isNoModRef(Result))
185  return ModRefInfo::NoModRef;
186  }
187 
188  return Result;
189 }
190 
192  SimpleAAQueryInfo AAQIP;
193  return getModRefInfo(I, Call2, AAQIP);
194 }
195 
197  AAQueryInfo &AAQI) {
198  // We may have two calls.
199  if (const auto *Call1 = dyn_cast<CallBase>(I)) {
200  // Check if the two calls modify the same memory.
201  return getModRefInfo(Call1, Call2, AAQI);
202  }
203  // If this is a fence, just return ModRef.
204  if (I->isFenceLike())
205  return ModRefInfo::ModRef;
206  // Otherwise, check if the call modifies or references the
207  // location this memory access defines. The best we can say
208  // is that if the call references what this instruction
209  // defines, it must be clobbered by this location.
210  const MemoryLocation DefLoc = MemoryLocation::get(I);
211  ModRefInfo MR = getModRefInfo(Call2, DefLoc, AAQI);
212  if (isModOrRefSet(MR))
213  return setModAndRef(MR);
214  return ModRefInfo::NoModRef;
215 }
216 
218  const MemoryLocation &Loc) {
219  SimpleAAQueryInfo AAQIP;
220  return getModRefInfo(Call, Loc, AAQIP);
221 }
222 
224  const MemoryLocation &Loc,
225  AAQueryInfo &AAQI) {
227 
228  for (const auto &AA : AAs) {
229  Result = intersectModRef(Result, AA->getModRefInfo(Call, Loc, AAQI));
230 
231  // Early-exit the moment we reach the bottom of the lattice.
232  if (isNoModRef(Result))
233  return ModRefInfo::NoModRef;
234  }
235 
236  // Try to refine the mod-ref info further using other API entry points to the
237  // aggregate set of AA results.
238  auto MRB = getModRefBehavior(Call);
240  return ModRefInfo::NoModRef;
241 
242  if (onlyReadsMemory(MRB))
243  Result = clearMod(Result);
244  else if (onlyWritesMemory(MRB))
245  Result = clearRef(Result);
246 
248  bool IsMustAlias = true;
249  ModRefInfo AllArgsMask = ModRefInfo::NoModRef;
250  if (doesAccessArgPointees(MRB)) {
251  for (const auto &I : llvm::enumerate(Call->args())) {
252  const Value *Arg = I.value();
253  if (!Arg->getType()->isPointerTy())
254  continue;
255  unsigned ArgIdx = I.index();
256  MemoryLocation ArgLoc =
257  MemoryLocation::getForArgument(Call, ArgIdx, TLI);
258  AliasResult ArgAlias = alias(ArgLoc, Loc, AAQI);
259  if (ArgAlias != AliasResult::NoAlias) {
260  ModRefInfo ArgMask = getArgModRefInfo(Call, ArgIdx);
261  AllArgsMask = unionModRef(AllArgsMask, ArgMask);
262  }
263  // Conservatively clear IsMustAlias unless only MustAlias is found.
264  IsMustAlias &= (ArgAlias == AliasResult::MustAlias);
265  }
266  }
267  // Return NoModRef if no alias found with any argument.
268  if (isNoModRef(AllArgsMask))
269  return ModRefInfo::NoModRef;
270  // Logical & between other AA analyses and argument analysis.
271  Result = intersectModRef(Result, AllArgsMask);
272  // If only MustAlias found above, set Must bit.
273  Result = IsMustAlias ? setMust(Result) : clearMust(Result);
274  }
275 
276  // If Loc is a constant memory location, the call definitely could not
277  // modify the memory location.
278  if (isModSet(Result) && pointsToConstantMemory(Loc, AAQI, /*OrLocal*/ false))
279  Result = clearMod(Result);
280 
281  return Result;
282 }
283 
285  const CallBase *Call2) {
286  SimpleAAQueryInfo AAQIP;
287  return getModRefInfo(Call1, Call2, AAQIP);
288 }
289 
291  const CallBase *Call2, AAQueryInfo &AAQI) {
293 
294  for (const auto &AA : AAs) {
295  Result = intersectModRef(Result, AA->getModRefInfo(Call1, Call2, AAQI));
296 
297  // Early-exit the moment we reach the bottom of the lattice.
298  if (isNoModRef(Result))
299  return ModRefInfo::NoModRef;
300  }
301 
302  // Try to refine the mod-ref info further using other API entry points to the
303  // aggregate set of AA results.
304 
305  // If Call1 or Call2 are readnone, they don't interact.
306  auto Call1B = getModRefBehavior(Call1);
307  if (Call1B == FMRB_DoesNotAccessMemory)
308  return ModRefInfo::NoModRef;
309 
310  auto Call2B = getModRefBehavior(Call2);
311  if (Call2B == FMRB_DoesNotAccessMemory)
312  return ModRefInfo::NoModRef;
313 
314  // If they both only read from memory, there is no dependence.
315  if (onlyReadsMemory(Call1B) && onlyReadsMemory(Call2B))
316  return ModRefInfo::NoModRef;
317 
318  // If Call1 only reads memory, the only dependence on Call2 can be
319  // from Call1 reading memory written by Call2.
320  if (onlyReadsMemory(Call1B))
321  Result = clearMod(Result);
322  else if (onlyWritesMemory(Call1B))
323  Result = clearRef(Result);
324 
325  // If Call2 only access memory through arguments, accumulate the mod/ref
326  // information from Call1's references to the memory referenced by
327  // Call2's arguments.
328  if (onlyAccessesArgPointees(Call2B)) {
329  if (!doesAccessArgPointees(Call2B))
330  return ModRefInfo::NoModRef;
332  bool IsMustAlias = true;
333  for (auto I = Call2->arg_begin(), E = Call2->arg_end(); I != E; ++I) {
334  const Value *Arg = *I;
335  if (!Arg->getType()->isPointerTy())
336  continue;
337  unsigned Call2ArgIdx = std::distance(Call2->arg_begin(), I);
338  auto Call2ArgLoc =
339  MemoryLocation::getForArgument(Call2, Call2ArgIdx, TLI);
340 
341  // ArgModRefC2 indicates what Call2 might do to Call2ArgLoc, and the
342  // dependence of Call1 on that location is the inverse:
343  // - If Call2 modifies location, dependence exists if Call1 reads or
344  // writes.
345  // - If Call2 only reads location, dependence exists if Call1 writes.
346  ModRefInfo ArgModRefC2 = getArgModRefInfo(Call2, Call2ArgIdx);
348  if (isModSet(ArgModRefC2))
349  ArgMask = ModRefInfo::ModRef;
350  else if (isRefSet(ArgModRefC2))
351  ArgMask = ModRefInfo::Mod;
352 
353  // ModRefC1 indicates what Call1 might do to Call2ArgLoc, and we use
354  // above ArgMask to update dependence info.
355  ModRefInfo ModRefC1 = getModRefInfo(Call1, Call2ArgLoc, AAQI);
356  ArgMask = intersectModRef(ArgMask, ModRefC1);
357 
358  // Conservatively clear IsMustAlias unless only MustAlias is found.
359  IsMustAlias &= isMustSet(ModRefC1);
360 
361  R = intersectModRef(unionModRef(R, ArgMask), Result);
362  if (R == Result) {
363  // On early exit, not all args were checked, cannot set Must.
364  if (I + 1 != E)
365  IsMustAlias = false;
366  break;
367  }
368  }
369 
370  if (isNoModRef(R))
371  return ModRefInfo::NoModRef;
372 
373  // If MustAlias found above, set Must bit.
374  return IsMustAlias ? setMust(R) : clearMust(R);
375  }
376 
377  // If Call1 only accesses memory through arguments, check if Call2 references
378  // any of the memory referenced by Call1's arguments. If not, return NoModRef.
379  if (onlyAccessesArgPointees(Call1B)) {
380  if (!doesAccessArgPointees(Call1B))
381  return ModRefInfo::NoModRef;
383  bool IsMustAlias = true;
384  for (auto I = Call1->arg_begin(), E = Call1->arg_end(); I != E; ++I) {
385  const Value *Arg = *I;
386  if (!Arg->getType()->isPointerTy())
387  continue;
388  unsigned Call1ArgIdx = std::distance(Call1->arg_begin(), I);
389  auto Call1ArgLoc =
390  MemoryLocation::getForArgument(Call1, Call1ArgIdx, TLI);
391 
392  // ArgModRefC1 indicates what Call1 might do to Call1ArgLoc; if Call1
393  // might Mod Call1ArgLoc, then we care about either a Mod or a Ref by
394  // Call2. If Call1 might Ref, then we care only about a Mod by Call2.
395  ModRefInfo ArgModRefC1 = getArgModRefInfo(Call1, Call1ArgIdx);
396  ModRefInfo ModRefC2 = getModRefInfo(Call2, Call1ArgLoc, AAQI);
397  if ((isModSet(ArgModRefC1) && isModOrRefSet(ModRefC2)) ||
398  (isRefSet(ArgModRefC1) && isModSet(ModRefC2)))
399  R = intersectModRef(unionModRef(R, ArgModRefC1), Result);
400 
401  // Conservatively clear IsMustAlias unless only MustAlias is found.
402  IsMustAlias &= isMustSet(ModRefC2);
403 
404  if (R == Result) {
405  // On early exit, not all args were checked, cannot set Must.
406  if (I + 1 != E)
407  IsMustAlias = false;
408  break;
409  }
410  }
411 
412  if (isNoModRef(R))
413  return ModRefInfo::NoModRef;
414 
415  // If MustAlias found above, set Must bit.
416  return IsMustAlias ? setMust(R) : clearMust(R);
417  }
418 
419  return Result;
420 }
421 
424 
425  for (const auto &AA : AAs) {
426  Result = FunctionModRefBehavior(Result & AA->getModRefBehavior(Call));
427 
428  // Early-exit the moment we reach the bottom of the lattice.
429  if (Result == FMRB_DoesNotAccessMemory)
430  return Result;
431  }
432 
433  return Result;
434 }
435 
438 
439  for (const auto &AA : AAs) {
440  Result = FunctionModRefBehavior(Result & AA->getModRefBehavior(F));
441 
442  // Early-exit the moment we reach the bottom of the lattice.
443  if (Result == FMRB_DoesNotAccessMemory)
444  return Result;
445  }
446 
447  return Result;
448 }
449 
451  switch (AR) {
453  OS << "NoAlias";
454  break;
456  OS << "MustAlias";
457  break;
459  OS << "MayAlias";
460  break;
462  OS << "PartialAlias";
463  if (AR.hasOffset())
464  OS << " (off " << AR.getOffset() << ")";
465  break;
466  }
467  return OS;
468 }
469 
470 //===----------------------------------------------------------------------===//
471 // Helper method implementation
472 //===----------------------------------------------------------------------===//
473 
475  const MemoryLocation &Loc) {
476  SimpleAAQueryInfo AAQIP;
477  return getModRefInfo(L, Loc, AAQIP);
478 }
480  const MemoryLocation &Loc,
481  AAQueryInfo &AAQI) {
482  // Be conservative in the face of atomic.
484  return ModRefInfo::ModRef;
485 
486  // If the load address doesn't alias the given address, it doesn't read
487  // or write the specified memory.
488  if (Loc.Ptr) {
489  AliasResult AR = alias(MemoryLocation::get(L), Loc, AAQI);
490  if (AR == AliasResult::NoAlias)
491  return ModRefInfo::NoModRef;
492  if (AR == AliasResult::MustAlias)
493  return ModRefInfo::MustRef;
494  }
495  // Otherwise, a load just reads.
496  return ModRefInfo::Ref;
497 }
498 
500  const MemoryLocation &Loc) {
501  SimpleAAQueryInfo AAQIP;
502  return getModRefInfo(S, Loc, AAQIP);
503 }
505  const MemoryLocation &Loc,
506  AAQueryInfo &AAQI) {
507  // Be conservative in the face of atomic.
508  if (isStrongerThan(S->getOrdering(), AtomicOrdering::Unordered))
509  return ModRefInfo::ModRef;
510 
511  if (Loc.Ptr) {
512  AliasResult AR = alias(MemoryLocation::get(S), Loc, AAQI);
513  // If the store address cannot alias the pointer in question, then the
514  // specified memory cannot be modified by the store.
515  if (AR == AliasResult::NoAlias)
516  return ModRefInfo::NoModRef;
517 
518  // If the pointer is a pointer to constant memory, then it could not have
519  // been modified by this store.
520  if (pointsToConstantMemory(Loc, AAQI))
521  return ModRefInfo::NoModRef;
522 
523  // If the store address aliases the pointer as must alias, set Must.
524  if (AR == AliasResult::MustAlias)
525  return ModRefInfo::MustMod;
526  }
527 
528  // Otherwise, a store just writes.
529  return ModRefInfo::Mod;
530 }
531 
533  SimpleAAQueryInfo AAQIP;
534  return getModRefInfo(S, Loc, AAQIP);
535 }
536 
538  const MemoryLocation &Loc,
539  AAQueryInfo &AAQI) {
540  // If we know that the location is a constant memory location, the fence
541  // cannot modify this location.
542  if (Loc.Ptr && pointsToConstantMemory(Loc, AAQI))
543  return ModRefInfo::Ref;
544  return ModRefInfo::ModRef;
545 }
546 
548  const MemoryLocation &Loc) {
549  SimpleAAQueryInfo AAQIP;
550  return getModRefInfo(V, Loc, AAQIP);
551 }
552 
554  const MemoryLocation &Loc,
555  AAQueryInfo &AAQI) {
556  if (Loc.Ptr) {
557  AliasResult AR = alias(MemoryLocation::get(V), Loc, AAQI);
558  // If the va_arg address cannot alias the pointer in question, then the
559  // specified memory cannot be accessed by the va_arg.
560  if (AR == AliasResult::NoAlias)
561  return ModRefInfo::NoModRef;
562 
563  // If the pointer is a pointer to constant memory, then it could not have
564  // been modified by this va_arg.
565  if (pointsToConstantMemory(Loc, AAQI))
566  return ModRefInfo::NoModRef;
567 
568  // If the va_arg aliases the pointer as must alias, set Must.
569  if (AR == AliasResult::MustAlias)
570  return ModRefInfo::MustModRef;
571  }
572 
573  // Otherwise, a va_arg reads and writes.
574  return ModRefInfo::ModRef;
575 }
576 
578  const MemoryLocation &Loc) {
579  SimpleAAQueryInfo AAQIP;
580  return getModRefInfo(CatchPad, Loc, AAQIP);
581 }
582 
584  const MemoryLocation &Loc,
585  AAQueryInfo &AAQI) {
586  if (Loc.Ptr) {
587  // If the pointer is a pointer to constant memory,
588  // then it could not have been modified by this catchpad.
589  if (pointsToConstantMemory(Loc, AAQI))
590  return ModRefInfo::NoModRef;
591  }
592 
593  // Otherwise, a catchpad reads and writes.
594  return ModRefInfo::ModRef;
595 }
596 
598  const MemoryLocation &Loc) {
599  SimpleAAQueryInfo AAQIP;
600  return getModRefInfo(CatchRet, Loc, AAQIP);
601 }
602 
604  const MemoryLocation &Loc,
605  AAQueryInfo &AAQI) {
606  if (Loc.Ptr) {
607  // If the pointer is a pointer to constant memory,
608  // then it could not have been modified by this catchpad.
609  if (pointsToConstantMemory(Loc, AAQI))
610  return ModRefInfo::NoModRef;
611  }
612 
613  // Otherwise, a catchret reads and writes.
614  return ModRefInfo::ModRef;
615 }
616 
618  const MemoryLocation &Loc) {
619  SimpleAAQueryInfo AAQIP;
620  return getModRefInfo(CX, Loc, AAQIP);
621 }
622 
624  const MemoryLocation &Loc,
625  AAQueryInfo &AAQI) {
626  // Acquire/Release cmpxchg has properties that matter for arbitrary addresses.
628  return ModRefInfo::ModRef;
629 
630  if (Loc.Ptr) {
631  AliasResult AR = alias(MemoryLocation::get(CX), Loc, AAQI);
632  // If the cmpxchg address does not alias the location, it does not access
633  // it.
634  if (AR == AliasResult::NoAlias)
635  return ModRefInfo::NoModRef;
636 
637  // If the cmpxchg address aliases the pointer as must alias, set Must.
638  if (AR == AliasResult::MustAlias)
639  return ModRefInfo::MustModRef;
640  }
641 
642  return ModRefInfo::ModRef;
643 }
644 
646  const MemoryLocation &Loc) {
647  SimpleAAQueryInfo AAQIP;
648  return getModRefInfo(RMW, Loc, AAQIP);
649 }
650 
652  const MemoryLocation &Loc,
653  AAQueryInfo &AAQI) {
654  // Acquire/Release atomicrmw has properties that matter for arbitrary addresses.
656  return ModRefInfo::ModRef;
657 
658  if (Loc.Ptr) {
659  AliasResult AR = alias(MemoryLocation::get(RMW), Loc, AAQI);
660  // If the atomicrmw address does not alias the location, it does not access
661  // it.
662  if (AR == AliasResult::NoAlias)
663  return ModRefInfo::NoModRef;
664 
665  // If the atomicrmw address aliases the pointer as must alias, set Must.
666  if (AR == AliasResult::MustAlias)
667  return ModRefInfo::MustModRef;
668  }
669 
670  return ModRefInfo::ModRef;
671 }
672 
674  const Optional<MemoryLocation> &OptLoc,
675  AAQueryInfo &AAQIP) {
676  if (OptLoc == None) {
677  if (const auto *Call = dyn_cast<CallBase>(I)) {
678  return createModRefInfo(getModRefBehavior(Call));
679  }
680  }
681 
682  const MemoryLocation &Loc = OptLoc.value_or(MemoryLocation());
683 
684  switch (I->getOpcode()) {
685  case Instruction::VAArg:
686  return getModRefInfo((const VAArgInst *)I, Loc, AAQIP);
687  case Instruction::Load:
688  return getModRefInfo((const LoadInst *)I, Loc, AAQIP);
689  case Instruction::Store:
690  return getModRefInfo((const StoreInst *)I, Loc, AAQIP);
691  case Instruction::Fence:
692  return getModRefInfo((const FenceInst *)I, Loc, AAQIP);
693  case Instruction::AtomicCmpXchg:
694  return getModRefInfo((const AtomicCmpXchgInst *)I, Loc, AAQIP);
695  case Instruction::AtomicRMW:
696  return getModRefInfo((const AtomicRMWInst *)I, Loc, AAQIP);
697  case Instruction::Call:
698  case Instruction::CallBr:
699  case Instruction::Invoke:
700  return getModRefInfo((const CallBase *)I, Loc, AAQIP);
701  case Instruction::CatchPad:
702  return getModRefInfo((const CatchPadInst *)I, Loc, AAQIP);
703  case Instruction::CatchRet:
704  return getModRefInfo((const CatchReturnInst *)I, Loc, AAQIP);
705  default:
706  assert(!I->mayReadOrWriteMemory() &&
707  "Unhandled memory access instruction!");
708  return ModRefInfo::NoModRef;
709  }
710 }
711 
712 /// Return information about whether a particular call site modifies
713 /// or reads the specified memory location \p MemLoc before instruction \p I
714 /// in a BasicBlock.
715 /// FIXME: this is really just shoring-up a deficiency in alias analysis.
716 /// BasicAA isn't willing to spend linear time determining whether an alloca
717 /// was captured before or after this particular call, while we are. However,
718 /// with a smarter AA in place, this test is just wasting compile time.
720  const MemoryLocation &MemLoc,
721  DominatorTree *DT,
722  AAQueryInfo &AAQI) {
723  if (!DT)
724  return ModRefInfo::ModRef;
725 
726  const Value *Object = getUnderlyingObject(MemLoc.Ptr);
727  if (!isIdentifiedFunctionLocal(Object))
728  return ModRefInfo::ModRef;
729 
730  const auto *Call = dyn_cast<CallBase>(I);
731  if (!Call || Call == Object)
732  return ModRefInfo::ModRef;
733 
734  if (PointerMayBeCapturedBefore(Object, /* ReturnCaptures */ true,
735  /* StoreCaptures */ true, I, DT,
736  /* include Object */ true))
737  return ModRefInfo::ModRef;
738 
739  unsigned ArgNo = 0;
741  bool IsMustAlias = true;
742  // Set flag only if no May found and all operands processed.
743  for (auto CI = Call->data_operands_begin(), CE = Call->data_operands_end();
744  CI != CE; ++CI, ++ArgNo) {
745  // Only look at the no-capture or byval pointer arguments. If this
746  // pointer were passed to arguments that were neither of these, then it
747  // couldn't be no-capture.
748  if (!(*CI)->getType()->isPointerTy() ||
749  (!Call->doesNotCapture(ArgNo) && ArgNo < Call->arg_size() &&
750  !Call->isByValArgument(ArgNo)))
751  continue;
752 
753  AliasResult AR = alias(
755  MemoryLocation::getBeforeOrAfter(Object), AAQI);
756  // If this is a no-capture pointer argument, see if we can tell that it
757  // is impossible to alias the pointer we're checking. If not, we have to
758  // assume that the call could touch the pointer, even though it doesn't
759  // escape.
760  if (AR != AliasResult::MustAlias)
761  IsMustAlias = false;
762  if (AR == AliasResult::NoAlias)
763  continue;
764  if (Call->doesNotAccessMemory(ArgNo))
765  continue;
766  if (Call->onlyReadsMemory(ArgNo)) {
767  R = ModRefInfo::Ref;
768  continue;
769  }
770  // Not returning MustModRef since we have not seen all the arguments.
771  return ModRefInfo::ModRef;
772  }
773  return IsMustAlias ? setMust(R) : clearMust(R);
774 }
775 
776 /// canBasicBlockModify - Return true if it is possible for execution of the
777 /// specified basic block to modify the location Loc.
778 ///
780  const MemoryLocation &Loc) {
781  return canInstructionRangeModRef(BB.front(), BB.back(), Loc, ModRefInfo::Mod);
782 }
783 
784 /// canInstructionRangeModRef - Return true if it is possible for the
785 /// execution of the specified instructions to mod\ref (according to the
786 /// mode) the location Loc. The instructions to consider are all
787 /// of the instructions in the range of [I1,I2] INCLUSIVE.
788 /// I1 and I2 must be in the same basic block.
790  const Instruction &I2,
791  const MemoryLocation &Loc,
792  const ModRefInfo Mode) {
793  assert(I1.getParent() == I2.getParent() &&
794  "Instructions not in same basic block!");
795  BasicBlock::const_iterator I = I1.getIterator();
797  ++E; // Convert from inclusive to exclusive range.
798 
799  for (; I != E; ++I) // Check every instruction in range
801  return true;
802  return false;
803 }
804 
805 // Provide a definition for the root virtual destructor.
806 AAResults::Concept::~Concept() = default;
807 
808 // Provide a definition for the static object used to identify passes.
809 AnalysisKey AAManager::Key;
810 
813 }
814 
816  : ImmutablePass(ID), CB(std::move(CB)) {
818 }
819 
821 
822 INITIALIZE_PASS(ExternalAAWrapperPass, "external-aa", "External Alias Analysis",
823  false, true)
824 
827  return new ExternalAAWrapperPass(std::move(Callback));
828 }
829 
832 }
833 
834 char AAResultsWrapperPass::ID = 0;
835 
837  "Function Alias Analysis Results", false, true)
843 INITIALIZE_PASS_DEPENDENCY(ObjCARCAAWrapperPass)
848  "Function Alias Analysis Results", false, true)
849 
851  return new AAResultsWrapperPass();
852 }
853 
854 /// Run the wrapper pass to rebuild an aggregation over known AA passes.
855 ///
856 /// This is the legacy pass manager's interface to the new-style AA results
857 /// aggregation object. Because this is somewhat shoe-horned into the legacy
858 /// pass manager, we hard code all the specific alias analyses available into
859 /// it. While the particular set enabled is configured via commandline flags,
860 /// adding a new alias analysis to LLVM will require adding support for it to
861 /// this list.
863  // NB! This *must* be reset before adding new AA results to the new
864  // AAResults object because in the legacy pass manager, each instance
865  // of these will refer to the *same* immutable analyses, registering and
866  // unregistering themselves with them. We need to carefully tear down the
867  // previous object first, in this case replacing it with an empty one, before
868  // registering new results.
869  AAR.reset(
870  new AAResults(getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(F)));
871 
872  // BasicAA is always available for function analyses. Also, we add it first
873  // so that it can trump TBAA results when it proves MustAlias.
874  // FIXME: TBAA should have an explicit mode to support this and then we
875  // should reconsider the ordering here.
876  if (!DisableBasicAA)
877  AAR->addAAResult(getAnalysis<BasicAAWrapperPass>().getResult());
878 
879  // Populate the results with the currently available AAs.
880  if (auto *WrapperPass = getAnalysisIfAvailable<ScopedNoAliasAAWrapperPass>())
881  AAR->addAAResult(WrapperPass->getResult());
882  if (auto *WrapperPass = getAnalysisIfAvailable<TypeBasedAAWrapperPass>())
883  AAR->addAAResult(WrapperPass->getResult());
884  if (auto *WrapperPass =
885  getAnalysisIfAvailable<objcarc::ObjCARCAAWrapperPass>())
886  AAR->addAAResult(WrapperPass->getResult());
887  if (auto *WrapperPass = getAnalysisIfAvailable<GlobalsAAWrapperPass>())
888  AAR->addAAResult(WrapperPass->getResult());
889  if (auto *WrapperPass = getAnalysisIfAvailable<SCEVAAWrapperPass>())
890  AAR->addAAResult(WrapperPass->getResult());
891  if (auto *WrapperPass = getAnalysisIfAvailable<CFLAndersAAWrapperPass>())
892  AAR->addAAResult(WrapperPass->getResult());
893  if (auto *WrapperPass = getAnalysisIfAvailable<CFLSteensAAWrapperPass>())
894  AAR->addAAResult(WrapperPass->getResult());
895 
896  // If available, run an external AA providing callback over the results as
897  // well.
898  if (auto *WrapperPass = getAnalysisIfAvailable<ExternalAAWrapperPass>())
899  if (WrapperPass->CB)
900  WrapperPass->CB(*this, F, *AAR);
901 
902  // Analyses don't mutate the IR, so return false.
903  return false;
904 }
905 
907  AU.setPreservesAll();
910 
911  // We also need to mark all the alias analysis passes we will potentially
912  // probe in runOnFunction as used here to ensure the legacy pass manager
913  // preserves them. This hard coding of lists of alias analyses is specific to
914  // the legacy pass manager.
923 }
924 
927  for (auto &Getter : ResultGetters)
928  (*Getter)(F, AM, R);
929  return R;
930 }
931 
933  BasicAAResult &BAR) {
934  AAResults AAR(P.getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(F));
935 
936  // Add in our explicitly constructed BasicAA results.
937  if (!DisableBasicAA)
938  AAR.addAAResult(BAR);
939 
940  // Populate the results with the other currently available AAs.
941  if (auto *WrapperPass =
942  P.getAnalysisIfAvailable<ScopedNoAliasAAWrapperPass>())
943  AAR.addAAResult(WrapperPass->getResult());
944  if (auto *WrapperPass = P.getAnalysisIfAvailable<TypeBasedAAWrapperPass>())
945  AAR.addAAResult(WrapperPass->getResult());
946  if (auto *WrapperPass =
947  P.getAnalysisIfAvailable<objcarc::ObjCARCAAWrapperPass>())
948  AAR.addAAResult(WrapperPass->getResult());
949  if (auto *WrapperPass = P.getAnalysisIfAvailable<GlobalsAAWrapperPass>())
950  AAR.addAAResult(WrapperPass->getResult());
951  if (auto *WrapperPass = P.getAnalysisIfAvailable<CFLAndersAAWrapperPass>())
952  AAR.addAAResult(WrapperPass->getResult());
953  if (auto *WrapperPass = P.getAnalysisIfAvailable<CFLSteensAAWrapperPass>())
954  AAR.addAAResult(WrapperPass->getResult());
955  if (auto *WrapperPass = P.getAnalysisIfAvailable<ExternalAAWrapperPass>())
956  if (WrapperPass->CB)
957  WrapperPass->CB(P, F, AAR);
958 
959  return AAR;
960 }
961 
962 bool llvm::isNoAliasCall(const Value *V) {
963  if (const auto *Call = dyn_cast<CallBase>(V))
964  return Call->hasRetAttr(Attribute::NoAlias);
965  return false;
966 }
967 
968 static bool isNoAliasOrByValArgument(const Value *V) {
969  if (const Argument *A = dyn_cast<Argument>(V))
970  return A->hasNoAliasAttr() || A->hasByValAttr();
971  return false;
972 }
973 
975  if (isa<AllocaInst>(V))
976  return true;
977  if (isa<GlobalValue>(V) && !isa<GlobalAlias>(V))
978  return true;
979  if (isNoAliasCall(V))
980  return true;
982  return true;
983  return false;
984 }
985 
987  return isa<AllocaInst>(V) || isNoAliasCall(V) || isNoAliasOrByValArgument(V);
988 }
989 
990 bool llvm::isEscapeSource(const Value *V) {
991  if (auto *CB = dyn_cast<CallBase>(V))
993  true);
994 
995  // The load case works because isNonEscapingLocalObject considers all
996  // stores to be escapes (it passes true for the StoreCaptures argument
997  // to PointerMayBeCaptured).
998  if (isa<LoadInst>(V))
999  return true;
1000 
1001  // The inttoptr case works because isNonEscapingLocalObject considers all
1002  // means of converting or equating a pointer to an int (ptrtoint, ptr store
1003  // which could be followed by an integer load, ptr<->int compare) as
1004  // escaping, and objects located at well-known addresses via platform-specific
1005  // means cannot be considered non-escaping local objects.
1006  if (isa<IntToPtrInst>(V))
1007  return true;
1008 
1009  return false;
1010 }
1011 
1013  bool &RequiresNoCaptureBeforeUnwind) {
1014  RequiresNoCaptureBeforeUnwind = false;
1015 
1016  // Alloca goes out of scope on unwind.
1017  if (isa<AllocaInst>(Object))
1018  return true;
1019 
1020  // Byval goes out of scope on unwind.
1021  if (auto *A = dyn_cast<Argument>(Object))
1022  return A->hasByValAttr();
1023 
1024  // A noalias return is not accessible from any other code. If the pointer
1025  // does not escape prior to the unwind, then the caller cannot access the
1026  // memory either.
1027  if (isNoAliasCall(Object)) {
1028  RequiresNoCaptureBeforeUnwind = true;
1029  return true;
1030  }
1031 
1032  return false;
1033 }
1034 
1036  // This function needs to be in sync with llvm::createLegacyPMAAResults -- if
1037  // more alias analyses are added to llvm::createLegacyPMAAResults, they need
1038  // to be added here also.
1047 }
llvm::AAResults::addAAResult
void addAAResult(AAResultT &AAResult)
Register a specific AA result.
Definition: AliasAnalysis.h:520
llvm::PreservedAnalyses
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:152
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:28
llvm::AAManager
A manager for alias analyses.
Definition: AliasAnalysis.h:1303
llvm::AliasResult::MayAlias
@ MayAlias
The two locations may or may not alias.
Definition: AliasAnalysis.h:102
llvm::AliasResult::PartialAlias
@ PartialAlias
The two locations alias, but only due to a partial overlap.
Definition: AliasAnalysis.h:104
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:35
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:17
llvm::ExternalAAWrapperPass::ExternalAAWrapperPass
ExternalAAWrapperPass()
Definition: AliasAnalysis.cpp:811
llvm::VAArgInst
This class represents the va_arg llvm instruction, which returns an argument of the specified type gi...
Definition: Instructions.h:1819
llvm::isModOrRefSet
LLVM_NODISCARD bool isModOrRefSet(const ModRefInfo MRI)
Definition: AliasAnalysis.h:189
llvm::ImmutablePass
ImmutablePass class - This class is used to provide information that does not need to be run.
Definition: Pass.h:279
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:780
llvm::MemoryLocation::Ptr
const Value * Ptr
The address of the start of the location.
Definition: MemoryLocation.h:218
aa
aa
Definition: AliasAnalysis.cpp:847
llvm::Function
Definition: Function.h:60
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:685
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:95
llvm::createAAResultsWrapperPass
FunctionPass * createAAResultsWrapperPass()
Definition: AliasAnalysis.cpp:850
Statistic.h
CaptureTracking.h
llvm::enumerate
detail::enumerator< R > enumerate(R &&TheRange)
Given an input range, returns a new range whose values are are pair (A,B) such that A is the 0-based ...
Definition: STLExtras.h:2057
llvm::AtomicCmpXchgInst::getSuccessOrdering
AtomicOrdering getSuccessOrdering() const
Returns the success ordering constraint of this cmpxchg instruction.
Definition: Instructions.h:592
llvm::AAResults::Concept::~Concept
virtual ~Concept()=0
llvm::createModRefInfo
LLVM_NODISCARD ModRefInfo createModRefInfo(const FunctionModRefBehavior FMRB)
Definition: AliasAnalysis.h:377
ValueTracking.h
llvm::DominatorTree
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
Definition: Dominators.h:166
GlobalsModRef.h
isNoAliasOrByValArgument
static bool isNoAliasOrByValArgument(const Value *V)
Definition: AliasAnalysis.cpp:968
llvm::cl::Hidden
@ Hidden
Definition: CommandLine.h:139
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:692
llvm::SimpleAAQueryInfo
AAQueryInfo that uses SimpleCaptureInfo.
Definition: AliasAnalysis.h:502
true
basic Basic Alias true
Definition: BasicAliasAnalysis.cpp:1886
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:227
llvm::Optional
Definition: APInt.h:33
llvm::FenceInst
An instruction for ordering other memory operations.
Definition: Instructions.h:432
llvm::AliasResult
The possible results of an alias query.
Definition: AliasAnalysis.h:81
Results
Function Alias Analysis Results
Definition: AliasAnalysis.cpp:848
llvm::CallBase::arg_begin
User::op_iterator arg_begin()
Return the iterator pointing to the beginning of the argument list.
Definition: InstrTypes.h:1316
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:368
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:1035
I1
@ I1
Definition: DXILOpLowering.cpp:37
F
#define F(x, y, z)
Definition: MD5.cpp:55
llvm::RISCVFenceField::R
@ R
Definition: RISCVBaseInfo.h:240
llvm::BasicBlock
LLVM Basic Block Representation.
Definition: BasicBlock.h:55
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:986
llvm::AAResults::AAResults
AAResults(const TargetLibraryInfo &TLI)
Definition: AliasAnalysis.h:515
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:186
llvm::AAQueryInfo
This class stores info we want to provide to or retain within an alias query.
Definition: AliasAnalysis.h:462
Instruction.h
CommandLine.h
llvm::SPII::Load
@ Load
Definition: SparcInstrInfo.h:32
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:962
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:906
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:660
llvm::ModRefInfo::Ref
@ Ref
The access may reference the value stored in memory.
llvm::AAResults
Definition: AliasAnalysis.h:511
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:117
llvm::ms_demangle::QualifierMangleMode::Result
@ Result
TargetLibraryInfo.h
false
Definition: StackSlotColoring.cpp:141
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:822
llvm::Instruction
Definition: Instruction.h:42
llvm::AAResults::onlyWritesMemory
static bool onlyWritesMemory(FunctionModRefBehavior MRB)
Checks if functions with the specified behavior are known to only write memory (or not access memory ...
Definition: AliasAnalysis.h:685
llvm::ExternalAAWrapperPass::CallbackT
std::function< void(Pass &, Function &, AAResults &)> CallbackT
Definition: AliasAnalysis.h:1370
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:54
llvm::AAManager::run
Result run(Function &F, FunctionAnalysisManager &AM)
Definition: AliasAnalysis.cpp:925
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:225
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:4455
llvm::AnalysisManager::Invalidator
API to communicate dependencies between analyses during invalidation.
Definition: PassManager.h:667
CFLAndersAliasAnalysis.h
llvm::MCID::Call
@ Call
Definition: MCInstrDesc.h:155
llvm::isModSet
LLVM_NODISCARD bool isModSet(const ModRefInfo MRI)
Definition: AliasAnalysis.h:196
llvm::SPII::Store
@ Store
Definition: SparcInstrInfo.h:33
ScopedNoAliasAA.h
llvm::None
const NoneType None
Definition: None.h:24
llvm::CallingConv::ID
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition: CallingConv.h:24
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:932
llvm::AliasResult::getOffset
constexpr int32_t getOffset() const
Definition: AliasAnalysis.h:118
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:222
llvm::OutputFileType::Object
@ Object
llvm::clearMust
LLVM_NODISCARD ModRefInfo clearMust(const ModRefInfo MRI)
Definition: AliasAnalysis.h:228
llvm::TypeBasedAAWrapperPass
Legacy wrapper pass to provide the TypeBasedAAResult object.
Definition: TypeBasedAliasAnalysis.h:71
BasicBlock.h
llvm::cl::opt< bool >
llvm::ExternalAAWrapperPass::ID
static char ID
Definition: AliasAnalysis.h:1374
llvm::StoreInst
An instruction for storing to memory.
Definition: Instructions.h:297
llvm::isNoModRef
LLVM_NODISCARD bool isNoModRef(const ModRefInfo MRI)
Definition: AliasAnalysis.h:185
llvm::SCEVAAWrapperPass
Legacy wrapper pass to provide the SCEVAAResult object.
Definition: ScalarEvolutionAliasAnalysis.h:56
llvm::TargetLibraryInfoWrapperPass
Definition: TargetLibraryInfo.h:468
llvm::CatchReturnInst
Definition: Instructions.h:4538
INITIALIZE_PASS_DEPENDENCY
INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
llvm::BasicAAWrapperPass
Legacy wrapper pass to provide the BasicAAResult object.
Definition: BasicAliasAnalysis.h:173
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:832
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:69
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:789
llvm::AtomicOrdering::Unordered
@ Unordered
I
#define I(x, y, z)
Definition: MD5.cpp:58
llvm::cl::init
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:432
llvm::unionModRef
LLVM_NODISCARD ModRefInfo unionModRef(const ModRefInfo MRI1, const ModRefInfo MRI2)
Definition: AliasAnalysis.h:232
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:121
llvm::ModRefInfo
ModRefInfo
Flags indicating whether a memory access modifies or references memory.
Definition: AliasAnalysis.h:148
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:1675
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:158
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:699
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:268
llvm::isEscapeSource
bool isEscapeSource(const Value *V)
Returns true if the pointer is one which would have been considered an escape by isNonEscapingLocalOb...
Definition: AliasAnalysis.cpp:990
llvm::CallBase::arg_end
User::op_iterator arg_end()
Return the iterator pointing to the end of the argument list.
Definition: InstrTypes.h:1322
llvm::AAResultsWrapperPass::ID
static char ID
Definition: AliasAnalysis.h:1355
llvm::initializeAAResultsWrapperPassPass
void initializeAAResultsWrapperPassPass(PassRegistry &)
llvm::isNotVisibleOnUnwind
bool isNotVisibleOnUnwind(const Value *Object, bool &RequiresNoCaptureBeforeUnwind)
Return true if Object memory is not visible after an unwind, in the sense that program semantics cann...
Definition: AliasAnalysis.cpp:1012
llvm::AAResults::~AAResults
~AAResults()
Definition: AliasAnalysis.cpp:84
llvm::AliasResult::NoAlias
@ NoAlias
The two locations do not alias at all.
Definition: AliasAnalysis.h:99
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:82
llvm::setModAndRef
LLVM_NODISCARD ModRefInfo setModAndRef(const ModRefInfo MRI)
Definition: AliasAnalysis.h:218
llvm::AliasResult::MustAlias
@ MustAlias
The two locations precisely alias each other.
Definition: AliasAnalysis.h:106
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:480
llvm::FunctionModRefBehavior
FunctionModRefBehavior
Summary of how a function affects memory in the program.
Definition: AliasAnalysis.h:262
llvm::LoadInst::getOrdering
AtomicOrdering getOrdering() const
Returns the ordering constraint of this load instruction.
Definition: Instructions.h:225
llvm::BasicAAResult
This is the AA result object for the basic, local, and stateless alias analysis.
Definition: BasicAliasAnalysis.h:44
llvm::LoadInst
An instruction for reading from memory.
Definition: Instructions.h:173
llvm::AAResults::getModRefBehavior
FunctionModRefBehavior getModRefBehavior(const CallBase *Call)
Return the behavior of the given call site.
Definition: AliasAnalysis.cpp:422
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:720
llvm::AtomicRMWInst
an instruction that atomically reads a memory location, combines it with another value,...
Definition: Instructions.h:714
Argument.h
Attributes.h
std
Definition: BitVector.h:851
llvm::isIdentifiedObject
bool isIdentifiedObject(const Value *V)
Return true if this pointer refers to a distinct and identifiable object.
Definition: AliasAnalysis.cpp:974
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:202
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:706
llvm::AAResultsWrapperPass::runOnFunction
bool runOnFunction(Function &F) override
Run the wrapper pass to rebuild an aggregation over known AA passes.
Definition: AliasAnalysis.cpp:862
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:119
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:162
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
AA
llvm::CatchPadInst
Definition: Instructions.h:4487
llvm::AAResultsWrapperPass::AAResultsWrapperPass
AAResultsWrapperPass()
Definition: AliasAnalysis.cpp:830
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:177
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:199
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:1351
llvm::Instruction::getParent
const BasicBlock * getParent() const
Definition: Instruction.h:91
llvm::ExternalAAWrapperPass
A wrapper pass for external alias analyses.
Definition: AliasAnalysis.h:1369
llvm::GlobalsAAWrapperPass
Legacy wrapper pass to provide the GlobalsAAResult object.
Definition: GlobalsModRef.h:148
llvm::isStrongerThanMonotonic
bool isStrongerThanMonotonic(AtomicOrdering AO)
Definition: AtomicOrdering.h:124
llvm::setMust
LLVM_NODISCARD ModRefInfo setMust(const ModRefInfo MRI)
Definition: AliasAnalysis.h:214
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:779
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:852
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:278
llvm::CallBase
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Definition: InstrTypes.h:1174
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:310
llvm::AnalysisManager
A container for analyses that lazily runs them and caches their results.
Definition: InstructionSimplify.h:42
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:308
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:236
llvm::initializeExternalAAWrapperPassPass
void initializeExternalAAWrapperPassPass(PassRegistry &)
Value.h
llvm::Optional::value_or
constexpr T value_or(U &&alt) const &
Definition: Optional.h:318
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:269
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:509
llvm::TargetLibraryAnalysis
Analysis pass providing the TargetLibraryInfo.
Definition: TargetLibraryInfo.h:443
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:217
llvm::isIntrinsicReturningPointerAliasingArgumentWithoutCapturing
bool isIntrinsicReturningPointerAliasingArgumentWithoutCapturing(const CallBase *Call, bool MustPreserveNullness)
{launder,strip}.invariant.group returns pointer that aliases its argument, and it only captures point...
Definition: ValueTracking.cpp:4413
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:210
llvm::BasicBlock::const_iterator
InstListType::const_iterator const_iterator
Definition: BasicBlock.h:88
llvm::AAQueryInfo::Depth
unsigned Depth
Query depth used to distinguish recursive queries.
Definition: AliasAnalysis.h:479