| /external/v8/src/compiler/ |
| loop-analysis.h | 34 // Represents a loop in the tree of loops, including the header nodes,
36 class Loop {
38 Loop* parent() const { return parent_; }
39 const ZoneVector<Loop*>& children() const { return children_; }
49 explicit Loop(Zone* zone)
56 Loop* parent_;
58 ZoneVector<Loop*> children_;
64 // Return the innermost nested loop, if any, that contains {node}.
65 Loop* ContainingLoop(Node* node) {
71 // Check if the {loop} contains the {node}, either directly or by containin
[all...] |
| loop-peeling.h | 8 #include "src/compiler/loop-analysis.h"
14 // Represents the output of peeling a loop, which is basically the mapping
15 // from the body of the loop to the corresponding nodes in the peeled
20 // the node was part of the body of the loop. Returns {node} otherwise.
29 // Implements loop peeling.
32 static bool CanPeel(LoopTree* loop_tree, LoopTree::Loop* loop);
34 LoopTree* loop_tree, LoopTree::Loop* loop,
|
| /external/llvm/include/llvm/Analysis/ |
| LoopPass.h | 10 // This file defines LoopPass class. All loop optimization
34 /// to a Loop.
39 // whatever action is necessary for the specified Loop.
40 virtual bool runOnLoop(Loop *L, LPPassManager &LPM) = 0;
46 virtual bool doInitialization(Loop *L, LPPassManager &LPM) {
50 // Finalization hook does not supply Loop because at this time
51 // loop nest is completely different.
77 /// Each loop pass can override these simple analysis hooks to update
80 virtual void cloneBasicBlockAnalysis(BasicBlock *F, BasicBlock *T, Loop *L) {}
83 virtual void deleteAnalysisValue(Value *V, Loop *L) {
[all...] |
| ScalarEvolutionNormalization.h | 21 // While the expression for most uses of i inside the loop is {0,+,1}<%L>, the
22 // expression for the use of i outside the loop is {1,+,1}<%L>, since i is
23 // incremented at the end of the loop body. This is inconveient, since it
26 // the same induction variable, with uses inside the loop using the
27 // "pre-incremented" value, and uses after the loop using the
45 class Loop;
56 /// update the given loop set, and normalize.
59 /// given loop set.
64 typedef SmallPtrSet<const Loop *, 2> PostIncLoopSet;
|
| VectorUtils.h | 27 class Loop;
70 /// getGEPInductionOperand. However, if there is some other non-loop-invariant
72 Value *stripGetElementPtr(Value *Ptr, ScalarEvolution *SE, Loop *Lp);
75 Value *getUniqueCastUse(Value *Ptr, Loop *Lp, Type *Ty);
77 /// \brief Get the stride of a pointer access in a loop. Looks for symbolic
79 Value *getStrideFromPointer(Value *Ptr, ScalarEvolution *SE, Loop *Lp);
|
| DependenceAnalysis.h | 50 class Loop;
106 bool Splitable : 1; // Splitting the loop will break dependence.
144 /// isLoopIndependent - Returns true if this is a loop-independent
170 /// this loop will break this dependence.
174 /// this loop will break this dependence.
177 /// isSplitable - Returns true if splitting this loop will break
183 /// variable associated with the loop at this level.
230 /// isLoopIndependent - Returns true if this is a loop-independent
256 /// this loop will break this dependence.
260 /// this loop will break this dependence
[all...] |
| BlockFrequencyInfoImpl.h | 39 class Loop;
192 /// \brief Data about a loop.
194 /// Contains the data necessary to represent a loop as a pseudo-node once it's
200 LoopData *Parent; ///< The parent loop.
204 NodeList Nodes; ///< Header and the members of the loop.
205 HeaderMassList BackedgeMass; ///< Mass returned to each loop header.
230 assert(isHeader(B) && "this is only valid on loop header blocks");
246 /// \brief Index of loop information.
249 LoopData *Loop; ///< The loop this block is inside
[all...] |
| IVUsers.h | 73 /// given loop.
74 void transformToPostInc(const Loop *L);
122 Loop *L;
138 bool runOnLoop(Loop *L, LPPassManager &LPM) override;
146 Loop *getLoop() const { return L; }
162 const SCEV *getStride(const IVStrideUse &IU, const Loop *L) const;
181 bool AddUsersImpl(Instruction *I, SmallPtrSetImpl<Loop*> &SimpleLoopNests);
|
| ScalarEvolutionExpander.h | 51 /// A memoization of the "relevant" loop for a given SCEV.
52 DenseMap<const SCEV *, const Loop *> RelevantLoops;
61 /// \brief When this is non-null, addrecs expanded in the loop it indicates
63 const Loop *IVIncInsertLoop;
65 /// \brief When expanding addrecs in the IVIncInsertLoop loop, insert the IV
124 bool isHighCostExpansion(const SCEV *Expr, Loop *L,
131 /// specified type for the specified loop (inserting one if there is none).
134 PHINode *getOrInsertCanonicalInductionVariable(const Loop *L, Type *Ty);
145 unsigned replaceCongruentIVs(Loop *L, const DominatorTree *DT,
170 /// \brief Set the current IV increment loop and position
[all...] |
| CodeMetrics.h | 25 class Loop;
94 /// \brief Collect a loop's ephemeral values (those used only by an assume
95 /// or similar intrinsics in the loop).
96 static void collectEphemeralValues(const Loop *L, AssumptionCache *AC,
|
| ScalarEvolution.h | 48 class Loop;
92 /// the integer domain, abs(step) * max-iteration(loop) <=
163 /// traversal loop, you will get one of these. None of the standard SCEV
320 /// An enum describing the relationship between a SCEV and a loop.
322 LoopVariant, ///< The SCEV is loop-variant (unknown).
323 LoopInvariant, ///< The SCEV is loop-invariant.
324 LoopComputable ///< The SCEV varies predictably with the loop.
379 /// The loop information for the function we are currently analyzing.
399 /// conditions dominating the backedge of a loop.
406 /// Information about the number of loop iterations for which a loop exit'
[all...] |
| LoopInfo.h | 1 //===- llvm/Analysis/LoopInfo.h - Natural Loop Calculator -------*- C++ -*-===//
11 // and determine the loop depth of various nodes of the CFG. A natural loop
16 // each natural loop identified, this analysis identifies natural loops
17 // contained entirely within the loop and the basic blocks the make up the loop.
21 // * whether there is a preheader for the loop
23 // * whether or not a particular block branches out of the loop
24 // * the successor blocks of the loop
25 // * the loop dept
[all...] |
| /external/llvm/include/llvm/Transforms/Utils/ |
| LoopVersioning.h | 1 //===- LoopVersioning.h - Utility to version a loop -------------*- C++ -*-===//
10 // This file defines a utility class to perform loop versioning. The versioned
11 // loop speculates that otherwise may-aliasing memory accesses don't overlap and
26 class Loop;
31 /// \brief This class emits a version of the loop where run-time checks ensure
34 /// It currently only supports single-exit loops and assumes that the loop
38 /// \brief Expects LoopAccessInfo, Loop, LoopInfo, DominatorTree as input.
42 LoopVersioning(const LoopAccessInfo &LAI, Loop *L, LoopInfo *LI,
46 /// \brief Performs the CFG manipulation part of versioning the loop including
49 /// The loop that was used to construct the class will be the "versioned" loo
[all...] |
| UnrollLoop.h | 10 // This file defines some loop unrolling utilities. It does not define any
11 // actual pass or policy, but provides a single function to perform loop
25 class Loop;
32 bool UnrollLoop(Loop *L, unsigned Count, unsigned TripCount, bool AllowRuntime,
37 bool UnrollRuntimeLoopProlog(Loop *L, unsigned Count,
|
| SimplifyIndVar.h | 12 // simplify a loop's induction variables based on ScalarEvolution.
27 class Loop;
65 /// loop. This does not actually change or add IVs.
66 bool simplifyLoopIVs(Loop *L, ScalarEvolution *SE, DominatorTree *DT,
|
| LoopUtils.h | 1 //===- llvm/Transforms/Utils/LoopUtils.h - Loop utilities -*- C++ -*-=========//
10 // This file defines some loop transformation utilities.
29 class Loop;
36 /// \brief Captures loop safety information.
37 /// It keep information for loop & its header may throw exception.
39 bool MayThrow; // The current loop contains an instruction which
41 bool HeaderMayThrow; // Same as previous, but specific to loop header
47 /// loop. Reduction is a special case of recurrence that has uses of the
48 /// recurrence variable outside the loop. The method isReductionPHI identifies
166 static bool AddReductionVar(PHINode *Phi, RecurrenceKind Kind, Loop *TheLoop
[all...] |
| /toolchain/binutils/binutils-2.25/gas/testsuite/gas/hppa/parse/ |
| nosubspace.s | 12 Loop:
17 addib,<> -1,%r23,Loop
|
| /external/llvm/lib/Analysis/ |
| LoopInfo.cpp | 1 //===- LoopInfo.cpp - Natural Loop Calculator -----------------------------===//
11 // and determine the loop depth of various nodes of the CFG. Note that the
13 // header node... not just a single natural loop.
37 template class llvm::LoopBase<BasicBlock, Loop>;
38 template class llvm::LoopInfoBase<BasicBlock, Loop>;
47 VerifyLoopInfoX("verify-loop-info", cl::location(VerifyLoopInfo),
48 cl::desc("Verify loop info (time consuming)"));
50 // Loop identifier metadata name.
51 static const char *const LoopMDName = "llvm.loop";
54 // Loop implementatio
[all...] |
| LoopPass.cpp | 1 //===- LoopPass.cpp - Loop Pass and Loop Pass Manager ---------------------===//
10 // This file implements LoopPass and LPPassManager. All loop optimization
25 #define DEBUG_TYPE "loop-pass-manager"
29 /// PrintLoopPass - Print a Function corresponding to a Loop.
44 bool runOnLoop(Loop *L, LPPassManager &) override {
65 // Inset loop into loop nest (LoopInfo) and loop queue (LQ).
66 Loop &LPPassManager::addLoop(Loop *ParentLoop)
[all...] |
| BlockFrequencyInfoImpl.cpp | 301 // If OuterLoop is an irreducible loop, we can't actually handle this.
310 // If "Pred" is a loop header, then this isn't really a backedge; rather,
312 // secondary loop headers.
323 const LoopData *OuterLoop, LoopData &Loop, Distribution &Dist) {
325 for (const auto &I : Loop.Exits)
326 if (!addToDist(Dist, OuterLoop, Loop.getHeader(), I.first,
334 /// \brief Compute the loop scale for a loop.
335 void BlockFrequencyInfoImplBase::computeLoopScale(LoopData &Loop) {
336 // Compute loop scale
[all...] |
| /external/llvm/lib/Target/Hexagon/ |
| HexagonTargetTransformInfo.cpp | 31 void HexagonTTIImpl::getUnrollingPreferences(Loop *L,
|
| /external/llvm/lib/Target/WebAssembly/ |
| WebAssemblyCFGStackify.cpp | 18 /// Then, it inserts BLOCK and LOOP markers to mark the start of scopes, since
114 static bool LoopContains(const MachineLoop *Loop,
116 return Loop ? Loop->contains(MBB) : true;
125 MachineLoop *Loop = MLI.getLoopFor(MBB);
135 // loop.
136 bool LoopContainsA = LoopContains(Loop, A);
137 bool LoopContainsB = LoopContains(Loop, B);
156 /// Return the "bottom" block of a loop. This differs from
157 /// MachineLoop::getBottomBlock in that it works even if the loop i
[all...] |
| /external/llvm/test/MC/COFF/ |
| simple-fixups.s | 19 # =>This Inner Loop Header: Depth=1
32 # =>This Inner Loop Header: Depth=1
|
| /toolchain/binutils/binutils-2.25/gas/testsuite/gas/xgate/ |
| insns.s | 10 Loop:
13 bne Loop
|
| /system/vold/ |
| Loop.h | 21 #include <linux/loop.h>
25 class Loop {
|
