[llvm] r313695 - [LoopInfo] Make LoopBase and Loop destructors non-public
Sanjoy Das via llvm-commits
llvm-commits at lists.llvm.org
Tue Sep 19 16:19:00 PDT 2017
Author: sanjoy
Date: Tue Sep 19 16:19:00 2017
New Revision: 313695
URL: http://llvm.org/viewvc/llvm-project?rev=313695&view=rev
Log:
[LoopInfo] Make LoopBase and Loop destructors non-public
Summary:
See comment for why I think this is a good idea.
This change also:
- Removes an SCEV test case. The SCEV test was not testing anything useful (most of it was `#if 0` ed out) and it would need to be updated to deal with a private ~Loop::Loop.
- Updates the loop pass manager test case to deal with a private ~Loop::Loop.
- Renames markAsRemoved to markAsErased to contrast with removeLoop, via the usual remove vs. erase idiom we already have for instructions and basic blocks.
Reviewers: chandlerc
Subscribers: mehdi_amini, mcrosier, llvm-commits
Differential Revision: https://reviews.llvm.org/D37996
Modified:
llvm/trunk/include/llvm/Analysis/LoopInfo.h
llvm/trunk/lib/Analysis/LoopInfo.cpp
llvm/trunk/lib/Transforms/IPO/LoopExtractor.cpp
llvm/trunk/lib/Transforms/Scalar/LoopDeletion.cpp
llvm/trunk/lib/Transforms/Utils/LoopUnroll.cpp
llvm/trunk/unittests/Analysis/ScalarEvolutionTest.cpp
llvm/trunk/unittests/Transforms/Scalar/LoopPassManagerTest.cpp
Modified: llvm/trunk/include/llvm/Analysis/LoopInfo.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Analysis/LoopInfo.h?rev=313695&r1=313694&r2=313695&view=diff
==============================================================================
--- llvm/trunk/include/llvm/Analysis/LoopInfo.h (original)
+++ llvm/trunk/include/llvm/Analysis/LoopInfo.h Tue Sep 19 16:19:00 2017
@@ -85,10 +85,6 @@ class LoopBase {
public:
/// This creates an empty loop.
LoopBase() : ParentLoop(nullptr) {}
- ~LoopBase() {
- for (size_t i = 0, e = SubLoops.size(); i != e; ++i)
- delete SubLoops[i];
- }
/// Return the nesting level of this loop. An outer-most loop has depth 1,
/// for consistency with loop depth values used for basic blocks, where depth
@@ -343,6 +339,20 @@ protected:
Blocks.push_back(BB);
DenseBlockSet.insert(BB);
}
+
+ // Since loop passes like SCEV are allowed to key analysis results off of
+ // `Loop` pointers, we cannot re-use pointers within a loop pass manager.
+ // This means loop passes should not be `delete` ing `Loop` objects directly
+ // (and risk a later `Loop` allocation re-using the address of a previous one)
+ // but should be using LoopInfo::markAsRemoved, which keeps around the `Loop`
+ // pointer till the end of the lifetime of the `LoopInfo` object.
+ //
+ // To make it easier to follow this rule, we mark the destructor as
+ // non-public.
+ ~LoopBase() {
+ for (auto *SubLoop : SubLoops)
+ delete SubLoop;
+ }
};
template<class BlockT, class LoopT>
@@ -500,7 +510,9 @@ public:
private:
friend class LoopInfoBase<BasicBlock, Loop>;
+ friend class LoopBase<BasicBlock, Loop>;
explicit Loop(BasicBlock *BB) : LoopBase<BasicBlock, Loop>(BB) {}
+ ~Loop() = default;
};
//===----------------------------------------------------------------------===//
@@ -702,7 +714,7 @@ public:
/// the loop forest and parent loops for each block so that \c L is no longer
/// referenced, but does not actually delete \c L immediately. The pointer
/// will remain valid until this LoopInfo's memory is released.
- void markAsRemoved(Loop *L);
+ void markAsErased(Loop *L);
/// Returns true if replacing From with To everywhere is guaranteed to
/// preserve LCSSA form.
Modified: llvm/trunk/lib/Analysis/LoopInfo.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/LoopInfo.cpp?rev=313695&r1=313694&r2=313695&view=diff
==============================================================================
--- llvm/trunk/lib/Analysis/LoopInfo.cpp (original)
+++ llvm/trunk/lib/Analysis/LoopInfo.cpp Tue Sep 19 16:19:00 2017
@@ -622,8 +622,8 @@ bool LoopInfo::invalidate(Function &F, c
PAC.preservedSet<CFGAnalyses>());
}
-void LoopInfo::markAsRemoved(Loop *Unloop) {
- assert(!Unloop->isInvalid() && "Loop has already been removed");
+void LoopInfo::markAsErased(Loop *Unloop) {
+ assert(!Unloop->isInvalid() && "Loop has already been erased!");
Unloop->invalidate();
RemovedLoops.push_back(Unloop);
Modified: llvm/trunk/lib/Transforms/IPO/LoopExtractor.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/IPO/LoopExtractor.cpp?rev=313695&r1=313694&r2=313695&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/IPO/LoopExtractor.cpp (original)
+++ llvm/trunk/lib/Transforms/IPO/LoopExtractor.cpp Tue Sep 19 16:19:00 2017
@@ -143,7 +143,7 @@ bool LoopExtractor::runOnLoop(Loop *L, L
Changed = true;
// After extraction, the loop is replaced by a function call, so
// we shouldn't try to run any more loop passes on it.
- LI.markAsRemoved(L);
+ LI.markAsErased(L);
}
++NumExtracted;
}
Modified: llvm/trunk/lib/Transforms/Scalar/LoopDeletion.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/LoopDeletion.cpp?rev=313695&r1=313694&r2=313695&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/Scalar/LoopDeletion.cpp (original)
+++ llvm/trunk/lib/Transforms/Scalar/LoopDeletion.cpp Tue Sep 19 16:19:00 2017
@@ -334,7 +334,7 @@ static void deleteDeadLoop(Loop *L, Domi
LI.removeBlock(BB);
// The last step is to update LoopInfo now that we've eliminated this loop.
- LI.markAsRemoved(L);
+ LI.markAsErased(L);
}
PreservedAnalyses LoopDeletionPass::run(Loop &L, LoopAnalysisManager &AM,
Modified: llvm/trunk/lib/Transforms/Utils/LoopUnroll.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Utils/LoopUnroll.cpp?rev=313695&r1=313694&r2=313695&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/Utils/LoopUnroll.cpp (original)
+++ llvm/trunk/lib/Transforms/Utils/LoopUnroll.cpp Tue Sep 19 16:19:00 2017
@@ -816,7 +816,7 @@ bool llvm::UnrollLoop(Loop *L, unsigned
Loop *OuterL = L->getParentLoop();
// Update LoopInfo if the loop is completely removed.
if (CompletelyUnroll)
- LI->markAsRemoved(L);
+ LI->markAsErased(L);
// After complete unrolling most of the blocks should be contained in OuterL.
// However, some of them might happen to be out of OuterL (e.g. if they
@@ -841,7 +841,7 @@ bool llvm::UnrollLoop(Loop *L, unsigned
if (NeedToFixLCSSA) {
// LCSSA must be performed on the outermost affected loop. The unrolled
// loop's last loop latch is guaranteed to be in the outermost loop
- // after LoopInfo's been updated by markAsRemoved.
+ // after LoopInfo's been updated by markAsErased.
Loop *LatchLoop = LI->getLoopFor(Latches.back());
Loop *FixLCSSALoop = OuterL;
if (!FixLCSSALoop->contains(LatchLoop))
Modified: llvm/trunk/unittests/Analysis/ScalarEvolutionTest.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/Analysis/ScalarEvolutionTest.cpp?rev=313695&r1=313694&r2=313695&view=diff
==============================================================================
--- llvm/trunk/unittests/Analysis/ScalarEvolutionTest.cpp (original)
+++ llvm/trunk/unittests/Analysis/ScalarEvolutionTest.cpp Tue Sep 19 16:19:00 2017
@@ -110,147 +110,6 @@ TEST_F(ScalarEvolutionsTest, SCEVUnknown
EXPECT_EQ(cast<SCEVUnknown>(M2->getOperand(1))->getValue(), V0);
}
-TEST_F(ScalarEvolutionsTest, SCEVMultiplyAddRecs) {
- Type *Ty = Type::getInt32Ty(Context);
- SmallVector<Type *, 10> Types;
- Types.append(10, Ty);
- FunctionType *FTy = FunctionType::get(Type::getVoidTy(Context), Types, false);
- Function *F = cast<Function>(M.getOrInsertFunction("f", FTy));
- BasicBlock *BB = BasicBlock::Create(Context, "entry", F);
- ReturnInst::Create(Context, nullptr, BB);
-
- ScalarEvolution SE = buildSE(*F);
-
- // It's possible to produce an empty loop through the default constructor,
- // but you can't add any blocks to it without a LoopInfo pass.
- Loop L;
- const_cast<std::vector<BasicBlock*>&>(L.getBlocks()).push_back(BB);
-
- Function::arg_iterator AI = F->arg_begin();
- SmallVector<const SCEV *, 5> A;
- A.push_back(SE.getSCEV(&*AI++));
- A.push_back(SE.getSCEV(&*AI++));
- A.push_back(SE.getSCEV(&*AI++));
- A.push_back(SE.getSCEV(&*AI++));
- A.push_back(SE.getSCEV(&*AI++));
- const SCEV *A_rec = SE.getAddRecExpr(A, &L, SCEV::FlagAnyWrap);
-
- SmallVector<const SCEV *, 5> B;
- B.push_back(SE.getSCEV(&*AI++));
- B.push_back(SE.getSCEV(&*AI++));
- B.push_back(SE.getSCEV(&*AI++));
- B.push_back(SE.getSCEV(&*AI++));
- B.push_back(SE.getSCEV(&*AI++));
- const SCEV *B_rec = SE.getAddRecExpr(B, &L, SCEV::FlagAnyWrap);
-
- /* Spot check that we perform this transformation:
- {A0,+,A1,+,A2,+,A3,+,A4} * {B0,+,B1,+,B2,+,B3,+,B4} =
- {A0*B0,+,
- A1*B0 + A0*B1 + A1*B1,+,
- A2*B0 + 2A1*B1 + A0*B2 + 2A2*B1 + 2A1*B2 + A2*B2,+,
- A3*B0 + 3A2*B1 + 3A1*B2 + A0*B3 + 3A3*B1 + 6A2*B2 + 3A1*B3 + 3A3*B2 +
- 3A2*B3 + A3*B3,+,
- A4*B0 + 4A3*B1 + 6A2*B2 + 4A1*B3 + A0*B4 + 4A4*B1 + 12A3*B2 + 12A2*B3 +
- 4A1*B4 + 6A4*B2 + 12A3*B3 + 6A2*B4 + 4A4*B3 + 4A3*B4 + A4*B4,+,
- 5A4*B1 + 10A3*B2 + 10A2*B3 + 5A1*B4 + 20A4*B2 + 30A3*B3 + 20A2*B4 +
- 30A4*B3 + 30A3*B4 + 20A4*B4,+,
- 15A4*B2 + 20A3*B3 + 15A2*B4 + 60A4*B3 + 60A3*B4 + 90A4*B4,+,
- 35A4*B3 + 35A3*B4 + 140A4*B4,+,
- 70A4*B4}
- */
-
- const SCEVAddRecExpr *Product =
- dyn_cast<SCEVAddRecExpr>(SE.getMulExpr(A_rec, B_rec));
- ASSERT_TRUE(Product);
- ASSERT_EQ(Product->getNumOperands(), 9u);
-
- SmallVector<const SCEV *, 16> Sum;
- Sum.push_back(SE.getMulExpr(A[0], B[0]));
- EXPECT_EQ(Product->getOperand(0), SE.getAddExpr(Sum));
- Sum.clear();
-
- // SCEV produces different an equal but different expression for these.
- // Re-enable when PR11052 is fixed.
-#if 0
- Sum.push_back(SE.getMulExpr(A[1], B[0]));
- Sum.push_back(SE.getMulExpr(A[0], B[1]));
- Sum.push_back(SE.getMulExpr(A[1], B[1]));
- EXPECT_EQ(Product->getOperand(1), SE.getAddExpr(Sum));
- Sum.clear();
-
- Sum.push_back(SE.getMulExpr(A[2], B[0]));
- Sum.push_back(SE.getMulExpr(SE.getConstant(Ty, 2), A[1], B[1]));
- Sum.push_back(SE.getMulExpr(A[0], B[2]));
- Sum.push_back(SE.getMulExpr(SE.getConstant(Ty, 2), A[2], B[1]));
- Sum.push_back(SE.getMulExpr(SE.getConstant(Ty, 2), A[1], B[2]));
- Sum.push_back(SE.getMulExpr(A[2], B[2]));
- EXPECT_EQ(Product->getOperand(2), SE.getAddExpr(Sum));
- Sum.clear();
-
- Sum.push_back(SE.getMulExpr(A[3], B[0]));
- Sum.push_back(SE.getMulExpr(SE.getConstant(Ty, 3), A[2], B[1]));
- Sum.push_back(SE.getMulExpr(SE.getConstant(Ty, 3), A[1], B[2]));
- Sum.push_back(SE.getMulExpr(A[0], B[3]));
- Sum.push_back(SE.getMulExpr(SE.getConstant(Ty, 3), A[3], B[1]));
- Sum.push_back(SE.getMulExpr(SE.getConstant(Ty, 6), A[2], B[2]));
- Sum.push_back(SE.getMulExpr(SE.getConstant(Ty, 3), A[1], B[3]));
- Sum.push_back(SE.getMulExpr(SE.getConstant(Ty, 3), A[3], B[2]));
- Sum.push_back(SE.getMulExpr(SE.getConstant(Ty, 3), A[2], B[3]));
- Sum.push_back(SE.getMulExpr(A[3], B[3]));
- EXPECT_EQ(Product->getOperand(3), SE.getAddExpr(Sum));
- Sum.clear();
-
- Sum.push_back(SE.getMulExpr(A[4], B[0]));
- Sum.push_back(SE.getMulExpr(SE.getConstant(Ty, 4), A[3], B[1]));
- Sum.push_back(SE.getMulExpr(SE.getConstant(Ty, 6), A[2], B[2]));
- Sum.push_back(SE.getMulExpr(SE.getConstant(Ty, 4), A[1], B[3]));
- Sum.push_back(SE.getMulExpr(A[0], B[4]));
- Sum.push_back(SE.getMulExpr(SE.getConstant(Ty, 4), A[4], B[1]));
- Sum.push_back(SE.getMulExpr(SE.getConstant(Ty, 12), A[3], B[2]));
- Sum.push_back(SE.getMulExpr(SE.getConstant(Ty, 12), A[2], B[3]));
- Sum.push_back(SE.getMulExpr(SE.getConstant(Ty, 4), A[1], B[4]));
- Sum.push_back(SE.getMulExpr(SE.getConstant(Ty, 6), A[4], B[2]));
- Sum.push_back(SE.getMulExpr(SE.getConstant(Ty, 12), A[3], B[3]));
- Sum.push_back(SE.getMulExpr(SE.getConstant(Ty, 6), A[2], B[4]));
- Sum.push_back(SE.getMulExpr(SE.getConstant(Ty, 4), A[4], B[3]));
- Sum.push_back(SE.getMulExpr(SE.getConstant(Ty, 4), A[3], B[4]));
- Sum.push_back(SE.getMulExpr(A[4], B[4]));
- EXPECT_EQ(Product->getOperand(4), SE.getAddExpr(Sum));
- Sum.clear();
-
- Sum.push_back(SE.getMulExpr(SE.getConstant(Ty, 5), A[4], B[1]));
- Sum.push_back(SE.getMulExpr(SE.getConstant(Ty, 10), A[3], B[2]));
- Sum.push_back(SE.getMulExpr(SE.getConstant(Ty, 10), A[2], B[3]));
- Sum.push_back(SE.getMulExpr(SE.getConstant(Ty, 5), A[1], B[4]));
- Sum.push_back(SE.getMulExpr(SE.getConstant(Ty, 20), A[4], B[2]));
- Sum.push_back(SE.getMulExpr(SE.getConstant(Ty, 30), A[3], B[3]));
- Sum.push_back(SE.getMulExpr(SE.getConstant(Ty, 20), A[2], B[4]));
- Sum.push_back(SE.getMulExpr(SE.getConstant(Ty, 30), A[4], B[3]));
- Sum.push_back(SE.getMulExpr(SE.getConstant(Ty, 30), A[3], B[4]));
- Sum.push_back(SE.getMulExpr(SE.getConstant(Ty, 20), A[4], B[4]));
- EXPECT_EQ(Product->getOperand(5), SE.getAddExpr(Sum));
- Sum.clear();
-
- Sum.push_back(SE.getMulExpr(SE.getConstant(Ty, 15), A[4], B[2]));
- Sum.push_back(SE.getMulExpr(SE.getConstant(Ty, 20), A[3], B[3]));
- Sum.push_back(SE.getMulExpr(SE.getConstant(Ty, 15), A[2], B[4]));
- Sum.push_back(SE.getMulExpr(SE.getConstant(Ty, 60), A[4], B[3]));
- Sum.push_back(SE.getMulExpr(SE.getConstant(Ty, 60), A[3], B[4]));
- Sum.push_back(SE.getMulExpr(SE.getConstant(Ty, 90), A[4], B[4]));
- EXPECT_EQ(Product->getOperand(6), SE.getAddExpr(Sum));
- Sum.clear();
-
- Sum.push_back(SE.getMulExpr(SE.getConstant(Ty, 35), A[4], B[3]));
- Sum.push_back(SE.getMulExpr(SE.getConstant(Ty, 35), A[3], B[4]));
- Sum.push_back(SE.getMulExpr(SE.getConstant(Ty, 140), A[4], B[4]));
- EXPECT_EQ(Product->getOperand(7), SE.getAddExpr(Sum));
- Sum.clear();
-#endif
-
- Sum.push_back(SE.getMulExpr(SE.getConstant(Ty, 70), A[4], B[4]));
- EXPECT_EQ(Product->getOperand(8), SE.getAddExpr(Sum));
-}
-
TEST_F(ScalarEvolutionsTest, SimplifiedPHI) {
FunctionType *FTy = FunctionType::get(Type::getVoidTy(Context),
std::vector<Type *>(), false);
Modified: llvm/trunk/unittests/Transforms/Scalar/LoopPassManagerTest.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/Transforms/Scalar/LoopPassManagerTest.cpp?rev=313695&r1=313694&r2=313695&view=diff
==============================================================================
--- llvm/trunk/unittests/Transforms/Scalar/LoopPassManagerTest.cpp (original)
+++ llvm/trunk/unittests/Transforms/Scalar/LoopPassManagerTest.cpp Tue Sep 19 16:19:00 2017
@@ -1374,9 +1374,8 @@ TEST_F(LoopPassManagerTest, LoopDeletion
// to isolate ourselves from the rest of LLVM and for simplicity. Here we can
// egregiously cheat based on knowledge of the test case. For example, we
// have no PHI nodes and there is always a single i-dom.
- auto RemoveLoop = [](Loop &L, BasicBlock &IDomBB,
- LoopStandardAnalysisResults &AR,
- LPMUpdater &Updater) {
+ auto EraseLoop = [](Loop &L, BasicBlock &IDomBB,
+ LoopStandardAnalysisResults &AR, LPMUpdater &Updater) {
assert(L.empty() && "Can only delete leaf loops with this routine!");
SmallVector<BasicBlock *, 4> LoopBBs(L.block_begin(), L.block_end());
Updater.markLoopAsDeleted(L);
@@ -1394,10 +1393,7 @@ TEST_F(LoopPassManagerTest, LoopDeletion
for (BasicBlock *LoopBB : LoopBBs)
LoopBB->eraseFromParent();
- if (Loop *ParentL = L.getParentLoop())
- return ParentL->removeChildLoop(find(*ParentL, &L));
-
- return AR.LI.removeLoop(find(AR.LI, &L));
+ AR.LI.markAsErased(&L);
};
// Build up the pass managers.
@@ -1442,7 +1438,7 @@ TEST_F(LoopPassManagerTest, LoopDeletion
LoopStandardAnalysisResults &AR, LPMUpdater &Updater) {
Loop *ParentL = L.getParentLoop();
AR.SE.forgetLoop(&L);
- delete RemoveLoop(L, Loop01PHBB, AR, Updater);
+ EraseLoop(L, Loop01PHBB, AR, Updater);
ParentL->verifyLoop();
return PreservedAnalyses::all();
}));
@@ -1469,10 +1465,8 @@ TEST_F(LoopPassManagerTest, LoopDeletion
.WillRepeatedly(Invoke(getLoopAnalysisResult));
// Run the loop pipeline again. This time we delete the last loop, which
- // contains a nested loop within it, and we reuse its inner loop object to
- // insert a new loop into the nest. This makes sure that we don't reuse
- // cached analysis results for loop objects when removed just because their
- // pointers match, and that we can handle nested loop deletion.
+ // contains a nested loop within it and insert a new loop into the nest. This
+ // makes sure we can handle nested loop deletion.
AddLoopPipelineAndVerificationPasses();
EXPECT_CALL(MLPHandle, run(HasName("loop.0.0"), _, _, _))
.Times(3)
@@ -1489,16 +1483,16 @@ TEST_F(LoopPassManagerTest, LoopDeletion
.WillOnce(
Invoke([&](Loop &L, LoopAnalysisManager &AM,
LoopStandardAnalysisResults &AR, LPMUpdater &Updater) {
- // Remove the inner loop first but retain it to reuse later.
AR.SE.forgetLoop(*L.begin());
- auto *OldL = RemoveLoop(**L.begin(), Loop020PHBB, AR, Updater);
+ EraseLoop(**L.begin(), Loop020PHBB, AR, Updater);
auto *ParentL = L.getParentLoop();
AR.SE.forgetLoop(&L);
- delete RemoveLoop(L, Loop02PHBB, AR, Updater);
+ EraseLoop(L, Loop02PHBB, AR, Updater);
- // Now insert a new sibling loop, reusing a loop pointer.
- ParentL->addChildLoop(OldL);
+ // Now insert a new sibling loop.
+ auto *NewSibling = new Loop;
+ ParentL->addChildLoop(NewSibling);
NewLoop03PHBB =
BasicBlock::Create(Context, "loop.0.3.ph", &F, &Loop0LatchBB);
auto *NewLoop03BB =
@@ -1515,10 +1509,10 @@ TEST_F(LoopPassManagerTest, LoopDeletion
AR.DT[NewLoop03BB]);
AR.DT.verifyDomTree();
ParentL->addBasicBlockToLoop(NewLoop03PHBB, AR.LI);
- OldL->addBasicBlockToLoop(NewLoop03BB, AR.LI);
- OldL->verifyLoop();
+ NewSibling->addBasicBlockToLoop(NewLoop03BB, AR.LI);
+ NewSibling->verifyLoop();
ParentL->verifyLoop();
- Updater.addSiblingLoops({OldL});
+ Updater.addSiblingLoops({NewSibling});
return PreservedAnalyses::all();
}));
@@ -1550,7 +1544,7 @@ TEST_F(LoopPassManagerTest, LoopDeletion
Invoke([&](Loop &L, LoopAnalysisManager &AM,
LoopStandardAnalysisResults &AR, LPMUpdater &Updater) {
AR.SE.forgetLoop(&L);
- delete RemoveLoop(L, Loop00PHBB, AR, Updater);
+ EraseLoop(L, Loop00PHBB, AR, Updater);
return PreservedAnalyses::all();
}));
@@ -1561,7 +1555,7 @@ TEST_F(LoopPassManagerTest, LoopDeletion
Invoke([&](Loop &L, LoopAnalysisManager &AM,
LoopStandardAnalysisResults &AR, LPMUpdater &Updater) {
AR.SE.forgetLoop(&L);
- delete RemoveLoop(L, *NewLoop03PHBB, AR, Updater);
+ EraseLoop(L, *NewLoop03PHBB, AR, Updater);
return PreservedAnalyses::all();
}));
@@ -1572,7 +1566,7 @@ TEST_F(LoopPassManagerTest, LoopDeletion
Invoke([&](Loop &L, LoopAnalysisManager &AM,
LoopStandardAnalysisResults &AR, LPMUpdater &Updater) {
AR.SE.forgetLoop(&L);
- delete RemoveLoop(L, EntryBB, AR, Updater);
+ EraseLoop(L, EntryBB, AR, Updater);
return PreservedAnalyses::all();
}));
More information about the llvm-commits
mailing list