From: Nikita Popov Date: Thu, 7 Apr 2022 07:49:21 +0000 (+0200) Subject: [LoopSink] Require MemorySSA X-Git-Tag: upstream/15.0.7~11046 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=5cefe7d9f531fe6eac4cd22978861752498b2265;p=platform%2Fupstream%2Fllvm.git [LoopSink] Require MemorySSA This makes MemorySSA in LoopSink required, and removes the AST-based implementation, as well as the related support code in LICM. Differential Revision: https://reviews.llvm.org/D123288 --- diff --git a/llvm/include/llvm/Transforms/Utils/LoopUtils.h b/llvm/include/llvm/Transforms/Utils/LoopUtils.h index 9b85d7b..d0c5824 100644 --- a/llvm/include/llvm/Transforms/Utils/LoopUtils.h +++ b/llvm/include/llvm/Transforms/Utils/LoopUtils.h @@ -24,7 +24,6 @@ class StringRef; class AnalysisUsage; class TargetTransformInfo; class AAResults; -class AliasSetTracker; class BasicBlock; class BlockFrequencyInfo; class ICFLoopSafetyInfo; @@ -345,8 +344,8 @@ void getLoopAnalysisUsage(AnalysisUsage &AU); /// true when moving out of loop and not true when moving into loops. /// If \p ORE is set use it to emit optimization remarks. bool canSinkOrHoistInst(Instruction &I, AAResults *AA, DominatorTree *DT, - Loop *CurLoop, AliasSetTracker *CurAST, - MemorySSAUpdater *MSSAU, bool TargetExecutesOncePerLoop, + Loop *CurLoop, MemorySSAUpdater *MSSAU, + bool TargetExecutesOncePerLoop, SinkAndHoistLICMFlags *LICMFlags = nullptr, OptimizationRemarkEmitter *ORE = nullptr); diff --git a/llvm/lib/Transforms/Scalar/LICM.cpp b/llvm/lib/Transforms/Scalar/LICM.cpp index af11109d..3197e4d 100644 --- a/llvm/lib/Transforms/Scalar/LICM.cpp +++ b/llvm/lib/Transforms/Scalar/LICM.cpp @@ -116,8 +116,7 @@ static cl::opt MaxNumUsesTraversed( // Experimental option to allow imprecision in LICM in pathological cases, in // exchange for faster compile. This is to be removed if MemorySSA starts to -// address the same issue. This flag applies only when LICM uses MemorySSA -// instead on AliasSetTracker. LICM calls MemorySSAWalker's +// address the same issue. LICM calls MemorySSAWalker's // getClobberingMemoryAccess, up to the value of the Cap, getting perfect // accuracy. Afterwards, LICM will call into MemorySSA's getDefiningAccess, // which may not be precise, since optimizeUses is capped. The result is @@ -156,14 +155,11 @@ static bool isSafeToExecuteUnconditionally( const Loop *CurLoop, const LoopSafetyInfo *SafetyInfo, OptimizationRemarkEmitter *ORE, const Instruction *CtxI, bool AllowSpeculation); -static bool pointerInvalidatedByLoop(MemoryLocation MemLoc, - AliasSetTracker *CurAST, Loop *CurLoop, - AAResults *AA); -static bool pointerInvalidatedByLoopWithMSSA(MemorySSA *MSSA, MemoryUse *MU, - Loop *CurLoop, Instruction &I, - SinkAndHoistLICMFlags &Flags); -static bool pointerInvalidatedByBlockWithMSSA(BasicBlock &BB, MemorySSA &MSSA, - MemoryUse &MU); +static bool pointerInvalidatedByLoop(MemorySSA *MSSA, MemoryUse *MU, + Loop *CurLoop, Instruction &I, + SinkAndHoistLICMFlags &Flags); +static bool pointerInvalidatedByBlock(BasicBlock &BB, MemorySSA &MSSA, + MemoryUse &MU); static Instruction *cloneInstructionInExitBlock( Instruction &I, BasicBlock &ExitBlock, PHINode &PN, const LoopInfo *LI, const LoopSafetyInfo *SafetyInfo, MemorySSAUpdater *MSSAU); @@ -580,8 +576,7 @@ bool llvm::sinkRegion(DomTreeNode *N, AAResults *AA, LoopInfo *LI, if (!I.mayHaveSideEffects() && isNotUsedOrFreeInLoop(I, LoopNestMode ? OutermostLoop : CurLoop, SafetyInfo, TTI, FreeInLoop, LoopNestMode) && - canSinkOrHoistInst(I, AA, DT, CurLoop, /*CurAST*/nullptr, MSSAU, true, - &Flags, ORE)) { + canSinkOrHoistInst(I, AA, DT, CurLoop, MSSAU, true, &Flags, ORE)) { if (sink(I, LI, DT, BFI, CurLoop, SafetyInfo, MSSAU, ORE)) { if (!FreeInLoop) { ++II; @@ -904,8 +899,7 @@ bool llvm::hoistRegion(DomTreeNode *N, AAResults *AA, LoopInfo *LI, // and we have accurately duplicated the control flow from the loop header // to that block. if (CurLoop->hasLoopInvariantOperands(&I) && - canSinkOrHoistInst(I, AA, DT, CurLoop, /*CurAST*/ nullptr, MSSAU, - true, &Flags, ORE) && + canSinkOrHoistInst(I, AA, DT, CurLoop, MSSAU, true, &Flags, ORE) && isSafeToExecuteUnconditionally( I, DT, TLI, CurLoop, SafetyInfo, ORE, CurLoop->getLoopPreheader()->getTerminator(), AllowSpeculation)) { @@ -1114,23 +1108,12 @@ bool isHoistableAndSinkableInst(Instruction &I) { isa(I) || isa(I) || isa(I) || isa(I)); } -/// Return true if all of the alias sets within this AST are known not to -/// contain a Mod, or if MSSA knows there are no MemoryDefs in the loop. -bool isReadOnly(AliasSetTracker *CurAST, const MemorySSAUpdater *MSSAU, - const Loop *L) { - if (CurAST) { - for (AliasSet &AS : *CurAST) { - if (!AS.isForwardingAliasSet() && AS.isMod()) { - return false; - } - } - return true; - } else { /*MSSAU*/ - for (auto *BB : L->getBlocks()) - if (MSSAU->getMemorySSA()->getBlockDefs(BB)) - return false; - return true; - } +/// Return true if MSSA knows there are no MemoryDefs in the loop. +bool isReadOnly(const MemorySSAUpdater *MSSAU, const Loop *L) { + for (auto *BB : L->getBlocks()) + if (MSSAU->getMemorySSA()->getBlockDefs(BB)) + return false; + return true; } /// Return true if I is the only Instruction with a MemoryAccess in L. @@ -1152,13 +1135,11 @@ bool isOnlyMemoryAccess(const Instruction *I, const Loop *L, } bool llvm::canSinkOrHoistInst(Instruction &I, AAResults *AA, DominatorTree *DT, - Loop *CurLoop, AliasSetTracker *CurAST, - MemorySSAUpdater *MSSAU, + Loop *CurLoop, MemorySSAUpdater *MSSAU, bool TargetExecutesOncePerLoop, SinkAndHoistLICMFlags *Flags, OptimizationRemarkEmitter *ORE) { - assert(((CurAST != nullptr) ^ (MSSAU != nullptr)) && - "Either AliasSetTracker or MemorySSA should be initialized."); + assert(MSSAU && "MemorySSA should be initialized."); // If we don't understand the instruction, bail early. if (!isHoistableAndSinkableInst(I)) @@ -1187,13 +1168,8 @@ bool llvm::canSinkOrHoistInst(Instruction &I, AAResults *AA, DominatorTree *DT, if (isLoadInvariantInLoop(LI, DT, CurLoop)) return true; - bool Invalidated; - if (CurAST) - Invalidated = pointerInvalidatedByLoop(MemoryLocation::get(LI), CurAST, - CurLoop, AA); - else - Invalidated = pointerInvalidatedByLoopWithMSSA( - MSSA, cast(MSSA->getMemoryAccess(LI)), CurLoop, I, *Flags); + bool Invalidated = pointerInvalidatedByLoop( + MSSA, cast(MSSA->getMemoryAccess(LI)), CurLoop, I, *Flags); // Check loop-invariant address because this may also be a sinkable load // whose address is not necessarily loop-invariant. if (ORE && Invalidated && CurLoop->isLoopInvariant(LI->getPointerOperand())) @@ -1241,24 +1217,17 @@ bool llvm::canSinkOrHoistInst(Instruction &I, AAResults *AA, DominatorTree *DT, if (AAResults::onlyAccessesArgPointees(Behavior)) { // TODO: expand to writeable arguments for (Value *Op : CI->args()) - if (Op->getType()->isPointerTy()) { - bool Invalidated; - if (CurAST) - Invalidated = pointerInvalidatedByLoop( - MemoryLocation::getBeforeOrAfter(Op), CurAST, CurLoop, AA); - else - Invalidated = pointerInvalidatedByLoopWithMSSA( + if (Op->getType()->isPointerTy() && + pointerInvalidatedByLoop( MSSA, cast(MSSA->getMemoryAccess(CI)), CurLoop, I, - *Flags); - if (Invalidated) - return false; - } + *Flags)) + return false; return true; } // If this call only reads from memory and there are no writes to memory // in the loop, we can hoist or sink the call as appropriate. - if (isReadOnly(CurAST, MSSAU, CurLoop)) + if (isReadOnly(MSSAU, CurLoop)) return true; } @@ -1269,21 +1238,7 @@ bool llvm::canSinkOrHoistInst(Instruction &I, AAResults *AA, DominatorTree *DT, } else if (auto *FI = dyn_cast(&I)) { // Fences alias (most) everything to provide ordering. For the moment, // just give up if there are any other memory operations in the loop. - if (CurAST) { - auto Begin = CurAST->begin(); - assert(Begin != CurAST->end() && "must contain FI"); - if (std::next(Begin) != CurAST->end()) - // constant memory for instance, TODO: handle better - return false; - auto *UniqueI = Begin->getUniqueInstruction(); - if (!UniqueI) - // other memory op, give up - return false; - (void)FI; // suppress unused variable warning - assert(UniqueI == FI && "AS must contain FI"); - return true; - } else // MSSAU - return isOnlyMemoryAccess(FI, CurLoop, MSSAU); + return isOnlyMemoryAccess(FI, CurLoop, MSSAU); } else if (auto *SI = dyn_cast(&I)) { if (!SI->isUnordered()) return false; // Don't sink/hoist volatile or ordered atomic store! @@ -1293,68 +1248,54 @@ bool llvm::canSinkOrHoistInst(Instruction &I, AAResults *AA, DominatorTree *DT, // load store promotion instead. TODO: We can extend this to cases where // there is exactly one write to the location and that write dominates an // arbitrary number of reads in the loop. - if (CurAST) { - auto &AS = CurAST->getAliasSetFor(MemoryLocation::get(SI)); - - if (AS.isRef() || !AS.isMustAlias()) - // Quick exit test, handled by the full path below as well. - return false; - auto *UniqueI = AS.getUniqueInstruction(); - if (!UniqueI) - // other memory op, give up - return false; - assert(UniqueI == SI && "AS must contain SI"); + if (isOnlyMemoryAccess(SI, CurLoop, MSSAU)) return true; - } else { // MSSAU - if (isOnlyMemoryAccess(SI, CurLoop, MSSAU)) - return true; - // If there are more accesses than the Promotion cap or no "quota" to - // check clobber, then give up as we're not walking a list that long. - if (Flags->tooManyMemoryAccesses() || Flags->tooManyClobberingCalls()) - return false; - // If there are interfering Uses (i.e. their defining access is in the - // loop), or ordered loads (stored as Defs!), don't move this store. - // Could do better here, but this is conservatively correct. - // TODO: Cache set of Uses on the first walk in runOnLoop, update when - // moving accesses. Can also extend to dominating uses. - auto *SIMD = MSSA->getMemoryAccess(SI); - for (auto *BB : CurLoop->getBlocks()) - if (auto *Accesses = MSSA->getBlockAccesses(BB)) { - for (const auto &MA : *Accesses) - if (const auto *MU = dyn_cast(&MA)) { - auto *MD = MU->getDefiningAccess(); - if (!MSSA->isLiveOnEntryDef(MD) && - CurLoop->contains(MD->getBlock())) - return false; - // Disable hoisting past potentially interfering loads. Optimized - // Uses may point to an access outside the loop, as getClobbering - // checks the previous iteration when walking the backedge. - // FIXME: More precise: no Uses that alias SI. - if (!Flags->getIsSink() && !MSSA->dominates(SIMD, MU)) - return false; - } else if (const auto *MD = dyn_cast(&MA)) { - if (auto *LI = dyn_cast(MD->getMemoryInst())) { - (void)LI; // Silence warning. - assert(!LI->isUnordered() && "Expected unordered load"); + // If there are more accesses than the Promotion cap or no "quota" to + // check clobber, then give up as we're not walking a list that long. + if (Flags->tooManyMemoryAccesses() || Flags->tooManyClobberingCalls()) + return false; + // If there are interfering Uses (i.e. their defining access is in the + // loop), or ordered loads (stored as Defs!), don't move this store. + // Could do better here, but this is conservatively correct. + // TODO: Cache set of Uses on the first walk in runOnLoop, update when + // moving accesses. Can also extend to dominating uses. + auto *SIMD = MSSA->getMemoryAccess(SI); + for (auto *BB : CurLoop->getBlocks()) + if (auto *Accesses = MSSA->getBlockAccesses(BB)) { + for (const auto &MA : *Accesses) + if (const auto *MU = dyn_cast(&MA)) { + auto *MD = MU->getDefiningAccess(); + if (!MSSA->isLiveOnEntryDef(MD) && + CurLoop->contains(MD->getBlock())) + return false; + // Disable hoisting past potentially interfering loads. Optimized + // Uses may point to an access outside the loop, as getClobbering + // checks the previous iteration when walking the backedge. + // FIXME: More precise: no Uses that alias SI. + if (!Flags->getIsSink() && !MSSA->dominates(SIMD, MU)) + return false; + } else if (const auto *MD = dyn_cast(&MA)) { + if (auto *LI = dyn_cast(MD->getMemoryInst())) { + (void)LI; // Silence warning. + assert(!LI->isUnordered() && "Expected unordered load"); + return false; + } + // Any call, while it may not be clobbering SI, it may be a use. + if (auto *CI = dyn_cast(MD->getMemoryInst())) { + // Check if the call may read from the memory location written + // to by SI. Check CI's attributes and arguments; the number of + // such checks performed is limited above by NoOfMemAccTooLarge. + ModRefInfo MRI = AA->getModRefInfo(CI, MemoryLocation::get(SI)); + if (isModOrRefSet(MRI)) return false; - } - // Any call, while it may not be clobbering SI, it may be a use. - if (auto *CI = dyn_cast(MD->getMemoryInst())) { - // Check if the call may read from the memory location written - // to by SI. Check CI's attributes and arguments; the number of - // such checks performed is limited above by NoOfMemAccTooLarge. - ModRefInfo MRI = AA->getModRefInfo(CI, MemoryLocation::get(SI)); - if (isModOrRefSet(MRI)) - return false; - } } - } - auto *Source = MSSA->getSkipSelfWalker()->getClobberingMemoryAccess(SI); - Flags->incrementClobberingCalls(); - // If there are no clobbering Defs in the loop, store is safe to hoist. - return MSSA->isLiveOnEntryDef(Source) || - !CurLoop->contains(Source->getBlock()); - } + } + } + auto *Source = MSSA->getSkipSelfWalker()->getClobberingMemoryAccess(SI); + Flags->incrementClobberingCalls(); + // If there are no clobbering Defs in the loop, store is safe to hoist. + return MSSA->isLiveOnEntryDef(Source) || + !CurLoop->contains(Source->getBlock()); } assert(!I.mayReadOrWriteMemory() && "unhandled aliasing"); @@ -2314,15 +2255,9 @@ collectPromotionCandidates(MemorySSA *MSSA, AliasAnalysis *AA, Loop *L) { return Result; } -static bool pointerInvalidatedByLoop(MemoryLocation MemLoc, - AliasSetTracker *CurAST, Loop *CurLoop, - AAResults *AA) { - return CurAST->getAliasSetFor(MemLoc).isMod(); -} - -bool pointerInvalidatedByLoopWithMSSA(MemorySSA *MSSA, MemoryUse *MU, - Loop *CurLoop, Instruction &I, - SinkAndHoistLICMFlags &Flags) { +static bool pointerInvalidatedByLoop(MemorySSA *MSSA, MemoryUse *MU, + Loop *CurLoop, Instruction &I, + SinkAndHoistLICMFlags &Flags) { // For hoisting, use the walker to determine safety if (!Flags.getIsSink()) { MemoryAccess *Source; @@ -2357,17 +2292,16 @@ bool pointerInvalidatedByLoopWithMSSA(MemorySSA *MSSA, MemoryUse *MU, if (Flags.tooManyMemoryAccesses()) return true; for (auto *BB : CurLoop->getBlocks()) - if (pointerInvalidatedByBlockWithMSSA(*BB, *MSSA, *MU)) + if (pointerInvalidatedByBlock(*BB, *MSSA, *MU)) return true; // When sinking, the source block may not be part of the loop so check it. if (!CurLoop->contains(&I)) - return pointerInvalidatedByBlockWithMSSA(*I.getParent(), *MSSA, *MU); + return pointerInvalidatedByBlock(*I.getParent(), *MSSA, *MU); return false; } -bool pointerInvalidatedByBlockWithMSSA(BasicBlock &BB, MemorySSA &MSSA, - MemoryUse &MU) { +bool pointerInvalidatedByBlock(BasicBlock &BB, MemorySSA &MSSA, MemoryUse &MU) { if (const auto *Accesses = MSSA.getBlockDefs(&BB)) for (const auto &MA : *Accesses) if (const auto *MD = dyn_cast(&MA)) diff --git a/llvm/lib/Transforms/Scalar/LoopSink.cpp b/llvm/lib/Transforms/Scalar/LoopSink.cpp index 746c40b..c4c8ad5 100644 --- a/llvm/lib/Transforms/Scalar/LoopSink.cpp +++ b/llvm/lib/Transforms/Scalar/LoopSink.cpp @@ -34,7 +34,6 @@ #include "llvm/ADT/SetOperations.h" #include "llvm/ADT/Statistic.h" #include "llvm/Analysis/AliasAnalysis.h" -#include "llvm/Analysis/AliasSetTracker.h" #include "llvm/Analysis/BlockFrequencyInfo.h" #include "llvm/Analysis/LoopInfo.h" #include "llvm/Analysis/LoopPass.h" @@ -65,14 +64,6 @@ static cl::opt MaxNumberOfUseBBsForSinking( "max-uses-for-sinking", cl::Hidden, cl::init(30), cl::desc("Do not sink instructions that have too many uses.")); -static cl::opt EnableMSSAInLoopSink( - "enable-mssa-in-loop-sink", cl::Hidden, cl::init(true), - cl::desc("Enable MemorySSA for LoopSink in new pass manager")); - -static cl::opt EnableMSSAInLegacyLoopSink( - "enable-mssa-in-legacy-loop-sink", cl::Hidden, cl::init(true), - cl::desc("Enable MemorySSA for LoopSink in legacy pass manager")); - /// Return adjusted total frequency of \p BBs. /// /// * If there is only one BB, sinking instruction will not introduce code @@ -274,9 +265,8 @@ static bool sinkInstruction( static bool sinkLoopInvariantInstructions(Loop &L, AAResults &AA, LoopInfo &LI, DominatorTree &DT, BlockFrequencyInfo &BFI, - ScalarEvolution *SE, - AliasSetTracker *CurAST, - MemorySSA *MSSA) { + MemorySSA &MSSA, + ScalarEvolution *SE) { BasicBlock *Preheader = L.getLoopPreheader(); assert(Preheader && "Expected loop to have preheader"); @@ -292,13 +282,8 @@ static bool sinkLoopInvariantInstructions(Loop &L, AAResults &AA, LoopInfo &LI, })) return false; - std::unique_ptr MSSAU; - std::unique_ptr LICMFlags; - if (MSSA) { - MSSAU = std::make_unique(MSSA); - LICMFlags = - std::make_unique(/*IsSink=*/true, &L, MSSA); - } + MemorySSAUpdater MSSAU(&MSSA); + SinkAndHoistLICMFlags LICMFlags(/*IsSink=*/true, &L, &MSSA); bool Changed = false; @@ -324,11 +309,10 @@ static bool sinkLoopInvariantInstructions(Loop &L, AAResults &AA, LoopInfo &LI, // No need to check for instruction's operands are loop invariant. assert(L.hasLoopInvariantOperands(&I) && "Insts in a loop's preheader should have loop invariant operands!"); - if (!canSinkOrHoistInst(I, &AA, &DT, &L, CurAST, MSSAU.get(), false, - LICMFlags.get())) + if (!canSinkOrHoistInst(I, &AA, &DT, &L, &MSSAU, false, &LICMFlags)) continue; if (sinkInstruction(L, I, ColdLoopBBs, LoopBlockNumber, LI, DT, BFI, - MSSAU.get())) + &MSSAU)) Changed = true; } @@ -337,13 +321,6 @@ static bool sinkLoopInvariantInstructions(Loop &L, AAResults &AA, LoopInfo &LI, return Changed; } -static void computeAliasSet(Loop &L, BasicBlock &Preheader, - AliasSetTracker &CurAST) { - for (BasicBlock *BB : L.blocks()) - CurAST.add(*BB); - CurAST.add(Preheader); -} - PreservedAnalyses LoopSinkPass::run(Function &F, FunctionAnalysisManager &FAM) { LoopInfo &LI = FAM.getResult(F); // Nothing to do if there are no loops. @@ -353,10 +330,7 @@ PreservedAnalyses LoopSinkPass::run(Function &F, FunctionAnalysisManager &FAM) { AAResults &AA = FAM.getResult(F); DominatorTree &DT = FAM.getResult(F); BlockFrequencyInfo &BFI = FAM.getResult(F); - - MemorySSA *MSSA = EnableMSSAInLoopSink - ? &FAM.getResult(F).getMSSA() - : nullptr; + MemorySSA &MSSA = FAM.getResult(F).getMSSA(); // We want to do a postorder walk over the loops. Since loops are a tree this // is equivalent to a reversed preorder walk and preorder is easy to compute @@ -378,18 +352,11 @@ PreservedAnalyses LoopSinkPass::run(Function &F, FunctionAnalysisManager &FAM) { if (!Preheader->getParent()->hasProfileData()) continue; - std::unique_ptr CurAST; - if (!EnableMSSAInLoopSink) { - CurAST = std::make_unique(AA); - computeAliasSet(L, *Preheader, *CurAST); - } - // Note that we don't pass SCEV here because it is only used to invalidate // loops in SCEV and we don't preserve (or request) SCEV at all making that // unnecessary. - Changed |= sinkLoopInvariantInstructions(L, AA, LI, DT, BFI, - /*ScalarEvolution*/ nullptr, - CurAST.get(), MSSA); + Changed |= sinkLoopInvariantInstructions(L, AA, LI, DT, BFI, MSSA, + /*ScalarEvolution*/ nullptr); } while (!PreorderLoops.empty()); if (!Changed) @@ -397,13 +364,10 @@ PreservedAnalyses LoopSinkPass::run(Function &F, FunctionAnalysisManager &FAM) { PreservedAnalyses PA; PA.preserveSet(); + PA.preserve(); - if (MSSA) { - PA.preserve(); - - if (VerifyMemorySSA) - MSSA->verifyMemorySSA(); - } + if (VerifyMemorySSA) + MSSA.verifyMemorySSA(); return PA; } @@ -429,24 +393,16 @@ struct LegacyLoopSinkPass : public LoopPass { return false; AAResults &AA = getAnalysis().getAAResults(); + MemorySSA &MSSA = getAnalysis().getMSSA(); auto *SE = getAnalysisIfAvailable(); - std::unique_ptr CurAST; - MemorySSA *MSSA = nullptr; - if (EnableMSSAInLegacyLoopSink) - MSSA = &getAnalysis().getMSSA(); - else { - CurAST = std::make_unique(AA); - computeAliasSet(*L, *Preheader, *CurAST); - } - bool Changed = sinkLoopInvariantInstructions( *L, AA, getAnalysis().getLoopInfo(), getAnalysis().getDomTree(), getAnalysis().getBFI(), - SE ? &SE->getSE() : nullptr, CurAST.get(), MSSA); + MSSA, SE ? &SE->getSE() : nullptr); - if (MSSA && VerifyMemorySSA) - MSSA->verifyMemorySSA(); + if (VerifyMemorySSA) + MSSA.verifyMemorySSA(); return Changed; } @@ -455,10 +411,8 @@ struct LegacyLoopSinkPass : public LoopPass { AU.setPreservesCFG(); AU.addRequired(); getLoopAnalysisUsage(AU); - if (EnableMSSAInLegacyLoopSink) { - AU.addRequired(); - AU.addPreserved(); - } + AU.addRequired(); + AU.addPreserved(); } }; } diff --git a/llvm/test/Transforms/LICM/loopsink-pr38462.ll b/llvm/test/Transforms/LICM/loopsink-pr38462.ll index 3dd6397..8d06c37 100644 --- a/llvm/test/Transforms/LICM/loopsink-pr38462.ll +++ b/llvm/test/Transforms/LICM/loopsink-pr38462.ll @@ -1,7 +1,5 @@ -; RUN: opt -S -loop-sink < %s | FileCheck %s -; RUN: opt -S -verify-memoryssa -enable-mssa-in-legacy-loop-sink -loop-sink < %s | FileCheck %s -; RUN: opt -S -aa-pipeline=basic-aa -passes=loop-sink < %s | FileCheck %s -; RUN: opt -S -verify-memoryssa -enable-mssa-in-loop-sink -aa-pipeline=basic-aa -passes=loop-sink < %s | FileCheck %s +; RUN: opt -S -verify-memoryssa -loop-sink < %s | FileCheck %s +; RUN: opt -S -verify-memoryssa -aa-pipeline=basic-aa -passes=loop-sink < %s | FileCheck %s target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target triple = "x86_64-pc-windows-msvc19.13.26128" diff --git a/llvm/test/Transforms/LICM/loopsink-pr39570.ll b/llvm/test/Transforms/LICM/loopsink-pr39570.ll index 893331f..0446ccd 100644 --- a/llvm/test/Transforms/LICM/loopsink-pr39570.ll +++ b/llvm/test/Transforms/LICM/loopsink-pr39570.ll @@ -1,7 +1,5 @@ -; RUN: opt -S -loop-sink < %s | FileCheck %s -; RUN: opt -S -verify-memoryssa -enable-mssa-in-legacy-loop-sink -loop-sink < %s | FileCheck %s -; RUN: opt -S -aa-pipeline=basic-aa -passes=loop-sink < %s | FileCheck %s -; RUN: opt -S -verify-memoryssa -enable-mssa-in-loop-sink -aa-pipeline=basic-aa -passes=loop-sink < %s | FileCheck %s +; RUN: opt -S -verify-memoryssa -loop-sink < %s | FileCheck %s +; RUN: opt -S -verify-memoryssa -aa-pipeline=basic-aa -passes=loop-sink < %s | FileCheck %s ; CHECK: pr39570 ; Make sure not to assert. diff --git a/llvm/test/Transforms/LICM/loopsink-pr39695.ll b/llvm/test/Transforms/LICM/loopsink-pr39695.ll index 71c36dc..ddb940a 100644 --- a/llvm/test/Transforms/LICM/loopsink-pr39695.ll +++ b/llvm/test/Transforms/LICM/loopsink-pr39695.ll @@ -1,7 +1,5 @@ -; RUN: opt -S -loop-sink < %s | FileCheck %s -; RUN: opt -S -verify-memoryssa -enable-mssa-in-legacy-loop-sink -loop-sink < %s | FileCheck %s -; RUN: opt -S -aa-pipeline=basic-aa -passes=loop-sink < %s | FileCheck %s -; RUN: opt -S -verify-memoryssa -enable-mssa-in-loop-sink -aa-pipeline=basic-aa -passes=loop-sink < %s | FileCheck %s +; RUN: opt -S -verify-memoryssa -loop-sink < %s | FileCheck %s +; RUN: opt -S -verify-memoryssa -aa-pipeline=basic-aa -passes=loop-sink < %s | FileCheck %s ; The load instruction should not be sunk into following loop. ; CHECK: @foo diff --git a/llvm/test/Transforms/LICM/loopsink.ll b/llvm/test/Transforms/LICM/loopsink.ll index 7982fd2..8769736 100644 --- a/llvm/test/Transforms/LICM/loopsink.ll +++ b/llvm/test/Transforms/LICM/loopsink.ll @@ -1,7 +1,5 @@ -; RUN: opt -S -loop-sink < %s | FileCheck %s -; RUN: opt -S -verify-memoryssa -enable-mssa-in-legacy-loop-sink -loop-sink < %s | FileCheck %s -; RUN: opt -S -aa-pipeline=basic-aa -passes=loop-sink < %s | FileCheck %s -; RUN: opt -S -verify-memoryssa -enable-mssa-in-loop-sink -aa-pipeline=basic-aa -passes=loop-sink < %s | FileCheck %s +; RUN: opt -S -verify-memoryssa -loop-sink < %s | FileCheck %s +; RUN: opt -S -verify-memoryssa -aa-pipeline=basic-aa -passes=loop-sink < %s | FileCheck %s @g = global i32 0, align 4