| /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(); }
|
| /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/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(); }
|
| ThreadSafetyTIL.h | [all...] |
| /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/lldb/include/lldb/Symbol/ |
| SymbolFile.h | 38 Blocks = (1u << 3),
|
| /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/llvm/lib/CodeGen/ |
| 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];
|
| MachineBlockPlacement.cpp | 14 // a topological ordering of basic blocks) in the absence of a *strong* signal
17 // blocks adjacent to each other.
20 // at each stage walks through the basic blocks, trying to coalesce them into
22 // probabilities). Finally, it walks the blocks in topological order, and the
23 // first time it reaches a chain of basic blocks, it schedules them in the
60 static cl::opt<unsigned> AlignAllBlock("align-all-blocks",
62 "blocks in the function."),
91 /// \brief A chain of blocks which will be laid out contiguously.
93 /// This is the datastructure representing a chain of consecutive blocks that
96 /// a sequence of basic blocks which have some external (correctness
[all...] |
| MachineLICM.cpp | 91 // Exit blocks for CurLoop.
119 // If a MBB does not dominate loop exiting blocks then it may not safe
241 /// blocks dominated by the specified header block, and that are in the
524 const std::vector<MachineBasicBlock *> &Blocks = CurLoop->getBlocks();
525 for (unsigned i = 0, e = Blocks.size(); i != e; ++i) {
526 MachineBasicBlock *BB = Blocks[i];
606 const std::vector<MachineBasicBlock *> &Blocks = CurLoop->getBlocks();
607 for (unsigned i = 0, e = Blocks.size(); i != e; ++i) {
608 MachineBasicBlock *BB = Blocks[i];
655 // Check loop exiting blocks
[all...] |
| RegAllocGreedy.cpp | 242 /// All basic blocks where the current register has uses.
555 // large blocks on targets with many physical registers.
[all...] |
| /external/llvm/tools/bugpoint/ |
| CrashDebugger.cpp | 244 /// all terminators except the specified basic blocks to a 'ret' instruction,
276 SmallPtrSet<BasicBlock*, 8> Blocks;
278 Blocks.insert(cast<BasicBlock>(VMap[BBs[i]]));
280 outs() << "Checking for crash with only these blocks:";
281 unsigned NumPrint = Blocks.size();
285 if (NumPrint < Blocks.size())
286 outs() << "... <" << Blocks.size() << " total>";
289 // Loop over and delete any hack up any blocks that are not listed...
292 if (!Blocks.count(BB) && BB->getTerminator()->getNumSuccessors()) {
308 // The CFG Simplifier pass may delete one of the basic blocks we ar
[all...] |
| /external/llvm/lib/Transforms/Scalar/ |
| DeadStoreElimination.cpp | 69 // Only check non-dead blocks. Dead blocks may have strange pointer
627 /// Find all blocks that will unconditionally lead to the block BB and append
629 static void FindUnconditionalPreds(SmallVectorImpl<BasicBlock *> &Blocks,
639 Blocks.push_back(Pred);
649 SmallVector<BasicBlock *, 16> Blocks;
650 Blocks.push_back(F->getParent());
653 while (!Blocks.empty()) {
654 BasicBlock *BB = Blocks.pop_back_val();
687 FindUnconditionalPreds(Blocks, BB, DT)
[all...] |
| InductiveRangeCheckElimination.cpp | 487 // The cloned blocks
488 std::vector<BasicBlock *> Blocks;
584 // blocks denoted by BBs to this loops parent loop if required.
920 Result.Blocks.push_back(Clone);
935 for (unsigned i = 0, e = Result.Blocks.size(); i != e; ++i) {
936 BasicBlock *ClonedBB = Result.Blocks[i];
945 // Exit blocks will now have one more predecessor and their PHI nodes need
[all...] |
| /external/llvm/tools/llvm-diff/ |
| DifferenceEngine.cpp | 121 /// The current mapping from old blocks to new blocks.
122 DenseMap<BasicBlock*, BasicBlock*> Blocks;
129 if (!Blocks.count(*I)) Count++;
136 /// predecessor blocks it has remaining.
149 /// A queue of unified blocks to process.
152 /// Try to unify the given two blocks. Enqueues them for processing
157 BasicBlock *&Ref = Blocks[L];
390 return Blocks[cast<BlockAddress>(L)->getBasicBlock()]
446 return Blocks[cast<BasicBlock>(L)] != R
[all...] |
| /external/clang/lib/AST/ |
| CommentParser.cpp | 764 SmallVector<BlockContentComment *, 8> Blocks;
766 Blocks.push_back(parseBlockContent());
772 return S.actOnFullComment(S.copyArray(llvm::makeArrayRef(Blocks)));
|
| /external/llvm/include/llvm/Analysis/ |
| LoopInfo.h | 17 // contained entirely within the loop and the basic blocks the make up the loop.
24 // * the successor blocks of the loop
77 // Blocks - The list of blocks in this loop. First entry is the header node.
78 std::vector<BlockT*> Blocks;
95 /// blocks, where depth 0 is used for blocks not inside any loops.
103 BlockT *getHeader() const { return Blocks.front(); }
144 /// getBlocks - Get a list of the basic blocks which make up this loop.
146 const std::vector<BlockT*> &getBlocks() const { return Blocks; }
[all...] |
| /external/llvm/include/llvm/Support/ |
| GCOV.h | 267 size_t getNumBlocks() const { return Blocks.size(); }
271 BlockIterator block_begin() const { return Blocks.begin(); }
272 BlockIterator block_end() const { return Blocks.end(); }
273 iterator_range<BlockIterator> blocks() const { function in class:llvm::GCOVFunction
287 SmallVector<std::unique_ptr<GCOVBlock>, 16> Blocks;
372 BlockLines Blocks;
399 LineInfo[Filename].Blocks[Line - 1].push_back(Block);
|
| /external/llvm/lib/Transforms/Instrumentation/ |
| GCOVProfiling.cpp | 12 // to records the edges between blocks that run and emit a complementary "gcda"
176 // Returns the length measured in 4-byte blocks that will be used to
241 // other blocks.
289 // blocks being copied or moved around.
308 // set of blocks and a map of edges between blocks. This is the only GCOV
309 // object users can construct, the blocks and lines will be rooted here.
326 Blocks.insert(std::make_pair(&BB, GCOVBlock(i++, os)));
339 return Blocks.find(BB)->second;
349 Function *F = Blocks.begin()->first->getParent()
[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...] |
| /external/clang/include/clang/Analysis/ |
| CFG.h | 407 /// LoopTarget - Some blocks are used to represent the "loop edge" to
409 /// refer to the loop statement for such blocks (and be null otherwise).
472 /// CFG blocks.
479 /// 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/lib/Target/Hexagon/ |
| HexagonHardwareLoops.cpp | 869 const std::vector<MachineBasicBlock *> &Blocks = L->getBlocks();
870 for (unsigned i = 0, e = Blocks.size(); i != e; ++i) {
871 MachineBasicBlock *MBB = Blocks[i];
[all...] |
| /external/v8/src/compiler/ |
| instruction.h | 286 bool Blocks(InstructionOperand* operand) const {
|
| /external/v8/src/ |
| lithium.h | 277 bool Blocks(LOperand* operand) const {
|
| /art/compiler/optimizing/ |
| nodes.h | 117 // Control-flow graph of a method. Contains a list of basic blocks.
188 // Need to add a couple of blocks to test if the loop body is entered and
330 // List of blocks in insertion order.
333 // List of blocks to perform a reverse post order tree traversal.
336 // List of blocks to perform a linear order tree traversal.
392 // Make bit vector growable, as the number of blocks may change.
446 // Finds blocks that are part of this loop. Returns whether the loop is a natural loop,
450 // Reanalyzes the loop by removing loop info from its blocks and re-running
650 // Split the block into two blocks just after `cursor`. Returns the newly
654 // blocks are consistent (for example ending with a control flow instruction)
[all...] |
