reference, declarationdefinition
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)) {