[AA] Pass AAResults through AAQueryInfo

[nikic]

Summary

Currently, AAResultBase (from which alias analysis passes inherit) stores a reference back to the AAResults aggregation it is part of, so it can perform recursive alias analysis queries via getBestAAResults. This has the implicit assumption that an AAResult can only be part of a single AAResults aggregation. At least under the legacy pass manager, this doesn't seem to actually be the case. This appears to be mostly harmless in practice, but caused quite a bit of confusion for me, and could be dangerous depending on the lifetimes of the objects involved (one could be left with dangling AAResults references).

Instead of storing a reference inside AAResult, this instead passes in the used AAResults aggregation as part of the query. AAQueryInfo offers a convenient way to do this nowadays. Code doing recursive queries just needs to use AAQI.AAR instead of getBestAAResults().

[nikic]

llvm/lib/Analysis/BasicAliasAnalysis.cpp

699

This is the only place using getBestAAResults() and not having access to AAQueryInfo yet. If the general approach here is okay, I'll thread through AAQI to this method in a separate commit.

[asbirlea]

Do you have an idea if there is overhead of adding the AAR object to each query (each query info object)? (vs the setAAResults being done once for all the AAs available).

Details/nits:

• clang-format
• if approved, this change would need to go in together with the patch threading AAQI to getModRefBehavior.

llvm/include/llvm/Analysis/AliasAnalysis.h

359

Add comment this stands for Aggregated Alias Result?

[nikic]

In D94363#2499809, @asbirlea wrote:

Do you have an idea if there is overhead of adding the AAR object to each query (each query info object)? (vs the setAAResults being done once for all the AAs available).

It looks like adding AAR to the query doesn't have noticeable overhead: https://llvm-compile-time-tracker.com/compare.php?from=6ee44ee7c3cee47cb070ccb961359df8de252f36&to=9787880b8fe7ed5f62f15eaeed561a6ce09fdfd6&stat=instructions

There is however a small cost to passing AAQI through getModRefBehavior: https://llvm-compile-time-tracker.com/compare.php?from=33be50daa9ce1074c3b423a4ab27c70c0722113a&to=6ee44ee7c3cee47cb070ccb961359df8de252f36&stat=instructions

[dfukalov]

llvm/include/llvm/Analysis/AliasAnalysis.h

814

Am I right AAResults &AA member is not needed anymore?

[nikic]

Rebase. I made an error in my previous compile-time test, it turns out that this change has no significant impact after all.

The original motivation for this patch mostly went away, but I still think that doing this is a good idea. Our current AA infrastructure is really complicated, with some convoluted layering of 7 different classes (AAResults, BatchAAResults, AAQueryInfo, AAResults::Concept, AAResults::Model, AAResultBase and AAResultsProxy).

This patch removes the AAResultsProxy part of the equation. An immediate followup would be to make AAResultBase non-CRTP (this patch leaves behind an unused template argument). Possible followups on top of that would be:

• Make AAResultBase virtual itself and drop the AAResults::Concept and AAResults::Model indirections. I gave this a try but it turned out to be not entirely straightforward due to some NewPM interaction, but should be principally possible now.
• Make methods that take AAQueryInfo member methods of AAQueryInfo. This should prevent accidentally not passing on AAQI. With this BatchAAResults would reduce down to AAQueryInfo, we could just make it an alias.

[nikic]

Ping :)

[jdoerfert]

FWIW, (and drive by) this looks like a more reasonable design.

[asbirlea]

In D94363#3817839, @nikic wrote:

Rebase. I made an error in my previous compile-time test, it turns out that this change has no significant impact after all.

The original motivation for this patch mostly went away, but I still think that doing this is a good idea. Our current AA infrastructure is really complicated, with some convoluted layering of 7 different classes (AAResults, BatchAAResults, AAQueryInfo, AAResults::Concept, AAResults::Model, AAResultBase and AAResultsProxy).

This patch removes the AAResultsProxy part of the equation. An immediate followup would be to make AAResultBase non-CRTP (this patch leaves behind an unused template argument). Possible followups on top of that would be:

• Make AAResultBase virtual itself and drop the AAResults::Concept and AAResults::Model indirections. I gave this a try but it turned out to be not entirely straightforward due to some NewPM interaction, but should be principally possible now.
• Make methods that take AAQueryInfo member methods of AAQueryInfo. This should prevent accidentally not passing on AAQI. With this BatchAAResults would reduce down to AAQueryInfo, we could just make it an alias.

The current design is much better IMO than what we had before.

If you make private the AAR inside AAQI and expose methods only, then instead of calling:

AAQI.AAR.alias(MemoryLocation::getBeforeOrAfter(*CI),
                         MemoryLocation::getBeforeOrAfter(Object), AAQI);

you'd call:

AAQI.alias(MemoryLocation::getBeforeOrAfter(*CI),
                   MemoryLocation::getBeforeOrAfter(Object), <OptionalNewAAQI>);

I think this is what you meant with "prevent accidentally not passing on AAQI". It's not a huge cleanup though, since there still needs to be an AAQI param for the recursive phi case when a new one's needed.

---

Is this comment outdated, or did we still have a case where the AAR could be null?

/// A pointer to the AAResults object that this AAResult is
/// aggregated within. May be null if not aggregated.

[nikic]

In D94363#3837312, @asbirlea wrote:

If you make private the AAR inside AAQI and expose methods only, then instead of calling:

AAQI.AAR.alias(MemoryLocation::getBeforeOrAfter(*CI),
                         MemoryLocation::getBeforeOrAfter(Object), AAQI);

you'd call:

AAQI.alias(MemoryLocation::getBeforeOrAfter(*CI),
                   MemoryLocation::getBeforeOrAfter(Object), <OptionalNewAAQI>);

I think this is what you meant with "prevent accidentally not passing on AAQI". It's not a huge cleanup though, since there still needs to be an AAQI param for the recursive phi case when a new one's needed.

Yes, that's basically what I had in mind. I don't think the OptionalNewAAQI argument is necessary though, you'd just call it on the new AAQueryInfo instance. The call in https://github.com/llvm/llvm-project/blob/5f7f4846e826f97c7f298fe419c958398d5a0386/llvm/lib/Analysis/BasicAliasAnalysis.cpp#L1449-L1450 would become UseAAQI->alias(MemoryLocation(...), MemoryLocation(...)).

Is this comment outdated, or did we still have a case where the AAR could be null?

/// A pointer to the AAResults object that this AAResult is
/// aggregated within. May be null if not aggregated.

It can be null if you construct a single AA provider by hand, but not as part of normal usage via the pass manager.

llvm/include/llvm/Analysis/AliasAnalysis.h

 // to obtain a valid ModRefInfo. The benefit of using the wrapper is that if
 // ModRefInfo enum changes, the wrapper can be updated to & with the new enum
 // entry with all bits set to 1.
 LLVM_NODISCARD inline ModRefInfo
 createModRefInfo(const FunctionModRefBehavior FMRB) {
   return ModRefInfo(FMRB & static_cast<int>(ModRefInfo::ModRef));
 }
 
+class AAResults;
+
 /// This class stores info we want to provide to or retain within an alias
 /// query. By default, the root query is stateless and starts with a freshly
 /// constructed info object. Specific alias analyses can use this query info to
 /// store per-query state that is important for recursive or nested queries to
 /// avoid recomputing. To enable preserving this state across multiple queries
 /// where safe (due to the IR not changing), use a `BatchAAResults` wrapper.
 /// The information stored in an `AAQueryInfo` is currently limitted to the
 /// caches used by BasicAA, but can further be extended to fit other AA needs.
 class AAQueryInfo {
 public:
   using LocPair = std::pair<MemoryLocation, MemoryLocation>;
   struct CacheEntry {
     AliasResult Result;
     /// Number of times a NoAlias assumption has been used.
     /// 0 for assumptions that have not been used, -1 for definitive results.
     int NumAssumptionUses;
     /// Whether this is a definitive (non-assumption) result.
     bool isDefinitive() const { return NumAssumptionUses < 0; }
   };
+
+  AAResults &AAR;
+
   using AliasCacheT = SmallDenseMap<LocPair, CacheEntry, 8>;
   AliasCacheT AliasCache;
 
   using IsCapturedCacheT = SmallDenseMap<const Value *, bool, 8>;
   IsCapturedCacheT IsCapturedCache;
 
-  AAQueryInfo() : AliasCache(), IsCapturedCache() {}
+  AAQueryInfo(AAResults &AAR) : AAR(AAR), AliasCache(), IsCapturedCache() {}
 };
 
 class BatchAAResults;
 
 class AAResults {
 public:
   // Make these results default constructable and movable. We have to spell
   // these out because MSVC won't synthesize them.
public:
   /// An instruction that doesn't read or write memory may be trivially LICM'd
   /// for example.
   ///
   /// For function calls, this delegates to the alias-analysis specific
   /// call-site mod-ref behavior queries. Otherwise it delegates to the specific
   /// helpers above.
   ModRefInfo getModRefInfo(const Instruction *I,
                            const Optional<MemoryLocation> &OptLoc) {
-    AAQueryInfo AAQIP;
+    AAQueryInfo AAQIP(*this);
     return getModRefInfo(I, OptLoc, AAQIP);
   }
 
   /// A convenience wrapper for constructing the memory location.
   ModRefInfo getModRefInfo(const Instruction *I, const Value *P,
                            LocationSize Size) {
     return getModRefInfo(I, MemoryLocation(P, Size));
   }
public:
 
   /// A convenience wrapper synthesizing a memory location.
   bool canInstructionRangeModRef(const Instruction &I1, const Instruction &I2,
                                  const Value *Ptr, LocationSize Size,
                                  const ModRefInfo Mode) {
     return canInstructionRangeModRef(I1, I2, MemoryLocation(Ptr, Size), Mode);
   }
 
-private:
   AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB,
                     AAQueryInfo &AAQI);
   bool pointsToConstantMemory(const MemoryLocation &Loc, AAQueryInfo &AAQI,
                               bool OrLocal = false);
   ModRefInfo getModRefInfo(Instruction *I, const CallBase *Call2,
                            AAQueryInfo &AAQIP);
   ModRefInfo getModRefInfo(const CallBase *Call, const MemoryLocation &Loc,
                            AAQueryInfo &AAQI);
public:
   ModRefInfo getModRefInfo(const CatchPadInst *I, const MemoryLocation &Loc,
                            AAQueryInfo &AAQI);
   ModRefInfo getModRefInfo(const CatchReturnInst *I, const MemoryLocation &Loc,
                            AAQueryInfo &AAQI);
   ModRefInfo getModRefInfo(const Instruction *I,
                            const Optional<MemoryLocation> &OptLoc,
                            AAQueryInfo &AAQIP);
 
+private:
   class Concept;
 
   template <typename T> class Model;
 
   template <typename T> friend class AAResultBase;
 
   const TargetLibraryInfo &TLI;
 

 /// esentially making AA work in "batch mode". The internal state cannot be
 /// cleared, so to go "out-of-batch-mode", the user must either use AAResults,
 /// or create a new BatchAAResults.
 class BatchAAResults {
   AAResults &AA;
   AAQueryInfo AAQI;
 
 public:
-  BatchAAResults(AAResults &AAR) : AA(AAR), AAQI() {}
+  BatchAAResults(AAResults &AAR) : AA(AAR), AAQI(AAR) {}
   AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB) {
     return AA.alias(LocA, LocB, AAQI);
   }
   bool pointsToConstantMemory(const MemoryLocation &Loc, bool OrLocal = false) {
     return AA.pointsToConstantMemory(Loc, AAQI, OrLocal);
   }
   ModRefInfo getModRefInfo(const CallBase *Call, const MemoryLocation &Loc) {
     return AA.getModRefInfo(Call, Loc, AAQI);

 ///
 /// All of these methods model methods by the same name in the \c
 /// AAResults class. Only differences and specifics to how the
 /// implementations are called are documented here.
 class AAResults::Concept {
 public:
   virtual ~Concept() = 0;
 
-  /// An update API used internally by the AAResults to provide
-  /// a handle back to the top level aggregation.
-  virtual void setAAResults(AAResults *NewAAR) = 0;
-
   //===--------------------------------------------------------------------===//
   /// \name Alias Queries
   /// @{
 
   /// The main low level interface to the alias analysis implementation.
   /// Returns an AliasResult indicating whether the two pointers are aliased to
   /// each other. This is the interface that must be implemented by specific
   /// alias analysis implementations.

 ///
 /// This models the concept by directly forwarding each interface point to the
 /// wrapped type which must implement a compatible interface. This provides
 /// a type erased binding.
 template <typename AAResultT> class AAResults::Model final : public Concept {
   AAResultT &Result;
 
 public:
-  explicit Model(AAResultT &Result, AAResults &AAR) : Result(Result) {
-    Result.setAAResults(&AAR);
-  }
+  explicit Model(AAResultT &Result, AAResults &AAR) : Result(Result) {}
   ~Model() override = default;
 
-  void setAAResults(AAResults *NewAAR) override { Result.setAAResults(NewAAR); }
-
   AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB,
                     AAQueryInfo &AAQI) override {
     return Result.alias(LocA, LocB, AAQI);
   }
 
   bool pointsToConstantMemory(const MemoryLocation &Loc, AAQueryInfo &AAQI,
                               bool OrLocal) override {
     return Result.pointsToConstantMemory(Loc, AAQI, OrLocal);

 /// of the interface where possible, and otherwise provide conservatively
 /// correct fallback implementations.
 ///
 /// Implementors of an alias analysis should derive from this CRTP, and then
 /// override specific methods that they wish to customize. There is no need to
 /// use virtual anywhere, the CRTP base class does static dispatch to the
 /// derived type passed into it.
 template <typename DerivedT> class AAResultBase {
-  // Expose some parts of the interface only to the AAResults::Model
-  // for wrapping. Specifically, this allows the model to call our
-  // setAAResults method without exposing it as a fully public API.
-  friend class AAResults::Model<DerivedT>;
-
-  /// A pointer to the AAResults object that this AAResult is
-  /// aggregated within. May be null if not aggregated.
-  AAResults *AAR = nullptr;
-
-  /// Helper to dispatch calls back through the derived type.
-  DerivedT &derived() { return static_cast<DerivedT &>(*this); }
-
-  /// A setter for the AAResults pointer, which is used to satisfy the
-  /// AAResults::Model contract.
-  void setAAResults(AAResults *NewAAR) { AAR = NewAAR; }
-
 protected:
-  /// This proxy class models a common pattern where we delegate to either the
-  /// top-level \c AAResults aggregation if one is registered, or to the
-  /// current result if none are registered.
-  class AAResultsProxy {
-    AAResults *AAR;
-    DerivedT &CurrentResult;
-
-  public:
-    AAResultsProxy(AAResults *AAR, DerivedT &CurrentResult)
-        : AAR(AAR), CurrentResult(CurrentResult) {}
-
-    AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB,
-                      AAQueryInfo &AAQI) {
-      return AAR ? AAR->alias(LocA, LocB, AAQI)
-                 : CurrentResult.alias(LocA, LocB, AAQI);
-    }
-
-    bool pointsToConstantMemory(const MemoryLocation &Loc, AAQueryInfo &AAQI,
-                                bool OrLocal) {
-      return AAR ? AAR->pointsToConstantMemory(Loc, AAQI, OrLocal)
-                 : CurrentResult.pointsToConstantMemory(Loc, AAQI, OrLocal);
-    }
-
-    ModRefInfo getArgModRefInfo(const CallBase *Call, unsigned ArgIdx) {
-      return AAR ? AAR->getArgModRefInfo(Call, ArgIdx)
-                 : CurrentResult.getArgModRefInfo(Call, ArgIdx);
-    }
-
-    FunctionModRefBehavior getModRefBehavior(const CallBase *Call) {
-      return AAR ? AAR->getModRefBehavior(Call)
-                 : CurrentResult.getModRefBehavior(Call);
-    }
-
-    FunctionModRefBehavior getModRefBehavior(const Function *F) {
-      return AAR ? AAR->getModRefBehavior(F) : CurrentResult.getModRefBehavior(F);
-    }
-
-    ModRefInfo getModRefInfo(const CallBase *Call, const MemoryLocation &Loc,
-                             AAQueryInfo &AAQI) {
-      return AAR ? AAR->getModRefInfo(Call, Loc, AAQI)
-                 : CurrentResult.getModRefInfo(Call, Loc, AAQI);
-    }
-
-    ModRefInfo getModRefInfo(const CallBase *Call1, const CallBase *Call2,
-                             AAQueryInfo &AAQI) {
-      return AAR ? AAR->getModRefInfo(Call1, Call2, AAQI)
-                 : CurrentResult.getModRefInfo(Call1, Call2, AAQI);
-    }
-  };
-
   explicit AAResultBase() = default;
 
   // Provide all the copy and move constructors so that derived types aren't
   // constrained.
   AAResultBase(const AAResultBase &Arg) {}
   AAResultBase(AAResultBase &&Arg) {}
 
-  /// Get a proxy for the best AA result set to query at this time.
-  ///
-  /// When this result is part of a larger aggregation, this will proxy to that
-  /// aggregation. When this result is used in isolation, it will just delegate
-  /// back to the derived class's implementation.
-  ///
-  /// Note that callers of this need to take considerable care to not cause
-  /// performance problems when they use this routine, in the case of a large
-  /// number of alias analyses being aggregated, it can be expensive to walk
-  /// back across the chain.
-  AAResultsProxy getBestAAResults() { return AAResultsProxy(AAR, derived()); }
-
 public:
   AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB,
                     AAQueryInfo &AAQI) {
     return MayAlias;
   }
 
   bool pointsToConstantMemory(const MemoryLocation &Loc, AAQueryInfo &AAQI,
                               bool OrLocal) {

llvm/lib/Analysis/AliasAnalysis.cpp

 STATISTIC(NumMustAlias, "Number of MustAlias results");
 
 /// Allow disabling BasicAA from the AA results. This is particularly useful
 /// when testing to isolate a single AA implementation.
 cl::opt<bool> DisableBasicAA("disable-basic-aa", cl::Hidden, cl::init(false));
 
 AAResults::AAResults(AAResults &&Arg)
     : TLI(Arg.TLI), AAs(std::move(Arg.AAs)), AADeps(std::move(Arg.AADeps)) {
-  for (auto &AA : AAs)
-    AA->setAAResults(this);
 }
 
-AAResults::~AAResults() {
-// FIXME; It would be nice to at least clear out the pointers back to this
-// aggregation here, but we end up with non-nesting lifetimes in the legacy
-// pass manager that prevent this from working. In the legacy pass manager
-// we'll end up with dangling references here in some cases.
-#if 0
-  for (auto &AA : AAs)
-    AA->setAAResults(nullptr);
-#endif
-}
+AAResults::~AAResults() { }
 
 bool AAResults::invalidate(Function &F, const PreservedAnalyses &PA,
                            FunctionAnalysisManager::Invalidator &Inv) {
   // AAResults preserves the AAManager by default, due to the stateless nature
   // of AliasAnalysis. There is no need to check whether it has been preserved
   // explicitly. Check if any module dependency was invalidated and caused the
   // AAManager to be invalidated. Invalidate ourselves in that case.
   auto PAC = PA.getChecker<AAManager>();

 }
 
 //===----------------------------------------------------------------------===//
 // Default chaining methods
 //===----------------------------------------------------------------------===//
 
 AliasResult AAResults::alias(const MemoryLocation &LocA,
                              const MemoryLocation &LocB) {
-  AAQueryInfo AAQIP;
+  AAQueryInfo AAQIP(*this);
   return alias(LocA, LocB, AAQIP);
 }
 
 AliasResult AAResults::alias(const MemoryLocation &LocA,
                              const MemoryLocation &LocB, AAQueryInfo &AAQI) {
   AliasResult Result = MayAlias;
 
   Depth++;
if (Depth == 0) {
     else
       ++NumMayAlias;
   }
   return Result;
 }
 
 bool AAResults::pointsToConstantMemory(const MemoryLocation &Loc,
                                        bool OrLocal) {
-  AAQueryInfo AAQIP;
+  AAQueryInfo AAQIP(*this);
   return pointsToConstantMemory(Loc, AAQIP, OrLocal);
 }
 
 bool AAResults::pointsToConstantMemory(const MemoryLocation &Loc,
                                        AAQueryInfo &AAQI, bool OrLocal) {
   for (const auto &AA : AAs)
     if (AA->pointsToConstantMemory(Loc, AAQI, OrLocal))
       return true;
for (const auto &AA : AAs) {
     if (isNoModRef(Result))
       return ModRefInfo::NoModRef;
   }
 
   return Result;
 }
 
 ModRefInfo AAResults::getModRefInfo(Instruction *I, const CallBase *Call2) {
-  AAQueryInfo AAQIP;
+  AAQueryInfo AAQIP(*this);
   return getModRefInfo(I, Call2, AAQIP);
 }
 
 ModRefInfo AAResults::getModRefInfo(Instruction *I, const CallBase *Call2,
                                     AAQueryInfo &AAQI) {
   // We may have two calls.
   if (const auto *Call1 = dyn_cast<CallBase>(I)) {
     // Check if the two calls modify the same memory.
if (const auto *Call1 = dyn_cast<CallBase>(I)) {
     if (isModOrRefSet(MR))
       return setModAndRef(MR);
   }
   return ModRefInfo::NoModRef;
 }
 
 ModRefInfo AAResults::getModRefInfo(const CallBase *Call,
                                     const MemoryLocation &Loc) {
-  AAQueryInfo AAQIP;
+  AAQueryInfo AAQIP(*this);
   return getModRefInfo(Call, Loc, AAQIP);
 }
 
 ModRefInfo AAResults::getModRefInfo(const CallBase *Call,
                                     const MemoryLocation &Loc,
                                     AAQueryInfo &AAQI) {
   ModRefInfo Result = ModRefInfo::ModRef;
 
ModRefInfo AAResults::getModRefInfo(const CallBase *Call,
   if (isModSet(Result) && pointsToConstantMemory(Loc, AAQI, /*OrLocal*/ false))
     Result = clearMod(Result);
 
   return Result;
 }
 
 ModRefInfo AAResults::getModRefInfo(const CallBase *Call1,
                                     const CallBase *Call2) {
-  AAQueryInfo AAQIP;
+  AAQueryInfo AAQIP(*this);
   return getModRefInfo(Call1, Call2, AAQIP);
 }
 
 ModRefInfo AAResults::getModRefInfo(const CallBase *Call1,
                                     const CallBase *Call2, AAQueryInfo &AAQI) {
   ModRefInfo Result = ModRefInfo::ModRef;
 
   for (const auto &AA : AAs) {

 }
 
 //===----------------------------------------------------------------------===//
 // Helper method implementation
 //===----------------------------------------------------------------------===//
 
 ModRefInfo AAResults::getModRefInfo(const LoadInst *L,
                                     const MemoryLocation &Loc) {
-  AAQueryInfo AAQIP;
+  AAQueryInfo AAQIP(*this);
   return getModRefInfo(L, Loc, AAQIP);
 }
 ModRefInfo AAResults::getModRefInfo(const LoadInst *L,
                                     const MemoryLocation &Loc,
                                     AAQueryInfo &AAQI) {
   // Be conservative in the face of atomic.
   if (isStrongerThan(L->getOrdering(), AtomicOrdering::Unordered))
     return ModRefInfo::ModRef;
 
   // If the load address doesn't alias the given address, it doesn't read
   // or write the specified memory.
   if (Loc.Ptr) {
     AliasResult AR = alias(MemoryLocation::get(L), Loc, AAQI);
     if (AR == NoAlias)
       return ModRefInfo::NoModRef;
     if (AR == MustAlias)
       return ModRefInfo::MustRef;
   }
   // Otherwise, a load just reads.
   return ModRefInfo::Ref;
 }
 
 ModRefInfo AAResults::getModRefInfo(const StoreInst *S,
                                     const MemoryLocation &Loc) {
-  AAQueryInfo AAQIP;
+  AAQueryInfo AAQIP(*this);
   return getModRefInfo(S, Loc, AAQIP);
 }
 ModRefInfo AAResults::getModRefInfo(const StoreInst *S,
                                     const MemoryLocation &Loc,
                                     AAQueryInfo &AAQI) {
   // Be conservative in the face of atomic.
   if (isStrongerThan(S->getOrdering(), AtomicOrdering::Unordered))
     return ModRefInfo::ModRef;
if (AR == MustAlias)
       return ModRefInfo::MustMod;
   }
 
   // Otherwise, a store just writes.
   return ModRefInfo::Mod;
 }
 
 ModRefInfo AAResults::getModRefInfo(const FenceInst *S, const MemoryLocation &Loc) {
-  AAQueryInfo AAQIP;
+  AAQueryInfo AAQIP(*this);
   return getModRefInfo(S, Loc, AAQIP);
 }
 
 ModRefInfo AAResults::getModRefInfo(const FenceInst *S,
                                     const MemoryLocation &Loc,
                                     AAQueryInfo &AAQI) {
   // If we know that the location is a constant memory location, the fence
   // cannot modify this location.
   if (Loc.Ptr && pointsToConstantMemory(Loc, AAQI))
     return ModRefInfo::Ref;
   return ModRefInfo::ModRef;
 }
 
 ModRefInfo AAResults::getModRefInfo(const VAArgInst *V,
                                     const MemoryLocation &Loc) {
-  AAQueryInfo AAQIP;
+  AAQueryInfo AAQIP(*this);
   return getModRefInfo(V, Loc, AAQIP);
 }
 
 ModRefInfo AAResults::getModRefInfo(const VAArgInst *V,
                                     const MemoryLocation &Loc,
                                     AAQueryInfo &AAQI) {
   if (Loc.Ptr) {
     AliasResult AR = alias(MemoryLocation::get(V), Loc, AAQI);
ModRefInfo AAResults::getModRefInfo(const VAArgInst *V,
   }
 
   // Otherwise, a va_arg reads and writes.
   return ModRefInfo::ModRef;
 }
 
 ModRefInfo AAResults::getModRefInfo(const CatchPadInst *CatchPad,
                                     const MemoryLocation &Loc) {
-  AAQueryInfo AAQIP;
+  AAQueryInfo AAQIP(*this);
   return getModRefInfo(CatchPad, Loc, AAQIP);
 }
 
 ModRefInfo AAResults::getModRefInfo(const CatchPadInst *CatchPad,
                                     const MemoryLocation &Loc,
                                     AAQueryInfo &AAQI) {
   if (Loc.Ptr) {
     // If the pointer is a pointer to constant memory,
     // then it could not have been modified by this catchpad.
     if (pointsToConstantMemory(Loc, AAQI))
       return ModRefInfo::NoModRef;
   }
 
   // Otherwise, a catchpad reads and writes.
   return ModRefInfo::ModRef;
 }
 
 ModRefInfo AAResults::getModRefInfo(const CatchReturnInst *CatchRet,
                                     const MemoryLocation &Loc) {
-  AAQueryInfo AAQIP;
+  AAQueryInfo AAQIP(*this);
   return getModRefInfo(CatchRet, Loc, AAQIP);
 }
 
 ModRefInfo AAResults::getModRefInfo(const CatchReturnInst *CatchRet,
                                     const MemoryLocation &Loc,
                                     AAQueryInfo &AAQI) {
   if (Loc.Ptr) {
     // If the pointer is a pointer to constant memory,
     // then it could not have been modified by this catchpad.
     if (pointsToConstantMemory(Loc, AAQI))
       return ModRefInfo::NoModRef;
   }
 
   // Otherwise, a catchret reads and writes.
   return ModRefInfo::ModRef;
 }
 
 ModRefInfo AAResults::getModRefInfo(const AtomicCmpXchgInst *CX,
                                     const MemoryLocation &Loc) {
-  AAQueryInfo AAQIP;
+  AAQueryInfo AAQIP(*this);
   return getModRefInfo(CX, Loc, AAQIP);
 }
 
 ModRefInfo AAResults::getModRefInfo(const AtomicCmpXchgInst *CX,
                                     const MemoryLocation &Loc,
                                     AAQueryInfo &AAQI) {
   // Acquire/Release cmpxchg has properties that matter for arbitrary addresses.
   if (isStrongerThanMonotonic(CX->getSuccessOrdering()))
if (AR == MustAlias)
       return ModRefInfo::MustModRef;
   }
 
   return ModRefInfo::ModRef;
 }
 
 ModRefInfo AAResults::getModRefInfo(const AtomicRMWInst *RMW,
                                     const MemoryLocation &Loc) {
-  AAQueryInfo AAQIP;
+  AAQueryInfo AAQIP(*this);
   return getModRefInfo(RMW, Loc, AAQIP);
 }
 
 ModRefInfo AAResults::getModRefInfo(const AtomicRMWInst *RMW,
                                     const MemoryLocation &Loc,
                                     AAQueryInfo &AAQI) {
   // Acquire/Release atomicrmw has properties that matter for arbitrary addresses.
   if (isStrongerThanMonotonic(RMW->getOrdering()))

llvm/lib/Analysis/BasicAliasAnalysis.cpp

FunctionModRefBehavior BasicAAResult::getModRefBehavior(const CallBase *Call) {
   else if (Call->onlyAccessesInaccessibleMemory())
     Min = FunctionModRefBehavior(Min & FMRB_OnlyAccessesInaccessibleMem);
   else if (Call->onlyAccessesInaccessibleMemOrArgMem())
     Min = FunctionModRefBehavior(Min & FMRB_OnlyAccessesInaccessibleOrArgMem);
 
   // If the call has operand bundles then aliasing attributes from the function
   // it calls do not directly apply to the call.  This can be made more precise
   // in the future.
+#if 0
   if (!Call->hasOperandBundles())
     if (const Function *F = Call->getCalledFunction())
       Min =
           FunctionModRefBehavior(Min & getBestAAResults().getModRefBehavior(F));
+#endif
 
   return Min;
 }
 
 /// Returns the behavior when calling the given function. For use when the call
 /// site is not known.
 FunctionModRefBehavior BasicAAResult::getModRefBehavior(const Function *F) {
   // If the function declares it doesn't access memory, we can't do better.
for (auto CI = Call->data_operands_begin(), CE = Call->data_operands_end();
 
       // Call doesn't access memory through this operand, so we don't care
       // if it aliases with Object.
       if (Call->doesNotAccessMemory(OperandNo))
         continue;
 
       // If this is a no-capture pointer argument, see if we can tell that it
       // is impossible to alias the pointer we're checking.
-      AliasResult AR = getBestAAResults().alias(
+      AliasResult AR = AAQI.AAR.alias(
           MemoryLocation::getBeforeOrAfter(*CI),
           MemoryLocation::getBeforeOrAfter(Object), AAQI);
       if (AR != MustAlias)
         IsMustAlias = false;
       // Operand doesn't alias 'Object', continue looking for other aliases
       if (AR == NoAlias)
         continue;
       // Operand aliases 'Object', but call doesn't modify it. Strengthen
ModRefInfo BasicAAResult::getModRefInfo(const CallBase *Call,
   // modify any IR visible value.  This is only valid because we assume these
   // routines do not read values visible in the IR.  TODO: Consider special
   // casing realloc and strdup routines which access only their arguments as
   // well.  Or alternatively, replace all of this with inaccessiblememonly once
   // that's implemented fully.
   if (isMallocOrCallocLikeFn(Call, &TLI)) {
     // Be conservative if the accessed pointer may alias the allocation -
     // fallback to the generic handling below.
-    if (getBestAAResults().alias(MemoryLocation::getBeforeOrAfter(Call),
-                                 Loc, AAQI) == NoAlias)
+    if (AAQI.AAR.alias(MemoryLocation::getBeforeOrAfter(Call),
       return ModRefInfo::NoModRef;
   }
 
   // The semantics of memcpy intrinsics either exactly overlap or do not
   // overlap, i.e., source and destination of any given memcpy are either
   // no-alias or must-alias.
   if (auto *Inst = dyn_cast<AnyMemCpyInst>(Call)) {
     AliasResult SrcAA =
-        getBestAAResults().alias(MemoryLocation::getForSource(Inst), Loc, AAQI);
+        AAQI.AAR.alias(MemoryLocation::getForSource(Inst), Loc, AAQI);
     AliasResult DestAA =
-        getBestAAResults().alias(MemoryLocation::getForDest(Inst), Loc, AAQI);
+        AAQI.AAR.alias(MemoryLocation::getForDest(Inst), Loc, AAQI);
     // It's also possible for Loc to alias both src and dest, or neither.
     ModRefInfo rv = ModRefInfo::NoModRef;
     if (SrcAA != NoAlias)
       rv = setRef(rv);
     if (DestAA != NoAlias)
       rv = setMod(rv);
     return rv;
   }
AliasResult BasicAAResult::aliasPHI(const PHINode *PN, LocationSize PNSize,
   auto _ = make_scope_exit([&]() {
     if (BlockInserted)
       VisitedPhiBBs.erase(PN->getParent());
   });
 
   // If we inserted a block into VisitedPhiBBs, alias analysis results that
   // have been cached earlier may no longer be valid. Perform recursive queries
   // with a new AAQueryInfo.
-  AAQueryInfo NewAAQI;
+  AAQueryInfo NewAAQI(AAQI.AAR);
   AAQueryInfo *UseAAQI = BlockInserted ? &NewAAQI : &AAQI;
 
   AliasResult Alias = aliasCheck(V2, V2Size, V2AAInfo, V1Srcs[0], PNSize,
                                  PNAAInfo, *UseAAQI, UnderV2);
 
   // Early exit if the check of the first PHI source against V2 is MayAlias.
   // Other results are not possible.
   if (Alias == MayAlias)
if (V1Size.isPrecise() && V2Size.isPrecise() &&
         (isObjectSize(O1, V1Size.getValue(), DL, TLI, NullIsValidLocation) ||
          isObjectSize(O2, V2Size.getValue(), DL, TLI, NullIsValidLocation)))
       return PartialAlias;
   }
 
   // Recurse back into the best AA results we have, potentially with refined
   // memory locations. We have already ensured that BasicAA has a MayAlias
   // cache result for these, so any recursion back into BasicAA won't loop.
-  return getBestAAResults().alias(MemoryLocation(V1, V1Size, V1AAInfo),
-                                  MemoryLocation(V2, V2Size, V2AAInfo), AAQI);
+  return AAQI.AAR.alias(MemoryLocation(V1, V1Size, V1AAInfo),
 }
 
 /// Check whether two Values can be considered equivalent.
 ///
 /// In addition to pointer equivalence of \p V1 and \p V2 this checks whether
 /// they can not be part of a cycle in the value graph by looking at all
 /// visited phi nodes an making sure that the phis cannot reach the value. We
 /// have to do this because we are looking through phi nodes (That is we say

llvm/unittests/Analysis/BasicAliasAnalysisTest.cpp

protected:
   TargetLibraryInfo TLI;
   Function *F;
 
   // Things that we need to build after the function is created.
   struct TestAnalyses {
     DominatorTree DT;
     AssumptionCache AC;
     BasicAAResult BAA;
+    AAResults AAR;
     AAQueryInfo AAQI;
 
     TestAnalyses(BasicAATest &Test)
         : DT(*Test.F), AC(*Test.F), BAA(Test.DL, *Test.F, Test.TLI, AC, &DT),
-          AAQI() {}
+          AAR(Test.TLI), AAQI(AAR) {
+      AAR.addAAResult(BAA);
+    }
   };
 
   llvm::Optional<TestAnalyses> Analyses;
 
   TestAnalyses &setupAnalyses() {
     assert(F);
     Analyses.emplace(*this);
     return Analyses.getValue();