reference, declaration → definition definition → references, declarations, derived classes, virtual overrides reference to multiple definitions → definitions unreferenced |
75 class BasicBlock;
108 const ArrayRef<U *> &A, 110 std::is_convertible<U *const *, T const *>::value>::type * = nullptr)include/llvm/Support/Casting.h
58 return To::classof(&Val); 106 return isa_impl<To, From>::doit(*Val); 122 return isa_impl_wrap<To, SimpleFrom, 132 return isa_impl_cl<To,FromTy>::doit(Val); 142 return isa_impl_wrap<X, const Y, 172 using ret_type = To *; // Pointer arg case, return Ty* 176 using ret_type = const To *; // Constant pointer arg case, return const Ty* 198 using ret_type = typename cast_retty<To, SimpleFrom>::ret_type; 204 using ret_type = typename cast_retty_impl<To,FromTy>::ret_type; 210 To, From, typename simplify_type<From>::SimpleType>::ret_type; 227 static typename cast_retty<To, FromTy>::ret_type doit(const FromTy &Val) { 228 typename cast_retty<To, FromTy>::ret_type Res2 256 inline typename cast_retty<X, Y>::ret_type cast(Y &Val) { 263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) { 265 return cast_convert_val<X, Y*,tools/clang/include/clang/Analysis/Analyses/ThreadSafetyCommon.h
384 til::BasicBlock *lookupBlock(const CFGBlock *B) { 501 std::vector<til::BasicBlock *> BlockMap; 510 til::BasicBlock *CurrentBB = nullptr;tools/clang/include/clang/Analysis/Analyses/ThreadSafetyTIL.h
315 BasicBlock *block() const { return Block; } 318 void setID(BasicBlock *B, unsigned id) { Block = B; SExprID = id; } 328 BasicBlock *Block = nullptr; 1355 ArrayRef<BasicBlock *> successors(); 1357 ArrayRef<BasicBlock *> successors() const { 1369 Goto(BasicBlock *B, unsigned I) 1371 Goto(const Goto &G, BasicBlock *B, unsigned I) 1376 const BasicBlock *targetBlock() const { return TargetBlock; } 1377 BasicBlock *targetBlock() { return TargetBlock; } 1383 ArrayRef<BasicBlock *> successors() { return TargetBlock; } 1387 BasicBlock *Ntb = Vs.reduceBasicBlockRef(TargetBlock); 1398 BasicBlock *TargetBlock; 1407 Branch(SExpr *C, BasicBlock *T, BasicBlock *E) 1407 Branch(SExpr *C, BasicBlock *T, BasicBlock *E) 1413 Branch(const Branch &Br, SExpr *C, BasicBlock *T, BasicBlock *E) 1413 Branch(const Branch &Br, SExpr *C, BasicBlock *T, BasicBlock *E) 1424 const BasicBlock *thenBlock() const { return Branches[0]; } 1425 BasicBlock *thenBlock() { return Branches[0]; } 1427 const BasicBlock *elseBlock() const { return Branches[1]; } 1428 BasicBlock *elseBlock() { return Branches[1]; } 1431 ArrayRef<BasicBlock*> successors() { 1438 BasicBlock *Ntb = Vs.reduceBasicBlockRef(Branches[0]); 1439 BasicBlock *Nte = Vs.reduceBasicBlockRef(Branches[1]); 1451 BasicBlock *Branches[2]; 1464 ArrayRef<BasicBlock *> successors() { return None; } 1484 inline ArrayRef<BasicBlock*> Terminator::successors() { 1502 using BlockArray = SimpleArray<BasicBlock *>; 1515 BasicBlock *Parent = nullptr; 1532 BasicBlock(BasicBlock &B, MemRegionRef A, InstrArray &&As, InstrArray &&Is, 1549 const BasicBlock *parent() const { return DominatorNode.Parent; } 1550 BasicBlock *parent() { return DominatorNode.Parent; } 1564 ArrayRef<BasicBlock*> successors() { return TermInstr->successors(); } 1565 ArrayRef<BasicBlock*> successors() const { return TermInstr->successors(); } 1572 bool Dominates(const BasicBlock &Other) { 1576 bool PostDominates(const BasicBlock &Other) { 1594 unsigned addPredecessor(BasicBlock *Pred); 1606 unsigned findPredecessorIndex(const BasicBlock *BB) const { 1636 typename C::CType compare(const BasicBlock *E, C &Cmp) const { 1647 unsigned topologicalSort(SimpleArray<BasicBlock *> &Blocks, unsigned ID); 1648 unsigned topologicalFinalSort(SimpleArray<BasicBlock *> &Blocks, unsigned ID); 1688 using BlockArray = SimpleArray<BasicBlock *>; 1694 Entry = new (A) BasicBlock(A); 1695 Exit = new (A) BasicBlock(A); 1727 const BasicBlock *entry() const { return Entry; } 1728 BasicBlock *entry() { return Entry; } 1729 const BasicBlock *exit() const { return Exit; } 1730 BasicBlock *exit() { return Exit; } 1741 inline void add(BasicBlock *BB) { 1748 void setEntry(BasicBlock *BB) { Entry = BB; } 1749 void setExit(BasicBlock *BB) { Exit = BB; } 1758 for (const auto *B : Blocks) { 1777 BasicBlock *Entry = nullptr; 1778 BasicBlock *Exit = nullptr;tools/clang/include/clang/Analysis/Analyses/ThreadSafetyTraverse.h
143 using R_BasicBlock = BasicBlock *; 246 R_SExpr reduceSCFG(SCFG &Orig, Container<BasicBlock *> Bbs) { 250 R_BasicBlock reduceBasicBlock(BasicBlock &Orig, Container<R_SExpr> &As, 259 R_SExpr reduceGoto(Goto &Orig, BasicBlock *B) { 263 R_SExpr reduceBranch(Branch &O, R_SExpr C, BasicBlock *B0, BasicBlock *B1) { 263 R_SExpr reduceBranch(Branch &O, R_SExpr C, BasicBlock *B0, BasicBlock *B1) { 287 void enterBasicBlock(BasicBlock &BB) {} 288 void exitBasicBlock(BasicBlock &BB) {} 291 BasicBlock *reduceBasicBlockRef(BasicBlock *Obb) { return Obb; } 291 BasicBlock *reduceBasicBlockRef(BasicBlock *Obb) { return Obb; } 485 void printBlockLabel(StreamType & SS, const BasicBlock *BB, int index) { 817 for (const auto *BBI : *E) 839 void printBasicBlock(const BasicBlock *E, StreamType &SS) {tools/clang/lib/Analysis/ThreadSafetyCommon.cpp
795 til::BasicBlock *BB = lookupBlock(Blk); 821 auto *BB = new (Arena) til::BasicBlock(Arena); 821 auto *BB = new (Arena) til::BasicBlock(Arena); 908 til::BasicBlock *BB = *It ? lookupBlock(*It) : nullptr; 916 til::BasicBlock *BB1 = *It ? lookupBlock(*It) : nullptr; 918 til::BasicBlock *BB2 = *It ? lookupBlock(*It) : nullptr;tools/clang/lib/Analysis/ThreadSafetyTIL.cpp
58 unsigned BasicBlock::addPredecessor(BasicBlock *Pred) { 165 unsigned BasicBlock::topologicalSort(SimpleArray<BasicBlock *> &Blocks, 169 for (auto *Block : successors()) 189 unsigned BasicBlock::topologicalFinalSort(SimpleArray<BasicBlock *> &Blocks, 197 for (auto *Pred : Predecessors) 209 BasicBlock *Candidate = nullptr; 211 for (auto *Pred : Predecessors) { 220 auto *Alternate = Pred; 236 BasicBlock *Candidate = nullptr; 238 for (auto *Succ : successors()) { 247 auto *Alternate = Succ; 262 for (auto *Block : Blocks) 266 static inline void computeNodeSize(BasicBlock *B, 268 BasicBlock::TopologyNode *N = &(B->*TN); 270 BasicBlock::TopologyNode *P = &(N->Parent->*TN); 277 static inline void computeNodeID(BasicBlock *B, 279 BasicBlock::TopologyNode *N = &(B->*TN); 281 BasicBlock::TopologyNode *P = &(N->Parent->*TN); 305 for (auto *Block : Blocks) 318 for (auto *Block : Blocks.reverse()) { 320 computeNodeSize(Block, &BasicBlock::DominatorNode); 324 for (auto *Block : Blocks) { 325 computeNodeID(Block, &BasicBlock::DominatorNode); 326 computeNodeSize(Block, &BasicBlock::PostDominatorNode); 329 for (auto *Block : Blocks.reverse()) { 330 computeNodeID(Block, &BasicBlock::PostDominatorNode);