Lines Matching refs:Block
493 CFGBlock *Block = nullptr;
495 // Block after the current block.
722 return Block;
762 void autoCreateBlock() { if (!Block) Block = createBlock(); }
825 Block = createNoReturnBlock();
831 Block->appendConstructor(CE, CC, cfg->getBumpVectorContext());
836 Block->appendStmt(CE, cfg->getBumpVectorContext());
1586 Block = nullptr; // the EXIT block is empty. Create all other blocks lazily.
1619 Block = createBlock();
1631 addSuccessor(B, Block, true);
1719 return Block;
1738 appendInitializer(Block, I);
1761 appendStmt(Block, Default);
1764 Block = R;
1765 return Block;
1771 return Block;
1816 appendLoopExit(Block, LoopStmt);
1893 Block = createNoReturnBlock();
1902 appendLifetimeEnds(Block, VD, S);
1904 appendAutomaticObjDtor(Block, VD, S);
1906 appendCleanupFunction(Block, VD);
1923 appendScopeEnd(Block, B.getFirstVarInScope(), S);
1945 appendLifetimeEnds(Block, VD, S);
1956 assert(Block && "Source block should be always crated");
1973 appendScopeBegin(Block, *I, S);
1998 SaveAndRestore save_Block(Block), save_Succ(Succ);
2001 Block = createBlock(false);
2002 Block->setTerminator(SrcBlk->getTerminator());
2004 addSuccessor(Block, DstBlk);
2006 // Fill the created Block with the required elements.
2007 addScopeChangesHandling(SrcPos, DstPos, Block->getTerminatorStmt());
2009 assert(Block && "There should be at least one scope changing Block");
2010 return Block;
2028 appendBaseDtor(Block, &VI);
2038 appendBaseDtor(Block, &BI);
2057 appendMemberDtor(Block, FI);
2211 return Block;
2349 return Block;
2373 return Block;
2422 appendStmt(Block, S);
2430 CFGBlock *B = Block;
2446 appendStmt(Block, ILE);
2448 CFGBlock *B = Block;
2472 appendStmt(Block, A);
2475 return Block;
2497 appendStmt(Block, A);
2506 appendStmt(Block, U);
2516 CFGBlock *ConfluenceBlock = Block ? Block : createBlock();
2568 Block = RHSBlock;
2597 Block = LHSBlock;
2627 appendStmt(Block, B);
2635 appendStmt(Block, B);
2643 appendStmt(Block, B);
2651 // If visiting RHS causes us to finish 'Block', e.g. the RHS is a StmtExpr
2660 appendStmt(Block, E);
2662 return Block;
2672 Block = createBlock(false);
2673 Block->setTerminator(B);
2679 addSuccessor(Block, BreakJumpTarget.block);
2683 return Block;
2751 appendStmt(Block, C);
2757 appendCall(Block, C);
2762 if (Block) {
2763 Succ = Block;
2769 Block = createNoReturnBlock();
2771 Block = createBlock();
2773 appendCall(Block, C);
2778 addSuccessor(Block, TryTerminatedBlock);
2780 addSuccessor(Block, &cfg->getExit());
2788 CFGBlock *ConfluenceBlock = Block ? Block : createBlock();
2795 Block = nullptr;
2801 Block = nullptr;
2806 Block = createBlock(false);
2809 addSuccessor(Block, KnownVal.isFalse() ? nullptr : LHSBlock);
2810 addSuccessor(Block, KnownVal.isTrue() ? nullptr : RHSBlock);
2811 Block->setTerminator(C);
2826 CFGBlock *LastBlock = Block;
2853 CFGBlock *ConfluenceBlock = Block ? Block : createBlock();
2865 Block = nullptr;
2872 Block = nullptr;
2890 Block = createBlock(false);
2894 addSuccessor(Block, LHSBlock, !KnownVal.isFalse());
2895 addSuccessor(Block, RHSBlock, !KnownVal.isTrue());
2896 Block->setTerminator(C);
2917 return Block;
2953 return Block;
2956 appendStmt(Block, DS);
2958 CFGBlock *LastBlock = Block;
2972 return Block;
2983 if (Block) {
2984 Succ = Block;
2985 Block = nullptr;
3015 Block = VisitDeclSubExpr(DSNew);
3021 appendStmt(Block, DS);
3031 // Keep track of the last non-null block, as 'Block' can be nulled out
3034 CFGBlock *LastBlock = Block;
3059 maybeAddScopeBeginForVarDecl(Block, VD, DS);
3068 Block = createBlock(false);
3069 Block->setTerminator(DS);
3070 addSuccessor(Block, blockAfterStaticInit);
3071 addSuccessor(Block, B);
3072 B = Block;
3103 if (Block) {
3104 Succ = Block;
3115 // NULL out Block so that the recursive call to Visit will
3117 Block = nullptr;
3128 else if (Block) {
3140 Block = nullptr;
3155 } else if (Block) {
3177 Block = createBlock(false);
3180 Block->setTerminator(I);
3189 addSuccessor(Block, ThenBlock, /* IsReachable = */ !KnownVal.isFalse());
3190 addSuccessor(Block, ElseBlock, /* IsReachable = */ !KnownVal.isTrue());
3193 return Block;
3197 // created blocks will be pointed to be "Block".
3227 Block = createBlock(false);
3238 if (!Block->hasNoReturnElement())
3239 addSuccessor(Block, &cfg->getExit());
3242 appendStmt(Block, S);
3248 return Block;
3252 auto *B = Block;
3272 appendStmt(Block, E);
3274 CFGBlock *B = Block;
3295 CFGBlock *SEHExceptBlock = Block;
3308 // We set Block to NULL to allow lazy creation of a new block (if necessary).
3309 Block = nullptr;
3325 Block = createBlock(false);
3326 Block->setTerminator(LS);
3332 addSuccessor(Block, SEHLeaveJumpTarget.block);
3336 return Block;
3344 if (Block) {
3347 SEHTrySuccessor = Block;
3365 Block = nullptr;
3392 Block = nullptr;
3399 CFGBlock *LabelBlock = Block;
3415 // We set Block to NULL to allow lazy creation of a new block (if necessary).
3416 Block = nullptr;
3465 Block = createBlock(false);
3466 Block->setTerminator(G);
3473 BackpatchBlocks.push_back(JumpSource(Block, ScopePos));
3476 addSuccessor(Block, JT.block);
3480 return Block;
3490 if (Block) {
3491 Succ = Block;
3495 Block = createBlock();
3496 Block->setTerminator(G);
3498 BackpatchBlocks.push_back(JumpSource(Block, ScopePos));
3529 if (Block) {
3532 LoopSuccessor = Block;
3547 // Save the current values for Block, Succ, continue and break targets.
3548 SaveAndRestore save_Block(Block), save_Succ(Succ);
3554 Block = Succ = TransitionBlock = createBlock(false);
3569 if (Block) {
3570 assert(Block == Succ);
3573 Block = nullptr;
3630 Block = ExitConditionBlock;
3643 appendStmt(Block, DS);
3645 assert(Block == EntryConditionBlock);
3650 if (Block && badCFG)
3675 Block = createBlock();
3680 // NULL out Block to force lazy block construction.
3681 Block = nullptr;
3699 appendStmt(Block, M);
3738 if (Block) {
3741 LoopSuccessor = Block;
3742 Block = nullptr;
3756 Block = ExitConditionBlock;
3763 if (Block) {
3766 Block = nullptr;
3776 SaveAndRestore save_Block(Block), save_Succ(Succ);
3794 else if (Block) {
3808 Block = createBlock();
3830 Block = nullptr;
3836 appendStmt(Block, S);
3846 appendStmt(Block, E);
3848 CFGBlock *lastBlock = Block;
3885 if (Block) {
3888 LoopSuccessor = Block;
3889 Block = nullptr;
3900 // Save the current values for Block, Succ, continue and break targets.
3901 SaveAndRestore save_Block(Block), save_Succ(Succ);
3927 else if (Block && badCFG)
3955 Block = ExitConditionBlock;
3956 Block = EntryConditionBlock = addStmt(C);
3969 appendStmt(Block, DS);
3971 assert(Block == EntryConditionBlock);
3976 if (Block && badCFG)
3994 // to this block. NULL out Block to force lazy creation of another block.
3995 Block = nullptr;
4006 appendStmt(Block, A);
4009 CFGBlock *B = Block;
4034 CFGBlock *CatchBlock = Block;
4047 // We set Block to NULL to allow lazy creation of a new block (if necessary).
4048 Block = nullptr;
4059 Block = createBlock(false);
4063 addSuccessor(Block, TryTerminatedBlock);
4066 addSuccessor(Block, &cfg->getExit());
4078 if (Block) {
4081 TrySuccessor = Block;
4103 Block = nullptr;
4128 Block = nullptr;
4137 appendObjCMessage(Block, ME);
4148 Block = createBlock(false);
4152 addSuccessor(Block, TryTerminatedBlock);
4155 addSuccessor(Block, &cfg->getExit());
4165 appendStmt(Block, S);
4178 return Block;
4188 if (Block) {
4191 LoopSuccessor = Block;
4207 Block = ExitConditionBlock;
4209 if (Block) {
4226 // Save the current values for Block, Succ, and continue and break targets
4227 SaveAndRestore save_Block(Block), save_Succ(Succ);
4237 // NULL out Block to force lazy instantiation of blocks for the body.
4238 Block = nullptr;
4250 else if (Block) {
4260 Block = nullptr;
4277 // the body. NULL out Block to force lazy creation of another block.
4278 Block = nullptr;
4292 Block = createBlock(false);
4293 Block->setTerminator(C);
4299 addSuccessor(Block, ContinueJumpTarget.block);
4303 return Block;
4310 appendStmt(Block, E);
4317 return Block;
4319 CFGBlock *lastBlock = Block;
4334 appendStmt(Block, SE);
4359 if (Block) {
4362 SwitchSuccessor = Block;
4387 Block = nullptr;
4405 if (Block) {
4425 Block = SwitchTerminatedBlock;
4433 appendStmt(Block, Terminator->getConditionVariableDeclStmt());
4515 CFGBlock *CaseBlock = Block;
4533 // We set Block to NULL to allow lazy creation of a new block (if necessary).
4534 Block = nullptr;
4551 DefaultCaseBlock = Block;
4569 // We set Block to NULL to allow lazy creation of a new block (if necessary).
4570 Block = nullptr;
4583 if (Block) {
4586 TrySuccessor = Block;
4605 Block = nullptr;
4628 Block = nullptr;
4651 CFGBlock *CatchBlock = Block;
4669 // We set Block to NULL to allow lazy creation of a new block (if necessary).
4670 Block = nullptr;
4706 if (Block) {
4709 LoopSuccessor = Block;
4724 Block = ConditionBlock;
4747 // Save the current values for Block, Succ, and continue targets.
4748 SaveAndRestore save_Block(Block), save_Succ(Succ);
4753 Block = nullptr;
4764 assert(Block);
4767 Block = nullptr;
4796 Block = createBlock();
4824 appendStmt(Block, E);
4850 appendStmt(Block, NE);
4857 Block = Visit(NE->getInitializer());
4860 appendNewAllocator(Block, NE);
4863 Block = Visit(*NE->getArraySize());
4867 Block = Visit(*I);
4869 return Block;
4875 appendStmt(Block, DE);
4882 appendDeleteDtor(Block, RD, DE);
4893 appendStmt(Block, E);
4915 appendStmt(Block, E);
4942 Block = createBlock(false);
4943 Block->setTerminator(I);
4944 addSuccessor(Block, IBlock);
5017 return Block;
5023 CFGBlock *B = Block;
5037 return Block;
5054 return Block;
5061 CFGBlock *B = Block;
5094 return Block;
5126 Block = createNoReturnBlock();
5131 Block = createBlock();
5138 appendTemporaryDtor(Block, E);
5140 B = Block;
5155 addSuccessor(Decision, Block, !Context.KnownExecuted.isFalse());
5158 Block = Decision;
5165 CFGBlock *ConditionBlock = Block;
5174 CFGBlock *TrueBlock = Block;
5176 Block = ConditionBlock;
5185 Block = TrueBlock;
5190 return Block;
5197 appendStmt(Block, D);
5201 CFGBlock *B = Block;