Lines Matching refs:Block
373 CFGBlock *Block;
416 Block(nullptr), Succ(nullptr),
569 return Block;
572 void autoCreateBlock() { if (!Block) Block = createBlock(); }
1032 Block = nullptr; // the EXIT block is empty. Create all other blocks lazily.
1118 return Block;
1137 appendInitializer(Block, I);
1151 appendStmt(Block, Default);
1154 Block = R;
1155 return Block;
1161 return Block;
1243 Block = createNoReturnBlock();
1247 appendAutomaticObjDtor(Block, *I, S);
1263 appendBaseDtor(Block, &VI);
1273 appendBaseDtor(Block, &BI);
1291 appendMemberDtor(Block, FI);
1560 return Block;
1581 return Block;
1610 appendStmt(Block, S);
1618 CFGBlock *B = Block;
1638 appendStmt(Block, A);
1641 return Block;
1648 appendStmt(Block, U);
1655 CFGBlock *ConfluenceBlock = Block ? Block : createBlock();
1704 Block = RHSBlock;
1733 Block = LHSBlock;
1764 appendStmt(Block, B);
1772 appendStmt(Block, B);
1780 appendStmt(Block, B);
1785 // If visiting RHS causes us to finish 'Block', e.g. the RHS is a StmtExpr
1794 appendStmt(Block, E);
1796 return Block;
1806 Block = createBlock(false);
1807 Block->setTerminator(B);
1813 addSuccessor(Block, BreakJumpTarget.block);
1818 return Block;
1880 appendStmt(Block, C);
1888 if (Block) {
1889 Succ = Block;
1895 Block = createNoReturnBlock();
1897 Block = createBlock();
1899 appendStmt(Block, C);
1904 addSuccessor(Block, TryTerminatedBlock);
1906 addSuccessor(Block, &cfg->getExit());
1914 CFGBlock *ConfluenceBlock = Block ? Block : createBlock();
1921 Block = nullptr;
1927 Block = nullptr;
1932 Block = createBlock(false);
1935 addSuccessor(Block, KnownVal.isFalse() ? nullptr : LHSBlock);
1936 addSuccessor(Block, KnownVal.isTrue() ? nullptr : RHSBlock);
1937 Block->setTerminator(C);
1953 CFGBlock *LastBlock = Block;
1976 CFGBlock *ConfluenceBlock = Block ? Block : createBlock();
1988 Block = nullptr;
1995 Block = nullptr;
2013 Block = createBlock(false);
2017 addSuccessor(Block, LHSBlock, !KnownVal.isFalse());
2018 addSuccessor(Block, RHSBlock, !KnownVal.isTrue());
2019 Block->setTerminator(C);
2040 return Block;
2080 return Block;
2091 if (Block) {
2092 Succ = Block;
2093 Block = nullptr;
2115 appendStmt(Block, DS);
2117 // Keep track of the last non-null block, as 'Block' can be nulled out
2120 CFGBlock *LastBlock = Block;
2150 Block = createBlock(false);
2151 Block->setTerminator(DS);
2152 addSuccessor(Block, blockAfterStaticInit);
2153 addSuccessor(Block, B);
2154 B = Block;
2189 if (Block) {
2190 Succ = Block;
2201 // NULL out Block so that the recursive call to Visit will
2203 Block = nullptr;
2214 else if (Block) {
2226 Block = nullptr;
2241 } else if (Block) {
2261 Block = createBlock(false);
2264 Block->setTerminator(I);
2271 addSuccessor(Block, ThenBlock, /* isReachable = */ !KnownVal.isFalse());
2272 addSuccessor(Block, ElseBlock, /* isReachable = */ !KnownVal.isTrue());
2276 // blocks will be pointed to be "Block".
2305 Block = createBlock(false);
2311 if (!Block->hasNoReturnElement())
2312 addSuccessor(Block, &cfg->getExit());
2322 CFGBlock *LabelBlock = Block;
2339 // We set Block to NULL to allow lazy creation of a new block (if necessary);
2340 Block = nullptr;
2377 Block = createBlock(false);
2378 Block->setTerminator(G);
2385 BackpatchBlocks.push_back(JumpSource(Block, ScopePos));
2389 addSuccessor(Block, JT.block);
2392 return Block;
2417 if (Block) {
2420 LoopSuccessor = Block;
2435 // Save the current values for Block, Succ, continue and break targets.
2436 SaveAndRestore<CFGBlock*> save_Block(Block), save_Succ(Succ);
2442 Block = Succ = TransitionBlock = createBlock(false);
2452 if (Block) {
2453 assert(Block == Succ);
2456 Block = nullptr;
2514 Block = ExitConditionBlock;
2522 appendStmt(Block, F->getConditionVariableDeclStmt());
2524 assert(Block == EntryConditionBlock);
2528 if (Block && badCFG)
2552 Block = createBlock();
2557 // NULL out Block to force lazy block construction.
2558 Block = nullptr;
2566 appendStmt(Block, M);
2606 if (Block) {
2609 LoopSuccessor = Block;
2610 Block = nullptr;
2624 Block = ExitConditionBlock;
2631 if (Block) {
2634 Block = nullptr;
2644 SaveAndRestore<CFGBlock*> save_Block(Block), save_Succ(Succ);
2662 else if (Block) {
2676 Block = createBlock();
2698 Block = nullptr;
2704 appendStmt(Block, S);
2719 appendStmt(Block, E);
2721 CFGBlock *lastBlock = Block;
2757 if (Block) {
2760 LoopSuccessor = Block;
2761 Block = nullptr;
2772 // Save the current values for Block, Succ, continue and break targets.
2773 SaveAndRestore<CFGBlock*> save_Block(Block), save_Succ(Succ);
2799 else if (Block && badCFG)
2827 Block = ExitConditionBlock;
2828 Block = EntryConditionBlock = addStmt(C);
2835 appendStmt(Block, W->getConditionVariableDeclStmt());
2837 assert(Block == EntryConditionBlock);
2841 if (Block && badCFG)
2860 // to this block. NULL out Block to force lazy creation of another block.
2861 Block = nullptr;
2872 return Block;
2884 Block = createBlock(false);
2887 addSuccessor(Block, &cfg->getExit());
2900 Block = createBlock(false);
2904 addSuccessor(Block, TryTerminatedBlock);
2907 addSuccessor(Block, &cfg->getExit());
2919 if (Block) {
2922 LoopSuccessor = Block;
2938 Block = ExitConditionBlock;
2940 if (Block) {
2957 // Save the current values for Block, Succ, and continue and break targets
2958 SaveAndRestore<CFGBlock*> save_Block(Block), save_Succ(Succ);
2968 // NULL out Block to force lazy instantiation of blocks for the body.
2969 Block = nullptr;
2981 else if (Block) {
2992 Block = nullptr;
3009 // the body. NULL out Block to force lazy creation of another block.
3010 Block = nullptr;
3024 Block = createBlock(false);
3025 Block->setTerminator(C);
3031 addSuccessor(Block, ContinueJumpTarget.block);
3035 return Block;
3043 appendStmt(Block, E);
3047 CFGBlock *lastBlock = Block;
3062 appendStmt(Block, SE);
3091 if (Block) {
3094 SwitchSuccessor = Block;
3119 Block = nullptr;
3139 if (Block) {
3159 Block = SwitchTerminatedBlock;
3167 appendStmt(Block, Terminator->getConditionVariableDeclStmt());
3248 CFGBlock *CaseBlock = Block;
3266 // We set Block to NULL to allow lazy creation of a new block (if necessary)
3267 Block = nullptr;
3284 DefaultCaseBlock = Block;
3302 // We set Block to NULL to allow lazy creation of a new block (if necessary)
3303 Block = nullptr;
3316 if (Block) {
3319 TrySuccessor = Block;
3337 Block = nullptr;
3360 Block = nullptr;
3383 CFGBlock *CatchBlock = Block;
3401 // We set Block to NULL to allow lazy creation of a new block (if necessary)
3402 Block = nullptr;
3438 if (Block) {
3441 LoopSuccessor = Block;
3456 Block = ConditionBlock;
3479 // Save the current values for Block, Succ, and continue targets.
3480 SaveAndRestore<CFGBlock*> save_Block(Block), save_Succ(Succ);
3485 Block = nullptr;
3496 assert(Block);
3499 Block = nullptr;
3522 Block = createBlock();
3547 appendStmt(Block, E);
3558 appendStmt(Block, C);
3567 appendStmt(Block, NE);
3570 Block = Visit(NE->getInitializer());
3572 appendNewAllocator(Block, NE);
3574 Block = Visit(NE->getArraySize());
3577 Block = Visit(*I);
3578 return Block;
3584 appendStmt(Block, DE);
3590 appendDeleteDtor(Block, RD, DE);
3600 appendStmt(Block, E);
3610 appendStmt(Block, C);
3618 appendStmt(Block, E);
3637 Block = createBlock(false);
3638 Block->setTerminator(I);
3639 addSuccessor(Block, IBlock);
3704 return Block;
3710 CFGBlock *B = Block;
3733 return Block;
3740 CFGBlock *B = Block;
3765 return Block;
3800 Block = createNoReturnBlock();
3805 Block = createBlock();
3812 appendTemporaryDtor(Block, E);
3814 B = Block;
3828 addSuccessor(Decision, Block, !Context.KnownExecuted.isFalse());
3831 Block = Decision;
3838 CFGBlock *ConditionBlock = Block;
3847 CFGBlock *TrueBlock = Block;
3849 Block = ConditionBlock;
3858 Block = TrueBlock;
3863 return Block;