94#define DEBUG_TYPE "licm"
96STATISTIC(NumCreatedBlocks,
"Number of blocks created");
97STATISTIC(NumClonedBranches,
"Number of branches cloned");
98STATISTIC(NumSunk,
"Number of instructions sunk out of loop");
99STATISTIC(NumHoisted,
"Number of instructions hoisted out of loop");
100STATISTIC(NumMovedLoads,
"Number of load insts hoisted or sunk");
101STATISTIC(NumMovedCalls,
"Number of call insts hoisted or sunk");
102STATISTIC(NumPromotionCandidates,
"Number of promotion candidates");
103STATISTIC(NumLoadPromoted,
"Number of load-only promotions");
104STATISTIC(NumLoadStorePromoted,
"Number of load and store promotions");
106 "Number of min/max expressions hoisted out of the loop");
108 "Number of geps reassociated and hoisted out of the loop");
109STATISTIC(NumAddSubHoisted,
"Number of add/subtract expressions reassociated "
110 "and hoisted out of the loop");
111STATISTIC(NumFPAssociationsHoisted,
"Number of invariant FP expressions "
112 "reassociated and hoisted out of the loop");
117 cl::desc(
"Disable memory promotion in LICM pass"));
121 cl::desc(
"Enable control flow (and PHI) hoisting in LICM"));
125 cl::desc(
"Force thread model single in LICM pass"));
129 cl::desc(
"Max num uses visited for identifying load "
130 "invariance in loop using invariant start (default = 8)"));
135 "Set upper limit for the number of transformations performed "
136 "during a single round of hoisting the reassociated expressions."));
148 cl::desc(
"Enable imprecision in LICM in pathological cases, in exchange "
149 "for faster compile. Caps the MemorySSA clobbering calls."));
156 cl::desc(
"[LICM & MemorySSA] When MSSA in LICM is disabled, this has no "
157 "effect. When MSSA in LICM is enabled, then this is the maximum "
158 "number of accesses allowed to be present in a loop in order to "
159 "enable memory promotion."));
165 bool &FoldableInLoop,
bool LoopNestMode);
181 bool InvariantGroup);
203 std::pair<SmallSetVector<Value *, 8>,
bool>;
208struct LoopInvariantCodeMotion {
214 LoopInvariantCodeMotion(
unsigned LicmMssaOptCap,
215 unsigned LicmMssaNoAccForPromotionCap,
216 bool LicmAllowSpeculation)
217 : LicmMssaOptCap(LicmMssaOptCap),
218 LicmMssaNoAccForPromotionCap(LicmMssaNoAccForPromotionCap),
219 LicmAllowSpeculation(LicmAllowSpeculation) {}
222 unsigned LicmMssaOptCap;
223 unsigned LicmMssaNoAccForPromotionCap;
224 bool LicmAllowSpeculation;
227struct LegacyLICMPass :
public LoopPass {
232 bool LicmAllowSpeculation =
true)
233 :
LoopPass(
ID), LICM(LicmMssaOptCap, LicmMssaNoAccForPromotionCap,
234 LicmAllowSpeculation) {
243 <<
L->getHeader()->getNameOrAsOperand() <<
"\n");
247 auto *SE = getAnalysisIfAvailable<ScalarEvolutionWrapperPass>();
248 MemorySSA *MSSA = &getAnalysis<MemorySSAWrapperPass>().getMSSA();
253 return LICM.runOnLoop(
254 L, &getAnalysis<AAResultsWrapperPass>().getAAResults(),
255 &getAnalysis<LoopInfoWrapperPass>().getLoopInfo(),
256 &getAnalysis<DominatorTreeWrapperPass>().getDomTree(),
257 &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(*
F),
258 &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(*
F),
259 &getAnalysis<TargetTransformInfoWrapperPass>().getTTI(*
F),
260 SE ? &SE->getSE() :
nullptr, MSSA, &ORE);
281 LoopInvariantCodeMotion LICM;
298 if (!LICM.runOnLoop(&L, &AR.
AA, &AR.
LI, &AR.
DT, &AR.
AC, &AR.
TLI, &AR.
TTI,
311 OS, MapClassName2PassName);
334 bool Changed = LICM.runOnLoop(&OutermostLoop, &AR.
AA, &AR.
LI, &AR.
DT, &AR.
AC,
352 OS, MapClassName2PassName);
359char LegacyLICMPass::ID = 0;
378 unsigned LicmMssaOptCap,
unsigned LicmMssaNoAccForPromotionCap,
bool IsSink,
380 : LicmMssaOptCap(LicmMssaOptCap),
381 LicmMssaNoAccForPromotionCap(LicmMssaNoAccForPromotionCap),
383 unsigned AccessCapCount = 0;
384 for (
auto *BB : L.getBlocks())
386 for (
const auto &MA : *Accesses) {
406 bool Changed =
false;
408 assert(L->isLCSSAForm(*DT) &&
"Loop is not in LCSSA form.");
426 return llvm::any_of(*BB, [](Instruction &I) {
427 IntrinsicInst *II = dyn_cast<IntrinsicInst>(&I);
428 return II && II->getIntrinsicID() == Intrinsic::coro_suspend;
452 if (
L->hasDedicatedExits())
456 TLI,
TTI, L, MSSAU, &SafetyInfo, Flags, ORE)
458 MSSAU, &SafetyInfo,
Flags, ORE);
459 Flags.setIsSink(
false);
462 MSSAU, SE, &SafetyInfo, Flags, ORE, LoopNestMode,
463 LicmAllowSpeculation);
473 !
Flags.tooManyMemoryAccesses() && !HasCoroSuspendInst) {
476 L->getUniqueExitBlocks(ExitBlocks);
483 if (!HasCatchSwitch) {
489 InsertPts.
push_back(ExitBlock->getFirstInsertionPt());
497 bool Promoted =
false;
500 LocalPromoted =
false;
501 for (
auto [PointerMustAliases, HasReadsOutsideSet] :
504 PointerMustAliases, ExitBlocks, InsertPts, MSSAInsertPts,
PIC, LI,
505 DT, AC, TLI,
TTI, L, MSSAU, &SafetyInfo, ORE,
506 LicmAllowSpeculation, HasReadsOutsideSet);
508 Promoted |= LocalPromoted;
509 }
while (LocalPromoted);
527 assert(
L->isLCSSAForm(*DT) &&
"Loop not left in LCSSA form after LICM!");
528 assert((
L->isOutermost() ||
L->getParentLoop()->isLCSSAForm(*DT)) &&
529 "Parent loop not left in LCSSA form after LICM!");
552 assert(
N !=
nullptr && AA !=
nullptr && LI !=
nullptr && DT !=
nullptr &&
553 CurLoop !=
nullptr && SafetyInfo !=
nullptr &&
554 "Unexpected input to sinkRegion.");
561 bool Changed =
false;
589 bool FoldableInLoop =
false;
590 bool LoopNestMode = OutermostLoop !=
nullptr;
591 if (!
I.mayHaveSideEffects() &&
593 SafetyInfo,
TTI, FoldableInLoop,
596 if (
sink(
I, LI, DT, CurLoop, SafetyInfo, MSSAU, ORE)) {
597 if (!FoldableInLoop) {
620 bool Changed =
false;
624 while (!Worklist.
empty()) {
627 MSSAU, SafetyInfo, Flags, ORE, CurLoop);
640class ControlFlowHoister {
659 : LI(LI), DT(DT), CurLoop(CurLoop), MSSAU(MSSAU) {}
661 void registerPossiblyHoistableBranch(
BranchInst *BI) {
673 TrueDest == FalseDest)
685 if (TrueDestSucc.
count(FalseDest)) {
686 CommonSucc = FalseDest;
687 }
else if (FalseDestSucc.
count(TrueDest)) {
688 CommonSucc = TrueDest;
692 if (TrueDestSucc.
size() == 1)
693 CommonSucc = *TrueDestSucc.
begin();
697 else if (!TrueDestSucc.
empty()) {
701 assert(It !=
F->end() &&
"Could not find successor in function");
713 if (CommonSucc && DT->
dominates(BI, CommonSucc))
714 HoistableBranches[BI] = CommonSucc;
717 bool canHoistPHI(
PHINode *PN) {
726 PredecessorBlocks.
insert(PredBB);
734 for (
auto &Pair : HoistableBranches) {
735 if (Pair.second == BB) {
738 if (Pair.first->getSuccessor(0) == BB) {
739 PredecessorBlocks.
erase(Pair.first->getParent());
740 PredecessorBlocks.
erase(Pair.first->getSuccessor(1));
741 }
else if (Pair.first->getSuccessor(1) == BB) {
742 PredecessorBlocks.
erase(Pair.first->getParent());
743 PredecessorBlocks.
erase(Pair.first->getSuccessor(0));
745 PredecessorBlocks.
erase(Pair.first->getSuccessor(0));
746 PredecessorBlocks.
erase(Pair.first->getSuccessor(1));
752 return PredecessorBlocks.
empty();
759 if (HoistDestinationMap.
count(BB))
760 return HoistDestinationMap[BB];
763 auto HasBBAsSuccessor =
765 return BB != Pair.second && (Pair.first->getSuccessor(0) == BB ||
766 Pair.first->getSuccessor(1) == BB);
768 auto It =
llvm::find_if(HoistableBranches, HasBBAsSuccessor);
772 if (It == HoistableBranches.end()) {
775 <<
" as hoist destination for "
777 HoistDestinationMap[BB] = InitialPreheader;
778 return InitialPreheader;
781 assert(std::find_if(++It, HoistableBranches.end(), HasBBAsSuccessor) ==
782 HoistableBranches.end() &&
783 "BB is expected to be the target of at most one branch");
788 BasicBlock *CommonSucc = HoistableBranches[BI];
792 auto CreateHoistedBlock = [&](
BasicBlock *Orig) {
793 if (HoistDestinationMap.
count(Orig))
794 return HoistDestinationMap[Orig];
797 HoistDestinationMap[Orig] =
New;
803 <<
" as hoist destination for " << Orig->getName()
807 BasicBlock *HoistTrueDest = CreateHoistedBlock(TrueDest);
808 BasicBlock *HoistFalseDest = CreateHoistedBlock(FalseDest);
809 BasicBlock *HoistCommonSucc = CreateHoistedBlock(CommonSucc);
816 assert(TargetSucc &&
"Expected hoist target to have a single successor");
831 if (HoistTarget == InitialPreheader) {
842 for (
auto &Pair : HoistDestinationMap)
843 if (Pair.second == InitialPreheader && Pair.first != BI->
getParent())
844 Pair.second = HoistCommonSucc;
854 "Hoisting blocks should not have destroyed preheader");
855 return HoistDestinationMap[BB];
872 bool AllowSpeculation) {
874 assert(
N !=
nullptr && AA !=
nullptr && LI !=
nullptr && DT !=
nullptr &&
875 CurLoop !=
nullptr && SafetyInfo !=
nullptr &&
876 "Unexpected input to hoistRegion.");
878 ControlFlowHoister CFH(LI, DT, CurLoop, MSSAU);
889 bool Changed =
false;
894 if (!LoopNestMode &&
inSubLoop(BB, CurLoop, LI))
908 I, DT, TLI, CurLoop, SafetyInfo, ORE,
910 hoist(
I, DT, CurLoop, CFH.getOrCreateHoistedBlock(BB), SafetyInfo,
919 if (
I.getOpcode() == Instruction::FDiv &&
I.hasAllowReciprocal() &&
921 auto Divisor =
I.getOperand(1);
923 auto ReciprocalDivisor = BinaryOperator::CreateFDiv(One, Divisor);
924 ReciprocalDivisor->setFastMathFlags(
I.getFastMathFlags());
926 ReciprocalDivisor->insertBefore(&
I);
929 BinaryOperator::CreateFMul(
I.getOperand(0), ReciprocalDivisor);
930 Product->setFastMathFlags(
I.getFastMathFlags());
932 Product->insertAfter(&
I);
933 I.replaceAllUsesWith(Product);
936 hoist(*ReciprocalDivisor, DT, CurLoop, CFH.getOrCreateHoistedBlock(BB),
937 SafetyInfo, MSSAU, SE, ORE);
938 HoistedInstructions.
push_back(ReciprocalDivisor);
944 using namespace PatternMatch;
945 return I.use_empty() &&
946 match(&
I, m_Intrinsic<Intrinsic::invariant_start>());
948 auto MustExecuteWithoutWritesBefore = [&](
Instruction &
I) {
952 if ((IsInvariantStart(
I) ||
isGuard(&
I)) &&
954 MustExecuteWithoutWritesBefore(
I)) {
955 hoist(
I, DT, CurLoop, CFH.getOrCreateHoistedBlock(BB), SafetyInfo,
962 if (
PHINode *PN = dyn_cast<PHINode>(&
I)) {
963 if (CFH.canHoistPHI(PN)) {
969 hoist(*PN, DT, CurLoop, CFH.getOrCreateHoistedBlock(BB), SafetyInfo,
987 CFH.registerPossiblyHoistableBranch(BI);
1002 [&](
Use &U) { return DT->dominates(I, U); })) {
1008 "New hoist point expected to dominate old hoist point");
1013 <<
": " << *
I <<
"\n");
1025#ifdef EXPENSIVE_CHECKS
1027 assert(DT->
verify(DominatorTree::VerificationLevel::Fast) &&
1028 "Dominator tree verification failed");
1060 if (isa<Constant>(
Addr))
1063 unsigned UsesVisited = 0;
1066 for (
auto *U :
Addr->users()) {
1100 return (isa<LoadInst>(
I) || isa<StoreInst>(
I) || isa<CallInst>(
I) ||
1101 isa<FenceInst>(
I) || isa<CastInst>(
I) || isa<UnaryOperator>(
I) ||
1102 isa<BinaryOperator>(
I) || isa<SelectInst>(
I) ||
1103 isa<GetElementPtrInst>(
I) || isa<CmpInst>(
I) ||
1104 isa<InsertElementInst>(
I) || isa<ExtractElementInst>(
I) ||
1105 isa<ShuffleVectorInst>(
I) || isa<ExtractValueInst>(
I) ||
1106 isa<InsertValueInst>(
I) || isa<FreezeInst>(
I));
1110 for (
auto *BB :
L->getBlocks())
1119 for (
auto *BB :
L->getBlocks())
1122 for (
const auto &Acc : *Accs) {
1123 if (isa<MemoryPhi>(&Acc))
1125 const auto *MUD = cast<MemoryUseOrDef>(&Acc);
1126 if (MUD->getMemoryInst() !=
I || NotAPhi++ == 1)
1139 if (Flags.tooManyClobberingCalls())
1144 Flags.incrementClobberingCalls();
1150 bool TargetExecutesOncePerLoop,
1154 if (!isHoistableAndSinkableInst(
I))
1159 if (
LoadInst *LI = dyn_cast<LoadInst>(&
I)) {
1160 if (!LI->isUnordered())
1167 if (LI->hasMetadata(LLVMContext::MD_invariant_load))
1170 if (LI->isAtomic() && !TargetExecutesOncePerLoop)
1179 bool InvariantGroup = LI->hasMetadata(LLVMContext::MD_invariant_group);
1182 MSSA, MU, CurLoop,
I, Flags, InvariantGroup);
1188 DEBUG_TYPE,
"LoadWithLoopInvariantAddressInvalidated", LI)
1189 <<
"failed to move load with loop-invariant address "
1190 "because the loop may invalidate its value";
1194 }
else if (
CallInst *CI = dyn_cast<CallInst>(&
I)) {
1196 if (isa<DbgInfoIntrinsic>(
I))
1207 if (CI->isConvergent())
1210 using namespace PatternMatch;
1211 if (
match(CI, m_Intrinsic<Intrinsic::assume>()))
1223 if (Behavior.
onlyReadsMemory() && CI->getFunction()->isPresplitCoroutine())
1235 if (
Op->getType()->isPointerTy() &&
1245 if (isReadOnly(MSSAU, CurLoop))
1253 }
else if (
auto *FI = dyn_cast<FenceInst>(&
I)) {
1256 return isOnlyMemoryAccess(FI, CurLoop, MSSAU);
1257 }
else if (
auto *SI = dyn_cast<StoreInst>(&
I)) {
1258 if (!SI->isUnordered())
1266 if (isOnlyMemoryAccess(SI, CurLoop, MSSAU))
1270 if (Flags.tooManyMemoryAccesses())
1278 CurLoop->
contains(Source->getBlock()))
1288 for (
const auto &MA : *Accesses)
1289 if (
const auto *MU = dyn_cast<MemoryUse>(&MA)) {
1299 if (!Flags.getIsSink() && !MSSA->
dominates(SIMD, MU))
1301 }
else if (
const auto *MD = dyn_cast<MemoryDef>(&MA)) {
1302 if (
auto *LI = dyn_cast<LoadInst>(MD->getMemoryInst())) {
1304 assert(!LI->isUnordered() &&
"Expected unordered load");
1308 if (
auto *CI = dyn_cast<CallInst>(MD->getMemoryInst())) {
1321 assert(!
I.mayReadOrWriteMemory() &&
"unhandled aliasing");
1344 if (
auto *
GEP = dyn_cast<GetElementPtrInst>(&
I)) {
1353 for (
const User *U :
GEP->users()) {
1357 (!isa<StoreInst>(UI) && !isa<LoadInst>(UI))))
1375 bool &FoldableInLoop,
bool LoopNestMode) {
1378 for (
const User *U :
I.users()) {
1380 if (
const PHINode *PN = dyn_cast<PHINode>(UI)) {
1388 if (isa<CallInst>(
I))
1389 if (!BlockColors.empty() &&
1390 BlockColors.find(
const_cast<BasicBlock *
>(BB))->second.size() != 1)
1394 while (isa<PHINode>(UI) && UI->
hasOneUser() &&
1398 UI = cast<Instruction>(UI->
user_back());
1405 FoldableInLoop =
true;
1418 if (
auto *CI = dyn_cast<CallInst>(&
I)) {
1425 for (
unsigned BundleIdx = 0, BundleEnd = CI->getNumOperandBundles();
1426 BundleIdx != BundleEnd; ++BundleIdx) {
1434 if (!BlockColors.empty()) {
1435 const ColorVector &CV = BlockColors.find(&ExitBlock)->second;
1436 assert(CV.
size() == 1 &&
"non-unique color for exit block!");
1449 if (!
I.getName().empty())
1450 New->setName(
I.getName() +
".le");
1457 if (
auto *MemDef = dyn_cast<MemoryDef>(NewMemAcc))
1460 auto *MemUse = cast<MemoryUse>(NewMemAcc);
1473 for (
Use &
Op : New->operands())
1475 auto *OInst = cast<Instruction>(
Op.get());
1478 OInst->getName() +
".lcssa");
1491 I.eraseFromParent();
1500 I.moveBefore(&Dest);
1514 "Expect only trivially replaceable PHI");
1517 auto It = SunkCopies.
find(ExitBlock);
1518 if (It != SunkCopies.
end())
1522 *
I, *ExitBlock, *TPN, LI, SafetyInfo, MSSAU);
1537 if (isa<IndirectBrInst>(BBPred->getTerminator()))
1554 assert(ExitBlockSet.
count(ExitBB) &&
"Expect the PHI is in an exit block.");
1590 while (!PredBBs.
empty()) {
1593 "Expect all predecessors are in the loop");
1596 ExitBB, PredBB,
".split.loop.exit", DT, LI, MSSAU,
true);
1600 if (!BlockColors.empty())
1618 bool Changed =
false;
1625 auto *
User = cast<Instruction>(*UI);
1626 Use &U = UI.getUse();
1664 UI =
I.user_begin();
1668 if (VisitedUsers.
empty())
1673 <<
"sinking " <<
ore::NV(
"Inst", &
I);
1675 if (isa<LoadInst>(
I))
1677 else if (isa<CallInst>(
I))
1697 for (
auto *UI :
Users) {
1698 auto *
User = cast<Instruction>(UI);
1705 "The LCSSA PHI is not in an exit block!");
1709 PN, &
I, LI, SunkCopies, SafetyInfo, CurLoop, MSSAU);
1711 New->dropLocation();
1741 if ((
I.hasMetadataOtherThanDebugLoc() || isa<CallInst>(
I)) &&
1746 I.dropUBImplyingAttrsAndMetadata();
1748 if (isa<PHINode>(
I))
1755 I.updateLocationAfterHoist();
1757 if (isa<LoadInst>(
I))
1759 else if (isa<CallInst>(
I))
1772 if (AllowSpeculation &&
1776 bool GuaranteedToExecute =
1779 if (!GuaranteedToExecute) {
1780 auto *LI = dyn_cast<LoadInst>(&Inst);
1784 DEBUG_TYPE,
"LoadWithLoopInvariantAddressCondExecuted", LI)
1785 <<
"failed to hoist load with loop-invariant address "
1786 "because load is conditionally executed";
1790 return GuaranteedToExecute;
1804 bool UnorderedAtomic;
1807 bool CanInsertStoresInExitBlocks;
1821 I->getName() +
".lcssa");
1837 LoopInsertPts(LIP), MSSAInsertPts(MSSAIP), PredCache(
PIC), MSSAU(MSSAU),
1838 LI(li),
DL(
std::
move(dl)), Alignment(Alignment),
1839 UnorderedAtomic(UnorderedAtomic), AATags(AATags),
1840 SafetyInfo(SafetyInfo),
1841 CanInsertStoresInExitBlocks(CanInsertStoresInExitBlocks),
Uses(Insts) {}
1843 void insertStoresInLoopExitBlocks() {
1849 for (
unsigned i = 0, e = LoopExitBlocks.
size(); i != e; ++i) {
1851 Value *LiveInValue =
SSA.GetValueInMiddleOfBlock(ExitBlock);
1852 LiveInValue = maybeInsertLCSSAPHI(LiveInValue, ExitBlock);
1853 Value *
Ptr = maybeInsertLCSSAPHI(SomePtr, ExitBlock);
1856 if (UnorderedAtomic)
1867 NewID = cast_or_null<DIAssignID>(
1872 NewSI->
setMetadata(LLVMContext::MD_DIAssignID, NewID);
1880 if (!MSSAInsertPoint) {
1887 MSSAInsertPts[i] = NewMemAcc;
1888 MSSAU.
insertDef(cast<MemoryDef>(NewMemAcc),
true);
1893 void doExtraRewritesBeforeFinalDeletion()
override {
1894 if (CanInsertStoresInExitBlocks)
1895 insertStoresInLoopExitBlocks();
1898 void instructionDeleted(
Instruction *
I)
const override {
1904 if (isa<StoreInst>(
I))
1905 return CanInsertStoresInExitBlocks;
1910bool isNotCapturedBeforeOrInLoop(
const Value *V,
const Loop *L,
1918 L->getHeader()->getTerminator(), DT);
1923bool isNotVisibleOnUnwindInLoop(
const Value *Object,
const Loop *L,
1925 bool RequiresNoCaptureBeforeUnwind;
1929 return !RequiresNoCaptureBeforeUnwind ||
1930 isNotCapturedBeforeOrInLoop(Object, L, DT);
1938 isNotCapturedBeforeOrInLoop(Object, L, DT)) ||
1958 bool HasReadsOutsideSet) {
1960 assert(LI !=
nullptr && DT !=
nullptr && CurLoop !=
nullptr &&
1961 SafetyInfo !=
nullptr &&
1962 "Unexpected Input to promoteLoopAccessesToScalars");
1965 dbgs() <<
"Trying to promote set of must-aliased pointers:\n";
1966 for (
Value *
Ptr : PointerMustAliases)
1967 dbgs() <<
" " << *
Ptr <<
"\n";
1969 ++NumPromotionCandidates;
1971 Value *SomePtr = *PointerMustAliases.
begin();
2011 bool DereferenceableInPH =
false;
2012 bool StoreIsGuanteedToExecute =
false;
2013 bool FoundLoadToPromote =
false;
2019 } StoreSafety = StoreSafetyUnknown;
2027 bool SawUnorderedAtomic =
false;
2028 bool SawNotAtomic =
false;
2035 if (HasReadsOutsideSet)
2036 StoreSafety = StoreUnsafe;
2045 if (!isNotVisibleOnUnwindInLoop(Object, CurLoop, DT))
2046 StoreSafety = StoreUnsafe;
2052 Type *AccessTy =
nullptr;
2053 for (
Value *ASIV : PointerMustAliases) {
2054 for (
Use &U : ASIV->uses()) {
2056 Instruction *UI = dyn_cast<Instruction>(U.getUser());
2062 if (
LoadInst *Load = dyn_cast<LoadInst>(UI)) {
2063 if (!Load->isUnordered())
2066 SawUnorderedAtomic |= Load->isAtomic();
2067 SawNotAtomic |= !Load->isAtomic();
2068 FoundLoadToPromote =
true;
2070 Align InstAlignment = Load->getAlign();
2076 if (!DereferenceableInPH || (InstAlignment > Alignment))
2078 *Load, DT, TLI, CurLoop, SafetyInfo, ORE,
2080 DereferenceableInPH =
true;
2081 Alignment = std::max(Alignment, InstAlignment);
2083 }
else if (
const StoreInst *Store = dyn_cast<StoreInst>(UI)) {
2088 if (!Store->isUnordered())
2091 SawUnorderedAtomic |= Store->isAtomic();
2092 SawNotAtomic |= !Store->isAtomic();
2099 Align InstAlignment = Store->getAlign();
2100 bool GuaranteedToExecute =
2102 StoreIsGuanteedToExecute |= GuaranteedToExecute;
2103 if (GuaranteedToExecute) {
2104 DereferenceableInPH =
true;
2105 if (StoreSafety == StoreSafetyUnknown)
2106 StoreSafety = StoreSafe;
2107 Alignment = std::max(Alignment, InstAlignment);
2116 if (StoreSafety == StoreSafetyUnknown &&
2118 return DT->
dominates(Store->getParent(), Exit);
2120 StoreSafety = StoreSafe;
2124 if (!DereferenceableInPH) {
2126 Store->getPointerOperand(), Store->getValueOperand()->getType(),
2127 Store->getAlign(), MDL, Preheader->
getTerminator(), AC, DT, TLI);
2138 if (LoopUses.
empty()) {
2141 }
else if (AATags) {
2153 if (SawUnorderedAtomic && SawNotAtomic)
2163 if (!DereferenceableInPH) {
2164 LLVM_DEBUG(
dbgs() <<
"Not promoting: Not dereferenceable in preheader\n");
2172 if (StoreSafety == StoreSafetyUnknown) {
2174 bool ExplicitlyDereferenceableOnly;
2176 (!ExplicitlyDereferenceableOnly ||
2178 isThreadLocalObject(Object, CurLoop, DT,
TTI))
2179 StoreSafety = StoreSafe;
2184 if (StoreSafety != StoreSafe && !FoundLoadToPromote)
2189 if (StoreSafety == StoreSafe) {
2190 LLVM_DEBUG(
dbgs() <<
"LICM: Promoting load/store of the value: " << *SomePtr
2192 ++NumLoadStorePromoted;
2194 LLVM_DEBUG(
dbgs() <<
"LICM: Promoting load of the value: " << *SomePtr
2202 <<
"Moving accesses to memory location out of the loop";
2206 std::vector<DILocation *> LoopUsesLocs;
2207 for (
auto *U : LoopUses)
2208 LoopUsesLocs.push_back(U->getDebugLoc().get());
2214 LoopPromoter Promoter(SomePtr, LoopUses,
SSA, ExitBlocks, InsertPts,
2215 MSSAInsertPts,
PIC, MSSAU, *LI,
DL, Alignment,
2216 SawUnorderedAtomic, AATags, *SafetyInfo,
2217 StoreSafety == StoreSafe);
2222 if (FoundLoadToPromote || !StoreIsGuanteedToExecute) {
2226 if (SawUnorderedAtomic)
2235 MemoryUse *NewMemUse = cast<MemoryUse>(PreheaderLoadMemoryAccess);
2237 SSA.AddAvailableValue(Preheader, PreheaderLoad);
2246 Promoter.run(LoopUses);
2251 if (PreheaderLoad && PreheaderLoad->
use_empty())
2261 for (
const auto &Access : *Accesses)
2262 if (
const auto *MUD = dyn_cast<MemoryUseOrDef>(&Access))
2263 Fn(MUD->getMemoryInst());
2273 auto IsPotentiallyPromotable = [L](
const Instruction *
I) {
2274 if (
const auto *SI = dyn_cast<StoreInst>(
I))
2275 return L->isLoopInvariant(SI->getPointerOperand());
2276 if (
const auto *LI = dyn_cast<LoadInst>(
I))
2277 return L->isLoopInvariant(LI->getPointerOperand());
2284 if (IsPotentiallyPromotable(
I)) {
2285 AttemptingPromotion.
insert(
I);
2293 if (!AS.isForwardingAliasSet() && AS.isMod() && AS.isMustAlias())
2305 ModRefInfo MR = Pair.getPointer()->aliasesUnknownInst(I, BatchAA);
2314 return !Pair.getPointer()->isRef();
2321 for (
auto [Set, HasReadsOutsideSet] : Sets) {
2323 for (
const auto &ASI : *Set)
2324 PointerMustAliases.
insert(ASI.getValue());
2325 Result.emplace_back(std::move(PointerMustAliases), HasReadsOutsideSet);
2334 bool InvariantGroup) {
2336 if (!Flags.getIsSink()) {
2349 CurLoop->
contains(Source->getBlock()) &&
2350 !(InvariantGroup && Source->getBlock() == CurLoop->
getHeader() && isa<MemoryPhi>(Source));
2370 if (Flags.tooManyMemoryAccesses())
2384 for (
const auto &MA : *Accesses)
2385 if (
const auto *MD = dyn_cast<MemoryDef>(&MA))
2397 using namespace PatternMatch;
2398 Value *Cond1, *Cond2;
2414 if (L.isLoopInvariant(
LHS)) {
2418 if (L.isLoopInvariant(
LHS) || !L.isLoopInvariant(
RHS))
2425 Value *LHS1, *LHS2, *RHS1, *RHS2;
2426 if (!MatchICmpAgainstInvariant(Cond1, P1, LHS1, RHS1) ||
2427 !MatchICmpAgainstInvariant(Cond2, P2, LHS2, RHS2))
2429 if (P1 != P2 || LHS1 != LHS2)
2436 "Relational predicate is either less (or equal) or greater (or equal)!");
2438 ? (UseMin ? Intrinsic::smin : Intrinsic::smax)
2439 : (UseMin ? Intrinsic::umin : Intrinsic::umax);
2440 auto *Preheader = L.getLoopPreheader();
2441 assert(Preheader &&
"Loop is not in simplify form?");
2447 if (isa<SelectInst>(
I))
2450 id, RHS1, RHS2,
nullptr,
StringRef(
"invariant.") +
2452 (UseMin ?
"min" :
"max"));
2459 I.replaceAllUsesWith(NewCond);
2471 auto *
GEP = dyn_cast<GetElementPtrInst>(&
I);
2475 auto *Src = dyn_cast<GetElementPtrInst>(
GEP->getPointerOperand());
2476 if (!Src || !Src->hasOneUse() || !L.contains(Src))
2479 Value *SrcPtr = Src->getPointerOperand();
2480 auto LoopInvariant = [&](
Value *V) {
return L.isLoopInvariant(V); };
2481 if (!L.isLoopInvariant(SrcPtr) || !
all_of(
GEP->indices(), LoopInvariant))
2488 if (
all_of(Src->indices(), LoopInvariant))
2498 bool IsInBounds = Src->isInBounds() &&
GEP->isInBounds() &&
2502 BasicBlock *Preheader = L.getLoopPreheader();
2506 "invariant.gep", IsInBounds);
2508 Value *NewGEP = Builder.
CreateGEP(Src->getSourceElementType(), NewSrc,
2511 GEP->replaceAllUsesWith(NewGEP);
2524 assert(!L.isLoopInvariant(VariantLHS) &&
"Precondition.");
2525 assert(L.isLoopInvariant(InvariantRHS) &&
"Precondition.");
2528 using namespace PatternMatch;
2529 Value *VariantOp, *InvariantOp;
2535 if (L.isLoopInvariant(VariantOp))
2537 if (L.isLoopInvariant(VariantOp) || !L.isLoopInvariant(InvariantOp))
2544 auto &
DL = L.getHeader()->getModule()->getDataLayout();
2545 bool ProvedNoOverflowAfterReassociate =
2549 if (!ProvedNoOverflowAfterReassociate)
2551 auto *Preheader = L.getLoopPreheader();
2552 assert(Preheader &&
"Loop is not in simplify form?");
2554 Value *NewCmpOp = Builder.
CreateSub(InvariantRHS, InvariantOp,
"invariant.op",
2571 assert(!L.isLoopInvariant(VariantLHS) &&
"Precondition.");
2572 assert(L.isLoopInvariant(InvariantRHS) &&
"Precondition.");
2575 using namespace PatternMatch;
2576 Value *VariantOp, *InvariantOp;
2580 bool VariantSubtracted =
false;
2584 if (L.isLoopInvariant(VariantOp)) {
2586 VariantSubtracted =
true;
2589 if (L.isLoopInvariant(VariantOp) || !L.isLoopInvariant(InvariantOp))
2597 auto &
DL = L.getHeader()->getModule()->getDataLayout();
2599 if (VariantSubtracted) {
2610 auto *Preheader = L.getLoopPreheader();
2611 assert(Preheader &&
"Loop is not in simplify form?");
2615 ? Builder.
CreateSub(InvariantOp, InvariantRHS,
"invariant.op",
2617 : Builder.
CreateAdd(InvariantOp, InvariantRHS,
"invariant.op",
2630 using namespace PatternMatch;
2641 if (L.isLoopInvariant(
LHS)) {
2652 if (
hoistAdd(Pred,
LHS,
RHS, cast<ICmpInst>(
I), L, SafetyInfo, MSSAU, AC, DT))
2655 if (
hoistSub(Pred,
LHS,
RHS, cast<ICmpInst>(
I), L, SafetyInfo, MSSAU, AC, DT))
2670 using namespace PatternMatch;
2671 Value *VariantOp =
nullptr, *InvariantOp =
nullptr;
2674 !
I.hasAllowReassoc() || !
I.hasNoSignedZeros())
2676 if (L.isLoopInvariant(VariantOp))
2678 if (L.isLoopInvariant(VariantOp) || !L.isLoopInvariant(InvariantOp))
2680 Value *Factor = InvariantOp;
2685 if (
BinaryOperator *VariantBinOp = dyn_cast<BinaryOperator>(VariantOp))
2687 while (!Worklist.
empty()) {
2697 if (BO->
getOpcode() != Instruction::FMul || L.isLoopInvariant(BO))
2701 if (L.isLoopInvariant(U0))
2703 else if (L.isLoopInvariant(U1))
2710 if (Changes.
empty())
2714 auto *Preheader = L.getLoopPreheader();
2715 assert(Preheader &&
"Loop is not in simplify form?");
2717 for (
auto *U : Changes) {
2718 assert(L.isLoopInvariant(U->get()));
2719 Instruction *Ins = cast<Instruction>(U->getUser());
2720 U->set(Builder.
CreateFMulFMF(U->get(), Factor, Ins,
"factor.op.fmul"));
2722 I.replaceAllUsesWith(VariantOp);
2741 if (
hoistGEP(
I, L, SafetyInfo, MSSAU, AC, DT)) {
2756 ++NumFPAssociationsHoisted;
2767 assert(CurLoop->
contains(BB) &&
"Only valid if BB is IN the loop");
unsigned const MachineRegisterInfo * MRI
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
This file contains the declarations for the subclasses of Constant, which represent the different fla...
Rewrite Partial Register Uses
This file provides various utilities for inspecting and working with the control flow graph in LLVM I...
iv Induction Variable Users
static bool isNotUsedOrFoldableInLoop(const Instruction &I, const Loop *CurLoop, const LoopSafetyInfo *SafetyInfo, TargetTransformInfo *TTI, bool &FoldableInLoop, bool LoopNestMode)
Return true if the only users of this instruction are outside of the loop.
static bool hoistGEP(Instruction &I, Loop &L, ICFLoopSafetyInfo &SafetyInfo, MemorySSAUpdater &MSSAU, AssumptionCache *AC, DominatorTree *DT)
Reassociate gep (gep ptr, idx1), idx2 to gep (gep ptr, idx2), idx1 if this allows hoisting the inner ...
static cl::opt< bool > SingleThread("licm-force-thread-model-single", cl::Hidden, cl::init(false), cl::desc("Force thread model single in LICM pass"))
static void splitPredecessorsOfLoopExit(PHINode *PN, DominatorTree *DT, LoopInfo *LI, const Loop *CurLoop, LoopSafetyInfo *SafetyInfo, MemorySSAUpdater *MSSAU)
static cl::opt< unsigned > FPAssociationUpperLimit("licm-max-num-fp-reassociations", cl::init(5U), cl::Hidden, cl::desc("Set upper limit for the number of transformations performed " "during a single round of hoisting the reassociated expressions."))
static bool isFoldableInLoop(const Instruction &I, const Loop *CurLoop, const TargetTransformInfo *TTI)
Return true if the instruction is foldable in the loop.
static bool hoistMinMax(Instruction &I, Loop &L, ICFLoopSafetyInfo &SafetyInfo, MemorySSAUpdater &MSSAU)
Try to simplify things like (A < INV_1 AND icmp A < INV_2) into (A < min(INV_1, INV_2)),...
static Instruction * cloneInstructionInExitBlock(Instruction &I, BasicBlock &ExitBlock, PHINode &PN, const LoopInfo *LI, const LoopSafetyInfo *SafetyInfo, MemorySSAUpdater &MSSAU)
static cl::opt< bool > ControlFlowHoisting("licm-control-flow-hoisting", cl::Hidden, cl::init(false), cl::desc("Enable control flow (and PHI) hoisting in LICM"))
static bool pointerInvalidatedByLoop(MemorySSA *MSSA, MemoryUse *MU, Loop *CurLoop, Instruction &I, SinkAndHoistLICMFlags &Flags, bool InvariantGroup)
static bool hoistAdd(ICmpInst::Predicate Pred, Value *VariantLHS, Value *InvariantRHS, ICmpInst &ICmp, Loop &L, ICFLoopSafetyInfo &SafetyInfo, MemorySSAUpdater &MSSAU, AssumptionCache *AC, DominatorTree *DT)
Try to turn things like "LV + C1 < C2" into "LV < C2 - C1".
static MemoryAccess * getClobberingMemoryAccess(MemorySSA &MSSA, BatchAAResults &BAA, SinkAndHoistLICMFlags &Flags, MemoryUseOrDef *MA)
static SmallVector< PointersAndHasReadsOutsideSet, 0 > collectPromotionCandidates(MemorySSA *MSSA, AliasAnalysis *AA, Loop *L)
static void hoist(Instruction &I, const DominatorTree *DT, const Loop *CurLoop, BasicBlock *Dest, ICFLoopSafetyInfo *SafetyInfo, MemorySSAUpdater &MSSAU, ScalarEvolution *SE, OptimizationRemarkEmitter *ORE)
When an instruction is found to only use loop invariant operands that is safe to hoist,...
static bool canSplitPredecessors(PHINode *PN, LoopSafetyInfo *SafetyInfo)
static void moveInstructionBefore(Instruction &I, Instruction &Dest, ICFLoopSafetyInfo &SafetyInfo, MemorySSAUpdater &MSSAU, ScalarEvolution *SE)
static bool sink(Instruction &I, LoopInfo *LI, DominatorTree *DT, const Loop *CurLoop, ICFLoopSafetyInfo *SafetyInfo, MemorySSAUpdater &MSSAU, OptimizationRemarkEmitter *ORE)
When an instruction is found to only be used outside of the loop, this function moves it to the exit ...
static bool hoistAddSub(Instruction &I, Loop &L, ICFLoopSafetyInfo &SafetyInfo, MemorySSAUpdater &MSSAU, AssumptionCache *AC, DominatorTree *DT)
Reassociate and hoist add/sub expressions.
static cl::opt< uint32_t > MaxNumUsesTraversed("licm-max-num-uses-traversed", cl::Hidden, cl::init(8), cl::desc("Max num uses visited for identifying load " "invariance in loop using invariant start (default = 8)"))
static void foreachMemoryAccess(MemorySSA *MSSA, Loop *L, function_ref< void(Instruction *)> Fn)
static bool isLoadInvariantInLoop(LoadInst *LI, DominatorTree *DT, Loop *CurLoop)
static Instruction * sinkThroughTriviallyReplaceablePHI(PHINode *TPN, Instruction *I, LoopInfo *LI, SmallDenseMap< BasicBlock *, Instruction *, 32 > &SunkCopies, const LoopSafetyInfo *SafetyInfo, const Loop *CurLoop, MemorySSAUpdater &MSSAU)
static bool inSubLoop(BasicBlock *BB, Loop *CurLoop, LoopInfo *LI)
Little predicate that returns true if the specified basic block is in a subloop of the current one,...
static bool hoistSub(ICmpInst::Predicate Pred, Value *VariantLHS, Value *InvariantRHS, ICmpInst &ICmp, Loop &L, ICFLoopSafetyInfo &SafetyInfo, MemorySSAUpdater &MSSAU, AssumptionCache *AC, DominatorTree *DT)
Try to reassociate and hoist the following two patterns: LV - C1 < C2 --> LV < C1 + C2,...
static void eraseInstruction(Instruction &I, ICFLoopSafetyInfo &SafetyInfo, MemorySSAUpdater &MSSAU)
static bool isSafeToExecuteUnconditionally(Instruction &Inst, const DominatorTree *DT, const TargetLibraryInfo *TLI, const Loop *CurLoop, const LoopSafetyInfo *SafetyInfo, OptimizationRemarkEmitter *ORE, const Instruction *CtxI, AssumptionCache *AC, bool AllowSpeculation)
Only sink or hoist an instruction if it is not a trapping instruction, or if the instruction is known...
static bool hoistArithmetics(Instruction &I, Loop &L, ICFLoopSafetyInfo &SafetyInfo, MemorySSAUpdater &MSSAU, AssumptionCache *AC, DominatorTree *DT)
Aggregates various functions for hoisting computations out of loop.
static bool isTriviallyReplaceablePHI(const PHINode &PN, const Instruction &I)
Returns true if a PHINode is a trivially replaceable with an Instruction.
std::pair< SmallSetVector< Value *, 8 >, bool > PointersAndHasReadsOutsideSet
static cl::opt< bool > DisablePromotion("disable-licm-promotion", cl::Hidden, cl::init(false), cl::desc("Disable memory promotion in LICM pass"))
Memory promotion is enabled by default.
static bool pointerInvalidatedByBlock(BasicBlock &BB, MemorySSA &MSSA, MemoryUse &MU)
static bool hoistFPAssociation(Instruction &I, Loop &L, ICFLoopSafetyInfo &SafetyInfo, MemorySSAUpdater &MSSAU, AssumptionCache *AC, DominatorTree *DT)
Try to reassociate expressions like ((A1 * B1) + (A2 * B2) + ...) * C where A1, A2,...
This file defines the interface for the loop nest analysis.
Machine Loop Invariant Code Motion
This file exposes an interface to building/using memory SSA to walk memory instructions using a use/d...
Contains a collection of routines for determining if a given instruction is guaranteed to execute if ...
PassInstrumentationCallbacks PIC
#define INITIALIZE_PASS_DEPENDENCY(depName)
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
#define INITIALIZE_PASS_BEGIN(passName, arg, name, cfg, analysis)
This file provides a priority worklist.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines generic set operations that may be used on set's of different types,...
This file defines the 'Statistic' class, which is designed to be an easy way to expose various metric...
#define STATISTIC(VARNAME, DESC)
ModRefInfo getModRefInfoMask(const MemoryLocation &Loc, bool IgnoreLocals=false)
Returns a bitmask that should be unconditionally applied to the ModRef info of a memory location.
MemoryEffects getMemoryEffects(const CallBase *Call)
Return the behavior of the given call site.
void add(Value *Ptr, LocationSize Size, const AAMDNodes &AAInfo)
These methods are used to add different types of instructions to the alias sets.
A container for analyses that lazily runs them and caches their results.
Represent the analysis usage information of a pass.
AnalysisUsage & addRequired()
AnalysisUsage & addPreserved()
Add the specified Pass class to the set of analyses preserved by this pass.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
An immutable pass that tracks lazily created AssumptionCache objects.
A cache of @llvm.assume calls within a function.
LLVM Basic Block Representation.
void replaceSuccessorsPhiUsesWith(BasicBlock *Old, BasicBlock *New)
Update all phi nodes in this basic block's successors to refer to basic block New instead of basic bl...
iterator begin()
Instruction iterator methods.
const_iterator getFirstInsertionPt() const
Returns an iterator to the first instruction in this block that is suitable for inserting a non-PHI i...
const Instruction * getFirstNonPHI() const
Returns a pointer to the first instruction in this block that is not a PHINode instruction.
static BasicBlock * Create(LLVMContext &Context, const Twine &Name="", Function *Parent=nullptr, BasicBlock *InsertBefore=nullptr)
Creates a new BasicBlock.
const BasicBlock * getSingleSuccessor() const
Return the successor of this block if it has a single successor.
const Function * getParent() const
Return the enclosing method, or null if none.
InstListType::iterator iterator
Instruction iterators...
LLVMContext & getContext() const
Get the context in which this basic block lives.
void moveBefore(BasicBlock *MovePos)
Unlink this basic block from its current function and insert it into the function that MovePos lives ...
const Instruction * getTerminator() const LLVM_READONLY
Returns the terminator instruction if the block is well formed or null if the block is not well forme...
bool canSplitPredecessors() const
const Module * getModule() const
Return the module owning the function this basic block belongs to, or nullptr if the function does no...
This class is a wrapper over an AAResults, and it is intended to be used only when there are no IR ch...
ModRefInfo getModRefInfo(const Instruction *I, const std::optional< MemoryLocation > &OptLoc)
BinaryOps getOpcode() const
Conditional or Unconditional Branch instruction.
bool isConditional() const
static BranchInst * Create(BasicBlock *IfTrue, Instruction *InsertBefore=nullptr)
BasicBlock * getSuccessor(unsigned i) const
Value * getCondition() const
Value * getArgOperand(unsigned i) const
This class represents a function call, abstracting a target machine's calling convention.
static CallInst * Create(FunctionType *Ty, Value *F, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
void setPredicate(Predicate P)
Set the predicate for this instruction to the specified value.
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
Predicate getSwappedPredicate() const
For example, EQ->EQ, SLE->SGE, ULT->UGT, OEQ->OEQ, ULE->UGE, OLT->OGT, etc.
Predicate getInversePredicate() const
For example, EQ -> NE, UGT -> ULE, SLT -> SGE, OEQ -> UNE, UGT -> OLE, OLT -> UGE,...
static Constant * get(Type *Ty, double V)
This returns a ConstantFP, or a vector containing a splat of a ConstantFP, for the specified value in...
This is the shared class of boolean and integer constants.
int64_t getSExtValue() const
Return the constant as a 64-bit integer value after it has been sign extended as appropriate for the ...
static DILocation * getMergedLocations(ArrayRef< DILocation * > Locs)
Try to combine the vector of locations passed as input in a single one.
This class represents an Operation in the Expression.
A parsed version of the target data layout string in and methods for querying it.
TypeSize getTypeStoreSize(Type *Ty) const
Returns the maximum number of bytes that may be overwritten by storing the specified type.
iterator find(const_arg_type_t< KeyT > Val)
size_type count(const_arg_type_t< KeyT > Val) const
Return 1 if the specified key is in the map, 0 otherwise.
DomTreeNodeBase * getIDom() const
Analysis pass which computes a DominatorTree.
bool verify(VerificationLevel VL=VerificationLevel::Full) const
verify - checks if the tree is correct.
void changeImmediateDominator(DomTreeNodeBase< NodeT > *N, DomTreeNodeBase< NodeT > *NewIDom)
changeImmediateDominator - This method is used to update the dominator tree information when a node's...
DomTreeNodeBase< NodeT > * addNewBlock(NodeT *BB, NodeT *DomBB)
Add a new node to the dominator tree information.
DomTreeNodeBase< NodeT > * getNode(const NodeT *BB) const
getNode - return the (Post)DominatorTree node for the specified basic block.
bool properlyDominates(const DomTreeNodeBase< NodeT > *A, const DomTreeNodeBase< NodeT > *B) const
properlyDominates - Returns true iff A dominates B and A != B.
Legacy analysis pass which computes a DominatorTree.
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
bool isReachableFromEntry(const Use &U) const
Provide an overload for a Use.
bool dominates(const BasicBlock *BB, const Use &U) const
Return true if the (end of the) basic block BB dominates the use U.
This implementation of LoopSafetyInfo use ImplicitControlFlowTracking to give precise answers on "may...
bool doesNotWriteMemoryBefore(const BasicBlock *BB, const Loop *CurLoop) const
Returns true if we could not execute a memory-modifying instruction before we enter BB under assumpti...
void removeInstruction(const Instruction *Inst)
Inform safety info that we are planning to remove the instruction Inst from its block.
bool isGuaranteedToExecute(const Instruction &Inst, const DominatorTree *DT, const Loop *CurLoop) const override
Returns true if the instruction in a loop is guaranteed to execute at least once (under the assumptio...
bool anyBlockMayThrow() const override
Returns true iff any block of the loop for which this info is contains an instruction that may throw ...
void computeLoopSafetyInfo(const Loop *CurLoop) override
Computes safety information for a loop checks loop body & header for the possibility of may throw exc...
void insertInstructionTo(const Instruction *Inst, const BasicBlock *BB)
Inform the safety info that we are planning to insert a new instruction Inst into the basic block BB.
This instruction compares its operands according to the predicate given to the constructor.
static bool isGE(Predicate P)
Return true if the predicate is SGE or UGE.
static bool isLT(Predicate P)
Return true if the predicate is SLT or ULT.
static bool isGT(Predicate P)
Return true if the predicate is SGT or UGT.
bool isRelational() const
Return true if the predicate is relational (not EQ or NE).
static bool isLE(Predicate P)
Return true if the predicate is SLE or ULE.
Value * CreateFMulFMF(Value *L, Value *R, Instruction *FMFSource, const Twine &Name="")
Copy fast-math-flags from an instruction rather than using the builder's default FMF.
Value * CreateFreeze(Value *V, const Twine &Name="")
Value * CreateSub(Value *LHS, Value *RHS, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)
CallInst * CreateBinaryIntrinsic(Intrinsic::ID ID, Value *LHS, Value *RHS, Instruction *FMFSource=nullptr, const Twine &Name="")
Create a call to intrinsic ID with 2 operands which is mangled on the first type.
Value * CreateAdd(Value *LHS, Value *RHS, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)
void SetInsertPoint(BasicBlock *TheBB)
This specifies that created instructions should be appended to the end of the specified block.
Value * CreateGEP(Type *Ty, Value *Ptr, ArrayRef< Value * > IdxList, const Twine &Name="", bool IsInBounds=false)
Value * CreateICmp(CmpInst::Predicate P, Value *LHS, Value *RHS, const Twine &Name="")
This provides a uniform API for creating instructions and inserting them into a basic block: either a...
void mergeDIAssignID(ArrayRef< const Instruction * > SourceInstructions)
Merge the DIAssignID metadata from this instruction and those attached to instructions in SourceInstr...
bool hasNoSignedZeros() const LLVM_READONLY
Determine whether the no-signed-zeros flag is set.
void insertBefore(Instruction *InsertPos)
Insert an unlinked instruction into a basic block immediately before the specified instruction.
const Module * getModule() const
Return the module owning the function this instruction belongs to or nullptr it the function does not...
void setAAMetadata(const AAMDNodes &N)
Sets the AA metadata on this instruction from the AAMDNodes structure.
bool isEHPad() const
Return true if the instruction is a variety of EH-block.
const BasicBlock * getParent() const
Instruction * user_back()
Specialize the methods defined in Value, as we know that an instruction can only be used by other ins...
MDNode * getMetadata(unsigned KindID) const
Get the metadata of given kind attached to this Instruction.
void setMetadata(unsigned KindID, MDNode *Node)
Set the metadata of the specified kind to the specified node.
AAMDNodes getAAMetadata() const
Returns the AA metadata for this instruction.
void setDebugLoc(DebugLoc Loc)
Set the debug location information for this instruction.
bool hasAllowReassoc() const LLVM_READONLY
Determine whether the allow-reassociation flag is set.
A wrapper class for inspecting calls to intrinsic functions.
Intrinsic::ID getIntrinsicID() const
Return the intrinsic ID of this intrinsic.
void printPipeline(raw_ostream &OS, function_ref< StringRef(StringRef)> MapClassName2PassName)
PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM, LoopStandardAnalysisResults &AR, LPMUpdater &U)
This is an important class for using LLVM in a threaded context.
PreservedAnalyses run(LoopNest &L, LoopAnalysisManager &AM, LoopStandardAnalysisResults &AR, LPMUpdater &U)
void printPipeline(raw_ostream &OS, function_ref< StringRef(StringRef)> MapClassName2PassName)
This class provides an interface for updating the loop pass manager based on mutations to the loop ne...
This is an alternative analysis pass to BlockFrequencyInfoWrapperPass.
static void getLazyBFIAnalysisUsage(AnalysisUsage &AU)
Helper for client passes to set up the analysis usage on behalf of this pass.
This is an alternative analysis pass to BranchProbabilityInfoWrapperPass.
An instruction for reading from memory.
void setAlignment(Align Align)
Value * getPointerOperand()
void setOrdering(AtomicOrdering Ordering)
Sets the ordering constraint of this load instruction.
Analysis pass that exposes the LoopInfo for a function.
bool contains(const LoopT *L) const
Return true if the specified loop is contained within in this loop.
BlockT * getHeader() const
void addBasicBlockToLoop(BlockT *NewBB, LoopInfoBase< BlockT, LoopT > &LI)
This method is used by other analyses to update loop information.
BlockT * getLoopPreheader() const
If there is a preheader for this loop, return it.
ArrayRef< BlockT * > getBlocks() const
Get a list of the basic blocks which make up this loop.
void getUniqueExitBlocks(SmallVectorImpl< BlockT * > &ExitBlocks) const
Return all unique successor blocks of this loop.
LoopT * getParentLoop() const
Return the parent loop if it exists or nullptr for top level loops.
Wrapper class to LoopBlocksDFS that provides a standard begin()/end() interface for the DFS reverse p...
void perform(const LoopInfo *LI)
Traverse the loop blocks and store the DFS result.
void verify(const DominatorTreeBase< BlockT, false > &DomTree) const
LoopT * getLoopFor(const BlockT *BB) const
Return the inner most loop that BB lives in.
The legacy pass manager's analysis pass to compute loop information.
bool wouldBeOutOfLoopUseRequiringLCSSA(const Value *V, const BasicBlock *ExitBB) const
This class represents a loop nest and can be used to query its properties.
Function * getParent() const
Return the function to which the loop-nest belongs.
Loop & getOutermostLoop() const
Return the outermost loop in the loop nest.
Captures loop safety information.
void copyColors(BasicBlock *New, BasicBlock *Old)
Copy colors of block Old into the block New.
const DenseMap< BasicBlock *, ColorVector > & getBlockColors() const
Returns block colors map that is used to update funclet operand bundles.
virtual bool isGuaranteedToExecute(const Instruction &Inst, const DominatorTree *DT, const Loop *CurLoop) const =0
Returns true if the instruction in a loop is guaranteed to execute at least once (under the assumptio...
Represents a single loop in the control flow graph.
bool hasLoopInvariantOperands(const Instruction *I) const
Return true if all the operands of the specified instruction are loop invariant.
bool isLoopInvariant(const Value *V) const
Return true if the specified value is loop invariant.
BasicBlock * getBlock() const
bool doesNotAccessMemory() const
Whether this function accesses no memory.
bool onlyAccessesArgPointees() const
Whether this function only (at most) accesses argument memory.
bool onlyReadsMemory() const
Whether this function only (at most) reads memory.
static MemoryLocation get(const LoadInst *LI)
Return a location with information about the memory reference by the given instruction.
An analysis that produces MemorySSA for a function.
MemorySSA * getMemorySSA() const
Get handle on MemorySSA.
void insertDef(MemoryDef *Def, bool RenameUses=false)
Insert a definition into the MemorySSA IR.
MemoryAccess * createMemoryAccessInBB(Instruction *I, MemoryAccess *Definition, const BasicBlock *BB, MemorySSA::InsertionPlace Point)
Create a MemoryAccess in MemorySSA at a specified point in a block.
void insertUse(MemoryUse *Use, bool RenameUses=false)
void removeMemoryAccess(MemoryAccess *, bool OptimizePhis=false)
Remove a MemoryAccess from MemorySSA, including updating all definitions and uses.
MemoryUseOrDef * createMemoryAccessAfter(Instruction *I, MemoryAccess *Definition, MemoryAccess *InsertPt)
Create a MemoryAccess in MemorySSA after an existing MemoryAccess.
void moveToPlace(MemoryUseOrDef *What, BasicBlock *BB, MemorySSA::InsertionPlace Where)
void wireOldPredecessorsToNewImmediatePredecessor(BasicBlock *Old, BasicBlock *New, ArrayRef< BasicBlock * > Preds, bool IdenticalEdgesWereMerged=true)
A new empty BasicBlock (New) now branches directly to Old.
MemoryAccess * getClobberingMemoryAccess(const Instruction *I, BatchAAResults &AA)
Given a memory Mod/Ref/ModRef'ing instruction, calling this will give you the nearest dominating Memo...
Legacy analysis pass which computes MemorySSA.
Encapsulates MemorySSA, including all data associated with memory accesses.
const AccessList * getBlockAccesses(const BasicBlock *BB) const
Return the list of MemoryAccess's for a given basic block.
MemorySSAWalker * getSkipSelfWalker()
bool dominates(const MemoryAccess *A, const MemoryAccess *B) const
Given two memory accesses in potentially different blocks, determine whether MemoryAccess A dominates...
void verifyMemorySSA(VerificationLevel=VerificationLevel::Fast) const
Verify that MemorySSA is self consistent (IE definitions dominate all uses, uses appear in the right ...
MemoryUseOrDef * getMemoryAccess(const Instruction *I) const
Given a memory Mod/Ref'ing instruction, get the MemorySSA access associated with it.
const DefsList * getBlockDefs(const BasicBlock *BB) const
Return the list of MemoryDef's and MemoryPhi's for a given basic block.
bool locallyDominates(const MemoryAccess *A, const MemoryAccess *B) const
Given two memory accesses in the same basic block, determine whether MemoryAccess A dominates MemoryA...
bool isLiveOnEntryDef(const MemoryAccess *MA) const
Return true if MA represents the live on entry value.
Class that has the common methods + fields of memory uses/defs.
MemoryAccess * getDefiningAccess() const
Get the access that produces the memory state used by this Use.
Represents read-only accesses to memory.
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
void addIncoming(Value *V, BasicBlock *BB)
Add an incoming value to the end of the PHI list.
op_range incoming_values()
void setIncomingBlock(unsigned i, BasicBlock *BB)
static PHINode * Create(Type *Ty, unsigned NumReservedValues, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Constructors - NumReservedValues is a hint for the number of incoming edges that this phi node will h...
BasicBlock * getIncomingBlock(unsigned i) const
Return incoming basic block number i.
int getBasicBlockIndex(const BasicBlock *BB) const
Return the first index of the specified basic block in the value list for this PHI.
unsigned getNumIncomingValues() const
Return the number of incoming edges.
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
Pass interface - Implemented by all 'passes'.
PointerIntPair - This class implements a pair of a pointer and small integer.
static PoisonValue * get(Type *T)
Static factory methods - Return an 'poison' object of the specified type.
PredIteratorCache - This class is an extremely trivial cache for predecessor iterator queries.
size_t size(BasicBlock *BB) const
ArrayRef< BasicBlock * > get(BasicBlock *BB)
A set of analyses that are preserved following a run of a transformation pass.
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
bool empty() const
Determine if the PriorityWorklist is empty or not.
bool insert(const T &X)
Insert a new element into the PriorityWorklist.
Helper class for SSA formation on a set of values defined in multiple blocks.
The main scalar evolution driver.
void forgetBlockAndLoopDispositions(Value *V=nullptr)
Called when the client has changed the disposition of values in a loop or block.
void forgetLoopDispositions()
Called when the client has changed the disposition of values in this loop.
bool remove(const value_type &X)
Remove an item from the set vector.
bool empty() const
Determine if the SetVector is empty or not.
iterator begin()
Get an iterator to the beginning of the SetVector.
bool insert(const value_type &X)
Insert a new element into the SetVector.
Flags controlling how much is checked when sinking or hoisting instructions.
SinkAndHoistLICMFlags(unsigned LicmMssaOptCap, unsigned LicmMssaNoAccForPromotionCap, bool IsSink, Loop &L, MemorySSA &MSSA)
unsigned LicmMssaNoAccForPromotionCap
A version of PriorityWorklist that selects small size optimized data structures for the vector and ma...
bool erase(PtrType Ptr)
erase - If the set contains the specified pointer, remove it and return true, otherwise return false.
size_type count(ConstPtrType Ptr) const
count - Return 1 if the specified pointer is in the set, 0 otherwise.
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
bool contains(ConstPtrType Ptr) const
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
A SetVector that performs no allocations if smaller than a certain size.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
reference emplace_back(ArgTypes &&... Args)
void reserve(size_type N)
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
An instruction for storing to memory.
void setAlignment(Align Align)
void setOrdering(AtomicOrdering Ordering)
Sets the ordering constraint of this store instruction.
static unsigned getPointerOperandIndex()
StringRef - Represent a constant reference to a string, i.e.
Provides information about what library functions are available for the current target.
TinyPtrVector - This class is specialized for cases where there are normally 0 or 1 element in a vect...
The instances of the Type class are immutable: once they are created, they are never changed.
bool isIntegerTy() const
True if this is an instance of IntegerType.
A Use represents the edge between a Value definition and its users.
const Use & getOperandUse(unsigned i) const
void setOperand(unsigned i, Value *Val)
unsigned getNumOperands() const
LLVM Value Representation.
Type * getType() const
All values are typed, get the type of this value.
bool hasOneUser() const
Return true if there is exactly one user of this value.
std::string getNameOrAsOperand() const
bool hasOneUse() const
Return true if there is exactly one use of this value.
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
user_iterator_impl< User > user_iterator
StringRef getName() const
Return a constant reference to the value's name.
void takeName(Value *V)
Transfer the name from V to this value.
constexpr ScalarTy getFixedValue() const
constexpr bool isScalable() const
Returns whether the quantity is scaled by a runtime quantity (vscale).
An efficient, type-erasing, non-owning reference to a callable.
This class implements an extremely fast bulk output stream that can only output to a stream.
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
@ C
The default llvm calling convention, compatible with C.
class_match< BinaryOperator > m_BinOp()
Match an arbitrary binary operation and ignore it.
OverflowingBinaryOp_match< LHS, RHS, Instruction::Sub, OverflowingBinaryOperator::NoSignedWrap > m_NSWSub(const LHS &L, const RHS &R)
BinaryOp_match< LHS, RHS, Instruction::FMul > m_FMul(const LHS &L, const RHS &R)
bool match(Val *V, const Pattern &P)
BinaryOp_match< LHS, RHS, Instruction::FAdd > m_FAdd(const LHS &L, const RHS &R)
CmpClass_match< LHS, RHS, ICmpInst, ICmpInst::Predicate > m_ICmp(ICmpInst::Predicate &Pred, const LHS &L, const RHS &R)
OneUse_match< T > m_OneUse(const T &SubPattern)
auto m_LogicalOr()
Matches L || R where L and R are arbitrary values.
class_match< Value > m_Value()
Match an arbitrary value and ignore it.
OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoSignedWrap > m_NSWAdd(const LHS &L, const RHS &R)
auto m_LogicalAnd()
Matches L && R where L and R are arbitrary values.
initializer< Ty > init(const Ty &Val)
DiagnosticInfoOptimizationBase::Argument NV
This is an optimization pass for GlobalISel generic memory operations.
void ReplaceInstWithInst(BasicBlock *BB, BasicBlock::iterator &BI, Instruction *I)
Replace the instruction specified by BI with the instruction specified by I.
SmallVector< DomTreeNode *, 16 > collectChildrenInLoop(DomTreeNode *N, const Loop *CurLoop)
Does a BFS from a given node to all of its children inside a given loop.
Interval::succ_iterator succ_end(Interval *I)
@ NeverOverflows
Never overflows.
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.
bool canSinkOrHoistInst(Instruction &I, AAResults *AA, DominatorTree *DT, Loop *CurLoop, MemorySSAUpdater &MSSAU, bool TargetExecutesOncePerLoop, SinkAndHoistLICMFlags &LICMFlags, OptimizationRemarkEmitter *ORE=nullptr)
Returns true if is legal to hoist or sink this instruction disregarding the possible introduction of ...
void set_intersect(S1Ty &S1, const S2Ty &S2)
set_intersect(A, B) - Compute A := A ^ B Identical to set_intersection, except that it works on set<>...
void salvageDebugInfo(const MachineRegisterInfo &MRI, MachineInstr &MI)
Assuming the instruction MI is going to be deleted, attempt to salvage debug users of MI by writing t...
void initializeLegacyLICMPassPass(PassRegistry &)
bool isDereferenceableAndAlignedPointer(const Value *V, Type *Ty, Align Alignment, const DataLayout &DL, const Instruction *CtxI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr, const TargetLibraryInfo *TLI=nullptr)
Returns true if V is always a dereferenceable pointer with alignment greater or equal than requested.
bool formLCSSARecursively(Loop &L, const DominatorTree &DT, const LoopInfo *LI, ScalarEvolution *SE)
Put a loop nest into LCSSA form.
bool PointerMayBeCapturedBefore(const Value *V, bool ReturnCaptures, bool StoreCaptures, const Instruction *I, const DominatorTree *DT, bool IncludeI=false, unsigned MaxUsesToExplore=0, const LoopInfo *LI=nullptr)
PointerMayBeCapturedBefore - Return true if this pointer value may be captured by the enclosing funct...
Interval::succ_iterator succ_begin(Interval *I)
succ_begin/succ_end - define methods so that Intervals may be used just like BasicBlocks can with the...
const Value * getUnderlyingObject(const Value *V, unsigned MaxLookup=6)
This method strips off any GEP address adjustments and pointer casts from the specified value,...
iterator_range< early_inc_iterator_impl< detail::IterOfRange< RangeT > > > make_early_inc_range(RangeT &&Range)
Make a range that does early increment to allow mutation of the underlying range without disrupting i...
Interval::pred_iterator pred_end(Interval *I)
bool hoistRegion(DomTreeNode *, AAResults *, LoopInfo *, DominatorTree *, AssumptionCache *, TargetLibraryInfo *, Loop *, MemorySSAUpdater &, ScalarEvolution *, ICFLoopSafetyInfo *, SinkAndHoistLICMFlags &, OptimizationRemarkEmitter *, bool, bool AllowSpeculation)
Walk the specified region of the CFG (defined by all blocks dominated by the specified block,...
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
bool isInstructionTriviallyDead(Instruction *I, const TargetLibraryInfo *TLI=nullptr)
Return true if the result produced by the instruction is not used, and the instruction will return.
bool isGuard(const User *U)
Returns true iff U has semantics of a guard expressed in a form of call of llvm.experimental....
auto reverse(ContainerTy &&C)
OverflowResult computeOverflowForSignedSub(const Value *LHS, const Value *RHS, const SimplifyQuery &SQ)
bool isModSet(const ModRefInfo MRI)
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Interval::pred_iterator pred_begin(Interval *I)
pred_begin/pred_end - define methods so that Intervals may be used just like BasicBlocks can with the...
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
bool isModOrRefSet(const ModRefInfo MRI)
bool isNotVisibleOnUnwind(const Value *Object, bool &RequiresNoCaptureBeforeUnwind)
Return true if Object memory is not visible after an unwind, in the sense that program semantics cann...
void getLoopAnalysisUsage(AnalysisUsage &AU)
Helper to consistently add the set of standard passes to a loop pass's AnalysisUsage.
BasicBlock * SplitBlockPredecessors(BasicBlock *BB, ArrayRef< BasicBlock * > Preds, const char *Suffix, DominatorTree *DT, LoopInfo *LI=nullptr, MemorySSAUpdater *MSSAU=nullptr, bool PreserveLCSSA=false)
This method introduces at least one new basic block into the function and moves some of the predecess...
ModRefInfo
Flags indicating whether a memory access modifies or references memory.
bool VerifyMemorySSA
Enables verification of MemorySSA.
bool salvageKnowledge(Instruction *I, AssumptionCache *AC=nullptr, DominatorTree *DT=nullptr)
Calls BuildAssumeFromInst and if the resulting llvm.assume is valid insert if before I.
bool hasDisableLICMTransformsHint(const Loop *L)
Look for the loop attribute that disables the LICM transformation heuristics.
OverflowResult computeOverflowForSignedAdd(const WithCache< const Value * > &LHS, const WithCache< const Value * > &RHS, const SimplifyQuery &SQ)
void appendLoopsToWorklist(RangeT &&, SmallPriorityWorklist< Loop *, 4 > &)
Utility that implements appending of loops onto a worklist given a range.
bool isIdentifiedFunctionLocal(const Value *V)
Return true if V is umabigously identified at the function-level.
bool isSafeToSpeculativelyExecute(const Instruction *I, const Instruction *CtxI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr, const TargetLibraryInfo *TLI=nullptr)
Return true if the instruction does not have any effects besides calculating the result and does not ...
bool isDereferenceablePointer(const Value *V, Type *Ty, const DataLayout &DL, const Instruction *CtxI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr, const TargetLibraryInfo *TLI=nullptr)
Return true if this is always a dereferenceable pointer.
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
PreservedAnalyses getLoopPassPreservedAnalyses()
Returns the minimum set of Analyses that all loop passes must preserve.
auto find_if(R &&Range, UnaryPredicate P)
Provide wrappers to std::find_if which take ranges instead of having to pass begin/end explicitly.
void erase_if(Container &C, UnaryPredicate P)
Provide a container algorithm similar to C++ Library Fundamentals v2's erase_if which is equivalent t...
auto predecessors(const MachineBasicBlock *BB)
bool sinkRegion(DomTreeNode *, AAResults *, LoopInfo *, DominatorTree *, TargetLibraryInfo *, TargetTransformInfo *, Loop *CurLoop, MemorySSAUpdater &, ICFLoopSafetyInfo *, SinkAndHoistLICMFlags &, OptimizationRemarkEmitter *, Loop *OutermostLoop=nullptr)
Walk the specified region of the CFG (defined by all blocks dominated by the specified block,...
cl::opt< unsigned > SetLicmMssaNoAccForPromotionCap
unsigned pred_size(const MachineBasicBlock *BB)
bool isKnownNonNegative(const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)
Returns true if the give value is known to be non-negative.
bool promoteLoopAccessesToScalars(const SmallSetVector< Value *, 8 > &, SmallVectorImpl< BasicBlock * > &, SmallVectorImpl< BasicBlock::iterator > &, SmallVectorImpl< MemoryAccess * > &, PredIteratorCache &, LoopInfo *, DominatorTree *, AssumptionCache *AC, const TargetLibraryInfo *, TargetTransformInfo *, Loop *, MemorySSAUpdater &, ICFLoopSafetyInfo *, OptimizationRemarkEmitter *, bool AllowSpeculation, bool HasReadsOutsideSet)
Try to promote memory values to scalars by sinking stores out of the loop and moving loads to before ...
cl::opt< unsigned > SetLicmMssaOptCap
bool sinkRegionForLoopNest(DomTreeNode *, AAResults *, LoopInfo *, DominatorTree *, TargetLibraryInfo *, TargetTransformInfo *, Loop *, MemorySSAUpdater &, ICFLoopSafetyInfo *, SinkAndHoistLICMFlags &, OptimizationRemarkEmitter *)
Call sinkRegion on loops contained within the specified loop in order from innermost to outermost.
Type * getLoadStoreType(Value *I)
A helper function that returns the type of a load or store instruction.
bool isWritableObject(const Value *Object, bool &ExplicitlyDereferenceableOnly)
Return true if the Object is writable, in the sense that any location based on this pointer that can ...
Implement std::hash so that hash_code can be used in STL containers.
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
A collection of metadata nodes that might be associated with a memory access used by the alias-analys...
AAMDNodes merge(const AAMDNodes &Other) const
Given two sets of AAMDNodes applying to potentially different locations, determine the best AAMDNodes...
This struct is a compact representation of a valid (non-zero power of two) alignment.
unsigned MssaNoAccForPromotionCap
The adaptor from a function pass to a loop pass computes these analyses and makes them available to t...
TargetTransformInfo & TTI
A lightweight accessor for an operand bundle meant to be passed around by value.
uint32_t getTagID() const
Return the tag of this operand bundle as an integer.
A CRTP mix-in to automatically provide informational APIs needed for passes.