| /src/external/apache2/llvm/dist/llvm/lib/Transforms/Vectorize/ |
| VPlanHCFGBuilder.h | 19 /// to easily add more nodes before/after the main vector loop (such as the
33 class Loop;
41 // The outermost loop of the input loop nest considered for vectorization.
42 Loop *TheLoop;
44 // Loop Info analysis.
63 VPlanHCFGBuilder(Loop *Lp, LoopInfo *LI, VPlan &P)
|
| /src/external/apache2/llvm/dist/llvm/include/llvm/Transforms/Utils/ |
| LoopPeel.h | 9 // This file defines some loop peeling utilities. It does not define any
21 bool canPeel(Loop *L);
23 bool peelLoop(Loop *L, unsigned PeelCount, LoopInfo *LI, ScalarEvolution *SE,
27 gatherPeelingPreferences(Loop *L, ScalarEvolution &SE,
33 void computePeelCount(Loop *L, unsigned LoopSize,
|
| LoopUtils.h | 1 //===- llvm/Transforms/Utils/LoopUtils.h - Loop utilities -------*- C++ -*-===//
9 // This file defines some loop transformation utilities.
32 class Loop;
57 BasicBlock *InsertPreheaderForLoop(Loop *L, DominatorTree *DT, LoopInfo *LI,
60 /// Ensure that all exit blocks of the loop are dedicated exits.
62 /// For any loop exit block with non-loop predecessors, we split the loop
63 /// predecessors to use a dedicated loop exit block. We update the dominator
64 /// tree and loop info if provided, and will preserve LCSSA if requested
[all...] |
| LoopRotationUtils.h | 1 //===- LoopRotationUtils.h - Utilities to perform loop rotation -*- C++ -*-===//
9 // This file provides utilities to convert a loop into a loop with bottom test.
20 class Loop;
27 /// Convert a loop into a loop with bottom test. It may
28 /// perform loop latch simplication as well if the flag RotationOnly
29 /// is false. The flag Threshold represents the size threshold of the loop
30 /// header. If the loop header's size exceeds the threshold, the loop rotatio
[all...] |
| LoopVersioning.h | 1 //===- LoopVersioning.h - Utility to version a loop -------------*- C++ -*-===//
9 // This file defines a utility class to perform loop versioning. The versioned
10 // loop speculates that otherwise may-aliasing memory accesses don't overlap and
25 class Loop;
35 /// This class emits a version of the loop where run-time checks ensure
38 /// It currently only supports single-exit loops and assumes that the loop
42 /// Expects LoopAccessInfo, Loop, LoopInfo, DominatorTree as input.
47 ArrayRef<RuntimePointerCheck> Checks, Loop *L, LoopInfo *LI,
50 /// Performs the CFG manipulation part of versioning the loop including
53 /// The loop that was used to construct the class will be the "versioned" loo
[all...] |
| UnrollLoop.h | 9 // This file defines some loop unrolling utilities. It does not define any
10 // actual pass or policy, but provides a single function to perform loop
29 class Loop;
38 using NewLoopsMap = SmallDenseMap<const Loop *, Loop *, 4>;
42 const char *const LLVMLoopUnrollFollowupAll = "llvm.loop.unroll.followup_all";
44 "llvm.loop.unroll.followup_unrolled";
46 "llvm.loop.unroll.followup_remainder";
49 const Loop* addClonedBlockToLoopInfo(BasicBlock *OriginalBB,
55 /// The loop was not modified
[all...] |
| /src/external/apache2/llvm/dist/llvm/include/llvm/Analysis/ |
| LoopNestAnalysis.h | 10 /// This file defines the interface for the loop nest analysis.
23 using LoopVectorTy = SmallVector<Loop *, 8>;
26 /// This class represents a loop nest and can be used to query its properties.
29 /// Construct a loop nest rooted by loop \p Root.
30 LoopNest(Loop &Root, ScalarEvolution &SE);
36 static std::unique_ptr<LoopNest> getLoopNest(Loop &Root, ScalarEvolution &SE);
49 static bool arePerfectlyNested(const Loop &OuterLoop, const Loop &InnerLoop,
52 /// Return the maximum nesting depth of the loop nest rooted by loop \p Root
[all...] |
| LoopCacheAnalysis.h | 10 /// This file defines the interface for the loop cache analysis.
32 using LoopVectorTy = SmallVector<Loop *, 8>;
36 /// 3-dim loop nest:
78 /// the given loop \p L. Return false if the distance is not smaller than \p
81 unsigned MaxDistance, const Loop &L,
84 /// Compute the cost of the reference w.r.t. the given loop \p L when it is
85 /// considered in the innermost position in the loop nest.
87 /// - equal to one if the reference is loop invariant, or
90 /// + the coefficient of this loop's index variable used in all other
93 CacheCostTy computeRefCost(const Loop &L, unsigned CLS) const
[all...] |
| LoopPass.h | 9 // This file defines LoopPass class. All loop optimization
32 /// to a Loop.
37 // whatever action is necessary for the specified Loop.
38 virtual bool runOnLoop(Loop *L, LPPassManager &LPM) = 0;
44 virtual bool doInitialization(Loop *L, LPPassManager &LPM) {
48 // Finalization hook does not supply Loop because at this time
49 // loop nest is completely different.
72 bool skipLoop(const Loop *L) const;
88 StringRef getPassName() const override { return "Loop Pass Manager"; }
107 // Add a new loop into the loop queue
[all...] |
| LoopAnalysisManager.h | 1 //===- LoopAnalysisManager.h - Loop analysis management ---------*- C++ -*-===//
10 /// This header provides classes for managing per-loop analyses. These are
11 /// typically used as part of a loop pass pipeline over the loop nests of
14 /// Loop analyses are allowed to make some simplifying assumptions:
23 /// The primary mechanism to provide these invariants is the loop pass manager,
24 /// but they can also be manually provided in order to reason about a loop from
41 class Loop;
48 /// The adaptor from a function pass to a loop pass computes these analyses and
49 /// makes them available to the loop passes "for free". Each loop pass i
[all...] |
| DivergenceAnalysis.h | 28 class Loop;
39 /// \brief This instance will analyze the whole function \p F or the loop \p
46 DivergenceAnalysisImpl(const Function &F, const Loop *RegionLoop,
50 /// \brief The loop that defines the analyzed region (if any).
51 const Loop *getRegionLoop() const { return RegionLoop; }
94 /// is a divergent loop exit of \p DivLoop. Mark those instructions as
97 const Loop &DivLoop);
101 const Loop &OuterDivLoop);
106 const Loop &OuterDivLoop);
126 const Loop *RegionLoop
[all...] |
| ScalarEvolutionNormalization.h | 20 // While the expression for most uses of i inside the loop is {0,+,1}<%L>, the
21 // expression for the use of i outside the loop is {1,+,1}<%L>, since i is
22 // incremented at the end of the loop body. This is inconveient, since it
25 // the same induction variable, with uses inside the loop using the
26 // "pre-incremented" value, and uses after the loop using the
43 class Loop;
48 typedef SmallPtrSet<const Loop *, 2> PostIncLoopSet;
|
| /src/external/apache2/llvm/dist/llvm/include/llvm/Transforms/Scalar/ |
| IndVarSimplify.h | 22 class Loop;
31 PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
|
| LoopIdiomRecognize.h | 1 //===- LoopIdiomRecognize.h - Loop Idiom Recognize Pass ---------*- C++ -*-===//
10 // non-loop form. In cases that this kicks in, it can be a significant
23 class Loop;
26 /// Options to disable Loop Idiom Recognize, which can be shared with other
39 /// Performs Loop Idiom Recognize Pass.
42 PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
|
| LoopInstSimplify.h | 1 //===- LoopInstSimplify.h - Loop Inst Simplify Pass -------------*- C++ -*-===//
9 // This pass performs lightweight instruction simplification on loop bodies.
21 class Loop;
24 /// Performs Loop Inst Simplify Pass.
27 PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
|
| LoopStrengthReduce.h | 1 //===- LoopStrengthReduce.h - Loop Strength Reduce Pass ---------*- C++ -*-===//
14 // have as one or more of their components the loop induction variable, it
17 // related to loop induction variables.
29 class Loop;
32 /// Performs Loop Strength Reduce Pass.
35 PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
|
| LoopPredication.h | 1 //===- LoopPredication.h - Guard based loop predication pass ----*- C++ -*-===//
9 // This pass tries to convert loop variant range checks to loop invariant by
10 // widening checks across loop iterations.
23 /// Performs Loop Predication Pass.
26 PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
|
| LoopSimplifyCFG.h | 1 //===- LoopSimplifyCFG.cpp - Loop CFG Simplification Pass -------*- C++ -*-===//
9 // This file implements the Loop SimplifyCFG Pass. This pass is responsible for
10 // basic loop CFG cleanup, primarily to assist other loop passes. If you
11 // encounter a noncanonical CFG construct that causes another loop pass to
25 /// Performs basic CFG simplifications to assist other loop passes.
28 PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
|
| LoopVersioningLICM.h | 1 //===- LoopVersioningLICM.h - LICM Loop Versioning ------------------------===//
19 PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
|
| /src/external/apache2/llvm/dist/llvm/lib/Target/Hexagon/ |
| HexagonVectorLoopCarriedReuse.h | 11 // to identify loop carried dependences. This is scalar replacement for vector
15 // Motivation: Consider the case where we have the following loop structure.
17 // Loop:
26 // cond_branch <Loop>
32 // Loop:
39 // cond_branch <Loop>
42 // Such a loop comes to this pass in the following form.
46 // Loop:
47 // X2 = PHI<(X0, LoopPreheader), (X1, Loop)>
55 // cond_branch <Loop>
[all...] |
| HexagonLoopIdiomRecognition.h | 19 PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
|
| /src/external/apache2/llvm/dist/llvm/tools/llvm-exegesis/lib/ |
| SnippetRepetitor.cpp | 55 // Loop over the snippet ceil(MinInstructions / Instructions.Size()) times.
61 auto Loop = Filler.addBasicBlock();
64 // Set loop counter to the right value:
71 // Set up the loop basic block.
72 Entry.MBB->addSuccessor(Loop.MBB, BranchProbability::getOne());
73 Loop.MBB->addSuccessor(Loop.MBB, BranchProbability::getOne());
74 // The live ins are: the loop counter, the registers that were setup by
76 Loop.MBB->addLiveIn(LoopCounter);
78 Loop.MBB->addLiveIn(Reg)
[all...] |
| /src/usr.sbin/mopd/common/ |
| device.h | 40 /* from loop-bsd.c */
41 __dead void Loop(void);
|
| /src/external/apache2/llvm/dist/llvm/lib/CodeGen/ |
| MachineLoopUtils.cpp | 28 MachineBasicBlock *Loop,
31 MachineFunction &MF = *Loop->getParent();
32 MachineBasicBlock *Preheader = *Loop->pred_begin();
33 if (Preheader == Loop)
34 Preheader = *std::next(Loop->pred_begin());
35 MachineBasicBlock *Exit = *Loop->succ_begin();
36 if (Exit == Loop)
37 Exit = *std::next(Loop->succ_begin());
39 MachineBasicBlock *NewBB = MF.CreateMachineBasicBlock(Loop->getBasicBlock());
41 MF.insert(Loop->getIterator(), NewBB)
[all...] |
| /src/external/apache2/llvm/dist/llvm/lib/Analysis/ |
| LoopAnalysisManager.cpp | 1 //===- LoopAnalysisManager.cpp - Loop analysis management -----------------===//
25 template class AllAnalysesOn<Loop>;
26 template class AnalysisManager<Loop, LoopStandardAnalysisResults &>;
28 template class OuterAnalysisManagerProxy<FunctionAnalysisManager, Loop,
39 SmallVector<Loop *, 4> PreOrderLoops = LI->getLoopsInReverseSiblingPreorder();
41 // If this proxy or the loop info is going to be invalidated, we also need
43 // away the loop analyses if any of the standard analyses provided by the
44 // loop pass manager go away so that loop analyses can freely use these
47 // loop analyses declare any dependencies on these and use the more genera
[all...] |
