| /external/llvm/include/llvm/Analysis/ |
| LoopAccessAnalysis.h | 10 // This file defines the interface for the loop memory dependence framework that
11 // was originally developed for the Loop Vectorizer.
33 class Loop;
68 const Loop *TheLoop,
72 /// \brief Collection of parameters shared beetween the Loop Vectorizer and the
73 /// Loop Access Analysis.
95 /// different underlying pointers. Clients, such as the loop vectorizer, will
99 /// functions pairs. Since we currently don't restructure the loop we can rely
141 // FIXME: If we only have loop-independent forward dependences (e.g. a
144 // enumerating loop-independent forward dependences i
[all...] |
| LoopIterator.h | 1 //===--------- LoopIterator.h - Iterate over loop blocks --------*- C++ -*-===//
9 // This file defines iterators to visit the basic blocks within a loop.
12 // Unfortunately we have no efficient way of summarizing loop exits which would
15 // If you want to visit all blocks in a loop and don't need an ordered traveral,
16 // use Loop::block_begin() instead.
20 // contained within the loop according to the most recent LoopInfo analysis are
21 // reachable from the loop header.
35 /// single loop.
47 Loop *L;
56 LoopBlocksDFS(Loop *Container)
[all...] |
| /external/llvm/lib/Transforms/Scalar/ |
| LoopInterchange.cpp | 1 //===- LoopInterchange.cpp - Loop interchange pass------------------------===//
10 // This Pass handles loop interchange transform.
46 #define DEBUG_TYPE "loop-interchange"
50 typedef SmallVector<Loop *, 8> LoopVector;
58 // Maximum loop depth supported.
75 Loop *L, DependenceAnalysis *DA) {
86 for (Loop::block_iterator BB = L->block_begin(), BE = L->block_end();
171 << " dependencies inside loop\n");
185 // A loop is moved from index 'from' to an index 'to'. Update the Dependence
242 // If OuterLoopId represents outermost loop then interchanging will make th
[all...] |
| LICM.cpp | 1 //===-- LICM.cpp - Loop Invariant Code Motion Pass ------------------------===//
10 // This pass performs loop invariant code motion, attempting to remove as much
11 // code from the body of a loop as possible. It does this by either hoisting
13 // safe. This pass also promotes must-aliased memory locations in the loop to
18 // 1. Moving loop invariant loads and calls out of loops. If we can determine
19 // that a load or call inside of a loop never aliases anything stored to,
22 // the loop, we try to move the store to happen AFTER the loop instead of
23 // inside of the loop. This can only happen if a few conditions are true:
24 // A. The pointer stored through is loop invarian
[all...] |
| LoopUnswitch.cpp | 1 //===-- LoopUnswitch.cpp - Hoist loop-invariant conditionals in loop ------===//
10 // This pass transforms loops that contain branches on loop-invariant conditions
21 // a loop is unswitched) so we only unswitch if the resultant code will be
25 // of the loop, to make the unswitching opportunity obvious.
63 #define DEBUG_TYPE "loop-unswitch"
75 Threshold("loop-unswitch-threshold", cl::desc("Max loop size to unswitch"),
79 LoopUnswitchWithBlockFrequency("loop-unswitch-with-block-frequency",
85 ColdnessThreshold("loop-unswitch-coldness-threshold", cl::init(1), cl::Hidden
[all...] |
| LoopDeletion.cpp | 1 //===- LoopDeletion.cpp - Dead Loop Deletion Pass ---------------===//
10 // This file implements the Dead Loop Deletion Pass. This pass is responsible
26 #define DEBUG_TYPE "loop-delete"
38 // Possibly eliminate loop L if it is dead.
39 bool runOnLoop(Loop *L, LPPassManager &) override;
57 bool isLoopDead(Loop *L, SmallVectorImpl<BasicBlock *> &exitingBlocks,
65 INITIALIZE_PASS_BEGIN(LoopDeletion, "loop-deletion",
72 INITIALIZE_PASS_END(LoopDeletion, "loop-deletion",
79 /// isLoopDead - Determined if a loop is dead. This assumes that we've already
82 bool LoopDeletion::isLoopDead(Loop *L
[all...] |
| LoopDistribute.cpp | 1 //===- LoopDistribute.cpp - Loop Distribution Pass ------------------------===//
10 // This file implements the Loop Distribution Pass. Its main focus is to
12 // tries to isolate the offending dependences into a new loop allowing
20 // Similarly to the Vectorizer, the pass also supports loop versioning to
41 #define LDIST_NAME "loop-distribute"
47 LDistVerify("loop-distribute-verify", cl::Hidden,
49 "after Loop Distribution"),
53 "loop-distribute-non-if-convertible", cl::Hidden,
54 cl::desc("Whether to distribute into a loop that may not be "
55 "if-convertible by the loop vectorizer")
[all...] |
| /build/kati/ |
| thread_pool.cc | 32 threads_.push_back(thread([this]() { Loop(); }));
60 void Loop() {
|
| /external/llvm/include/llvm/Transforms/Utils/ |
| CodeExtractor.h | 25 class Loop;
72 /// \brief Create a code extractor for a loop body.
75 /// block sequence of the loop.
76 CodeExtractor(DominatorTree &DT, Loop &L, bool AggregateArgs = false);
|
| Cloning.h | 13 // functions, to copying basic blocks to support loop unrolling or superblock
45 class Loop;
90 /// from (loop unrolling would use this, for example).
249 /// \brief Clones a loop \p OrigLoop. Returns the loop and the blocks in \p
252 /// Updates LoopInfo and DominatorTree assuming the loop is dominated by block
254 Loop *cloneLoopWithPreheader(BasicBlock *Before, BasicBlock *LoopDomBB,
255 Loop *OrigLoop, ValueToValueMapTy &VMap,
|
| /system/vold/ |
| Loop.cpp | 36 #include "Loop.h"
41 int Loop::dumpState(SocketClient *c) {
50 sprintf(filename, "/dev/block/loop%d", i);
68 SLOGE("Unable to get loop status for %s (%s)", filename,
83 int Loop::lookupActive(const char *id, char *buffer, size_t len) {
94 sprintf(filename, "/dev/block/loop%d", i);
113 SLOGE("Unable to get loop status for %s (%s)", filename,
130 int Loop::create(const char *id, const char *loopFile, char *loopDeviceBuffer, size_t len) {
140 sprintf(filename, "/dev/block/loop%d", i);
143 * The kernel starts us off with 8 loop nodes, but mor
[all...] |
| /toolchain/binutils/binutils-2.25/gas/testsuite/gas/m68hc11/ |
| insns.s | 9 Loop:
12 bne Loop
|
| insns-dwarf2.d | 23 0+06 <Loop>:
24 Loop:
29 bne Loop
30 a: 26 fa bne 0x6 <Loop>
|
| insns.d | 13 0+0006 <Loop> jsr 0x0+0+ <_start>
16 0+0009 <Loop\+0x3> dex
17 0+000a <Loop\+0x4> bne 0x0+0006 <Loop>
|
| /toolchain/binutils/binutils-2.25/gas/testsuite/gas/xgate/ |
| insns-dwarf2.d | 28 0+000c <Loop>:
29 Loop:
34 bne Loop
35 10: 25 fd bne \*-4 Abs\* 0xc <Loop>
|
| insns.d | 20 0+000c <Loop> bra \*10 Abs\* 0x00000016 <test>
21 0+000e <Loop\+0x2> nop
22 0+0010 <Loop\+0x4> bne \*\-4 Abs\* 0x0000000c <Loop>
|
| /external/llvm/lib/Analysis/ |
| IVUsers.cpp | 52 /// given loop.
53 static bool isInteresting(const SCEV *S, const Instruction *I, const Loop *L,
57 // Keep things simple. Don't touch loop-variant strides unless they're
58 // only used outside the loop and we can simplify them.
87 /// Return true if all loop headers that dominate this block are in simplified
91 SmallPtrSetImpl<Loop*> &SimpleLoopNests) {
92 Loop *NearestLoop = nullptr;
96 Loop *DomLoop = LI->getLoopFor(DomBB);
98 // If the domtree walk reaches a loop with no preheader, return false.
101 // If we have already checked this loop nest, stop checking
[all...] |
| CFG.cpp | 23 /// loop backedges in the function and return them. This is a relatively cheap
24 /// (compared to computing dominators and loop info) analysis.
111 // LoopInfo contains a mapping from basic block to the innermost loop. Find
112 // the outermost loop in the loop nest that contains BB.
113 static const Loop *getOutermostLoop(const LoopInfo *LI, const BasicBlock *BB) {
114 const Loop *L = LI->getLoopFor(BB);
116 while (const Loop *Parent = L->getParentLoop())
122 // True if there is a loop which contains both BB1 and BB2.
125 const Loop *L1 = getOutermostLoop(LI, BB1)
[all...] |
| /external/icu/android_icu4j/src/main/tests/android/icu/dev/util/ |
| Timer.java | 88 public abstract static class Loop {
93 public long timeIterations(Loop loop, Object... params) {
99 loop.init(params);
102 loop.time(1);
109 loop.time(iterations);
|
| /external/icu/icu4j/main/tests/framework/src/com/ibm/icu/dev/util/ |
| Timer.java | 87 public abstract static class Loop {
92 public long timeIterations(Loop loop, Object... params) {
98 loop.init(params);
101 loop.time(1);
108 loop.time(iterations);
|
| /frameworks/av/media/libstagefright/codecs/on2/h264dec/omxdl/arm11/vc/m4p2/src/ |
| omxVCM4P2_QuantInvInter_I_s.s | 104 Loop
148 BGT Loop
|
| /external/llvm/lib/Target/WebAssembly/ |
| Relooper.cpp | 334 // loop
361 // Find the inner blocks in this loop. Proceed backwards from the entries
388 LoopShape *Loop = new LoopShape();
389 Notice(Loop);
391 // Solipsize the loop, replacing with break/continue and marking branches
393 // A. Branches to the loop entries become a continue to this shape
395 Solipsize(iter, Branch::Continue, Loop, InnerBlocks);
396 // B. Branches to outside the loop (a next entry) become breaks on this
399 Solipsize(iter, Branch::Break, Loop, InnerBlocks);
402 Loop->Inner = Inner
[all...] |
| /external/llvm/lib/Transforms/Utils/ |
| LoopSimplify.cpp | 1 //===- LoopSimplify.cpp - Loop Canonicalization Pass ----------------------===//
14 // Loop pre-header insertion guarantees that there is a single, non-critical
15 // entry edge from outside of the loop to the loop header. This simplifies a
18 // Loop exit-block insertion guarantees that all exit blocks from the loop
19 // (blocks which are outside of the loop that have predecessors inside of the
20 // loop) only have predecessors from inside of the loop (and are thus dominated
21 // by the loop header). This simplifies transformations such as store-sinkin
[all...] |
| LoopUnroll.cpp | 1 //===-- UnrollLoop.cpp - Loop unrolling utilities -------------------------===//
10 // This file implements some loop unrolling utilities. It does not define any
11 // actual pass or policy, but provides a single function to perform loop
41 #define DEBUG_TYPE "loop-unroll"
70 /// successful references to the containing loop must be removed from
77 SmallPtrSetImpl<Loop *> &ForgottenLoops) {
111 // ScalarEvolution holds references to loop exit blocks.
113 if (Loop *L = LI->getLoopFor(BB)) {
129 /// Unroll the given loop by Count. The loop must be in LCSSA form. Returns tru
[all...] |
| LCSSA.cpp | 1 //===-- LCSSA.cpp - Convert loops into loop-closed SSA form ---------------===//
11 // all values that are live across the loop boundary. For example, it turns
25 // transformation is that it makes many other loop optimizations, such as
50 STATISTIC(NumLCSSA, "Number of live out of a loop variables");
61 /// Given an instruction in the loop, check to see if it has any uses that are
62 /// outside the current loop. If so, insert LCSSA PHI nodes and rewrite the
64 static bool processInstruction(Loop &L, Instruction &Inst, DominatorTree &DT,
70 // We can run into tokens which are live out of a loop with catchswitch
72 // is inside the loop and another which is not.
88 // If there are no uses outside the loop, exit with no change
[all...] |
