|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
Declarations
tools/clang/include/clang/Analysis/Analyses/CFGReachabilityAnalysis.h 24 class CFGBlock;
tools/clang/include/clang/Analysis/Analyses/LiveVariables.h 23 class CFGBlock;
tools/clang/include/clang/Analysis/Analyses/ReachableCode.h 28 class CFGBlock;
tools/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporterVisitors.h 29 class CFGBlock;
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SubEngine.h 21 class CFGBlock;
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/WorkList.h 23 class CFGBlock;
References
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/ADT/STLExtras.h 261 auto reverse(ContainerTy &&C,
include/llvm/Support/Allocator.h 81 template <typename T> T *Allocate(size_t Num = 1) {
82 return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82 return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
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 {
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/GenericIteratedDominanceFrontier.h 60 typename std::conditional<IsPostDom, Inverse<NodeTy *>, NodeTy *>::type;
60 typename std::conditional<IsPostDom, Inverse<NodeTy *>, NodeTy *>::type;
62 IDFCalculatorDetail::ChildrenGetterTy<NodeTy, IsPostDom>;
64 IDFCalculatorBase(DominatorTreeBase<NodeTy, IsPostDom> &DT) : DT(DT) {}
66 IDFCalculatorBase(DominatorTreeBase<NodeTy, IsPostDom> &DT,
75 void setDefiningBlocks(const SmallPtrSetImpl<NodeTy *> &Blocks) {
84 void setLiveInBlocks(const SmallPtrSetImpl<NodeTy *> &Blocks) {
102 void calculate(SmallVectorImpl<NodeTy *> &IDFBlocks);
105 DominatorTreeBase<NodeTy, IsPostDom> &DT;
108 const SmallPtrSetImpl<NodeTy *> *LiveInBlocks;
109 const SmallPtrSetImpl<NodeTy *> *DefBlocks;
138 std::pair<DomTreeNodeBase<NodeTy> *, std::pair<unsigned, unsigned>>;
147 for (NodeTy *BB : *DefBlocks) {
148 if (DomTreeNodeBase<NodeTy> *Node = DT.getNode(BB))
152 SmallVector<DomTreeNodeBase<NodeTy> *, 32> Worklist;
153 SmallPtrSet<DomTreeNodeBase<NodeTy> *, 32> VisitedPQ;
154 SmallPtrSet<DomTreeNodeBase<NodeTy> *, 32> VisitedWorklist;
159 DomTreeNodeBase<NodeTy> *Root = RootPair.first;
172 DomTreeNodeBase<NodeTy> *Node = Worklist.pop_back_val();
173 NodeTy *BB = Node->getBlock();
177 DomTreeNodeBase<NodeTy> *SuccNode = DT.getNode(Succ);
186 NodeTy *SuccBB = SuccNode->getBlock();
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) {
tools/clang/include/clang/Analysis/Analyses/CFGReachabilityAnalysis.h 42 bool isReachable(const CFGBlock *Src, const CFGBlock *Dst);
42 bool isReachable(const CFGBlock *Src, const CFGBlock *Dst);
45 void mapReachability(const CFGBlock *Dst);
tools/clang/include/clang/Analysis/Analyses/Consumed.h 176 void intersectAtLoopHead(const CFGBlock *LoopHead, const CFGBlock *LoopBack,
176 void intersectAtLoopHead(const CFGBlock *LoopHead, const CFGBlock *LoopBack,
221 bool allBackEdgesVisited(const CFGBlock *CurrBlock,
222 const CFGBlock *TargetBlock);
224 void addInfo(const CFGBlock *Block, ConsumedStateMap *StateMap,
226 void addInfo(const CFGBlock *Block,
229 ConsumedStateMap* borrowInfo(const CFGBlock *Block);
231 void discardInfo(const CFGBlock *Block);
233 std::unique_ptr<ConsumedStateMap> getInfo(const CFGBlock *Block);
235 bool isBackEdge(const CFGBlock *From, const CFGBlock *To);
235 bool isBackEdge(const CFGBlock *From, const CFGBlock *To);
236 bool isBackEdgeTarget(const CFGBlock *Block);
248 bool splitState(const CFGBlock *CurrBlock,
tools/clang/include/clang/Analysis/Analyses/Dominators.h 38 using DomTreeNode = llvm::DomTreeNodeBase<CFGBlock>;
46 using DominatorTreeBase = llvm::DominatorTreeBase<CFGBlock, IsPostDom>;
61 CFGBlock *getRoot() const {
136 bool dominates(const CFGBlock *A, const CFGBlock *B) const {
136 bool dominates(const CFGBlock *A, const CFGBlock *B) const {
143 bool properlyDominates(const CFGBlock *A, const CFGBlock *B) const {
143 bool properlyDominates(const CFGBlock *A, const CFGBlock *B) const {
149 CFGBlock *findNearestCommonDominator(CFGBlock *A, CFGBlock *B) {
149 CFGBlock *findNearestCommonDominator(CFGBlock *A, CFGBlock *B) {
149 CFGBlock *findNearestCommonDominator(CFGBlock *A, CFGBlock *B) {
153 const CFGBlock *findNearestCommonDominator(const CFGBlock *A,
153 const CFGBlock *findNearestCommonDominator(const CFGBlock *A,
154 const CFGBlock *B) {
160 void changeImmediateDominator(CFGBlock *N, CFGBlock *NewIDom) {
160 void changeImmediateDominator(CFGBlock *N, CFGBlock *NewIDom) {
165 bool isReachableFromEntry(const CFGBlock *A) {
197 struct ChildrenGetterTy<clang::CFGBlock, IsPostDom> {
198 using NodeRef = typename GraphTraits<clang::CFGBlock>::NodeRef;
203 typename IDFCalculatorBase<clang::CFGBlock, IsPostDom>::OrderedNodeTy;
218 using IDFCalculator = llvm::IDFCalculatorBase<CFGBlock, /*IsPostDom=*/true>;
219 using CFGBlockVector = llvm::SmallVector<CFGBlock *, 4>;
220 using CFGBlockSet = llvm::SmallPtrSet<CFGBlock *, 4>;
225 llvm::DenseMap<CFGBlock *, CFGBlockVector> ControlDepenencyMap;
251 bool isControlDependent(CFGBlock *A, CFGBlock *B) {
251 bool isControlDependent(CFGBlock *A, CFGBlock *B) {
259 for (CFGBlock *BB : *cfg) {
265 for (CFGBlock *isControlDependency : getControlDependencies(BB))
tools/clang/include/clang/Analysis/Analyses/LiveVariables.h 62 const CFGBlock *currentBlock,
78 bool isLive(const CFGBlock *B, const VarDecl *D);
tools/clang/include/clang/Analysis/Analyses/PostOrderCFGView.h 44 struct iterator { using value_type = const CFGBlock *; };
51 std::pair<llvm::NoneType, bool> insert(const CFGBlock *Block) {
67 bool alreadySet(const CFGBlock *Block) {
74 std::vector<const CFGBlock *> Blocks;
76 using BlockOrderTy = llvm::DenseMap<const CFGBlock *, unsigned>;
82 using iterator = std::vector<const CFGBlock *>::reverse_iterator;
83 using const_iterator = std::vector<const CFGBlock *>::const_reverse_iterator;
101 bool operator()(const CFGBlock *b1, const CFGBlock *b2) const;
101 bool operator()(const CFGBlock *b1, const CFGBlock *b2) const;
tools/clang/include/clang/Analysis/Analyses/ReachableCode.h 60 unsigned ScanReachableFromBlock(const CFGBlock *Start,
tools/clang/include/clang/Analysis/Analyses/ThreadSafetyCommon.h 102 void enterCFG(CFG *Cfg, const NamedDecl *D, const CFGBlock *First) {}
105 void enterCFGBlock(const CFGBlock *B) {}
111 void handlePredecessor(const CFGBlock *Pred) {}
114 void handlePredecessorBackEdge(const CFGBlock *Pred) {}
117 void enterCFGBlockBody(const CFGBlock *B) {}
126 void exitCFGBlockBody(const CFGBlock *B) {}
132 void handleSuccessor(const CFGBlock *Succ) {}
135 void handleSuccessorBackEdge(const CFGBlock *Succ) {}
138 void exitCFGBlock(const CFGBlock *B) {}
141 void exitCFG(const CFGBlock *Last) {}
175 for (const auto *CurrBlock : *SortedGraph) {
182 SmallVector<CFGBlock*, 4> BackEdges;
184 for (CFGBlock::const_pred_iterator SI = CurrBlock->pred_begin(),
197 for (auto *Blk : BackEdges)
227 SmallVector<CFGBlock*, 8> ForwardEdges;
230 for (CFGBlock::const_succ_iterator SI = CurrBlock->succ_begin(),
243 for (auto *Blk : ForwardEdges)
384 til::BasicBlock *lookupBlock(const CFGBlock *B) {
450 void enterCFG(CFG *Cfg, const NamedDecl *D, const CFGBlock *First);
451 void enterCFGBlock(const CFGBlock *B);
453 void handlePredecessor(const CFGBlock *Pred);
454 void handlePredecessorBackEdge(const CFGBlock *Pred);
455 void enterCFGBlockBody(const CFGBlock *B);
458 void exitCFGBlockBody(const CFGBlock *B);
460 void handleSuccessor(const CFGBlock *Succ);
461 void handleSuccessorBackEdge(const CFGBlock *Succ);
462 void exitCFGBlock(const CFGBlock *B);
463 void exitCFG(const CFGBlock *Last);
480 void mergePhiNodesBackEdge(const CFGBlock *Blk);
tools/clang/include/clang/Analysis/AnalysisDeclContext.h 133 const CFGBlock *getBlockForRegisteredExpression(const Stmt *stmt);
186 const Stmt *S, const CFGBlock *Blk,
303 const CFGBlock *Block;
314 const Stmt *s, const CFGBlock *blk, unsigned blockCount,
324 const CFGBlock *getCallSiteBlock() const { return Block; }
335 const CFGBlock *blk, unsigned blockCount, unsigned idx) {
417 const Stmt *s, const CFGBlock *blk,
491 const Stmt *S, const CFGBlock *Blk,
505 const Stmt *S, const CFGBlock *Blk,
tools/clang/include/clang/Analysis/CFG.h 627 typename std::conditional<IsConst, const CFGBlock *, CFGBlock *>::type;
627 typename std::conditional<IsConst, const CFGBlock *, CFGBlock *>::type;
678 typename std::conditional<IsConst, const CFGBlock *, CFGBlock *>::type;
678 typename std::conditional<IsConst, const CFGBlock *, CFGBlock *>::type;
689 using ElementRef = typename CFGBlock::ElementRefImpl<IsConst>;
729 getIndexInBlock(CFGBlock::ElementRefIterator<true, IsOtherConst> E) {
735 getIndexInBlock(CFGBlock::ElementRefIterator<false, IsOtherConst> E) {
799 CFGBlock *ReachableBlock;
800 llvm::PointerIntPair<CFGBlock *, 2> UnreachableBlock;
804 AdjacentBlock(CFGBlock *B, bool IsReachable);
808 AdjacentBlock(CFGBlock *B, CFGBlock *AlternateBlock);
808 AdjacentBlock(CFGBlock *B, CFGBlock *AlternateBlock);
811 CFGBlock *getReachableBlock() const {
816 CFGBlock *getPossiblyUnreachableBlock() const {
822 operator CFGBlock*() const {
826 CFGBlock& operator *() const {
830 CFGBlock* operator ->() const {
990 static bool FilterEdge(const FilterOptions &F, const CFGBlock *Src,
991 const CFGBlock *Dst);
998 const CFGBlock *From;
1002 const CFGBlock *from,
1016 const CFGBlock *operator*() const { return *I; }
1019 bool Filter(const CFGBlock *To) {
1236 using ForcedBlkExprs = llvm::DenseMap<const Stmt *, const CFGBlock *>;
1278 CFGBlock *createBlock();
1283 void setEntry(CFGBlock *B) { Entry = B; }
1287 void setIndirectGotoBlock(CFGBlock *B) { IndirectGotoBlock = B; }
1293 using CFGBlockListTy = BumpVector<CFGBlock *>;
1299 CFGBlock & front() { return *Blocks.front(); }
1300 CFGBlock & back() { return *Blocks.back(); }
1317 CFGBlock & getEntry() { return *Entry; }
1318 const CFGBlock & getEntry() const { return *Entry; }
1319 CFGBlock & getExit() { return *Exit; }
1320 const CFGBlock & getExit() const { return *Exit; }
1322 CFGBlock * getIndirectGotoBlock() { return IndirectGotoBlock; }
1323 const CFGBlock * getIndirectGotoBlock() const { return IndirectGotoBlock; }
1325 using try_block_iterator = std::vector<const CFGBlock *>::const_iterator;
1335 void addTryDispatchBlock(const CFGBlock *block) {
1381 for (CFGBlock::const_iterator BI = (*I)->begin(), BE = (*I)->end();
1429 CFGBlock *Entry = nullptr;
1430 CFGBlock *Exit = nullptr;
1433 CFGBlock* IndirectGotoBlock = nullptr;
1443 std::vector<const CFGBlock *> TryDispatchBlocks;
1471 using NodeRef = ::clang::CFGBlock *;
1472 using ChildIteratorType = ::clang::CFGBlock::succ_iterator;
1474 static NodeRef getEntryNode(::clang::CFGBlock *BB) { return BB; }
1480 : GraphTraits<clang::CFGBlock *> {};
1483 using NodeRef = const ::clang::CFGBlock *;
1484 using ChildIteratorType = ::clang::CFGBlock::const_succ_iterator;
1486 static NodeRef getEntryNode(const clang::CFGBlock *BB) { return BB; }
1492 : GraphTraits<clang::CFGBlock *> {};
1495 using NodeRef = ::clang::CFGBlock *;
1496 using ChildIteratorType = ::clang::CFGBlock::const_pred_iterator;
1498 static NodeRef getEntryNode(Inverse<::clang::CFGBlock *> G) {
1507 : GraphTraits<clang::CFGBlock *> {};
1510 using NodeRef = const ::clang::CFGBlock *;
1511 using ChildIteratorType = ::clang::CFGBlock::const_pred_iterator;
1513 static NodeRef getEntryNode(Inverse<const ::clang::CFGBlock *> G) {
1522 : GraphTraits<clang::CFGBlock *> {};
1527 : public GraphTraits< ::clang::CFGBlock *> {
1537 : public GraphTraits<const ::clang::CFGBlock *> {
1556 : public GraphTraits<Inverse< ::clang::CFGBlock *>> {
1565 : public GraphTraits<Inverse<const ::clang::CFGBlock *>> {
tools/clang/include/clang/Analysis/CFGStmtMap.h 41 CFGBlock *getBlock(Stmt * S);
43 const CFGBlock *getBlock(const Stmt * S) const {
tools/clang/include/clang/Analysis/ProgramPoint.h 227 BlockEntrance(const CFGBlock *B, const LocationContext *L,
233 const CFGBlock *getBlock() const {
238 const CFGBlock *B = getBlock();
252 BlockExit(const CFGBlock *B, const LocationContext *L)
255 const CFGBlock *getBlock() const {
342 const CFGBlock *getBlock() const {
505 BlockEdge(const CFGBlock *B1, const CFGBlock *B2, const LocationContext *L)
505 BlockEdge(const CFGBlock *B1, const CFGBlock *B2, const LocationContext *L)
511 const CFGBlock *getSrc() const {
515 const CFGBlock *getDst() const {
645 const CFGBlock *getEntry() const {
tools/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporterVisitors.h 240 const CFGBlock *SrcBlk, const CFGBlock *DstBlk,
240 const CFGBlock *SrcBlk, const CFGBlock *DstBlk,
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CoreEngine.h 69 std::vector<std::pair<const CFGBlock *, const ExplodedNode *>>;
109 void HandleBlockExit(const CFGBlock *B, ExplodedNode *Pred);
113 void HandlePostStmt(const CFGBlock *B, unsigned StmtIdx, ExplodedNode *Pred);
115 void HandleBranch(const Stmt *Cond, const Stmt *Term, const CFGBlock *B,
118 const CFGBlock *B, ExplodedNode *Pred);
121 void HandleStaticInit(const DeclStmt *DS, const CFGBlock *B,
124 void HandleVirtualBaseBranch(const CFGBlock *B, ExplodedNode *Pred);
167 void addAbortedBlock(const ExplodedNode *node, const CFGBlock *block) {
194 void enqueue(ExplodedNodeSet &Set, const CFGBlock *Block, unsigned Idx);
201 void enqueueStmtNode(ExplodedNode *N, const CFGBlock *Block, unsigned Idx);
209 const CFGBlock *Block;
212 NodeBuilderContext(const CoreEngine &E, const CFGBlock *B, ExplodedNode *N)
216 const CFGBlock *getBlock() const { return Block; }
431 const CFGBlock *DstT;
432 const CFGBlock *DstF;
442 const CFGBlock *dstT, const CFGBlock *dstF)
442 const CFGBlock *dstT, const CFGBlock *dstF)
452 const CFGBlock *dstT, const CFGBlock *dstF)
452 const CFGBlock *dstT, const CFGBlock *dstF)
461 const CFGBlock *getTargetBlock(bool branch) const {
479 const CFGBlock *Src;
480 const CFGBlock &DispatchBlock;
485 IndirectGotoNodeBuilder(ExplodedNode *pred, const CFGBlock *src,
486 const Expr *e, const CFGBlock *dispatch, CoreEngine* eng)
492 CFGBlock::const_succ_iterator I;
494 iterator(CFGBlock::const_succ_iterator i) : I(i) {}
504 const CFGBlock *getBlock() const {
527 const CFGBlock *Src;
532 SwitchNodeBuilder(ExplodedNode *pred, const CFGBlock *src,
539 CFGBlock::const_succ_reverse_iterator I;
541 iterator(CFGBlock::const_succ_reverse_iterator i) : I(i) {}
552 const CFGBlock *getBlock() const {
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h 158 const CFGBlock *getCFGBlock() const;
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h 307 const CFGBlock *DstT,
308 const CFGBlock *DstF) override;
316 const CFGBlock *DstT,
317 const CFGBlock *DstF) override;
325 const CFGBlock *DstT,
326 const CFGBlock *DstF) override;
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SubEngine.h 78 const CFGBlock *DstT,
79 const CFGBlock *DstF) = 0;
88 const CFGBlock *DstT,
89 const CFGBlock *DstF) = 0;
97 const CFGBlock *DstT,
98 const CFGBlock *DstF) = 0;
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/WorkList.h 30 const CFGBlock *block;
35 const CFGBlock *B, unsigned idx)
54 const CFGBlock *getBlock() const { return block; }
68 void enqueue(ExplodedNode *N, const CFGBlock *B, unsigned idx) {
tools/clang/lib/Analysis/AnalysisDeclContext.cpp 189 const CFGBlock *
313 const CFGBlock *Blk, unsigned BlockCount,
400 const CFGBlock *blk, unsigned blockCount, unsigned idx) {
tools/clang/lib/Analysis/CFG.cpp 374 CFGBlock *block = nullptr;
378 BlockScopePosPair(CFGBlock *b, LocalScope::const_iterator scopePos)
476 CFGBlock *Block = nullptr;
479 CFGBlock *Succ = nullptr;
484 CFGBlock *SwitchTerminatedBlock = nullptr;
485 CFGBlock *DefaultCaseBlock = nullptr;
489 CFGBlock *TryTerminatedBlock = nullptr;
545 CFGBlock *VisitAddrLabelExpr(AddrLabelExpr *A, AddStmtChoice asc);
546 CFGBlock *VisitBinaryOperator(BinaryOperator *B, AddStmtChoice asc);
547 CFGBlock *VisitBreakStmt(BreakStmt *B);
548 CFGBlock *VisitCallExpr(CallExpr *C, AddStmtChoice asc);
549 CFGBlock *VisitCaseStmt(CaseStmt *C);
550 CFGBlock *VisitChooseExpr(ChooseExpr *C, AddStmtChoice asc);
551 CFGBlock *VisitCompoundStmt(CompoundStmt *C, bool ExternallyDestructed);
552 CFGBlock *VisitConditionalOperator(AbstractConditionalOperator *C,
554 CFGBlock *VisitContinueStmt(ContinueStmt *C);
555 CFGBlock *VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E,
557 CFGBlock *VisitCXXCatchStmt(CXXCatchStmt *S);
558 CFGBlock *VisitCXXConstructExpr(CXXConstructExpr *C, AddStmtChoice asc);
559 CFGBlock *VisitCXXNewExpr(CXXNewExpr *DE, AddStmtChoice asc);
560 CFGBlock *VisitCXXDeleteExpr(CXXDeleteExpr *DE, AddStmtChoice asc);
561 CFGBlock *VisitCXXForRangeStmt(CXXForRangeStmt *S);
562 CFGBlock *VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E,
564 CFGBlock *VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *C,
566 CFGBlock *VisitCXXThrowExpr(CXXThrowExpr *T);
567 CFGBlock *VisitCXXTryStmt(CXXTryStmt *S);
568 CFGBlock *VisitDeclStmt(DeclStmt *DS);
569 CFGBlock *VisitDeclSubExpr(DeclStmt *DS);
570 CFGBlock *VisitDefaultStmt(DefaultStmt *D);
571 CFGBlock *VisitDoStmt(DoStmt *D);
572 CFGBlock *VisitExprWithCleanups(ExprWithCleanups *E,
574 CFGBlock *VisitForStmt(ForStmt *F);
575 CFGBlock *VisitGotoStmt(GotoStmt *G);
576 CFGBlock *VisitGCCAsmStmt(GCCAsmStmt *G, AddStmtChoice asc);
577 CFGBlock *VisitIfStmt(IfStmt *I);
578 CFGBlock *VisitImplicitCastExpr(ImplicitCastExpr *E, AddStmtChoice asc);
579 CFGBlock *VisitConstantExpr(ConstantExpr *E, AddStmtChoice asc);
580 CFGBlock *VisitIndirectGotoStmt(IndirectGotoStmt *I);
581 CFGBlock *VisitLabelStmt(LabelStmt *L);
582 CFGBlock *VisitBlockExpr(BlockExpr *E, AddStmtChoice asc);
583 CFGBlock *VisitLambdaExpr(LambdaExpr *E, AddStmtChoice asc);
584 CFGBlock *VisitLogicalOperator(BinaryOperator *B);
585 std::pair<CFGBlock *, CFGBlock *> VisitLogicalOperator(BinaryOperator *B,
585 std::pair<CFGBlock *, CFGBlock *> VisitLogicalOperator(BinaryOperator *B,
587 CFGBlock *TrueBlock,
588 CFGBlock *FalseBlock);
589 CFGBlock *VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *MTE,
591 CFGBlock *VisitMemberExpr(MemberExpr *M, AddStmtChoice asc);
592 CFGBlock *VisitObjCAtCatchStmt(ObjCAtCatchStmt *S);
593 CFGBlock *VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S);
594 CFGBlock *VisitObjCAtThrowStmt(ObjCAtThrowStmt *S);
595 CFGBlock *VisitObjCAtTryStmt(ObjCAtTryStmt *S);
596 CFGBlock *VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S);
597 CFGBlock *VisitObjCForCollectionStmt(ObjCForCollectionStmt *S);
598 CFGBlock *VisitObjCMessageExpr(ObjCMessageExpr *E, AddStmtChoice asc);
599 CFGBlock *VisitPseudoObjectExpr(PseudoObjectExpr *E);
600 CFGBlock *VisitReturnStmt(Stmt *S);
601 CFGBlock *VisitSEHExceptStmt(SEHExceptStmt *S);
602 CFGBlock *VisitSEHFinallyStmt(SEHFinallyStmt *S);
603 CFGBlock *VisitSEHLeaveStmt(SEHLeaveStmt *S);
604 CFGBlock *VisitSEHTryStmt(SEHTryStmt *S);
605 CFGBlock *VisitStmtExpr(StmtExpr *S, AddStmtChoice asc);
606 CFGBlock *VisitSwitchStmt(SwitchStmt *S);
607 CFGBlock *VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E,
609 CFGBlock *VisitUnaryOperator(UnaryOperator *U, AddStmtChoice asc);
610 CFGBlock *VisitWhileStmt(WhileStmt *W);
612 CFGBlock *Visit(Stmt *S, AddStmtChoice asc = AddStmtChoice::NotAlwaysAdd,
614 CFGBlock *VisitStmt(Stmt *S, AddStmtChoice asc);
615 CFGBlock *VisitChildren(Stmt *S);
616 CFGBlock *VisitNoRecurse(Expr *E, AddStmtChoice asc);
617 CFGBlock *VisitOMPExecutableDirective(OMPExecutableDirective *D,
620 void maybeAddScopeBeginForVarDecl(CFGBlock *B, const VarDecl *VD,
671 void setDecisionPoint(CFGBlock *S, CXXBindTemporaryExpr *E) {
678 CFGBlock *Succ = nullptr;
684 CFGBlock *VisitForTemporaryDtors(Stmt *E, bool ExternallyDestructed,
686 CFGBlock *VisitChildrenForTemporaryDtors(Stmt *E, bool ExternallyDestructed,
688 CFGBlock *VisitBinaryOperatorForTemporaryDtors(BinaryOperator *E,
691 CFGBlock *VisitCXXBindTemporaryExprForTemporaryDtors(
693 CFGBlock *VisitConditionalOperatorForTemporaryDtors(
697 CFGBlock *FalseSucc = nullptr);
700 CFGBlock *NYS() {
743 CFGBlock *createBlock(bool add_successor = true);
744 CFGBlock *createNoReturnBlock();
746 CFGBlock *addStmt(Stmt *S) {
750 CFGBlock *addInitializer(CXXCtorInitializer *I);
790 void appendStmt(CFGBlock *B, const Stmt *S) {
799 void appendConstructor(CFGBlock *B, CXXConstructExpr *CE) {
810 void appendCall(CFGBlock *B, CallExpr *CE) {
824 void appendInitializer(CFGBlock *B, CXXCtorInitializer *I) {
828 void appendNewAllocator(CFGBlock *B, CXXNewExpr *NE) {
832 void appendBaseDtor(CFGBlock *B, const CXXBaseSpecifier *BS) {
836 void appendMemberDtor(CFGBlock *B, FieldDecl *FD) {
840 void appendObjCMessage(CFGBlock *B, ObjCMessageExpr *ME) {
854 void appendTemporaryDtor(CFGBlock *B, CXXBindTemporaryExpr *E) {
858 void appendAutomaticObjDtor(CFGBlock *B, VarDecl *VD, Stmt *S) {
862 void appendLifetimeEnds(CFGBlock *B, VarDecl *VD, Stmt *S) {
866 void appendLoopExit(CFGBlock *B, const Stmt *LoopStmt) {
870 void appendDeleteDtor(CFGBlock *B, CXXRecordDecl *RD, CXXDeleteExpr *DE) {
874 void prependAutomaticObjDtorsWithTerminator(CFGBlock *Blk,
877 void prependAutomaticObjLifetimeWithTerminator(CFGBlock *Blk,
882 prependAutomaticObjScopeEndWithTerminator(CFGBlock *Blk,
886 void addSuccessor(CFGBlock *B, CFGBlock *S, bool IsReachable = true) {
886 void addSuccessor(CFGBlock *B, CFGBlock *S, bool IsReachable = true) {
893 void addSuccessor(CFGBlock *B, CFGBlock *ReachableBlock, CFGBlock *AltBlock) {
893 void addSuccessor(CFGBlock *B, CFGBlock *ReachableBlock, CFGBlock *AltBlock) {
893 void addSuccessor(CFGBlock *B, CFGBlock *ReachableBlock, CFGBlock *AltBlock) {
898 void appendScopeBegin(CFGBlock *B, const VarDecl *VD, const Stmt *S) {
903 void prependScopeBegin(CFGBlock *B, const VarDecl *VD, const Stmt *S) {
908 void appendScopeEnd(CFGBlock *B, const VarDecl *VD, const Stmt *S) {
913 void prependScopeEnd(CFGBlock *B, const VarDecl *VD, const Stmt *S) {
1499 CFGBlock *B = addStmt(Statement);
1517 CFGBlock *VBaseSucc = nullptr;
1549 CFGBlock *B = I->block;
1567 CFGBlock *Successor = (I+1)->block;
1585 if (CFGBlock *B = cfg->getIndirectGotoBlock())
1610 CFGBlock *CFGBuilder::createBlock(bool add_successor) {
1611 CFGBlock *B = cfg->createBlock();
1620 CFGBlock *CFGBuilder::createNoReturnBlock() {
1621 CFGBlock *B = createBlock(false);
1628 CFGBlock *CFGBuilder::addInitializer(CXXCtorInitializer *I) {
1669 if (CFGBlock *R = Visit(Child))
2067 void CFGBuilder::prependAutomaticObjDtorsWithTerminator(CFGBlock *Blk,
2072 CFGBlock::iterator InsertPos
2085 CFGBlock *Blk, LocalScope::const_iterator B, LocalScope::const_iterator E) {
2089 CFGBlock::iterator InsertPos =
2104 CFGBlock *Blk, LocalScope::const_iterator B, LocalScope::const_iterator E) {
2108 CFGBlock::iterator InsertPos =
2120 CFGBlock *CFGBuilder::Visit(Stmt * S, AddStmtChoice asc,
2328 CFGBlock *CFGBuilder::VisitStmt(Stmt *S, AddStmtChoice asc) {
2338 CFGBlock *CFGBuilder::VisitChildren(Stmt *S) {
2339 CFGBlock *B = Block;
2347 if (CFGBlock *R = Visit(Child))
2353 CFGBlock *CFGBuilder::VisitAddrLabelExpr(AddrLabelExpr *A,
2365 CFGBlock *CFGBuilder::VisitUnaryOperator(UnaryOperator *U,
2378 CFGBlock *CFGBuilder::VisitLogicalOperator(BinaryOperator *B) {
2379 CFGBlock *ConfluenceBlock = Block ? Block : createBlock();
2389 std::pair<CFGBlock*, CFGBlock*>
2389 std::pair<CFGBlock*, CFGBlock*>
2392 CFGBlock *TrueBlock,
2393 CFGBlock *FalseBlock) {
2398 CFGBlock *RHSBlock, *ExitBlock;
2457 CFGBlock *LHSBlock = createBlock(false);
2461 CFGBlock *EntryLHSBlock = addStmt(LHS);
2482 CFGBlock *CFGBuilder::VisitBinaryOperator(BinaryOperator *B,
2512 CFGBlock *RBlock = Visit(B->getRHS());
2513 CFGBlock *LBlock = Visit(B->getLHS());
2520 CFGBlock *CFGBuilder::VisitNoRecurse(Expr *E, AddStmtChoice asc) {
2528 CFGBlock *CFGBuilder::VisitBreakStmt(BreakStmt *B) {
2564 CFGBlock *CFGBuilder::VisitCallExpr(CallExpr *C, AddStmtChoice asc) {
2649 CFGBlock *CFGBuilder::VisitChooseExpr(ChooseExpr *C,
2651 CFGBlock *ConfluenceBlock = Block ? Block : createBlock();
2659 CFGBlock *LHSBlock = Visit(C->getLHS(), alwaysAdd);
2665 CFGBlock *RHSBlock = Visit(C->getRHS(), alwaysAdd);
2678 CFGBlock *CFGBuilder::VisitCompoundStmt(CompoundStmt *C, bool ExternallyDestructed) {
2688 CFGBlock *LastBlock = Block;
2694 CFGBlock *newBlock = Visit(*I, AddStmtChoice::AlwaysAdd,
2709 CFGBlock *CFGBuilder::VisitConditionalOperator(AbstractConditionalOperator *C,
2716 CFGBlock *ConfluenceBlock = Block ? Block : createBlock();
2729 CFGBlock *LHSBlock = nullptr;
2742 CFGBlock *RHSBlock = Visit(C->getFalseExpr(), alwaysAdd);
2776 CFGBlock *CFGBuilder::VisitDeclStmt(DeclStmt *DS) {
2786 CFGBlock *B = nullptr;
2809 CFGBlock *CFGBuilder::VisitDeclSubExpr(DeclStmt *DS) {
2822 CFGBlock *blockAfterStaticInit = nullptr;
2860 CFGBlock *LastBlock = Block;
2867 if (CFGBlock *newBlock = Visit(EC->getSubExpr()))
2871 if (CFGBlock *newBlock = Visit(Init))
2879 if (CFGBlock *newBlock = addStmt(VA->getSizeExpr()))
2889 CFGBlock *B = LastBlock;
2902 CFGBlock *CFGBuilder::VisitIfStmt(IfStmt *I) {
2934 CFGBlock *ElseBlock = Succ;
2937 SaveAndRestore<CFGBlock*> sv(Succ);
2959 CFGBlock *ThenBlock;
2963 SaveAndRestore<CFGBlock*> sv(Succ);
2996 CFGBlock *LastBlock;
3036 CFGBlock *CFGBuilder::VisitReturnStmt(Stmt *S) {
3073 CFGBlock *CFGBuilder::VisitSEHExceptStmt(SEHExceptStmt *ES) {
3082 CFGBlock *SEHExceptBlock = Block;
3101 CFGBlock *CFGBuilder::VisitSEHFinallyStmt(SEHFinallyStmt *FS) {
3105 CFGBlock *CFGBuilder::VisitSEHLeaveStmt(SEHLeaveStmt *LS) {
3126 CFGBlock *CFGBuilder::VisitSEHTryStmt(SEHTryStmt *Terminator) {
3129 CFGBlock *SEHTrySuccessor = nullptr;
3141 CFGBlock *PrevSEHTryTerminatedBlock = TryTerminatedBlock;
3144 CFGBlock *NewTryTerminatedBlock = createBlock(false);
3153 CFGBlock *ExceptBlock = VisitSEHExceptStmt(Except);
3169 SaveAndRestore<CFGBlock *> save_try(TryTerminatedBlock,
3184 CFGBlock *CFGBuilder::VisitLabelStmt(LabelStmt *L) {
3187 CFGBlock *LabelBlock = Block;
3213 CFGBlock *CFGBuilder::VisitBlockExpr(BlockExpr *E, AddStmtChoice asc) {
3214 CFGBlock *LastBlock = VisitNoRecurse(E, asc);
3217 CFGBlock *Tmp = Visit(CopyExpr);
3225 CFGBlock *CFGBuilder::VisitLambdaExpr(LambdaExpr *E, AddStmtChoice asc) {
3226 CFGBlock *LastBlock = VisitNoRecurse(E, asc);
3230 CFGBlock *Tmp = Visit(Init);
3238 CFGBlock *CFGBuilder::VisitGotoStmt(GotoStmt *G) {
3260 CFGBlock *CFGBuilder::VisitGCCAsmStmt(GCCAsmStmt *G, AddStmtChoice asc) {
3282 CFGBlock *CFGBuilder::VisitForStmt(ForStmt *F) {
3283 CFGBlock *LoopSuccessor = nullptr;
3318 CFGBlock *BodyBlock = nullptr, *TransitionBlock = nullptr;
3325 SaveAndRestore<CFGBlock*> save_Block(Block), save_Succ(Succ);
3377 CFGBlock *EntryConditionBlock = nullptr, *ExitConditionBlock = nullptr;
3460 CFGBlock *
3470 CFGBlock *CFGBuilder::VisitMemberExpr(MemberExpr *M, AddStmtChoice asc) {
3478 CFGBlock *CFGBuilder::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
3510 CFGBlock *LoopSuccessor = nullptr;
3521 CFGBlock *ExitConditionBlock = createBlock(false);
3535 CFGBlock *EntryConditionBlock = Visit(S->getElement(),
3550 SaveAndRestore<CFGBlock*> save_Block(Block), save_Succ(Succ);
3557 CFGBlock *LoopBackBlock = nullptr;
3564 CFGBlock *BodyBlock = addStmt(S->getBody());
3586 CFGBlock *CFGBuilder::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) {
3592 CFGBlock *CFGBuilder::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
3596 CFGBlock *SyncBlock = addStmt(S->getSynchBody());
3616 CFGBlock *CFGBuilder::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
3621 CFGBlock *CFGBuilder::VisitPseudoObjectExpr(PseudoObjectExpr *E) {
3627 CFGBlock *lastBlock = Block;
3639 if (CFGBlock *B = Visit(Semantic))
3646 CFGBlock *CFGBuilder::VisitWhileStmt(WhileStmt *W) {
3647 CFGBlock *LoopSuccessor = nullptr;
3673 CFGBlock *BodyBlock = nullptr, *TransitionBlock = nullptr;
3680 SaveAndRestore<CFGBlock*> save_Block(Block), save_Succ(Succ);
3713 CFGBlock *EntryConditionBlock = nullptr, *ExitConditionBlock = nullptr;
3781 CFGBlock *CFGBuilder::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
3787 CFGBlock *CFGBuilder::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
3806 CFGBlock *CFGBuilder::VisitObjCMessageExpr(ObjCMessageExpr *ME,
3816 CFGBlock *CFGBuilder::VisitCXXThrowExpr(CXXThrowExpr *T) {
3836 CFGBlock *CFGBuilder::VisitDoStmt(DoStmt *D) {
3837 CFGBlock *LoopSuccessor = nullptr;
3853 CFGBlock *ExitConditionBlock = createBlock(false);
3854 CFGBlock *EntryConditionBlock = ExitConditionBlock;
3877 CFGBlock *BodyBlock = nullptr;
3882 SaveAndRestore<CFGBlock*> save_Block(Block), save_Succ(Succ);
3917 CFGBlock *LoopBackBlock = createBlock();
3940 CFGBlock *CFGBuilder::VisitContinueStmt(ContinueStmt *C) {
3961 CFGBlock *CFGBuilder::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E,
3969 CFGBlock *lastBlock = Block;
3981 CFGBlock *CFGBuilder::VisitStmtExpr(StmtExpr *SE, AddStmtChoice asc) {
3989 CFGBlock *CFGBuilder::VisitSwitchStmt(SwitchStmt *Terminator) {
3992 CFGBlock *SwitchSuccessor = nullptr;
4016 SaveAndRestore<CFGBlock*> save_switch(SwitchTerminatedBlock),
4078 CFGBlock *LastBlock = addStmt(Terminator->getCond());
4136 CFGBlock *CFGBuilder::VisitCaseStmt(CaseStmt *CS) {
4139 CFGBlock *TopBlock = nullptr, *LastBlock = nullptr;
4146 CFGBlock *currentBlock = createBlock(false);
4167 CFGBlock *CaseBlock = Block;
4199 CFGBlock *CFGBuilder::VisitDefaultStmt(DefaultStmt *Terminator) {
4230 CFGBlock *CFGBuilder::VisitCXXTryStmt(CXXTryStmt *Terminator) {
4233 CFGBlock *TrySuccessor = nullptr;
4241 CFGBlock *PrevTryTerminatedBlock = TryTerminatedBlock;
4244 CFGBlock *NewTryTerminatedBlock = createBlock(false);
4257 CFGBlock *CatchBlock = VisitCXXCatchStmt(CS);
4275 SaveAndRestore<CFGBlock*> save_try(TryTerminatedBlock, NewTryTerminatedBlock);
4283 CFGBlock *CFGBuilder::VisitCXXCatchStmt(CXXCatchStmt *CS) {
4302 CFGBlock *CatchBlock = Block;
4326 CFGBlock *CFGBuilder::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
4356 CFGBlock *LoopSuccessor = nullptr;
4370 CFGBlock *ConditionBlock = createBlock(false);
4376 CFGBlock *BeginConditionBlock = addStmt(C);
4399 SaveAndRestore<CFGBlock*> save_Block(Block), save_Succ(Succ);
4427 CFGBlock *LoopVarStmtBlock = addStmt(S->getLoopVarStmt());
4444 CFGBlock *Head = addStmt(S->getRangeStmt());
4450 CFGBlock *CFGBuilder::VisitExprWithCleanups(ExprWithCleanups *E,
4465 CFGBlock *CFGBuilder::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E,
4481 CFGBlock *CFGBuilder::VisitCXXConstructExpr(CXXConstructExpr *C,
4494 CFGBlock *CFGBuilder::VisitCXXNewExpr(CXXNewExpr *NE,
4519 CFGBlock *CFGBuilder::VisitCXXDeleteExpr(CXXDeleteExpr *DE,
4536 CFGBlock *CFGBuilder::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E,
4547 CFGBlock *CFGBuilder::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *C,
4559 CFGBlock *CFGBuilder::VisitImplicitCastExpr(ImplicitCastExpr *E,
4572 CFGBlock *CFGBuilder::VisitConstantExpr(ConstantExpr *E, AddStmtChoice asc) {
4576 CFGBlock *CFGBuilder::VisitIndirectGotoStmt(IndirectGotoStmt *I) {
4578 CFGBlock *IBlock = cfg->getIndirectGotoBlock();
4596 CFGBlock *CFGBuilder::VisitForTemporaryDtors(Stmt *E, bool ExternallyDestructed,
4671 CFGBlock *B = Block;
4674 if (CFGBlock *R = VisitForTemporaryDtors(
4697 CFGBlock *CFGBuilder::VisitChildrenForTemporaryDtors(Stmt *E,
4709 CFGBlock *B = Block;
4712 if (CFGBlock *R = VisitForTemporaryDtors(Child, ExternallyDestructed, Context))
4718 CFGBlock *CFGBuilder::VisitBinaryOperatorForTemporaryDtors(
4723 CFGBlock *RHSBlock = VisitForTemporaryDtors(E->getRHS(), ExternallyDestructed, Context);
4724 CFGBlock *LHSBlock = VisitForTemporaryDtors(E->getLHS(), false, Context);
4748 CFGBlock *RHSBlock = VisitForTemporaryDtors(E->getRHS(), false, Context);
4749 CFGBlock *LHSBlock = VisitForTemporaryDtors(E->getLHS(), false, Context);
4756 CFGBlock *LHSBlock = VisitForTemporaryDtors(E->getLHS(), false, Context);
4757 CFGBlock *RHSBlock = VisitForTemporaryDtors(E->getRHS(), false, Context);
4761 CFGBlock *CFGBuilder::VisitCXXBindTemporaryExprForTemporaryDtors(
4765 CFGBlock *B = VisitForTemporaryDtors(E->getSubExpr(), true, Context);
4798 CFGBlock *FalseSucc) {
4804 CFGBlock *Decision = createBlock(false);
4813 CFGBlock *CFGBuilder::VisitConditionalOperatorForTemporaryDtors(
4817 CFGBlock *ConditionBlock = Block;
4818 CFGBlock *ConditionSucc = Succ;
4826 CFGBlock *TrueBlock = Block;
4845 CFGBlock *CFGBuilder::VisitOMPExecutableDirective(OMPExecutableDirective *D,
4853 CFGBlock *B = Block;
4861 if (CFGBlock *R = Visit(S))
4870 if (CFGBlock *R = addStmt(S))
4880 CFGBlock *CFG::createBlock() {
4884 CFGBlock *Mem = getAllocator().Allocate<CFGBlock>();
4884 CFGBlock *Mem = getAllocator().Allocate<CFGBlock>();
4885 new (Mem) CFGBlock(NumBlockIDs++, BlkBVC, this);
4912 llvm::SmallPtrSet<const CFGBlock *, 4> Visited;
4913 const CFGBlock *B = Entry;
4922 const CFGBlock *FirstReachableB = nullptr;
4923 for (const CFGBlock::AdjacentBlock &AB : B->succs()) {
5014 CFGBlock::AdjacentBlock::AdjacentBlock(CFGBlock *B, bool IsReachable)
5019 CFGBlock::AdjacentBlock::AdjacentBlock(CFGBlock *B, CFGBlock *AlternateBlock)
5019 CFGBlock::AdjacentBlock::AdjacentBlock(CFGBlock *B, CFGBlock *AlternateBlock)
5026 if (CFGBlock *B = Succ.getReachableBlock())
5029 if (CFGBlock *UnreachableB = Succ.getPossiblyUnreachableBlock())
5035 bool CFGBlock::FilterEdge(const CFGBlock::FilterOptions &F,
5036 const CFGBlock *From, const CFGBlock *To) {
5036 const CFGBlock *From, const CFGBlock *To) {
5079 for (CFGBlock::const_iterator BI = (*I)->begin(), BEnd = (*I)->end() ;
5559 const CFGBlock &B,
5625 for (CFGBlock::const_iterator I = B.begin(), E = B.end() ;
5671 for (CFGBlock::const_pred_iterator I = B.pred_begin(), E = B.pred_end();
5676 CFGBlock *B = *I;
5708 for (CFGBlock::const_succ_iterator I = B.succ_begin(), E = B.succ_end();
5713 CFGBlock *B = *I;
5812 static bool isImmediateSinkBlock(const CFGBlock *Blk) {
5836 const CFGBlock *StartBlk = this;
5840 llvm::SmallVector<const CFGBlock *, 32> DFSWorkList;
5841 llvm::SmallPtrSet<const CFGBlock *, 32> Visited;
5845 const CFGBlock *Blk = DFSWorkList.back();
5857 if (const CFGBlock *SuccBlk = Succ.getReachableBlock()) {
5983 static std::string getNodeLabel(const CFGBlock *Node, const CFG* Graph) {
tools/clang/lib/Analysis/CFGReachabilityAnalysis.cpp 26 bool CFGReverseBlockReachabilityAnalysis::isReachable(const CFGBlock *Src,
27 const CFGBlock *Dst) {
42 void CFGReverseBlockReachabilityAnalysis::mapReachability(const CFGBlock *Dst) {
43 SmallVector<const CFGBlock *, 11> worklist;
55 const CFGBlock *block = worklist.pop_back_val();
70 for (CFGBlock::const_pred_iterator i = block->pred_begin(),
tools/clang/lib/Analysis/CFGStmtMap.cpp 21 typedef llvm::DenseMap<const Stmt*, CFGBlock*> SMap;
26 CFGBlock *CFGStmtMap::getBlock(Stmt *S) {
35 CFGBlock *B = I->second;
48 static void Accumulate(SMap &SM, CFGBlock *B) {
50 for (CFGBlock::iterator I = B->begin(), E = B->end(); I != E; ++I) {
56 CFGBlock *&Entry = SM[CS->getStmt()];
tools/clang/lib/Analysis/Consumed.cpp 61 static SourceLocation getFirstStmtLoc(const CFGBlock *Block) {
76 static SourceLocation getLastStmtLoc(const CFGBlock *Block) {
82 for (CFGBlock::const_reverse_iterator BI = Block->rbegin(),
1003 bool ConsumedBlockInfo::allBackEdgesVisited(const CFGBlock *CurrBlock,
1004 const CFGBlock *TargetBlock) {
1009 for (CFGBlock::const_pred_iterator PI = TargetBlock->pred_begin(),
1018 const CFGBlock *Block, ConsumedStateMap *StateMap,
1032 void ConsumedBlockInfo::addInfo(const CFGBlock *Block,
1045 ConsumedStateMap* ConsumedBlockInfo::borrowInfo(const CFGBlock *Block) {
1052 void ConsumedBlockInfo::discardInfo(const CFGBlock *Block) {
1057 ConsumedBlockInfo::getInfo(const CFGBlock *Block) {
1065 bool ConsumedBlockInfo::isBackEdge(const CFGBlock *From, const CFGBlock *To) {
1065 bool ConsumedBlockInfo::isBackEdge(const CFGBlock *From, const CFGBlock *To) {
1072 bool ConsumedBlockInfo::isBackEdgeTarget(const CFGBlock *Block) {
1081 for (CFGBlock::const_pred_iterator PI = Block->pred_begin(),
1151 void ConsumedStateMap::intersectAtLoopHead(const CFGBlock *LoopHead,
1152 const CFGBlock *LoopBack, const ConsumedStateMap *LoopBackStates,
1228 bool ConsumedAnalyzer::splitState(const CFGBlock *CurrBlock,
1291 CFGBlock::const_succ_iterator SI = CurrBlock->succ_begin();
1328 for (const auto *CurrBlock : *SortedGraph) {
1386 for (CFGBlock::const_succ_iterator SI = CurrBlock->succ_begin(),
tools/clang/lib/Analysis/LiveVariables.cpp 33 llvm::PriorityQueue<const CFGBlock *, SmallVector<const CFGBlock *, 20>,
33 llvm::PriorityQueue<const CFGBlock *, SmallVector<const CFGBlock *, 20>,
42 void enqueueBlock(const CFGBlock *block);
43 void enqueuePredecessors(const CFGBlock *block);
45 const CFGBlock *dequeue();
50 void DataflowWorklist::enqueueBlock(const clang::CFGBlock *block) {
57 void DataflowWorklist::enqueuePredecessors(const clang::CFGBlock *block) {
58 for (CFGBlock::const_pred_iterator I = block->pred_begin(),
64 const CFGBlock *DataflowWorklist::dequeue() {
67 const CFGBlock *b = worklist.top();
80 llvm::DenseMap<const CFGBlock *, LiveVariables::LivenessValues> blocksEndToLiveness;
81 llvm::DenseMap<const CFGBlock *, LiveVariables::LivenessValues> blocksBeginToLiveness;
91 runOnBlock(const CFGBlock *block, LiveVariables::LivenessValues val,
183 bool LiveVariables::isLive(const CFGBlock *B, const VarDecl *D) {
204 const CFGBlock *currentBlock;
209 const CFGBlock *CurrentBlock)
497 LiveVariablesImpl::runOnBlock(const CFGBlock *block,
508 for (CFGBlock::const_reverse_iterator it = block->rbegin(),
563 const CFGBlock *block = *it;
571 for (CFGBlock::const_iterator bi = block->begin(), be = block->end();
587 while (const CFGBlock *block = worklist.dequeue()) {
594 for (CFGBlock::const_succ_iterator it = block->succ_begin(),
596 if (const CFGBlock *succ = *it) {
623 std::vector<const CFGBlock *> vec;
624 for (llvm::DenseMap<const CFGBlock *, LiveVariables::LivenessValues>::iterator
635 for (std::vector<const CFGBlock *>::iterator
tools/clang/lib/Analysis/PathDiagnostic.cpp 510 const CFGBlock &Block = *SFC->getCallSiteBlock();
653 const CFGBlock *BSrc = BE->getSrc();
tools/clang/lib/Analysis/PostOrderCFGView.cpp 41 bool PostOrderCFGView::BlockOrderCompare::operator()(const CFGBlock *b1,
42 const CFGBlock *b2) const {
tools/clang/lib/Analysis/ReachableCode.cpp 48 static bool isTrivialDoWhile(const CFGBlock *B, const Stmt *S) {
68 static bool isBuiltinAssumeFalse(const CFGBlock *B, const Stmt *S,
83 static bool isDeadReturn(const CFGBlock *B, const Stmt *S) {
87 const CFGBlock *Current = B;
89 for (CFGBlock::const_reverse_iterator I = Current->rbegin(),
293 static bool shouldTreatSuccessorsAsReachable(const CFGBlock *B,
308 static unsigned scanFromBlock(const CFGBlock *Start,
315 SmallVector<const CFGBlock*, 32> WL;
328 const CFGBlock *item = WL.pop_back_val();
340 for (CFGBlock::const_succ_iterator I = item->succ_begin(),
342 const CFGBlock *B = *I;
344 const CFGBlock *UB = I->getPossiblyUnreachableBlock();
374 static unsigned scanMaybeReachableFromBlock(const CFGBlock *Start,
388 SmallVector<const CFGBlock *, 10> WorkList;
392 typedef SmallVector<std::pair<const CFGBlock *, const Stmt *>, 12>
403 void enqueue(const CFGBlock *block);
404 unsigned scanBackwards(const CFGBlock *Start,
407 bool isDeadCodeRoot(const CFGBlock *Block);
409 const Stmt *findDeadCode(const CFGBlock *Block);
411 void reportDeadCode(const CFGBlock *B,
417 void DeadCodeScan::enqueue(const CFGBlock *block) {
425 bool DeadCodeScan::isDeadCodeRoot(const clang::CFGBlock *Block) {
428 for (CFGBlock::const_pred_iterator I = Block->pred_begin(),
430 if (const CFGBlock *PredBlock = *I) {
456 const Stmt *DeadCodeScan::findDeadCode(const clang::CFGBlock *Block) {
457 for (CFGBlock::const_iterator I = Block->begin(), E = Block->end(); I!=E; ++I)
474 static int SrcCmp(const std::pair<const CFGBlock *, const Stmt *> *p1,
475 const std::pair<const CFGBlock *, const Stmt *> *p2) {
483 unsigned DeadCodeScan::scanBackwards(const clang::CFGBlock *Start,
490 const CFGBlock *Block = WorkList.pop_back_val();
502 for (CFGBlock::const_pred_iterator I = Block->pred_begin(),
504 if (const CFGBlock *predBlock = *I)
534 const CFGBlock *Block = I->first;
610 void DeadCodeScan::reportDeadCode(const CFGBlock *B,
650 CFGBlock::const_pred_iterator PI = B->pred_begin();
652 if (const CFGBlock *PredBlock = PI->getPossiblyUnreachableBlock()) {
673 unsigned ScanReachableFromBlock(const CFGBlock *Start,
707 const CFGBlock *block = *I;
tools/clang/lib/Analysis/ThreadSafety.cpp 733 for (const auto *CurrBlock : *SortedGraph) {
742 for (CFGBlock::const_pred_iterator PI = CurrBlock->pred_begin(),
790 for (CFGBlock::const_succ_iterator SI = CurrBlock->succ_begin(),
796 CFGBlock *FirstLoopBlock = *SI;
813 for (const auto *CurrBlock : *SortedGraph) {
821 for (CFGBlock::const_reverse_iterator BI = CurrBlock->rbegin(),
1043 const CFGBlock *PredBlock, const CFGBlock *CurrBlock,
1043 const CFGBlock *PredBlock, const CFGBlock *CurrBlock,
1050 const CFGBlock* PredBlock,
1051 const CFGBlock *CurrBlock);
1383 const CFGBlock *PredBlock,
1384 const CFGBlock *CurrBlock,
1399 for (CFGBlock::const_succ_iterator SI = PredBlock->succ_begin(),
1496 const CFGBlock *PredBlock,
1497 const CFGBlock *CurrBlock) {
2234 static bool neverReturns(const CFGBlock *B) {
2308 const CFGBlock *FirstBlock = *SortedGraph->begin();
2363 for (const auto *CurrBlock : *SortedGraph) {
2384 SmallVector<CFGBlock *, 8> SpecialBlocks;
2385 for (CFGBlock::const_pred_iterator PI = CurrBlock->pred_begin(),
2431 for (const auto *PrevBlock : SpecialBlocks) {
2495 for (CFGBlock::const_succ_iterator SI = CurrBlock->succ_begin(),
2501 CFGBlock *FirstLoopBlock = *SI;
tools/clang/lib/Analysis/ThreadSafetyCommon.cpp 794 void SExprBuilder::mergePhiNodesBackEdge(const CFGBlock *Blk) {
811 const CFGBlock *First) {
820 for (auto *B : *Cfg) {
843 void SExprBuilder::enterCFGBlock(const CFGBlock *B) {
856 void SExprBuilder::handlePredecessor(const CFGBlock *Pred) {
871 void SExprBuilder::handlePredecessorBackEdge(const CFGBlock *Pred) {
875 void SExprBuilder::enterCFGBlockBody(const CFGBlock *B) {
898 void SExprBuilder::exitCFGBlockBody(const CFGBlock *B) {
925 void SExprBuilder::handleSuccessor(const CFGBlock *Succ) {
929 void SExprBuilder::handleSuccessorBackEdge(const CFGBlock *Succ) {
934 void SExprBuilder::exitCFGBlock(const CFGBlock *B) {
942 void SExprBuilder::exitCFG(const CFGBlock *Last) {
tools/clang/lib/Analysis/UninitializedValues.cpp 137 bool updateValueVectorWithScratch(const CFGBlock *block);
147 Value getValue(const CFGBlock *block, const CFGBlock *dstBlock,
147 Value getValue(const CFGBlock *block, const CFGBlock *dstBlock,
194 bool CFGBlockValues::updateValueVectorWithScratch(const CFGBlock *block) {
223 SmallVector<const CFGBlock *, 20> worklist;
238 void enqueueSuccessors(const CFGBlock *block);
239 const CFGBlock *dequeue();
244 void DataflowWorklist::enqueueSuccessors(const CFGBlock *block) {
245 for (CFGBlock::const_succ_iterator I = block->succ_begin(),
247 const CFGBlock *Successor = *I;
255 const CFGBlock *DataflowWorklist::dequeue() {
256 const CFGBlock *B = nullptr;
517 const CFGBlock *block;
525 const CFGBlock *block, AnalysisDeclContext &ac,
604 SmallVector<const CFGBlock*, 32> Queue;
612 const CFGBlock *B = Queue.pop_back_val();
618 for (CFGBlock::const_pred_iterator I = B->pred_begin(), E = B->pred_end();
620 const CFGBlock *Pred = *I;
643 for (CFGBlock::const_succ_iterator SI = Pred->succ_begin(),
659 for (const auto *Block : cfg) {
667 for (CFGBlock::const_succ_iterator I = Block->succ_begin(),
669 const CFGBlock *Succ = *I;
836 static bool runOnBlock(const CFGBlock *block, const CFG &cfg,
845 for (CFGBlock::const_pred_iterator I = block->pred_begin(),
847 const CFGBlock *pred = *I;
919 const CFGBlock &entry = cfg.getEntry();
934 while (const CFGBlock *block = worklist.dequeue()) {
950 for (const auto *block : cfg)
tools/clang/lib/Sema/AnalysisBasedWarnings.cpp 186 static bool hasRecursiveCallInPath(const FunctionDecl *FD, CFGBlock &Block) {
218 llvm::SmallPtrSet<CFGBlock *, 16> Visited;
219 llvm::SmallVector<CFGBlock *, 16> WorkList;
229 CFGBlock *Block = WorkList.pop_back_val();
232 if (CFGBlock *SuccBlock = *I) {
281 static bool throwEscapes(Sema &S, const CXXThrowExpr *E, CFGBlock &ThrowBlock,
283 SmallVector<CFGBlock *, 16> Stack;
290 CFGBlock &UnwindBlock = *Stack.back();
320 llvm::function_ref<void(const CXXThrowExpr *, CFGBlock &)> Visit) {
323 for (CFGBlock *B : *BodyCFG) {
412 for (const auto *B : *cfg) {
435 CFGBlock::FilterOptions FO;
438 for (CFGBlock::filtered_pred_iterator I =
441 const CFGBlock &B = **I;
456 CFGBlock::const_reverse_iterator ri = B.rbegin(), re = B.rend();
1056 std::deque<const CFGBlock *> BlockQueue;
1064 for (const auto *B : *Cfg) {
1071 const CFGBlock *P = BlockQueue.front();
1073 for (CFGBlock::const_succ_iterator I = P->succ_begin(),
1082 bool checkFallThroughIntoBlock(const CFGBlock &B, int &AnnotatedCnt,
1089 std::deque<const CFGBlock*> BlockQueue(B.pred_begin(), B.pred_end());
1091 const CFGBlock *P = BlockQueue.front();
1108 for (CFGBlock::const_reverse_iterator ElemIt = P->rbegin(),
1192 static const Stmt *getLastStmt(const CFGBlock &B) {
1195 for (CFGBlock::const_reverse_iterator ElemIt = B.rbegin(),
1214 llvm::SmallPtrSet<const CFGBlock *, 16> ReachableBlocks;
1270 for (const CFGBlock *B : llvm::reverse(*Cfg)) {
2109 const CFGBlock *block = AC.getBlockForRegisteredExpression(S);
tools/clang/lib/StaticAnalyzer/Checkers/AnalyzerStatsChecker.cpp 45 llvm::SmallPtrSet<const CFGBlock*, 32> reachable;
63 const CFGBlock *CB = BE->getBlock();
75 const CFGBlock *CB = *I;
123 const CFGBlock *Exit = BE.getDst();
tools/clang/lib/StaticAnalyzer/Checkers/DeadStoresChecker.cpp 76 bool isReachable(const CFGBlock *block) const {
86 SmallVector<const CFGBlock*, 10> worklist;
90 const CFGBlock *block = worklist.pop_back_val();
95 for (CFGBlock::const_succ_iterator i = block->succ_begin(),
97 if (const CFGBlock *succ = *i)
141 const CFGBlock *currentBlock;
317 void observeStmt(const Stmt *S, const CFGBlock *block,
tools/clang/lib/StaticAnalyzer/Checkers/MallocOverflowSecurityChecker.cpp 307 CFGBlock *block = *it;
308 for (CFGBlock::iterator bi = block->begin(), be = block->end();
tools/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountDiagnostics.cpp 428 const CFGBlock *Src = PP->getSrc();
tools/clang/lib/StaticAnalyzer/Checkers/UnreachableCodeChecker.cpp 39 static inline const Stmt *getUnreachableStmt(const CFGBlock *CB);
40 static void FindUnreachableEntryPoints(const CFGBlock *CB,
43 static bool isInvalidPath(const CFGBlock *CB, const ParentMap &PM);
44 static inline bool isEmptyCFGBlock(const CFGBlock *CB);
78 const CFGBlock *CB = BE->getBlock();
96 const CFGBlock *CB = *I;
130 for (CFGBlock::const_iterator ci = CB->begin(), ce = CB->end();
178 void UnreachableCodeChecker::FindUnreachableEntryPoints(const CFGBlock *CB,
183 for (CFGBlock::const_pred_iterator I = CB->pred_begin(), E = CB->pred_end();
200 const Stmt *UnreachableCodeChecker::getUnreachableStmt(const CFGBlock *CB) {
201 for (CFGBlock::const_iterator I = CB->begin(), E = CB->end(); I != E; ++I) {
218 bool UnreachableCodeChecker::isInvalidPath(const CFGBlock *CB,
230 const CFGBlock *pred = *CB->pred_begin();
250 bool UnreachableCodeChecker::isEmptyCFGBlock(const CFGBlock *CB) {
tools/clang/lib/StaticAnalyzer/Core/BugReporter.cpp 255 generateDiagForSwitchOP(const PathDiagnosticConstruct &C, const CFGBlock *Dst,
260 const CFGBlock *Src, const CFGBlock *DstC) const;
260 const CFGBlock *Src, const CFGBlock *DstC) const;
738 const PathDiagnosticConstruct &C, const CFGBlock *Dst,
807 const PathDiagnosticConstruct &C, const Stmt *T, const CFGBlock *Src,
808 const CFGBlock *Dst) const {
858 const CFGBlock *Src = BE.getSrc();
859 const CFGBlock *Dst = BE.getDst();
1012 const CFGBlock *Src = BE->getSrc();
1102 static const Stmt *getTerminatorCondition(const CFGBlock *B) {
1267 const CFGBlock *BSrc = BE->getSrc();
2317 CFGBlock &Exit = ProgP.getLocationContext()->getCFG()->getExit();
2932 if (const CFGBlock *ErrorB = errorNode->getCFGBlock())
tools/clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp 1716 llvm::SmallSet<const CFGBlock *, 32> VisitedBlocks;
1753 static bool isAssertlikeBlock(const CFGBlock *B, ASTContext &Context) {
1757 const CFGBlock *Then = B->succ_begin()->getReachableBlock();
1758 const CFGBlock *Else = (B->succ_begin() + 1)->getReachableBlock();
1793 CFGBlock *NB = const_cast<CFGBlock *>(N->getCFGBlock());
1799 CFGBlock *OriginB = const_cast<CFGBlock *>(Origin->getCFGBlock());
1882 const CFGBlock *srcBlk = BE->getSrc();
2162 const CFGBlock *SrcBlock = BE->getSrc();
2191 const Stmt *Term, const ExplodedNode *N, const CFGBlock *srcBlk,
2192 const CFGBlock *dstBlk, PathSensitiveBugReport &R,
tools/clang/lib/StaticAnalyzer/Core/CallEvent.cpp 210 const CFGBlock *B = Map->getBlock(E);
1407 const CFGBlock *B = CalleeCtx->getCallSiteBlock();
tools/clang/lib/StaticAnalyzer/Core/CoreEngine.cpp 85 const CFGBlock *Entry = &(L->getCFG()->getEntry());
97 const CFGBlock *Succ = *(Entry->succ_begin());
210 const CFGBlock *Blk = L.getDst();
296 void CoreEngine::HandleBlockExit(const CFGBlock * B, ExplodedNode *Pred) {
332 for (CFGBlock::const_succ_iterator it = B->succ_begin(),
334 if (const CFGBlock *succ = *it) {
425 const CFGBlock * B, ExplodedNode *Pred) {
436 const CFGBlock *B,
447 void CoreEngine::HandleStaticInit(const DeclStmt *DS, const CFGBlock *B,
458 void CoreEngine::HandlePostStmt(const CFGBlock *B, unsigned StmtIdx,
471 void CoreEngine::HandleVirtualBaseBranch(const CFGBlock *B,
514 const CFGBlock *Block, unsigned Idx) {
583 const CFGBlock *Block, unsigned Idx) {
686 CFGBlock *DefaultBlock = *Src->succ_rbegin();
tools/clang/lib/StaticAnalyzer/Core/ExplodedGraph.cpp 292 const CFGBlock *ExplodedNode::getCFGBlock() const {
tools/clang/lib/StaticAnalyzer/Core/ExprEngine.cpp 1133 const CFGBlock *DstT,
1134 const CFGBlock *DstF) {
2055 const CFGBlock *B) {
2074 CFGBlock::const_reverse_iterator I = B->rbegin(), E = B->rend();
2091 const CFGBlock *DstT,
2092 const CFGBlock *DstF) {
2189 const CFGBlock *DstT,
2190 const CFGBlock *DstF) {
tools/clang/lib/StaticAnalyzer/Core/ExprEngineC.cpp 697 const CFGBlock *SrcBlock = BE.getSrc();
791 const CFGBlock *SrcBlock = nullptr;
tools/clang/lib/StaticAnalyzer/Core/ExprEngineCallAndReturn.cpp 44 const CFGBlock *Entry = CE.getEntry();
51 const CFGBlock *Succ = *(Entry->succ_begin());
73 const CFGBlock*> getLastStmt(const ExplodedNode *Node) {
75 const CFGBlock *Blk = nullptr;
165 const CFGBlock *Blk = nullptr;
216 const CFGBlock *Blk = nullptr;
tools/clang/lib/StaticAnalyzer/Core/WorkList.cpp 257 using LocIdentifier = const CFGBlock *;
tools/clang/tools/extra/clang-tidy/bugprone/UseAfterMoveCheck.cpp 49 bool findInternal(const CFGBlock *Block, const Expr *MovingCall,
52 void getUsesAndReinits(const CFGBlock *Block, const ValueDecl *MovedVariable,
55 void getDeclRefs(const CFGBlock *Block, const Decl *MovedVariable,
57 void getReinits(const CFGBlock *Block, const ValueDecl *MovedVariable,
64 llvm::SmallPtrSet<const CFGBlock *, 8> Visited;
109 const CFGBlock *Block = BlockMap->blockContainingStmt(MovingCall);
116 bool UseAfterMoveFinder::findInternal(const CFGBlock *Block,
185 const CFGBlock *Block, const ValueDecl *MovedVariable,
229 const CFGBlock *Block, const Decl *MovedVariable,
268 const CFGBlock *Block, const ValueDecl *MovedVariable,
tools/clang/tools/extra/clang-tidy/utils/ExprSequence.cpp 188 for (const auto *B : *TheCFG) {
196 const CFGBlock *StmtToBlockMap::blockContainingStmt(const Stmt *S) const {
tools/clang/tools/extra/clang-tidy/utils/ExprSequence.h 112 const CFGBlock *blockContainingStmt(const Stmt *S) const;
117 llvm::DenseMap<const Stmt *, const CFGBlock *> Map;
tools/clang/unittests/Analysis/CFGDominatorTree.cpp 39 CFGBlock *ExitBlock = *cfg->begin();
42 CFGBlock *SwitchBlock = *(cfg->begin() + 1);
44 CFGBlock *CaseABlock = *(cfg->begin() + 2);
46 CFGBlock *EntryBlock = *(cfg->begin() + 3);
128 CFGBlock *ExitBlock = *cfg->begin();
131 CFGBlock *NullDerefBlock = *(cfg->begin() + 1);
133 CFGBlock *SecondThenBlock = *(cfg->begin() + 2);
135 CFGBlock *SecondIfBlock = *(cfg->begin() + 3);
137 CFGBlock *FirstIfBlock = *(cfg->begin() + 4);
139 CFGBlock *EntryBlock = *(cfg->begin() + 5);
tools/clang/unittests/Analysis/CFGTest.cpp 97 CFGBlock *MainBlock = *(Cfg->begin() + 1);
99 constexpr CFGBlock::ref_iterator::difference_type MainBlockSize = 4;
107 for (CFGBlock::CFGElementRef ElementRef : MainBlock->refs()) {
129 const CFGBlock *CMainBlock = MainBlock;
131 for (CFGBlock::ConstCFGElementRef ElementRef : CMainBlock->refs()) {
154 for (CFGBlock::CFGElementRef ElementRef : MainBlock->rrefs()) {
178 for (CFGBlock::ConstCFGElementRef ElementRef : CMainBlock->rrefs()) {
usr/include/c++/7.4.0/bits/move.h 72 constexpr _Tp&&
83 constexpr _Tp&&
usr/include/c++/7.4.0/type_traits 1554 { typedef _Tp type; };
1558 { typedef _Tp type; };
1633 { typedef _Tp type; };
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)) {