[LoopRotate][WIP] Check code-motion safety before hoisting

[RithikSharma]

Summary

This patch adds checking of code-motion safety before hoisting, Loop rotate considers moving memory instructions as unsafe we used CodeMoverUtils to check code-motion safety of memory instructions and included other pass independent checks, It hoists more memory instructions resulting in less duplication.

LoopRotate:

define void @test(i32 %n, i32* %A) {
  %cond1 = icmp slt i32 0, %n
  %0 = load i32, i32* %A
  %1 = add nsw i32 %0, 5
  br i1 %cond1, label %body.lr.ph, label %exit

body.lr.ph:                                       ; preds = %entry
  br label %body

body:                                             ; preds = %body.lr.ph, %latch
  %i2 = phi i32 [ 0, %body.lr.ph ], [ %i.next, %latch ]
  br label %latch

latch:                                            ; preds = %body
  %i.next = add nsw i32 %i2, 1
  %cond = icmp slt i32 %i.next, %n
  %2 = load i32, i32* %A
  %3 = add nsw i32 %2, 5
  br i1 %cond, label %body, label %for.header.exit_crit_edge

for.header.exit_crit_edge:                        ; preds = %latch
  br label %exit

exit:                                             ; preds = %for.header.exit_crit_edge, %entry
  ret void
}

CodeMoverUtils:

define void @test(i32 %n, i32* %A) {
entry:
  %cond1 = icmp slt i32 0, %n
  %0 = load i32, i32* %A, align 4
  %1 = add nsw i32 %0, 5
  br i1 %cond1, label %body.lr.ph, label %exit

body.lr.ph:                                       ; preds = %entry
  br label %body

body:                                             ; preds = %body.lr.ph, %latch
  %i2 = phi i32 [ 0, %body.lr.ph ], [ %i.next, %latch ]
  br label %latch

latch:                                            ; preds = %body
  %i.next = add nsw i32 %i2, 1
  %cond = icmp slt i32 %i.next, %n
  br i1 %cond, label %body, label %for.header.exit_crit_edge

for.header.exit_crit_edge:                        ; preds = %latch
  br label %exit

exit:                                             ; preds = %for.header.exit_crit_edge, %entry
  ret void
}

This shows more hoisting of instructions and less duplication after using code-motion checks before hoisting.
PS: Some test case are failing. I'm working to fix them.

[lebedev.ri]

Tests missing

[bmahjour]

llvm/lib/Transforms/Utils/CodeMoverUtils.cpp

431

This makes it easy to misuse the interface. If someone forgets to pass PDT, we skip checking for control flow equivalence and may return "safe" when it's not the case. I think we should pass a separate boolean to make the user explicitly state whether they care about control-flow equivalence or not.

llvm/lib/Transforms/Utils/LoopRotationUtils.cpp

81

AA is a member variable, why does it need to be passed as an argument too?

84

why pass AA as argument when it's available as a member?

[RithikSharma]

llvm/lib/Transforms/Utils/CodeMoverUtils.cpp

431

The basic assumption was that the user will guarantee control flow equivalence as there are not many loop passes that have PDT.

llvm/lib/Transforms/Utils/LoopRotationUtils.cpp

81

Thanks, yes we don't require it as an argument, I will update this asap.

84

Same for this, I will update this soon.

[bmahjour]

llvm/lib/Transforms/Utils/CodeMoverUtils.cpp

431

I understand, but the user might pass nullptr (because they don't have PDT) without checking for control flow (by mistake). I would consider this an interface bug to assume that the user checked for control-flow equivalence in the absence of a valid PDT. Instead of assuming it, we should make the user be explicit about it.

[RithikSharma]

llvm/lib/Transforms/Utils/CodeMoverUtils.cpp

431

This makes sense to me, instead of assuming about control flow equivalence the pass would tell us more about it. I will update the patch with the required changes asap.

llvm/include/llvm/Transforms/Scalar/LoopRotation.h

 #define LLVM_TRANSFORMS_SCALAR_LOOPROTATION_H
 
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/Transforms/Scalar/LoopPassManager.h"
 
 namespace llvm {
 
+class AAResults;
 /// A simple loop rotation transformation.
 class LoopRotatePass : public PassInfoMixin<LoopRotatePass> {
 public:
   LoopRotatePass(bool EnableHeaderDuplication = true);
   PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
-                        LoopStandardAnalysisResults &AR, LPMUpdater &U);
+                        LoopStandardAnalysisResults &AR, LPMUpdater &U,
+                        AAResults *AA = nullptr);
 
 private:
   const bool EnableHeaderDuplication;
 };
-}
+} // namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_LOOPROTATION_H

llvm/include/llvm/Transforms/Utils/LoopRotationUtils.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TRANSFORMS_UTILS_LOOPROTATIONUTILS_H
 #define LLVM_TRANSFORMS_UTILS_LOOPROTATIONUTILS_H
 
 namespace llvm {
 
+class AAResults;
 class AssumptionCache;
 class DominatorTree;
 class Loop;
 class LoopInfo;
 class MemorySSAUpdater;
 class ScalarEvolution;
 struct SimplifyQuery;
 class TargetTransformInfo;
 
 /// Convert a loop into a loop with bottom test. It may
 /// perform loop latch simplication as well if the flag RotationOnly
 /// is false. The flag Threshold represents the size threshold of the loop
 /// header. If the loop header's size exceeds the threshold, the loop rotation
 /// will give up. The flag IsUtilMode controls the heuristic used in the
 /// LoopRotation. If it is true, the profitability heuristic will be ignored.
 bool LoopRotation(Loop *L, LoopInfo *LI, const TargetTransformInfo *TTI,
                   AssumptionCache *AC, DominatorTree *DT, ScalarEvolution *SE,
                   MemorySSAUpdater *MSSAU, const SimplifyQuery &SQ,
-                  bool RotationOnly, unsigned Threshold, bool IsUtilMode);
+                  bool RotationOnly, unsigned Threshold, bool IsUtilMode,
+                  AAResults *AA = nullptr);
 
 } // namespace llvm
 
 #endif

llvm/lib/Transforms/Scalar/LoopRotation.cpp

 //===- LoopRotation.cpp - Loop Rotation Pass ------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements Loop Rotation Pass.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Transforms/Scalar/LoopRotation.h"
 #include "llvm/ADT/Statistic.h"
+#include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/InstructionSimplify.h"
 #include "llvm/Analysis/LoopPass.h"
 #include "llvm/Analysis/MemorySSA.h"
 #include "llvm/Analysis/MemorySSAUpdater.h"
 #include "llvm/Analysis/ScalarEvolution.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/Support/CommandLine.h"
static cl::opt<unsigned> DefaultRotationThreshold(
     "rotation-max-header-size", cl::init(16), cl::Hidden,
     cl::desc("The default maximum header size for automatic loop rotation"));
 
 LoopRotatePass::LoopRotatePass(bool EnableHeaderDuplication)
     : EnableHeaderDuplication(EnableHeaderDuplication) {}
 
 PreservedAnalyses LoopRotatePass::run(Loop &L, LoopAnalysisManager &AM,
                                       LoopStandardAnalysisResults &AR,
-                                      LPMUpdater &) {
+                                      LPMUpdater &, AAResults *AA) {
   int Threshold = EnableHeaderDuplication ? DefaultRotationThreshold : 0;
   const DataLayout &DL = L.getHeader()->getModule()->getDataLayout();
   const SimplifyQuery SQ = getBestSimplifyQuery(AR, DL);
 
   Optional<MemorySSAUpdater> MSSAU;
   if (AR.MSSA)
     MSSAU = MemorySSAUpdater(AR.MSSA);
   bool Changed = LoopRotation(&L, &AR.LI, &AR.TTI, &AR.AC, &AR.DT, &AR.SE,
                               MSSAU.hasValue() ? MSSAU.getPointer() : nullptr,
-                              SQ, false, Threshold, false);
+                              SQ, false, Threshold, false, &AR.AA);
 
   if (!Changed)
     return PreservedAnalyses::all();
 
   if (AR.MSSA && VerifyMemorySSA)
     AR.MSSA->verifyMemorySSA();
 
   auto PA = getLoopPassPreservedAnalyses();
LoopRotateLegacyPass(int SpecifiedMaxHeaderSize = -1) : LoopPass(ID) {
     if (SpecifiedMaxHeaderSize == -1)
       MaxHeaderSize = DefaultRotationThreshold;
     else
       MaxHeaderSize = unsigned(SpecifiedMaxHeaderSize);
   }
 
   // LCSSA form makes instruction renaming easier.
   void getAnalysisUsage(AnalysisUsage &AU) const override {
+    LoopPass::getAnalysisUsage(AU);
     AU.addRequired<AssumptionCacheTracker>();
     AU.addRequired<TargetTransformInfoWrapperPass>();
     if (EnableMSSALoopDependency)
-      AU.addPreserved<MemorySSAWrapperPass>();
+    AU.addRequired<AAResultsWrapperPass>();
     getLoopAnalysisUsage(AU);
   }
 
   bool runOnLoop(Loop *L, LPPassManager &LPM) override {
     if (skipLoop(L))
       return false;
     Function &F = *L->getHeader()->getParent();
 
+    auto *AA = &getAnalysis<AAResultsWrapperPass>().getAAResults();
     auto *LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
     const auto *TTI = &getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F);
     auto *AC = &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
     auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
     auto &SE = getAnalysis<ScalarEvolutionWrapperPass>().getSE();
     const SimplifyQuery SQ = getBestSimplifyQuery(*this, F);
     Optional<MemorySSAUpdater> MSSAU;
     if (EnableMSSALoopDependency) {
       // Not requiring MemorySSA and getting it only if available will split
       // the loop pass pipeline when LoopRotate is being run first.
       auto *MSSAA = getAnalysisIfAvailable<MemorySSAWrapperPass>();
       if (MSSAA)
         MSSAU = MemorySSAUpdater(&MSSAA->getMSSA());
     }
     return LoopRotation(L, LI, TTI, AC, &DT, &SE,
                         MSSAU.hasValue() ? MSSAU.getPointer() : nullptr, SQ,
-                        false, MaxHeaderSize, false);
+                        false, MaxHeaderSize, false, AA);
   }
 };
 } // end namespace
 
 char LoopRotateLegacyPass::ID = 0;
 INITIALIZE_PASS_BEGIN(LoopRotateLegacyPass, "loop-rotate", "Rotate Loops",
                       false, false)
+INITIALIZE_PASS_DEPENDENCY(AAResultsWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
 INITIALIZE_PASS_DEPENDENCY(LoopPass)
 INITIALIZE_PASS_DEPENDENCY(TargetTransformInfoWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(MemorySSAWrapperPass)
 INITIALIZE_PASS_END(LoopRotateLegacyPass, "loop-rotate", "Rotate Loops", false,
                     false)
 
 Pass *llvm::createLoopRotatePass(int MaxHeaderSize) {
   return new LoopRotateLegacyPass(MaxHeaderSize);
 }

llvm/lib/Transforms/Utils/CodeMoverUtils.cpp

 #include "llvm/Transforms/Utils/CodeMoverUtils.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/DependenceAnalysis.h"
 #include "llvm/Analysis/PostDominators.h"
 #include "llvm/Analysis/ValueTracking.h"
 #include "llvm/IR/Dominators.h"
+#include "llvm/IR/IntrinsicInst.h"
 
 using namespace llvm;
 
 #define DEBUG_TYPE "codemover-utils"
 
 STATISTIC(HasDependences,
           "Cannot move across instructions that has memory dependences");
 STATISTIC(MayThrowException, "Cannot move across instructions that may throw");
 STATISTIC(NotControlFlowEquivalent,
           "Instructions are not control flow equivalent");
 STATISTIC(NotMovedPHINode, "Movement of PHINodes are not supported");
 STATISTIC(NotMovedTerminator, "Movement of Terminator are not supported");
+STATISTIC(NotAllocaInst, "Movement of AllocaInst are not supported");
+STATISTIC(NotDbgInfoIntrinsic,
+          "Movement of DbgInfoIntrinsic are not supported");
 
 namespace {
 /// Represent a control condition. A control condition is a condition of a
 /// terminator to decide which successors to execute. The pointer field
 /// represents the address of the condition of the terminator. The integer field
 /// is a bool, it is true when the basic block is executed when V is true. For
 /// example, `br %cond, bb0, bb1` %cond is a control condition of bb0 with the
 /// integer field equals to true, while %cond is a control condition of bb1 with
while (!WorkList.empty()) {
     getNextInsts(*CurInst, WorkList);
   }
 }
 
 bool llvm::isSafeToMoveBefore(Instruction &I, Instruction &InsertPoint,
                               DominatorTree &DT, const PostDominatorTree *PDT,
                               DependenceInfo *DI, AAResults *AA) {
   // Skip tests when we don't have PDT or either one of DI or AA.
-  if (!PDT || !(DI || AA))
+  if (PDT && !(DI || AA))
     return false;
 
   // Cannot move itself before itself.
   if (&I == &InsertPoint)
     return false;
 
   // Not moved.
   if (I.getNextNode() == &InsertPoint)
     return true;
 
   if (isa<PHINode>(I) || isa<PHINode>(InsertPoint))
     return reportInvalidCandidate(I, NotMovedPHINode);
 
   if (I.isTerminator())
     return reportInvalidCandidate(I, NotMovedTerminator);
 
+  if (isa<DbgInfoIntrinsic>(&I))
+    return reportInvalidCandidate(I, NotDbgInfoIntrinsic);
+
+  if (isa<AllocaInst>(&I))
+    return reportInvalidCandidate(I, NotAllocaInst);
+
   // TODO remove this limitation.
-  if (!isControlFlowEquivalent(I, InsertPoint, DT, *PDT))
+  if (PDT && !isControlFlowEquivalent(I, InsertPoint, DT, *PDT))
     return reportInvalidCandidate(I, NotControlFlowEquivalent);
 
   if (!DT.dominates(&InsertPoint, &I))
     for (const Use &U : I.uses())
       if (auto *UserInst = dyn_cast<Instruction>(U.getUser()))
         if (UserInst != &InsertPoint && !DT.dominates(&InsertPoint, U))
           return false;
   if (!DT.dominates(&I, &InsertPoint))

llvm/lib/Transforms/Utils/LoopRotationUtils.cpp

 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
+#include "llvm/Transforms/Utils/CodeMoverUtils.h"
 #include "llvm/Transforms/Utils/Local.h"
 #include "llvm/Transforms/Utils/LoopUtils.h"
 #include "llvm/Transforms/Utils/SSAUpdater.h"
 #include "llvm/Transforms/Utils/ValueMapper.h"
 using namespace llvm;
 
 #define DEBUG_TYPE "loop-rotate"
 
class LoopRotate {
   const TargetTransformInfo *TTI;
   AssumptionCache *AC;
   DominatorTree *DT;
   ScalarEvolution *SE;
   MemorySSAUpdater *MSSAU;
   const SimplifyQuery &SQ;
   bool RotationOnly;
   bool IsUtilMode;
+  AAResults *AA;
 
 public:
   LoopRotate(unsigned MaxHeaderSize, LoopInfo *LI,
              const TargetTransformInfo *TTI, AssumptionCache *AC,
              DominatorTree *DT, ScalarEvolution *SE, MemorySSAUpdater *MSSAU,
-             const SimplifyQuery &SQ, bool RotationOnly, bool IsUtilMode)
+             const SimplifyQuery &SQ, bool RotationOnly, bool IsUtilMode,
+             AAResults *AA)
       : MaxHeaderSize(MaxHeaderSize), LI(LI), TTI(TTI), AC(AC), DT(DT), SE(SE),
         MSSAU(MSSAU), SQ(SQ), RotationOnly(RotationOnly),
-        IsUtilMode(IsUtilMode) {}
-  bool processLoop(Loop *L);
+        IsUtilMode(IsUtilMode), AA(AA) {}
+  bool processLoop(Loop *L, AAResults *AA);
 
 private:
-  bool rotateLoop(Loop *L, bool SimplifiedLatch);
+  bool rotateLoop(Loop *L, bool SimplifiedLatch, AAResults *AA);
   bool simplifyLoopLatch(Loop *L);
 };
 } // end anonymous namespace
 
 /// Insert (K, V) pair into the ValueToValueMap, and verify the key did not
 /// previously exist in the map, and the value was inserted.
 static void InsertNewValueIntoMap(ValueToValueMapTy &VM, Value *K, Value *V) {
   bool Inserted = VM.insert({K, V}).second;

 /// been simplified. However, if SimplifiedLatch is false, then we avoid
 /// rotating loops in which the latch exits to avoid excessive or endless
 /// rotation. LoopRotate should be repeatable and converge to a canonical
 /// form. This property is satisfied because simplifying the loop latch can only
 /// happen once across multiple invocations of the LoopRotate pass.
 ///
 /// If -loop-rotate-multi is enabled we can do multiple rotations in one go
 /// so to reach a suitable (non-deoptimizing) exit.
-bool LoopRotate::rotateLoop(Loop *L, bool SimplifiedLatch) {
+bool LoopRotate::rotateLoop(Loop *L, bool SimplifiedLatch, AAResults *AA) {
   // If the loop has only one block then there is not much to rotate.
   if (L->getBlocks().size() == 1)
     return false;
 
   bool Rotated = false;
   do {
     BasicBlock *OrigHeader = L->getHeader();
     BasicBlock *OrigLatch = L->getLoopLatch();
while (I != E) {
       Instruction *Inst = &*I++;
 
       // If the instruction's operands are invariant and it doesn't read or write
       // memory, then it is safe to hoist.  Doing this doesn't change the order of
       // execution in the preheader, but does prevent the instruction from
       // executing in each iteration of the loop.  This means it is safe to hoist
       // something that might trap, but isn't safe to hoist something that reads
       // memory (without proving that the loop doesn't write).
-      if (L->hasLoopInvariantOperands(Inst) && !Inst->mayReadFromMemory() &&
-          !Inst->mayWriteToMemory() && !Inst->isTerminator() &&
-          !isa<DbgInfoIntrinsic>(Inst) && !isa<AllocaInst>(Inst)) {
+      if (L->hasLoopInvariantOperands(Inst) && 
+          isSafeToMoveBefore(*Inst, *LoopEntryBranch, *DT, nullptr, nullptr,
+                             AA)) {
         Inst->moveBefore(LoopEntryBranch);
         continue;
       }
 
       // Otherwise, create a duplicate of the instruction.
       Instruction *C = Inst->clone();
 
       // Eagerly remap the operands of the instruction.
bool LoopRotate::simplifyLoopLatch(Loop *L) {
 
   if (MSSAU && VerifyMemorySSA)
     MSSAU->getMemorySSA()->verifyMemorySSA();
 
   return true;
 }
 
 /// Rotate \c L, and return true if any modification was made.
-bool LoopRotate::processLoop(Loop *L) {
+bool LoopRotate::processLoop(Loop *L, AAResults *AA) {
   // Save the loop metadata.
   MDNode *LoopMD = L->getLoopID();
 
   bool SimplifiedLatch = false;
 
   // Simplify the loop latch before attempting to rotate the header
   // upward. Rotation may not be needed if the loop tail can be folded into the
   // loop exit.
   if (!RotationOnly)
     SimplifiedLatch = simplifyLoopLatch(L);
 
-  bool MadeChange = rotateLoop(L, SimplifiedLatch);
+  bool MadeChange = rotateLoop(L, SimplifiedLatch, AA);
   assert((!MadeChange || L->isLoopExiting(L->getLoopLatch())) &&
          "Loop latch should be exiting after loop-rotate.");
 
   // Restore the loop metadata.
   // NB! We presume LoopRotation DOESN'T ADD its own metadata.
   if ((MadeChange || SimplifiedLatch) && LoopMD)
     L->setLoopID(LoopMD);
 
   return MadeChange || SimplifiedLatch;
 }
 
 
 /// The utility to convert a loop into a loop with bottom test.
 bool llvm::LoopRotation(Loop *L, LoopInfo *LI, const TargetTransformInfo *TTI,
                         AssumptionCache *AC, DominatorTree *DT,
                         ScalarEvolution *SE, MemorySSAUpdater *MSSAU,
                         const SimplifyQuery &SQ, bool RotationOnly = true,
                         unsigned Threshold = unsigned(-1),
-                        bool IsUtilMode = true) {
+                        bool IsUtilMode = true, AAResults *AA) {
   LoopRotate LR(Threshold, LI, TTI, AC, DT, SE, MSSAU, SQ, RotationOnly,
-                IsUtilMode);
-  return LR.processLoop(L);
+                IsUtilMode, AA);
+  return LR.processLoop(L, AA);
 }

llvm/unittests/Transforms/Utils/LoopRotationUtilsTest.cpp

 //===- LoopRotationUtilsTest.cpp - Unit tests for LoopRotation utility ----===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Transforms/Utils/LoopRotationUtils.h"
+#include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/AssumptionCache.h"
+#include "llvm/Analysis/BasicAliasAnalysis.h"
 #include "llvm/Analysis/InstructionSimplify.h"
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/Analysis/ScalarEvolution.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
 #include "llvm/AsmParser/Parser.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/LLVMContext.h"
deopt.exit:
 
   auto *F = M->getFunction("test");
   DominatorTree DT(*F);
   LoopInfo LI(DT);
   AssumptionCache AC(*F);
   TargetTransformInfo TTI(M->getDataLayout());
   TargetLibraryInfoImpl TLII;
   TargetLibraryInfo TLI(TLII);
+  AAResults AA(TLI);
+  DataLayout DL("");
+  BasicAAResult BAA(DL, *F, TLI, AC, &DT);
+  AA.addAAResult(BAA);
   ScalarEvolution SE(*F, TLI, AC, DT, LI);
   SimplifyQuery SQ(M->getDataLayout());
 
   Loop *L = *LI.begin();
 
   bool ret = LoopRotation(L, &LI, &TTI,
                           &AC, &DT,
                           &SE, nullptr,
-                          SQ, true, -1, false);
+                          SQ, true, -1, false, &AA);
   EXPECT_TRUE(ret);
 }
 
 /// Checking a special case of multi-deopt exit loop that can not perform
 /// required amount of rotations due to the desired header containing
 /// non-duplicatable code.
 /// Similar to MultiDeoptExit test this one should do at least one rotation and
 /// pass no matter what loop rotation settings are.
deopt.exit:
 
   auto *F = M->getFunction("test_nondup");
   DominatorTree DT(*F);
   LoopInfo LI(DT);
   AssumptionCache AC(*F);
   TargetTransformInfo TTI(M->getDataLayout());
   TargetLibraryInfoImpl TLII;
   TargetLibraryInfo TLI(TLII);
+  AAResults AA(TLI);
+  DataLayout DL("");
+  BasicAAResult BAA(DL, *F, TLI, AC, &DT);
+  AA.addAAResult(BAA);
   ScalarEvolution SE(*F, TLI, AC, DT, LI);
   SimplifyQuery SQ(M->getDataLayout());
 
   Loop *L = *LI.begin();
 
   bool ret = LoopRotation(L, &LI, &TTI,
                           &AC, &DT,
                           &SE, nullptr,
-                          SQ, true, -1, false);
+                          SQ, true, -1, false, &AA);
   /// LoopRotation should properly report "true" as we still perform the first rotation
   /// so we do change the IR.
   EXPECT_TRUE(ret);
 }