[CodeMoverUtils] Add optional data dependence checks using Alias Analysis

[RithikSharma]

Summary

isSafeToMoveBefore uses Dependence Info to check for flow/anti/output dependence, this patch adds alternative checks using Alias Analysis.

[Whitney]

llvm/lib/Transforms/Utils/CodeMoverUtils.cpp

230

Please add a description for each isDependenceSafe(). And declare them as static.

231

SmallPtrSet<Instruction *, 10> -> SmallPtrSetImpl<Instruction *>

Same for the other isDependenceSafe().

258

check this at line 251.

if (AA.isNoAlias(MemLoc, DestMemLoc))
  return false;

llvm/unittests/Transforms/Utils/CodeMoverUtilsTest.cpp

46

Does DataLayout DL(""); work?

[RithikSharma]

llvm/unittests/Transforms/Utils/CodeMoverUtilsTest.cpp

46

Thanks, yes it works.

[Whitney]

llvm/lib/Transforms/Utils/CodeMoverUtils.cpp

230

Instructions -> instructions

236

return (DepResult && (DepResult->isOutput() || DepResult->isFlow() || DepResult->isAnti()));

258

check isNoAlias before querying getModRefInfo

269

using dependence info or alias analysis

[RithikSharma]

Acknowledged, updated.

[bmahjour]

llvm/lib/Transforms/Utils/CodeMoverUtils.cpp

252

MemoryLocation::get returns "none" if Inst is a call. Please add special handling for calls and make sure your tests cover it.

260

The ref bit could be on for mod-ref cases. Please also check to make sure they are not mod.

[RithikSharma]

llvm/lib/Transforms/Utils/CodeMoverUtils.cpp

252

Test case pending.

[bmahjour]

llvm/lib/Transforms/Utils/CodeMoverUtils.cpp

264

Inst (from the list of instructions being checked) may also be a call.

[bmahjour]

llvm/lib/Transforms/Utils/CodeMoverUtils.cpp

249

Not all aliasing implications are visible through the arguments. AAResults contains a number of overloads specifically designed to handle function calls. Did you look into using the following instead?

ModRefInfo getModRefInfo(const CallBase *Call, const MemoryLocation &Loc);
ModRefInfo getModRefInfo(Instruction *I, const CallBase *Call);
ModRefInfo getModRefInfo(const CallBase *Call1, const CallBase *Call2);

[fhahn]

Are there plans on moving some transforms to use this with AA? I think it would be good to have a concrete plan to make use of this, otherwise I am worried that the code will miss out on large real-world test coverage.

[RithikSharma]

In D84589#2180220, @fhahn wrote:

Are there plans on moving some transforms to use this with AA? I think it would be good to have a concrete plan to make use of this, otherwise I am worried that the code will miss out on large real-world test coverage.

This was inspired from LICM, I'm trying to test this part by manually plugging this into LICM.

[hiraditya]

llvm/lib/Transforms/Utils/CodeMoverUtils.cpp

248

Any reason we have '10' instead of a value which is power of 2?

260

Once IsSafe is false. should we just return and avoid subsequent checks?

298

else is not needed,

375

comment needs update.

444

Are we planning to make use of AA here?

[RithikSharma]

Many thanks for you reviews @hiraditya , acknowledged and updated.

[Whitney]

llvm/lib/Transforms/Utils/CodeMoverUtils.cpp

252

Is the test cases for call going to be added in this patch?

260

You don't need to variable IsSafe anymore, as you return false right away if IsSafe is false. And you can return true at the end of the function instead.

264

// This can be none for CallInst but this won't be used for CallInst

I don't understand this comment.

280

Is it safe to check this first if the memory locations are not None?
Something like...

auto DestMemLoc = MemoryLocation::get(Inst);
if (MemLoc.hasValue() && DestMemLoc.hasValue() &&  AA.isNoAlias(MemLoc, DestMemLoc))
    return false;

ModRefInfo Result = AA.getModRefInfo(Inst, MemLoc);
ModRefInfo DestResult = AA.getModRefInfo(&I, DestMemLoc);
if (CallBase *CBDest = dyn_cast<CallBase>(Inst)) {
  if (!MemLoc.hasValue())
    Result = DestResult = AA.getModRefInfo(&I, CBDest);
if (CallBase *CBSrc = dyn_cast<CallBase>(&I))
  if (!DestMemLoc.hasValue())
    DestResult = AA.getModRefInfo(Inst, CBSrc);

419–432

why remove isSafeToSpeculativelyExecute?

[RithikSharma]

Thanks for the reviews @Whitney , I have updated the patch with the changes.

llvm/lib/Transforms/Utils/CodeMoverUtils.cpp

252

Test cases are present in https://reviews.llvm.org/D84776

[Whitney]

llvm/lib/Transforms/Utils/CodeMoverUtils.cpp

252

Can you move specifically the part that test call instructions here? And the test in D84776 doesn't have any call instructions with pointer operands, so this code is not tested.

280

I mean check isNoAlias first, before querying getModRefInfo.

[bmahjour]

llvm/lib/Transforms/Utils/CodeMoverUtils.cpp

287

Two comments here:

1. As I mentioned before, isRefSet may be true when isModSet is also true, so if you want to check for RAR you'd have to make sure that isModSet is false.
2. Why do we need two results (Result and DestResult)? I'm not sure we need to query AA.getModRefInfo twice, once for each direction. Alias queries normally refer to a value in a symmetric bit matrix. Do you have a test where the result of AA.getModRefInfo is different depending on the order in which you pass the two memory location arguments?

[RithikSharma]

@Whitney thanks for the reviews, I have added the test case.

[RithikSharma]

@bmahjour thanks for the reviews, I will update the patch soon.

[RithikSharma]

llvm/lib/Transforms/Utils/CodeMoverUtils.cpp

287

1. I have added checks for isModSet .
2. We don't require two (Result and DestResult), I have checked the values of Result and DestResult, they are different.

I have made the required changes.

[bmahjour]

llvm/lib/Transforms/Utils/CodeMoverUtils.cpp

250

I think the call itself should also go into the MemLocs vector.

[Whitney]

llvm/lib/Transforms/Utils/CodeMoverUtils.cpp

280

I am confused why cannot change to the code as suggested above.

This current code seems to have some code duplication.

292

This is no longer needed.

[RithikSharma]

llvm/lib/Transforms/Utils/CodeMoverUtils.cpp

280

I'll verify that and look more what's missing, extra and not in sequence. I will update the patch with required changes asap.

292

Thanks, I'll include this in the next update.

[RithikSharma]

llvm/lib/Transforms/Utils/CodeMoverUtils.cpp

250

CallInst returns none memory location, which won't be useful to find dependence info and we may have to skip it so I did not add it into the MemLocs in the first place.

[bmahjour]

llvm/lib/Transforms/Utils/CodeMoverUtils.cpp

250

Then we have a problem if the memory accesses of a function are not represented through their arguments. For example consider:

int a = 0;

void foo() {
  a = 1;
}

int main() {
  foo();
  a = 3;
  return a;
}

In the case above a = 3 should not be allowed to move before the call to foo().

If this information is not available through AliasAnalysis, then we have to check for it separately. One way to solve it is to look at the underlying object referenced by I and Inst, and if any of them is a global and one of the intervening instructions is a call that may have side-effect, then return false.

[Whitney]

llvm/lib/Transforms/Utils/CodeMoverUtils.cpp

250

Please add this test case, and update the patch.

298

that's true, please remove the else.

llvm/include/llvm/Transforms/Utils/CodeMoverUtils.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TRANSFORMS_UTILS_CODEMOVERUTILS_H
 #define LLVM_TRANSFORMS_UTILS_CODEMOVERUTILS_H
 
 namespace llvm {
 
+class AAResults;
 class BasicBlock;
 class DependenceInfo;
 class DominatorTree;
 class Instruction;
 class PostDominatorTree;
 
 /// Return true if \p I0 and \p I1 are control flow equivalent.
 /// Two instructions are control flow equivalent if their basic blocks are
 /// control flow equivalent.
 bool isControlFlowEquivalent(const Instruction &I0, const Instruction &I1,
                              const DominatorTree &DT,
                              const PostDominatorTree &PDT);
 
 /// Return true if \p BB0 and \p BB1 are control flow equivalent.
 /// Two basic blocks are control flow equivalent if when one executes, the other
 /// is guaranteed to execute.
 bool isControlFlowEquivalent(const BasicBlock &BB0, const BasicBlock &BB1,
                              const DominatorTree &DT,
                              const PostDominatorTree &PDT);
 
 /// Return true if \p I can be safely moved before \p InsertPoint.
 bool isSafeToMoveBefore(Instruction &I, Instruction &InsertPoint,
                         DominatorTree &DT,
                         const PostDominatorTree *PDT = nullptr,
-                        DependenceInfo *DI = nullptr);
+                        DependenceInfo *DI = nullptr, AAResults *AA = nullptr);
 
 /// Return true if all instructions (except the terminator) in \p BB can be
 /// safely moved before \p InsertPoint.
 bool isSafeToMoveBefore(BasicBlock &BB, Instruction &InsertPoint,
                         DominatorTree &DT,
                         const PostDominatorTree *PDT = nullptr,
-                        DependenceInfo *DI = nullptr);
+                        DependenceInfo *DI = nullptr, AAResults *AA = nullptr);
 
 /// Move instructions, in an order-preserving manner, from \p FromBB to the
 /// beginning of \p ToBB when proven safe.
 void moveInstructionsToTheBeginning(BasicBlock &FromBB, BasicBlock &ToBB,
                                     DominatorTree &DT,
                                     const PostDominatorTree &PDT,
                                     DependenceInfo &DI);
 

llvm/lib/Transforms/Utils/CodeMoverUtils.cpp

 //===- CodeMoverUtils.cpp - CodeMover Utilities ----------------------------==//
 //
 // 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 family of functions perform movements on basic blocks, and instructions
 // contained within a function.
 //
 //===----------------------------------------------------------------------===//
 
 #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"
 
 using namespace llvm;
 
 #define DEBUG_TYPE "codemover-utils"
if (const CmpInst *Cmp2 = dyn_cast<CmpInst>(&V2)) {
               CmpInst::getSwappedPredicate(Cmp2->getInversePredicate()) &&
           Cmp1->getOperand(0) == Cmp2->getOperand(1) &&
           Cmp1->getOperand(1) == Cmp2->getOperand(0))
         return true;
     }
   return false;
 }
 
+/// Checks data dependency between /p I and instructions in /p InstsToCheck
+/// using dependence info.
+static bool isDependenceSafe(Instruction &I, DependenceInfo &DI,
+                             SmallPtrSetImpl<Instruction *> &InstsToCheck) {
+  return llvm::none_of(InstsToCheck, [&DI, &I](Instruction *CurInst) {
+    auto DepResult = DI.depends(&I, CurInst, true);
+    return (DepResult && (DepResult->isOutput() || DepResult->isFlow() ||
+                          DepResult->isAnti()));
+  });
+}
+
+/// Checks data dependency between /p I and instructions in /p InstsToCheck
+/// using alias analysis.
+static bool isDependenceSafe(Instruction &I, AAResults &AA,
+                             SmallPtrSetImpl<Instruction *> &InstsToCheck) {
+  if (!I.mayReadOrWriteMemory())
+    return true;
+  auto MemLoc = MemoryLocation::get(&I);
+
+  return llvm::none_of(InstsToCheck, [&AA, &I, &MemLoc](Instruction *Inst) {
+    if (!Inst->mayReadOrWriteMemory())
+      return false;
+    auto DestMemLoc = MemoryLocation::get(Inst);
+
+    ModRefInfo Result, DestResult;
+    if (AA.isNoAlias(MemLoc, DestMemLoc))
+      return false;
+
+    if (CallBase *CBSrc = dyn_cast<CallBase>(&I)) {
+      if (CallBase *CBDest = dyn_cast<CallBase>(Inst)) {
+        Result = DestResult = AA.getModRefInfo(CBSrc, CBDest);
+      } else {
+        Result = AA.getModRefInfo(CBSrc, DestMemLoc);
+        DestResult = AA.getModRefInfo(Inst, CBSrc);
+      }
+    } else if (CallBase *CBDest = dyn_cast<CallBase>(Inst)) {
+      Result = AA.getModRefInfo(&I, CBDest);
+      DestResult = AA.getModRefInfo(CBDest, MemLoc);
+    } else {
+      Result = AA.getModRefInfo(Inst, MemLoc);
+      DestResult = AA.getModRefInfo(&I, DestMemLoc);
+    }
+
+    // RAR dependency is safe
+    if (isRefSet(Result) && isRefSet(DestResult))
+      return false;
+    return true;
+  });
+}
+
+/// Checks data dependency between /p I and instructions in /p InstsToCheck
+/// using dependence info or alias analysis.
+static bool isDependenceSafe(Instruction &I, DependenceInfo *DI, AAResults *AA,
+                             SmallPtrSetImpl<Instruction *> &InstsToCheck) {
+  if (DI)
+    return isDependenceSafe(I, *DI, InstsToCheck);
+  else if (AA)
+    return isDependenceSafe(I, *AA, InstsToCheck);
+  return false;
+}
+
 bool llvm::isControlFlowEquivalent(const Instruction &I0, const Instruction &I1,
                                    const DominatorTree &DT,
                                    const PostDominatorTree &PDT) {
   return isControlFlowEquivalent(*I0.getParent(), *I1.getParent(), DT, PDT);
 }
 
 bool llvm::isControlFlowEquivalent(const BasicBlock &BB0, const BasicBlock &BB1,
                                    const DominatorTree &DT,
                                    const PostDominatorTree &PDT) {
   if (&BB0 == &BB1)
     return true;
 
   if ((DT.dominates(&BB0, &BB1) && PDT.dominates(&BB1, &BB0)) ||
       (PDT.dominates(&BB0, &BB1) && DT.dominates(&BB1, &BB0)))
     return true;
 
if (!InBetweenInsts.insert(CurInst).second)
       continue;
 
     getNextInsts(*CurInst, WorkList);
   }
 }
 
 bool llvm::isSafeToMoveBefore(Instruction &I, Instruction &InsertPoint,
                               DominatorTree &DT, const PostDominatorTree *PDT,
-                              DependenceInfo *DI) {
+                              DependenceInfo *DI, AAResults *AA) {
   // Skip tests when we don't have PDT or DI
-  if (!PDT || !DI)
+  if (!PDT || !(DI || AA))
     return false;
 
   // Cannot move itself before itself.
   if (&I == &InsertPoint)
     return false;
 
   // Not moved.
   if (I.getNextNode() == &InsertPoint)
bool llvm::isSafeToMoveBefore(Instruction &I, Instruction &InsertPoint,
   Instruction &EndInst = (MoveForward ? InsertPoint : I);
   SmallPtrSet<Instruction *, 10> InstsToCheck;
   collectInstructionsInBetween(StartInst, EndInst, InstsToCheck);
   if (!MoveForward)
     InstsToCheck.insert(&InsertPoint);
 
   // Check if there exists instructions which may throw, may synchonize, or may
   // never return, from I to InsertPoint.
-  if (!isSafeToSpeculativelyExecute(&I))
-    if (std::any_of(InstsToCheck.begin(), InstsToCheck.end(),
-                    [](Instruction *I) {
-                      if (I->mayThrow())
-                        return true;
-
-                      const CallBase *CB = dyn_cast<CallBase>(I);
-                      if (!CB)
-                        return false;
-                      if (!CB->hasFnAttr(Attribute::WillReturn))
-                        return true;
-                      if (!CB->hasFnAttr(Attribute::NoSync))
-                        return true;
-
-                      return false;
-                    })) {
-      return reportInvalidCandidate(I, MayThrowException);
-    }
+  if (std::any_of(InstsToCheck.begin(), InstsToCheck.end(), [](Instruction *I) {
 
   // Check if I has any output/flow/anti dependences with instructions from \p
   // StartInst to \p EndInst.
-  if (std::any_of(InstsToCheck.begin(), InstsToCheck.end(),
-                  [&DI, &I](Instruction *CurInst) {
-                    auto DepResult = DI->depends(&I, CurInst, true);
-                    if (DepResult &&
-                        (DepResult->isOutput() || DepResult->isFlow() ||
-                         DepResult->isAnti()))
-                      return true;
-                    return false;
-                  }))
+  if (!isDependenceSafe(I, DI, AA, InstsToCheck))
     return reportInvalidCandidate(I, HasDependences);
 
   return true;
 }
 
 bool llvm::isSafeToMoveBefore(BasicBlock &BB, Instruction &InsertPoint,
                               DominatorTree &DT, const PostDominatorTree *PDT,
-                              DependenceInfo *DI) {
+                              DependenceInfo *DI, AAResults *AA) {
   return llvm::all_of(BB, [&](Instruction &I) {
     if (BB.getTerminator() == &I)
       return true;
 
     return isSafeToMoveBefore(I, InsertPoint, DT, PDT, DI);
   });
 }
 

llvm/unittests/Transforms/Utils/CodeMoverUtilsTest.cpp

 //===- CodeMoverUtils.cpp - Unit tests for CodeMoverUtils ---------------===//
 //
 // 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/CodeMoverUtils.h"
 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/AssumptionCache.h"
+#include "llvm/Analysis/BasicAliasAnalysis.h"
 #include "llvm/Analysis/DependenceAnalysis.h"
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/Analysis/PostDominators.h"
 #include "llvm/AsmParser/Parser.h"
+#include "llvm/IR/DataLayout.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Transforms/Utils/ScalarEvolutionExpander.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 
 static std::unique_ptr<Module> parseIR(LLVMContext &C, const char *IR) {
   SMDiagnostic Err;
   std::unique_ptr<Module> Mod = parseAssemblyString(IR, Err, C);
   if (!Mod)
     Err.print("CodeMoverUtilsTests", errs());
   return Mod;
 }
 
-static void run(Module &M, StringRef FuncName,
-                function_ref<void(Function &F, DominatorTree &DT,
-                                  PostDominatorTree &PDT, DependenceInfo &DI)>
-                    Test) {
+static void
+run(Module &M, StringRef FuncName,
+    function_ref<void(Function &F, DominatorTree &DT, PostDominatorTree &PDT,
+                      DependenceInfo &DI, AAResults &AA)>
   auto *F = M.getFunction(FuncName);
   DominatorTree DT(*F);
   PostDominatorTree PDT(*F);
   TargetLibraryInfoImpl TLII;
   TargetLibraryInfo TLI(TLII);
   AssumptionCache AC(*F);
-  AliasAnalysis AA(TLI);
+  AAResults AA(TLI);
+  DataLayout DL("");
+  BasicAAResult BAA(DL, *F, TLI, AC, &DT);
+  AA.addAAResult(BAA);
   LoopInfo LI(DT);
   ScalarEvolution SE(*F, TLI, AC, DT, LI);
   DependenceInfo DI(F, &AA, &SE, &LI);
-  Test(*F, DT, PDT, DI);
+  Test(*F, DT, PDT, DI, AA);
 }
 
 static BasicBlock *getBasicBlockByName(Function &F, StringRef Name) {
   for (BasicBlock &BB : F)
     if (BB.getName() == Name)
       return &BB;
   llvm_unreachable("Expected to find basic block!");
 }
std::unique_ptr<Module> M =
                  if.third:
                    store i32 3, i32* %i, align 4
                    br label %if.third.end
                  if.third.end:
                    ret void
                  })");
   run(*M, "foo",
       [&](Function &F, DominatorTree &DT, PostDominatorTree &PDT,
-          DependenceInfo &DI) {
+          DependenceInfo &DI, AAResults &AA) {
         BasicBlock *FirstIfBody = getBasicBlockByName(F, "if.first");
         EXPECT_TRUE(
             isControlFlowEquivalent(*FirstIfBody, *FirstIfBody, DT, PDT));
         BasicBlock *SecondIfBody = getBasicBlockByName(F, "if.second");
         EXPECT_TRUE(
             isControlFlowEquivalent(*FirstIfBody, *SecondIfBody, DT, PDT));
 
         BasicBlock *ThirdIfBody = getBasicBlockByName(F, "if.third");
std::unique_ptr<Module> M =
                  if.sixth.else:
                    store i32 9, i32* %i, align 4
                    br label %if.sixth.end
                  if.sixth.end:
                    ret void
                  })");
   run(*M, "foo",
       [&](Function &F, DominatorTree &DT, PostDominatorTree &PDT,
-          DependenceInfo &DI) {
+          DependenceInfo &DI, AAResults &AA) {
         BasicBlock *FirstIfBody = getBasicBlockByName(F, "if.first");
         BasicBlock *SecondIfBody = getBasicBlockByName(F, "if.second");
         BasicBlock *ThirdIfBody = getBasicBlockByName(F, "if.third");
         BasicBlock *ThirdElseBody = getBasicBlockByName(F, "if.third.else");
         EXPECT_TRUE(
             isControlFlowEquivalent(*FirstIfBody, *ThirdElseBody, DT, PDT));
         EXPECT_TRUE(
             isControlFlowEquivalent(*SecondIfBody, *ThirdElseBody, DT, PDT));
std::unique_ptr<Module> M =
          if.inner.second:
            store i32 2, i32* %i, align 4
            br label %if.second.end
          if.second.end:
            ret void
          })");
   run(*M, "foo",
       [&](Function &F, DominatorTree &DT, PostDominatorTree &PDT,
-          DependenceInfo &DI) {
+          DependenceInfo &DI, AAResults &AA) {
         BasicBlock *FirstOuterIfBody = getBasicBlockByName(F, "if.outer.first");
         BasicBlock *FirstInnerIfBody = getBasicBlockByName(F, "if.inner.first");
         BasicBlock *SecondOuterIfBody =
             getBasicBlockByName(F, "if.outer.second");
         BasicBlock *SecondInnerIfBody =
             getBasicBlockByName(F, "if.inner.second");
         EXPECT_TRUE(isControlFlowEquivalent(*FirstInnerIfBody,
                                             *SecondInnerIfBody, DT, PDT));
std::unique_ptr<Module> M = parseIR(
          if.fourth:
            store i32 4, i32* %i, align 4
            br label %if.fourth.end
          if.fourth.end:
            ret void
          })");
   run(*M, "foo",
       [&](Function &F, DominatorTree &DT, PostDominatorTree &PDT,
-          DependenceInfo &DI) {
+          DependenceInfo &DI, AAResults &AA) {
         BasicBlock *FirstIfBody = getBasicBlockByName(F, "if.inner.first");
         BasicBlock *SecondIfBody = getBasicBlockByName(F, "if.inner.second");
         EXPECT_FALSE(
             isControlFlowEquivalent(*FirstIfBody, *SecondIfBody, DT, PDT));
 
         BasicBlock *ThirdIfBody = getBasicBlockByName(F, "if.inner.third");
         BasicBlock *FourthIfBody = getBasicBlockByName(F, "if.fourth");
         EXPECT_TRUE(
std::unique_ptr<Module> M =
                  if.third:
                    store i32 3, i32* %i, align 4
                    br label %if.third.end
                  if.third.end:
                    ret void
                  })");
   run(*M, "foo",
       [&](Function &F, DominatorTree &DT, PostDominatorTree &PDT,
-          DependenceInfo &DI) {
+          DependenceInfo &DI, AAResults &AA) {
         BasicBlock *FirstIfBody = getBasicBlockByName(F, "if.first");
         BasicBlock *SecondIfBody = getBasicBlockByName(F, "if.second");
         // Limitation: if we can prove cond haven't been modify between %0 and
         // %1, then we can prove FirstIfBody and SecondIfBody are control flow
         // equivalent.
         EXPECT_FALSE(
             isControlFlowEquivalent(*FirstIfBody, *SecondIfBody, DT, PDT));
 
std::unique_ptr<Module> M =
                    ret void
                  succ1succ1:
                    br label %bb
                  bb:
                    ret void
                  })");
   run(*M, "foo",
       [&](Function &F, DominatorTree &DT, PostDominatorTree &PDT,
-          DependenceInfo &DI) {
+          DependenceInfo &DI, AAResults &AA) {
         BasicBlock &Idom = F.front();
         assert(Idom.getName() == "idom" && "Expecting BasicBlock idom");
         BasicBlock &BB = F.back();
         assert(BB.getName() == "bb" && "Expecting BasicBlock bb");
         EXPECT_FALSE(isControlFlowEquivalent(Idom, BB, DT, PDT));
       });
 }
 
std::unique_ptr<Module> M = parseIR(
            ret void
          }
          declare void @safecall() nounwind nosync willreturn
          declare void @unsafecall1()
          declare void @unsafecall2())");
 
   run(*M, "foo",
       [&](Function &F, DominatorTree &DT, PostDominatorTree &PDT,
-          DependenceInfo &DI) {
+          DependenceInfo &DI, AAResults &AA) {
         BasicBlock *Entry = getBasicBlockByName(F, "entry");
         Instruction *CI_safecall = Entry->front().getNextNode();
         assert(isa<CallInst>(CI_safecall) &&
                "Expecting CI_safecall to be a CallInst");
         Instruction *CI_unsafecall = CI_safecall->getNextNode()->getNextNode();
         assert(isa<CallInst>(CI_unsafecall) &&
                "Expecting CI_unsafecall to be a CallInst");
         BasicBlock *ForBody = getBasicBlockByName(F, "for.body");
         Instruction &PN = ForBody->front();
         assert(isa<PHINode>(PN) && "Expecting PN to be a PHINode");
         Instruction *SI_A5 =
             getInstructionByName(F, "arrayidx_A5")->getNextNode();
         Instruction *SI = getInstructionByName(F, "arrayidx_A")->getNextNode();
         Instruction *LI1 = getInstructionByName(F, "load1");
         Instruction *LI2 = getInstructionByName(F, "load2");
         Instruction *SI_A6 =
             getInstructionByName(F, "arrayidx_A6")->getNextNode();
 
         // Can move after CI_safecall, as it does not throw, not synchronize, or
         // must return.
         EXPECT_TRUE(isSafeToMoveBefore(*CI_safecall->getPrevNode(),
                                        *CI_safecall->getNextNode(), DT, &PDT,
-                                       &DI));
+                                       &DI, nullptr));
+        EXPECT_TRUE(isSafeToMoveBefore(*CI_safecall->getPrevNode(),
+                                       *CI_safecall->getNextNode(), DT, &PDT,
+                                       nullptr, &AA));
 
         // Cannot move CI_unsafecall, as it may throw.
         EXPECT_FALSE(isSafeToMoveBefore(*CI_unsafecall->getNextNode(),
-                                        *CI_unsafecall, DT, &PDT, &DI));
+                                        *CI_unsafecall, DT, &PDT, &DI,
+                                        nullptr));
+        EXPECT_FALSE(isSafeToMoveBefore(*CI_unsafecall->getNextNode(),
+                                        *CI_unsafecall, DT, &PDT, nullptr,
+                                        &AA));
 
         // Moving instruction to non control flow equivalent places are not
         // supported.
-        EXPECT_FALSE(
-            isSafeToMoveBefore(*SI_A5, *Entry->getTerminator(), DT, &PDT, &DI));
-
+        EXPECT_FALSE(isSafeToMoveBefore(*SI_A5, *Entry->getTerminator(), DT,
+                                        &PDT, &DI, nullptr));
+        EXPECT_FALSE(isSafeToMoveBefore(*SI_A5, *Entry->getTerminator(), DT,
+                                        &PDT, nullptr, &AA));
         // Moving PHINode is not supported.
         EXPECT_FALSE(isSafeToMoveBefore(PN, *PN.getNextNode()->getNextNode(),
-                                        DT, &PDT, &DI));
+                                        DT, &PDT, &DI, nullptr));
+        EXPECT_FALSE(isSafeToMoveBefore(PN, *PN.getNextNode()->getNextNode(),
+                                        DT, &PDT, nullptr, &AA));
 
         // Cannot move non-PHINode before PHINode.
-        EXPECT_FALSE(isSafeToMoveBefore(*PN.getNextNode(), PN, DT, &PDT, &DI));
+        EXPECT_FALSE(
+            isSafeToMoveBefore(*PN.getNextNode(), PN, DT, &PDT, &DI, nullptr));
+        EXPECT_FALSE(
+            isSafeToMoveBefore(*PN.getNextNode(), PN, DT, &PDT, nullptr, &AA));
 
         // Moving Terminator is not supported.
         EXPECT_FALSE(isSafeToMoveBefore(*Entry->getTerminator(),
-                                        *PN.getNextNode(), DT, &PDT, &DI));
+                                        *PN.getNextNode(), DT, &PDT, &DI,
+                                        nullptr));
+        EXPECT_FALSE(isSafeToMoveBefore(*Entry->getTerminator(),
+                                        *PN.getNextNode(), DT, &PDT, nullptr,
+                                        &AA));
 
         // Cannot move %arrayidx_A after SI, as SI is its user.
         EXPECT_FALSE(isSafeToMoveBefore(*SI->getPrevNode(), *SI->getNextNode(),
-                                        DT, &PDT, &DI));
+                                        DT, &PDT, &DI, nullptr));
+        EXPECT_FALSE(isSafeToMoveBefore(*SI->getPrevNode(), *SI->getNextNode(),
+                                        DT, &PDT, nullptr, &AA));
 
         // Cannot move SI before %arrayidx_A, as %arrayidx_A is its operand.
-        EXPECT_FALSE(
-            isSafeToMoveBefore(*SI, *SI->getPrevNode(), DT, &PDT, &DI));
+        EXPECT_FALSE(isSafeToMoveBefore(*SI, *SI->getPrevNode(), DT, &PDT, &DI,
+                                        nullptr));
+        EXPECT_FALSE(isSafeToMoveBefore(*SI, *SI->getPrevNode(), DT, &PDT,
+                                        nullptr, &AA));
 
         // Cannot move LI2 after SI_A6, as there is a flow dependence.
-        EXPECT_FALSE(
-            isSafeToMoveBefore(*LI2, *SI_A6->getNextNode(), DT, &PDT, &DI));
+        EXPECT_FALSE(isSafeToMoveBefore(*LI2, *SI_A6->getNextNode(), DT, &PDT,
+                                        &DI, nullptr));
+        EXPECT_FALSE(isSafeToMoveBefore(*LI2, *SI_A6->getNextNode(), DT, &PDT,
+                                        nullptr, &AA));
 
         // Cannot move SI after LI1, as there is a anti dependence.
-        EXPECT_FALSE(
-            isSafeToMoveBefore(*SI, *LI1->getNextNode(), DT, &PDT, &DI));
+        EXPECT_FALSE(isSafeToMoveBefore(*SI, *LI1->getNextNode(), DT, &PDT, &DI,
+                                        nullptr));
+        EXPECT_FALSE(isSafeToMoveBefore(*SI, *LI1->getNextNode(), DT, &PDT,
+                                        nullptr, &AA));
 
         // Cannot move SI_A5 after SI, as there is a output dependence.
-        EXPECT_FALSE(isSafeToMoveBefore(*SI_A5, *LI1, DT, &PDT, &DI));
+        EXPECT_FALSE(isSafeToMoveBefore(*SI_A5, *LI1, DT, &PDT, &DI, nullptr));
+        EXPECT_FALSE(isSafeToMoveBefore(*SI_A5, *LI1, DT, &PDT, nullptr, &AA));
 
         // Can move LI2 before LI1, as there is only an input dependence.
-        EXPECT_TRUE(isSafeToMoveBefore(*LI2, *LI1, DT, &PDT, &DI));
+        EXPECT_TRUE(isSafeToMoveBefore(*LI2, *LI1, DT, &PDT, &DI, nullptr));
+        EXPECT_TRUE(isSafeToMoveBefore(*LI2, *LI1, DT, &PDT, nullptr, &AA));
       });
 }
 
 TEST(CodeMoverUtils, IsSafeToMoveTest2) {
   LLVMContext C;
 
   std::unique_ptr<Module> M =
       parseIR(C, R"(define void @foo(i1 %cond, i32 %op0, i32 %op1) {
std::unique_ptr<Module> M =
                    %sub = sub i32 %sub_op0, %op1
                    br label %if.end.second
                  if.end.second:
                    ret void
                  })");
 
   run(*M, "foo",
       [&](Function &F, DominatorTree &DT, PostDominatorTree &PDT,
-          DependenceInfo &DI) {
+          DependenceInfo &DI, AAResults &AA) {
         Instruction *AddInst = getInstructionByName(F, "add");
         Instruction *SubInst = getInstructionByName(F, "sub");
 
         // Cannot move as %user uses %add and %sub doesn't dominates %user.
-        EXPECT_FALSE(isSafeToMoveBefore(*AddInst, *SubInst, DT, &PDT, &DI));
+        EXPECT_FALSE(
+            isSafeToMoveBefore(*AddInst, *SubInst, DT, &PDT, &DI, nullptr));
+        EXPECT_FALSE(
+            isSafeToMoveBefore(*AddInst, *SubInst, DT, &PDT, nullptr, &AA));
 
         // Cannot move as %sub_op0 is an operand of %sub and %add doesn't
         // dominates %sub_op0.
-        EXPECT_FALSE(isSafeToMoveBefore(*SubInst, *AddInst, DT, &PDT, &DI));
+        EXPECT_FALSE(
+            isSafeToMoveBefore(*SubInst, *AddInst, DT, &PDT, &DI, nullptr));
+        EXPECT_FALSE(
+            isSafeToMoveBefore(*SubInst, *AddInst, DT, &PDT, nullptr, &AA));
       });
 }
 
 TEST(CodeMoverUtils, IsSafeToMoveTest3) {
   LLVMContext C;
 
   std::unique_ptr<Module> M = parseIR(C, R"(define void @foo(i64 %N) {
                  entry:
                    br label %for.body
                  for.body:
                    %i = phi i64 [ 0, %entry ], [ %inc, %for.latch ]
                    %inc = add nsw i64 %i, 1
                    br label %for.latch
                  for.latch:
                    %cmp = icmp slt i64 %inc, %N
                    br i1 %cmp, label %for.body, label %for.end
                  for.end:
                    ret void
                  })");
 
   run(*M, "foo",
       [&](Function &F, DominatorTree &DT, PostDominatorTree &PDT,
-          DependenceInfo &DI) {
+          DependenceInfo &DI, AAResults &AA) {
         Instruction *IncInst = getInstructionByName(F, "inc");
         Instruction *CmpInst = getInstructionByName(F, "cmp");
 
         // Can move as the incoming block of %inc for %i (%for.latch) dominated
         // by %cmp.
-        EXPECT_TRUE(isSafeToMoveBefore(*IncInst, *CmpInst, DT, &PDT, &DI));
+        EXPECT_TRUE(
+            isSafeToMoveBefore(*IncInst, *CmpInst, DT, &PDT, &DI, nullptr));
+        EXPECT_TRUE(
+            isSafeToMoveBefore(*IncInst, *CmpInst, DT, &PDT, nullptr, &AA));
       });
 }
 
 TEST(CodeMoverUtils, IsSafeToMoveTest4) {
   LLVMContext C;
 
   std::unique_ptr<Module> M =
       parseIR(C, R"(define void @foo(i1 %cond, i32 %op0, i32 %op1) {
std::unique_ptr<Module> M =
                    %sub = sub i32 %sub_op0, %op1
                    br label %if.end.second
                  if.end.second:
                    ret void
                  })");
 
   run(*M, "foo",
       [&](Function &F, DominatorTree &DT, PostDominatorTree &PDT,
-          DependenceInfo &DI) {
+          DependenceInfo &DI, AAResults &AA) {
         Instruction *AddInst = getInstructionByName(F, "add");
         Instruction *SubInst = getInstructionByName(F, "sub");
 
         // Cannot move as %user uses %add and %sub doesn't dominates %user.
-        EXPECT_FALSE(isSafeToMoveBefore(*AddInst, *SubInst, DT, &PDT, &DI));
+        EXPECT_FALSE(
+            isSafeToMoveBefore(*AddInst, *SubInst, DT, &PDT, &DI, nullptr));
+        EXPECT_FALSE(
+            isSafeToMoveBefore(*AddInst, *SubInst, DT, &PDT, nullptr, &AA));
 
         // Cannot move as %sub_op0 is an operand of %sub and %add doesn't
         // dominates %sub_op0.
-        EXPECT_FALSE(isSafeToMoveBefore(*SubInst, *AddInst, DT, &PDT, &DI));
+        EXPECT_FALSE(
+            isSafeToMoveBefore(*SubInst, *AddInst, DT, &PDT, &DI, nullptr));
+        EXPECT_FALSE(
+            isSafeToMoveBefore(*SubInst, *AddInst, DT, &PDT, nullptr, &AA));
       });
 }
 
 TEST(CodeMoverUtils, IsSafeToMoveTest5) {
   LLVMContext C;
 
   std::unique_ptr<Module> M =
       parseIR(C, R"(define void @dependence(i32* noalias %A, i32* noalias %B){
entry:
     %tmp3 = load i32, i32* %A, align 4 ; loadA3 
     %tmp4 = load i32, i32* %B, align 4 ; loadB2
     %tmp5 = load i32, i32* %B, align 4 ; loadB3
     ret void
 })");
 
   run(*M, "dependence",
       [&](Function &F, DominatorTree &DT, PostDominatorTree &PDT,
-          DependenceInfo &DI) {
+          DependenceInfo &DI, AAResults &AA) {
         Instruction *LoadA0 = getInstructionByName(F, "tmp0");
         Instruction *LoadA1 = getInstructionByName(F, "tmp1");
         Instruction *LoadA2 = getInstructionByName(F, "tmp2");
         Instruction *LoadA3 = getInstructionByName(F, "tmp3");
         Instruction *LoadB2 = getInstructionByName(F, "tmp4");
         Instruction *LoadB3 = getInstructionByName(F, "tmp5");
         Instruction *StoreA1 = LoadA0->getPrevNode();
         Instruction *StoreA0 = StoreA1->getPrevNode();
         Instruction *StoreB0 = LoadA0->getNextNode();
         Instruction *StoreB1 = LoadA2->getPrevNode();
         Instruction *StoreA2 = StoreB1->getPrevNode();
 
         // Input forward dependency
-        EXPECT_TRUE(isSafeToMoveBefore(*LoadA2, *LoadB2, DT, &PDT, &DI));
+        EXPECT_TRUE(
+            isSafeToMoveBefore(*LoadA2, *LoadB2, DT, &PDT, &DI, nullptr));
+        EXPECT_TRUE(
+            isSafeToMoveBefore(*LoadA2, *LoadB2, DT, &PDT, nullptr, &AA));
         // Input backward dependency
-        EXPECT_TRUE(isSafeToMoveBefore(*LoadA3, *LoadA2, DT, &PDT, &DI));
+        EXPECT_TRUE(
+            isSafeToMoveBefore(*LoadA3, *LoadA2, DT, &PDT, &DI, nullptr));
+        EXPECT_TRUE(
+            isSafeToMoveBefore(*LoadA3, *LoadA2, DT, &PDT, nullptr, &AA));
 
         // Output forward dependency
-        EXPECT_FALSE(isSafeToMoveBefore(*StoreA0, *LoadA0, DT, &PDT, &DI));
+        EXPECT_FALSE(
+            isSafeToMoveBefore(*StoreA0, *LoadA0, DT, &PDT, &DI, nullptr));
+        EXPECT_FALSE(
+            isSafeToMoveBefore(*StoreA0, *LoadA0, DT, &PDT, nullptr, &AA));
         // Output backward dependency
-        EXPECT_FALSE(isSafeToMoveBefore(*StoreA1, *StoreA0, DT, &PDT, &DI));
+        EXPECT_FALSE(
+            isSafeToMoveBefore(*StoreA1, *StoreA0, DT, &PDT, &DI, nullptr));
+        EXPECT_FALSE(
+            isSafeToMoveBefore(*StoreA1, *StoreA0, DT, &PDT, nullptr, &AA));
 
         // Flow forward dependency
-        EXPECT_FALSE(isSafeToMoveBefore(*StoreA1, *StoreB0, DT, &PDT, &DI));
+        EXPECT_FALSE(
+            isSafeToMoveBefore(*StoreA1, *StoreB0, DT, &PDT, &DI, nullptr));
+        EXPECT_FALSE(
+            isSafeToMoveBefore(*StoreA1, *StoreB0, DT, &PDT, nullptr, &AA));
         // Flow backward dependency
-        EXPECT_FALSE(isSafeToMoveBefore(*LoadA0, *StoreA1, DT, &PDT, &DI));
+        EXPECT_FALSE(
+            isSafeToMoveBefore(*LoadA0, *StoreA1, DT, &PDT, &DI, nullptr));
+        EXPECT_FALSE(
+            isSafeToMoveBefore(*LoadA0, *StoreA1, DT, &PDT, nullptr, &AA));
 
         // Anti forward dependency
-        EXPECT_FALSE(isSafeToMoveBefore(*LoadA1, *StoreB1, DT, &PDT, &DI));
+        EXPECT_FALSE(
+            isSafeToMoveBefore(*LoadA1, *StoreB1, DT, &PDT, &DI, nullptr));
+        EXPECT_FALSE(
+            isSafeToMoveBefore(*LoadA1, *StoreB1, DT, &PDT, nullptr, &AA));
         // Anti backward dependency
-        EXPECT_FALSE(isSafeToMoveBefore(*StoreA2, *LoadA1, DT, &PDT, &DI));
+        EXPECT_FALSE(
+            isSafeToMoveBefore(*StoreA2, *LoadA1, DT, &PDT, &DI, nullptr));
+        EXPECT_FALSE(
+            isSafeToMoveBefore(*StoreA2, *LoadA1, DT, &PDT, nullptr, &AA));
 
         // No input backward dependency
-        EXPECT_TRUE(isSafeToMoveBefore(*LoadB2, *LoadA3, DT, &PDT, &DI));
+        EXPECT_TRUE(
+            isSafeToMoveBefore(*LoadB2, *LoadA3, DT, &PDT, &DI, nullptr));
+        EXPECT_TRUE(
+            isSafeToMoveBefore(*LoadB2, *LoadA3, DT, &PDT, nullptr, &AA));
         // No input forward dependency
-        EXPECT_TRUE(isSafeToMoveBefore(*LoadA3, *LoadB3, DT, &PDT, &DI));
+        EXPECT_TRUE(
+            isSafeToMoveBefore(*LoadA3, *LoadB3, DT, &PDT, &DI, nullptr));
+        EXPECT_TRUE(
+            isSafeToMoveBefore(*LoadA3, *LoadB3, DT, &PDT, nullptr, &AA));
 
         // No Output forward dependency
-        EXPECT_TRUE(isSafeToMoveBefore(*StoreA2, *LoadA2, DT, &PDT, &DI));
+        EXPECT_TRUE(
+            isSafeToMoveBefore(*StoreA2, *LoadA2, DT, &PDT, &DI, nullptr));
+        EXPECT_TRUE(
+            isSafeToMoveBefore(*StoreA2, *LoadA2, DT, &PDT, nullptr, &AA));
         // No Output backward dependency
-        EXPECT_TRUE(isSafeToMoveBefore(*StoreB1, *StoreA2, DT, &PDT, &DI));
+        EXPECT_TRUE(
+            isSafeToMoveBefore(*StoreB1, *StoreA2, DT, &PDT, &DI, nullptr));
+        EXPECT_TRUE(
+            isSafeToMoveBefore(*StoreB1, *StoreA2, DT, &PDT, nullptr, &AA));
 
         // No flow forward dependency
-        EXPECT_TRUE(isSafeToMoveBefore(*StoreB0, *StoreA2, DT, &PDT, &DI));
+        EXPECT_TRUE(
+            isSafeToMoveBefore(*StoreB0, *StoreA2, DT, &PDT, &DI, nullptr));
+        EXPECT_TRUE(
+            isSafeToMoveBefore(*StoreB0, *StoreA2, DT, &PDT, nullptr, &AA));
         // No flow backward dependency
-        EXPECT_TRUE(isSafeToMoveBefore(*LoadA1, *StoreB0, DT, &PDT, &DI));
+        EXPECT_TRUE(
+            isSafeToMoveBefore(*LoadA1, *StoreB0, DT, &PDT, &DI, nullptr));
+        EXPECT_TRUE(
+            isSafeToMoveBefore(*LoadA1, *StoreB0, DT, &PDT, nullptr, &AA));
 
         // No anti backward dependency
-        EXPECT_TRUE(isSafeToMoveBefore(*StoreB0, *LoadA0, DT, &PDT, &DI));
+        EXPECT_TRUE(
+            isSafeToMoveBefore(*StoreB0, *LoadA0, DT, &PDT, &DI, nullptr));
+        EXPECT_TRUE(
+            isSafeToMoveBefore(*StoreB0, *LoadA0, DT, &PDT, nullptr, &AA));
         // No anti forward dependency
-        EXPECT_TRUE(isSafeToMoveBefore(*LoadA0, *LoadA1, DT, &PDT, &DI));
+        EXPECT_TRUE(
+            isSafeToMoveBefore(*LoadA0, *LoadA1, DT, &PDT, &DI, nullptr));
+        EXPECT_TRUE(
+            isSafeToMoveBefore(*LoadA0, *LoadA1, DT, &PDT, nullptr, &AA));
       });
 }
 
 TEST(CodeMoverUtils, IsSafeToMoveTest6) {
   LLVMContext C;
 
   std::unique_ptr<Module> M = parseIR(
       C, R"(define void @dependence(i1 %cond, i32* noalias %A, i32* noalias %B){
bb0:
     bb20:
        br label %bb21
     bb21:
        %tmp5 = load i32, i32* %B, align 4 ; loadB3
        ret void
    })");
   run(*M, "dependence",
       [&](Function &F, DominatorTree &DT, PostDominatorTree &PDT,
-          DependenceInfo &DI) {
+          DependenceInfo &DI, AAResults &AA) {
         BasicBlock *BB1 = getBasicBlockByName(F, "bb1");
         BasicBlock *BB3 = getBasicBlockByName(F, "bb3");
         BasicBlock *BB7 = getBasicBlockByName(F, "bb7");
         BasicBlock *BB11 = getBasicBlockByName(F, "bb11");
         BasicBlock *BB13 = getBasicBlockByName(F, "bb13");
         Instruction *LoadA0 = getInstructionByName(F, "tmp0");
         Instruction *LoadA1 = getInstructionByName(F, "tmp1");
         Instruction *LoadA2 = getInstructionByName(F, "tmp2");
         Instruction *LoadA3 = getInstructionByName(F, "tmp3");
         Instruction *LoadB2 = getInstructionByName(F, "tmp4");
         Instruction *LoadB3 = getInstructionByName(F, "tmp5");
         Instruction &StoreA1 = BB3->front();
         Instruction &StoreA0 = BB1->front();
         Instruction &StoreB0 = BB7->front();
         Instruction &StoreB1 = BB13->front();
         Instruction &StoreA2 = BB11->front();
 
         // Input forward dependency
-        EXPECT_TRUE(isSafeToMoveBefore(*LoadA2, *LoadB2, DT, &PDT, &DI));
+        EXPECT_TRUE(
+            isSafeToMoveBefore(*LoadA2, *LoadB2, DT, &PDT, &DI, nullptr));
+        EXPECT_TRUE(
+            isSafeToMoveBefore(*LoadA2, *LoadB2, DT, &PDT, nullptr, &AA));
         // Input backward dependency
-        EXPECT_TRUE(isSafeToMoveBefore(*LoadA3, *LoadA2, DT, &PDT, &DI));
+        EXPECT_TRUE(
+            isSafeToMoveBefore(*LoadA3, *LoadA2, DT, &PDT, &DI, nullptr));
+        EXPECT_TRUE(
+            isSafeToMoveBefore(*LoadA3, *LoadA2, DT, &PDT, nullptr, &AA));
 
         // Output forward dependency
-        EXPECT_FALSE(isSafeToMoveBefore(StoreA0, *LoadA0, DT, &PDT, &DI));
+        EXPECT_FALSE(
+            isSafeToMoveBefore(StoreA0, *LoadA0, DT, &PDT, &DI, nullptr));
+        EXPECT_FALSE(
+            isSafeToMoveBefore(StoreA0, *LoadA0, DT, &PDT, nullptr, &AA));
         // Output backward dependency
-        EXPECT_FALSE(isSafeToMoveBefore(StoreA1, StoreA0, DT, &PDT, &DI));
+        EXPECT_FALSE(
+            isSafeToMoveBefore(StoreA1, StoreA0, DT, &PDT, &DI, nullptr));
+        EXPECT_FALSE(
+            isSafeToMoveBefore(StoreA1, StoreA0, DT, &PDT, nullptr, &AA));
 
         // Flow forward dependency
-        EXPECT_FALSE(isSafeToMoveBefore(StoreA1, StoreB0, DT, &PDT, &DI));
+        EXPECT_FALSE(
+            isSafeToMoveBefore(StoreA1, StoreB0, DT, &PDT, &DI, nullptr));
+        EXPECT_FALSE(
+            isSafeToMoveBefore(StoreA1, StoreB0, DT, &PDT, nullptr, &AA));
         // Flow backward dependency
-        EXPECT_FALSE(isSafeToMoveBefore(*LoadA0, StoreA1, DT, &PDT, &DI));
+        EXPECT_FALSE(
+            isSafeToMoveBefore(*LoadA0, StoreA1, DT, &PDT, &DI, nullptr));
+        EXPECT_FALSE(
+            isSafeToMoveBefore(*LoadA0, StoreA1, DT, &PDT, nullptr, &AA));
 
         // Anti forward dependency
-        EXPECT_FALSE(isSafeToMoveBefore(*LoadA1, StoreB1, DT, &PDT, &DI));
+        EXPECT_FALSE(
+            isSafeToMoveBefore(*LoadA1, StoreB1, DT, &PDT, &DI, nullptr));
+        EXPECT_FALSE(
+            isSafeToMoveBefore(*LoadA1, StoreB1, DT, &PDT, nullptr, &AA));
         // Anti backward dependency
-        EXPECT_FALSE(isSafeToMoveBefore(StoreA2, *LoadA1, DT, &PDT, &DI));
+        EXPECT_FALSE(
+            isSafeToMoveBefore(StoreA2, *LoadA1, DT, &PDT, &DI, nullptr));
+        EXPECT_FALSE(
+            isSafeToMoveBefore(StoreA2, *LoadA1, DT, &PDT, nullptr, &AA));
 
         // No input backward dependency
-        EXPECT_TRUE(isSafeToMoveBefore(*LoadB2, *LoadA3, DT, &PDT, &DI));
+        EXPECT_TRUE(
+            isSafeToMoveBefore(*LoadB2, *LoadA3, DT, &PDT, &DI, nullptr));
+        EXPECT_TRUE(
+            isSafeToMoveBefore(*LoadB2, *LoadA3, DT, &PDT, nullptr, &AA));
         // No input forward dependency
-        EXPECT_TRUE(isSafeToMoveBefore(*LoadA3, *LoadB3, DT, &PDT, &DI));
+        EXPECT_TRUE(
+            isSafeToMoveBefore(*LoadA3, *LoadB3, DT, &PDT, &DI, nullptr));
+        EXPECT_TRUE(
+            isSafeToMoveBefore(*LoadA3, *LoadB3, DT, &PDT, nullptr, &AA));
 
         // No Output forward dependency
-        EXPECT_TRUE(isSafeToMoveBefore(StoreA2, *LoadA2, DT, &PDT, &DI));
+        EXPECT_TRUE(
+            isSafeToMoveBefore(StoreA2, *LoadA2, DT, &PDT, &DI, nullptr));
+        EXPECT_TRUE(
+            isSafeToMoveBefore(StoreA2, *LoadA2, DT, &PDT, nullptr, &AA));
         // No Output backward dependency
-        EXPECT_TRUE(isSafeToMoveBefore(StoreB1, StoreA2, DT, &PDT, &DI));
+        EXPECT_TRUE(
+            isSafeToMoveBefore(StoreB1, StoreA2, DT, &PDT, &DI, nullptr));
+        EXPECT_TRUE(
+            isSafeToMoveBefore(StoreB1, StoreA2, DT, &PDT, nullptr, &AA));
 
         // No flow forward dependency
-        EXPECT_TRUE(isSafeToMoveBefore(StoreB0, StoreA2, DT, &PDT, &DI));
+        EXPECT_TRUE(
+            isSafeToMoveBefore(StoreB0, StoreA2, DT, &PDT, &DI, nullptr));
+        EXPECT_TRUE(
+            isSafeToMoveBefore(StoreB0, StoreA2, DT, &PDT, nullptr, &AA));
         // No flow backward dependency
-        EXPECT_TRUE(isSafeToMoveBefore(*LoadA1, StoreB0, DT, &PDT, &DI));
+        EXPECT_TRUE(
+            isSafeToMoveBefore(*LoadA1, StoreB0, DT, &PDT, &DI, nullptr));
+        EXPECT_TRUE(
+            isSafeToMoveBefore(*LoadA1, StoreB0, DT, &PDT, nullptr, &AA));
 
         // No anti backward dependency
-        EXPECT_TRUE(isSafeToMoveBefore(StoreB0, *LoadA0, DT, &PDT, &DI));
+        EXPECT_TRUE(
+            isSafeToMoveBefore(StoreB0, *LoadA0, DT, &PDT, &DI, nullptr));
+        EXPECT_TRUE(
+            isSafeToMoveBefore(StoreB0, *LoadA0, DT, &PDT, nullptr, &AA));
         // No anti forward dependency
-        EXPECT_TRUE(isSafeToMoveBefore(*LoadA0, *LoadA1, DT, &PDT, &DI));
+        EXPECT_TRUE(
+            isSafeToMoveBefore(*LoadA0, *LoadA1, DT, &PDT, &DI, nullptr));
+        EXPECT_TRUE(
+            isSafeToMoveBefore(*LoadA0, *LoadA1, DT, &PDT, nullptr, &AA));
       });
 }