|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
Derived Classes
lib/Transforms/Vectorize/VPlan.h 986 class VPBasicBlock : public VPBlockBase {
1071 class VPRegionBlock : public VPBlockBase {
Declarations
lib/Transforms/Vectorize/VPlanLoopInfo.h 23 class VPBlockBase;
References
include/llvm/ADT/ArrayRef.h 108 const ArrayRef<U *> &A,
110 std::is_convertible<U *const *, T const *>::value>::type * = nullptr)
118 const SmallVectorTemplateCommon<U *, DummyT> &Vec,
120 std::is_convertible<U *const *, T const *>::value>::type * = nullptr)
127 ArrayRef(const std::vector<U *, A> &Vec,
129 std::is_convertible<U *const *, T const *>::value>::type* = 0)
include/llvm/ADT/DenseMapInfo.h 39 static inline T* getEmptyKey() {
41 Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
45 static inline T* getTombstoneKey() {
47 Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
51 static unsigned getHashValue(const T *PtrVal) {
56 static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
56 static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
include/llvm/Analysis/LoopInfo.h 80 std::vector<BlockT *> Blocks;
82 SmallPtrSet<const BlockT *, 8> DenseBlockSet;
89 LoopBase(const LoopBase<BlockT, LoopT> &) = delete;
90 const LoopBase<BlockT, LoopT> &
91 operator=(const LoopBase<BlockT, LoopT> &) = delete;
105 BlockT *getHeader() const { return getBlocks().front(); }
125 bool contains(const BlockT *BB) const {
131 template <class InstT> bool contains(const InstT *Inst) const {
154 ArrayRef<BlockT *> getBlocks() const {
158 typedef typename ArrayRef<BlockT *>::const_iterator block_iterator;
175 std::vector<BlockT *> &getBlocksVector() {
181 SmallPtrSetImpl<const BlockT *> &getBlocksSet() {
187 const SmallPtrSetImpl<const BlockT *> &getBlocksSet() const {
208 bool isLoopExiting(const BlockT *BB) const {
211 for (const auto &Succ : children<const BlockT *>(BB)) {
222 bool isLoopLatch(const BlockT *BB) const {
226 BlockT *Header = getHeader();
227 auto PredBegin = GraphTraits<Inverse<BlockT *>>::child_begin(Header);
228 auto PredEnd = GraphTraits<Inverse<BlockT *>>::child_end(Header);
256 void getExitingBlocks(SmallVectorImpl<BlockT *> &ExitingBlocks) const;
260 BlockT *getExitingBlock() const;
264 void getExitBlocks(SmallVectorImpl<BlockT *> &ExitBlocks) const;
268 BlockT *getExitBlock() const;
276 void getUniqueExitBlocks(SmallVectorImpl<BlockT *> &ExitBlocks) const;
282 void getUniqueNonLatchExitBlocks(SmallVectorImpl<BlockT *> &ExitBlocks) const;
286 BlockT *getUniqueExitBlock() const;
289 typedef std::pair<BlockT *, BlockT *> Edge;
289 typedef std::pair<BlockT *, BlockT *> Edge;
300 BlockT *getLoopPreheader() const;
306 BlockT *getLoopPredecessor() const;
310 BlockT *getLoopLatch() const;
314 void getLoopLatches(SmallVectorImpl<BlockT *> &LoopLatches) const {
365 void addBasicBlockToLoop(BlockT *NewBB, LoopInfoBase<BlockT, LoopT> &LI);
365 void addBasicBlockToLoop(BlockT *NewBB, LoopInfoBase<BlockT, LoopT> &LI);
403 void addBlockEntry(BlockT *BB) {
423 void moveToHeader(BlockT *BB) {
440 void removeBlockFromLoop(BlockT *BB) {
470 explicit LoopBase(BlockT *BB) : ParentLoop(nullptr) {
850 DenseMap<const BlockT *, LoopT *> BBMap;
928 LoopT *getLoopFor(const BlockT *BB) const { return BBMap.lookup(BB); }
931 const LoopT *operator[](const BlockT *BB) const { return getLoopFor(BB); }
935 unsigned getLoopDepth(const BlockT *BB) const {
941 bool isLoopHeader(const BlockT *BB) const {
960 void changeLoopFor(BlockT *BB, LoopT *L) {
987 void removeBlock(BlockT *BB) {
1009 void analyze(const DominatorTreeBase<BlockT, false> &DomTree);
1014 void verify(const DominatorTreeBase<BlockT, false> &DomTree) const;
include/llvm/Analysis/LoopInfoImpl.h 38 for (const auto &Succ : children<BlockT *>(BB))
51 SmallVector<BlockT *, 8> ExitingBlocks;
66 for (const auto &Succ : children<BlockT *>(BB))
77 SmallVector<BlockT *, 8> ExitBlocks;
163 BlockT *Out = getLoopPredecessor();
172 typedef GraphTraits<BlockT *> BlockTraits;
191 BlockT *Out = nullptr;
194 BlockT *Header = getHeader();
195 for (const auto Pred : children<Inverse<BlockT *>>(Header)) {
211 BlockT *Header = getHeader();
212 BlockT *Latch = nullptr;
213 for (const auto Pred : children<Inverse<BlockT *>>(Header)) {
384 BlockT *H = getHeader();
386 BlockT *BB = getBlocks()[i];
418 static void discoverAndMapSubloop(LoopT *L, ArrayRef<BlockT *> Backedges,
419 LoopInfoBase<BlockT, LoopT> *LI,
420 const DomTreeBase<BlockT> &DomTree) {
421 typedef GraphTraits<Inverse<BlockT *>> InvBlockTraits;
427 std::vector<BlockT *> ReverseCFGWorklist(Backedges.begin(), Backedges.end());
429 BlockT *PredBB = ReverseCFGWorklist.back();
464 for (const auto Pred : children<Inverse<BlockT *>>(PredBB)) {
476 typedef GraphTraits<BlockT *> BlockTraits;
479 LoopInfoBase<BlockT, LoopT> *LI;
482 PopulateLoopsDFS(LoopInfoBase<BlockT, LoopT> *li) : LI(li) {}
484 void traverse(BlockT *EntryBlock);
487 void insertIntoLoop(BlockT *Block);
493 for (BlockT *BB : post_order(EntryBlock))
540 const DomTreeNodeBase<BlockT> *DomRoot = DomTree.getRootNode();
543 BlockT *Header = DomNode->getBlock();
544 SmallVector<BlockT *, 4> Backedges;
547 for (const auto Backedge : children<Inverse<BlockT *>>(Header)) {
562 PopulateLoopsDFS<BlockT, LoopT> DFS(this);
include/llvm/Support/Casting.h 57 static inline bool doit(const From &Val) {
104 static inline bool doit(const From *Val) {
106 return isa_impl<To, From>::doit(*Val);
263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
265 return cast_convert_val<X, Y*,
266 typename simplify_type<Y*>::SimpleType>::doit(Val);
342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
include/llvm/Support/GenericDomTree.h 61 NodeT *TheBB;
69 DomTreeNodeBase(NodeT *BB, DomTreeNodeBase *iDom)
81 NodeT *getBlock() const { return TheBB; }
167 raw_ostream &operator<<(raw_ostream &O, const DomTreeNodeBase<NodeT> *Node) {
180 void PrintDomTree(const DomTreeNodeBase<NodeT> *N, raw_ostream &O,
183 for (typename DomTreeNodeBase<NodeT>::const_iterator I = N->begin(),
186 PrintDomTree<NodeT>(*I, O, Lev + 1);
221 static_assert(std::is_pointer<typename GraphTraits<NodeT *>::NodeRef>::value,
223 using NodeType = NodeT;
224 using NodePtr = NodeT *;
225 using ParentPtr = decltype(std::declval<NodeT *>()->getParent());
240 SmallVector<NodeT *, IsPostDom ? 4 : 1> Roots;
243 DenseMap<NodeT *, std::unique_ptr<DomTreeNodeBase<NodeT>>>;
243 DenseMap<NodeT *, std::unique_ptr<DomTreeNodeBase<NodeT>>>;
245 DomTreeNodeBase<NodeT> *RootNode = nullptr;
284 const SmallVectorImpl<NodeT *> &getRoots() const { return Roots; }
328 DomTreeNodeBase<NodeT> *getNode(const NodeT *BB) const {
328 DomTreeNodeBase<NodeT> *getNode(const NodeT *BB) const {
336 DomTreeNodeBase<NodeT> *operator[](const NodeT *BB) const {
336 DomTreeNodeBase<NodeT> *operator[](const NodeT *BB) const {
347 DomTreeNodeBase<NodeT> *getRootNode() { return RootNode; }
348 const DomTreeNodeBase<NodeT> *getRootNode() const { return RootNode; }
351 void getDescendants(NodeT *R, SmallVectorImpl<NodeT *> &Result) const {
351 void getDescendants(NodeT *R, SmallVectorImpl<NodeT *> &Result) const {
369 bool properlyDominates(const DomTreeNodeBase<NodeT> *A,
370 const DomTreeNodeBase<NodeT> *B) const {
378 bool properlyDominates(const NodeT *A, const NodeT *B) const;
378 bool properlyDominates(const NodeT *A, const NodeT *B) const;
382 bool isReachableFromEntry(const NodeT *A) const {
388 bool isReachableFromEntry(const DomTreeNodeBase<NodeT> *A) const { return A; }
393 bool dominates(const DomTreeNodeBase<NodeT> *A,
394 const DomTreeNodeBase<NodeT> *B) const {
436 bool dominates(const NodeT *A, const NodeT *B) const;
436 bool dominates(const NodeT *A, const NodeT *B) const;
438 NodeT *getRoot() const {
445 NodeT *findNearestCommonDominator(NodeT *A, NodeT *B) const {
445 NodeT *findNearestCommonDominator(NodeT *A, NodeT *B) const {
445 NodeT *findNearestCommonDominator(NodeT *A, NodeT *B) const {
453 NodeT &Entry = A->getParent()->front();
458 DomTreeNodeBase<NodeT> *NodeA = getNode(A);
459 DomTreeNodeBase<NodeT> *NodeB = getNode(B);
474 const NodeT *findNearestCommonDominator(const NodeT *A,
474 const NodeT *findNearestCommonDominator(const NodeT *A,
475 const NodeT *B) const {
482 bool isVirtualRoot(const DomTreeNodeBase<NodeT> *A) const {
533 void insertEdge(NodeT *From, NodeT *To) {
533 void insertEdge(NodeT *From, NodeT *To) {
551 void deleteEdge(NodeT *From, NodeT *To) {
551 void deleteEdge(NodeT *From, NodeT *To) {
568 DomTreeNodeBase<NodeT> *addNewBlock(NodeT *BB, NodeT *DomBB) {
568 DomTreeNodeBase<NodeT> *addNewBlock(NodeT *BB, NodeT *DomBB) {
568 DomTreeNodeBase<NodeT> *addNewBlock(NodeT *BB, NodeT *DomBB) {
582 DomTreeNodeBase<NodeT> *setNewRoot(NodeT *BB) {
582 DomTreeNodeBase<NodeT> *setNewRoot(NodeT *BB) {
606 void changeImmediateDominator(DomTreeNodeBase<NodeT> *N,
607 DomTreeNodeBase<NodeT> *NewIDom) {
613 void changeImmediateDominator(NodeT *BB, NodeT *NewBB) {
613 void changeImmediateDominator(NodeT *BB, NodeT *NewBB) {
620 void eraseNode(NodeT *BB) {
651 void splitBlock(NodeT *NewBB) {
671 if (getRootNode()) PrintDomTree<NodeT>(getRootNode(), O, 1);
689 SmallVector<std::pair<const DomTreeNodeBase<NodeT> *,
690 typename DomTreeNodeBase<NodeT>::const_iterator>,
693 const DomTreeNodeBase<NodeT> *ThisRoot = getRootNode();
706 const DomTreeNodeBase<NodeT> *Node = WorkStack.back().first;
716 const DomTreeNodeBase<NodeT> *Child = *ChildIt;
758 void addRoot(NodeT *BB) { this->Roots.push_back(BB); }
827 bool dominatedBySlowTreeWalk(const DomTreeNodeBase<NodeT> *A,
828 const DomTreeNodeBase<NodeT> *B) const {
834 const DomTreeNodeBase<NodeT> *IDom;
include/llvm/Support/PointerLikeTypeTraits.h 56 static inline void *getAsVoidPointer(T *P) { return P; }
57 static inline T *getFromVoidPointer(void *P) { return static_cast<T *>(P); }
59 enum { NumLowBitsAvailable = detail::ConstantLog2<alignof(T)>::value };
91 typedef PointerLikeTypeTraits<T *> NonConst;
93 static inline const void *getAsVoidPointer(const T *P) {
96 static inline const T *getFromVoidPointer(const void *P) {
lib/Transforms/Vectorize/LoopVectorize.cpp 6970 VPBlockBase *Region = createReplicateRegion(I, Recipe, Plan);
7194 VPBlockBase *Entry = Plan->setEntry(PreEntry->getSingleSuccessor());
lib/Transforms/Vectorize/VPlan.cpp 60 const VPBlockBase *Block = this;
67 VPBlockBase *Block = this;
75 const VPBlockBase *Block = this;
82 VPBlockBase *Block = this;
88 VPBlockBase *VPBlockBase::getEnclosingBlockWithSuccessors() {
96 VPBlockBase *VPBlockBase::getEnclosingBlockWithPredecessors() {
104 void VPBlockBase::deleteCFG(VPBlockBase *Entry) {
105 SmallVector<VPBlockBase *, 8> Blocks;
106 for (VPBlockBase *Block : depth_first(Entry))
109 for (VPBlockBase *Block : Blocks)
123 for (VPBlockBase *PredVPBlock : getHierarchicalPredecessors()) {
165 VPBlockBase *SingleHPred = nullptr;
231 ReversePostOrderTraversal<VPBlockBase *> RPOT(Entry);
235 for (VPBlockBase *Block : RPOT) {
266 for (VPBlockBase *Block : RPOT) {
410 for (VPBlockBase *Block : depth_first(Entry))
424 for (VPBlockBase *SuccVPBlock : VPBB->getHierarchicalSuccessors()) {
490 const Twine VPlanPrinter::getUID(const VPBlockBase *Block) {
495 const Twine VPlanPrinter::getOrCreateName(const VPBlockBase *Block) {
525 for (VPBlockBase *Block : depth_first(Plan.getEntry()))
531 void VPlanPrinter::dumpBlock(const VPBlockBase *Block) {
540 void VPlanPrinter::drawEdge(const VPBlockBase *From, const VPBlockBase *To,
540 void VPlanPrinter::drawEdge(const VPBlockBase *From, const VPBlockBase *To,
544 const VPBlockBase *Tail = From->getExitBasicBlock();
545 const VPBlockBase *Head = To->getEntryBasicBlock();
557 void VPlanPrinter::dumpEdges(const VPBlockBase *Block) {
566 for (auto *Successor : Successors)
619 for (const VPBlockBase *Block : depth_first(Region->getEntry()))
725 ReversePostOrderTraversal<VPBlockBase *> RPOT(Region->getEntry());
726 for (VPBlockBase *Base : RPOT) {
731 void VPInterleavedAccessInfo::visitBlock(VPBlockBase *Block, Old2NewTy &Old2New,
lib/Transforms/Vectorize/VPlan.h 347 SmallVector<VPBlockBase *, 1> Predecessors;
350 SmallVector<VPBlockBase *, 1> Successors;
359 void appendSuccessor(VPBlockBase *Successor) {
365 void appendPredecessor(VPBlockBase *Predecessor) {
371 void removePredecessor(VPBlockBase *Predecessor) {
378 void removeSuccessor(VPBlockBase *Successor) {
395 using VPBlocksTy = SmallVectorImpl<VPBlockBase *>;
433 VPBlockBase *getSingleSuccessor() const {
439 VPBlockBase *getSinglePredecessor() const {
450 VPBlockBase *getEnclosingBlockWithSuccessors();
455 VPBlockBase *getEnclosingBlockWithPredecessors();
469 VPBlockBase *getSingleHierarchicalSuccessor() {
485 VPBlockBase *getSingleHierarchicalPredecessor() {
505 void setOneSuccessor(VPBlockBase *Successor) {
514 void setTwoSuccessors(VPBlockBase *IfTrue, VPBlockBase *IfFalse,
514 void setTwoSuccessors(VPBlockBase *IfTrue, VPBlockBase *IfFalse,
526 void setPredecessors(ArrayRef<VPBlockBase *> NewPreds) {
528 for (auto *Pred : NewPreds)
546 static void deleteCFG(VPBlockBase *Entry);
986 class VPBasicBlock : public VPBlockBase {
1038 static inline bool classof(const VPBlockBase *V) {
1039 return V->getVPBlockID() == VPBlockBase::VPBasicBlockSC;
1071 class VPRegionBlock : public VPBlockBase {
1074 VPBlockBase *Entry;
1077 VPBlockBase *Exit;
1084 VPRegionBlock(VPBlockBase *Entry, VPBlockBase *Exit,
1084 VPRegionBlock(VPBlockBase *Entry, VPBlockBase *Exit,
1103 static inline bool classof(const VPBlockBase *V) {
1104 return V->getVPBlockID() == VPBlockBase::VPRegionBlockSC;
1107 const VPBlockBase *getEntry() const { return Entry; }
1108 VPBlockBase *getEntry() { return Entry; }
1112 void setEntry(VPBlockBase *EntryBlock) {
1123 VPBlockBase &front() const { return *Entry; }
1125 const VPBlockBase *getExit() const { return Exit; }
1126 VPBlockBase *getExit() { return Exit; }
1130 void setExit(VPBlockBase *ExitBlock) {
1156 VPBlockBase *Entry;
1186 VPlan(VPBlockBase *Entry = nullptr) : Entry(Entry) {}
1190 VPBlockBase::deleteCFG(Entry);
1205 VPBlockBase *getEntry() { return Entry; }
1206 const VPBlockBase *getEntry() const { return Entry; }
1208 VPBlockBase *setEntry(VPBlockBase *Block) { return Entry = Block; }
1208 VPBlockBase *setEntry(VPBlockBase *Block) { return Entry = Block; }
1274 SmallDenseMap<const VPBlockBase *, unsigned> BlockID;
1282 void dumpBlock(const VPBlockBase *Block);
1286 void dumpEdges(const VPBlockBase *Block);
1295 unsigned getOrCreateBID(const VPBlockBase *Block) {
1299 const Twine getOrCreateName(const VPBlockBase *Block);
1301 const Twine getUID(const VPBlockBase *Block);
1304 void drawEdge(const VPBlockBase *From, const VPBlockBase *To, bool Hidden,
1304 void drawEdge(const VPBlockBase *From, const VPBlockBase *To, bool Hidden,
1340 using NodeRef = VPBlockBase *;
1341 using ChildIteratorType = SmallVectorImpl<VPBlockBase *>::iterator;
1355 using NodeRef = const VPBlockBase *;
1356 using ChildIteratorType = SmallVectorImpl<VPBlockBase *>::const_iterator;
1372 using NodeRef = VPBlockBase *;
1373 using ChildIteratorType = SmallVectorImpl<VPBlockBase *>::iterator;
1394 struct GraphTraits<VPRegionBlock *> : public GraphTraits<VPBlockBase *> {
1413 : public GraphTraits<const VPBlockBase *> {
1432 : public GraphTraits<Inverse<VPBlockBase *>> {
1465 static void insertBlockAfter(VPBlockBase *NewBlock, VPBlockBase *BlockPtr) {
1465 static void insertBlockAfter(VPBlockBase *NewBlock, VPBlockBase *BlockPtr) {
1482 static void insertTwoBlocksAfter(VPBlockBase *IfTrue, VPBlockBase *IfFalse,
1482 static void insertTwoBlocksAfter(VPBlockBase *IfTrue, VPBlockBase *IfFalse,
1483 VPValue *Condition, VPBlockBase *BlockPtr) {
1499 static void connectBlocks(VPBlockBase *From, VPBlockBase *To) {
1499 static void connectBlocks(VPBlockBase *From, VPBlockBase *To) {
1510 static void disconnectBlocks(VPBlockBase *From, VPBlockBase *To) {
1510 static void disconnectBlocks(VPBlockBase *From, VPBlockBase *To) {
1517 static bool isBackEdge(const VPBlockBase *FromBlock,
1518 const VPBlockBase *ToBlock, const VPLoopInfo *VPLI) {
1531 static bool blockIsLoopLatch(const VPBlockBase *Block,
1541 static unsigned countSuccessorsNoBE(VPBlockBase *PredBlock,
1544 for (VPBlockBase *SuccBlock : PredBlock->getSuccessors()) {
1568 void visitBlock(VPBlockBase *Block, Old2NewTy &Old2New,
lib/Transforms/Vectorize/VPlanDominatorTree.h 26 using VPDominatorTree = DomTreeBase<VPBlockBase>;
28 using VPDomTreeNode = DomTreeNodeBase<VPBlockBase>;
lib/Transforms/Vectorize/VPlanHCFGBuilder.cpp 84 SmallVector<VPBlockBase *, 8> VPBBPreds;
258 VPBlockBase *HeaderVPBB = getOrCreateVPBB(TheLoop->getHeader());
lib/Transforms/Vectorize/VPlanHCFGTransforms.cpp 25 ReversePostOrderTraversal<VPBlockBase *> RPOT(TopRegion->getEntry());
30 for (VPBlockBase *Base : RPOT) {
38 for (VPBlockBase *Base : RPOT) {
lib/Transforms/Vectorize/VPlanLoopInfo.h 27 class VPLoop : public LoopBase<VPBlockBase, VPLoop> {
30 explicit VPLoop(VPBlockBase *VPB) : LoopBase<VPBlockBase, VPLoop>(VPB) {}
40 typedef LoopInfoBase<VPBlockBase, VPLoop> VPLoopInfo;
lib/Transforms/Vectorize/VPlanPredicator.cpp 117 VPlanPredicator::getEdgeTypeBetween(VPBlockBase *FromBlock,
118 VPBlockBase *ToBlock) {
120 for (VPBlockBase *SuccBlock : FromBlock->getSuccessors()) {
133 void VPlanPredicator::createOrPropagatePredicates(VPBlockBase *CurrBlock,
154 for (VPBlockBase *PredBlock : CurrBlock->getPredecessors()) {
189 ReversePostOrderTraversal<VPBlockBase *> RPOT(EntryBlock);
194 for (VPBlockBase *Block : make_range(RPOT.begin(), RPOT.end())) {
208 ReversePostOrderTraversal<VPBlockBase *> RPOT(Region->getEntry());
209 VPBlockBase *PrevBlock = nullptr;
211 for (VPBlockBase *CurrBlock : make_range(RPOT.begin(), RPOT.end())) {
lib/Transforms/Vectorize/VPlanPredicator.h 46 EdgeType getEdgeTypeBetween(VPBlockBase *FromBlock, VPBlockBase *ToBlock);
46 EdgeType getEdgeTypeBetween(VPBlockBase *FromBlock, VPBlockBase *ToBlock);
58 void createOrPropagatePredicates(VPBlockBase *CurrBlock,
lib/Transforms/Vectorize/VPlanVerifier.cpp 29 static bool hasDuplicates(const SmallVectorImpl<VPBlockBase *> &VPBlockVec) {
30 SmallDenseSet<const VPBlockBase *, 8> VPBlockSet;
31 for (const auto *Block : VPBlockVec) {
44 for (const VPBlockBase *VPB :
45 make_range(df_iterator<const VPBlockBase *>::begin(Region->getEntry()),
46 df_iterator<const VPBlockBase *>::end(Region->getExit()))) {
63 for (const VPBlockBase *Succ : Successors) {
80 for (const VPBlockBase *Pred : Predecessors) {
98 const VPBlockBase *Entry = Region->getEntry();
99 const VPBlockBase *Exit = Region->getExit();
116 for (const VPBlockBase *VPB :
117 make_range(df_iterator<const VPBlockBase *>::begin(Region->getEntry()),
118 df_iterator<const VPBlockBase *>::end(Region->getExit()))) {
unittests/Transforms/Vectorize/VPlanDominatorTreeTest.cpp 49 VPBlockBase *PH = TopRegion->getEntry();
50 VPBlockBase *H = PH->getSingleSuccessor();
51 VPBlockBase *IfThen = H->getSuccessors()[0];
52 VPBlockBase *IfElse = H->getSuccessors()[1];
53 VPBlockBase *Latch = IfThen->getSingleSuccessor();
54 VPBlockBase *Exit = Latch->getSuccessors()[0] != H
unittests/Transforms/Vectorize/VPlanHCFGTest.cpp 125 VPBlockBase *Entry = Plan->getEntry()->getEntryBasicBlock();
unittests/Transforms/Vectorize/VPlanLoopInfoTest.cpp 51 VPBlockBase *PH = TopRegion->getEntry();
52 VPBlockBase *H = PH->getSingleSuccessor();
53 VPBlockBase *IfThen = H->getSuccessors()[0];
54 VPBlockBase *IfElse = H->getSuccessors()[1];
55 VPBlockBase *Latch = IfThen->getSingleSuccessor();
56 VPBlockBase *Exit = Latch->getSuccessors()[0] != H
unittests/Transforms/Vectorize/VPlanPredicatorTest.cpp 70 VPBlockBase *PH = TopRegion->getEntry();
71 VPBlockBase *H = PH->getSingleSuccessor();
72 VPBlockBase *InnerLoopH = H->getSingleSuccessor();
73 VPBlockBase *OuterIf = InnerLoopH->getSuccessors()[0];
74 VPBlockBase *InnerLoopLatch = InnerLoopH->getSuccessors()[1];
75 VPBlockBase *InnerIf = OuterIf->getSuccessors()[0];
83 VPBlockBase *InnerLoopLinSucc = InnerLoopH->getSingleSuccessor();
84 VPBlockBase *OuterIfLinSucc = OuterIf->getSingleSuccessor();
85 VPBlockBase *InnerIfLinSucc = InnerIf->getSingleSuccessor();
164 VPBlockBase *PH = TopRegion->getEntry();
165 VPBlockBase *H = PH->getSingleSuccessor();
166 VPBlockBase *OuterIfCmpBlk = H->getSingleSuccessor();
167 VPBlockBase *InnerIfCmpBlk = OuterIfCmpBlk->getSuccessors()[0];
168 VPBlockBase *InnerIfTSucc = InnerIfCmpBlk->getSuccessors()[0];
169 VPBlockBase *InnerIfFSucc = InnerIfCmpBlk->getSuccessors()[1];
170 VPBlockBase *TSuccSucc = InnerIfTSucc->getSingleSuccessor();
171 VPBlockBase *FSuccSucc = InnerIfFSucc->getSingleSuccessor();
unittests/Transforms/Vectorize/VPlanSlpTest.cpp 100 VPBlockBase *Entry = Plan->getEntry()->getEntryBasicBlock();
167 VPBlockBase *Entry = Plan->getEntry()->getEntryBasicBlock();
234 VPBlockBase *Entry = Plan->getEntry()->getEntryBasicBlock();
293 VPBlockBase *Entry = Plan->getEntry()->getEntryBasicBlock();
421 VPBlockBase *Entry = Plan->getEntry()->getEntryBasicBlock();
493 VPBlockBase *Entry = Plan->getEntry()->getEntryBasicBlock();
565 VPBlockBase *Entry = Plan->getEntry()->getEntryBasicBlock();
641 VPBlockBase *Entry = Plan->getEntry()->getEntryBasicBlock();
702 VPBlockBase *Entry = Plan->getEntry()->getEntryBasicBlock();
765 VPBlockBase *Entry = Plan->getEntry()->getEntryBasicBlock();
825 VPBlockBase *Entry = Plan->getEntry()->getEntryBasicBlock();
884 VPBlockBase *Entry = Plan->getEntry()->getEntryBasicBlock();
usr/include/c++/7.4.0/type_traits 1983 { typedef _Up type; };
utils/unittest/googletest/include/gtest/gtest-printers.h 407 T* p, ::std::ostream* os) {
416 if (IsTrue(ImplicitlyConvertible<T*, const void*>::value)) {