reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

References

include/llvm/Analysis/AliasSetTracker.h

  301   void addUnknownInst(Instruction *I, AliasAnalysis &AA);
  319                              const AAMDNodes &AAInfo, AliasAnalysis &AA) const;
  320   bool aliasesUnknownInst(const Instruction *Inst, AliasAnalysis &AA) const;
  346   AliasAnalysis &AA;
  360   explicit AliasSetTracker(AliasAnalysis &aa) : AA(aa) {}
  361   explicit AliasSetTracker(AliasAnalysis &aa, MemorySSA *mssa, Loop *l)
  401   AliasAnalysis &getAliasAnalysis() const { return AA; }

include/llvm/Analysis/DependenceAnalysis.h

  273     DependenceInfo(Function *F, AliasAnalysis *AA, ScalarEvolution *SE,
  336     AliasAnalysis *AA;

include/llvm/Analysis/Loads.h

  123                                 AliasAnalysis *AA = nullptr,
  153                                  unsigned MaxInstsToScan, AliasAnalysis *AA,

include/llvm/Analysis/LoopAccessAnalysis.h

  519                  AliasAnalysis *AA, DominatorTree *DT, LoopInfo *LI);
  610   void analyzeLoop(AliasAnalysis *AA, LoopInfo *LI,
  755   AliasAnalysis *AA;

include/llvm/Analysis/LoopCacheAnalysis.h

   73                                  AliasAnalysis &AA) const;
   81                                   DependenceInfo &DI, AliasAnalysis &AA) const;
  121   bool isAliased(const IndexedReference &Other, AliasAnalysis &AA) const;
  186             TargetTransformInfo &TTI, AliasAnalysis &AA, DependenceInfo &DI,
  261   AliasAnalysis &AA;

include/llvm/Analysis/MemoryDependenceAnalysis.h

  358   AliasAnalysis &AA;
  368   MemoryDependenceResults(AliasAnalysis &AA, AssumptionCache &AC,

include/llvm/Analysis/MemorySSA.h

  705   MemorySSA(Function &, AliasAnalysis *, DominatorTree *);
  843   CachingWalker<AliasAnalysis> *getWalkerImpl();
  871   AliasAnalysis *AA;
  895   std::unique_ptr<ClobberWalkerBase<AliasAnalysis>> WalkerBase;
  896   std::unique_ptr<CachingWalker<AliasAnalysis>> Walker;
  897   std::unique_ptr<SkipSelfWalker<AliasAnalysis>> SkipWalker;
  909                                   AliasAnalysis &AA);

include/llvm/Analysis/ObjCARCAnalysisUtils.h

  178                                                AliasAnalysis &AA) {

include/llvm/CodeGen/LiveIntervals.h

   59     AliasAnalysis *AA;
  215     AliasAnalysis *getAliasAnalysis() const {

include/llvm/CodeGen/LiveRangeEdit.h

   97   void scanRemattable(AliasAnalysis *aa);
  113                         AliasAnalysis *AA);
  193   bool anyRematerializable(AliasAnalysis *);
  198                              AliasAnalysis *);
  247                          AliasAnalysis *AA = nullptr);

include/llvm/CodeGen/MachinePipeliner.h

  284   void addLoopCarriedDependences(AliasAnalysis *AA);

include/llvm/CodeGen/MachineScheduler.h

  124   AliasAnalysis *AA = nullptr;
  264   AliasAnalysis *AA;

include/llvm/LinkAllPasses.h

  236       llvm::AliasAnalysis AA(TLI);

include/llvm/Transforms/Scalar/GVN.h

   83   AliasAnalysis *getAliasAnalysis() const { return VN.getAliasAnalysis(); }
  110     AliasAnalysis *AA;
  145     void setAliasAnalysis(AliasAnalysis *A) { AA = A; }
  146     AliasAnalysis *getAliasAnalysis() const { return AA; }

include/llvm/Transforms/Scalar/JumpThreading.h

   80   AliasAnalysis *AA;
   99                AliasAnalysis *AA_, DomTreeUpdater *DTU_, bool HasProfileData_,

include/llvm/Transforms/Scalar/MemCpyOptimizer.h

   42   std::function<AliasAnalysis &()> LookupAliasAnalysis;
   54                std::function<AliasAnalysis &()> LookupAliasAnalysis_,

include/llvm/Transforms/Utils/Local.h

  229 bool FlattenCFG(BasicBlock *BB, AliasAnalysis *AA = nullptr);

include/llvm/Transforms/Utils/LoopUtils.h

  120 bool sinkRegion(DomTreeNode *, AliasAnalysis *, LoopInfo *, DominatorTree *,
  133 bool hoistRegion(DomTreeNode *, AliasAnalysis *, LoopInfo *, DominatorTree *,

include/llvm/Transforms/Vectorize/LoopVectorizationLegality.h

  201       TargetTransformInfo *TTI, TargetLibraryInfo *TLI, AliasAnalysis *AA,

include/llvm/Transforms/Vectorize/LoopVectorize.h

  139   AliasAnalysis *AA;
  151                DemandedBits &DB_, AliasAnalysis &AA_, AssumptionCache &AC_,

include/llvm/Transforms/Vectorize/SLPVectorizer.h

   68   AliasAnalysis *AA = nullptr;
   80                TargetLibraryInfo *TLI_, AliasAnalysis *AA_, LoopInfo *LI_,

lib/Analysis/AliasSetTracker.cpp

   65     AliasAnalysis &AA = AST.getAliasAnalysis();
  144         AliasAnalysis &AA = AST.getAliasAnalysis();
  173 void AliasSet::addUnknownInst(Instruction *I, AliasAnalysis &AA) {
  200                                      AliasAnalysis &AA) const {
  237                                   AliasAnalysis &AA) const {

lib/Analysis/DependenceAnalysis.cpp

  644 static AliasResult underlyingObjectsAlias(AliasAnalysis *AA,

lib/Analysis/Lint.cpp

  130     AliasAnalysis *AA;

lib/Analysis/Loads.cpp

  365                                       AliasAnalysis *AA, bool *IsLoad,
  380                                        AliasAnalysis *AA, bool *IsLoadCSE,

lib/Analysis/LoopAccessAnalysis.cpp

  502   AccessAnalysis(const DataLayout &Dl, Loop *TheLoop, AliasAnalysis *AA,
 1789 void LoopAccessInfo::analyzeLoop(AliasAnalysis *AA, LoopInfo *LI,
 2345                                const TargetLibraryInfo *TLI, AliasAnalysis *AA,

lib/Analysis/LoopCacheAnalysis.cpp

  142                                                  AliasAnalysis &AA) const {
  199                                                   AliasAnalysis &AA) const {
  434                                  AliasAnalysis &AA) const {

lib/Analysis/MemorySSA.cpp

  329                                         AliasAnalysis &AA) {
 1224 MemorySSA::MemorySSA(Function &Func, AliasAnalysis *AA, DominatorTree *DT)
 1563 MemorySSA::CachingWalker<AliasAnalysis> *MemorySSA::getWalkerImpl() {
 1569         std::make_unique<ClobberWalkerBase<AliasAnalysis>>(this, AA, DT);
 1572       std::make_unique<CachingWalker<AliasAnalysis>>(this, WalkerBase.get());
 1582         std::make_unique<ClobberWalkerBase<AliasAnalysis>>(this, AA, DT);
 1585       std::make_unique<SkipSelfWalker<AliasAnalysis>>(this, WalkerBase.get());

lib/CodeGen/ImplicitNullChecks.cpp

  165   AliasAnalysis *AA = nullptr;

lib/CodeGen/InlineSpiller.cpp

   89   AliasAnalysis *AA;
  162   AliasAnalysis *AA;

lib/CodeGen/LiveRangeEdit.cpp

   72                                           AliasAnalysis *aa) {
   81 void LiveRangeEdit::scanRemattable(AliasAnalysis *aa) {
   98 bool LiveRangeEdit::anyRematerializable(AliasAnalysis *aa) {
  394                                       AliasAnalysis *AA) {

lib/CodeGen/MachineCSE.cpp

   67     AliasAnalysis *AA;

lib/CodeGen/MachineLICM.cpp

  103     AliasAnalysis        *AA;      // Alias analysis info.

lib/CodeGen/MachinePipeliner.cpp

  426   AliasAnalysis *AA = &Pass.getAnalysis<AAResultsWrapperPass>().getAAResults();
  628 static bool isDependenceBarrier(MachineInstr &MI, AliasAnalysis *AA) {
  660 void SwingSchedulerDAG::addLoopCarriedDependences(AliasAnalysis *AA) {

lib/CodeGen/MachineSink.cpp

   93     AliasAnalysis *AA;

lib/CodeGen/PostRASchedulerList.cpp

  131     AliasAnalysis *AA;
  147         MachineFunction &MF, MachineLoopInfo &MLI, AliasAnalysis *AA,
  206     MachineFunction &MF, MachineLoopInfo &MLI, AliasAnalysis *AA,
  287   AliasAnalysis *AA = &getAnalysis<AAResultsWrapperPass>().getAAResults();

lib/CodeGen/RegAllocGreedy.cpp

  175   AliasAnalysis *AA;

lib/CodeGen/RegisterCoalescer.cpp

  130     AliasAnalysis *AA;

lib/CodeGen/SelectionDAG/DAGCombiner.cpp

  173     AliasAnalysis *AA;
  217     DAGCombiner(SelectionDAG &D, AliasAnalysis *AA, CodeGenOpt::Level OL)
20889 void SelectionDAG::Combine(CombineLevel Level, AliasAnalysis *AA,

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

 1008 void SelectionDAGBuilder::init(GCFunctionInfo *gfi, AliasAnalysis *aa,

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h

  380   AliasAnalysis *AA = nullptr;
  432   void init(GCFunctionInfo *gfi, AliasAnalysis *AA,

lib/CodeGen/SplitKit.cpp

  365 SplitEditor::SplitEditor(SplitAnalysis &sa, AliasAnalysis &aa,

lib/CodeGen/SplitKit.h

  259   AliasAnalysis &AA;
  445   SplitEditor(SplitAnalysis &sa, AliasAnalysis &aa, LiveIntervals &lis,

lib/CodeGen/TwoAddressInstructionPass.cpp

  100   AliasAnalysis *AA;

lib/Target/AArch64/AArch64LoadStoreOptimizer.cpp

   95   AliasAnalysis *AA;
 1081                      AliasAnalysis *AA) {
 1095                      AliasAnalysis *AA) {

lib/Target/AMDGPU/AMDGPULibCalls.cpp

  130   bool fold_sincos(CallInst * CI, IRBuilder<> &B, AliasAnalysis * AA);
  158   bool fold(CallInst *CI, AliasAnalysis *AA = nullptr);
  639 bool AMDGPULibCalls::fold(CallInst *CI, AliasAnalysis *AA) {
 1282                                  AliasAnalysis *AA) {

lib/Target/AMDGPU/SIInstrInfo.cpp

  129                                                     AliasAnalysis *AA) const {

lib/Target/AMDGPU/SILoadStoreOptimizer.cpp

  209   AliasAnalysis *AA = nullptr;
  611                                     AliasAnalysis *AA) {

lib/Target/ARM/ARMLoadStoreOptimizer.cpp

 2036     AliasAnalysis *AA;

lib/Target/ARM/ARMParallelDSP.cpp

  213     AliasAnalysis     *AA;

lib/Target/Hexagon/HexagonLoopIdiomRecognition.cpp

  153     AliasAnalysis *AA;
 1969                       AliasAnalysis &AA,

lib/Target/Hexagon/HexagonStoreWidening.cpp

   67     AliasAnalysis               *AA;

lib/Target/PowerPC/PPCInstrInfo.cpp

  319                                                      AliasAnalysis *AA) const {

lib/Target/WebAssembly/WebAssemblyRegStackify.cpp

  170 static void query(const MachineInstr &MI, AliasAnalysis &AA, bool &Read,
  261 static bool shouldRematerialize(const MachineInstr &Def, AliasAnalysis &AA,
  317                          AliasAnalysis &AA, const MachineRegisterInfo &MRI) {
  778   AliasAnalysis &AA = getAnalysis<AAResultsWrapperPass>().getAAResults();

lib/Target/X86/X86AvoidStoreForwardingBlocks.cpp

   92   AliasAnalysis *AA;

lib/Transforms/IPO/FunctionAttrs.cpp

  117     if (AliasAnalysis::onlyReadsMemory(MRB))
  120     if (AliasAnalysis::doesNotReadMemory(MRB))
  150       if (!AliasAnalysis::onlyAccessesArgPointees(MRB)) {

lib/Transforms/InstCombine/InstCombineInternal.h

  319   AliasAnalysis *AA;
  339                bool MinimizeSize, bool ExpensiveCombines, AliasAnalysis *AA,

lib/Transforms/InstCombine/InstructionCombining.cpp

 3507     Function &F, InstCombineWorklist &Worklist, AliasAnalysis *AA,

lib/Transforms/ObjCARC/DependencyAnalysis.cpp

   51   if (AliasAnalysis::onlyReadsMemory(MRB))
   53   if (AliasAnalysis::onlyAccessesArgPointees(MRB)) {

lib/Transforms/ObjCARC/ObjCARCContract.cpp

   63     AliasAnalysis *AA;
  209                                                          AliasAnalysis *AA) {

lib/Transforms/ObjCARC/ProvenanceAnalysis.h

   52   AliasAnalysis *AA;
   70   void setAA(AliasAnalysis *aa) { AA = aa; }
   72   AliasAnalysis *getAA() const { return AA; }

lib/Transforms/Scalar/DeadStoreElimination.cpp

  349                                    AliasAnalysis &AA,
  543                                AliasAnalysis &AA) {
  587                                        AliasAnalysis *AA) {
  656 static bool handleFree(CallInst *F, AliasAnalysis *AA,
  717                                   const DataLayout &DL, AliasAnalysis *AA,
  747 static bool handleEndBlock(BasicBlock &BB, AliasAnalysis *AA,
 1002 static bool removePartiallyOverlappedStores(AliasAnalysis *AA,
 1027                                AliasAnalysis *AA, MemoryDependenceResults *MD,
 1073 static bool eliminateDeadStores(BasicBlock &BB, AliasAnalysis *AA,
 1313 static bool eliminateDeadStores(Function &F, AliasAnalysis *AA,
 1330   AliasAnalysis *AA = &AM.getResult<AAManager>(F);
 1361     AliasAnalysis *AA = &getAnalysis<AAResultsWrapperPass>().getAAResults();

lib/Transforms/Scalar/FlattenCFGPass.cpp

   38   AliasAnalysis *AA;
   54 static bool iterativelyFlattenCFG(Function &F, AliasAnalysis *AA) {

lib/Transforms/Scalar/GVNHoist.cpp

  257   GVNHoist(DominatorTree *DT, PostDominatorTree *PDT, AliasAnalysis *AA,
  332   AliasAnalysis *AA;
 1179   AliasAnalysis &AA = AM.getResult<AAManager>(F);

lib/Transforms/Scalar/JumpThreading.cpp

  355                                 LazyValueInfo *LVI_, AliasAnalysis *AA_,

lib/Transforms/Scalar/LICM.cpp

  152                                      AliasAnalysis *AA);
  170   bool runOnLoop(Loop *L, AliasAnalysis *AA, LoopInfo *LI, DominatorTree *DT,
  187   collectAliasInfoForLoop(Loop *L, LoopInfo *LI, AliasAnalysis *AA);
  189   collectAliasInfoForLoopWithMSSA(Loop *L, AliasAnalysis *AA,
  327     Loop *L, AliasAnalysis *AA, LoopInfo *LI, DominatorTree *DT,
  494 bool llvm::sinkRegion(DomTreeNode *N, AliasAnalysis *AA, LoopInfo *LI,
  795 bool llvm::hoistRegion(DomTreeNode *N, AliasAnalysis *AA, LoopInfo *LI,
 1149     if (AliasAnalysis::onlyReadsMemory(Behavior)) {
 1153       if (AliasAnalysis::onlyAccessesArgPointees(Behavior)) {
 2158                                                  AliasAnalysis *AA) {
 2200     Loop *L, AliasAnalysis *AA, MemorySSAUpdater *MSSAU) {
 2239                                      AliasAnalysis *AA) {

lib/Transforms/Scalar/LoopIdiomRecognize.cpp

  142   AliasAnalysis *AA;
  154   explicit LoopIdiomRecognize(AliasAnalysis *AA, DominatorTree *DT,
  271     AliasAnalysis *AA = &getAnalysis<AAResultsWrapperPass>().getAAResults();
  860                       AliasAnalysis &AA,

lib/Transforms/Scalar/LoopPredication.cpp

  250   AliasAnalysis *AA;
  304   LoopPredication(AliasAnalysis *AA, ScalarEvolution *SE,

lib/Transforms/Scalar/LoopRerollPass.cpp

  179     AliasAnalysis *AA;
  379                      ScalarEvolution *SE, AliasAnalysis *AA,
  434       AliasAnalysis *AA;

lib/Transforms/Scalar/LoopVersioningLICM.cpp

  167   AliasAnalysis *AA = nullptr;

lib/Transforms/Scalar/MemCpyOptimizer.cpp

  444 static bool moveUp(AliasAnalysis &AA, StoreInst *SI, Instruction *P,
  555         AliasAnalysis &AA = LookupAliasAnalysis();
  630         AliasAnalysis &AA = LookupAliasAnalysis();
  862   AliasAnalysis &AA = LookupAliasAnalysis();
  949   AliasAnalysis &AA = LookupAliasAnalysis();
 1098   AliasAnalysis &AA = LookupAliasAnalysis();
 1229   AliasAnalysis &AA = LookupAliasAnalysis();
 1407     std::function<AliasAnalysis &()> LookupAliasAnalysis_,

lib/Transforms/Scalar/MergeICmps.cpp

  218   bool canSplit(AliasAnalysis &AA) const;
  225                          AliasAnalysis &AA) const;
  230   void split(BasicBlock *NewParent, AliasAnalysis &AA) const;
  249                                     AliasAnalysis &AA) const {
  272 void BCECmpBlock::split(BasicBlock *NewParent, AliasAnalysis &AA) const {
  292 bool BCECmpBlock::canSplit(AliasAnalysis &AA) const {
  409                AliasAnalysis &AA);
  417   bool simplify(const TargetLibraryInfo &TLI, AliasAnalysis &AA,
  436                          AliasAnalysis &AA)
  609                                     AliasAnalysis &AA, DomTreeUpdater &DTU) {
  677 bool BCECmpChain::simplify(const TargetLibraryInfo &TLI, AliasAnalysis &AA,
  793 bool processPhi(PHINode &Phi, const TargetLibraryInfo &TLI, AliasAnalysis &AA,
  863                     const TargetTransformInfo &TTI, AliasAnalysis &AA,

lib/Transforms/Scalar/MergedLoadStoreMotion.cpp

  100   AliasAnalysis *AA = nullptr;
  111   bool run(Function &F, AliasAnalysis &AA);
  346 bool MergedLoadStoreMotion::run(Function &F, AliasAnalysis &AA) {

lib/Transforms/Scalar/NewGVN.cpp

  494   AliasAnalysis *AA;
  658          TargetLibraryInfo *TLI, AliasAnalysis *AA, MemorySSA *MSSA,

lib/Transforms/Scalar/Sink.cpp

   59 static bool isSafeToMove(Instruction *Inst, AliasAnalysis &AA,

lib/Transforms/Scalar/TailRecursionElimination.cpp

  328 static bool canMoveAboveCall(Instruction *I, CallInst *CI, AliasAnalysis *AA) {
  502     AliasAnalysis *AA, OptimizationRemarkEmitter *ORE, DomTreeUpdater &DTU) {
  690     AliasAnalysis *AA, OptimizationRemarkEmitter *ORE, DomTreeUpdater &DTU) {
  739     AliasAnalysis *AA, OptimizationRemarkEmitter *ORE, DomTreeUpdater &DTU) {
  749                                    AliasAnalysis *AA,
  865   AliasAnalysis &AA = AM.getResult<AAManager>(F);

lib/Transforms/Utils/FlattenCFG.cpp

   36   AliasAnalysis *AA;
   56   FlattenCFGOpt(AliasAnalysis *AA) : AA(AA) {}
  499 bool llvm::FlattenCFG(BasicBlock *BB, AliasAnalysis *AA) {

lib/Transforms/Vectorize/LoadStoreVectorizer.cpp

  113   AliasAnalysis &AA;
  121   Vectorizer(Function &F, AliasAnalysis &AA, DominatorTree &DT,
  254   AliasAnalysis &AA = getAnalysis<AAResultsWrapperPass>().getAAResults();
  269   AliasAnalysis &AA = AM.getResult<AAManager>(F);

lib/Transforms/Vectorize/LoopVectorize.cpp

  676   AliasAnalysis *AA;
 7804     DemandedBits &DB_, AliasAnalysis &AA_, AssumptionCache &AC_,

lib/Transforms/Vectorize/SLPVectorizer.cpp

  466 static MemoryLocation getLocation(Instruction *I, AliasAnalysis *AA) {
  503           TargetLibraryInfo *TLi, AliasAnalysis *Aa, LoopInfo *Li,
 1956   AliasAnalysis *AA;
 5266                                 TargetLibraryInfo *TLI_, AliasAnalysis *AA_,

tools/polly/include/polly/ScopBuilder.h

   35   AliasAnalysis &AA;
  814   explicit ScopBuilder(Region *R, AssumptionCache &AC, AliasAnalysis &AA,

tools/polly/include/polly/ScopDetection.h

  164     DetectionContext(Region &R, AliasAnalysis &AA, bool Verify)
  197   AliasAnalysis &AA;
  518                 LoopInfo &LI, RegionInfo &RI, AliasAnalysis &AA,

tools/polly/include/polly/ScopInfo.h

 1952   void init(AliasAnalysis &AA, AssumptionCache &AC, DominatorTree &DT,
 2811   AliasAnalysis &AA;
 2818            LoopInfo &LI, AliasAnalysis &AA, DominatorTree &DT,

tools/polly/lib/Analysis/ScopBuilder.cpp

 3750 ScopBuilder::ScopBuilder(Region *R, AssumptionCache &AC, AliasAnalysis &AA,

tools/polly/lib/Analysis/ScopDetection.cpp

  331                              AliasAnalysis &AA, OptimizationRemarkEmitter &ORE)

tools/polly/lib/Analysis/ScopInfo.cpp

 2720                    LoopInfo &LI, AliasAnalysis &AA, DominatorTree &DT,

unittests/Analysis/AliasAnalysisTest.cpp

   45     AliasAnalysis &AA = getAnalysis<AAResultsWrapperPass>().getAAResults();