| /external/llvm/include/llvm/Analysis/ |
| IteratedDominanceFrontier.h | 34 class BasicBlock;
36 typedef DomTreeNodeBase<BasicBlock> DomTreeNode;
50 IDFCalculator(DominatorTreeBase<BasicBlock> &DT) : DT(DT), useLiveIn(false) {}
57 void setDefiningBlocks(const SmallPtrSetImpl<BasicBlock *> &Blocks) {
67 void setLiveInBlocks(const SmallPtrSetImpl<BasicBlock *> &Blocks) {
85 void calculate(SmallVectorImpl<BasicBlock *> &IDFBlocks);
88 DominatorTreeBase<BasicBlock> &DT;
91 const SmallPtrSetImpl<BasicBlock *> *LiveInBlocks;
92 const SmallPtrSetImpl<BasicBlock *> *DefBlocks;
93 SmallVector<BasicBlock *, 32> PHIBlocks
[all...] |
| OrderedBasicBlock.h | 12 // in a BasicBlock. Since BasicBlock currently lacks a reliable way to query
14 // such queries. OrderedBasicBlock is lazily built on a source BasicBlock and
16 // instance should be discarded whenever the source BasicBlock changes.
19 // positions of a pair of instructions inside a BasicBlock.
27 #include "llvm/IR/BasicBlock.h"
32 class BasicBlock;
36 /// \brief Map a instruction to its position in a BasicBlock.
42 BasicBlock::const_iterator LastInstFound;
47 /// \brief The source BasicBlock to map
[all...] |
| BranchProbabilityInfo.h | 55 BranchProbability getEdgeProbability(const BasicBlock *Src,
61 BranchProbability getEdgeProbability(const BasicBlock *Src,
62 const BasicBlock *Dst) const;
64 BranchProbability getEdgeProbability(const BasicBlock *Src,
71 bool isEdgeHot(const BasicBlock *Src, const BasicBlock *Dst) const;
77 BasicBlock *getHotSucc(BasicBlock *BB) const;
84 raw_ostream &printEdgeProbability(raw_ostream &OS, const BasicBlock *Src,
85 const BasicBlock *Dst) const
[all...] |
| CFG.h | 1 //===-- Analysis/CFG.h - BasicBlock Analyses --------------------*- C++ -*-===//
18 #include "llvm/IR/BasicBlock.h"
23 class BasicBlock;
37 SmallVectorImpl<std::pair<const BasicBlock *, const BasicBlock *> > &
43 unsigned GetSuccessorNumber(const BasicBlock *BB, const BasicBlock *Succ);
77 bool isPotentiallyReachable(const BasicBlock *From, const BasicBlock *To,
88 bool isPotentiallyReachableFromMany(SmallVectorImpl<BasicBlock *> &Worklist
[all...] |
| PostDominators.h | 26 DominatorTreeBase<BasicBlock>* DT;
30 DT = new DominatorTreeBase<BasicBlock>(true);
41 inline const std::vector<BasicBlock*> &getRoots() const {
49 inline DomTreeNode *operator[](BasicBlock *BB) const {
53 inline DomTreeNode *getNode(BasicBlock *BB) const {
61 inline bool dominates(const BasicBlock* A, const BasicBlock* B) const {
69 inline bool properlyDominates(BasicBlock* A, BasicBlock* B) const {
73 inline BasicBlock *findNearestCommonDominator(BasicBlock *A, BasicBlock *B)
[all...] |
| Interval.h | 28 class BasicBlock;
38 /// HeaderNode - The header BasicBlock, which dominates all BasicBlocks in this
41 BasicBlock *HeaderNode;
43 typedef std::vector<BasicBlock*>::iterator succ_iterator;
44 typedef std::vector<BasicBlock*>::iterator pred_iterator;
45 typedef std::vector<BasicBlock*>::iterator node_iterator;
47 inline Interval(BasicBlock *Header) : HeaderNode(Header) {
51 inline BasicBlock *getHeaderNode() const { return HeaderNode; }
55 std::vector<BasicBlock*> Nodes;
61 std::vector<BasicBlock*> Successors
[all...] |
| LazyValueInfo.h | 55 BasicBlock *FromBB, BasicBlock *ToBB,
66 Constant *getConstant(Value *V, BasicBlock *BB, Instruction *CxtI = nullptr);
70 Constant *getConstantOnEdge(Value *V, BasicBlock *FromBB, BasicBlock *ToBB,
75 void threadEdge(BasicBlock *PredBB, BasicBlock *OldSucc, BasicBlock *NewSucc);
78 void eraseBlock(BasicBlock *BB);
|
| PHITransAddr.h | 63 /// BasicBlock to its predecessors requires PHI translation.
64 bool NeedsPHITranslationFromBlock(BasicBlock *BB) const {
82 bool PHITranslateValue(BasicBlock *CurBB, BasicBlock *PredBB,
92 Value *PHITranslateWithInsertion(BasicBlock *CurBB, BasicBlock *PredBB,
104 Value *PHITranslateSubExpr(Value *V, BasicBlock *CurBB, BasicBlock *PredBB,
112 Value *InsertPHITranslatedSubExpr(Value *InVal, BasicBlock *CurBB,
113 BasicBlock *PredBB, const DominatorTree &DT
[all...] |
| Loads.h | 18 #include "llvm/IR/BasicBlock.h"
54 Value *FindAvailableLoadedValue(Value *Ptr, BasicBlock *ScanBB,
55 BasicBlock::iterator &ScanFrom,
|
| Trace.h | 25 class BasicBlock;
31 typedef std::vector<BasicBlock *> BasicBlockListType;
39 Trace(const std::vector<BasicBlock *> &vBB) : BasicBlocks (vBB) {}
44 BasicBlock *getEntryBasicBlock () const { return BasicBlocks[0]; }
48 BasicBlock *operator[](unsigned i) const { return BasicBlocks[i]; }
49 BasicBlock *getBlock(unsigned i) const { return BasicBlocks[i]; }
62 int getBlockIndex(const BasicBlock *X) const {
72 bool contains(const BasicBlock *X) const {
79 bool dominates(const BasicBlock *B1, const BasicBlock *B2) const
[all...] |
| LoopIterator.h | 41 typedef std::vector<BasicBlock*>::const_iterator POIterator;
42 typedef std::vector<BasicBlock*>::const_reverse_iterator RPOIterator;
52 DenseMap<BasicBlock*, unsigned> PostNumbers;
53 std::vector<BasicBlock*> PostBlocks;
84 bool hasPreorder(BasicBlock *BB) const { return PostNumbers.count(BB); }
87 bool hasPostorder(BasicBlock *BB) const {
88 DenseMap<BasicBlock*, unsigned>::const_iterator I = PostNumbers.find(BB);
93 unsigned getPostorder(BasicBlock *BB) const {
94 DenseMap<BasicBlock*, unsigned>::const_iterator I = PostNumbers.find(BB);
101 unsigned getRPO(BasicBlock *BB) const
[all...] |
| /external/llvm/include/llvm/IR/ |
| PredIteratorCache.h | 30 DenseMap<BasicBlock *, BasicBlock **> BlockToPredsMap;
31 DenseMap<BasicBlock *, unsigned> BlockToPredCountMap;
39 /// for (BasicBlock **PI = PredCache->GetPreds(BB); *PI; ++PI)
43 BasicBlock **GetPreds(BasicBlock *BB) {
44 BasicBlock **&Entry = BlockToPredsMap[BB];
48 SmallVector<BasicBlock *, 32> PredCache(pred_begin(BB), pred_end(BB));
53 Entry = Memory.Allocate<BasicBlock *>(PredCache.size());
58 unsigned GetNumPreds(BasicBlock *BB)
[all...] |
| BasicBlock.h | 1 //===-- llvm/BasicBlock.h - Represent a basic block in the VM ---*- C++ -*-===//
10 // This file contains the declaration of the BasicBlock class.
34 struct SymbolTableListSentinelTraits<BasicBlock>
35 : public ilist_half_embedded_sentinel_traits<BasicBlock> {};
42 /// tables. The type of a BasicBlock is "Type::LabelTy" because the basic block
48 /// terminate the blocks. The BasicBlock class allows malformed basic blocks to
52 class BasicBlock : public Value, // Basic blocks are data objects also
53 public ilist_node_with_parent<BasicBlock, Function> {
63 friend class SymbolTableListTraits<BasicBlock>;
65 BasicBlock(const BasicBlock &) = delete
[all...] |
| AssemblyAnnotationWriter.h | 23 class BasicBlock;
40 virtual void emitBasicBlockStartAnnot(const BasicBlock *,
46 virtual void emitBasicBlockEndAnnot(const BasicBlock *,
|
| CFG.h | 11 // BasicBlock graphs to be treated as proper graphs for generic algorithms.
26 // BasicBlock pred_iterator definition
85 typedef PredIterator<BasicBlock, Value::user_iterator> pred_iterator;
86 typedef PredIterator<const BasicBlock,
91 inline pred_iterator pred_begin(BasicBlock *BB) { return pred_iterator(BB); }
92 inline const_pred_iterator pred_begin(const BasicBlock *BB) {
95 inline pred_iterator pred_end(BasicBlock *BB) { return pred_iterator(BB, true);}
96 inline const_pred_iterator pred_end(const BasicBlock *BB) {
99 inline bool pred_empty(const BasicBlock *BB) {
102 inline pred_range predecessors(BasicBlock *BB)
[all...] |
| Dominators.h | 23 #include "llvm/IR/BasicBlock.h"
39 extern template class DomTreeNodeBase<BasicBlock>;
40 extern template class DominatorTreeBase<BasicBlock>;
42 extern template void Calculate<Function, BasicBlock *>(
43 DominatorTreeBase<GraphTraits<BasicBlock *>::NodeType> &DT, Function &F);
44 extern template void Calculate<Function, Inverse<BasicBlock *>>(
45 DominatorTreeBase<GraphTraits<Inverse<BasicBlock *>>::NodeType> &DT,
48 typedef DomTreeNodeBase<BasicBlock> DomTreeNode;
51 const BasicBlock *Start;
52 const BasicBlock *End
[all...] |
| /external/v8/src/compiler/ |
| schedule.h | 17 class BasicBlock;
22 typedef ZoneVector<BasicBlock*> BasicBlockVector;
29 class BasicBlock final : public ZoneObject {
57 BasicBlock(Zone* zone, Id id);
65 BasicBlock* PredecessorAt(size_t index) { return predecessors_[index]; }
67 void AddPredecessor(BasicBlock* predecessor);
73 BasicBlock* SuccessorAt(size_t index) { return successors_[index]; }
75 void AddSuccessor(BasicBlock* successor);
119 BasicBlock* dominator() const { return dominator_; }
120 void set_dominator(BasicBlock* dominator) { dominator_ = dominator;
[all...] |
| schedule.cc | 15 BasicBlock::BasicBlock(Zone* zone, Id id)
33 bool BasicBlock::LoopContains(BasicBlock* block) const {
43 void BasicBlock::AddSuccessor(BasicBlock* successor) {
48 void BasicBlock::AddPredecessor(BasicBlock* predecessor) {
53 void BasicBlock::AddNode(Node* node) { nodes_.push_back(node); }
56 void BasicBlock::set_control(Control control)
[all...] |
| /external/llvm/include/llvm/Transforms/Utils/ |
| UnifyFunctionExitNodes.h | 26 BasicBlock *ReturnBlock, *UnwindBlock, *UnreachableBlock;
41 BasicBlock *getReturnBlock() const { return ReturnBlock; }
42 BasicBlock *getUnwindBlock() const { return UnwindBlock; }
43 BasicBlock *getUnreachableBlock() const { return UnreachableBlock; }
|
| BasicBlockUtils.h | 1 //===-- Transform/Utils/BasicBlockUtils.h - BasicBlock Utils ----*- C++ -*-===//
18 // FIXME: Move to this file: BasicBlock::removePredecessor, BB::splitBasicBlock
20 #include "llvm/IR/BasicBlock.h"
36 void DeleteDeadBlock(BasicBlock *BB);
42 void FoldSingleEntryPHINodes(BasicBlock *BB,
50 bool DeleteDeadPHIs(BasicBlock *BB, const TargetLibraryInfo *TLI = nullptr);
54 bool MergeBlockIntoPredecessor(BasicBlock *BB, DominatorTree *DT = nullptr,
61 void ReplaceInstWithValue(BasicBlock::InstListType &BIL,
62 BasicBlock::iterator &BI, Value *V);
69 void ReplaceInstWithInst(BasicBlock::InstListType &BIL
[all...] |
| CodeExtractor.h | 22 class BasicBlock;
52 SetVector<BasicBlock *> Blocks;
61 CodeExtractor(BasicBlock *BB, bool AggregateArgs = false);
69 CodeExtractor(ArrayRef<BasicBlock *> BBs, DominatorTree *DT = nullptr,
108 void severSplitPHINodes(BasicBlock *&Header);
113 BasicBlock *header,
114 BasicBlock *newRootNode, BasicBlock *newHeader,
120 BasicBlock *newHeader,
|
| /external/llvm/lib/IR/ |
| BasicBlock.cpp | 1 //===-- BasicBlock.cpp - Implement BasicBlock related methods -------------===//
10 // This file implements the BasicBlock class for the IR library.
14 #include "llvm/IR/BasicBlock.h"
27 ValueSymbolTable *BasicBlock::getValueSymbolTable() {
33 LLVMContext &BasicBlock::getContext() const {
41 BasicBlock::BasicBlock(LLVMContext &C, const Twine &Name, Function *NewParent,
42 BasicBlock *InsertBefore)
54 void BasicBlock::insertInto(Function *NewParent, BasicBlock *InsertBefore)
[all...] |
| /external/llvm/lib/Transforms/Utils/ |
| FlattenCFG.cpp | 31 bool FlattenParallelAndOr(BasicBlock *BB, IRBuilder<> &Builder);
35 bool MergeIfRegion(BasicBlock *BB, IRBuilder<> &Builder);
41 bool CompareIfRegionBlock(BasicBlock *Head1, BasicBlock *Head2,
42 BasicBlock *Block1, BasicBlock *Block2);
46 bool run(BasicBlock *BB);
124 bool FlattenCFGOpt::FlattenParallelAndOr(BasicBlock *BB, IRBuilder<> &Builder) {
129 BasicBlock *LastCondBlock = nullptr;
130 BasicBlock *FirstCondBlock = nullptr
[all...] |
| UnifyFunctionExitNodes.cpp | 19 #include "llvm/IR/BasicBlock.h"
42 // BasicBlock, and converting all returns to unconditional branches to this
51 std::vector<BasicBlock*> ReturningBlocks;
52 std::vector<BasicBlock*> UnreachableBlocks;
53 for (BasicBlock &I : F)
65 UnreachableBlock = BasicBlock::Create(F.getContext(),
69 for (std::vector<BasicBlock*>::iterator I = UnreachableBlocks.begin(),
71 BasicBlock *BB = *I;
90 BasicBlock *NewRetBlock = BasicBlock::Create(F.getContext()
[all...] |
| /external/llvm/lib/Analysis/ |
| CFG.cpp | 1 //===-- CFG.cpp - BasicBlock analysis --------------------------------------==//
28 SmallVectorImpl<std::pair<const BasicBlock*,const BasicBlock*> > &Result) {
29 const BasicBlock *BB = &F.getEntryBlock();
33 SmallPtrSet<const BasicBlock*, 8> Visited;
34 SmallVector<std::pair<const BasicBlock*, succ_const_iterator>, 8> VisitStack;
35 SmallPtrSet<const BasicBlock*, 8> InStack;
41 std::pair<const BasicBlock*, succ_const_iterator> &Top = VisitStack.back();
42 const BasicBlock *ParentBB = Top.first;
72 unsigned llvm::GetSuccessorNumber(const BasicBlock *BB
[all...] |
