[AliasAnalysis] Prototype to cache BasicAA / anyAA state.

[asbirlea]

Summary

Test for adding a temporary cache to AAs.
[DO NOT MERGE]

include/llvm/Analysis/AliasAnalysis.h

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);
   }
 
+  void startKeepingCaches();
+  void stopKeepingCaches();
+
 private:
   class Concept;
 
   template <typename T> class Model;
 
   template <typename T> friend class AAResultBase;
 
   const TargetLibraryInfo &TLI;
virtual ModRefInfo getModRefInfo(const CallBase *Call,
                                    const MemoryLocation &Loc) = 0;
 
   /// Return information about whether two call sites may refer to the same set
   /// of memory locations. See the AA documentation for details:
   ///   http://llvm.org/docs/AliasAnalysis.html#ModRefInfo
   virtual ModRefInfo getModRefInfo(const CallBase *Call1,
                                    const CallBase *Call2) = 0;
 
+  // Don't clear internal caches. Only call when we know thare are no functional
+  // IR changes. Call its counterpart below to clear caches and make AA
+  // stateless again.
+  virtual void startKeepingCaches() = 0;
+  virtual void stopKeepingCaches() = 0;
+
   /// @}
 };
 
 /// A private class template which derives from \c Concept and wraps some other
 /// type.
 ///
 /// This models the concept by directly forwarding each interface point to the
 /// wrapped type which must implement a compatible interface. This provides
ModRefInfo getModRefInfo(const CallBase *Call,
                            const MemoryLocation &Loc) override {
     return Result.getModRefInfo(Call, Loc);
   }
 
   ModRefInfo getModRefInfo(const CallBase *Call1,
                            const CallBase *Call2) override {
     return Result.getModRefInfo(Call1, Call2);
   }
+
+  void startKeepingCaches() override { Result.startKeepingCaches(); }
+  void stopKeepingCaches() override { Result.stopKeepingCaches(); }
 };
 
 /// A CRTP-driven "mixin" base class to help implement the function alias
 /// analysis results concept.
 ///
 /// Because of the nature of many alias analysis implementations, they often
 /// only implement a subset of the interface. This base class will attempt to
 /// implement the remaining portions of the interface in terms of simpler forms
ModRefInfo getModRefInfo(const CallBase *Call, const MemoryLocation &Loc) {
       return AAR ? AAR->getModRefInfo(Call, Loc)
                  : CurrentResult.getModRefInfo(Call, Loc);
     }
 
     ModRefInfo getModRefInfo(const CallBase *Call1, const CallBase *Call2) {
       return AAR ? AAR->getModRefInfo(Call1, Call2)
                  : CurrentResult.getModRefInfo(Call1, Call2);
     }
+
+    void startKeepingCaches() {
+      AAR ? AAR->startKeepingCaches() : CurrentResult.startKeepingCaches();
+    }
+
+    void stopKeepingCaches() {
+      AAR ? AAR->stopKeepingCaches() : CurrentResult.stopKeepingCaches();
+    }
   };
 
   explicit AAResultBase() = default;
 
   // Provide all the copy and move constructors so that derived types aren't
   // constrained.
   AAResultBase(const AAResultBase &Arg) {}
   AAResultBase(AAResultBase &&Arg) {}
public:
 
   ModRefInfo getModRefInfo(const CallBase *Call, const MemoryLocation &Loc) {
     return ModRefInfo::ModRef;
   }
 
   ModRefInfo getModRefInfo(const CallBase *Call1, const CallBase *Call2) {
     return ModRefInfo::ModRef;
   }
+
+  void startKeepingCaches() {}
+  void stopKeepingCaches() {}
 };
 
 /// Return true if this pointer is returned by a noalias function.
 bool isNoAliasCall(const Value *V);
 
 /// Return true if this is an argument with the noalias attribute.
 bool isNoAliasArgument(const Value *V);
 

include/llvm/Analysis/BasicAliasAnalysis.h

public:
 
   /// Returns the behavior when calling the given call site.
   FunctionModRefBehavior getModRefBehavior(const CallBase *Call);
 
   /// Returns the behavior when calling the given function. For use when the
   /// call site is not known.
   FunctionModRefBehavior getModRefBehavior(const Function *Fn);
 
+  void startKeepingCaches();
+  void stopKeepingCaches();
+
 private:
+  bool keepBasicAAInternalCaches = false;
+
   // A linear transformation of a Value; this class represents ZExt(SExt(V,
   // SExtBits), ZExtBits) * Scale + Offset.
   struct VariableGEPIndex {
     // An opaque Value - we can't decompose this further.
     const Value *V;
 
     // We need to track what extensions we've done as we consider the same Value
     // with different extensions as different variables in a GEP's linear

lib/Analysis/AliasAnalysis.cpp

for (const auto &AA : AAs) {
     // Early-exit the moment we reach the bottom of the lattice.
     if (Result == FMRB_DoesNotAccessMemory)
       return Result;
   }
 
   return Result;
 }
 
+void AAResults::startKeepingCaches() {
+  for (const auto &AA : AAs)
+    AA->startKeepingCaches();
+}
+
+void AAResults::stopKeepingCaches() {
+  for (const auto &AA : AAs)
+    AA->stopKeepingCaches();
+}
+
 raw_ostream &llvm::operator<<(raw_ostream &OS, AliasResult AR) {
   switch (AR) {
   case NoAlias:
     OS << "NoAlias";
     break;
   case MustAlias:
     OS << "MustAlias";
     break;

lib/Analysis/BasicAliasAnalysis.cpp

static bool notDifferentParent(const Value *O1, const Value *O2) {
 
   const Function *F1 = getParent(O1);
   const Function *F2 = getParent(O2);
 
   return !F1 || !F2 || F1 == F2;
 }
 #endif
 
+void BasicAAResult::startKeepingCaches() {
+  keepBasicAAInternalCaches = true;
+}
+
+void BasicAAResult::stopKeepingCaches() {
+  AliasCache.shrink_and_clear();
+  IsCapturedCache.shrink_and_clear();
+  keepBasicAAInternalCaches = false;
+}
+
 AliasResult BasicAAResult::alias(const MemoryLocation &LocA,
                                  const MemoryLocation &LocB) {
   assert(notDifferentParent(LocA.Ptr, LocB.Ptr) &&
          "BasicAliasAnalysis doesn't support interprocedural queries.");
 
   // If we have a directly cached entry for these locations, we have recursed
   // through this once, so just return the cached results. Notably, when this
   // happens, we don't clear the cache.
   auto CacheIt = AliasCache.find(LocPair(LocA, LocB));
   if (CacheIt != AliasCache.end())
     return CacheIt->second;
 
   AliasResult Alias = aliasCheck(LocA.Ptr, LocA.Size, LocA.AATags, LocB.Ptr,
                                  LocB.Size, LocB.AATags);
   // AliasCache rarely has more than 1 or 2 elements, always use
   // shrink_and_clear so it quickly returns to the inline capacity of the
   // SmallDenseMap if it ever grows larger.
   // FIXME: This should really be shrink_to_inline_capacity_and_clear().
+
+  if (!keepBasicAAInternalCaches) {
     AliasCache.shrink_and_clear();
     IsCapturedCache.shrink_and_clear();
+  }
+
   VisitedPhiBBs.clear();
   return Alias;
 }
 
 /// Checks to see if the specified callsite can clobber the specified memory
 /// object.
 ///
 /// Since we only look at local properties of this function, we really can't

lib/Analysis/MemorySSA.cpp

else
       Accesses->erase(AI);
     AI = Next;
   }
 }
 
 MemorySSA::MemorySSA(Function &Func, AliasAnalysis *AA, DominatorTree *DT)
     : AA(AA), DT(DT), F(Func), LiveOnEntryDef(nullptr), Walker(nullptr),
       SkipWalker(nullptr), NextID(0) {
+  AA->startKeepingCaches();
   buildMemorySSA();
+  AA->stopKeepingCaches();
 }
 
 MemorySSA::~MemorySSA() {
   // Drop all our references
   for (const auto &Pair : PerBlockAccesses)
     for (MemoryAccess &MA : *Pair.second)
       MA.dropAllReferences();
 }