LLVM  13.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 /// 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 
70 #ifndef NDEBUG
71 /// Print a trace of alias analysis queries and their results.
72 static cl::opt<bool> EnableAATrace("aa-trace", cl::Hidden, cl::init(false));
73 #else
74 static const bool EnableAATrace = false;
75 #endif
76 
78  : TLI(Arg.TLI), AAs(std::move(Arg.AAs)), AADeps(std::move(Arg.AADeps)) {
79  for (auto &AA : AAs)
80  AA->setAAResults(this);
81 }
82 
84 // FIXME; It would be nice to at least clear out the pointers back to this
85 // aggregation here, but we end up with non-nesting lifetimes in the legacy
86 // pass manager that prevent this from working. In the legacy pass manager
87 // we'll end up with dangling references here in some cases.
88 #if 0
89  for (auto &AA : AAs)
90  AA->setAAResults(nullptr);
91 #endif
92 }
93 
96  // AAResults preserves the AAManager by default, due to the stateless nature
97  // of AliasAnalysis. There is no need to check whether it has been preserved
98  // explicitly. Check if any module dependency was invalidated and caused the
99  // AAManager to be invalidated. Invalidate ourselves in that case.
100  auto PAC = PA.getChecker<AAManager>();
101  if (!PAC.preservedWhenStateless())
102  return true;
103 
104  // Check if any of the function dependencies were invalidated, and invalidate
105  // ourselves in that case.
106  for (AnalysisKey *ID : AADeps)
107  if (Inv.invalidate(ID, F, PA))
108  return true;
109 
110  // Everything we depend on is still fine, so are we. Nothing to invalidate.
111  return false;
112 }
113 
114 //===----------------------------------------------------------------------===//
115 // Default chaining methods
116 //===----------------------------------------------------------------------===//
117 
119  const MemoryLocation &LocB) {
120  AAQueryInfo AAQIP;
121  return alias(LocA, LocB, AAQIP);
122 }
123 
125  const MemoryLocation &LocB, AAQueryInfo &AAQI) {
127 
128  if (EnableAATrace) {
129  for (unsigned I = 0; I < AAQI.Depth; ++I)
130  dbgs() << " ";
131  dbgs() << "Start " << *LocA.Ptr << " @ " << LocA.Size << ", "
132  << *LocB.Ptr << " @ " << LocB.Size << "\n";
133  }
134 
135  AAQI.Depth++;
136  for (const auto &AA : AAs) {
137  Result = AA->alias(LocA, LocB, AAQI);
138  if (Result != AliasResult::MayAlias)
139  break;
140  }
141  AAQI.Depth--;
142 
143  if (EnableAATrace) {
144  for (unsigned I = 0; I < AAQI.Depth; ++I)
145  dbgs() << " ";
146  dbgs() << "End " << *LocA.Ptr << " @ " << LocA.Size << ", "
147  << *LocB.Ptr << " @ " << LocB.Size << " = " << Result << "\n";
148  }
149 
150  if (AAQI.Depth == 0) {
151  if (Result == AliasResult::NoAlias)
152  ++NumNoAlias;
153  else if (Result == AliasResult::MustAlias)
154  ++NumMustAlias;
155  else
156  ++NumMayAlias;
157  }
158  return Result;
159 }
160 
162  bool OrLocal) {
163  AAQueryInfo AAQIP;
164  return pointsToConstantMemory(Loc, AAQIP, OrLocal);
165 }
166 
168  AAQueryInfo &AAQI, bool OrLocal) {
169  for (const auto &AA : AAs)
170  if (AA->pointsToConstantMemory(Loc, AAQI, OrLocal))
171  return true;
172 
173  return false;
174 }
175 
176 ModRefInfo AAResults::getArgModRefInfo(const CallBase *Call, unsigned ArgIdx) {
178 
179  for (const auto &AA : AAs) {
180  Result = intersectModRef(Result, AA->getArgModRefInfo(Call, ArgIdx));
181 
182  // Early-exit the moment we reach the bottom of the lattice.
183  if (isNoModRef(Result))
184  return ModRefInfo::NoModRef;
185  }
186 
187  return Result;
188 }
189 
191  AAQueryInfo AAQIP;
192  return getModRefInfo(I, Call2, AAQIP);
193 }
194 
196  AAQueryInfo &AAQI) {
197  // We may have two calls.
198  if (const auto *Call1 = dyn_cast<CallBase>(I)) {
199  // Check if the two calls modify the same memory.
200  return getModRefInfo(Call1, Call2, AAQI);
201  } else if (I->isFenceLike()) {
202  // If this is a fence, just return ModRef.
203  return ModRefInfo::ModRef;
204  } else {
205  // Otherwise, check if the call modifies or references the
206  // location this memory access defines. The best we can say
207  // is that if the call references what this instruction
208  // defines, it must be clobbered by this location.
209  const MemoryLocation DefLoc = MemoryLocation::get(I);
210  ModRefInfo MR = getModRefInfo(Call2, DefLoc, AAQI);
211  if (isModOrRefSet(MR))
212  return setModAndRef(MR);
213  }
214  return ModRefInfo::NoModRef;
215 }
216 
218  const MemoryLocation &Loc) {
219  AAQueryInfo 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 (doesNotReadMemory(MRB))
245  Result = clearRef(Result);
246 
248  bool IsMustAlias = true;
249  ModRefInfo AllArgsMask = ModRefInfo::NoModRef;
250  if (doesAccessArgPointees(MRB)) {
251  for (auto AI = Call->arg_begin(), AE = Call->arg_end(); AI != AE; ++AI) {
252  const Value *Arg = *AI;
253  if (!Arg->getType()->isPointerTy())
254  continue;
255  unsigned ArgIdx = std::distance(Call->arg_begin(), AI);
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  AAQueryInfo 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 (doesNotReadMemory(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  AAQueryInfo 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  AAQueryInfo 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  AAQueryInfo 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  AAQueryInfo 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  AAQueryInfo 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  AAQueryInfo 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  AAQueryInfo 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  AAQueryInfo 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.getValueOr(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  return getModRefInfo((const CallInst *)I, Loc, AAQIP);
699  case Instruction::Invoke:
700  return getModRefInfo((const InvokeInst *)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  return ModRefInfo::NoModRef;
707  }
708 }
709 
710 /// Return information about whether a particular call site modifies
711 /// or reads the specified memory location \p MemLoc before instruction \p I
712 /// in a BasicBlock.
713 /// FIXME: this is really just shoring-up a deficiency in alias analysis.
714 /// BasicAA isn't willing to spend linear time determining whether an alloca
715 /// was captured before or after this particular call, while we are. However,
716 /// with a smarter AA in place, this test is just wasting compile time.
718  const MemoryLocation &MemLoc,
719  DominatorTree *DT) {
720  if (!DT)
721  return ModRefInfo::ModRef;
722 
723  const Value *Object = getUnderlyingObject(MemLoc.Ptr);
724  if (!isIdentifiedObject(Object) || isa<GlobalValue>(Object) ||
725  isa<Constant>(Object))
726  return ModRefInfo::ModRef;
727 
728  const auto *Call = dyn_cast<CallBase>(I);
729  if (!Call || Call == Object)
730  return ModRefInfo::ModRef;
731 
732  if (PointerMayBeCapturedBefore(Object, /* ReturnCaptures */ true,
733  /* StoreCaptures */ true, I, DT,
734  /* include Object */ true))
735  return ModRefInfo::ModRef;
736 
737  unsigned ArgNo = 0;
739  bool IsMustAlias = true;
740  // Set flag only if no May found and all operands processed.
741  for (auto CI = Call->data_operands_begin(), CE = Call->data_operands_end();
742  CI != CE; ++CI, ++ArgNo) {
743  // Only look at the no-capture or byval pointer arguments. If this
744  // pointer were passed to arguments that were neither of these, then it
745  // couldn't be no-capture.
746  if (!(*CI)->getType()->isPointerTy() ||
747  (!Call->doesNotCapture(ArgNo) && ArgNo < Call->getNumArgOperands() &&
748  !Call->isByValArgument(ArgNo)))
749  continue;
750 
751  AliasResult AR = alias(*CI, Object);
752  // If this is a no-capture pointer argument, see if we can tell that it
753  // is impossible to alias the pointer we're checking. If not, we have to
754  // assume that the call could touch the pointer, even though it doesn't
755  // escape.
756  if (AR != AliasResult::MustAlias)
757  IsMustAlias = false;
758  if (AR == AliasResult::NoAlias)
759  continue;
760  if (Call->doesNotAccessMemory(ArgNo))
761  continue;
762  if (Call->onlyReadsMemory(ArgNo)) {
763  R = ModRefInfo::Ref;
764  continue;
765  }
766  // Not returning MustModRef since we have not seen all the arguments.
767  return ModRefInfo::ModRef;
768  }
769  return IsMustAlias ? setMust(R) : clearMust(R);
770 }
771 
772 /// canBasicBlockModify - Return true if it is possible for execution of the
773 /// specified basic block to modify the location Loc.
774 ///
776  const MemoryLocation &Loc) {
777  return canInstructionRangeModRef(BB.front(), BB.back(), Loc, ModRefInfo::Mod);
778 }
779 
780 /// canInstructionRangeModRef - Return true if it is possible for the
781 /// execution of the specified instructions to mod\ref (according to the
782 /// mode) the location Loc. The instructions to consider are all
783 /// of the instructions in the range of [I1,I2] INCLUSIVE.
784 /// I1 and I2 must be in the same basic block.
786  const Instruction &I2,
787  const MemoryLocation &Loc,
788  const ModRefInfo Mode) {
789  assert(I1.getParent() == I2.getParent() &&
790  "Instructions not in same basic block!");
793  ++E; // Convert from inclusive to exclusive range.
794 
795  for (; I != E; ++I) // Check every instruction in range
797  return true;
798  return false;
799 }
800 
801 // Provide a definition for the root virtual destructor.
802 AAResults::Concept::~Concept() = default;
803 
804 // Provide a definition for the static object used to identify passes.
805 AnalysisKey AAManager::Key;
806 
807 namespace {
808 
809 
810 } // end anonymous namespace
811 
814 }
815 
817  : ImmutablePass(ID), CB(std::move(CB)) {
819 }
820 
822 
823 INITIALIZE_PASS(ExternalAAWrapperPass, "external-aa", "External Alias Analysis",
824  false, true)
825 
828  return new ExternalAAWrapperPass(std::move(Callback));
829 }
830 
833 }
834 
835 char AAResultsWrapperPass::ID = 0;
836 
838  "Function Alias Analysis Results", false, true)
844 INITIALIZE_PASS_DEPENDENCY(ObjCARCAAWrapperPass)
849  "Function Alias Analysis Results", false, true)
850 
852  return new AAResultsWrapperPass();
853 }
854 
855 /// Run the wrapper pass to rebuild an aggregation over known AA passes.
856 ///
857 /// This is the legacy pass manager's interface to the new-style AA results
858 /// aggregation object. Because this is somewhat shoe-horned into the legacy
859 /// pass manager, we hard code all the specific alias analyses available into
860 /// it. While the particular set enabled is configured via commandline flags,
861 /// adding a new alias analysis to LLVM will require adding support for it to
862 /// this list.
864  // NB! This *must* be reset before adding new AA results to the new
865  // AAResults object because in the legacy pass manager, each instance
866  // of these will refer to the *same* immutable analyses, registering and
867  // unregistering themselves with them. We need to carefully tear down the
868  // previous object first, in this case replacing it with an empty one, before
869  // registering new results.
870  AAR.reset(
871  new AAResults(getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(F)));
872 
873  // BasicAA is always available for function analyses. Also, we add it first
874  // so that it can trump TBAA results when it proves MustAlias.
875  // FIXME: TBAA should have an explicit mode to support this and then we
876  // should reconsider the ordering here.
877  if (!DisableBasicAA)
878  AAR->addAAResult(getAnalysis<BasicAAWrapperPass>().getResult());
879 
880  // Populate the results with the currently available AAs.
881  if (auto *WrapperPass = getAnalysisIfAvailable<ScopedNoAliasAAWrapperPass>())
882  AAR->addAAResult(WrapperPass->getResult());
883  if (auto *WrapperPass = getAnalysisIfAvailable<TypeBasedAAWrapperPass>())
884  AAR->addAAResult(WrapperPass->getResult());
885  if (auto *WrapperPass =
886  getAnalysisIfAvailable<objcarc::ObjCARCAAWrapperPass>())
887  AAR->addAAResult(WrapperPass->getResult());
888  if (auto *WrapperPass = getAnalysisIfAvailable<GlobalsAAWrapperPass>())
889  AAR->addAAResult(WrapperPass->getResult());
890  if (auto *WrapperPass = getAnalysisIfAvailable<SCEVAAWrapperPass>())
891  AAR->addAAResult(WrapperPass->getResult());
892  if (auto *WrapperPass = getAnalysisIfAvailable<CFLAndersAAWrapperPass>())
893  AAR->addAAResult(WrapperPass->getResult());
894  if (auto *WrapperPass = getAnalysisIfAvailable<CFLSteensAAWrapperPass>())
895  AAR->addAAResult(WrapperPass->getResult());
896 
897  // If available, run an external AA providing callback over the results as
898  // well.
899  if (auto *WrapperPass = getAnalysisIfAvailable<ExternalAAWrapperPass>())
900  if (WrapperPass->CB)
901  WrapperPass->CB(*this, F, *AAR);
902 
903  // Analyses don't mutate the IR, so return false.
904  return false;
905 }
906 
908  AU.setPreservesAll();
911 
912  // We also need to mark all the alias analysis passes we will potentially
913  // probe in runOnFunction as used here to ensure the legacy pass manager
914  // preserves them. This hard coding of lists of alias analyses is specific to
915  // the legacy pass manager.
924 }
925 
928  for (auto &Getter : ResultGetters)
929  (*Getter)(F, AM, R);
930  return R;
931 }
932 
934  BasicAAResult &BAR) {
935  AAResults AAR(P.getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(F));
936 
937  // Add in our explicitly constructed BasicAA results.
938  if (!DisableBasicAA)
939  AAR.addAAResult(BAR);
940 
941  // Populate the results with the other currently available AAs.
942  if (auto *WrapperPass =
943  P.getAnalysisIfAvailable<ScopedNoAliasAAWrapperPass>())
944  AAR.addAAResult(WrapperPass->getResult());
945  if (auto *WrapperPass = P.getAnalysisIfAvailable<TypeBasedAAWrapperPass>())
946  AAR.addAAResult(WrapperPass->getResult());
947  if (auto *WrapperPass =
948  P.getAnalysisIfAvailable<objcarc::ObjCARCAAWrapperPass>())
949  AAR.addAAResult(WrapperPass->getResult());
950  if (auto *WrapperPass = P.getAnalysisIfAvailable<GlobalsAAWrapperPass>())
951  AAR.addAAResult(WrapperPass->getResult());
952  if (auto *WrapperPass = P.getAnalysisIfAvailable<CFLAndersAAWrapperPass>())
953  AAR.addAAResult(WrapperPass->getResult());
954  if (auto *WrapperPass = P.getAnalysisIfAvailable<CFLSteensAAWrapperPass>())
955  AAR.addAAResult(WrapperPass->getResult());
956  if (auto *WrapperPass = P.getAnalysisIfAvailable<ExternalAAWrapperPass>())
957  if (WrapperPass->CB)
958  WrapperPass->CB(P, F, AAR);
959 
960  return AAR;
961 }
962 
963 bool llvm::isNoAliasCall(const Value *V) {
964  if (const auto *Call = dyn_cast<CallBase>(V))
965  return Call->hasRetAttr(Attribute::NoAlias);
966  return false;
967 }
968 
969 static bool isNoAliasOrByValArgument(const Value *V) {
970  if (const Argument *A = dyn_cast<Argument>(V))
971  return A->hasNoAliasAttr() || A->hasByValAttr();
972  return false;
973 }
974 
976  if (isa<AllocaInst>(V))
977  return true;
978  if (isa<GlobalValue>(V) && !isa<GlobalAlias>(V))
979  return true;
980  if (isNoAliasCall(V))
981  return true;
983  return true;
984  return false;
985 }
986 
988  return isa<AllocaInst>(V) || isNoAliasCall(V) || isNoAliasOrByValArgument(V);
989 }
990 
992  // This function needs to be in sync with llvm::createLegacyPMAAResults -- if
993  // more alias analyses are added to llvm::createLegacyPMAAResults, they need
994  // to be added here also.
1003 }
llvm::AAResults::addAAResult
void addAAResult(AAResultT &AAResult)
Register a specific AA result.
Definition: AliasAnalysis.h:465
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:1221
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:37
llvm
Definition: AllocatorList.h:23
llvm::ExternalAAWrapperPass::ExternalAAWrapperPass
ExternalAAWrapperPass()
Definition: AliasAnalysis.cpp:812
llvm::VAArgInst
This class represents the va_arg llvm instruction, which returns an argument of the specified type gi...
Definition: Instructions.h:1810
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: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:785
llvm::MemoryLocation::Ptr
const Value * Ptr
The address of the start of the location.
Definition: MemoryLocation.h:217
aa
aa
Definition: AliasAnalysis.cpp:848
llvm::Function
Definition: Function.h:61
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:94
llvm::createAAResultsWrapperPass
FunctionPass * createAAResultsWrapperPass()
Definition: AliasAnalysis.cpp:851
Statistic.h
CaptureTracking.h
llvm::AtomicCmpXchgInst::getSuccessOrdering
AtomicOrdering getSuccessOrdering() const
Returns the success ordering constraint of this cmpxchg instruction.
Definition: Instructions.h:594
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:151
GlobalsModRef.h
isNoAliasOrByValArgument
static bool isNoAliasOrByValArgument(const Value *V)
Definition: AliasAnalysis.cpp:969
llvm::cl::Hidden
@ Hidden
Definition: CommandLine.h:140
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:637
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:34
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:81
Results
Function Alias Analysis Results
Definition: AliasAnalysis.cpp:849
llvm::CallBase::arg_begin
User::op_iterator arg_begin()
Return the iterator pointing to the beginning of the argument list.
Definition: InstrTypes.h:1306
DisableBasicAA
cl::opt< bool > DisableBasicAA("disable-basic-aa", cl::Hidden, cl::init(false))
Allow disabling BasicAA from the AA results.
BasicAliasAnalysis.h
llvm::PointerMayBeCapturedBefore
bool PointerMayBeCapturedBefore(const Value *V, bool ReturnCaptures, bool StoreCaptures, const Instruction *I, const DominatorTree *DT, bool IncludeI=false, unsigned MaxUsesToExplore=0)
PointerMayBeCapturedBefore - Return true if this pointer value may be captured by the enclosing funct...
Definition: CaptureTracking.cpp:221
llvm::FMRB_UnknownModRefBehavior
@ FMRB_UnknownModRefBehavior
This indicates that the function could not be classified into one of the behaviors above.
Definition: AliasAnalysis.h:368
INITIALIZE_PASS_END
INITIALIZE_PASS_END(RegBankSelect, DEBUG_TYPE, "Assign register bank of generic virtual registers", false, false) RegBankSelect
Definition: RegBankSelect.cpp:69
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:991
F
#define F(x, y, z)
Definition: MD5.cpp:56
llvm::RISCVFenceField::R
@ R
Definition: RISCVBaseInfo.h:129
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:132
llvm::isIdentifiedFunctionLocal
bool isIdentifiedFunctionLocal(const Value *V)
Return true if V is umabigously identified at the function-level.
Definition: AliasAnalysis.cpp:987
llvm::AAResults::AAResults
AAResults(const TargetLibraryInfo &TLI)
Definition: AliasAnalysis.h:460
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:205
llvm::AAQueryInfo
This class stores info we want to provide to or retain within an alias query.
Definition: AliasAnalysis.h:414
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:963
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:907
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:605
llvm::ModRefInfo::Ref
@ Ref
The access may reference the value stored in memory.
llvm::AAResults
Definition: AliasAnalysis.h:456
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::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.cpp:717
llvm::AliasResult::hasOffset
constexpr bool hasOffset() const
Definition: AliasAnalysis.h:117
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:823
llvm::Instruction
Definition: Instruction.h:45
llvm::ExternalAAWrapperPass::CallbackT
std::function< void(Pass &, Function &, AAResults &)> CallbackT
Definition: AliasAnalysis.h:1288
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:50
llvm::AAManager::run
Result run(Function &F, FunctionAnalysisManager &AM)
Definition: AliasAnalysis.cpp:926
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:4272
llvm::AnalysisManager::Invalidator
API to communicate dependencies between analyses during invalidation.
Definition: PassManager.h:670
CFLAndersAliasAnalysis.h
llvm::MCID::Call
@ Call
Definition: MCInstrDesc.h:154
llvm::isModSet
LLVM_NODISCARD bool isModSet(const ModRefInfo MRI)
Definition: AliasAnalysis.h:196
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:933
llvm::AliasResult::getOffset
constexpr int32_t getOffset() const
Definition: AliasAnalysis.h:118
llvm::clearMod
LLVM_NODISCARD ModRefInfo clearMod(const ModRefInfo MRI)
Definition: AliasAnalysis.h:222
llvm::InvokeInst
Invoke instruction.
Definition: Instructions.h:3686
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
llvm::Optional::getValueOr
constexpr T getValueOr(U &&value) const LLVM_LVALUE_FUNCTION
Definition: Optional.h:295
BasicBlock.h
llvm::cl::opt< bool >
llvm::ExternalAAWrapperPass::ID
static char ID
Definition: AliasAnalysis.h:1292
llvm::StoreInst
An instruction for storing to memory.
Definition: Instructions.h:303
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:52
llvm::TargetLibraryInfoWrapperPass
Definition: TargetLibraryInfo.h:446
llvm::CatchReturnInst
Definition: Instructions.h:4461
INITIALIZE_PASS_DEPENDENCY
INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
llvm::BasicAAWrapperPass
Legacy wrapper pass to provide the BasicAAResult object.
Definition: BasicAliasAnalysis.h:245
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:821
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:785
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:440
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:123
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:1563
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:147
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:644
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::CallBase::arg_end
User::op_iterator arg_end()
Return the iterator pointing to the end of the argument list.
Definition: InstrTypes.h:1312
llvm::AAResultsWrapperPass::ID
static char ID
Definition: AliasAnalysis.h:1273
llvm::initializeAAResultsWrapperPassPass
void initializeAAResultsWrapperPassPass(PassRegistry &)
llvm::SPII::Load
@ Load
Definition: SparcInstrInfo.h:32
llvm::AAResults::~AAResults
~AAResults()
Definition: AliasAnalysis.cpp:83
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:81
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:458
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:231
llvm::BasicAAResult
This is the AA result object for the basic, local, and stateless alias analysis.
Definition: BasicAliasAnalysis.h:50
llvm::LoadInst
An instruction for reading from memory.
Definition: Instructions.h:174
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:665
llvm::SPII::Store
@ Store
Definition: SparcInstrInfo.h:33
llvm::AtomicRMWInst
an instruction that atomically reads a memory location, combines it with another value,...
Definition: Instructions.h:702
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:975
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::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:630
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:651
llvm::AAResultsWrapperPass::runOnFunction
bool runOnFunction(Function &F) override
Run the wrapper pass to rebuild an aggregation over known AA passes.
Definition: AliasAnalysis.cpp:863
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:118
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:161
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:4410
llvm::AAResultsWrapperPass::AAResultsWrapperPass
AAResultsWrapperPass()
Definition: AliasAnalysis.cpp:831
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:176
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::AAResultsWrapperPass
A wrapper pass to provide the legacy pass manager access to a suitably prepared AAResults object.
Definition: AliasAnalysis.h:1269
llvm::Instruction::getParent
const BasicBlock * getParent() const
Definition: Instruction.h:94
llvm::ExternalAAWrapperPass
A wrapper pass for external alias analyses.
Definition: AliasAnalysis.h:1287
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: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:775
llvm::CallBase
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Definition: InstrTypes.h:1164
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:1450
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
true
basic Basic Alias true
Definition: BasicAliasAnalysis.cpp:1789
llvm::initializeExternalAAWrapperPassPass
void initializeExternalAAWrapperPassPass(PassRegistry &)
Value.h
InitializePasses.h
llvm::Value
LLVM Value Representation.
Definition: Value.h:75
llvm::AtomicCmpXchgInst
An instruction that atomically checks whether a specified value is in a memory location,...
Definition: Instructions.h:522
llvm::TargetLibraryAnalysis
Analysis pass providing the TargetLibraryInfo.
Definition: TargetLibraryInfo.h:421
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
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:432
llvm::Intrinsic::ID
unsigned ID
Definition: TargetTransformInfo.h:38