[llvm-branch-commits] [llvm] 2e59efa - Revert "base changes"
via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Mon Aug 10 10:27:50 PDT 2020
Author: SharmaRithik
Date: 2020-08-10T22:57:07+05:30
New Revision: 2e59efac833cce636feeaaacfadc7f0e5218e5da
URL: https://github.com/llvm/llvm-project/commit/2e59efac833cce636feeaaacfadc7f0e5218e5da
DIFF: https://github.com/llvm/llvm-project/commit/2e59efac833cce636feeaaacfadc7f0e5218e5da.diff
LOG: Revert "base changes"
This reverts commit 8b679fbdd28129fc31d57c75614b83ee8501b4ab.
Added:
Modified:
llvm/include/llvm/Transforms/Utils/CodeMoverUtils.h
llvm/lib/Transforms/Utils/CodeMoverUtils.cpp
llvm/unittests/Transforms/Utils/CodeMoverUtilsTest.cpp
Removed:
################################################################################
diff --git a/llvm/include/llvm/Transforms/Utils/CodeMoverUtils.h b/llvm/include/llvm/Transforms/Utils/CodeMoverUtils.h
index b313dccdde3b..630f936471f2 100644
--- a/llvm/include/llvm/Transforms/Utils/CodeMoverUtils.h
+++ b/llvm/include/llvm/Transforms/Utils/CodeMoverUtils.h
@@ -16,7 +16,6 @@
namespace llvm {
-class AAResults;
class BasicBlock;
class DependenceInfo;
class DominatorTree;
@@ -41,14 +40,14 @@ bool isControlFlowEquivalent(const BasicBlock &BB0, const BasicBlock &BB1,
bool isSafeToMoveBefore(Instruction &I, Instruction &InsertPoint,
DominatorTree &DT,
const PostDominatorTree *PDT = nullptr,
- DependenceInfo *DI = nullptr, AAResults *AA = nullptr);
+ DependenceInfo *DI = 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, AAResults *AA = nullptr);
+ DependenceInfo *DI = nullptr);
/// Move instructions, in an order-preserving manner, from \p FromBB to the
/// beginning of \p ToBB when proven safe.
diff --git a/llvm/lib/Transforms/Utils/CodeMoverUtils.cpp b/llvm/lib/Transforms/Utils/CodeMoverUtils.cpp
index 1367baf8e137..08047dc0f96e 100644
--- a/llvm/lib/Transforms/Utils/CodeMoverUtils.cpp
+++ b/llvm/lib/Transforms/Utils/CodeMoverUtils.cpp
@@ -14,7 +14,6 @@
#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"
@@ -227,82 +226,6 @@ bool ControlConditions::isInverse(const Value &V1, const Value &V2) {
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;
-
- SmallVector<MemoryLocation, 8> MemLocs;
- if (CallInst *CI = dyn_cast<CallInst>(&I)) {
- for (Value *Op : CI->arg_operands())
- if (Op->getType()->isPointerTy()) {
- MemLocs.push_back(
- MemoryLocation(Op, LocationSize::unknown(), AAMDNodes()));
- }
- } else {
- MemLocs.push_back(MemoryLocation::get(&I));
- }
- for (MemoryLocation MemLoc : MemLocs) {
- return llvm::none_of(InstsToCheck, [&AA, &I, &MemLoc](Instruction *Inst) {
- if (!Inst->mayReadOrWriteMemory())
- return false;
- /// Get memory location for CallInst can be none and it won't be used for
- /// CallInst.
- auto DestMemLoc = MemoryLocation::get(Inst);
- ModRefInfo Result, DestResult;
- 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);
- if (AA.isNoAlias(MemLoc, DestMemLoc)) {
- auto DestMemLoc = MemoryLocation::get(Inst);
- if (MemLoc.Size.hasValue() && DestMemLoc.Size.hasValue() &&
- AA.isNoAlias(MemLoc, DestMemLoc))
- return false;
- }
- }
- // RAR dependency is safe
- if (isRefSet(Result) && isRefSet(DestResult))
- return false;
- return true;
- });
- }
- 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) {
@@ -386,9 +309,9 @@ collectInstructionsInBetween(Instruction &StartInst, const Instruction &EndInst,
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))
+ DependenceInfo *DI) {
+ // Skip tests when we don't have PDT or DI
+ if (!PDT || !DI)
return false;
// Cannot move itself before itself.
@@ -436,6 +359,7 @@ bool llvm::isSafeToMoveBefore(Instruction &I, Instruction &InsertPoint,
[](Instruction *I) {
if (I->mayThrow())
return true;
+
const CallBase *CB = dyn_cast<CallBase>(I);
if (!CB)
return false;
@@ -443,6 +367,7 @@ bool llvm::isSafeToMoveBefore(Instruction &I, Instruction &InsertPoint,
return true;
if (!CB->hasFnAttr(Attribute::NoSync))
return true;
+
return false;
})) {
return reportInvalidCandidate(I, MayThrowException);
@@ -450,7 +375,15 @@ bool llvm::isSafeToMoveBefore(Instruction &I, Instruction &InsertPoint,
// Check if I has any output/flow/anti dependences with instructions from \p
// StartInst to \p EndInst.
- if (!isDependenceSafe(I, DI, AA, InstsToCheck))
+ 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;
+ }))
return reportInvalidCandidate(I, HasDependences);
return true;
@@ -458,12 +391,12 @@ bool llvm::isSafeToMoveBefore(Instruction &I, Instruction &InsertPoint,
bool llvm::isSafeToMoveBefore(BasicBlock &BB, Instruction &InsertPoint,
DominatorTree &DT, const PostDominatorTree *PDT,
- DependenceInfo *DI, AAResults *AA) {
+ DependenceInfo *DI) {
return llvm::all_of(BB, [&](Instruction &I) {
if (BB.getTerminator() == &I)
return true;
- return isSafeToMoveBefore(I, InsertPoint, DT, PDT, DI, AA);
+ return isSafeToMoveBefore(I, InsertPoint, DT, PDT, DI);
});
}
diff --git a/llvm/unittests/Transforms/Utils/CodeMoverUtilsTest.cpp b/llvm/unittests/Transforms/Utils/CodeMoverUtilsTest.cpp
index cb5bbd5ba3ae..c7e63d4a38fc 100644
--- a/llvm/unittests/Transforms/Utils/CodeMoverUtilsTest.cpp
+++ b/llvm/unittests/Transforms/Utils/CodeMoverUtilsTest.cpp
@@ -9,12 +9,10 @@
#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"
@@ -31,25 +29,21 @@ static std::unique_ptr<Module> parseIR(LLVMContext &C, const char *IR) {
return Mod;
}
-static void
-run(Module &M, StringRef FuncName,
- function_ref<void(Function &F, DominatorTree &DT, PostDominatorTree &PDT,
- DependenceInfo &DI, AAResults &AA)>
- Test) {
+static void run(Module &M, StringRef FuncName,
+ function_ref<void(Function &F, DominatorTree &DT,
+ PostDominatorTree &PDT, DependenceInfo &DI)>
+ Test) {
auto *F = M.getFunction(FuncName);
DominatorTree DT(*F);
PostDominatorTree PDT(*F);
TargetLibraryInfoImpl TLII;
TargetLibraryInfo TLI(TLII);
AssumptionCache AC(*F);
- AAResults AA(TLI);
- DataLayout DL("");
- BasicAAResult BAA(DL, *F, TLI, AC, &DT);
- AA.addAAResult(BAA);
+ AliasAnalysis AA(TLI);
LoopInfo LI(DT);
ScalarEvolution SE(*F, TLI, AC, DT, LI);
DependenceInfo DI(F, &AA, &SE, &LI);
- Test(*F, DT, PDT, DI, AA);
+ Test(*F, DT, PDT, DI);
}
static BasicBlock *getBasicBlockByName(Function &F, StringRef Name) {
@@ -100,7 +94,7 @@ TEST(CodeMoverUtils, IsControlFlowEquivalentSimpleTest) {
})");
run(*M, "foo",
[&](Function &F, DominatorTree &DT, PostDominatorTree &PDT,
- DependenceInfo &DI, AAResults &AA) {
+ DependenceInfo &DI) {
BasicBlock *FirstIfBody = getBasicBlockByName(F, "if.first");
EXPECT_TRUE(
isControlFlowEquivalent(*FirstIfBody, *FirstIfBody, DT, PDT));
@@ -191,7 +185,7 @@ TEST(CodeMoverUtils, IsControlFlowEquivalentOppositeCondTest) {
})");
run(*M, "foo",
[&](Function &F, DominatorTree &DT, PostDominatorTree &PDT,
- DependenceInfo &DI, AAResults &AA) {
+ DependenceInfo &DI) {
BasicBlock *FirstIfBody = getBasicBlockByName(F, "if.first");
BasicBlock *SecondIfBody = getBasicBlockByName(F, "if.second");
BasicBlock *ThirdIfBody = getBasicBlockByName(F, "if.third");
@@ -251,7 +245,7 @@ TEST(CodeMoverUtils, IsControlFlowEquivalentCondNestTest) {
})");
run(*M, "foo",
[&](Function &F, DominatorTree &DT, PostDominatorTree &PDT,
- DependenceInfo &DI, AAResults &AA) {
+ DependenceInfo &DI) {
BasicBlock *FirstOuterIfBody = getBasicBlockByName(F, "if.outer.first");
BasicBlock *FirstInnerIfBody = getBasicBlockByName(F, "if.inner.first");
BasicBlock *SecondOuterIfBody =
@@ -321,7 +315,7 @@ TEST(CodeMoverUtils, IsControlFlowEquivalentImbalanceTest) {
})");
run(*M, "foo",
[&](Function &F, DominatorTree &DT, PostDominatorTree &PDT,
- DependenceInfo &DI, AAResults &AA) {
+ DependenceInfo &DI) {
BasicBlock *FirstIfBody = getBasicBlockByName(F, "if.inner.first");
BasicBlock *SecondIfBody = getBasicBlockByName(F, "if.inner.second");
EXPECT_FALSE(
@@ -375,7 +369,7 @@ TEST(CodeMoverUtils, IsControlFlowEquivalentPointerTest) {
})");
run(*M, "foo",
[&](Function &F, DominatorTree &DT, PostDominatorTree &PDT,
- DependenceInfo &DI, AAResults &AA) {
+ DependenceInfo &DI) {
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
@@ -425,7 +419,7 @@ TEST(CodeMoverUtils, IsControlFlowEquivalentNotPostdomTest) {
})");
run(*M, "foo",
[&](Function &F, DominatorTree &DT, PostDominatorTree &PDT,
- DependenceInfo &DI, AAResults &AA) {
+ DependenceInfo &DI) {
BasicBlock &Idom = F.front();
assert(Idom.getName() == "idom" && "Expecting BasicBlock idom");
BasicBlock &BB = F.back();
@@ -489,7 +483,7 @@ TEST(CodeMoverUtils, IsSafeToMoveTest1) {
run(*M, "foo",
[&](Function &F, DominatorTree &DT, PostDominatorTree &PDT,
- DependenceInfo &DI, AAResults &AA) {
+ DependenceInfo &DI) {
BasicBlock *Entry = getBasicBlockByName(F, "entry");
Instruction *CI_safecall = Entry->front().getNextNode();
assert(isa<CallInst>(CI_safecall) &&
@@ -512,76 +506,49 @@ TEST(CodeMoverUtils, IsSafeToMoveTest1) {
// must return.
EXPECT_TRUE(isSafeToMoveBefore(*CI_safecall->getPrevNode(),
*CI_safecall->getNextNode(), DT, &PDT,
- &DI, nullptr));
- EXPECT_TRUE(isSafeToMoveBefore(*CI_safecall->getPrevNode(),
- *CI_safecall->getNextNode(), DT, &PDT,
- nullptr, &AA));
+ &DI));
// Cannot move CI_unsafecall, as it may throw.
EXPECT_FALSE(isSafeToMoveBefore(*CI_unsafecall->getNextNode(),
- *CI_unsafecall, DT, &PDT, &DI,
- nullptr));
- EXPECT_FALSE(isSafeToMoveBefore(*CI_unsafecall->getNextNode(),
- *CI_unsafecall, DT, &PDT, nullptr,
- &AA));
+ *CI_unsafecall, DT, &PDT, &DI));
// Moving instruction to non control flow equivalent places are not
// supported.
- EXPECT_FALSE(isSafeToMoveBefore(*SI_A5, *Entry->getTerminator(), DT,
- &PDT, &DI, nullptr));
- EXPECT_FALSE(isSafeToMoveBefore(*SI_A5, *Entry->getTerminator(), DT,
- &PDT, nullptr, &AA));
+ EXPECT_FALSE(
+ isSafeToMoveBefore(*SI_A5, *Entry->getTerminator(), DT, &PDT, &DI));
+
// Moving PHINode is not supported.
EXPECT_FALSE(isSafeToMoveBefore(PN, *PN.getNextNode()->getNextNode(),
- DT, &PDT, &DI, nullptr));
- EXPECT_FALSE(isSafeToMoveBefore(PN, *PN.getNextNode()->getNextNode(),
- DT, &PDT, nullptr, &AA));
+ DT, &PDT, &DI));
// Cannot move non-PHINode before PHINode.
- EXPECT_FALSE(
- isSafeToMoveBefore(*PN.getNextNode(), PN, DT, &PDT, &DI, nullptr));
- EXPECT_FALSE(
- isSafeToMoveBefore(*PN.getNextNode(), PN, DT, &PDT, nullptr, &AA));
+ EXPECT_FALSE(isSafeToMoveBefore(*PN.getNextNode(), PN, DT, &PDT, &DI));
// Moving Terminator is not supported.
EXPECT_FALSE(isSafeToMoveBefore(*Entry->getTerminator(),
- *PN.getNextNode(), DT, &PDT, &DI,
- nullptr));
- EXPECT_FALSE(isSafeToMoveBefore(*Entry->getTerminator(),
- *PN.getNextNode(), DT, &PDT, nullptr,
- &AA));
+ *PN.getNextNode(), DT, &PDT, &DI));
// Cannot move %arrayidx_A after SI, as SI is its user.
EXPECT_FALSE(isSafeToMoveBefore(*SI->getPrevNode(), *SI->getNextNode(),
- DT, &PDT, &DI, nullptr));
- EXPECT_FALSE(isSafeToMoveBefore(*SI->getPrevNode(), *SI->getNextNode(),
- DT, &PDT, nullptr, &AA));
+ DT, &PDT, &DI));
// Cannot move SI before %arrayidx_A, as %arrayidx_A is its operand.
- EXPECT_FALSE(isSafeToMoveBefore(*SI, *SI->getPrevNode(), DT, &PDT, &DI,
- nullptr));
- EXPECT_FALSE(isSafeToMoveBefore(*SI, *SI->getPrevNode(), DT, &PDT,
- nullptr, &AA));
+ EXPECT_FALSE(
+ isSafeToMoveBefore(*SI, *SI->getPrevNode(), DT, &PDT, &DI));
// Cannot move LI2 after SI_A6, as there is a flow dependence.
- EXPECT_FALSE(isSafeToMoveBefore(*LI2, *SI_A6->getNextNode(), DT, &PDT,
- &DI, nullptr));
- EXPECT_FALSE(isSafeToMoveBefore(*LI2, *SI_A6->getNextNode(), DT, &PDT,
- nullptr, &AA));
+ EXPECT_FALSE(
+ isSafeToMoveBefore(*LI2, *SI_A6->getNextNode(), DT, &PDT, &DI));
// Cannot move SI after LI1, as there is a anti dependence.
- EXPECT_FALSE(isSafeToMoveBefore(*SI, *LI1->getNextNode(), DT, &PDT, &DI,
- nullptr));
- EXPECT_FALSE(isSafeToMoveBefore(*SI, *LI1->getNextNode(), DT, &PDT,
- nullptr, &AA));
+ EXPECT_FALSE(
+ isSafeToMoveBefore(*SI, *LI1->getNextNode(), DT, &PDT, &DI));
// Cannot move SI_A5 after SI, as there is a output dependence.
- EXPECT_FALSE(isSafeToMoveBefore(*SI_A5, *LI1, DT, &PDT, &DI, nullptr));
- EXPECT_FALSE(isSafeToMoveBefore(*SI_A5, *LI1, DT, &PDT, nullptr, &AA));
+ EXPECT_FALSE(isSafeToMoveBefore(*SI_A5, *LI1, DT, &PDT, &DI));
// Can move LI2 before LI1, as there is only an input dependence.
- EXPECT_TRUE(isSafeToMoveBefore(*LI2, *LI1, DT, &PDT, &DI, nullptr));
- EXPECT_TRUE(isSafeToMoveBefore(*LI2, *LI1, DT, &PDT, nullptr, &AA));
+ EXPECT_TRUE(isSafeToMoveBefore(*LI2, *LI1, DT, &PDT, &DI));
});
}
@@ -608,22 +575,16 @@ TEST(CodeMoverUtils, IsSafeToMoveTest2) {
run(*M, "foo",
[&](Function &F, DominatorTree &DT, PostDominatorTree &PDT,
- DependenceInfo &DI, AAResults &AA) {
+ DependenceInfo &DI) {
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, nullptr));
- EXPECT_FALSE(
- isSafeToMoveBefore(*AddInst, *SubInst, DT, &PDT, nullptr, &AA));
+ EXPECT_FALSE(isSafeToMoveBefore(*AddInst, *SubInst, DT, &PDT, &DI));
// 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, nullptr));
- EXPECT_FALSE(
- isSafeToMoveBefore(*SubInst, *AddInst, DT, &PDT, nullptr, &AA));
+ EXPECT_FALSE(isSafeToMoveBefore(*SubInst, *AddInst, DT, &PDT, &DI));
});
}
@@ -646,16 +607,13 @@ TEST(CodeMoverUtils, IsSafeToMoveTest3) {
run(*M, "foo",
[&](Function &F, DominatorTree &DT, PostDominatorTree &PDT,
- DependenceInfo &DI, AAResults &AA) {
+ DependenceInfo &DI) {
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, nullptr));
- EXPECT_TRUE(
- isSafeToMoveBefore(*IncInst, *CmpInst, DT, &PDT, nullptr, &AA));
+ EXPECT_TRUE(isSafeToMoveBefore(*IncInst, *CmpInst, DT, &PDT, &DI));
});
}
@@ -682,22 +640,16 @@ TEST(CodeMoverUtils, IsSafeToMoveTest4) {
run(*M, "foo",
[&](Function &F, DominatorTree &DT, PostDominatorTree &PDT,
- DependenceInfo &DI, AAResults &AA) {
+ DependenceInfo &DI) {
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, nullptr));
- EXPECT_FALSE(
- isSafeToMoveBefore(*AddInst, *SubInst, DT, &PDT, nullptr, &AA));
+ EXPECT_FALSE(isSafeToMoveBefore(*AddInst, *SubInst, DT, &PDT, &DI));
// 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, nullptr));
- EXPECT_FALSE(
- isSafeToMoveBefore(*SubInst, *AddInst, DT, &PDT, nullptr, &AA));
+ EXPECT_FALSE(isSafeToMoveBefore(*SubInst, *AddInst, DT, &PDT, &DI));
});
}
@@ -723,7 +675,7 @@ TEST(CodeMoverUtils, IsSafeToMoveTest5) {
run(*M, "dependence",
[&](Function &F, DominatorTree &DT, PostDominatorTree &PDT,
- DependenceInfo &DI, AAResults &AA) {
+ DependenceInfo &DI) {
Instruction *LoadA0 = getInstructionByName(F, "tmp0");
Instruction *LoadA1 = getInstructionByName(F, "tmp1");
Instruction *LoadA2 = getInstructionByName(F, "tmp2");
@@ -737,92 +689,44 @@ TEST(CodeMoverUtils, IsSafeToMoveTest5) {
Instruction *StoreA2 = StoreB1->getPrevNode();
// Input forward dependency
- EXPECT_TRUE(
- isSafeToMoveBefore(*LoadA2, *LoadB2, DT, &PDT, &DI, nullptr));
- EXPECT_TRUE(
- isSafeToMoveBefore(*LoadA2, *LoadB2, DT, &PDT, nullptr, &AA));
+ EXPECT_TRUE(isSafeToMoveBefore(*LoadA2, *LoadB2, DT, &PDT, &DI));
// Input backward dependency
- EXPECT_TRUE(
- isSafeToMoveBefore(*LoadA3, *LoadA2, DT, &PDT, &DI, nullptr));
- EXPECT_TRUE(
- isSafeToMoveBefore(*LoadA3, *LoadA2, DT, &PDT, nullptr, &AA));
+ EXPECT_TRUE(isSafeToMoveBefore(*LoadA3, *LoadA2, DT, &PDT, &DI));
// Output forward dependency
- EXPECT_FALSE(
- isSafeToMoveBefore(*StoreA0, *LoadA0, DT, &PDT, &DI, nullptr));
- EXPECT_FALSE(
- isSafeToMoveBefore(*StoreA0, *LoadA0, DT, &PDT, nullptr, &AA));
+ EXPECT_FALSE(isSafeToMoveBefore(*StoreA0, *LoadA0, DT, &PDT, &DI));
// Output backward dependency
- EXPECT_FALSE(
- isSafeToMoveBefore(*StoreA1, *StoreA0, DT, &PDT, &DI, nullptr));
- EXPECT_FALSE(
- isSafeToMoveBefore(*StoreA1, *StoreA0, DT, &PDT, nullptr, &AA));
+ EXPECT_FALSE(isSafeToMoveBefore(*StoreA1, *StoreA0, DT, &PDT, &DI));
// Flow forward dependency
- EXPECT_FALSE(
- isSafeToMoveBefore(*StoreA1, *StoreB0, DT, &PDT, &DI, nullptr));
- EXPECT_FALSE(
- isSafeToMoveBefore(*StoreA1, *StoreB0, DT, &PDT, nullptr, &AA));
+ EXPECT_FALSE(isSafeToMoveBefore(*StoreA1, *StoreB0, DT, &PDT, &DI));
// Flow backward dependency
- EXPECT_FALSE(
- isSafeToMoveBefore(*LoadA0, *StoreA1, DT, &PDT, &DI, nullptr));
- EXPECT_FALSE(
- isSafeToMoveBefore(*LoadA0, *StoreA1, DT, &PDT, nullptr, &AA));
+ EXPECT_FALSE(isSafeToMoveBefore(*LoadA0, *StoreA1, DT, &PDT, &DI));
// Anti forward dependency
- EXPECT_FALSE(
- isSafeToMoveBefore(*LoadA1, *StoreB1, DT, &PDT, &DI, nullptr));
- EXPECT_FALSE(
- isSafeToMoveBefore(*LoadA1, *StoreB1, DT, &PDT, nullptr, &AA));
+ EXPECT_FALSE(isSafeToMoveBefore(*LoadA1, *StoreB1, DT, &PDT, &DI));
// Anti backward dependency
- EXPECT_FALSE(
- isSafeToMoveBefore(*StoreA2, *LoadA1, DT, &PDT, &DI, nullptr));
- EXPECT_FALSE(
- isSafeToMoveBefore(*StoreA2, *LoadA1, DT, &PDT, nullptr, &AA));
+ EXPECT_FALSE(isSafeToMoveBefore(*StoreA2, *LoadA1, DT, &PDT, &DI));
// No input backward dependency
- EXPECT_TRUE(
- isSafeToMoveBefore(*LoadB2, *LoadA3, DT, &PDT, &DI, nullptr));
- EXPECT_TRUE(
- isSafeToMoveBefore(*LoadB2, *LoadA3, DT, &PDT, nullptr, &AA));
+ EXPECT_TRUE(isSafeToMoveBefore(*LoadB2, *LoadA3, DT, &PDT, &DI));
// No input forward dependency
- EXPECT_TRUE(
- isSafeToMoveBefore(*LoadA3, *LoadB3, DT, &PDT, &DI, nullptr));
- EXPECT_TRUE(
- isSafeToMoveBefore(*LoadA3, *LoadB3, DT, &PDT, nullptr, &AA));
+ EXPECT_TRUE(isSafeToMoveBefore(*LoadA3, *LoadB3, DT, &PDT, &DI));
// No Output forward dependency
- EXPECT_TRUE(
- isSafeToMoveBefore(*StoreA2, *LoadA2, DT, &PDT, &DI, nullptr));
- EXPECT_TRUE(
- isSafeToMoveBefore(*StoreA2, *LoadA2, DT, &PDT, nullptr, &AA));
+ EXPECT_TRUE(isSafeToMoveBefore(*StoreA2, *LoadA2, DT, &PDT, &DI));
// No Output backward dependency
- EXPECT_TRUE(
- isSafeToMoveBefore(*StoreB1, *StoreA2, DT, &PDT, &DI, nullptr));
- EXPECT_TRUE(
- isSafeToMoveBefore(*StoreB1, *StoreA2, DT, &PDT, nullptr, &AA));
+ EXPECT_TRUE(isSafeToMoveBefore(*StoreB1, *StoreA2, DT, &PDT, &DI));
// No flow forward dependency
- EXPECT_TRUE(
- isSafeToMoveBefore(*StoreB0, *StoreA2, DT, &PDT, &DI, nullptr));
- EXPECT_TRUE(
- isSafeToMoveBefore(*StoreB0, *StoreA2, DT, &PDT, nullptr, &AA));
+ EXPECT_TRUE(isSafeToMoveBefore(*StoreB0, *StoreA2, DT, &PDT, &DI));
// No flow backward dependency
- EXPECT_TRUE(
- isSafeToMoveBefore(*LoadA1, *StoreB0, DT, &PDT, &DI, nullptr));
- EXPECT_TRUE(
- isSafeToMoveBefore(*LoadA1, *StoreB0, DT, &PDT, nullptr, &AA));
+ EXPECT_TRUE(isSafeToMoveBefore(*LoadA1, *StoreB0, DT, &PDT, &DI));
// No anti backward dependency
- EXPECT_TRUE(
- isSafeToMoveBefore(*StoreB0, *LoadA0, DT, &PDT, &DI, nullptr));
- EXPECT_TRUE(
- isSafeToMoveBefore(*StoreB0, *LoadA0, DT, &PDT, nullptr, &AA));
+ EXPECT_TRUE(isSafeToMoveBefore(*StoreB0, *LoadA0, DT, &PDT, &DI));
// No anti forward dependency
- EXPECT_TRUE(
- isSafeToMoveBefore(*LoadA0, *LoadA1, DT, &PDT, &DI, nullptr));
- EXPECT_TRUE(
- isSafeToMoveBefore(*LoadA0, *LoadA1, DT, &PDT, nullptr, &AA));
+ EXPECT_TRUE(isSafeToMoveBefore(*LoadA0, *LoadA1, DT, &PDT, &DI));
});
}
@@ -891,7 +795,7 @@ TEST(CodeMoverUtils, IsSafeToMoveTest6) {
})");
run(*M, "dependence",
[&](Function &F, DominatorTree &DT, PostDominatorTree &PDT,
- DependenceInfo &DI, AAResults &AA) {
+ DependenceInfo &DI) {
BasicBlock *BB1 = getBasicBlockByName(F, "bb1");
BasicBlock *BB3 = getBasicBlockByName(F, "bb3");
BasicBlock *BB7 = getBasicBlockByName(F, "bb7");
@@ -910,91 +814,43 @@ TEST(CodeMoverUtils, IsSafeToMoveTest6) {
Instruction &StoreA2 = BB11->front();
// Input forward dependency
- EXPECT_TRUE(
- isSafeToMoveBefore(*LoadA2, *LoadB2, DT, &PDT, &DI, nullptr));
- EXPECT_TRUE(
- isSafeToMoveBefore(*LoadA2, *LoadB2, DT, &PDT, nullptr, &AA));
+ EXPECT_TRUE(isSafeToMoveBefore(*LoadA2, *LoadB2, DT, &PDT, &DI));
// Input backward dependency
- EXPECT_TRUE(
- isSafeToMoveBefore(*LoadA3, *LoadA2, DT, &PDT, &DI, nullptr));
- EXPECT_TRUE(
- isSafeToMoveBefore(*LoadA3, *LoadA2, DT, &PDT, nullptr, &AA));
+ EXPECT_TRUE(isSafeToMoveBefore(*LoadA3, *LoadA2, DT, &PDT, &DI));
// Output forward dependency
- EXPECT_FALSE(
- isSafeToMoveBefore(StoreA0, *LoadA0, DT, &PDT, &DI, nullptr));
- EXPECT_FALSE(
- isSafeToMoveBefore(StoreA0, *LoadA0, DT, &PDT, nullptr, &AA));
+ EXPECT_FALSE(isSafeToMoveBefore(StoreA0, *LoadA0, DT, &PDT, &DI));
// Output backward dependency
- EXPECT_FALSE(
- isSafeToMoveBefore(StoreA1, StoreA0, DT, &PDT, &DI, nullptr));
- EXPECT_FALSE(
- isSafeToMoveBefore(StoreA1, StoreA0, DT, &PDT, nullptr, &AA));
+ EXPECT_FALSE(isSafeToMoveBefore(StoreA1, StoreA0, DT, &PDT, &DI));
// Flow forward dependency
- EXPECT_FALSE(
- isSafeToMoveBefore(StoreA1, StoreB0, DT, &PDT, &DI, nullptr));
- EXPECT_FALSE(
- isSafeToMoveBefore(StoreA1, StoreB0, DT, &PDT, nullptr, &AA));
+ EXPECT_FALSE(isSafeToMoveBefore(StoreA1, StoreB0, DT, &PDT, &DI));
// Flow backward dependency
- EXPECT_FALSE(
- isSafeToMoveBefore(*LoadA0, StoreA1, DT, &PDT, &DI, nullptr));
- EXPECT_FALSE(
- isSafeToMoveBefore(*LoadA0, StoreA1, DT, &PDT, nullptr, &AA));
+ EXPECT_FALSE(isSafeToMoveBefore(*LoadA0, StoreA1, DT, &PDT, &DI));
// Anti forward dependency
- EXPECT_FALSE(
- isSafeToMoveBefore(*LoadA1, StoreB1, DT, &PDT, &DI, nullptr));
- EXPECT_FALSE(
- isSafeToMoveBefore(*LoadA1, StoreB1, DT, &PDT, nullptr, &AA));
+ EXPECT_FALSE(isSafeToMoveBefore(*LoadA1, StoreB1, DT, &PDT, &DI));
// Anti backward dependency
- EXPECT_FALSE(
- isSafeToMoveBefore(StoreA2, *LoadA1, DT, &PDT, &DI, nullptr));
- EXPECT_FALSE(
- isSafeToMoveBefore(StoreA2, *LoadA1, DT, &PDT, nullptr, &AA));
+ EXPECT_FALSE(isSafeToMoveBefore(StoreA2, *LoadA1, DT, &PDT, &DI));
// No input backward dependency
- EXPECT_TRUE(
- isSafeToMoveBefore(*LoadB2, *LoadA3, DT, &PDT, &DI, nullptr));
- EXPECT_TRUE(
- isSafeToMoveBefore(*LoadB2, *LoadA3, DT, &PDT, nullptr, &AA));
+ EXPECT_TRUE(isSafeToMoveBefore(*LoadB2, *LoadA3, DT, &PDT, &DI));
// No input forward dependency
- EXPECT_TRUE(
- isSafeToMoveBefore(*LoadA3, *LoadB3, DT, &PDT, &DI, nullptr));
- EXPECT_TRUE(
- isSafeToMoveBefore(*LoadA3, *LoadB3, DT, &PDT, nullptr, &AA));
+ EXPECT_TRUE(isSafeToMoveBefore(*LoadA3, *LoadB3, DT, &PDT, &DI));
// No Output forward dependency
- EXPECT_TRUE(
- isSafeToMoveBefore(StoreA2, *LoadA2, DT, &PDT, &DI, nullptr));
- EXPECT_TRUE(
- isSafeToMoveBefore(StoreA2, *LoadA2, DT, &PDT, nullptr, &AA));
+ EXPECT_TRUE(isSafeToMoveBefore(StoreA2, *LoadA2, DT, &PDT, &DI));
// No Output backward dependency
- EXPECT_TRUE(
- isSafeToMoveBefore(StoreB1, StoreA2, DT, &PDT, &DI, nullptr));
- EXPECT_TRUE(
- isSafeToMoveBefore(StoreB1, StoreA2, DT, &PDT, nullptr, &AA));
+ EXPECT_TRUE(isSafeToMoveBefore(StoreB1, StoreA2, DT, &PDT, &DI));
// No flow forward dependency
- EXPECT_TRUE(
- isSafeToMoveBefore(StoreB0, StoreA2, DT, &PDT, &DI, nullptr));
- EXPECT_TRUE(
- isSafeToMoveBefore(StoreB0, StoreA2, DT, &PDT, nullptr, &AA));
+ EXPECT_TRUE(isSafeToMoveBefore(StoreB0, StoreA2, DT, &PDT, &DI));
// No flow backward dependency
- EXPECT_TRUE(
- isSafeToMoveBefore(*LoadA1, StoreB0, DT, &PDT, &DI, nullptr));
- EXPECT_TRUE(
- isSafeToMoveBefore(*LoadA1, StoreB0, DT, &PDT, nullptr, &AA));
+ EXPECT_TRUE(isSafeToMoveBefore(*LoadA1, StoreB0, DT, &PDT, &DI));
// No anti backward dependency
- EXPECT_TRUE(
- isSafeToMoveBefore(StoreB0, *LoadA0, DT, &PDT, &DI, nullptr));
- EXPECT_TRUE(
- isSafeToMoveBefore(StoreB0, *LoadA0, DT, &PDT, nullptr, &AA));
+ EXPECT_TRUE(isSafeToMoveBefore(StoreB0, *LoadA0, DT, &PDT, &DI));
// No anti forward dependency
- EXPECT_TRUE(
- isSafeToMoveBefore(*LoadA0, *LoadA1, DT, &PDT, &DI, nullptr));
- EXPECT_TRUE(
- isSafeToMoveBefore(*LoadA0, *LoadA1, DT, &PDT, nullptr, &AA));
+ EXPECT_TRUE(isSafeToMoveBefore(*LoadA0, *LoadA1, DT, &PDT, &DI));
});
}
More information about the llvm-branch-commits
mailing list