[LAA] Use cross-iteration alias analysis

[nikic]

Summary

LAA analyzes cross-iteration memory dependencies, as such AA should not make assumptions about equality of values inside the loop, as they may come from different iterations.

Fix this by exposing the MayBeCrossIteration AA flag and enabling it for LAA.

Depends on D137955.

[fhahn]

LGTM, thanks!

llvm/include/llvm/Analysis/AliasAnalysis.h

return alias(MemoryLocation(V1, LocationSize::precise(1)),
                  MemoryLocation(V2, LocationSize::precise(1))) ==
            AliasResult::MustAlias;
   }
   ModRefInfo callCapturesBefore(const Instruction *I,
                                 const MemoryLocation &MemLoc,
                                 DominatorTree *DT) {
     return AA.callCapturesBefore(I, MemLoc, DT, AAQI);
   }
+
+  /// Assume that values may come from different cycle iterations.
+  void enableCrossIterationMode() {
+    AAQI.MayBeCrossIteration = true;
+  }
 };
 
 /// Temporary typedef for legacy code that uses a generic \c AliasAnalysis
 /// pointer or reference.
 using AliasAnalysis = AAResults;
 
 /// A private abstract base class describing the concept of an individual alias
 /// analysis implementation.

llvm/lib/Analysis/LoopAccessAnalysis.cpp

 public:
   /// Read or write access location.
   typedef PointerIntPair<Value *, 1, bool> MemAccessInfo;
   typedef SmallVector<MemAccessInfo, 8> MemAccessInfoList;
 
   AccessAnalysis(Loop *TheLoop, AAResults *AA, LoopInfo *LI,
                  MemoryDepChecker::DepCandidates &DA,
                  PredicatedScalarEvolution &PSE)
-      : TheLoop(TheLoop), BAA(*AA), AST(BAA), LI(LI), DepCands(DA), PSE(PSE) {}
+      : TheLoop(TheLoop), BAA(*AA), AST(BAA), LI(LI), DepCands(DA), PSE(PSE) {
+    // We're analyzing dependences across loop iterations.
+    BAA.enableCrossIterationMode();
+  }
 
   /// Register a load  and whether it is only read from.
   void addLoad(MemoryLocation &Loc, Type *AccessTy, bool IsReadOnly) {
     Value *Ptr = const_cast<Value*>(Loc.Ptr);
     AST.add(Ptr, LocationSize::beforeOrAfterPointer(), Loc.AATags);
     Accesses[MemAccessInfo(Ptr, false)].insert(AccessTy);
     if (IsReadOnly)
       ReadOnlyPtr.insert(Ptr);

llvm/test/Analysis/LoopAccessAnalysis/select-dependence.ll

+; RUN: opt -passes='print<access-info>' -disable-output 2>&1 < %s | FileCheck %s
+
+; CHECK: Dependences:
+; CHECK-NEXT: Unknown:
+; CHECK-NEXT: %t63 = load double, ptr %t62, align 8 ->
+; CHECK-NEXT: store double %t63, ptr %t64, align 8
+
+define i32 @test() {
+   %a1 = alloca [128 x double], align 8
+   %a2 = alloca [128 x double], align 8
+   %a3 = alloca [128 x double], align 8
+   %t30 = getelementptr double, ptr %a2, i64 -32
+   br label %loop
+
+loop:
+   %t58 = phi i64 [ %t65, %loop ], [ 0, %0 ]
+   %t59 = icmp ule i64 %t58, 32
+   %t60 = select i1 %t59, ptr %a1, ptr %t30
+   %t62 = getelementptr inbounds double, ptr %t60, i64 %t58
+   %t63 = load double, ptr %t62, align 8
+   %t61 = select i1 %t59, ptr %a2, ptr %a3
+   %t64 = getelementptr inbounds double, ptr %t61, i64 %t58
+   store double %t63, ptr %t64, align 8
+   %t65 = add nuw nsw i64 %t58, 1
+   %t66 = icmp eq i64 %t65, 94
+   br i1 %t66, label %exit, label %loop
+
+exit:
+   ret i32 0
+}