|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
Declarations
include/llvm/Analysis/AliasSetTracker.h 39 class Loop;
include/llvm/Analysis/BlockFrequencyInfoImpl.h 53 class Loop;
include/llvm/Analysis/CodeMetrics.h 23 class Loop;
include/llvm/Analysis/DependenceAnalysis.h 49 class Loop;
include/llvm/Analysis/DivergenceAnalysis.h 28 class Loop;
include/llvm/Analysis/IVDescriptors.h 40 class Loop;
include/llvm/Analysis/Loads.h 23 class Loop;
include/llvm/Analysis/LoopAccessAnalysis.h 34 class Loop;
include/llvm/Analysis/LoopInfo.h 59 class Loop;
include/llvm/Analysis/MustExecute.h 38 class Loop;
include/llvm/Analysis/OptimizationRemarkEmitter.h 26 class Loop;
include/llvm/Analysis/RegionInfo.h 63 class Loop;
include/llvm/Analysis/ScalarEvolutionExpressions.h 35 class Loop;
include/llvm/Analysis/ScalarEvolutionNormalization.h 44 class Loop;
include/llvm/Analysis/SyncDependenceAnalysis.h 29 class Loop;
include/llvm/Analysis/TargetTransformInfo.h 48 class Loop;
include/llvm/Analysis/ValueTracking.h 38 class Loop;
include/llvm/Analysis/VectorUtils.h 138 class Loop;
include/llvm/Transforms/Scalar/IndVarSimplify.h 22 class Loop;
include/llvm/Transforms/Scalar/LoopIdiomRecognize.h 23 class Loop;
include/llvm/Transforms/Scalar/LoopInstSimplify.h 21 class Loop;
include/llvm/Transforms/Scalar/LoopStrengthReduce.h 29 class Loop;
include/llvm/Transforms/Scalar/LoopUnrollAndJamPass.h 18 class Loop;
include/llvm/Transforms/Scalar/LoopUnrollPass.h 21 class Loop;
include/llvm/Transforms/Scalar/WarnMissedTransforms.h 20 class Loop;
include/llvm/Transforms/Utils/Cloning.h 44 class Loop;
include/llvm/Transforms/Utils/CodeExtractor.h 35 class Loop;
include/llvm/Transforms/Utils/LoopRotationUtils.h 20 class Loop;
include/llvm/Transforms/Utils/LoopUtils.h 41 class Loop;
include/llvm/Transforms/Utils/LoopVersioning.h 25 class Loop;
include/llvm/Transforms/Utils/SimplifyIndVar.h 24 class Loop;
include/llvm/Transforms/Utils/UnrollLoop.h 30 class Loop;
include/llvm/Transforms/Vectorize/LoopVectorize.h 70 class Loop;
lib/Target/AArch64/AArch64TargetTransformInfo.h 34 class Loop;
lib/Target/AMDGPU/AMDGPUTargetTransformInfo.h 36 class Loop;
lib/Target/ARM/ARMTargetTransformInfo.h 35 class Loop;
lib/Target/Hexagon/HexagonTargetTransformInfo.h 28 class Loop;
lib/Transforms/Vectorize/VPlanHCFGBuilder.h 33 class Loop;
tools/polly/include/polly/CodeGen/IRBuilder.h 21 class Loop;
tools/polly/include/polly/PolyhedralInfo.h 25 class Loop;
tools/polly/include/polly/Support/ScopHelper.h 23 class Loop;
tools/polly/include/polly/ZoneAlgo.h 25 class Loop;
References
include/llvm/ADT/ArrayRef.h 108 const ArrayRef<U *> &A,
110 std::is_convertible<U *const *, T const *>::value>::type * = nullptr)
118 const SmallVectorTemplateCommon<U *, DummyT> &Vec,
120 std::is_convertible<U *const *, T const *>::value>::type * = nullptr)
include/llvm/ADT/DenseMapInfo.h 39 static inline T* getEmptyKey() {
41 Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
45 static inline T* getTombstoneKey() {
47 Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
51 static unsigned getHashValue(const T *PtrVal) {
56 static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
56 static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
include/llvm/ADT/STLExtras.h 154 auto adl_begin(ContainerTy &&container)
162 auto adl_end(ContainerTy &&container)
178 auto adl_begin(ContainerTy &&container)
184 auto adl_end(ContainerTy &&container)
244 static yes& test(Inner *I, decltype(I->rbegin()) * = nullptr);
250 static const bool value = sizeof(test<Ty>(nullptr)) == sizeof(yes);
261 auto reverse(ContainerTy &&C,
1186 auto find(R &&Range, const T &Val) -> decltype(adl_begin(Range)) {
1224 bool is_contained(R &&Range, const E &Element) {
include/llvm/Analysis/AliasSetTracker.h 348 Loop *L;
361 explicit AliasSetTracker(AliasAnalysis &aa, MemorySSA *mssa, Loop *l)
include/llvm/Analysis/BlockFrequencyInfoImpl.h 549 using LoopT = Loop;
include/llvm/Analysis/CFG.h 150 for (const auto *Lp = LI.getLoopFor(Src); Lp; Lp = Lp->getParentLoop()) {
include/llvm/Analysis/CodeMetrics.h 84 static void collectEphemeralValues(const Loop *L, AssumptionCache *AC,
include/llvm/Analysis/DDG.h 254 DataDependenceGraph(const Loop &L, DependenceInfo &DI);
323 Result run(Loop &L, LoopAnalysisManager &AM, LoopStandardAnalysisResults &AR);
334 PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
include/llvm/Analysis/DependenceAnalysis.h 390 const Loop *AssociatedLoop;
435 const Loop *getAssociatedLoop() const;
438 void setPoint(const SCEV *X, const SCEV *Y, const Loop *CurrentLoop);
442 const SCEV *C, const Loop *CurrentLoop);
445 void setDistance(const SCEV *D, const Loop *CurrentLoop);
515 unsigned mapSrcLoop(const Loop *SrcLoop) const;
519 unsigned mapDstLoop(const Loop *DstLoop) const;
523 bool isLoopInvariant(const SCEV *Expression, const Loop *LoopNest) const;
540 const Loop *LoopNest,
546 const Loop *LoopNest,
552 const Loop *LoopNest,
579 const SCEV *collectUpperBound(const Loop *l, Type *T) const;
584 const SCEVConstant *collectConstantUpperBound(const Loop *l, Type *T) const;
590 const Loop *SrcLoopNest,
592 const Loop *DstLoopNest,
653 const Loop *CurrentLoop,
671 const Loop *CurrentLoop,
690 const Loop *CurrentLoop,
708 const Loop *CurrentLoop,
726 const Loop *CurrentLoop,
743 const Loop *SrcLoop,
744 const Loop *DstLoop,
760 const Loop *SrcLoop,
761 const Loop *DstLoop) const;
903 const Loop *TargetLoop) const;
911 const Loop *TargetLoop) const;
919 const Loop *TargetLoop,
include/llvm/Analysis/DivergenceAnalysis.h 46 DivergenceAnalysis(const Function &F, const Loop *RegionLoop,
51 const Loop *getRegionLoop() const { return RegionLoop; }
136 const Loop *TermLoop);
145 void propagateLoopDivergence(const Loop &ExitingLoop);
151 const Loop *RegionLoop;
157 DenseSet<const Loop *> DivergentLoops;
include/llvm/Analysis/IVDescriptors.h 170 static bool AddReductionVar(PHINode *Phi, RecurrenceKind Kind, Loop *TheLoop,
181 static bool isReductionPHI(PHINode *Phi, Loop *TheLoop,
195 isFirstOrderRecurrence(PHINode *Phi, Loop *TheLoop,
294 isInductionPHI(PHINode *Phi, const Loop *L, ScalarEvolution *SE,
301 static bool isFPInductionPHI(PHINode *Phi, const Loop *L, ScalarEvolution *SE,
310 static bool isInductionPHI(PHINode *Phi, const Loop *L,
include/llvm/Analysis/IVUsers.h 74 void transformToPostInc(const Loop *L);
95 Loop *L;
110 IVUsers(Loop *L, AssumptionCache *AC, LoopInfo *LI, DominatorTree *DT,
124 Loop *getLoop() const { return L; }
140 const SCEV *getStride(const IVStrideUse &IU, const Loop *L) const;
162 bool AddUsersImpl(Instruction *I, SmallPtrSetImpl<Loop*> &SimpleLoopNests);
180 bool runOnLoop(Loop *L, LPPassManager &LPM) override;
195 IVUsers run(Loop &L, LoopAnalysisManager &AM,
include/llvm/Analysis/Loads.h 74 bool isDereferenceableAndAlignedInLoop(LoadInst *LI, Loop *L,
include/llvm/Analysis/LoopAccessAnalysis.h 177 MemoryDepChecker(PredicatedScalarEvolution &PSE, const Loop *L)
265 const Loop *InnermostLoop;
377 void insert(Loop *Lp, Value *Ptr, bool WritePtr, unsigned DepSetId,
518 LoopAccessInfo(Loop *L, ScalarEvolution *SE, const TargetLibraryInfo *TLI,
542 static bool blockNeedsPredication(BasicBlock *BB, Loop *TheLoop,
641 Loop *TheLoop;
693 int64_t getPtrStride(PredicatedScalarEvolution &PSE, Value *Ptr, const Loop *Lp,
738 const LoopAccessInfo &getInfo(Loop *L);
750 DenseMap<Loop *, std::unique_ptr<LoopAccessInfo>> LoopAccessInfoMap;
775 Result run(Loop &L, LoopAnalysisManager &AM, LoopStandardAnalysisResults &AR);
include/llvm/Analysis/LoopAnalysisManager.h 74 typedef AnalysisManager<Loop, LoopStandardAnalysisResults &>
154 typedef OuterAnalysisManagerProxy<FunctionAnalysisManager, Loop,
include/llvm/Analysis/LoopCacheAnalysis.h 31 using LoopVectorTy = SmallVector<Loop *, 8>;
80 unsigned MaxDistance, const Loop &L,
92 CacheCostTy computeRefCost(const Loop &L, unsigned CLS) const;
99 bool isLoopInvariant(const Loop &L) const;
105 bool isConsecutive(const Loop &L, unsigned CLS) const;
113 const Loop &L) const;
117 bool isSimpleAddRecurrence(const SCEV &Subscript, const Loop &L) const;
175 using LoopTripCountTy = std::pair<const Loop *, unsigned>;
176 using LoopCacheCostTy = std::pair<const Loop *, CacheCostTy>;
194 getCacheCost(Loop &Root, LoopStandardAnalysisResults &AR, DependenceInfo &DI,
199 CacheCostTy getLoopCost(const Loop &L) const {
221 CacheCostTy computeLoopCacheCost(const Loop &L,
235 const Loop &L) const;
275 PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
include/llvm/Analysis/LoopInfo.h 75 LoopT *ParentLoop;
77 std::vector<LoopT *> SubLoops;
89 LoopBase(const LoopBase<BlockT, LoopT> &) = delete;
90 const LoopBase<BlockT, LoopT> &
91 operator=(const LoopBase<BlockT, LoopT> &) = delete;
100 for (const LoopT *CurLoop = ParentLoop; CurLoop;
106 LoopT *getParentLoop() const { return ParentLoop; }
109 void setParentLoop(LoopT *L) {
115 bool contains(const LoopT *L) const {
131 template <class InstT> bool contains(const InstT *Inst) const {
136 const std::vector<LoopT *> &getSubLoops() const {
140 std::vector<LoopT *> &getSubLoopsVector() {
144 typedef typename std::vector<LoopT *>::const_iterator iterator;
146 typename std::vector<LoopT *>::const_reverse_iterator reverse_iterator;
325 static void getInnerLoopsInPreorder(const LoopT &L,
327 SmallVector<LoopT *, 4> PreOrderWorklist;
331 LoopT *L = PreOrderWorklist.pop_back_val();
341 SmallVector<const LoopT *, 4> getLoopsInPreorder() const {
342 SmallVector<const LoopT *, 4> PreOrderLoops;
343 const LoopT *CurLoop = static_cast<const LoopT *>(this);
348 SmallVector<LoopT *, 4> getLoopsInPreorder() {
349 SmallVector<LoopT *, 4> PreOrderLoops;
350 LoopT *CurLoop = static_cast<LoopT *>(this);
365 void addBasicBlockToLoop(BlockT *NewBB, LoopInfoBase<BlockT, LoopT> &LI);
371 void replaceChildLoopWith(LoopT *OldChild, LoopT *NewChild);
371 void replaceChildLoopWith(LoopT *OldChild, LoopT *NewChild);
375 void addChildLoop(LoopT *NewChild) {
384 LoopT *removeChildLoop(iterator I) {
387 LoopT *Child = *I;
396 LoopT *removeChildLoop(LoopT *Child) {
396 LoopT *removeChildLoop(LoopT *Child) {
453 void verifyLoopNest(DenseSet<const LoopT *> *Loops) const;
485 for (auto *SubLoop : SubLoops)
499 raw_ostream &operator<<(raw_ostream &OS, const LoopBase<BlockT, LoopT> &Loop) {
509 class Loop : public LoopBase<BasicBlock, Loop> {
622 static Optional<Loop::LoopBounds> getBounds(const Loop &L, PHINode &IndVar,
622 static Optional<Loop::LoopBounds> getBounds(const Loop &L, PHINode &IndVar,
683 LoopBounds(const Loop &Loop, Value &I, Instruction &SI, Value *SV, Value &F,
688 const Loop &L;
850 DenseMap<const BlockT *, LoopT *> BBMap;
851 std::vector<LoopT *> TopLevelLoops;
874 for (auto *L : TopLevelLoops)
886 for (auto *L : TopLevelLoops)
892 template <typename... ArgsTy> LoopT *AllocateLoop(ArgsTy &&... Args) {
893 LoopT *Storage = LoopAllocator.Allocate<LoopT>();
893 LoopT *Storage = LoopAllocator.Allocate<LoopT>();
894 return new (Storage) LoopT(std::forward<ArgsTy>(Args)...);
900 typedef typename std::vector<LoopT *>::const_iterator iterator;
902 typename std::vector<LoopT *>::const_reverse_iterator reverse_iterator;
914 SmallVector<LoopT *, 4> getLoopsInPreorder();
924 SmallVector<LoopT *, 4> getLoopsInReverseSiblingPreorder();
928 LoopT *getLoopFor(const BlockT *BB) const { return BBMap.lookup(BB); }
931 const LoopT *operator[](const BlockT *BB) const { return getLoopFor(BB); }
936 const LoopT *L = getLoopFor(BB);
942 const LoopT *L = getLoopFor(BB);
949 LoopT *removeLoop(iterator I) {
951 LoopT *L = *I;
960 void changeLoopFor(BlockT *BB, LoopT *L) {
970 void changeTopLevelLoop(LoopT *OldLoop, LoopT *NewLoop) {
970 void changeTopLevelLoop(LoopT *OldLoop, LoopT *NewLoop) {
979 void addTopLevelLoop(LoopT *New) {
990 for (LoopT *L = I->second; L; L = L->getParentLoop())
999 static bool isNotAlreadyContainedIn(const LoopT *SubLoop,
1000 const LoopT *ParentLoop) {
1026 void destroy(LoopT *L) {
1038 class LoopInfo : public LoopInfoBase<BasicBlock, Loop> {
1039 typedef LoopInfoBase<BasicBlock, Loop> BaseT;
1066 void erase(Loop *L);
1082 Loop *ToLoop = getLoopFor(I->getParent());
1108 auto *OldLoop = getLoopFor(OldBB);
1109 auto *NewLoop = getLoopFor(NewBB);
1165 typedef const Loop *NodeRef;
1168 static NodeRef getEntryNode(const Loop *L) { return L; }
1174 typedef Loop *NodeRef;
1177 static NodeRef getEntryNode(Loop *L) { return L; }
1234 void printLoop(Loop &L, raw_ostream &OS, const std::string &Banner = "");
1245 MDNode *findOptionMDForLoop(const Loop *TheLoop, StringRef Name);
include/llvm/Analysis/LoopInfoImpl.h 248 LoopT *L = static_cast<LoopT *>(this);
270 typename std::vector<LoopT *>::iterator I = find(SubLoops, OldChild);
418 static void discoverAndMapSubloop(LoopT *L, ArrayRef<BlockT *> Backedges,
419 LoopInfoBase<BlockT, LoopT> *LI,
432 LoopT *Subloop = LI->getLoopFor(PredBB);
448 while (LoopT *Parent = Subloop->getParentLoop())
479 LoopInfoBase<BlockT, LoopT> *LI;
482 PopulateLoopsDFS(LoopInfoBase<BlockT, LoopT> *li) : LI(li) {}
502 LoopT *Subloop = LI->getLoopFor(Block);
556 LoopT *L = AllocateLoop(Header);
562 PopulateLoopsDFS<BlockT, LoopT> DFS(this);
568 SmallVector<LoopT *, 4> PreOrderLoops, PreOrderWorklist;
574 for (LoopT *RootL : reverse(*this)) {
586 SmallVector<LoopT *, 4> PreOrderLoops, PreOrderWorklist;
592 for (LoopT *RootL : *this) {
597 LoopT *L = PreOrderWorklist.pop_back_val();
629 void addInnerLoopsToHeadersMap(DenseMap<BlockT *, const LoopT *> &LoopHeaders,
630 const LoopInfoBase<BlockT, LoopT> &LI,
631 const LoopT &L) {
633 for (LoopT *SL : L)
639 static void compareLoops(const LoopT *L, const LoopT *OtherL,
639 static void compareLoops(const LoopT *L, const LoopT *OtherL,
640 DenseMap<BlockT *, const LoopT *> &OtherLoopHeaders) {
648 const LoopT *ParentL = L, *OtherParentL = OtherL;
656 for (const LoopT *SubL : *L) {
658 const LoopT *OtherSubL = OtherLoopHeaders.lookup(SubH);
683 DenseSet<const LoopT *> Loops;
693 LoopT *L = Entry.second;
696 for (LoopT *ChildLoop : *L)
702 LoopInfoBase<BlockT, LoopT> OtherLI;
708 DenseMap<BlockT *, const LoopT *> OtherLoopHeaders;
709 for (LoopT *L : OtherLI)
715 for (LoopT *L : *this) {
717 const LoopT *OtherL = OtherLoopHeaders.lookup(Header);
include/llvm/Analysis/LoopIterator.h 41 using NodeRef = std::pair<const Loop *, BasicBlock *>;
55 const Loop *L;
58 WrappedSuccIterator(succ_iterator Begin, const Loop *L)
66 const Loop *L = N.first;
74 static NodeRef getEntryNode(const Loop &G) { return {&G, G.getHeader()}; }
106 Loop *L;
115 LoopBlocksDFS(Loop *Container) :
120 Loop *getLoop() const { return L; }
177 LoopBlocksRPO(Loop *Container) : DFS(Container) {}
include/llvm/Analysis/LoopPass.h 39 virtual bool runOnLoop(Loop *L, LPPassManager &LPM) = 0;
45 virtual bool doInitialization(Loop *L, LPPassManager &LPM) {
79 virtual void cloneBasicBlockAnalysis(BasicBlock *F, BasicBlock *T, Loop *L) {}
82 virtual void deleteAnalysisValue(Value *V, Loop *L) {}
87 virtual void deleteAnalysisLoop(Loop *L) {}
93 bool skipLoop(const Loop *L) const;
129 void addLoop(Loop &L);
132 void markLoopAsDeleted(Loop &L);
143 void cloneBasicBlockSimpleAnalysis(BasicBlock *From, BasicBlock *To, Loop *L);
147 void deleteSimpleAnalysisValue(Value *V, Loop *L);
151 void deleteSimpleAnalysisLoop(Loop *L);
154 std::deque<Loop *> LQ;
156 Loop *CurrentLoop;
include/llvm/Analysis/LoopUnrollAnalyzer.h 50 ScalarEvolution &SE, const Loop *L)
82 const Loop *L;
include/llvm/Analysis/MustExecute.h 60 void computeBlockColors(const Loop *CurLoop);
79 bool allLoopPathsLeadToBlock(const Loop *CurLoop, const BasicBlock *BB,
87 virtual void computeLoopSafetyInfo(const Loop *CurLoop) = 0;
93 const Loop *CurLoop) const = 0;
114 virtual void computeLoopSafetyInfo(const Loop *CurLoop);
118 const Loop *CurLoop) const;
143 virtual void computeLoopSafetyInfo(const Loop *CurLoop);
147 const Loop *CurLoop) const;
151 bool doesNotWriteMemoryBefore(const BasicBlock *BB, const Loop *CurLoop)
156 bool doesNotWriteMemoryBefore(const Instruction &I, const Loop *CurLoop)
include/llvm/Analysis/RegionInfo.h 97 using LoopT = Loop;
include/llvm/Analysis/ScalarEvolution.h 550 const SCEV *getAddRecExpr(const SCEV *Start, const SCEV *Step, const Loop *L,
553 const Loop *L, SCEV::NoWrapFlags Flags);
555 const Loop *L, SCEV::NoWrapFlags Flags) {
668 const SCEV *getSCEVAtScope(const SCEV *S, const Loop *L);
671 const SCEV *getSCEVAtScope(Value *V, const Loop *L);
676 bool isLoopEntryGuardedByCond(const Loop *L, ICmpInst::Predicate Pred,
681 bool isLoopBackedgeGuardedByCond(const Loop *L, ICmpInst::Predicate Pred,
689 unsigned getSmallConstantTripCount(const Loop *L);
698 unsigned getSmallConstantTripCount(const Loop *L, BasicBlock *ExitingBlock);
703 unsigned getSmallConstantMaxTripCount(const Loop *L);
711 unsigned getSmallConstantTripMultiple(const Loop *L);
719 unsigned getSmallConstantTripMultiple(const Loop *L,
740 const SCEV *getExitCount(const Loop *L, BasicBlock *ExitingBlock,
753 const SCEV *getBackedgeTakenCount(const Loop *L, ExitCountKind Kind = Exact);
759 const SCEV *getPredicatedBackedgeTakenCount(const Loop *L,
766 const SCEV *getConstantMaxBackedgeTakenCount(const Loop *L) {
772 bool isBackedgeTakenCountMaxOrZero(const Loop *L);
776 bool hasLoopInvariantBackedgeTakenCount(const Loop *L);
789 void forgetLoop(const Loop *L);
795 void forgetTopmostLoop(const Loop *L);
807 void forgetLoopDispositions(const Loop *L) { LoopDispositions.clear(); }
878 std::pair<const SCEV *, const SCEV *> SplitIntoInitAndPostInc(const Loop *L,
929 const SCEV *RHS, const Loop *L,
943 LoopDisposition getLoopDisposition(const SCEV *S, const Loop *L);
947 bool isLoopInvariant(const SCEV *S, const Loop *L);
952 bool isAvailableAtLoopEntry(const SCEV *S, const Loop *L);
958 bool hasComputableLoopEvolution(const SCEV *S, const Loop *L);
1082 const SCEV *rewriteUsingPredicate(const SCEV *S, const Loop *L,
1087 const SCEV *S, const Loop *L,
1329 const SCEV *getExact(const Loop *L, ScalarEvolution *SE,
1358 DenseMap<const Loop *, BackedgeTakenInfo> BackedgeTakenCounts;
1362 DenseMap<const Loop *, BackedgeTakenInfo> PredicatedBackedgeTakenCounts;
1373 DenseMap<const SCEV *, SmallVector<std::pair<const Loop *, const SCEV *>, 2>>
1378 SmallVector<PointerIntPair<const Loop *, 2, LoopDisposition>, 2>>
1395 DenseMap<const Loop *, LoopProperties> LoopPropertiesCache;
1398 LoopProperties getLoopProperties(const Loop *L);
1400 bool loopHasNoSideEffects(const Loop *L) {
1404 bool loopHasNoAbnormalExits(const Loop *L) {
1409 LoopDisposition computeLoopDisposition(const SCEV *S, const Loop *L);
1486 const SCEV *computeSCEVAtScope(const SCEV *S, const Loop *L);
1496 const BackedgeTakenInfo &getBackedgeTakenInfo(const Loop *L);
1500 const BackedgeTakenInfo &getPredicatedBackedgeTakenInfo(const Loop *L);
1505 BackedgeTakenInfo computeBackedgeTakenCount(const Loop *L,
1512 ExitLimit computeExitLimit(const Loop *L, BasicBlock *ExitingBlock,
1525 ExitLimit computeExitLimitFromCond(const Loop *L, Value *ExitCond,
1540 const Loop *L;
1545 ExitLimitCache(const Loop *L, bool ExitIfTrue, bool AllowPredicates)
1548 Optional<ExitLimit> find(const Loop *L, Value *ExitCond, bool ExitIfTrue,
1551 void insert(const Loop *L, Value *ExitCond, bool ExitIfTrue,
1558 const Loop *L, Value *ExitCond,
1562 ExitLimit computeExitLimitFromCondImpl(ExitLimitCacheTy &Cache, const Loop *L,
1572 ExitLimit computeExitLimitFromICmp(const Loop *L, ICmpInst *ExitCond,
1580 ExitLimit computeExitLimitFromSingleExitSwitch(const Loop *L,
1588 const Loop *L,
1598 ExitLimit computeShiftCompareExitLimit(Value *LHS, Value *RHS, const Loop *L,
1606 const SCEV *computeExitCountExhaustively(const Loop *L, Value *Cond,
1613 ExitLimit howFarToZero(const SCEV *V, const Loop *L, bool IsSubExpr,
1619 ExitLimit howFarToNonZero(const SCEV *V, const Loop *L);
1633 ExitLimit howManyLessThans(const SCEV *LHS, const SCEV *RHS, const Loop *L,
1637 ExitLimit howManyGreaterThans(const SCEV *LHS, const SCEV *RHS, const Loop *L,
1727 const Loop *L);
1777 const Loop *L);
1812 bool isAddRecNeverPoison(const Instruction *I, const Loop *L);
1864 const Loop *L, SCEV::NoWrapFlags Flags);
1872 void getUsedLoops(const SCEV *S, SmallPtrSetImpl<const Loop *> &LoopsUsed);
1898 DenseMap<const Loop *, SmallVector<const SCEV *, 4>> LoopUsers;
1902 DenseMap<std::pair<const SCEVUnknown *, const Loop *>,
1969 PredicatedScalarEvolution(ScalarEvolution &SE, Loop &L);
2036 const Loop &L;
include/llvm/Analysis/ScalarEvolutionExpander.h 61 DenseMap<const SCEV *, const Loop *> RelevantLoops;
71 const Loop *IVIncInsertLoop;
180 bool isHighCostExpansion(const SCEV *Expr, Loop *L,
190 PHINode *getOrInsertCanonicalInductionVariable(const Loop *L, Type *Ty);
201 unsigned replaceCongruentIVs(Loop *L, const DominatorTree *DT,
240 void setIVIncInsertPos(const Loop *L, Instruction *Pos) {
304 Loop *L);
319 getRelatedExistingExpansion(const SCEV *S, const Instruction *At, Loop *L);
325 bool isHighCostExpansionHelper(const SCEV *S, Loop *L,
360 const Loop *getRelevantLoop(const SCEV *);
394 bool isNormalAddRecExprPHI(PHINode *PN, Instruction *IncV, const Loop *L);
396 bool isExpandedAddRecExprPHI(PHINode *PN, Instruction *IncV, const Loop *L);
400 const Loop *L,
405 Value *expandIVInc(PHINode *PN, Value *StepV, const Loop *L,
include/llvm/Analysis/ScalarEvolutionExpressions.h 299 const Loop *L;
302 const SCEV *const *O, size_t N, const Loop *l)
307 const Loop *getLoop() const { return L; }
817 using LoopToScevMapT = DenseMap<const Loop *, const SCEV *>;
838 const Loop *L = Expr->getLoop();
include/llvm/Analysis/ScalarEvolutionNormalization.h 48 typedef SmallPtrSet<const Loop *, 2> PostIncLoopSet;
include/llvm/Analysis/SyncDependenceAnalysis.h 40 void visitSuccessor(const BasicBlock &succBlock, const Loop *termLoop,
68 const ConstBlockSet &join_blocks(const Loop &Loop);
78 std::map<const Loop *, std::unique_ptr<ConstBlockSet>> CachedLoopExitJoins;
include/llvm/Analysis/TargetTransformInfo.h 85 HardwareLoopInfo(Loop *L) : L(L) {}
86 Loop *L = nullptr;
507 void getUnrollingPreferences(Loop *L, ScalarEvolution &,
512 bool isHardwareLoopProfitable(Loop *L, ScalarEvolution &SE,
565 bool canSaveCmp(Loop *L, BranchInst **BI, ScalarEvolution *SE, LoopInfo *LI,
575 bool shouldFavorBackedgeIndex(const Loop *L) const;
1192 virtual void getUnrollingPreferences(Loop *L, ScalarEvolution &,
1194 virtual bool isHardwareLoopProfitable(Loop *L, ScalarEvolution &SE,
1208 virtual bool canSaveCmp(Loop *L, BranchInst **BI, ScalarEvolution *SE,
1212 virtual bool shouldFavorBackedgeIndex(const Loop *L) const = 0;
1458 void getUnrollingPreferences(Loop *L, ScalarEvolution &SE,
1462 bool isHardwareLoopProfitable(Loop *L, ScalarEvolution &SE,
1488 bool canSaveCmp(Loop *L, BranchInst **BI,
1497 bool shouldFavorBackedgeIndex(const Loop *L) const override {
include/llvm/Analysis/TargetTransformInfoImpl.h 205 bool isHardwareLoopProfitable(Loop *L, ScalarEvolution &SE,
212 void getUnrollingPreferences(Loop *, ScalarEvolution &,
236 bool canSaveCmp(Loop *L, BranchInst **BI, ScalarEvolution *SE, LoopInfo *LI,
244 bool shouldFavorBackedgeIndex(const Loop *L) const { return false; }
include/llvm/Analysis/ValueTracking.h 532 const Loop *L);
include/llvm/Analysis/VectorUtils.h 172 Value *stripGetElementPtr(Value *Ptr, ScalarEvolution *SE, Loop *Lp);
175 Value *getUniqueCastUse(Value *Ptr, Loop *Lp, Type *Ty);
179 Value *getStrideFromPointer(Value *Ptr, ScalarEvolution *SE, Loop *Lp);
527 InterleavedAccessInfo(PredicatedScalarEvolution &PSE, Loop *L,
592 Loop *TheLoop;
include/llvm/CodeGen/BasicTTIImpl.h 439 void getUnrollingPreferences(Loop *L, ScalarEvolution &SE,
474 for (Loop::block_iterator I = L->block_begin(), E = L->block_end(); I != E;
504 bool isHardwareLoopProfitable(Loop *L, ScalarEvolution &SE,
include/llvm/IR/PassInstrumentation.h 144 bool runBeforePass(const PassT &Pass, const IRUnitT &IR) const {
158 void runAfterPass(const PassT &Pass, const IRUnitT &IR) const {
177 void runBeforeAnalysis(const PassT &Analysis, const IRUnitT &IR) const {
186 void runAfterAnalysis(const PassT &Analysis, const IRUnitT &IR) const {
198 bool invalidate(IRUnitT &, const class llvm::PreservedAnalyses &,
include/llvm/IR/PassManager.h 420 getAnalysisResultUnpackTuple(AnalysisManagerT &AM, IRUnitT &IR,
435 getAnalysisResult(AnalysisManager<IRUnitT, AnalysisArgTs...> &AM, IRUnitT &IR,
435 getAnalysisResult(AnalysisManager<IRUnitT, AnalysisArgTs...> &AM, IRUnitT &IR,
438 PassT, IRUnitT>)(AM, IR, Args,
466 PassManager<IRUnitT, AnalysisManagerT, ExtraArgTs...>> {
489 PreservedAnalyses run(IRUnitT &IR, AnalysisManagerT &AM,
551 detail::PassModel<IRUnitT, PassT, PreservedAnalyses, AnalysisManagerT,
559 detail::PassConcept<IRUnitT, AnalysisManagerT, ExtraArgTs...>;
598 Result run(IRUnitT &, AnalysisManagerT &, ExtraArgTs &&...) {
615 detail::AnalysisResultConcept<IRUnitT, PreservedAnalyses, Invalidator>;
617 detail::AnalysisPassConcept<IRUnitT, PreservedAnalyses, Invalidator,
630 using AnalysisResultListMapT = DenseMap<IRUnitT *, AnalysisResultListT>;
636 DenseMap<std::pair<AnalysisKey *, IRUnitT *>,
667 bool invalidate(IRUnitT &IR, const PreservedAnalyses &PA) {
669 detail::AnalysisResultModel<IRUnitT, PassT, typename PassT::Result,
681 bool invalidate(AnalysisKey *ID, IRUnitT &IR, const PreservedAnalyses &PA) {
689 bool invalidateImpl(AnalysisKey *ID, IRUnitT &IR,
747 void clear(IRUnitT &IR, llvm::StringRef Name) {
777 typename PassT::Result &getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs) {
784 detail::AnalysisResultModel<IRUnitT, PassT, typename PassT::Result,
796 typename PassT::Result *getCachedResult(IRUnitT &IR) const {
805 detail::AnalysisResultModel<IRUnitT, PassT, typename PassT::Result,
832 detail::AnalysisPassModel<IRUnitT, PassT, PreservedAnalyses,
849 template <typename PassT> void invalidate(IRUnitT &IR) {
859 void invalidate(IRUnitT &IR, const PreservedAnalyses &PA) {
861 if (PA.allAnalysesInSetPreserved<AllAnalysesOn<IRUnitT>>())
939 ResultConceptT &getResultImpl(AnalysisKey *ID, IRUnitT &IR,
977 ResultConceptT *getCachedResultImpl(AnalysisKey *ID, IRUnitT &IR) const {
984 void invalidateImpl(AnalysisKey *ID, IRUnitT &IR) {
1163 OuterAnalysisManagerProxy<AnalysisManagerT, IRUnitT, ExtraArgTs...>> {
1174 IRUnitT &IRUnit, const PreservedAnalyses &PA,
1175 typename AnalysisManager<IRUnitT, ExtraArgTs...>::Invalidator &Inv) {
1235 Result run(IRUnitT &, AnalysisManager<IRUnitT, ExtraArgTs...> &,
1235 Result run(IRUnitT &, AnalysisManager<IRUnitT, ExtraArgTs...> &,
1386 PreservedAnalyses run(IRUnitT &Arg, AnalysisManagerT &AM, ExtraArgTs &&...) {
1400 PreservedAnalyses run(IRUnitT &, AnalysisManagerT &, ExtraArgTs &&...) {
1415 PreservedAnalyses run(IRUnitT &IR, AnalysisManagerT &AM, Ts &&... Args) {
1430 if (!PI.runBeforePass<IRUnitT>(P, IR))
include/llvm/IR/PassManagerInternal.h 46 virtual PreservedAnalyses run(IRUnitT &IR, AnalysisManagerT &AM,
60 struct PassModel : PassConcept<IRUnitT, AnalysisManagerT, ExtraArgTs...> {
77 PreservedAnalysesT run(IRUnitT &IR, AnalysisManagerT &AM,
110 virtual bool invalidate(IRUnitT &IR, const PreservedAnalysesT &PA,
128 std::declval<IRUnitT &>(), std::declval<PreservedAnalyses>()))>::Type
168 : AnalysisResultConcept<IRUnitT, PreservedAnalysesT, InvalidatorT> {
191 bool invalidate(IRUnitT &, const PreservedAnalysesT &PA,
195 !PAC.template preservedSet<AllAnalysesOn<IRUnitT>>();
207 : AnalysisResultConcept<IRUnitT, PreservedAnalysesT, InvalidatorT> {
226 bool invalidate(IRUnitT &IR, const PreservedAnalysesT &PA,
247 AnalysisResultConcept<IRUnitT, PreservedAnalysesT, InvalidatorT>>
248 run(IRUnitT &IR, AnalysisManager<IRUnitT, ExtraArgTs...> &AM,
248 run(IRUnitT &IR, AnalysisManager<IRUnitT, ExtraArgTs...> &AM,
262 struct AnalysisPassModel : AnalysisPassConcept<IRUnitT, PreservedAnalysesT,
282 AnalysisResultModel<IRUnitT, PassT, typename PassT::Result,
289 AnalysisResultConcept<IRUnitT, PreservedAnalysesT, InvalidatorT>>
290 run(IRUnitT &IR, AnalysisManager<IRUnitT, ExtraArgTs...> &AM,
290 run(IRUnitT &IR, AnalysisManager<IRUnitT, ExtraArgTs...> &AM,
include/llvm/Passes/PassBuilder.h 743 PassManager<IRUnitT, AnalysisManagerT, ExtraArgTs...> &PM) {
include/llvm/Support/Allocator.h 81 template <typename T> T *Allocate(size_t Num = 1) {
82 return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82 return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
88 !std::is_same<typename std::remove_cv<T>::type, void>::value, void>::type
89 Deallocate(T *Ptr, size_t Num = 1) {
90 Deallocate(static_cast<const void *>(Ptr), Num * sizeof(T));
include/llvm/Support/PointerLikeTypeTraits.h 56 static inline void *getAsVoidPointer(T *P) { return P; }
57 static inline T *getFromVoidPointer(void *P) { return static_cast<T *>(P); }
59 enum { NumLowBitsAvailable = detail::ConstantLog2<alignof(T)>::value };
91 typedef PointerLikeTypeTraits<T *> NonConst;
93 static inline const void *getAsVoidPointer(const T *P) {
96 static inline const T *getFromVoidPointer(const void *P) {
include/llvm/Transforms/Scalar/GuardWidening.h 29 PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
include/llvm/Transforms/Scalar/IVUsersPrinter.h 24 PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
include/llvm/Transforms/Scalar/IndVarSimplify.h 27 PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
include/llvm/Transforms/Scalar/InductiveRangeCheckElimination.h 24 PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
include/llvm/Transforms/Scalar/LICM.h 56 PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
include/llvm/Transforms/Scalar/LoopAccessAnalysisPrinter.h 24 PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
include/llvm/Transforms/Scalar/LoopDeletion.h 28 PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
include/llvm/Transforms/Scalar/LoopIdiomRecognize.h 29 PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
include/llvm/Transforms/Scalar/LoopInstSimplify.h 27 PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
include/llvm/Transforms/Scalar/LoopPassManager.h 67 LPMUpdater &>::run(Loop &InitialL, LoopAnalysisManager &AM,
78 typedef PassManager<Loop, LoopAnalysisManager, LoopStandardAnalysisResults &,
86 struct RequireAnalysisPass<AnalysisT, Loop, LoopAnalysisManager,
89 RequireAnalysisPass<AnalysisT, Loop, LoopAnalysisManager,
91 PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
101 RequireAnalysisPass<AnalysisT, Loop, LoopAnalysisManager,
114 SmallPriorityWorklist<Loop *, 4> &Worklist) {
117 SmallVector<Loop *, 4> PreOrderLoops, PreOrderWorklist;
121 for (Loop *RootL : reverse(Loops)) {
127 Loop *L = PreOrderWorklist.pop_back_val();
166 void markLoopAsDeleted(Loop &L, llvm::StringRef Name) {
181 void addChildLoops(ArrayRef<Loop *> NewChildLoops) {
187 for (Loop *NewL : NewChildLoops)
206 void addSiblingLoops(ArrayRef<Loop *> NewSibLoops) {
208 for (Loop *NewL : NewSibLoops)
236 SmallPriorityWorklist<Loop *, 4> &Worklist;
241 Loop *CurrentL;
247 Loop *ParentL;
250 LPMUpdater(SmallPriorityWorklist<Loop *, 4> &Worklist,
321 SmallPriorityWorklist<Loop *, 4> Worklist;
336 Loop *L = Worklist.pop_back_val();
354 if (!PI.runBeforePass<Loop>(Pass, *L))
360 PI.runAfterPassInvalidated<Loop>(Pass);
362 PI.runAfterPass<Loop>(Pass, *L);
383 PA.preserveSet<AllAnalysesOn<Loop>>();
427 PreservedAnalyses run(Loop &L, LoopAnalysisManager &,
include/llvm/Transforms/Scalar/LoopPredication.h 26 PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
include/llvm/Transforms/Scalar/LoopRotation.h 26 PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
include/llvm/Transforms/Scalar/LoopSimplifyCFG.h 28 PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
include/llvm/Transforms/Scalar/LoopStrengthReduce.h 35 PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
include/llvm/Transforms/Scalar/LoopUnrollAndJamPass.h 28 PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
include/llvm/Transforms/Scalar/LoopUnrollPass.h 44 PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
include/llvm/Transforms/Scalar/SimpleLoopUnswitch.h 68 PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
include/llvm/Transforms/Utils/Cloning.h 246 Loop *cloneLoopWithPreheader(BasicBlock *Before, BasicBlock *LoopDomBB,
247 Loop *OrigLoop, ValueToValueMapTy &VMap,
include/llvm/Transforms/Utils/CodeExtractor.h 130 CodeExtractor(DominatorTree &DT, Loop &L, bool AggregateArgs = false,
include/llvm/Transforms/Utils/LoopRotationUtils.h 33 bool LoopRotation(Loop *L, LoopInfo *LI, const TargetTransformInfo *TTI,
include/llvm/Transforms/Utils/LoopSimplify.h 62 bool simplifyLoop(Loop *L, DominatorTree *DT, LoopInfo *LI, ScalarEvolution *SE,
include/llvm/Transforms/Utils/LoopUtils.h 53 BasicBlock *InsertPreheaderForLoop(Loop *L, DominatorTree *DT, LoopInfo *LI,
61 bool formDedicatedExitBlocks(Loop *L, DominatorTree *DT, LoopInfo *LI,
90 bool formLCSSA(Loop &L, DominatorTree &DT, LoopInfo *LI, ScalarEvolution *SE);
101 bool formLCSSARecursively(Loop &L, DominatorTree &DT, LoopInfo *LI,
121 TargetLibraryInfo *, TargetTransformInfo *, Loop *,
134 TargetLibraryInfo *, Loop *, AliasSetTracker *,
149 void deleteDeadLoop(Loop *L, DominatorTree *DT, ScalarEvolution *SE,
164 Loop *, AliasSetTracker *, MemorySSAUpdater *, ICFLoopSafetyInfo *,
170 const Loop *CurLoop);
173 SmallVector<Instruction *, 8> findDefsUsedOutsideOfLoop(Loop *L);
180 Optional<const MDOperand *> findStringMetadataForLoop(const Loop *TheLoop,
184 llvm::Optional<int> getOptionalIntLoopAttribute(Loop *TheLoop, StringRef Name);
216 bool hasDisableAllTransformsHint(const Loop *L);
219 bool hasDisableLICMTransformsHint(const Loop *L);
250 TransformationMode hasUnrollTransformation(Loop *L);
251 TransformationMode hasUnrollAndJamTransformation(Loop *L);
252 TransformationMode hasVectorizeTransformation(Loop *L);
253 TransformationMode hasDistributeTransformation(Loop *L);
254 TransformationMode hasLICMVersioningTransformation(Loop *L);
260 void addStringMetadataToLoop(Loop *TheLoop, const char *MDString,
266 Optional<unsigned> getLoopEstimatedTripCount(Loop *L);
271 bool hasIterationCountInvariantInParent(Loop *L, ScalarEvolution &SE);
290 Loop *CurLoop, AliasSetTracker *CurAST,
344 bool isKnownNegativeInLoop(const SCEV *S, const Loop *L, ScalarEvolution &SE);
348 bool isKnownNonNegativeInLoop(const SCEV *S, const Loop *L,
352 bool cannotBeMaxInLoop(const SCEV *S, const Loop *L, ScalarEvolution &SE,
356 bool cannotBeMinInLoop(const SCEV *S, const Loop *L, ScalarEvolution &SE,
include/llvm/Transforms/Utils/LoopVersioning.h 41 LoopVersioning(const LoopAccessInfo &LAI, Loop *L, LoopInfo *LI,
67 Loop *getVersionedLoop() { return VersionedLoop; }
71 Loop *getNonVersionedLoop() { return NonVersionedLoop; }
115 Loop *VersionedLoop;
118 Loop *NonVersionedLoop;
include/llvm/Transforms/Utils/SimplifyIndVar.h 54 bool simplifyLoopIVs(Loop *L, ScalarEvolution *SE, DominatorTree *DT,
include/llvm/Transforms/Utils/UnrollLoop.h 37 using NewLoopsMap = SmallDenseMap<const Loop *, Loop *, 4>;
37 using NewLoopsMap = SmallDenseMap<const Loop *, Loop *, 4>;
48 const Loop* addClonedBlockToLoopInfo(BasicBlock *OriginalBB,
81 LoopUnrollResult UnrollLoop(Loop *L, UnrollLoopOptions ULO, LoopInfo *LI,
84 bool PreserveLCSSA, Loop **RemainderLoop = nullptr);
86 bool UnrollRuntimeLoopRemainder(Loop *L, unsigned Count,
92 Loop **ResultLoop = nullptr);
94 void computePeelCount(Loop *L, unsigned LoopSize,
98 bool canPeel(Loop *L);
100 bool peelLoop(Loop *L, unsigned PeelCount, LoopInfo *LI, ScalarEvolution *SE,
103 LoopUnrollResult UnrollAndJamLoop(Loop *L, unsigned Count, unsigned TripCount,
108 Loop **EpilogueLoop = nullptr);
110 bool isSafeToUnrollAndJam(Loop *L, ScalarEvolution &SE, DominatorTree &DT,
113 bool computeUnrollCount(Loop *L, const TargetTransformInfo &TTI,
124 void simplifyLoopAfterUnroll(Loop *L, bool SimplifyIVs, LoopInfo *LI,
131 Loop *L, ScalarEvolution &SE, const TargetTransformInfo &TTI,
139 unsigned ApproximateLoopSize(const Loop *L, unsigned &NumCalls,
include/llvm/Transforms/Vectorize/LoopVectorizationLegality.h 89 LoopVectorizeHints(const Loop *L, bool InterleaveOnlyWhenForced,
95 bool allowVectorization(Function *F, Loop *L,
144 const Loop *TheLoop;
174 bool doesNotMeet(Function *F, Loop *L, const LoopVectorizeHints &Hints);
200 Loop *L, PredicatedScalarEvolution &PSE, DominatorTree *DT,
202 Function *F, std::function<const LoopAccessInfo &(Loop &)> *GetLAA,
323 bool canVectorizeLoopNestCFG(Loop *Lp, bool UseVPlanNativePath);
336 bool canVectorizeLoopCFG(Loop *Lp, bool UseVPlanNativePath);
386 Loop *TheLoop;
408 std::function<const LoopAccessInfo &(Loop &)> *GetLAA;
include/llvm/Transforms/Vectorize/LoopVectorize.h 141 std::function<const LoopAccessInfo &(Loop &)> *GetLAA;
152 std::function<const LoopAccessInfo &(Loop &)> &GetLAA_,
155 bool processLoop(Loop *L);
164 OptimizationRemarkEmitter *ORE, Loop *TheLoop, Instruction *I = nullptr);
lib/Analysis/BranchProbabilityInfo.cpp 469 computeUnlikelySuccessors(const BasicBlock *BB, Loop *L,
578 Loop *L = LI.getLoopFor(BB);
lib/Analysis/CFG.cpp 121 static const Loop *getOutermostLoop(const LoopInfo *LI, const BasicBlock *BB) {
122 const Loop *L = LI->getLoopFor(BB);
124 while (const Loop *Parent = L->getParentLoop())
147 SmallPtrSet<const Loop *, 8> LoopsWithHoles;
150 if (const Loop *L = getOutermostLoop(LI, BB))
155 const Loop *StopLoop = LI ? getOutermostLoop(LI, StopBB) : nullptr;
172 const Loop *Outer = nullptr;
lib/Analysis/CodeMetrics.cpp 71 const Loop *L, AssumptionCache *AC,
lib/Analysis/DDG.cpp 143 DataDependenceGraph::DataDependenceGraph(const Loop &L, DependenceInfo &D)
189 DDGAnalysis::Result DDGAnalysis::run(Loop &L, LoopAnalysisManager &AM,
197 PreservedAnalyses DDGAnalysisPrinterPass::run(Loop &L, LoopAnalysisManager &AM,
lib/Analysis/Delinearization.cpp 84 for (Loop *L = LI->getLoopFor(BB); L != nullptr; L = L->getParentLoop()) {
lib/Analysis/DependenceAnalysis.cpp 363 const Loop *DependenceInfo::Constraint::getAssociatedLoop() const {
370 const Loop *CurLoop) {
378 const SCEV *CC, const Loop *CurLoop) {
387 const Loop *CurLoop) {
742 const Loop *SrcLoop = LI->getLoopFor(SrcBlock);
743 const Loop *DstLoop = LI->getLoopFor(DstBlock);
766 unsigned DependenceInfo::mapSrcLoop(const Loop *SrcLoop) const {
773 unsigned DependenceInfo::mapDstLoop(const Loop *DstLoop) const {
784 const Loop *LoopNest) const {
796 const Loop *LoopNest,
882 bool DependenceInfo::checkSrcSubscript(const SCEV *Src, const Loop *LoopNest,
907 bool DependenceInfo::checkDstSubscript(const SCEV *Dst, const Loop *LoopNest,
933 DependenceInfo::classifyPair(const SCEV *Src, const Loop *SrcLoopNest,
934 const SCEV *Dst, const Loop *DstLoopNest,
1070 const SCEV *DependenceInfo::collectUpperBound(const Loop *L, Type *T) const {
1081 const SCEVConstant *DependenceInfo::collectConstantUpperBound(const Loop *L,
1147 const SCEV *DstConst, const Loop *CurLoop,
1284 const Loop *CurLoop, unsigned Level, FullDependence &Result,
1495 const Loop *CurLoop, unsigned Level,
1705 const Loop *CurLoop, unsigned Level,
1815 const Loop *CurLoop, unsigned Level,
1899 const Loop *SrcLoop, const Loop *DstLoop,
1899 const Loop *SrcLoop, const Loop *DstLoop,
2040 const Loop *Loop1,
2041 const Loop *Loop2) const {
2165 const Loop *CurLoop = SrcAddRec->getLoop();
2187 const Loop *CurLoop = SrcAddRec->getLoop();
2197 const Loop *CurLoop = DstAddRec->getLoop();
2231 const Loop *SrcLoop, *DstLoop;
2433 const Loop *CurLoop = AddRec->getLoop();
2924 const Loop *L = AddRec->getLoop();
2996 const Loop *TargetLoop) const {
3012 const Loop *TargetLoop) const {
3031 const Loop *TargetLoop,
3094 const Loop *CurLoop = CurConstraint.getAssociatedLoop();
3120 const Loop *CurLoop = CurConstraint.getAssociatedLoop();
3194 const Loop *CurLoop = CurConstraint.getAssociatedLoop();
3271 Loop *SrcLoop = LI->getLoopFor(Src->getParent());
3272 Loop *DstLoop = LI->getLoopFor(Dst->getParent());
lib/Analysis/DivergenceAnalysis.cpp 95 const Function &F, const Loop *RegionLoop, const DominatorTree &DT,
143 for (const auto *Loop = LI.getLoopFor(Inst->getParent());
190 auto *DivLoop = LI.getLoopFor(&LoopHeader);
278 const Loop *BranchLoop) {
304 const auto *BranchLoop = LI.getLoopFor(Term.getParent());
325 void DivergenceAnalysis::propagateLoopDivergence(const Loop &ExitingLoop) {
332 const auto *BranchLoop = ExitingLoop.getParentLoop();
lib/Analysis/IVDescriptors.cpp 161 static void collectCastsToIgnore(Loop *TheLoop, Instruction *Exit,
191 Loop *TheLoop, bool HasFunNoNaNAttr,
611 bool RecurrenceDescriptor::isReductionPHI(PHINode *Phi, Loop *TheLoop,
672 PHINode *Phi, Loop *TheLoop,
827 bool InductionDescriptor::isFPInductionPHI(PHINode *Phi, const Loop *TheLoop,
920 const Loop *L = AR->getLoop();
985 bool InductionDescriptor::isInductionPHI(PHINode *Phi, const Loop *TheLoop,
1030 PHINode *Phi, const Loop *TheLoop, ScalarEvolution *SE,
lib/Analysis/IVUsers.cpp 39 IVUsers IVUsersAnalysis::run(Loop &L, LoopAnalysisManager &AM,
59 static bool isInteresting(const SCEV *S, const Instruction *I, const Loop *L,
96 SmallPtrSetImpl<Loop*> &SimpleLoopNests) {
97 Loop *NearestLoop = nullptr;
101 Loop *DomLoop = LI->getLoopFor(DomBB);
129 const Loop *L, DominatorTree *DT) {
168 SmallPtrSetImpl<Loop*> &SimpleLoopNests) {
294 SmallPtrSet<Loop*,16> SimpleLoopNests;
304 IVUsers::IVUsers(Loop *L, AssumptionCache *AC, LoopInfo *LI, DominatorTree *DT,
365 bool IVUsersWrapperPass::runOnLoop(Loop *L, LPPassManager &LPM) {
394 static const SCEVAddRecExpr *findAddRecForLoop(const SCEV *S, const Loop *L) {
411 const SCEV *IVUsers::getStride(const IVStrideUse &IU, const Loop *L) const {
417 void IVStrideUse::transformToPostInc(const Loop *L) {
lib/Analysis/InlineCost.cpp 1920 for (Loop *L : LI) {
lib/Analysis/Loads.cpp 197 bool llvm::isDereferenceableAndAlignedInLoop(LoadInst *LI, Loop *L,
lib/Analysis/LoopAccessAnalysis.cpp 189 void RuntimePointerChecking::insert(Loop *Lp, Value *Ptr, bool WritePtr,
502 AccessAnalysis(const DataLayout &Dl, Loop *TheLoop, AliasAnalysis *AA,
545 Loop *TheLoop, const ValueToValueMap &Strides,
582 const Loop *TheLoop;
621 Loop *L, bool Assume) {
641 const ValueToValueMap &Strides, Value *Ptr, Loop *L) {
695 ScalarEvolution *SE, Loop *TheLoop,
944 PredicatedScalarEvolution &PSE, const Loop *L) {
991 const Loop *Lp, const ValueToValueMap &StridesMap,
2078 bool LoopAccessInfo::blockNeedsPredication(BasicBlock *BB, Loop *TheLoop,
2145 expandBounds(const RuntimePointerChecking::CheckingPtrGroup *CG, Loop *TheLoop,
2344 LoopAccessInfo::LoopAccessInfo(Loop *L, ScalarEvolution *SE,
2400 const LoopAccessInfo &LoopAccessLegacyAnalysis::getInfo(Loop *L) {
2412 for (Loop *TopLevelLoop : *LI)
2413 for (Loop *L : depth_first(TopLevelLoop)) {
2453 LoopAccessInfo LoopAccessAnalysis::run(Loop &L, LoopAnalysisManager &AM,
lib/Analysis/LoopAnalysisManager.cpp 37 SmallVector<Loop *, 4> PreOrderLoops = LI->getLoopsInReverseSiblingPreorder();
63 for (Loop *L : PreOrderLoops) {
85 PA.allAnalysesInSetPreserved<AllAnalysesOn<Loop>>();
93 for (Loop *L : reverse(PreOrderLoops)) {
lib/Analysis/LoopCacheAnalysis.cpp 55 static Loop *getInnerMostLoop(const LoopVectorTy &Loops) {
58 Loop *LastLoop = Loops.back();
59 Loop *ParentLoop = LastLoop->getParentLoop();
75 const Loop &L, ScalarEvolution &SE) {
97 static const SCEV *computeTripCount(const Loop &L, ScalarEvolution &SE) {
197 const Loop &L,
254 CacheCostTy IndexedReference::computeRefCost(const Loop &L,
316 for (Loop *L = LI.getLoopFor(BB); L != nullptr; L = L->getParentLoop()) {
361 bool IndexedReference::isLoopInvariant(const Loop &L) const {
378 bool IndexedReference::isConsecutive(const Loop &L, unsigned CLS) const {
407 const Loop &L) const {
414 const Loop &L) const {
445 const Loop *L = LC.first;
460 for (const Loop *L : Loops) {
470 CacheCost::getCacheCost(Loop &Root, LoopStandardAnalysisResults &AR,
478 for (Loop *L : breadth_first(&Root))
497 for (const Loop *L : Loops) {
515 Loop *InnerMostLoop = getInnerMostLoop(Loops);
576 CacheCost::computeLoopCacheCost(const Loop &L,
615 PreservedAnalyses LoopCachePrinterPass::run(Loop &L, LoopAnalysisManager &AM,
lib/Analysis/LoopInfo.cpp 170 static ICmpInst *getLatchCmpInst(const Loop &L) {
180 static Value *findFinalIVValue(const Loop &L, const PHINode &IndVar,
197 Optional<Loop::LoopBounds> Loop::LoopBounds::getBounds(const Loop &L,
197 Optional<Loop::LoopBounds> Loop::LoopBounds::getBounds(const Loop &L,
226 using Direction = Loop::LoopBounds::Direction;
283 Optional<Loop::LoopBounds> Loop::getBounds(ScalarEvolution &SE) const {
421 static bool isBlockInLCSSAForm(const Loop &L, const BasicBlock &BB,
613 Loop::LocRange Loop::getLocRange() const {
662 Loop &Unloop;
671 DenseMap<Loop *, Loop *> SubloopParents;
671 DenseMap<Loop *, Loop *> SubloopParents;
678 UnloopUpdater(Loop *UL, LoopInfo *LInfo)
688 Loop *getNearestLoop(BasicBlock *BB, Loop *BBLoop);
688 Loop *getNearestLoop(BasicBlock *BB, Loop *BBLoop);
701 Loop *L = LI->getLoopFor(POI);
702 Loop *NL = getNearestLoop(POI, L);
729 Loop *L = LI->getLoopFor(*POI);
730 Loop *NL = getNearestLoop(*POI, L);
745 for (Loop::block_iterator BI = Unloop.block_begin(), BE = Unloop.block_end();
747 Loop *OuterParent = LI->getLoopFor(*BI);
755 for (Loop *OldParent = Unloop.getParentLoop(); OldParent != OuterParent;
766 Loop *Subloop = *std::prev(Unloop.end());
770 if (Loop *Parent = SubloopParents[Subloop])
782 Loop *UnloopUpdater::getNearestLoop(BasicBlock *BB, Loop *BBLoop) {
782 Loop *UnloopUpdater::getNearestLoop(BasicBlock *BB, Loop *BBLoop) {
786 Loop *NearLoop = BBLoop;
788 Loop *Subloop = nullptr;
809 Loop *L = LI->getLoopFor(*I);
857 void LoopInfo::erase(Loop *Unloop) {
865 for (Loop::block_iterator I = Unloop->block_begin(),
906 Loop *ParentLoop = Unloop->getParentLoop();
907 for (Loop::iterator I = ParentLoop->begin();; ++I) {
936 void llvm::printLoop(Loop &L, raw_ostream &OS, const std::string &Banner) {
1002 MDNode *llvm::findOptionMDForLoop(const Loop *TheLoop, StringRef Name) {
lib/Analysis/LoopPass.cpp 49 bool runOnLoop(Loop *L, LPPassManager &) override {
77 void LPPassManager::addLoop(Loop &L) {
98 BasicBlock *To, Loop *L) {
106 void LPPassManager::deleteSimpleAnalysisValue(Value *V, Loop *L) {
119 void LPPassManager::deleteSimpleAnalysisLoop(Loop *L) {
128 static void addLoopIntoQueue(Loop *L, std::deque<Loop *> &LQ) {
128 static void addLoopIntoQueue(Loop *L, std::deque<Loop *> &LQ) {
130 for (Loop *I : reverse(*L))
143 void LPPassManager::markLoopAsDeleted(Loop &L) {
182 for (Loop *L : reverse(*LI))
189 for (Loop *L : LQ) {
389 static std::string getDescription(const Loop &L) {
393 bool LoopPass::skipLoop(const Loop *L) const {
lib/Analysis/MustExecute.cpp 49 void SimpleLoopSafetyInfo::computeLoopSafetyInfo(const Loop *CurLoop) {
60 for (Loop::block_iterator BB = std::next(CurLoop->block_begin()),
76 void ICFLoopSafetyInfo::computeLoopSafetyInfo(const Loop *CurLoop) {
101 void LoopSafetyInfo::computeBlockColors(const Loop *CurLoop) {
116 const Loop *CurLoop) {
158 const Loop *CurLoop, const BasicBlock *BB,
187 bool LoopSafetyInfo::allLoopPathsLeadToBlock(const Loop *CurLoop,
248 const Loop *CurLoop) const {
267 const Loop *CurLoop) const {
273 const Loop *CurLoop) const {
293 const Loop *CurLoop) const {
369 static bool isMustExecuteIn(const Instruction &I, Loop *L, DominatorTree *DT) {
383 DenseMap<const Value*, SmallVector<Loop*, 4> > MustExec;
389 Loop *L = LI.getLoopFor(I.getParent());
402 Loop *L = LI.getLoopFor(I.getParent());
425 for (const Loop *L : Loops) {
lib/Analysis/ScalarEvolution.cpp 702 const Loop *LLoop = LA->getLoop(), *RLoop = RA->getLoop();
1442 const Loop *L = AR->getLoop();
1560 const Loop *L) {
1692 const Loop *L = AR->getLoop();
2036 const Loop *L = AR->getLoop();
2401 bool ScalarEvolution::isAvailableAtLoopEntry(const SCEV *S, const Loop *L) {
2698 const Loop *AddRecLoop = AddRec->getLoop();
2809 const Loop *L, SCEV::NoWrapFlags Flags) {
3036 const Loop *AddRecLoop = AddRec->getLoop();
3393 const Loop *L,
3411 const Loop *L, SCEV::NoWrapFlags Flags) {
3438 const Loop *NestedLoop = NestedAR->getLoop();
4239 static const SCEV *rewrite(const SCEV *S, const Loop *L, ScalarEvolution &SE,
4269 explicit SCEVInitRewriter(const Loop *L, ScalarEvolution &SE)
4272 const Loop *L;
4283 static const SCEV *rewrite(const SCEV *S, const Loop *L, ScalarEvolution &SE) {
4310 explicit SCEVPostIncRewriter(const Loop *L, ScalarEvolution &SE)
4313 const Loop *L;
4324 static const SCEV *rewrite(const SCEV *S, const Loop *L,
4372 explicit SCEVBackedgeConditionFolder(const Loop *L, Value *BECond,
4379 const Loop *L;
4400 static const SCEV *rewrite(const SCEV *S, const Loop *L,
4424 explicit SCEVShiftRewriter(const Loop *L, ScalarEvolution &SE)
4427 const Loop *L;
4621 static const Loop *isIntegerLoopHeaderPHI(const PHINode *PN, LoopInfo &LI) {
4624 const Loop *L = LI.getLoopFor(PN->getParent());
4691 const Loop *L = isIntegerLoopHeaderPHI(PN, LI);
4897 const Loop *L = isIntegerLoopHeaderPHI(PN, LI);
4962 const Loop *L = LI.getLoopFor(PN->getParent());
5004 const Loop *L = LI.getLoopFor(PN->getParent());
5162 static bool IsAvailableOnEntry(const Loop *L, DominatorTree &DT, const SCEV *S,
5168 const Loop *L = nullptr; // The loop BB is in (can be nullptr)
5172 CheckAvailable(const Loop *L, BasicBlock *BB, DominatorTree &DT)
5196 const auto *ARLoop = cast<SCEVAddRecExpr>(S)->getLoop();
5272 const Loop *L = LI.getLoopFor(PN->getParent());
5988 Loop *InnermostContainingLoop = LI.getLoopFor(I->getParent());
6038 bool ScalarEvolution::isAddRecNeverPoison(const Instruction *I, const Loop *L) {
6101 ScalarEvolution::getLoopProperties(const Loop *L) {
6526 unsigned ScalarEvolution::getSmallConstantTripCount(const Loop *L) {
6534 unsigned ScalarEvolution::getSmallConstantTripCount(const Loop *L,
6544 unsigned ScalarEvolution::getSmallConstantMaxTripCount(const Loop *L) {
6550 unsigned ScalarEvolution::getSmallConstantTripMultiple(const Loop *L) {
6571 ScalarEvolution::getSmallConstantTripMultiple(const Loop *L,
6602 const SCEV *ScalarEvolution::getExitCount(const Loop *L,
6615 ScalarEvolution::getPredicatedBackedgeTakenCount(const Loop *L,
6620 const SCEV *ScalarEvolution::getBackedgeTakenCount(const Loop *L,
6631 bool ScalarEvolution::isBackedgeTakenCountMaxOrZero(const Loop *L) {
6637 PushLoopPHIs(const Loop *L, SmallVectorImpl<Instruction *> &Worklist) {
6646 ScalarEvolution::getPredicatedBackedgeTakenInfo(const Loop *L) {
6663 ScalarEvolution::getBackedgeTakenInfo(const Loop *L) {
6669 std::pair<DenseMap<const Loop *, BackedgeTakenInfo>::iterator, bool> Pair =
6749 auto *LoopForUser = LI.getLoopFor(I->getParent());
6787 void ScalarEvolution::forgetLoop(const Loop *L) {
6798 SmallVector<const Loop *, 16> LoopWorklist(1, L);
6812 std::pair<const SCEV *, const Loop *> Entry = I->first;
6853 void ScalarEvolution::forgetTopmostLoop(const Loop *L) {
6854 while (Loop *Parent = L->getParentLoop())
6893 ScalarEvolution::BackedgeTakenInfo::getExact(const Loop *L, ScalarEvolution *SE,
7059 ScalarEvolution::computeBackedgeTakenCount(const Loop *L,
7130 ScalarEvolution::computeExitLimit(const Loop *L, BasicBlock *ExitingBlock,
7170 const Loop *L, Value *ExitCond, bool ExitIfTrue,
7178 ScalarEvolution::ExitLimitCache::find(const Loop *L, Value *ExitCond,
7194 void ScalarEvolution::ExitLimitCache::insert(const Loop *L, Value *ExitCond,
7210 ExitLimitCacheTy &Cache, const Loop *L, Value *ExitCond, bool ExitIfTrue,
7224 ExitLimitCacheTy &Cache, const Loop *L, Value *ExitCond, bool ExitIfTrue,
7356 ScalarEvolution::computeExitLimitFromICmp(const Loop *L,
7455 ScalarEvolution::computeExitLimitFromSingleExitSwitch(const Loop *L,
7494 const Loop *L,
7567 Value *LHS, Value *RHSV, const Loop *L, ICmpInst::Predicate Pred) {
7725 static bool canConstantEvolve(Instruction *I, const Loop *L) {
7743 getConstantEvolvingPHIOperands(Instruction *UseInst, const Loop *L,
7785 static PHINode *getConstantEvolvingPHI(Value *V, const Loop *L) {
7801 static Constant *EvaluateExpression(Value *V, const Loop *L,
7877 const Loop *L) {
7957 const SCEV *ScalarEvolution::computeExitCountExhaustively(const Loop *L,
8024 const SCEV *ScalarEvolution::getSCEVAtScope(const SCEV *V, const Loop *L) {
8025 SmallVector<std::pair<const Loop *, const SCEV *>, 2> &Values =
8145 const SCEV *ScalarEvolution::computeSCEVAtScope(const SCEV *V, const Loop *L) {
8153 const Loop *LI = this->LI[I->getParent()];
8373 const SCEV *ScalarEvolution::getSCEVAtScope(Value *V, const Loop *L) {
8702 ScalarEvolution::howFarToZero(const SCEV *V, const Loop *L, bool ControlsExit,
8831 ScalarEvolution::howFarToNonZero(const SCEV *V, const Loop *L) {
8860 if (Loop *L = LI.getLoopFor(BB))
8930 const Loop *L = AR->getLoop();
9112 ScalarEvolution::SplitIntoInitAndPostInc(const Loop *L, const SCEV *S) {
9126 SmallPtrSet<const Loop *, 8> LoopsUsed;
9142 const Loop *MDL =
9190 const Loop *L = LHS->getLoop();
9272 ICmpInst::Predicate Pred, const SCEV *LHS, const SCEV *RHS, const Loop *L,
9452 ScalarEvolution::isLoopBackedgeGuardedByCond(const Loop *L,
9562 ScalarEvolution::isLoopEntryGuardedByCond(const Loop *L,
9945 const Loop *L = AddRecFoundLHS->getLoop();
10583 const Loop *L, bool IsSigned,
10724 const Loop *L, bool IsSigned,
11477 bool ScalarEvolution::hasLoopInvariantBackedgeTakenCount(const Loop *L) {
11482 const Loop *L) {
11484 for (Loop *I : *L)
11580 const Loop *L = LI.getLoopFor(I.getParent());
11639 for (Loop *I : LI)
11644 ScalarEvolution::getLoopDisposition(const SCEV *S, const Loop *L) {
11663 ScalarEvolution::computeLoopDisposition(const SCEV *S, const Loop *L) {
11742 bool ScalarEvolution::isLoopInvariant(const SCEV *S, const Loop *L) {
11746 bool ScalarEvolution::hasComputableLoopEvolution(const SCEV *S, const Loop *L) {
11868 std::pair<const SCEV *, const Loop *> Entry = I->first;
11893 SmallPtrSetImpl<const Loop *> &LoopsUsed) {
11895 FindUsedLoops(SmallPtrSetImpl<const Loop *> &LoopsUsed)
11897 SmallPtrSetImpl<const Loop *> &LoopsUsed;
11912 SmallPtrSet<const Loop *, 8> LoopsUsed;
11922 SmallVector<Loop *, 8> LoopStack(LI.begin(), LI.end());
11944 auto *L = LoopStack.pop_back_val();
12112 static const SCEV *rewrite(const SCEV *S, const Loop *L, ScalarEvolution &SE,
12163 explicit SCEVPredicateRewriter(const Loop *L, ScalarEvolution &SE,
12211 const Loop *L;
12216 const SCEV *ScalarEvolution::rewriteUsingPredicate(const SCEV *S, const Loop *L,
12222 const SCEV *S, const Loop *L,
12378 Loop &L)
lib/Analysis/ScalarEvolutionExpander.cpp 217 while (const Loop *L = SE.LI.getLoopFor(Builder.GetInsertBlock())) {
546 while (const Loop *L = SE.LI.getLoopFor(Builder.GetInsertBlock())) {
566 while (const Loop *L = SE.LI.getLoopFor(Builder.GetInsertBlock())) {
605 static const Loop *PickMostRelevantLoop(const Loop *A, const Loop *B,
605 static const Loop *PickMostRelevantLoop(const Loop *A, const Loop *B,
605 static const Loop *PickMostRelevantLoop(const Loop *A, const Loop *B,
618 const Loop *SCEVExpander::getRelevantLoop(const SCEV *S) {
634 const Loop *L = nullptr;
642 const Loop *Result = getRelevantLoop(C->getOperand());
646 const Loop *Result = PickMostRelevantLoop(
661 bool operator()(std::pair<const Loop *, const SCEV *> LHS,
662 std::pair<const Loop *, const SCEV *> RHS) const {
695 SmallVector<std::pair<const Loop *, const SCEV *>, 8> OpsAndLoops;
708 const Loop *CurLoop = I->first;
765 SmallVector<std::pair<const Loop *, const SCEV *>, 8> OpsAndLoops;
897 const Loop *L) {
1039 const Loop *L) {
1052 Value *SCEVExpander::expandIVInc(PHINode *PN, Value *StepV, const Loop *L,
1160 const Loop *L,
1340 const Loop *L = S->getLoop();
1500 const Loop *L = S->getLoop();
1836 for (Loop *L = SE.LI.getLoopFor(Builder.GetInsertBlock());;
1925 SCEVExpander::getOrInsertCanonicalInductionVariable(const Loop *L,
1949 SCEVExpander::replaceCongruentIVs(Loop *L, const DominatorTree *DT,
2085 const Instruction *At, Loop *L) {
2095 Loop *L) {
2132 const SCEV *S, Loop *L, const Instruction *At,
lib/Analysis/SyncDependenceAnalysis.cpp 181 void visitSuccessor(const BasicBlock &SuccBlock, const Loop *ParentLoop,
272 auto *BlockLoop = LI.getLoopFor(Block);
333 const ConstBlockSet &SyncDependenceAnalysis::join_blocks(const Loop &Loop) {
lib/Analysis/TargetTransformInfo.cpp 240 Loop *L, ScalarEvolution &SE, AssumptionCache &AC,
246 Loop *L, ScalarEvolution &SE, UnrollingPreferences &UP) const {
276 bool TargetTransformInfo::canSaveCmp(Loop *L, BranchInst **BI,
287 bool TargetTransformInfo::shouldFavorBackedgeIndex(const Loop *L) const {
lib/Analysis/ValueTracking.cpp 3692 Loop *L = LI->getLoopFor(PN->getParent());
4305 const Loop *L) {
lib/Analysis/VectorUtils.cpp 152 Value *llvm::stripGetElementPtr(Value *Ptr, ScalarEvolution *SE, Loop *Lp) {
169 Value *llvm::getUniqueCastUse(Value *Ptr, Loop *Lp, Type *Ty) {
185 Value *llvm::getStrideFromPointer(Value *Ptr, ScalarEvolution *SE, Loop *Lp) {
lib/CodeGen/CodeGenPrepare.cpp 632 SmallVector<Loop *, 16> LoopList(LI->begin(), LI->end());
634 Loop *L = LoopList.pop_back_val();
lib/CodeGen/HardwareLoops.cpp 103 bool TryConvertLoop(Loop *L);
160 Loop *L = nullptr;
192 Loop *L = *I;
202 bool HardwareLoops::TryConvertLoop(Loop *L) {
204 for (Loop::iterator I = L->begin(), E = L->end(); I != E; ++I)
233 Loop *L = HWLoopInfo.L;
281 static bool CanGenerateTest(Loop *L, Value *Count) {
lib/Passes/PassBuilder.cpp 317 PreservedAnalyses run(Loop &L, LoopAnalysisManager &,
331 Result run(Loop &, LoopAnalysisManager &, LoopStandardAnalysisResults &) {
lib/Passes/StandardInstrumentations.cpp 58 if (any_isa<const Loop *>(IR)) {
59 const Loop *L = any_cast<const Loop *>(IR);
59 const Loop *L = any_cast<const Loop *>(IR);
97 void printIR(const Loop *L, StringRef Banner) {
135 if (any_isa<const Loop *>(IR)) {
136 const Loop *L = any_cast<const Loop *>(IR);
136 const Loop *L = any_cast<const Loop *>(IR);
lib/Target/AArch64/AArch64FalkorHWPFFix.cpp 76 bool runOnLoop(Loop &L);
139 for (Loop *L : LI)
146 bool FalkorMarkStridedAccesses::runOnLoop(Loop &L) {
lib/Target/AArch64/AArch64TargetTransformInfo.cpp 721 getFalkorUnrollingPreferences(Loop *L, ScalarEvolution &SE,
768 void AArch64TTIImpl::getUnrollingPreferences(Loop *L, ScalarEvolution &SE,
lib/Target/AArch64/AArch64TargetTransformInfo.h 142 void getUnrollingPreferences(Loop *L, ScalarEvolution &SE,
lib/Target/AMDGPU/AMDGPUAnnotateUniformValues.cpp 94 const Loop *L = LI->getLoopFor(Start);
96 const Loop *P = L;
lib/Target/AMDGPU/AMDGPUTargetTransformInfo.cpp 72 static bool dependsOnLocalPhi(const Loop *L, const Value *Cond,
91 void AMDGPUTTIImpl::getUnrollingPreferences(Loop *L, ScalarEvolution &SE,
691 void GCNTTIImpl::getUnrollingPreferences(Loop *L, ScalarEvolution &SE,
827 void R600TTIImpl::getUnrollingPreferences(Loop *L, ScalarEvolution &SE,
lib/Target/AMDGPU/AMDGPUTargetTransformInfo.h 62 void getUnrollingPreferences(Loop *L, ScalarEvolution &SE,
138 void getUnrollingPreferences(Loop *L, ScalarEvolution &SE,
240 void getUnrollingPreferences(Loop *L, ScalarEvolution &SE,
lib/Target/AMDGPU/SIAnnotateControlFlow.cpp 98 handleLoopCondition(Value *Cond, PHINode *Broken, llvm::Loop *L,
230 Value *Cond, PHINode *Broken, llvm::Loop *L, BranchInst *Term) {
262 llvm::Loop *L = LI->getLoopFor(BB);
292 llvm::Loop *L = LI->getLoopFor(BB);
lib/Target/ARM/ARMTargetTransformInfo.cpp 848 bool ARMTTIImpl::isHardwareLoopProfitable(Loop *L, ScalarEvolution &SE,
1003 void ARMTTIImpl::getUnrollingPreferences(Loop *L, ScalarEvolution &SE,
lib/Target/ARM/ARMTargetTransformInfo.h 96 bool shouldFavorBackedgeIndex(const Loop *L) const {
202 bool isHardwareLoopProfitable(Loop *L, ScalarEvolution &SE,
207 void getUnrollingPreferences(Loop *L, ScalarEvolution &SE,
lib/Target/ARM/MVETailPredication.cpp 52 Loop *L = nullptr;
70 bool runOnLoop(Loop *L, LPPassManager&) override;
111 bool MVETailPredication::runOnLoop(Loop *L, LPPassManager&) {
401 SetVector<Instruction*> &MaybeDead, Loop *L) {
lib/Target/Hexagon/HexagonCommonGEP.cpp 132 bool isInvariantIn(Value *Val, Loop *L);
133 bool isInvariantIn(GepNode *Node, Loop *L);
134 bool isInMainPath(BasicBlock *B, Loop *L);
837 bool HexagonCommonGEP::isInvariantIn(Value *Val, Loop *L) {
847 bool HexagonCommonGEP::isInvariantIn(GepNode *Node, Loop *L) {
854 bool HexagonCommonGEP::isInMainPath(BasicBlock *B, Loop *L) {
865 static BasicBlock *preheader(DominatorTree *DT, Loop *L) {
902 Loop *Lp = LI->getLoopFor(LocB);
lib/Target/Hexagon/HexagonLoopIdiomRecognition.cpp 140 bool runOnLoop(Loop *L, LPPassManager &LPM) override;
144 bool isLegalStore(Loop *CurLoop, StoreInst *SI);
145 void collectStores(Loop *CurLoop, BasicBlock *BB,
147 bool processCopyingStore(Loop *CurLoop, StoreInst *SI, const SCEV *BECount);
148 bool coverLoop(Loop *L, SmallVectorImpl<Instruction*> &Insts) const;
149 bool runOnLoopBlock(Loop *CurLoop, BasicBlock *BB, const SCEV *BECount,
151 bool runOnCountableLoop(Loop *L);
558 explicit PolynomialMultiplyRecognize(Loop *loop, const DataLayout &dl,
614 Loop *CurLoop;
1913 bool HexagonLoopIdiomRecognize::isLegalStore(Loop *CurLoop, StoreInst *SI) {
1967 mayLoopAccessLocation(Value *Ptr, ModRefInfo Access, Loop *L,
1998 void HexagonLoopIdiomRecognize::collectStores(Loop *CurLoop, BasicBlock *BB,
2007 bool HexagonLoopIdiomRecognize::processCopyingStore(Loop *CurLoop,
2171 Loop *ParentL = LF->getLoopFor(Preheader);
2303 bool HexagonLoopIdiomRecognize::coverLoop(Loop *L,
2355 bool HexagonLoopIdiomRecognize::runOnLoopBlock(Loop *CurLoop, BasicBlock *BB,
2378 bool HexagonLoopIdiomRecognize::runOnCountableLoop(Loop *L) {
2407 bool HexagonLoopIdiomRecognize::runOnLoop(Loop *L, LPPassManager &LPM) {
lib/Target/Hexagon/HexagonTargetTransformInfo.cpp 78 void HexagonTTIImpl::getUnrollingPreferences(Loop *L, ScalarEvolution &SE,
lib/Target/Hexagon/HexagonTargetTransformInfo.h 64 void getUnrollingPreferences(Loop *L, ScalarEvolution &SE,
lib/Target/Hexagon/HexagonVectorLoopCarriedReuse.cpp 284 bool runOnLoop(Loop *L, LPPassManager &LPM) override;
289 Loop *CurLoop;
316 bool HexagonVectorLoopCarriedReuse::runOnLoop(Loop *L, LPPassManager &LPM) {
lib/Target/NVPTX/NVPTXTargetTransformInfo.cpp 142 void NVPTXTTIImpl::getUnrollingPreferences(Loop *L, ScalarEvolution &SE,
lib/Target/NVPTX/NVPTXTargetTransformInfo.h 96 void getUnrollingPreferences(Loop *L, ScalarEvolution &SE,
lib/Target/PowerPC/PPCLoopPreIncPrep.cpp 114 bool runOnLoop(Loop *L);
117 bool alreadyPrepared(Loop *L, Instruction* MemI,
135 bool updateFormPrep(Loop *L, SmallVector<Bucket, 16> &Buckets);
143 bool rewriteLoadStores(Loop *L, Bucket &BucketChain,
327 Loop *L, Bucket &BucketChain, SmallSet<BasicBlock *, 16> &BBChanged) {
468 bool PPCLoopPreIncPrep::updateFormPrep(Loop *L,
490 bool PPCLoopPreIncPrep::alreadyPrepared(Loop *L, Instruction* MemI,
542 bool PPCLoopPreIncPrep::runOnLoop(Loop *L) {
lib/Target/PowerPC/PPCTargetTransformInfo.cpp 496 bool PPCTTIImpl::isHardwareLoopProfitable(Loop *L, ScalarEvolution &SE,
519 for (Loop::block_iterator I = L->block_begin(), IE = L->block_end();
555 void PPCTTIImpl::getUnrollingPreferences(Loop *L, ScalarEvolution &SE,
941 bool PPCTTIImpl::canSaveCmp(Loop *L, BranchInst **BI, ScalarEvolution *SE,
945 for (Loop::iterator I = L->begin(), E = L->end(); I != E; ++I)
lib/Target/PowerPC/PPCTargetTransformInfo.h 56 bool isHardwareLoopProfitable(Loop *L, ScalarEvolution &SE,
60 bool canSaveCmp(Loop *L, BranchInst **BI, ScalarEvolution *SE, LoopInfo *LI,
63 void getUnrollingPreferences(Loop *L, ScalarEvolution &SE,
lib/Target/SystemZ/SystemZTargetTransformInfo.cpp 240 void SystemZTTIImpl::getUnrollingPreferences(Loop *L, ScalarEvolution &SE,
lib/Target/SystemZ/SystemZTargetTransformInfo.h 49 void getUnrollingPreferences(Loop *L, ScalarEvolution &SE,
lib/Transforms/IPO/LoopExtractor.cpp 47 bool runOnLoop(Loop *L, LPPassManager &) override;
85 bool LoopExtractor::runOnLoop(Loop *L, LPPassManager &LPM) {
lib/Transforms/IPO/SampleProfile.cpp 1377 Loop *L = LI->getLoopFor(BB);
lib/Transforms/InstCombine/InstructionCombining.cpp 1803 if (Loop *L = LI->getLoopFor(GEP.getParent())) {
lib/Transforms/Instrumentation/InstrProfiling.cpp 185 DenseMap<Loop *, SmallVector<LoadStorePair, 8>> &LoopToCands,
217 auto *TargetLoop = LI.getLoopFor(ExitBlock);
229 DenseMap<Loop *, SmallVector<LoadStorePair, 8>> &LoopToCandidates;
239 DenseMap<Loop *, SmallVector<LoadStorePair, 8>> &LoopToCands,
304 bool allowSpeculativeCounterPromotion(Loop *LP) {
316 unsigned getMaxNumOfPromotionsInLoop(Loop *LP) {
353 auto *TargetLoop = LI.getLoopFor(TargetBlock);
365 DenseMap<Loop *, SmallVector<LoadStorePair, 8>> &LoopToCandidates;
368 Loop &L;
446 DenseMap<Loop *, SmallVector<LoadStorePair, 8>> LoopPromotionCandidates;
459 Loop *ParentLoop = LI.getLoopFor(BB);
465 SmallVector<Loop *, 4> Loops = LI.getLoopsInPreorder();
469 for (auto *Loop : llvm::reverse(Loops)) {
lib/Transforms/Scalar/GuardWidening.cpp 442 Loop *DominatedInstrLoop = LI.getLoopFor(DominatedInstr->getParent());
443 Loop *DominatingGuardLoop = LI.getLoopFor(DominatingGuard->getParent());
820 PreservedAnalyses GuardWideningPass::run(Loop &L, LoopAnalysisManager &AM,
885 bool runOnLoop(Loop *L, LPPassManager &LPM) override {
lib/Transforms/Scalar/IVUsersPrinter.cpp 16 PreservedAnalyses IVUsersPrinterPass::run(Loop &L, LoopAnalysisManager &AM,
lib/Transforms/Scalar/IndVarSimplify.cpp 147 bool handleFloatingPointIV(Loop *L, PHINode *PH);
148 bool rewriteNonIntegerIVs(Loop *L);
150 bool simplifyAndExtend(Loop *L, SCEVExpander &Rewriter, LoopInfo *LI);
152 bool optimizeLoopExits(Loop *L, SCEVExpander &Rewriter);
155 bool predicateLoopExits(Loop *L, SCEVExpander &Rewriter);
157 bool canLoopBeDeleted(Loop *L, SmallVector<RewritePhi, 8> &RewritePhiSet);
158 bool rewriteLoopExitValues(Loop *L, SCEVExpander &Rewriter);
159 bool rewriteFirstIterationLoopExitValues(Loop *L);
160 bool hasHardUserWithinLoop(const Loop *L, const Instruction *I) const;
162 bool linearFunctionTestReplace(Loop *L, BasicBlock *ExitingBB,
166 bool sinkUnusedInvariants(Loop *L);
174 bool run(Loop *L);
272 auto *L = LI->getLoopFor(DefI->getParent());
307 bool IndVarSimplify::handleFloatingPointIV(Loop *L, PHINode *PN) {
501 bool IndVarSimplify::rewriteNonIntegerIVs(Loop *L) {
551 bool IndVarSimplify::hasHardUserWithinLoop(const Loop *L, const Instruction *I) const {
584 bool IndVarSimplify::rewriteLoopExitValues(Loop *L, SCEVExpander &Rewriter) {
690 if (auto *EVL = LI->getLoopFor(ExitInsn->getParent()))
749 bool IndVarSimplify::rewriteFirstIterationLoopExitValues(Loop *L) {
819 Loop *L, SmallVector<RewritePhi, 8> &RewritePhiSet) {
972 Loop *L;
1075 for (const Loop *L = LI->getLoopFor(Use->getParent());
1963 bool IndVarSimplify::simplifyAndExtend(Loop *L,
2020 static PHINode *getLoopPhiForCounter(Value *IncV, Loop *L) {
2071 static bool needsLFTR(Loop *L, BasicBlock *ExitingBB) {
2219 static bool isLoopCounter(PHINode* Phi, Loop *L,
2247 static PHINode *FindLoopCounter(Loop *L, BasicBlock *ExitingBB,
2332 const SCEV *ExitCount, bool UsePostInc, Loop *L,
2422 linearFunctionTestReplace(Loop *L, BasicBlock *ExitingBB,
2566 bool IndVarSimplify::sinkUnusedInvariants(Loop *L) {
2657 DominatorTree &DT, Loop *L) {
2682 bool IndVarSimplify::optimizeLoopExits(Loop *L, SCEVExpander &Rewriter) {
2807 bool IndVarSimplify::predicateLoopExits(Loop *L, SCEVExpander &Rewriter) {
2975 bool IndVarSimplify::run(Loop *L) {
3139 PreservedAnalyses IndVarSimplifyPass::run(Loop &L, LoopAnalysisManager &AM,
3163 bool runOnLoop(Loop *L, LPPassManager &LPM) override {
lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp 147 static bool parseRangeCheckICmp(Loop *L, ICmpInst *ICI, ScalarEvolution &SE,
152 extractRangeChecksFromCond(Loop *L, ScalarEvolution &SE, Use &ConditionUse,
224 extractRangeChecksFromBranch(BranchInst *BI, Loop *L, ScalarEvolution &SE,
241 bool run(Loop *L, function_ref<void(Loop *, bool)> LPMAddNewLoop);
241 bool run(Loop *L, function_ref<void(Loop *, bool)> LPMAddNewLoop);
257 bool runOnLoop(Loop *L, LPPassManager &LPM) override;
276 InductiveRangeCheck::parseRangeCheckICmp(Loop *L, ICmpInst *ICI,
336 Loop *L, ScalarEvolution &SE, Use &ConditionUse,
392 BranchInst *BI, Loop *L, ScalarEvolution &SE, BranchProbabilityInfo *BPI,
410 static void DisableAllLoopOptsOnLoop(Loop &L) {
492 Loop &, const char *&);
552 Loop *createClonedLoopStructure(Loop *Original, Loop *Parent,
552 Loop *createClonedLoopStructure(Loop *Original, Loop *Parent,
552 Loop *createClonedLoopStructure(Loop *Original, Loop *Parent,
606 function_ref<void(Loop *, bool)> LPMAddNewLoop;
609 Loop &OriginalLoop;
626 LoopConstrainer(Loop &L, LoopInfo &LI,
627 function_ref<void(Loop *, bool)> LPMAddNewLoop,
646 Loop *L, ScalarEvolution &SE) {
696 Loop *L, ScalarEvolution &SE) {
737 BranchProbabilityInfo *BPI, Loop &L,
1356 Loop *ParentLoop = OriginalLoop.getParentLoop();
1364 Loop *LoopConstrainer::createClonedLoopStructure(Loop *Original, Loop *Parent,
1364 Loop *LoopConstrainer::createClonedLoopStructure(Loop *Original, Loop *Parent,
1364 Loop *LoopConstrainer::createClonedLoopStructure(Loop *Original, Loop *Parent,
1367 Loop &New = *LI.AllocateLoop();
1380 for (Loop *SubLoop : *Original)
1531 Loop *PreL = nullptr, *PostL = nullptr;
1663 const Loop *L = IndVar->getLoop();
1749 PreservedAnalyses IRCEPass::run(Loop &L, LoopAnalysisManager &AM,
1768 bool IRCELegacyPass::runOnLoop(Loop *L, LPPassManager &LPM) {
1785 Loop *L, function_ref<void(Loop *, bool)> LPMAddNewLoop) {
1785 Loop *L, function_ref<void(Loop *, bool)> LPMAddNewLoop) {
lib/Transforms/Scalar/LICM.cpp 134 static bool inSubLoop(BasicBlock *BB, Loop *CurLoop, LoopInfo *LI);
135 static bool isNotUsedOrFreeInLoop(const Instruction &I, const Loop *CurLoop,
138 static void hoist(Instruction &I, const DominatorTree *DT, const Loop *CurLoop,
142 const Loop *CurLoop, ICFLoopSafetyInfo *SafetyInfo,
146 const Loop *CurLoop,
151 AliasSetTracker *CurAST, Loop *CurLoop,
154 Loop *CurLoop,
169 using ASTrackerMapTy = DenseMap<Loop *, std::unique_ptr<AliasSetTracker>>;
170 bool runOnLoop(Loop *L, AliasAnalysis *AA, LoopInfo *LI, DominatorTree *DT,
187 collectAliasInfoForLoop(Loop *L, LoopInfo *LI, AliasAnalysis *AA);
189 collectAliasInfoForLoopWithMSSA(Loop *L, AliasAnalysis *AA,
202 bool runOnLoop(Loop *L, LPPassManager &LPM) override {
266 Loop *L) override;
270 void deleteAnalysisValue(Value *V, Loop *L) override;
273 void deleteAnalysisLoop(Loop *L) override;
277 PreservedAnalyses LICMPass::run(Loop &L, LoopAnalysisManager &AM,
327 Loop *L, AliasAnalysis *AA, LoopInfo *LI, DominatorTree *DT,
496 TargetTransformInfo *TTI, Loop *CurLoop,
574 Loop *CurLoop;
586 ControlFlowHoister(LoopInfo *LI, DominatorTree *DT, Loop *CurLoop,
796 DominatorTree *DT, TargetLibraryInfo *TLI, Loop *CurLoop,
982 Loop *CurLoop) {
1046 const Loop *L) {
1063 bool isOnlyMemoryAccess(const Instruction *I, const Loop *L,
1081 Loop *CurLoop, AliasSetTracker *CurAST,
1298 static bool isFreeInLoop(const Instruction &I, const Loop *CurLoop,
1326 static bool isNotUsedOrFreeInLoop(const Instruction &I, const Loop *CurLoop,
1420 if (Loop *OLoop = LI->getLoopFor(OInst->getParent()))
1457 const LoopSafetyInfo *SafetyInfo, const Loop *CurLoop,
1491 LoopInfo *LI, const Loop *CurLoop,
1563 const Loop *CurLoop, ICFLoopSafetyInfo *SafetyInfo,
1663 static void hoist(Instruction &I, const DominatorTree *DT, const Loop *CurLoop,
1708 const Loop *CurLoop,
1751 if (Loop *L = LI.getLoopFor(I->getParent()))
2157 LoopInvariantCodeMotion::collectAliasInfoForLoop(Loop *L, LoopInfo *LI,
2160 SmallVector<Loop *, 4> RecomputeLoops;
2161 for (Loop *InnerL : L->getSubLoops()) {
2186 for (Loop *InnerL : RecomputeLoops)
2200 Loop *L, AliasAnalysis *AA, MemorySSAUpdater *MSSAU) {
2210 Loop *L) {
2220 void LegacyLICMPass::deleteAnalysisValue(Value *V, Loop *L) {
2230 void LegacyLICMPass::deleteAnalysisLoop(Loop *L) {
2238 AliasSetTracker *CurAST, Loop *CurLoop,
2285 Loop *CurLoop,
2333 static bool inSubLoop(BasicBlock *BB, Loop *CurLoop, LoopInfo *LI) {
lib/Transforms/Scalar/LoopAccessAnalysisPrinter.cpp 16 LoopAccessInfoPrinterPass::run(Loop &L, LoopAnalysisManager &AM,
lib/Transforms/Scalar/LoopDataPrefetch.cpp 71 bool runOnLoop(Loop *L);
205 for (Loop *I : *LI)
212 bool LoopDataPrefetch::runOnLoop(Loop *L) {
lib/Transforms/Scalar/LoopDeletion.cpp 42 static bool isLoopDead(Loop *L, ScalarEvolution &SE,
93 static bool isLoopNeverExecuted(Loop *L) {
135 static LoopDeletionResult deleteLoopIfDead(Loop *L, DominatorTree &DT,
208 PreservedAnalyses LoopDeletionPass::run(Loop &L, LoopAnalysisManager &AM,
234 bool runOnLoop(Loop *L, LPPassManager &) override;
251 bool LoopDeletionLegacyPass::runOnLoop(Loop *L, LPPassManager &LPM) {
lib/Transforms/Scalar/LoopDistribute.cpp 131 InstPartition(Instruction *I, Loop *L, bool DepCycle = false)
184 Loop *cloneLoopWithPreheader(BasicBlock *InsertBefore, BasicBlock *LoopDomBB,
195 const Loop *getClonedLoop() const { return ClonedLoop; }
200 Loop *getDistributedLoop() const {
260 Loop *OrigLoop;
264 Loop *ClonedLoop = nullptr;
282 InstPartitionContainer(Loop *L, LoopInfo *LI, DominatorTree *DT)
449 Loop *NewLoop;
573 Loop *L;
605 Loop *NewLoop = Part->getDistributedLoop();
658 LoopDistributeForLoop(Loop *L, Function *F, LoopInfo *LI, DominatorTree *DT,
665 bool processLoop(std::function<const LoopAccessInfo &(Loop &)> &GetLAA) {
952 Loop *L;
976 std::function<const LoopAccessInfo &(Loop &)> &GetLAA) {
980 SmallVector<Loop *, 8> Worklist;
982 for (Loop *TopLevelLoop : *LI)
983 for (Loop *L : depth_first(TopLevelLoop))
990 for (Loop *L : Worklist) {
1024 std::function<const LoopAccessInfo &(Loop &)> GetLAA =
1059 std::function<const LoopAccessInfo &(Loop &)> GetLAA =
lib/Transforms/Scalar/LoopFuse.cpp 143 Loop *L;
162 FusionCandidate(Loop *L, const DominatorTree *DT,
385 using LoopVector = SmallVector<Loop *, 4>;
448 bool isRemovedLoop(const Loop *L) const { return RemovedLoops.count(L); }
452 void removeLoop(const Loop *L) { RemovedLoops.insert(L); }
459 for (Loop *L : LV)
480 SmallPtrSet<const Loop *, 8> RemovedLoops;
610 for (Loop *L : LV) {
841 AddRecLoopReplacer(ScalarEvolution &SE, const Loop &OldL, const Loop &NewL,
841 AddRecLoopReplacer(ScalarEvolution &SE, const Loop &OldL, const Loop &NewL,
847 const Loop *ExprL = Expr->getLoop();
872 const Loop &OldL, &NewL;
877 bool accessDiffIsPositive(const Loop &L0, const Loop &L1, Instruction &I0,
877 bool accessDiffIsPositive(const Loop &L0, const Loop &L1, Instruction &I0,
1145 Loop *performFusion(const FusionCandidate &FC0, const FusionCandidate &FC1) {
1286 Loop *ChildLoop = *ChildLoopIt;
1349 Loop *fuseGuardedLoops(const FusionCandidate &FC0,
1539 Loop *ChildLoop = *ChildLoopIt;
lib/Transforms/Scalar/LoopIdiomRecognize.cpp 122 virtual void markLoopAsDeleted(Loop *L) = 0;
129 void markLoopAsDeleted(Loop *L) override { LPM.markLoopAsDeleted(*L); }
135 void markLoopAsDeleted(Loop *L) override {
141 Loop *CurLoop = nullptr;
163 bool runOnLoop(Loop *L);
267 bool runOnLoop(Loop *L, LPPassManager &LPM) override {
306 PreservedAnalyses LoopIdiomRecognizePass::run(Loop &L, LoopAnalysisManager &AM,
352 bool LoopIdiomRecognize::runOnLoop(Loop *L) {
858 mayLoopAccessLocation(Value *Ptr, ModRefInfo Access, Loop *L,
879 for (Loop::block_iterator BI = L->block_begin(), E = L->block_end(); BI != E;
908 unsigned StoreSize, Loop *CurLoop,
1284 static bool detectPopcountIdiom(Loop *CurLoop, BasicBlock *PreCondBB,
1419 static bool detectShiftUntilZeroIdiom(Loop *CurLoop, const DataLayout &DL,
2338 SmallVector<Loop::Edge, 2> LoopExitEdges;
2343 for (const Loop::Edge &Edge : LoopExitEdges) {
2404 Loop *ParentLoop = CurLoop->getParentLoop();
2538 Loop *PhonyLoop = LI->AllocateLoop();
lib/Transforms/Scalar/LoopInstSimplify.cpp 50 static bool simplifyLoopInst(Loop &L, DominatorTree &DT, LoopInfo &LI,
186 bool runOnLoop(Loop *L, LPPassManager &LPM) override {
223 PreservedAnalyses LoopInstSimplifyPass::run(Loop &L, LoopAnalysisManager &AM,
lib/Transforms/Scalar/LoopInterchange.cpp 62 using LoopVector = SmallVector<Loop *, 8>;
86 Loop *L, DependenceInfo *DI) {
278 Loop *CurrentLoop = &L;
279 const std::vector<Loop *> *Vec = &CurrentLoop->getSubLoops();
295 static PHINode *getInductionVariable(Loop *L, ScalarEvolution *SE) {
327 LoopInterchangeLegality(Loop *Outer, Loop *Inner, ScalarEvolution *SE,
327 LoopInterchangeLegality(Loop *Outer, Loop *Inner, ScalarEvolution *SE,
346 bool tightlyNested(Loop *Outer, Loop *Inner);
346 bool tightlyNested(Loop *Outer, Loop *Inner);
353 bool findInductionAndReductions(Loop *L,
355 Loop *InnerLoop);
357 Loop *OuterLoop;
358 Loop *InnerLoop;
374 LoopInterchangeProfitability(Loop *Outer, Loop *Inner, ScalarEvolution *SE,
374 LoopInterchangeProfitability(Loop *Outer, Loop *Inner, ScalarEvolution *SE,
385 Loop *OuterLoop;
386 Loop *InnerLoop;
398 LoopInterchangeTransform(Loop *Outer, Loop *Inner, ScalarEvolution *SE,
398 LoopInterchangeTransform(Loop *Outer, Loop *Inner, ScalarEvolution *SE,
407 void restructureLoops(Loop *NewInner, Loop *NewOuter,
407 void restructureLoops(Loop *NewInner, Loop *NewOuter,
410 void removeChildLoop(Loop *OuterLoop, Loop *InnerLoop);
410 void removeChildLoop(Loop *OuterLoop, Loop *InnerLoop);
417 Loop *OuterLoop;
418 Loop *InnerLoop;
452 bool runOnLoop(Loop *L, LPPassManager &LPM) override {
466 for (Loop *L : LoopList) {
511 Loop *OuterMostLoop = *(LoopList.begin());
555 Loop *InnerLoop = LoopList[InnerLoopId];
556 Loop *OuterLoop = LoopList[OuterLoopId];
594 bool LoopInterchangeLegality::tightlyNested(Loop *OuterLoop, Loop *InnerLoop) {
594 bool LoopInterchangeLegality::tightlyNested(Loop *OuterLoop, Loop *InnerLoop) {
663 static PHINode *findInnerReductionPhi(Loop *L, Value *V) {
679 Loop *L, SmallVector<PHINode *, 8> &Inductions, Loop *InnerLoop) {
679 Loop *L, SmallVector<PHINode *, 8> &Inductions, Loop *InnerLoop) {
930 static bool areLoopExitPHIsSupported(Loop *OuterLoop, Loop *InnerLoop) {
930 static bool areLoopExitPHIsSupported(Loop *OuterLoop, Loop *InnerLoop) {
1131 void LoopInterchangeTransform::removeChildLoop(Loop *OuterLoop,
1132 Loop *InnerLoop) {
1133 for (Loop *L : *OuterLoop)
1165 Loop *NewInner, Loop *NewOuter, BasicBlock *OrigInnerPreHeader,
1165 Loop *NewInner, Loop *NewOuter, BasicBlock *OrigInnerPreHeader,
1167 Loop *OuterLoopParent = OuterLoop->getParentLoop();
lib/Transforms/Scalar/LoopLoadElimination.cpp 98 Loop *L) const {
146 static bool doesStoreDominatesAllLatches(BasicBlock *StoreBlock, Loop *L,
156 static bool isLoadConditional(LoadInst *Load, Loop *L) {
165 LoadEliminationForLoop(Loop *L, LoopInfo *LI, const LoopAccessInfo &LAI,
581 Loop *L;
601 function_ref<const LoopAccessInfo &(Loop &)> GetLAI) {
607 SmallVector<Loop *, 8> Worklist;
609 for (Loop *TopLevelLoop : LI)
610 for (Loop *L : depth_first(TopLevelLoop))
617 for (Loop *L : Worklist) {
lib/Transforms/Scalar/LoopPassManager.cpp 25 LPMUpdater &>::run(Loop &L, LoopAnalysisManager &AM,
41 if (!PI.runBeforePass<Loop>(*Pass, L))
48 PI.runAfterPassInvalidated<Loop>(*Pass);
50 PI.runAfterPass<Loop>(*Pass, L);
87 PA.preserveSet<AllAnalysesOn<Loop>>();
100 PreservedAnalyses PrintLoopPass::run(Loop &L, LoopAnalysisManager &,
lib/Transforms/Scalar/LoopPredication.cpp 254 Loop *L;
307 bool runOnLoop(Loop *L);
322 bool runOnLoop(Loop *L, LPPassManager &LPM) override {
348 PreservedAnalyses LoopPredicationPass::run(Loop &L, LoopAnalysisManager &AM,
648 static void normalizePredicate(ScalarEvolution *SE, Loop *L,
956 bool LoopPredication::runOnLoop(Loop *Loop) {
lib/Transforms/Scalar/LoopRerollPass.cpp 171 bool runOnLoop(Loop *L, LPPassManager &LPM) override;
200 SimpleLoopReduction(Instruction *P, Loop *L) : Instructions(1, P) {
252 void add(Loop *L);
378 DAGRootTracker(LoopReroll *Parent, Loop *L, Instruction *IV,
432 Loop *L;
476 bool isLoopControlIV(Loop *L, Instruction *IV);
477 void collectPossibleIVs(Loop *L, SmallInstructionVector &PossibleIVs);
478 void collectPossibleReductions(Loop *L,
480 bool reroll(Instruction *IV, Loop *L, BasicBlock *Header,
500 static bool hasUsesOutsideLoop(Instruction *I, Loop *L) {
514 bool LoopReroll::isLoopControlIV(Loop *L, Instruction *IV) {
572 void LoopReroll::collectPossibleIVs(Loop *L,
609 void LoopReroll::SimpleLoopReduction::add(Loop *L) {
651 void LoopReroll::collectPossibleReductions(Loop *L,
1615 bool LoopReroll::reroll(Instruction *IV, Loop *L, BasicBlock *Header,
1640 bool LoopReroll::runOnLoop(Loop *L, LPPassManager &LPM) {
lib/Transforms/Scalar/LoopRotation.cpp 37 PreservedAnalyses LoopRotatePass::run(Loop &L, LoopAnalysisManager &AM,
89 bool runOnLoop(Loop *L, LPPassManager &LPM) override {
lib/Transforms/Scalar/LoopSimplifyCFG.cpp 83 static void removeBlockFromLoops(BasicBlock *BB, Loop *FirstLoop,
84 Loop *LastLoop = nullptr) {
88 for (Loop *Current = FirstLoop; Current != LastLoop;
95 static Loop *getInnermostLoopFor(SmallPtrSetImpl<BasicBlock *> &BBs,
96 Loop &L, LoopInfo &LI) {
97 Loop *Innermost = nullptr;
99 Loop *BBL = LI.getLoopFor(BB);
117 Loop &L;
381 if (Loop *OuterLoop = LI.getLoopFor(Preheader)) {
386 Loop *StillReachable = getInnermostLoopFor(LiveExitBlocks, L, LI);
404 Loop *FixLCSSALoop = OuterLoop;
445 Loop *DL = LI.getLoopFor(BB);
447 for (auto *PL = DL->getParentLoop(); PL; PL = PL->getParentLoop())
524 ConstantTerminatorFoldingImpl(Loop &L, LoopInfo &LI, DominatorTree &DT,
623 static bool constantFoldTerminators(Loop &L, DominatorTree &DT, LoopInfo &LI,
641 static bool mergeBlocksIntoPredecessors(Loop &L, DominatorTree &DT,
669 static bool simplifyLoopCFG(Loop &L, DominatorTree &DT, LoopInfo &LI,
689 PreservedAnalyses LoopSimplifyCFGPass::run(Loop &L, LoopAnalysisManager &AM,
718 bool runOnLoop(Loop *L, LPPassManager &LPM) override {
lib/Transforms/Scalar/LoopSink.cpp 174 static bool sinkInstruction(Loop &L, Instruction &I,
251 static bool sinkLoopInvariantInstructions(Loop &L, AAResults &AA, LoopInfo &LI,
328 SmallVector<Loop *, 4> PreorderLoops = LI.getLoopsInPreorder();
332 Loop &L = *PreorderLoops.pop_back_val();
356 bool runOnLoop(Loop *L, LPPassManager &LPM) override {
lib/Transforms/Scalar/LoopStrengthReduce.cpp 363 void initialMatch(const SCEV *S, Loop *L, ScalarEvolution &SE);
365 bool isCanonical(const Loop &L) const;
367 void canonicalize(const Loop &L);
389 static void DoInitialMatch(const SCEV *S, Loop *L,
443 void Formula::initialMatch(const SCEV *S, Loop *L, ScalarEvolution &SE) {
465 bool Formula::isCanonical(const Loop &L) const {
496 void Formula::canonicalize(const Loop &L) {
1012 const Loop &L);
1018 const Loop *L = nullptr;
1025 Cost(const Loop *L, ScalarEvolution &SE, const TargetTransformInfo &TTI) :
1095 bool isUseFullyOutsideLoop(const Loop *L) const;
1199 bool InsertFormula(const Formula &F, const Loop &L);
1470 bool LSRFixup::isUseFullyOutsideLoop(const Loop *L) const {
1498 for (const Loop *PIL : PostIncLoops) {
1533 bool LSRUse::InsertFormula(const Formula &F, const Loop &L) {
1706 const Formula &F, const Loop &L) {
1760 const Loop &L) {
1917 Loop *const L;
2053 LSRInstance(Loop *L, IVUsers &IU, ScalarEvolution &SE, DominatorTree &DT,
2719 Loop *L, ScalarEvolution &SE) {
3487 const Loop *L,
3544 LSRUse &LU, const SCEV *S, const Loop *L,
5036 const Loop *IPLoop = LI.getLoopFor(IP->getParent());
5047 const Loop *IDomLoop = LI.getLoopFor(IDom);
5085 for (const Loop *PIL : LF.PostIncLoops) {
5322 Loop *PNLoop = LI.getLoopFor(Parent);
5495 LSRInstance::LSRInstance(Loop *L, IVUsers &IU, ScalarEvolution &SE,
5542 const Loop *DomLoop = LI.getLoopFor(BB);
5674 bool runOnLoop(Loop *L, LPPassManager &LPM) override;
5706 static bool ReduceLoopStrength(Loop *L, IVUsers &IU, ScalarEvolution &SE,
5736 bool LoopStrengthReduce::runOnLoop(Loop *L, LPPassManager & /*LPM*/) {
5753 PreservedAnalyses LoopStrengthReducePass::run(Loop &L, LoopAnalysisManager &AM,
lib/Transforms/Scalar/LoopUnrollAndJamPass.cpp 93 static MDNode *GetUnrollMetadataForLoop(const Loop *L, StringRef Name) {
101 static bool HasAnyUnrollPragma(const Loop *L, StringRef Prefix) {
124 static bool HasUnrollAndJamEnablePragma(const Loop *L) {
130 static unsigned UnrollAndJamCountPragmaValue(const Loop *L) {
154 Loop *L, Loop *SubLoop, const TargetTransformInfo &TTI, DominatorTree &DT,
154 Loop *L, Loop *SubLoop, const TargetTransformInfo &TTI, DominatorTree &DT,
277 tryToUnrollAndJamLoop(Loop *L, DominatorTree &DT, LoopInfo *LI,
284 Loop *SubLoop = L->getSubLoops()[0];
387 Loop *EpilogueOuterLoop = nullptr;
440 bool runOnLoop(Loop *L, LPPassManager &LPM) override {
494 PreservedAnalyses LoopUnrollAndJamPass::run(Loop &L, LoopAnalysisManager &AM,
lib/Transforms/Scalar/LoopUnrollPass.cpp 177 Loop *L, ScalarEvolution &SE, const TargetTransformInfo &TTI,
334 const Loop *L, unsigned TripCount, DominatorTree &DT, ScalarEvolution &SE,
640 const Loop *L, unsigned &NumCalls, bool &NotDuplicatable, bool &Convergent,
666 static MDNode *GetUnrollMetadataForLoop(const Loop *L, StringRef Name) {
673 static bool HasUnrollFullPragma(const Loop *L) {
679 static bool HasUnrollEnablePragma(const Loop *L) {
684 static bool HasRuntimeUnrollDisablePragma(const Loop *L) {
690 static unsigned UnrollCountPragmaValue(const Loop *L) {
737 Loop *L, const TargetTransformInfo &TTI, DominatorTree &DT, LoopInfo *LI,
1012 Loop *L, DominatorTree &DT, LoopInfo *LI, ScalarEvolution &SE,
1132 Loop *RemainderLoop = nullptr;
1219 bool runOnLoop(Loop *L, LPPassManager &LPM) override {
1294 PreservedAnalyses LoopFullUnrollPass::run(Loop &L, LoopAnalysisManager &AM,
1310 Loop *ParentL = L.getParentLoop();
1311 SmallPtrSet<Loop *, 4> OldLoops;
1355 SmallVector<Loop *, 4> SibLoops;
1377 SmallVector<Loop *, 4> ChildLoops(L.begin(), L.end());
1386 static SmallVector<Loop *, 8> appendLoopsToWorklist(RangeT &&Loops) {
1387 SmallVector<Loop *, 8> Worklist;
1390 SmallVector<Loop *, 4> PreOrderLoops, PreOrderWorklist;
1392 for (Loop *RootL : Loops) {
1398 Loop *L = PreOrderWorklist.pop_back_val();
1442 SmallVector<Loop *, 8> Worklist = appendLoopsToWorklist(LI);
1449 Loop &L = *Worklist.pop_back_val();
1451 Loop *ParentL = L.getParentLoop();
lib/Transforms/Scalar/LoopUnswitch.cpp 116 using LoopPropsMap = std::map<const Loop *, LoopProperties>;
144 bool countLoop(const Loop *L, const TargetTransformInfo &TTI,
148 void forgetLoop(const Loop *L);
165 void cloneData(const Loop *NewLoop, const Loop *OldLoop,
165 void cloneData(const Loop *NewLoop, const Loop *OldLoop,
176 std::vector<Loop*> LoopProcessWorklist;
183 Loop *currentLoop = nullptr;
211 bool runOnLoop(Loop *L, LPPassManager &LPM) override;
242 void SplitExitEdges(Loop *L,
249 void UnswitchTrivialCondition(Loop *L, Value *Cond, Constant *Val,
251 void UnswitchNontrivialCondition(Value *LIC, Constant *OnVal, Loop *L,
254 void RewriteLoopBodyWithConditionConstant(Loop *L, Value *LIC,
262 void SimplifyCode(std::vector<Instruction*> &Worklist, Loop *L);
274 bool LUAnalysisCache::countLoop(const Loop *L, const TargetTransformInfo &TTI,
298 for (Loop::block_iterator I = L->block_begin(), E = L->block_end(); I != E;
323 void LUAnalysisCache::forgetLoop(const Loop *L) {
356 void LUAnalysisCache::cloneData(const Loop *NewLoop, const Loop *OldLoop,
356 void LUAnalysisCache::cloneData(const Loop *NewLoop, const Loop *OldLoop,
421 static Value *FindLIVLoopCondition(Value *Cond, Loop *L, bool &Changed,
505 FindLIVLoopCondition(Value *Cond, Loop *L, bool &Changed,
518 bool LoopUnswitch::runOnLoop(Loop *L, LPPassManager &LPM_Ref) {
714 for (Loop::block_iterator I = currentLoop->block_begin(),
833 static bool isTrivialLoopExitBlockHelper(Loop *L, BasicBlock *BB,
868 static BasicBlock *isTrivialLoopExitBlock(Loop *L, BasicBlock *BB) {
907 static Loop *CloneLoop(Loop *L, Loop *PL, ValueToValueMapTy &VM,
907 static Loop *CloneLoop(Loop *L, Loop *PL, ValueToValueMapTy &VM,
907 static Loop *CloneLoop(Loop *L, Loop *PL, ValueToValueMapTy &VM,
909 Loop &New = *LI->AllocateLoop();
917 for (Loop::block_iterator I = L->block_begin(), E = L->block_end();
923 for (Loop *I : *L)
999 void LoopUnswitch::UnswitchTrivialCondition(Loop *L, Value *Cond, Constant *Val,
1215 void LoopUnswitch::SplitExitEdges(Loop *L,
1234 Loop *L, Instruction *TI) {
1295 Loop *NewLoop = CloneLoop(L, L->getParentLoop(), VMap, LI, LPM);
1301 Loop *ParentLoop = L->getParentLoop();
1311 if (Loop *ExitBBLoop = LI->getLoopFor(ExitBlocks[i]))
1416 std::vector<Instruction *> &Worklist, Loop *L,
1442 void LoopUnswitch::RewriteLoopBodyWithConditionConstant(Loop *L, Value *LIC,
1581 void LoopUnswitch::SimplifyCode(std::vector<Instruction*> &Worklist, Loop *L) {
lib/Transforms/Scalar/LoopVersioningLICM.cpp 126 bool runOnLoop(Loop *L, LPPassManager &LPM) override;
179 Loop *CurLoop = nullptr;
207 void setNoAliasToLoop(Loop *VerLoop);
535 void LoopVersioningLICM::setNoAliasToLoop(Loop *VerLoop) {
567 bool LoopVersioningLICM::runOnLoop(Loop *L, LPPassManager &LPM) {
lib/Transforms/Scalar/PlaceSafepoints.cpp 122 bool runOnLoop(Loop *);
123 void runOnLoopAndSubLoops(Loop *L) {
125 for (Loop *I : *L)
135 for (Loop *I : *LI) {
198 static bool containsUnconditionalCallSafepoint(Loop *L, BasicBlock *Header,
240 static bool mustBeFiniteCountedLoop(Loop *L, ScalarEvolution *SE,
306 bool PlaceBackedgeSafepointsImpl::runOnLoop(Loop *L) {
lib/Transforms/Scalar/SeparateConstOffsetFromGEP.cpp 438 bool hasMoreThanOneUseInLoop(Value *v, Loop *L);
445 Loop *CurLoop);
821 Loop *L = LI->getLoopFor(Variadic->getParent());
1225 GetElementPtrInst *FirstGEP, GetElementPtrInst *SecondGEP, Loop *CurLoop) {
1280 bool SeparateConstOffsetFromGEP::hasMoreThanOneUseInLoop(Value *V, Loop *L) {
lib/Transforms/Scalar/SimpleLoopUnswitch.cpp 103 collectHomogenousInstGraphLoopInvariants(Loop &L, Instruction &Root,
141 static void replaceLoopInvariantUses(Loop &L, Value *Invariant,
159 static bool areLoopExitPHIsLoopInvariant(Loop &L, BasicBlock &ExitingBB,
264 static void hoistLoopToNewParent(Loop &L, BasicBlock &Preheader,
268 Loop *OldParentL = L.getParentLoop();
274 Loop *NewParentL = nullptr;
276 if (Loop *ExitL = LI.getLoopFor(ExitBB))
306 for (Loop *OldContainingL = OldParentL; OldContainingL != NewParentL;
349 static bool unswitchTrivialBranch(Loop &L, BranchInst &BI, DominatorTree &DT,
418 if (Loop *ExitL = LI.getLoopFor(LoopExitBB))
572 static bool unswitchTrivialSwitch(Loop &L, SwitchInst &SI, DominatorTree &DT,
608 Loop *OuterL = &L;
615 Loop *ExitL = LI.getLoopFor(DefaultExitBB);
632 Loop *ExitL = LI.getLoopFor(CaseI->getCaseSuccessor());
851 static bool unswitchAllTrivialConditions(Loop &L, DominatorTree &DT,
970 Loop &L, BasicBlock *LoopPH, BasicBlock *SplitBB,
1141 static Loop *cloneLoopNest(Loop &OrigRootL, Loop *RootParentL,
1141 static Loop *cloneLoopNest(Loop &OrigRootL, Loop *RootParentL,
1141 static Loop *cloneLoopNest(Loop &OrigRootL, Loop *RootParentL,
1156 Loop *ClonedRootL = LI.AllocateLoop();
1169 SmallVector<std::pair<Loop *, Loop *>, 16> LoopsToClone;
1169 SmallVector<std::pair<Loop *, Loop *>, 16> LoopsToClone;
1172 for (Loop *ChildL : llvm::reverse(OrigRootL))
1175 Loop *ClonedParentL, *L;
1177 Loop *ClonedL = LI.AllocateLoop();
1180 for (Loop *ChildL : llvm::reverse(*L))
1200 static void buildClonedLoops(Loop &OrigL, ArrayRef<BasicBlock *> ExitBlocks,
1202 SmallVectorImpl<Loop *> &NonChildClonedLoops) {
1203 Loop *ClonedL = nullptr;
1215 Loop *ParentL = nullptr;
1217 SmallDenseMap<BasicBlock *, Loop *, 16> ExitLoopMap;
1221 if (Loop *ExitL = LI.getLoopFor(ExitBB)) {
1317 for (Loop *PL = ClonedL; PL; PL = PL->getParentLoop())
1325 for (Loop *ChildL : OrigL) {
1375 Loop *ExitL = ExitLoopMap.lookup(ExitBB);
1417 if (Loop *OuterL = ExitLoopMap.lookup(BB))
1423 auto *OuterL = BBAndL.second;
1432 for (Loop *ChildL : OrigL) {
1450 deleteDeadClonedBlocks(Loop &L, ArrayRef<BasicBlock *> ExitBlocks,
1479 static void deleteDeadBlocksFromLoop(Loop &L,
1513 for (Loop *ParentL = &L; ParentL; ParentL = ParentL->getParentLoop()) {
1610 if (Loop *InnerL = LI.getLoopFor(BB))
1674 static bool rebuildLoopAfterUnswitch(Loop &L, ArrayRef<BasicBlock *> ExitBlocks,
1676 SmallVectorImpl<Loop *> &HoistedLoops) {
1681 Loop *ParentL = nullptr;
1682 SmallVector<Loop *, 4> ExitLoops;
1686 if (Loop *ExitL = LI.getLoopFor(ExitBB)) {
1703 for (Loop *IL = L.getParentLoop(); IL != ParentL;
1748 Loop *PrevExitL = L.getParentLoop(); // The deepest possible exit loop.
1766 Loop &ExitL = *LI.getLoopFor(ExitBB);
1811 if (Loop *BBL = LI.getLoopFor(BB))
1825 if (Loop *BBL = LI.getLoopFor(BB))
1840 for (auto *HoistedL : make_range(SubLoopsSplitI, SubLoops.end())) {
1852 if (auto *NewParentL = LI.getLoopFor(HoistedL->getLoopPreheader()))
1863 if (Loop *ParentL = L.getParentLoop())
1902 Loop &L, Instruction &TI, ArrayRef<Value *> Invariants,
1904 AssumptionCache &AC, function_ref<void(bool, ArrayRef<Loop *>)> UnswitchCB,
1964 Loop *ParentL = L.getParentLoop();
1973 Loop *OuterExitL = &L;
1975 Loop *NewOuterExitL = LI.getLoopFor(ExitBB);
2169 SmallVector<Loop *, 4> NonChildClonedLoops;
2181 SmallVector<Loop *, 4> HoistedLoops;
2254 for (Loop *ChildL : UpdateL) {
2277 for (Loop *UpdatedL :
2278 llvm::concat<Loop *>(NonChildClonedLoops, HoistedLoops)) {
2292 for (Loop *OuterL = ParentL; OuterL != OuterExitL;
2305 SmallVector<Loop *, 4> SibLoops;
2306 for (Loop *UpdatedL : llvm::concat<Loop *>(NonChildClonedLoops, HoistedLoops))
2306 for (Loop *UpdatedL : llvm::concat<Loop *>(NonChildClonedLoops, HoistedLoops))
2375 turnGuardIntoBranch(IntrinsicInst *GI, Loop &L,
2452 Instruction &TI, Loop &L, LoopInfo &LI, DominatorTree &DT,
2471 auto *ParentL = L.getParentLoop();
2524 unswitchBestCondition(Loop &L, DominatorTree &DT, LoopInfo &LI,
2526 function_ref<void(bool, ArrayRef<Loop *>)> UnswitchCB,
2801 static bool unswitchLoop(Loop &L, DominatorTree &DT, LoopInfo &LI,
2804 function_ref<void(bool, ArrayRef<Loop *>)> UnswitchCB,
2843 PreservedAnalyses SimpleLoopUnswitchPass::run(Loop &L, LoopAnalysisManager &AM,
2907 bool runOnLoop(Loop *L, LPPassManager &LPM) override;
2922 bool SimpleLoopUnswitchLegacyPass::runOnLoop(Loop *L, LPPassManager &LPM) {
2948 for (auto *NewL : NewLoops)
lib/Transforms/Scalar/Sink.cpp 125 Loop *succ = LI.getLoopFor(SuccToSinkTo);
126 Loop *cur = LI.getLoopFor(Inst->getParent());
lib/Transforms/Scalar/StructurizeCFG.cpp 212 Loop *getAdjustedLoop(RegionNode *RN);
313 Loop *StructurizeCFG::getAdjustedLoop(RegionNode *RN) {
335 SmallDenseMap<Loop*, unsigned, 8> LoopBlocks;
341 Loop *Loop = getAdjustedLoop(RN);
346 Loop *CurrentLoop = nullptr;
lib/Transforms/Scalar/WarnMissedTransforms.cpp 23 static void warnAboutLeftoverTransformations(Loop *L,
86 for (auto *L : LI->getLoopsInPreorder())
lib/Transforms/Utils/BasicBlockUtils.cpp 415 if (Loop *L = LI->getLoopFor(Old))
462 Loop *L = LI->getLoopFor(OldBB);
478 if (Loop *PL = LI->getLoopFor(Pred))
501 Loop *InnermostPredLoop = nullptr;
503 if (Loop *PredLoop = LI->getLoopFor(Pred)) {
853 if (Loop *L = LI->getLoopFor(Head)) {
lib/Transforms/Utils/BreakCriticalEdges.cpp 247 if (Loop *TIL = LI->getLoopFor(TIBB)) {
250 if (Loop *DestLoop = LI->getLoopFor(DestBB)) {
267 if (Loop *P = DestLoop->getParentLoop())
lib/Transforms/Utils/CloneFunction.cpp 752 Loop *llvm::cloneLoopWithPreheader(BasicBlock *Before, BasicBlock *LoopDomBB,
753 Loop *OrigLoop, ValueToValueMapTy &VMap,
758 Loop *ParentLoop = OrigLoop->getParentLoop();
759 DenseMap<Loop *, Loop *> LMap;
759 DenseMap<Loop *, Loop *> LMap;
761 Loop *NewLoop = LI->AllocateLoop();
782 for (Loop *CurLoop : OrigLoop->getLoopsInPreorder()) {
783 Loop *&NewLoop = LMap[CurLoop];
788 Loop *OrigParent = CurLoop->getParentLoop();
790 Loop *NewParentLoop = LMap[OrigParent];
798 Loop *CurLoop = LI->getLoopFor(BB);
799 Loop *&NewLoop = LMap[CurLoop];
lib/Transforms/Utils/CodeExtractor.cpp 254 CodeExtractor::CodeExtractor(DominatorTree &DT, Loop &L, bool AggregateArgs,
lib/Transforms/Utils/LCSSA.cpp 86 SmallDenseMap<Loop*, SmallVector<BasicBlock *,1>> LoopExitBlocks;
94 Loop *L = LI.getLoopFor(InstBB);
177 if (auto *OtherLoop = LI.getLoopFor(ExitBB))
238 if (auto *OtherLoop = LI.getLoopFor(InsertedPN->getParent()))
276 Loop &L, DominatorTree &DT, SmallVector<BasicBlock *, 8> &ExitBlocks,
320 bool llvm::formLCSSA(Loop &L, DominatorTree &DT, LoopInfo *LI,
385 bool llvm::formLCSSARecursively(Loop &L, DominatorTree &DT, LoopInfo *LI,
390 for (Loop *SubLoop : L.getSubLoops())
lib/Transforms/Utils/LoopRotationUtils.cpp 71 bool processLoop(Loop *L);
74 bool rotateLoop(Loop *L, bool SimplifiedLatch);
75 bool simplifyLoopLatch(Loop *L);
176 static bool shouldRotateLoopExitingLatch(Loop *L) {
204 bool LoopRotate::rotateLoop(Loop *L, bool SimplifiedLatch) {
468 Loop *PredLoop = LI->getLoopFor(ExitPred);
523 BasicBlock::iterator End, Loop *L) {
595 bool LoopRotate::simplifyLoopLatch(Loop *L) {
629 bool LoopRotate::processLoop(Loop *L) {
655 bool llvm::LoopRotation(Loop *L, LoopInfo *LI, const TargetTransformInfo *TTI,
lib/Transforms/Utils/LoopSimplify.cpp 87 Loop *L) {
122 BasicBlock *llvm::InsertPreheaderForLoop(Loop *L, DominatorTree *DT,
182 static PHINode *findPHIToPartitionLoops(Loop *L, DominatorTree *DT,
224 static Loop *separateNestedLoop(Loop *L, BasicBlock *Preheader,
224 static Loop *separateNestedLoop(Loop *L, BasicBlock *Preheader,
268 Loop *NewOuter = LI->AllocateLoop();
271 if (Loop *Parent = L->getParentLoop())
279 for (Loop::block_iterator I = L->block_begin(), E = L->block_end();
298 const std::vector<Loop*> &SubLoops = L->getSubLoops();
348 static BasicBlock *insertUniqueBackedgeBlock(Loop *L, BasicBlock *Preheader,
471 static bool simplifyOneLoop(Loop *L, SmallVectorImpl<Loop *> &Worklist,
471 static bool simplifyOneLoop(Loop *L, SmallVectorImpl<Loop *> &Worklist,
485 for (Loop::block_iterator BB = L->block_begin(), E = L->block_end();
561 if (Loop *OuterL = separateNestedLoop(L, Preheader, DT, LI, SE,
709 bool llvm::simplifyLoop(Loop *L, DominatorTree *DT, LoopInfo *LI,
726 SmallVector<Loop *, 4> Worklist;
733 Loop *L2 = Worklist[Idx];
lib/Transforms/Utils/LoopUnroll.cpp 107 static bool needToInsertPhisForLCSSA(Loop *L, std::vector<BasicBlock *> Blocks,
115 Loop *DefLoop = LI->getLoopFor(Def->getParent());
131 const Loop* llvm::addClonedBlockToLoopInfo(BasicBlock *OriginalBB,
135 const Loop *OldLoop = LI->getLoopFor(OriginalBB);
138 Loop *&NewLoop = NewLoops[OldLoop];
145 Loop *NewLoopParent = NewLoops.lookup(OldLoop->getParentLoop());
185 static bool isEpilogProfitable(Loop *L) {
199 void llvm::simplifyLoopAfterUnroll(Loop *L, bool SimplifyIVs, LoopInfo *LI,
276 LoopUnrollResult llvm::UnrollLoop(Loop *L, UnrollLoopOptions ULO, LoopInfo *LI,
280 bool PreserveLCSSA, Loop **RemainderLoop) {
583 SmallSetVector<Loop *, 4> LoopsToSimplify;
584 for (Loop *SubLoop : *L)
603 SmallDenseMap<const Loop *, Loop *, 4> NewLoops;
603 SmallDenseMap<const Loop *, Loop *, 4> NewLoops;
614 const Loop *OldLoop = addClonedBlockToLoopInfo(*BB, New, LI, NewLoops);
904 Loop *OuterL = L->getParentLoop();
933 Loop *LatchLoop = LI->getLoopFor(Latches.back());
934 Loop *FixLCSSALoop = OuterL;
950 for (Loop *SubLoop : LoopsToSimplify)
lib/Transforms/Utils/LoopUnrollAndJam.cpp 51 static bool partitionOuterLoopBlocks(Loop *L, Loop *SubLoop,
51 static bool partitionOuterLoopBlocks(Loop *L, Loop *SubLoop,
174 Loop *L, unsigned Count, unsigned TripCount, unsigned TripMultiple,
176 AssumptionCache *AC, OptimizationRemarkEmitter *ORE, Loop **EpilogueLoop) {
181 Loop *SubLoop = *L->begin();
572 Loop *OuterL = L->getParentLoop();
573 Loop *OutestLoop = OuterL ? OuterL : (!CompletelyUnroll ? L : SubLoop);
664 static bool checkDependencies(Loop *L, BasicBlockSet &ForeBlocks,
687 bool llvm::isSafeToUnrollAndJam(Loop *L, ScalarEvolution &SE, DominatorTree &DT,
728 Loop *SubLoop = L->getSubLoops()[0];
lib/Transforms/Utils/LoopUnrollPeel.cpp 77 bool llvm::canPeel(Loop *L) {
126 PHINode *Phi, Loop *L, BasicBlock *BackEdge,
172 static unsigned countToEliminateCompares(Loop &L, unsigned MaxPeelCount,
259 void llvm::computePeelCount(Loop *L, unsigned LoopSize,
469 Loop *L, unsigned IterNumber, BasicBlock *InsertTop, BasicBlock *InsertBot,
481 Loop *ParentLoop = L->getParentLoop();
578 bool llvm::peelLoop(Loop *L, unsigned PeelCount, LoopInfo *LI,
750 if (Loop *ParentLoop = L->getParentLoop())
lib/Transforms/Utils/LoopUnrollRuntime.cpp 66 static void ConnectProlog(Loop *L, Value *BECount, unsigned Count,
136 Loop *PrologLoop = LI->getLoopFor(PrologLatch);
182 static void ConnectEpilog(Loop *L, Value *ModVal, BasicBlock *NewExit,
298 static Loop *
299 CloneLoopBlocks(Loop *L, Value *NewIter, const bool CreateRemainderLoop,
311 Loop *ParentLoop = L->getParentLoop();
398 Loop *NewLoop = NewLoops[L];
427 static bool canSafelyUnrollMultiExitLoop(Loop *L, BasicBlock *LatchExit,
462 Loop *L, SmallVectorImpl<BasicBlock *> &OtherExits, BasicBlock *LatchExit,
545 bool llvm::UnrollRuntimeLoopRemainder(Loop *L, unsigned Count,
551 bool PreserveLCSSA, Loop **ResultLoop) {
786 Loop *remainderLoop = CloneLoopBlocks(
lib/Transforms/Utils/LoopUtils.cpp 51 bool llvm::formDedicatedExitBlocks(Loop *L, DominatorTree *DT, LoopInfo *LI,
200 static MDNode *createStringMetadata(Loop *TheLoop, StringRef Name, unsigned V) {
211 void llvm::addStringMetadataToLoop(Loop *TheLoop, const char *StringMD,
251 Optional<const MDOperand *> llvm::findStringMetadataForLoop(const Loop *TheLoop,
266 static Optional<bool> getOptionalBoolLoopAttribute(const Loop *TheLoop,
284 static bool getBooleanLoopAttribute(const Loop *TheLoop, StringRef Name) {
288 llvm::Optional<int> llvm::getOptionalIntLoopAttribute(Loop *TheLoop,
383 bool llvm::hasDisableAllTransformsHint(const Loop *L) {
387 bool llvm::hasDisableLICMTransformsHint(const Loop *L) {
391 TransformationMode llvm::hasUnrollTransformation(Loop *L) {
412 TransformationMode llvm::hasUnrollAndJamTransformation(Loop *L) {
430 TransformationMode llvm::hasVectorizeTransformation(Loop *L) {
465 TransformationMode llvm::hasDistributeTransformation(Loop *L) {
475 TransformationMode llvm::hasLICMVersioningTransformation(Loop *L) {
506 void llvm::deleteDeadLoop(Loop *L, DominatorTree *DT = nullptr,
662 for (Loop::block_iterator LpI = L->block_begin(), LpE = L->block_end();
679 Optional<unsigned> llvm::getLoopEstimatedTripCount(Loop *L) {
720 bool llvm::hasIterationCountInvariantInParent(Loop *InnerLoop,
722 Loop *OuterL = InnerLoop->getParentLoop();
998 bool llvm::isKnownNegativeInLoop(const SCEV *S, const Loop *L,
1005 bool llvm::isKnownNonNegativeInLoop(const SCEV *S, const Loop *L,
1012 bool llvm::cannotBeMinInLoop(const SCEV *S, const Loop *L, ScalarEvolution &SE,
1023 bool llvm::cannotBeMaxInLoop(const SCEV *S, const Loop *L, ScalarEvolution &SE,
lib/Transforms/Utils/LoopVersioning.cpp 32 LoopVersioning::LoopVersioning(const LoopAccessInfo &LAI, Loop *L, LoopInfo *LI,
271 SmallVector<Loop *, 8> Worklist;
273 for (Loop *TopLevelLoop : *LI)
274 for (Loop *L : depth_first(TopLevelLoop))
281 for (Loop *L : Worklist) {
lib/Transforms/Utils/SimplifyIndVar.cpp 53 Loop *L;
63 SimplifyIndvar(Loop *Loop, ScalarEvolution *SE, DominatorTree *DT,
188 const Loop *ICmpLoop = LI->getLoopFor(ICmp->getParent());
258 const Loop *ICmpLoop = LI->getLoopFor(ICmp->getParent());
298 const Loop *L = LI->getLoopFor(SDiv->getParent());
370 const Loop *ICmpLoop = LI->getLoopFor(Rem->getParent());
651 static Instruction *GetLoopInvariantInsertPosition(Loop *L, Instruction *Hint) {
792 Instruction *Def, Loop *L,
825 static bool isSimpleIVUser(Instruction *I, const Loop *L, ScalarEvolution *SE) {
944 bool simplifyLoopIVs(Loop *L, ScalarEvolution *SE, DominatorTree *DT,
lib/Transforms/Vectorize/LoopVectorizationLegality.cpp 68 LoopVectorizeHints::LoopVectorizeHints(const Loop *L,
113 Function *F, Loop *L, bool VectorizeOnlyWhenForced) const {
240 Function *F, Loop *L, const LoopVectorizeHints &Hints) {
298 static bool isUniformLoop(Loop *Lp, Loop *OuterLp) {
298 static bool isUniformLoop(Loop *Lp, Loop *OuterLp) {
343 static bool isUniformLoopNest(Loop *Lp, Loop *OuterLp) {
343 static bool isUniformLoopNest(Loop *Lp, Loop *OuterLp) {
348 for (Loop *SubLp : *Lp)
391 static bool hasOutsideLoopUser(const Loop *TheLoop, Instruction *Inst,
1000 bool LoopVectorizationLegality::canVectorizeLoopCFG(Loop *Lp,
1066 Loop *Lp, bool UseVPlanNativePath) {
1080 for (Loop *SubLp : *Lp)
lib/Transforms/Vectorize/LoopVectorizationPlanner.h 187 Loop *OrigLoop;
223 LoopVectorizationPlanner(Loop *L, LoopInfo *LI, const TargetLibraryInfo *TLI,
lib/Transforms/Vectorize/LoopVectorize.cpp 365 static Optional<unsigned> getSmallBestKnownTC(ScalarEvolution &SE, Loop *L) {
400 InnerLoopVectorizer(Loop *OrigLoop, PredicatedScalarEvolution &PSE,
515 PHINode *createInductionVariable(Loop *L, Value *Start, Value *End,
612 Value *getOrCreateTripCount(Loop *NewLoop);
615 Value *getOrCreateVectorTripCount(Loop *NewLoop);
624 void emitMinimumIterationCountCheck(Loop *L, BasicBlock *Bypass);
628 void emitSCEVChecks(Loop *L, BasicBlock *Bypass);
631 void emitMemRuntimeChecks(Loop *L, BasicBlock *Bypass);
662 Loop *OrigLoop;
772 InnerLoopUnroller(Loop *OrigLoop, PredicatedScalarEvolution &PSE,
853 StringRef RemarkName, Loop *TheLoop, Instruction *I) {
874 OptimizationRemarkEmitter *ORE, Loop *TheLoop, Instruction *I) {
885 static std::string getDebugLocString(const Loop *L) {
953 LoopVectorizationCostModel(ScalarEpilogueLowering SEL, Loop *L,
1468 Loop *TheLoop;
1526 static bool isExplicitVecOuterLoop(Loop *OuterLp,
1554 static void collectSupportedLoops(Loop &L, LoopInfo *LI,
1556 SmallVectorImpl<Loop *> &V) {
1575 for (Loop *InnerL : L)
1614 std::function<const LoopAccessInfo &(Loop &)> GetLAA =
2522 PHINode *InnerLoopVectorizer::createInductionVariable(Loop *L, Value *Start,
2554 Value *InnerLoopVectorizer::getOrCreateTripCount(Loop *L) {
2601 Value *InnerLoopVectorizer::getOrCreateVectorTripCount(Loop *L) {
2677 void InnerLoopVectorizer::emitMinimumIterationCountCheck(Loop *L,
2710 void InnerLoopVectorizer::emitSCEVChecks(Loop *L, BasicBlock *Bypass) {
2743 void InnerLoopVectorizer::emitMemRuntimeChecks(Loop *L, BasicBlock *Bypass) {
2946 Loop *Lp = LI->AllocateLoop();
2947 Loop *ParentLoop = OrigLoop->getParentLoop();
3867 auto *VectorLoop = LI->getLoopFor(PredBB);
5702 const Loop *TheLoop) {
6580 static void AddRuntimeUnrollDisableMetaData(Loop *L) {
7442 getScalarEpilogueLowering(Function *F, Loop *L, LoopVectorizeHints &Hints,
7460 Loop *L, PredicatedScalarEvolution &PSE, LoopInfo *LI, DominatorTree *DT,
7506 bool LoopVectorizePass::processLoop(Loop *L) {
7805 std::function<const LoopAccessInfo &(Loop &)> &GetLAA_,
7845 SmallVector<Loop *, 8> Worklist;
7847 for (Loop *L : *LI)
7854 Loop *L = Worklist.pop_back_val();
7884 std::function<const LoopAccessInfo &(Loop &)> GetLAA =
lib/Transforms/Vectorize/SLPVectorizer.cpp 4400 Loop *L = LI->getLoopFor(I->getParent());
6701 Loop *BBL = LI->getLoopFor(ParentBB);
lib/Transforms/Vectorize/VPRecipeBuilder.h 27 Loop *OrigLoop;
103 VPRecipeBuilder(Loop *OrigLoop, const TargetLibraryInfo *TLI,
lib/Transforms/Vectorize/VPlan.cpp 187 Loop *L = State->LI->getLoopFor(State->CFG.LastBB);
394 Loop *L = State->LI->getLoopFor(VectorHeaderBB);
lib/Transforms/Vectorize/VPlanHCFGBuilder.cpp 37 Loop *TheLoop;
73 PlainCFGBuilder(Loop *Lp, LoopInfo *LI, VPlan &P)
lib/Transforms/Vectorize/VPlanHCFGBuilder.h 42 Loop *TheLoop;
63 VPlanHCFGBuilder(Loop *Lp, LoopInfo *LI, VPlan &P)
tools/opt/PassPrinters.cpp 146 bool runOnLoop(Loop *L, LPPassManager &LPM) override {
tools/polly/include/polly/CodeGen/BlockGenerators.h 448 LoopToScevMapT <S, Loop *L) const;
475 LoopToScevMapT <S, Loop *L) const;
481 Loop *getLoopForStmt(const ScopStmt &Stmt) const;
506 Value *generateLocationAccessed(ScopStmt &Stmt, Loop *L, Value *Pointer,
529 Value *getImplicitAddress(MemoryAccess &Access, Loop *L, LoopToScevMapT <S,
663 VectorValueMapT &ScalarMaps, Loop *L);
927 Loop *L);
tools/polly/include/polly/CodeGen/IRBuilder.h 51 void pushLoop(llvm::Loop *L, bool IsParallel);
60 void annotateLoopLatch(llvm::BranchInst *B, llvm::Loop *L, bool IsParallel,
101 llvm::SmallVector<llvm::Loop *, 8> ActiveLoops;
tools/polly/include/polly/CodeGen/IslNodeBuilder.h 163 MapVector<const Loop *, const SCEV *> OutsideLoopIterations;
255 SetVector<const Loop *> &Loops);
429 Value *materializeNonScopLoopInductionVariable(const Loop *L);
tools/polly/include/polly/PolyhedralInfo.h 47 bool isParallel(llvm::Loop *L) const;
55 const Scop *getScopContainingLoop(llvm::Loop *L) const;
64 llvm::Loop *L) const;
88 bool checkParallel(llvm::Loop *L,
tools/polly/include/polly/ScopBuilder.h 131 isl::set adjustDomainDimensions(isl::set Dom, Loop *OldL, Loop *NewL);
131 isl::set adjustDomainDimensions(isl::set Dom, Loop *OldL, Loop *NewL);
159 bool buildConditionSets(BasicBlock *BB, Instruction *TI, Loop *L,
173 Loop *L, __isl_keep isl_set *Domain,
182 bool buildConditionSets(BasicBlock *BB, SwitchInst *SI, Loop *L,
236 BasicBlock *BB, Loop *BBLoop,
275 Loop *L, DenseMap<BasicBlock *, isl::set> &InvalidDomainMap);
496 bool shouldModelInst(Instruction *Inst, Loop *L);
764 Loop *L;
773 LoopStackElement(Loop *L, isl::schedule S, unsigned NumBlocksProcessed)
tools/polly/include/polly/ScopDetection.h 138 SetVector<std::pair<const SCEVUnknown *, Loop *>> NonAffineAccesses;
218 bool involvesMultiplePtrs(const SCEV *S0, const SCEV *S1, Loop *Scope) const;
248 const SCEVUnknown *BasePointer, Loop *Scope) const;
272 const SCEVUnknown *BasePointer, Loop *Scope) const;
443 bool isAffine(const SCEV *S, Loop *Scope, DetectionContext &Context) const;
468 bool isValidLoop(Loop *L, DetectionContext &Context) const;
479 countBeneficialSubLoops(Loop *L, ScalarEvolution &SE,
493 bool canUseISLTripCount(Loop *L, DetectionContext &Context) const;
tools/polly/include/polly/ScopDetectionDiagnostic.h 524 Loop *L;
533 ReportLoopBound(Loop *L, const SCEV *LoopCount);
556 Loop *L;
561 ReportLoopHasNoExit(Loop *L)
584 Loop *L;
589 ReportLoopHasMultipleExits(Loop *L)
612 Loop *L;
617 ReportLoopOnlySomeLatches(Loop *L)
tools/polly/include/polly/ScopInfo.h 203 using LoopBoundMapType = std::map<const Loop *, const SCEV *>;
1158 ScopStmt(Scop &parent, BasicBlock &bb, StringRef Name, Loop *SurroundingLoop,
1169 ScopStmt(Scop &parent, Region &R, StringRef Name, Loop *SurroundingLoop,
1271 SmallVector<Loop *, 4> NestLoops;
1276 Loop *SurroundingLoop;
1355 bool contains(const Loop *L) const {
1395 Loop *getSurroundingLoop() const {
1590 Loop *getLoopForDimension(unsigned Dimension) const;
1654 Instruction *TI, Loop *L, __isl_keep isl_set *Domain,
1678 bool buildConditionSets(Scop &S, BasicBlock *BB, Instruction *TI, Loop *L,
1983 void addScopStmt(BasicBlock *BB, StringRef Name, Loop *SurroundingLoop,
1997 void addScopStmt(Region *R, StringRef Name, Loop *SurroundingLoop,
2196 bool contains(const Loop *L) const { return R.contains(L); }
2601 bool hasNSWAddRecForLoop(Loop *L) { return Affinator.hasNSWAddRecForLoop(L); }
2679 int getRelativeLoopDepth(const Loop *L) const;
tools/polly/include/polly/Support/SCEVAffinator.h 48 bool hasNSWAddRecForLoop(llvm::Loop *L) const;
71 llvm::Loop *getScope();
tools/polly/include/polly/Support/SCEVValidator.h 45 llvm::SetVector<const llvm::Loop *> &Loops);
65 llvm::Loop *Scope, bool AllowLoops,
67 bool isAffineExpr(const llvm::Region *R, llvm::Loop *Scope,
73 llvm::Loop *Scope, llvm::ScalarEvolution &SE,
76 ParameterSetTy getParamsInAffineExpr(const llvm::Region *R, llvm::Loop *Scope,
tools/polly/include/polly/Support/ScopHelper.h 48 using BoxedLoopsSetTy = llvm::SetVector<const llvm::Loop *>;
384 llvm::Loop *getLoopSurroundingScop(Scop &S, llvm::LoopInfo &LI);
396 unsigned getNumBlocksInLoop(llvm::Loop *L);
402 llvm::Loop *getRegionNodeLoop(llvm::RegionNode *RN, llvm::LoopInfo &LI);
436 llvm::ScalarEvolution *SE, llvm::Loop *Scope);
469 llvm::Loop *getFirstNonBoxedLoopFor(llvm::Loop *L, llvm::LoopInfo &LI,
469 llvm::Loop *getFirstNonBoxedLoopFor(llvm::Loop *L, llvm::LoopInfo &LI,
479 llvm::Loop *getFirstNonBoxedLoopFor(llvm::BasicBlock *BB, llvm::LoopInfo &LI,
tools/polly/include/polly/Support/VirtualInstruction.h 120 static VirtualUse create(Scop *S, ScopStmt *UserStmt, Loop *UserScope,
123 static VirtualUse create(ScopStmt *UserStmt, Loop *UserScope, Value *Val,
tools/polly/include/polly/ZoneAlgo.h 334 isl::map makeValInst(llvm::Value *Val, ScopStmt *UserStmt, llvm::Loop *Scope,
343 llvm::Loop *Scope,
tools/polly/lib/Analysis/PolyhedralInfo.cpp 61 for (auto *TopLevelLoop : LI) {
62 for (auto *L : depth_first(TopLevelLoop)) {
72 bool PolyhedralInfo::checkParallel(Loop *L, isl_pw_aff **MinDepDistPtr) const {
98 bool PolyhedralInfo::isParallel(Loop *L) const { return checkParallel(L); }
100 const Scop *PolyhedralInfo::getScopContainingLoop(Loop *L) const {
124 Loop *L) const {
tools/polly/lib/Analysis/ScopBuilder.cpp 292 isl::set ScopBuilder::adjustDomainDimensions(isl::set Dom, Loop *OldL,
293 Loop *NewL) {
391 BasicBlock *BB, SwitchInst *SI, Loop *L, __isl_keep isl_set *Domain,
428 BasicBlock *BB, Value *Condition, Instruction *TI, Loop *L,
562 BasicBlock *BB, Instruction *TI, Loop *L, __isl_keep isl_set *Domain,
616 Loop *BBLoop = getRegionNodeLoop(RN, LI);
626 BasicBlock *BB, Loop *BBLoop,
639 auto *L = BBLoop;
652 Loop *ExitBBLoop = getFirstNonBoxedLoopFor(ExitBB, LI, scop->getBoxedLoops());
678 Loop *BBLoop = getFirstNonBoxedLoopFor(BB, LI, scop->getBoxedLoops());
714 Loop *PredBBLoop =
724 Loop *L, DenseMap<BasicBlock *, isl::set> &InvalidDomainMap) {
829 auto *L = IsOnlyNonAffineRegion ? nullptr : LI.getLoopFor(EntryBB);
908 auto *BBLoop = getRegionNodeLoop(RN, LI);
958 Loop *SuccBBLoop =
1033 auto *BBLoop = getRegionNodeLoop(RN, LI);
1047 Loop *SuccBBLoop =
1086 auto *Scope = LI.getLoopFor(PHI->getParent());
1173 Loop *L = getLoopSurroundingScop(*scop, LI);
1205 Loop *OuterScopLoop = getLoopSurroundingScop(*scop, LI);
1231 Loop *L = getRegionNodeLoop(RN, LI);
1235 Loop *LastLoop = LoopStack.back().L;
1535 auto *L = LI.getLoopFor(CI->getParent());
1647 Loop *SurroundingLoop = Stmt->getSurroundingLoop();
1730 auto *L = LI.getLoopFor(Inst->getParent());
1738 Loop *SurroundingLoop = Stmt->getSurroundingLoop();
1822 Loop *L = LI.getLoopFor(Inst->getParent());
1859 SetVector<const Loop *> Loops;
1861 for (const Loop *L : Loops)
1869 Loop *SurroundingLoop = Stmt->getSurroundingLoop();
1924 bool ScopBuilder::shouldModelInst(Instruction *Inst, Loop *L) {
1963 Loop *SurroundingLoop = LI.getLoopFor(BB);
2094 Loop *L = LI.getLoopFor(BB);
2180 Loop *SurroundingLoop =
2546 auto *Scope = UserStmt->getSurroundingLoop();
2635 Loop *L = LI.getLoopFor(BB);
2640 SmallVector<llvm::Loop *, 8> Loops;
tools/polly/lib/Analysis/ScopDetection.cpp 442 Loop *L = LI.getLoopFor(BB);
487 Loop *Scope) const {
520 bool ScopDetection::isAffine(const SCEV *S, Loop *Scope,
535 Loop *L = LI.getLoopFor(&BB);
601 Loop *L = LI.getLoopFor(&BB);
746 Loop *L = LI.getLoopFor(II.getParent());
904 Loop *Scope) const {
979 auto *Scope = LI.getLoopFor(Insn->getParent());
1020 Loop *Scope) const {
1043 auto *Scope = Pair.second;
1096 SetVector<const Loop *> Loops;
1098 for (const Loop *L : Loops)
1102 auto *Scope = LI.getLoopFor(Inst->getParent());
1183 Loop *L = LI.getLoopFor(Inst->getParent());
1252 static bool hasExitingBlocks(Loop *L) {
1258 bool ScopDetection::canUseISLTripCount(Loop *L,
1274 bool ScopDetection::isValidLoop(Loop *L, DetectionContext &Context) const {
1338 ScopDetection::countBeneficialSubLoops(Loop *L, ScalarEvolution &SE,
1526 Loop *L = LI.getLoopFor(BB);
1584 auto *L = LI.getLoopFor(BB);
tools/polly/lib/Analysis/ScopDetectionDiagnostic.cpp 448 ReportLoopBound::ReportLoopBound(Loop *L, const SCEV *LoopCount)
tools/polly/lib/Analysis/ScopInfo.cpp 1189 Loop *SurroundingLoop,
1196 Loop *SurroundingLoop,
1246 Loop *ScopStmt::getLoopForDimension(unsigned Dimension) const {
2369 void Scop::addScopStmt(BasicBlock *BB, StringRef Name, Loop *SurroundingLoop,
2382 void Scop::addScopStmt(Region *R, StringRef Name, Loop *SurroundingLoop,
2462 int Scop::getRelativeLoopDepth(const Loop *L) const {
2470 Loop *OuterLoop = R.outermostLoopInRegion(const_cast<Loop *>(L));
tools/polly/lib/CodeGen/BlockGenerators.cpp 67 Loop *L) const {
98 LoopToScevMapT <S, Loop *L) const {
267 ScopStmt &Stmt, Loop *L, Value *Pointer, ValueMapT &BBMap,
295 BlockGenerator::getImplicitAddress(MemoryAccess &Access, Loop *L,
306 Loop *BlockGenerator::getLoopForStmt(const ScopStmt &Stmt) const {
351 Loop *L = getLoopForStmt(Stmt);
758 Loop *L = LI.getLoopFor(Stmt.getBasicBlock());
994 if (Loop *L = LI.getLoopFor(EUser->getParent()))
1021 Loop *L) {
1176 Loop *L = getLoopForStmt(Stmt);
1581 Loop *L = LI.getLoopFor(BB);
1622 ValueMapT &BBMap, Loop *L) {
1667 Loop *L = LI.getLoopFor(Stmt->getRegion()->getExit());
tools/polly/lib/CodeGen/IRBuilder.cpp 98 void ScopAnnotator::pushLoop(Loop *L, bool IsParallel) {
123 void ScopAnnotator::annotateLoopLatch(BranchInst *B, Loop *L, bool IsParallel,
tools/polly/lib/CodeGen/IslNodeBuilder.cpp 217 auto *Scope = References.LI.getLoopFor(BB);
310 SetVector<const Loop *> &Loops) {
666 SetVector<const Loop *> Loops;
674 for (const Loop *L : Loops) {
725 for (const Loop *L : Loops)
801 Loop *L = LI.getLoopFor(CondBB);
959 Value *IslNodeBuilder::materializeNonScopLoopInductionVariable(const Loop *L) {
1287 if (Loop *L = LI.getLoopFor(CondBB))
1540 Loop *L = LI.getLoopFor(S.getEntry());
tools/polly/lib/CodeGen/LoopGenerators.cpp 103 Loop *OuterLoop = LI.getLoopFor(BeforeBB);
104 Loop *NewLoop = LI.AllocateLoop();
tools/polly/lib/CodeGen/Utils.cpp 151 if (Loop *L = LI.getLoopFor(SplitBlock)) {
tools/polly/lib/Exchange/JSONExporter.cpp 811 PA.preserveSet<AllAnalysesOn<Loop>>();
tools/polly/lib/Support/SCEVAffinator.cpp 87 Loop *SCEVAffinator::getScope() { return BB ? LI.getLoopFor(BB) : nullptr; }
167 bool SCEVAffinator::hasNSWAddRecForLoop(Loop *L) const {
201 auto *Scope = getScope();
499 auto *Scope = getScope();
516 auto *Scope = getScope();
tools/polly/lib/Support/SCEVValidator.cpp 136 Loop *Scope;
141 SCEVValidator(const Region *R, Loop *Scope, ScalarEvolution &SE,
497 Loop *Scope;
503 SCEVInRegionDependences(const Region *R, Loop *Scope, bool AllowLoops,
558 SetVector<const Loop *> &Loops;
561 SCEVFindLoops(SetVector<const Loop *> &Loops) : Loops(Loops) {}
571 void findLoops(const SCEV *Expr, SetVector<const Loop *> &Loops) {
627 llvm::Loop *Scope, bool AllowLoops,
635 bool isAffineExpr(const Region *R, llvm::Loop *Scope, const SCEV *Expr,
659 static bool isAffineExpr(Value *V, const Region *R, Loop *Scope,
676 bool isAffineConstraint(Value *V, const Region *R, llvm::Loop *Scope,
699 ParameterSetTy getParamsInAffineExpr(const Region *R, Loop *Scope,
tools/polly/lib/Support/ScopHelper.cpp 464 Loop *polly::getLoopSurroundingScop(Scop &S, LoopInfo &LI) {
470 Loop *L = LI.getLoopFor(S.getEntry());
483 unsigned polly::getNumBlocksInLoop(Loop *L) {
503 Loop *polly::getRegionNodeLoop(RegionNode *RN, LoopInfo &LI) {
506 Loop *L = LI.getLoopFor(BB);
532 Loop *L = LI.getLoopFor(NonAffineSubRegion->getEntry());
538 static bool hasVariantIndex(GetElementPtrInst *Gep, Loop *L, Region &R,
542 Loop *OuterLoop = R.outermostLoopInRegion(L);
552 Loop *L = LI.getLoopFor(LInst->getParent());
637 Loop *Scope) {
710 llvm::Loop *polly::getFirstNonBoxedLoopFor(llvm::Loop *L, llvm::LoopInfo &LI,
710 llvm::Loop *polly::getFirstNonBoxedLoopFor(llvm::Loop *L, llvm::LoopInfo &LI,
717 llvm::Loop *polly::getFirstNonBoxedLoopFor(llvm::BasicBlock *BB,
720 Loop *L = LI.getLoopFor(BB);
tools/polly/lib/Support/VirtualInstruction.cpp 22 Loop *UserScope = LI->getLoopFor(UserBB);
52 VirtualUse VirtualUse::create(Scop *S, ScopStmt *UserStmt, Loop *UserScope,
349 Loop *Scope = Stmt->getSurroundingLoop();
tools/polly/lib/Transform/DeLICM.cpp 788 isl::map makeValInst(Value *Val, ScopStmt *UserStmt, Loop *Scope,
tools/polly/lib/Transform/ForwardOpTree.cpp 392 ScopStmt *UseStmt, Loop *UseLoop,
393 ScopStmt *DefStmt, Loop *DefLoop,
544 ScopStmt *UseStmt, Loop *UseLoop,
545 ScopStmt *DefStmt, Loop *DefLoop,
615 ScopStmt *DefStmt, Loop *DefLoop,
691 ScopStmt *UseStmt, Loop *UseLoop, bool DoIt) {
693 Loop *DefLoop = nullptr;
801 Loop *InLoop = Stmt->getSurroundingLoop();
tools/polly/lib/Transform/ZoneAlgo.cpp 315 static bool isInsideLoop(Loop *OuterLoop, Loop *InnerLoop) {
315 static bool isInsideLoop(Loop *OuterLoop, Loop *InnerLoop) {
747 isl::map ZoneAlgorithm::makeValInst(Value *Val, ScopStmt *UserStmt, Loop *Scope,
874 llvm::Loop *Scope,
unittests/Analysis/IVDescriptorsTest.cpp 80 Loop *L = LI.getLoopFor(Header);
unittests/Analysis/LoopInfoTest.cpp 84 Loop *L = LI.getLoopFor(Header);
134 Loop *L = LI.getLoopFor(Header);
193 Loop &L_0 = *LI.getLoopFor(&*I++);
195 Loop &L_0_0 = *LI.getLoopFor(&*I++);
197 Loop &L_0_1 = *LI.getLoopFor(&*I++);
199 Loop &L_0_2 = *LI.getLoopFor(&*I++);
201 Loop &L_1 = *LI.getLoopFor(&*I++);
203 Loop &L_1_0 = *LI.getLoopFor(&*I++);
205 Loop &L_1_1 = *LI.getLoopFor(&*I++);
207 Loop &L_1_2 = *LI.getLoopFor(&*I++);
269 Loop *L = LI.getLoopFor(Header);
272 Optional<Loop::LoopBounds> Bounds = L->getBounds(SE);
327 Loop *L = LI.getLoopFor(Header);
330 Optional<Loop::LoopBounds> Bounds = L->getBounds(SE);
385 Loop *L = LI.getLoopFor(Header);
388 Optional<Loop::LoopBounds> Bounds = L->getBounds(SE);
443 Loop *L = LI.getLoopFor(Header);
446 Optional<Loop::LoopBounds> Bounds = L->getBounds(SE);
501 Loop *L = LI.getLoopFor(Header);
504 Optional<Loop::LoopBounds> Bounds = L->getBounds(SE);
560 Loop *L = LI.getLoopFor(Header);
563 Optional<Loop::LoopBounds> Bounds = L->getBounds(SE);
618 Loop *L = LI.getLoopFor(Header);
621 Optional<Loop::LoopBounds> Bounds = L->getBounds(SE);
673 Loop *L = LI.getLoopFor(Header);
676 Optional<Loop::LoopBounds> Bounds = L->getBounds(SE);
731 Loop *L = LI.getLoopFor(Header);
734 Optional<Loop::LoopBounds> Bounds = L->getBounds(SE);
790 Loop *L = LI.getLoopFor(Header);
793 Optional<Loop::LoopBounds> Bounds = L->getBounds(SE);
849 Loop *L = LI.getLoopFor(Header);
852 Optional<Loop::LoopBounds> Bounds = L->getBounds(SE);
909 Loop *L = LI.getLoopFor(Header);
912 Optional<Loop::LoopBounds> Bounds = L->getBounds(SE);
969 Loop *L = LI.getLoopFor(Header);
972 Optional<Loop::LoopBounds> Bounds = L->getBounds(SE);
1021 Loop *L = LI.getLoopFor(Header);
1024 Optional<Loop::LoopBounds> Bounds = L->getBounds(SE);
1078 Loop *L = LI.getLoopFor(Header);
1081 Optional<Loop::LoopBounds> Bounds = L->getBounds(SE);
1148 Loop *L = LI.getLoopFor(Header);
1151 Optional<Loop::LoopBounds> Bounds = L->getBounds(SE);
1176 Optional<Loop::LoopBounds> InnerBounds = L->getBounds(SE);
1239 Loop *L = LI.getLoopFor(Header);
1242 Optional<Loop::LoopBounds> Bounds = L->getBounds(SE);
1303 Loop *L = LI.getLoopFor(Header);
1349 Loop *L = LI.getLoopFor(Header);
1393 Loop *L = LI.getLoopFor(Header);
1436 Loop *L = LI.getLoopFor(Header);
unittests/Analysis/ScalarEvolutionTest.cpp 553 auto *L2 = *LI.begin();
554 auto *L1 = *std::next(LI.begin());
555 auto *L0 = *std::next(LI.begin(), 2);
860 auto *Loop = LI->getLoopFor(L);
960 auto *Loop = LI->getLoopFor(L);
1479 auto *Loop = LI.getLoopFor(I.getParent());
1524 auto *Loop = LI.getLoopFor(LoopHeaderBB);
1605 auto *Loop = LI.getLoopFor(LoopHeaderBB);
1778 auto *Loop = LI.getLoopFor(I.getParent());
1821 auto *Loop = LI.getLoopFor(LoopHeaderBB);
1875 auto *Loop = LI.getLoopFor(LoopHeaderBB);
unittests/Analysis/UnrollAnalyzerTest.cpp 33 Loop *L = LI->getLoopFor(Header);
unittests/IR/LegacyPassManagerTest.cpp 204 bool doInitialization(Loop* L, LPPassManager &LPM) override {
209 bool runOnLoop(Loop *L, LPPassManager &LPM) override {
unittests/IR/PassBuilderCallbacksTest.cpp 71 bool invalidate(IRUnitT &IR, const PreservedAnalyses &PA,
77 Result run(IRUnitT &IR, AnalysisManagerT &AM, ExtraArgTs... ExtraArgs) {
91 static bool invalidateCallback(IRUnitT &IR, const PreservedAnalyses &PA,
95 !PAC.template preservedSet<AllAnalysesOn<IRUnitT>>();
137 PreservedAnalyses run(IRUnitT &IR, AnalysisManagerT &AM,
164 : MockPassHandleBase<MockPassHandle<Loop>, Loop, LoopAnalysisManager,
164 : MockPassHandleBase<MockPassHandle<Loop>, Loop, LoopAnalysisManager,
169 static void invalidateLoop(Loop &L, LoopAnalysisManager &,
216 : MockAnalysisHandleBase<MockAnalysisHandle<Loop>, Loop,
216 : MockAnalysisHandleBase<MockAnalysisHandle<Loop>, Loop,
272 template <typename IRUnitT> std::string getName(const IRUnitT &IR) {
283 if (any_isa<const Loop *>(WrappedIR))
284 return any_cast<const Loop *>(WrappedIR)->getName().str();
374 using IRUnitT = TestIRUnitT;
375 using AnalysisManagerT = AnalysisManager<TestIRUnitT, ExtraAnalysisArgTs...>;
377 PassManager<TestIRUnitT, AnalysisManagerT, ExtraPassArgTs...>;
unittests/Transforms/Scalar/LoopPassManagerTest.cpp 64 bool invalidate(IRUnitT &IR, const PreservedAnalyses &PA,
70 Result run(IRUnitT &IR, AnalysisManagerT &AM, ExtraArgTs... ExtraArgs) {
83 static bool invalidateCallback(IRUnitT &IR, const PreservedAnalyses &PA,
87 !PAC.template preservedSet<AllAnalysesOn<IRUnitT>>();
122 : MockAnalysisHandleBase<MockLoopAnalysisHandleTemplate<I>, Loop,
164 PreservedAnalyses run(IRUnitT &IR, AnalysisManagerT &AM,
184 : MockPassHandleBase<MockLoopPassHandle, Loop, LoopAnalysisManager,
245 getLoopAnalysisResult(Loop &L, LoopAnalysisManager &AM,
531 PA.preserveSet<AllAnalysesOn<Loop>>();
690 return !(PAC.preserved() || PAC.preservedSet<AllAnalysesOn<Loop>>()) ||
811 PA.preserveSet<AllAnalysesOn<Loop>>();
834 PA.preserveSet<AllAnalysesOn<Loop>>();
952 auto *NewLoop = AR.LI.AllocateLoop();
998 auto *NewLoop = AR.LI.AllocateLoop();
1146 auto *NewLoop = AR.LI.AllocateLoop();
1188 Loop *NewLoops[] = {AR.LI.AllocateLoop(), AR.LI.AllocateLoop(),
1268 auto *NewLoop = AR.LI.AllocateLoop();
1444 Loop *ParentL = L.getParentLoop();
1494 auto *ParentL = L.getParentLoop();
1499 auto *NewSibling = AR.LI.AllocateLoop();
unittests/Transforms/Utils/CloningTest.cpp 425 Loop *L = LI.getLoopFor(Header);
432 Loop *NewLoop = cloneLoopWithPreheader(Preheader, Preheader, L, VMap,
436 Loop::block_iterator BI = NewLoop->block_begin();
unittests/Transforms/Utils/UnrollLoopTest.cpp 69 Loop *L = *LI.begin();
unittests/Transforms/Vectorize/VPlanSlpTest.cpp 39 VPInterleavedAccessInfo getInterleavedAccessInfo(Function &F, Loop *L,
usr/include/c++/7.4.0/bits/move.h 72 constexpr _Tp&&
83 constexpr _Tp&&
usr/include/c++/7.4.0/bits/range_access.h 48 begin(_Container& __cont) -> decltype(__cont.begin())
58 begin(const _Container& __cont) -> decltype(__cont.begin())
68 end(_Container& __cont) -> decltype(__cont.end())
78 end(const _Container& __cont) -> decltype(__cont.end())
usr/include/c++/7.4.0/bits/std_function.h 299 _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
628 using _Invoker_type = _Res (*)(const _Any_data&, _ArgTypes&&...);
usr/include/c++/7.4.0/bits/unique_ptr.h 824 make_unique(_Args&&... __args)
usr/include/c++/7.4.0/tuple 125 constexpr _Head_base(const _Head& __h)
132 constexpr _Head_base(_UHead&& __h)
159 static constexpr _Head&
162 static constexpr const _Head&
194 static constexpr _Head&
197 static constexpr const _Head&
210 constexpr _Tuple_impl(const _Head& __head, const _Tail&... __tail)
216 constexpr _Tuple_impl(_UHead&& __head, _UTail&&... __tail)
248 const _Head& __head, const _Tail&... __tail)
473 return __and_<is_constructible<_Elements, const _UElements&>...>::value;
479 return __and_<is_convertible<const _UElements&, _Elements>...>::value;
485 return __and_<is_constructible<_Elements, _UElements&&>...>::value;
491 return __and_<is_convertible<_UElements&&, _Elements>...>::value;
608 constexpr tuple(const _Elements&... __elements)
619 explicit constexpr tuple(const _Elements&... __elements)
646 constexpr tuple(_UElements&&... __elements)
730 const _Elements&... __elements)
741 const _Elements&... __elements)
1302 constexpr _Head&
1307 constexpr const _Head&
1313 constexpr __tuple_element_t<__i, tuple<_Elements...>>&
1319 constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
1325 constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
usr/include/c++/7.4.0/type_traits 1246 : public is_nothrow_constructible<_Tp, _Tp&&>
1554 { typedef _Tp type; };
1563 { typedef _Tp type; };
1574 remove_const<typename remove_volatile<_Tp>::type>::type type;
1633 { typedef _Tp type; };
1659 { typedef _Tp&& type; };
1983 { typedef _Up type; };
utils/unittest/googletest/include/gtest/gtest-printers.h 140 static void PrintValue(const T& value, ::std::ostream* os) {
205 ::std::basic_ostream<Char, CharTraits>& os, const T& x) {
206 TypeWithoutFormatter<T,
207 (internal::IsAProtocolMessage<T>::value ? kProtobuf :
208 internal::ImplicitlyConvertible<const T&, internal::BiggestInt>::value ?
223 void DefaultPrintNonContainerTo(const T& value, ::std::ostream* os) {
366 void UniversalPrint(const T& value, ::std::ostream* os);
373 const C& container, ::std::ostream* os) {
407 T* p, ::std::ostream* os) {
416 if (IsTrue(ImplicitlyConvertible<T*, const void*>::value)) {
439 const T& value, ::std::ostream* os) {
455 void PrintTo(const T& value, ::std::ostream* os) {
478 DefaultPrintTo(IsContainerTest<T>(0), is_pointer<T>(), value, os);
699 static void Print(const T& value, ::std::ostream* os) {
765 static void Print(const T& value, ::std::ostream* os) {
856 typedef T T1;
utils/unittest/googletest/include/gtest/internal/custom/raw-ostream.h 29 static const T& printable(const T& V) { return V; }
29 static const T& printable(const T& V) { return V; }
35 auto printable(const T &V) -> decltype(StreamSwitch<T>::printable(V)) {
35 auto printable(const T &V) -> decltype(StreamSwitch<T>::printable(V)) {
37 return StreamSwitch<T>::printable(V);