Lines Matching refs:Block
474 CFGBlock *Block = nullptr;
476 // Block after the current block.
701 return Block;
741 void autoCreateBlock() { if (!Block) Block = createBlock(); }
1488 Block = nullptr; // the EXIT block is empty. Create all other blocks lazily.
1524 Block = createBlock();
1536 addSuccessor(B, Block, true);
1629 return Block;
1648 appendInitializer(Block, I);
1666 appendStmt(Block, Default);
1669 Block = R;
1670 return Block;
1676 return Block;
1724 appendLoopExit(Block, LoopStmt);
1797 appendLifetimeEnds(Block, *I, S);
1803 appendLifetimeEnds(Block, *I, S);
1818 appendScopeEnd(Block, *I, S);
1848 // ScopeEnd marker in a Block.
1851 appendScopeEnd(Block, *I, S);
1865 Block = createNoReturnBlock();
1871 appendScopeEnd(Block, *I, S);
1872 appendAutomaticObjDtor(Block, *I, S);
1891 appendBaseDtor(Block, &VI);
1901 appendBaseDtor(Block, &BI);
1919 appendMemberDtor(Block, FI);
2139 return Block;
2272 return Block;
2296 return Block;
2338 appendStmt(Block, S);
2346 CFGBlock *B = Block;
2362 appendStmt(Block, ILE);
2364 CFGBlock *B = Block;
2388 appendStmt(Block, A);
2391 return Block;
2398 appendStmt(Block, U);
2408 CFGBlock *ConfluenceBlock = Block ? Block : createBlock();
2460 Block = RHSBlock;
2489 Block = LHSBlock;
2519 appendStmt(Block, B);
2527 appendStmt(Block, B);
2535 appendStmt(Block, B);
2543 // If visiting RHS causes us to finish 'Block', e.g. the RHS is a StmtExpr
2552 appendStmt(Block, E);
2554 return Block;
2564 Block = createBlock(false);
2565 Block->setTerminator(B);
2571 addSuccessor(Block, BreakJumpTarget.block);
2575 return Block;
2643 appendStmt(Block, C);
2649 appendCall(Block, C);
2654 if (Block) {
2655 Succ = Block;
2661 Block = createNoReturnBlock();
2663 Block = createBlock();
2665 appendCall(Block, C);
2670 addSuccessor(Block, TryTerminatedBlock);
2672 addSuccessor(Block, &cfg->getExit());
2680 CFGBlock *ConfluenceBlock = Block ? Block : createBlock();
2687 Block = nullptr;
2693 Block = nullptr;
2698 Block = createBlock(false);
2701 addSuccessor(Block, KnownVal.isFalse() ? nullptr : LHSBlock);
2702 addSuccessor(Block, KnownVal.isTrue() ? nullptr : RHSBlock);
2703 Block->setTerminator(C);
2717 CFGBlock *LastBlock = Block;
2745 CFGBlock *ConfluenceBlock = Block ? Block : createBlock();
2757 Block = nullptr;
2764 Block = nullptr;
2782 Block = createBlock(false);
2786 addSuccessor(Block, LHSBlock, !KnownVal.isFalse());
2787 addSuccessor(Block, RHSBlock, !KnownVal.isTrue());
2788 Block->setTerminator(C);
2809 return Block;
2845 return Block;
2848 appendStmt(Block, DS);
2850 CFGBlock *LastBlock = Block;
2864 return Block;
2875 if (Block) {
2876 Succ = Block;
2877 Block = nullptr;
2899 appendStmt(Block, DS);
2905 // Keep track of the last non-null block, as 'Block' can be nulled out
2908 CFGBlock *LastBlock = Block;
2933 maybeAddScopeBeginForVarDecl(Block, VD, DS);
2942 Block = createBlock(false);
2943 Block->setTerminator(DS);
2944 addSuccessor(Block, blockAfterStaticInit);
2945 addSuccessor(Block, B);
2946 B = Block;
2977 if (Block) {
2978 Succ = Block;
2989 // NULL out Block so that the recursive call to Visit will
2991 Block = nullptr;
3002 else if (Block) {
3014 Block = nullptr;
3029 } else if (Block) {
3051 Block = createBlock(false);
3054 Block->setTerminator(I);
3061 addSuccessor(Block, ThenBlock, /* IsReachable = */ !KnownVal.isFalse());
3062 addSuccessor(Block, ElseBlock, /* IsReachable = */ !KnownVal.isTrue());
3066 // created blocks will be pointed to be "Block".
3096 Block = createBlock(false);
3107 if (!Block->hasNoReturnElement())
3108 addSuccessor(Block, &cfg->getExit());
3111 appendStmt(Block, S);
3117 return Block;
3132 CFGBlock *SEHExceptBlock = Block;
3145 // We set Block to NULL to allow lazy creation of a new block (if necessary).
3146 Block = nullptr;
3162 Block = createBlock(false);
3163 Block->setTerminator(LS);
3169 addSuccessor(Block, SEHLeaveJumpTarget.block);
3173 return Block;
3181 if (Block) {
3184 SEHTrySuccessor = Block;
3202 Block = nullptr;
3230 Block = nullptr;
3237 CFGBlock *LabelBlock = Block;
3254 // We set Block to NULL to allow lazy creation of a new block (if necessary);
3255 Block = nullptr;
3292 Block = createBlock(false);
3293 Block->setTerminator(G);
3300 BackpatchBlocks.push_back(JumpSource(Block, ScopePos));
3304 addSuccessor(Block, JT.block);
3307 return Block;
3317 if (Block) {
3318 Succ = Block;
3322 Block = createBlock();
3323 Block->setTerminator(G);
3325 BackpatchBlocks.push_back(JumpSource(Block, ScopePos));
3329 return Block;
3356 if (Block) {
3359 LoopSuccessor = Block;
3374 // Save the current values for Block, Succ, continue and break targets.
3375 SaveAndRestore<CFGBlock*> save_Block(Block), save_Succ(Succ);
3381 Block = Succ = TransitionBlock = createBlock(false);
3391 if (Block) {
3392 assert(Block == Succ);
3395 Block = nullptr;
3454 Block = ExitConditionBlock;
3467 appendStmt(Block, DS);
3469 assert(Block == EntryConditionBlock);
3474 if (Block && badCFG)
3499 Block = createBlock();
3504 // NULL out Block to force lazy block construction.
3505 Block = nullptr;
3523 appendStmt(Block, M);
3562 if (Block) {
3565 LoopSuccessor = Block;
3566 Block = nullptr;
3580 Block = ExitConditionBlock;
3587 if (Block) {
3590 Block = nullptr;
3600 SaveAndRestore<CFGBlock*> save_Block(Block), save_Succ(Succ);
3618 else if (Block) {
3632 Block = createBlock();
3654 Block = nullptr;
3660 appendStmt(Block, S);
3675 appendStmt(Block, E);
3677 CFGBlock *lastBlock = Block;
3714 if (Block) {
3717 LoopSuccessor = Block;
3718 Block = nullptr;
3729 // Save the current values for Block, Succ, continue and break targets.
3730 SaveAndRestore<CFGBlock*> save_Block(Block), save_Succ(Succ);
3756 else if (Block && badCFG)
3784 Block = ExitConditionBlock;
3785 Block = EntryConditionBlock = addStmt(C);
3798 appendStmt(Block, DS);
3800 assert(Block == EntryConditionBlock);
3805 if (Block && badCFG)
3823 // to this block. NULL out Block to force lazy creation of another block.
3824 Block = nullptr;
3834 return Block;
3846 Block = createBlock(false);
3849 addSuccessor(Block, &cfg->getExit());
3861 appendObjCMessage(Block, ME);
3872 Block = createBlock(false);
3876 addSuccessor(Block, TryTerminatedBlock);
3879 addSuccessor(Block, &cfg->getExit());
3893 if (Block) {
3896 LoopSuccessor = Block;
3912 Block = ExitConditionBlock;
3914 if (Block) {
3931 // Save the current values for Block, Succ, and continue and break targets
3932 SaveAndRestore<CFGBlock*> save_Block(Block), save_Succ(Succ);
3942 // NULL out Block to force lazy instantiation of blocks for the body.
3943 Block = nullptr;
3955 else if (Block) {
3965 Block = nullptr;
3982 // the body. NULL out Block to force lazy creation of another block.
3983 Block = nullptr;
3997 Block = createBlock(false);
3998 Block->setTerminator(C);
4004 addSuccessor(Block, ContinueJumpTarget.block);
4008 return Block;
4015 appendStmt(Block, E);
4022 return Block;
4024 CFGBlock *lastBlock = Block;
4039 appendStmt(Block, SE);
4064 if (Block) {
4067 SwitchSuccessor = Block;
4092 Block = nullptr;
4112 if (Block) {
4132 Block = SwitchTerminatedBlock;
4140 appendStmt(Block, Terminator->getConditionVariableDeclStmt());
4222 CFGBlock *CaseBlock = Block;
4240 // We set Block to NULL to allow lazy creation of a new block (if necessary)
4241 Block = nullptr;
4258 DefaultCaseBlock = Block;
4276 // We set Block to NULL to allow lazy creation of a new block (if necessary)
4277 Block = nullptr;
4290 if (Block) {
4293 TrySuccessor = Block;
4311 Block = nullptr;
4334 Block = nullptr;
4357 CFGBlock *CatchBlock = Block;
4375 // We set Block to NULL to allow lazy creation of a new block (if necessary)
4376 Block = nullptr;
4412 if (Block) {
4415 LoopSuccessor = Block;
4430 Block = ConditionBlock;
4453 // Save the current values for Block, Succ, and continue targets.
4454 SaveAndRestore<CFGBlock*> save_Block(Block), save_Succ(Succ);
4459 Block = nullptr;
4470 assert(Block);
4473 Block = nullptr;
4496 Block = createBlock();
4524 appendStmt(Block, E);
4544 appendConstructor(Block, C);
4552 appendStmt(Block, NE);
4559 Block = Visit(NE->getInitializer());
4562 appendNewAllocator(Block, NE);
4565 Block = Visit(*NE->getArraySize());
4569 Block = Visit(*I);
4571 return Block;
4577 appendStmt(Block, DE);
4584 appendDeleteDtor(Block, RD, DE);
4595 appendStmt(Block, E);
4610 appendConstructor(Block, C);
4618 appendStmt(Block, E);
4645 Block = createBlock(false);
4646 Block->setTerminator(I);
4647 addSuccessor(Block, IBlock);
4720 return Block;
4726 CFGBlock *B = Block;
4740 return Block;
4757 return Block;
4764 CFGBlock *B = Block;
4797 return Block;
4833 Block = createNoReturnBlock();
4838 Block = createBlock();
4845 appendTemporaryDtor(Block, E);
4847 B = Block;
4862 addSuccessor(Decision, Block, !Context.KnownExecuted.isFalse());
4865 Block = Decision;
4872 CFGBlock *ConditionBlock = Block;
4881 CFGBlock *TrueBlock = Block;
4883 Block = ConditionBlock;
4892 Block = TrueBlock;
4897 return Block;
4904 appendStmt(Block, D);
4908 CFGBlock *B = Block;