| /external/llvm/include/llvm/Analysis/ |
| IteratedDominanceFrontier.h | 40 /// blocks, and optionally, a set of live-in blocks.
52 /// \brief Give the IDF calculator the set of blocks in which the value is
53 /// defined. This is equivalent to the set of starting blocks it should be
57 void setDefiningBlocks(const SmallPtrSetImpl<BasicBlock *> &Blocks) {
58 DefBlocks = &Blocks;
61 /// \brief Give the IDF calculator the set of blocks in which the value is
63 /// not include blocks where any phi insertion would be dead.
67 void setLiveInBlocks(const SmallPtrSetImpl<BasicBlock *> &Blocks) {
68 LiveInBlocks = &Blocks;
[all...] |
| LoopInfo.h | 17 // contained entirely within the loop and the basic blocks the make up the loop.
24 // * the successor blocks of the loop
71 // Blocks - The list of blocks in this loop. First entry is the header node.
72 std::vector<BlockT*> Blocks;
93 /// blocks, where depth 0 is used for blocks not inside any loops.
101 BlockT *getHeader() const { return Blocks.front(); }
142 /// getBlocks - Get a list of the basic blocks which make up this loop.
144 const std::vector<BlockT*> &getBlocks() const { return Blocks; }
148 inline iterator_range<block_iterator> blocks() const { function in class:llvm::LoopBase
[all...] |
| VectorUtils.h | 126 computeMinimumValueSizes(ArrayRef<BasicBlock*> Blocks,
|
| /external/llvm/include/llvm/CodeGen/ |
| EdgeBundles.h | 34 /// Blocks - Map each bundle to a list of basic block numbers.
35 SmallVector<SmallVector<unsigned, 8>, 4> Blocks;
48 /// getBlocks - Return an array of blocks that are connected to Bundle.
49 ArrayRef<unsigned> getBlocks(unsigned Bundle) const { return Blocks[Bundle]; }
|
| /external/clang/lib/Analysis/ |
| ThreadSafetyTIL.cpp | 164 // Sorts the CFGs blocks using a reverse post-order depth-first traversal.
165 // Each block will be written into the Blocks array in order, and its BlockID
167 // block, and ID should be the total number of blocks.
168 int BasicBlock::topologicalSort(SimpleArray<BasicBlock*>& Blocks, int ID) {
172 ID = Block->topologicalSort(Blocks, ID);
174 // We may lose pointers to unreachable blocks.
177 Blocks[BlockID] = this;
183 // which guarantees that all blocks are serialized after their dominator and
189 // and no blocks are accessable via traversal of back-edges from the exit that
191 int BasicBlock::topologicalFinalSort(SimpleArray<BasicBlock*>& Blocks, int ID)
[all...] |
| PostOrderCFGView.cpp | 1 //===- PostOrderCFGView.cpp - Post order view of CFG blocks -------*- C++ --*-//
10 // This file implements post order view of the blocks in a CFG.
21 Blocks.reserve(cfg->getNumBlockIDs());
26 BlockOrder[*I] = Blocks.size() + 1;
27 Blocks.push_back(*I);
|
| /external/clang/include/clang/Analysis/Analyses/ |
| PostOrderCFGView.h | 1 //===- PostOrderCFGView.h - Post order view of CFG blocks ---------*- C++ --*-//
10 // This file implements post order view of the blocks in a CFG.
64 /// This method is for tracking visited blocks in the main threadsafety
73 std::vector<const CFGBlock*> Blocks;
84 iterator begin() { return Blocks.rbegin(); }
85 iterator end() { return Blocks.rend(); }
87 const_iterator begin() const { return Blocks.rbegin(); }
88 const_iterator end() const { return Blocks.rend(); }
|
| /external/v8/src/compiler/ |
| gap-resolver.cc | 17 inline bool Blocks(MoveOperands* move, InstructionOperand destination) {
18 return move->Blocks(destination);
55 // destination blocks this one so recursively perform all such moves.
57 if (other->Blocks(destination) && !other->IsPending()) {
87 std::bind2nd(std::ptr_fun(&Blocks), destination));
107 if (other->Blocks(source)) {
109 } else if (other->Blocks(destination)) {
|
| /external/llvm/lib/CodeGen/ |
| EdgeBundles.cpp | 56 Blocks.clear();
57 Blocks.resize(getNumBundles());
62 Blocks[b0].push_back(i);
64 Blocks[b1].push_back(i);
|
| InterferenceCache.h | 39 /// of PhysReg in all basic blocks.
90 /// Blocks - Interference for each block in the function.
91 SmallVector<BlockInterference, 8> Blocks;
93 /// update - Recompute Blocks[MBBNum]
126 if (Blocks[MBBNum].Tag != Tag)
128 return &Blocks[MBBNum];
|
| SpillPlacement.h | 10 // This analysis computes the optimal spill code placement between basic blocks.
16 // Given a variable that is live across multiple basic blocks, and given
17 // constraints on the basic blocks where the variable is live, determine which
108 /// @param LiveBlocks Constraints for blocks that have the variable live in or
112 /// addPrefSpill - Add PrefSpill constraints to all blocks listed. This is
116 /// @param Blocks Array of block numbers that prefer to spill in and out.
117 /// @param Strong When true, double the negative bias for these blocks.
118 void addPrefSpill(ArrayRef<unsigned> Blocks, bool Strong);
120 /// addLinks - Add transparent blocks with the given numbers.
|
| /external/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ |
| FunctionSummary.h | 34 /// Marks the IDs of the basic blocks visited during the analyzes.
37 /// Total number of blocks in the function.
96 llvm::SmallBitVector &Blocks = I->second.VisitedBasicBlocks;
98 if (TotalIDs > Blocks.size()) {
99 Blocks.resize(TotalIDs);
102 Blocks.set(ID);
124 /// Get the percentage of the reachable blocks.
|
| /external/llvm/lib/Transforms/Utils/ |
| CodeExtractor.cpp | 70 /// \brief Build a set of blocks to extract if the input blocks are viable.
78 // Loop over the blocks, adding them to our set-vector, and aborting with an
79 // empty set if we encounter invalid blocks.
82 llvm_unreachable("Repeated basic blocks in extraction input");
97 "No blocks in this region may have entries from outside the region"
124 Blocks(buildExtractionBlockSet(BB)), NumExitBlocks(~0U) {}
129 Blocks(buildExtractionBlockSet(BBs)), NumExitBlocks(~0U) {}
133 Blocks(buildExtractionBlockSet(L.getBlocks())), NumExitBlocks(~0U) {}
138 Blocks(buildExtractionBlockSet(RN)), NumExitBlocks(~0U) {
[all...] |
| /external/llvm/include/llvm/Transforms/Utils/ |
| CodeExtractor.h | 52 SetVector<BasicBlock *> Blocks;
63 /// \brief Create a code extractor for a sequence of blocks.
65 /// Given a sequence of basic blocks where the first block in the sequence
93 /// Based on the blocks used when constructing the code extractor,
95 bool isEligible() const { return !Blocks.empty(); }
|
| Cloning.h | 13 // functions, to copying basic blocks to support loop unrolling or superblock
100 /// The correlation between instructions in the source and result basic blocks
134 /// to VMap values. Note that if NewFunc already has basic blocks, the ones
249 /// \brief Clones a loop \p OrigLoop. Returns the loop and the blocks in \p
250 /// Blocks.
253 /// \p LoopDomBB. Insert the new blocks before block specified in \p Before.
258 SmallVectorImpl<BasicBlock *> &Blocks);
260 /// \brief Remaps instructions in \p Blocks using the mapping in \p VMap.
261 void remapInstructionsInBlocks(const SmallVectorImpl<BasicBlock *> &Blocks,
|
| /external/llvm/lib/IR/ |
| GCOV.cpp | 151 // read blocks.
162 Blocks.push_back(make_unique<GCOVBlock>(*this, i));
183 Edges.push_back(make_unique<GCOVEdge>(*Blocks[BlockNo], *Blocks[Dst]));
185 Blocks[BlockNo]->addDstEdge(Edge);
186 Blocks[Dst]->addSrcEdge(Edge);
208 GCOVBlock &Block = *Blocks[BlockNo];
306 if (BlockNo >= Blocks.size()) {
310 if (BlockNo == Blocks.size() - 1)
312 GCOVBlock &Block = *Blocks[BlockNo]
[all...] |
| /external/llvm/lib/Target/WebAssembly/ |
| Relooper.cpp | 66 /// Implements the relooper algorithm for a function's blocks.
69 /// ownership of the blocks and shapes, and frees them when done.
72 std::deque<Block *> Blocks;
125 for (Block *B : R.Blocks) {
191 for (auto Curr : Blocks)
199 Blocks.push_back(New);
249 // Split the node (for simplicity, we replace all the blocks, even
284 // Add incoming branches from live blocks, ignoring dead code
285 for (unsigned i = 0; i < Blocks.size(); i++) {
286 Block *Curr = Blocks[i]
[all...] |
| /art/compiler/optimizing/ |
| parallel_move_resolver.cc | 144 // as this one's destination blocks this one so recursively perform all
149 if (other_move.Blocks(destination) && !other_move.IsPending()) {
202 if (other_move->Blocks(destination)) {
224 if (other_move->Blocks(source)) {
226 } else if (other_move->Blocks(swap_destination)) {
245 if (move->Blocks(loc)) {
432 // as this one's destination blocks this one so recursively perform all
436 if (other_move.Blocks(destination) && !other_move.IsPending()) {
545 if (move->Blocks(loc)) {
550 if (move->Blocks(loc))
[all...] |
| /external/clang/test/SemaCXX/ |
| nested-name-spec-locations.cpp | 158 void bar(std::vector<int*> &Blocks) {
159 foo(Blocks); // expected-note{{in instantiation of}}
|
| /external/clang/include/clang/Analysis/ |
| CFG.h | 406 /// LoopTarget - Some blocks are used to represent the "loop edge" to
408 /// refer to the loop statement for such blocks (and be null otherwise).
471 /// CFG blocks.
478 /// control cannot technically ever proceed past this block. All such blocks
840 CFGBlock & front() { return *Blocks.front(); }
841 CFGBlock & back() { return *Blocks.back(); }
843 iterator begin() { return Blocks.begin(); }
844 iterator end() { return Blocks.end(); }
845 const_iterator begin() const { return Blocks.begin(); }
846 const_iterator end() const { return Blocks.end();
[all...] |
| /external/llvm/include/llvm/Support/ |
| GCOV.h | 272 size_t getNumBlocks() const { return Blocks.size(); }
276 BlockIterator block_begin() const { return Blocks.begin(); }
277 BlockIterator block_end() const { return Blocks.end(); }
278 iterator_range<BlockIterator> blocks() const { function in class:llvm::GCOVFunction
292 SmallVector<std::unique_ptr<GCOVBlock>, 16> Blocks;
377 BlockLines Blocks;
404 LineInfo[Filename].Blocks[Line - 1].push_back(Block);
|
| /external/llvm/include/llvm/ADT/ |
| PostOrderIterator.h | 42 // confine a CFG traversal to blocks in a specific loop.
262 // This is used to visit basic blocks in a method in reverse post order. This
284 std::vector<NodeType*> Blocks; // Block list in normal PO order
286 std::copy(po_begin(BB), po_end(BB), std::back_inserter(Blocks));
294 rpo_iterator begin() { return Blocks.rbegin(); }
295 rpo_iterator end() { return Blocks.rend(); }
|
| /external/v8/src/crankshaft/x64/ |
| lithium-gap-resolver-x64.cc | 79 // as this one's destination blocks this one so recursively perform all
83 if (other_move.Blocks(destination) && !other_move.IsPending()) {
113 if (other_move.Blocks(destination)) {
308 if (other_move.Blocks(source)) {
310 } else if (other_move.Blocks(destination)) {
|
| /external/llvm/tools/bugpoint/ |
| CrashDebugger.cpp | 320 /// all terminators except the specified basic blocks to a 'ret' instruction,
352 SmallPtrSet<BasicBlock*, 8> Blocks;
354 Blocks.insert(cast<BasicBlock>(VMap[BBs[i]]));
356 outs() << "Checking for crash with only these blocks:";
357 unsigned NumPrint = Blocks.size();
361 if (NumPrint < Blocks.size())
362 outs() << "... <" << Blocks.size() << " total>";
365 // Loop over and delete any hack up any blocks that are not listed...
368 if (!Blocks.count(&*BB) && BB->getTerminator()->getNumSuccessors()) {
386 // The CFG Simplifier pass may delete one of the basic blocks we ar
[all...] |
| /external/clang/include/clang/AST/ |
| Comment.h | 1098 ArrayRef<BlockContentComment *> Blocks;
1102 FullComment(ArrayRef<BlockContentComment *> Blocks, DeclInfo *D) :
1104 Blocks(Blocks), ThisDeclInfo(D) {
1105 if (Blocks.empty())
1108 setSourceRange(SourceRange(Blocks.front()->getLocStart(),
1109 Blocks.back()->getLocEnd()));
1110 setLocation(Blocks.front()->getLocStart());
1118 return reinterpret_cast<child_iterator>(Blocks.begin());
1122 return reinterpret_cast<child_iterator>(Blocks.end());
[all...] |
