Handle info about the processing of invariant intrinsics...

[lvoufo]

Summary

Continuation of D14008: use the property to extend basic AA's assessment that a given memory location is to be treated as constant memory

[nlewycky]

This is overlapping with D14003?

[lvoufo]

In D14009#284833, @nlewycky wrote:

This is overlapping with D14003?

Yes. It can be hard to keep track of the dependencies in this framework... There is a comment in D14003 that states that D14003 was split into D14008 and D14009. So, D14003 is really just a merge of both D14008 and D14009.

include/llvm/Analysis/BasicAliasAnalysis.h

 /// analysis. It implements the AA query interface in an entirely stateless
 /// manner. As one consequence, it is never invalidated. While it does retain
 /// some storage, that is used as an optimization and not to preserve
 /// information from query to query.
 class BasicAAResult : public AAResultBase<BasicAAResult> {
   friend AAResultBase<BasicAAResult>;
 
   const DataLayout &DL;
+  InvariantInfo &InvInfo;
   AssumptionCache &AC;
   DominatorTree *DT;
   LoopInfo *LI;
 
 public:
   BasicAAResult(const DataLayout &DL, const TargetLibraryInfo &TLI,
-                AssumptionCache &AC, DominatorTree *DT = nullptr,
-                LoopInfo *LI = nullptr)
-      : AAResultBase(TLI), DL(DL), AC(AC), DT(DT), LI(LI) {}
+                AssumptionCache &AC, InvariantInfo &InvInfo,
+                DominatorTree *DT = nullptr, LoopInfo *LI = nullptr)
+      : AAResultBase(TLI), DL(DL), InvInfo(InvInfo), AC(AC), DT(DT), LI(LI) {}
 
   BasicAAResult(const BasicAAResult &Arg)
-      : AAResultBase(Arg), DL(Arg.DL), AC(Arg.AC), DT(Arg.DT), LI(Arg.LI) {}
+      : AAResultBase(Arg), DL(Arg.DL), InvInfo(Arg.InvInfo), AC(Arg.AC),
+        DT(Arg.DT), LI(Arg.LI) {}
   BasicAAResult(BasicAAResult &&Arg)
-      : AAResultBase(std::move(Arg)), DL(Arg.DL), AC(Arg.AC), DT(Arg.DT),
-        LI(Arg.LI) {}
+      : AAResultBase(std::move(Arg)), DL(Arg.DL), InvInfo(Arg.InvInfo),
+        AC(Arg.AC), DT(Arg.DT), LI(Arg.LI) {}
 
   /// Handle invalidation events from the new pass manager.
   ///
   /// By definition, this result is stateless and so remains valid.
   bool invalidate(Function &, const PreservedAnalyses &) { return false; }
 
   AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB);
 

lib/Analysis/BasicAliasAnalysis.cpp

if (!Visited.insert(V).second) {
       Visited.clear();
       return AAResultBase::pointsToConstantMemory(Loc, OrLocal);
     }
 
     // An alloca instruction defines local memory.
     if (OrLocal && isa<AllocaInst>(V))
       continue;
 
+    if (const AllocaInst *AI = dyn_cast<AllocaInst>(V))
+      if (InvInfo.GetStartInstruction(AI)) continue;
+
     // A global constant counts as local memory for our purposes.
     if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(V)) {
       // Note: this doesn't require GV to be "ODR" because it isn't legal for a
       // global to be marked constant in some modules and non-constant in
       // others.  GV may even be a declaration, not a definition.
-      if (!GV->isConstant()) {
+      if (!GV->isConstant() && !InvInfo.GetStartInstruction(GV)) {
         Visited.clear();
         return AAResultBase::pointsToConstantMemory(Loc, OrLocal);
       }
       continue;
     }
 
     // If both select values point to local memory, then so does the select.
     if (const SelectInst *SI = dyn_cast<SelectInst>(V)) {
AliasResult BasicAAResult::alias(const MemoryLocation &LocA,
   // 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().
   AliasCache.shrink_and_clear();
   VisitedPhiBBs.clear();
   return Alias;
 }
 
+static bool isInvariantIntrinsic(ImmutableCallSite CS) {
+  const IntrinsicInst *II = dyn_cast<IntrinsicInst>(CS.getInstruction());
+  return II && (II->getIntrinsicID() == Intrinsic::invariant_start ||
+                II->getIntrinsicID() == Intrinsic::invariant_end);
+}
+
 /// 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
 /// say much about this query.  We do, however, use simple "address taken"
 /// analysis on local objects.
 ModRefInfo BasicAAResult::getModRefInfo(ImmutableCallSite CS,
                                         const MemoryLocation &Loc) {
ModRefInfo BasicAAResult::getModRefInfo(ImmutableCallSite CS,
   }
 
   // While the assume intrinsic is marked as arbitrarily writing so that
   // proper control dependencies will be maintained, it never aliases any
   // particular memory location.
   if (isAssumeIntrinsic(CS))
     return MRI_NoModRef;
 
+  // Invariant intrinsics follow the same pattern as assume intrinsic.
+  if (isInvariantIntrinsic(CS)) return MRI_NoModRef;
+
   // The AAResultBase base class has some smarts, lets use them.
   return AAResultBase::getModRefInfo(CS, Loc);
 }
 
 ModRefInfo BasicAAResult::getModRefInfo(ImmutableCallSite CS1,
                                         ImmutableCallSite CS2) {
   // While the assume intrinsic is marked as arbitrarily writing so that
   // proper control dependencies will be maintained, it never aliases any
   // particular memory location.
   if (isAssumeIntrinsic(CS1) || isAssumeIntrinsic(CS2))
     return MRI_NoModRef;
 
+  // Invariant intrinsics follow the same pattern as assume intrinsic.
+  if (isInvariantIntrinsic(CS1) || isInvariantIntrinsic(CS2))
+    return MRI_NoModRef;
+
   // The AAResultBase base class has some smarts, lets use them.
   return AAResultBase::getModRefInfo(CS1, CS2);
 }
 
 /// Provide ad-hoc rules to disambiguate accesses through two GEP operators,
 /// both having the exact same pointer operand.
 static AliasResult aliasSameBasePointerGEPs(const GEPOperator *GEP1,
                                             uint64_t V1Size,

 //===----------------------------------------------------------------------===//
 
 char BasicAA::PassID;
 
 BasicAAResult BasicAA::run(Function &F, AnalysisManager<Function> *AM) {
   return BasicAAResult(F.getParent()->getDataLayout(),
                        AM->getResult<TargetLibraryAnalysis>(F),
                        AM->getResult<AssumptionAnalysis>(F),
+                       F.getParent()->getInvariantInfo(),
                        AM->getCachedResult<DominatorTreeAnalysis>(F),
                        AM->getCachedResult<LoopAnalysis>(F));
 }
 
 char BasicAAWrapperPass::ID = 0;
 void BasicAAWrapperPass::anchor() {}
 
 INITIALIZE_PASS_BEGIN(BasicAAWrapperPass, "basicaa",

 bool BasicAAWrapperPass::runOnFunction(Function &F) {
   auto &ACT = getAnalysis<AssumptionCacheTracker>();
   auto &TLIWP = getAnalysis<TargetLibraryInfoWrapperPass>();
   auto *DTWP = getAnalysisIfAvailable<DominatorTreeWrapperPass>();
   auto *LIWP = getAnalysisIfAvailable<LoopInfoWrapperPass>();
 
   Result.reset(new BasicAAResult(F.getParent()->getDataLayout(), TLIWP.getTLI(),
                                  ACT.getAssumptionCache(F),
+                                 F.getParent()->getInvariantInfo(),
                                  DTWP ? &DTWP->getDomTree() : nullptr,
                                  LIWP ? &LIWP->getLoopInfo() : nullptr));
 
   return false;
 }
 
 void BasicAAWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.setPreservesAll();
   AU.addRequired<AssumptionCacheTracker>();
   AU.addRequired<TargetLibraryInfoWrapperPass>();
 }
 
 BasicAAResult llvm::createLegacyPMBasicAAResult(Pass &P, Function &F) {
   return BasicAAResult(
       F.getParent()->getDataLayout(),
       P.getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(),
-      P.getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F));
+      P.getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F),
+      F.getParent()->getInvariantInfo());
 }

unittests/Analysis/AliasAnalysisTest.cpp

protected:
   AliasAnalysisTest() : M("AliasAnalysisTest", C), TLI(TLII) {}
 
   AAResults &getAAResults(Function &F) {
     // Reset the Function AA results first to clear out any references.
     AAR.reset(new AAResults());
 
     // Build the various AA results and register them.
     AC.reset(new AssumptionCache(F));
-    BAR.reset(new BasicAAResult(M.getDataLayout(), TLI, *AC));
+    BAR.reset(new BasicAAResult(M.getDataLayout(), TLI, *AC,
+                                M.getInvariantInfo()));
     AAR->addAAResult(*BAR);
 
     return *AAR;
   }
 };
 
 TEST_F(AliasAnalysisTest, getModRefInfo) {
   // Setup function.