diff options
Diffstat (limited to 'clang/lib/Analysis/CFG.cpp')
| -rw-r--r-- | clang/lib/Analysis/CFG.cpp | 314 |
1 files changed, 159 insertions, 155 deletions
diff --git a/clang/lib/Analysis/CFG.cpp b/clang/lib/Analysis/CFG.cpp index fc0cc2dba82..3139ae4c5d3 100644 --- a/clang/lib/Analysis/CFG.cpp +++ b/clang/lib/Analysis/CFG.cpp @@ -112,7 +112,7 @@ public: /// Incrementing invalid iterator is allowed and will result in invalid /// iterator. const_iterator() - : Scope(NULL), VarIter(0) {} + : Scope(nullptr), VarIter(0) {} /// Create valid iterator. In case when S.Prev is an invalid iterator and /// I is equal to 0, this will create invalid iterator. @@ -207,7 +207,7 @@ int LocalScope::const_iterator::distance(LocalScope::const_iterator L) { /// build process. It consists of CFGBlock that specifies position in CFG graph /// and LocalScope::const_iterator that specifies position in LocalScope graph. struct BlockScopePosPair { - BlockScopePosPair() : block(0) {} + BlockScopePosPair() : block(nullptr) {} BlockScopePosPair(CFGBlock *b, LocalScope::const_iterator scopePos) : block(b), scopePosition(scopePos) {} @@ -336,11 +336,11 @@ public: explicit CFGBuilder(ASTContext *astContext, const CFG::BuildOptions &buildOpts) : Context(astContext), cfg(new CFG()), // crew a new CFG - Block(NULL), Succ(NULL), - SwitchTerminatedBlock(NULL), DefaultCaseBlock(NULL), - TryTerminatedBlock(NULL), badCFG(false), BuildOpts(buildOpts), - switchExclusivelyCovered(false), switchCond(0), - cachedEntry(0), lastLookup(0) {} + Block(nullptr), Succ(nullptr), + SwitchTerminatedBlock(nullptr), DefaultCaseBlock(nullptr), + TryTerminatedBlock(nullptr), badCFG(false), BuildOpts(buildOpts), + switchExclusivelyCovered(false), switchCond(nullptr), + cachedEntry(nullptr), lastLookup(nullptr) {} // buildCFG - Used by external clients to construct the CFG. CFG* buildCFG(const Decl *D, Stmt *Statement); @@ -443,8 +443,9 @@ private: LocalScope* createOrReuseLocalScope(LocalScope* Scope); void addLocalScopeForStmt(Stmt *S); - LocalScope* addLocalScopeForDeclStmt(DeclStmt *DS, LocalScope* Scope = NULL); - LocalScope* addLocalScopeForVarDecl(VarDecl *VD, LocalScope* Scope = NULL); + LocalScope* addLocalScopeForDeclStmt(DeclStmt *DS, + LocalScope* Scope = nullptr); + LocalScope* addLocalScopeForVarDecl(VarDecl *VD, LocalScope* Scope = nullptr); void addLocalScopeAndDtors(Stmt *S); @@ -840,13 +841,13 @@ bool CFGBuilder::alwaysAdd(const Stmt *stmt) { if (!fb) { // No need to update 'cachedEntry', since it will always be null. - assert(cachedEntry == 0); + assert(!cachedEntry); return shouldAdd; } CFG::BuildOptions::ForcedBlkExprs::iterator itr = fb->find(stmt); if (itr == fb->end()) { - cachedEntry = 0; + cachedEntry = nullptr; return shouldAdd; } @@ -865,7 +866,7 @@ static const VariableArrayType *FindVA(const Type *t) { t = vt->getElementType().getTypePtr(); } - return 0; + return nullptr; } /// BuildCFG - Constructs a CFG from an AST (a Stmt*). The AST can represent an @@ -876,14 +877,14 @@ static const VariableArrayType *FindVA(const Type *t) { CFG* CFGBuilder::buildCFG(const Decl *D, Stmt *Statement) { assert(cfg.get()); if (!Statement) - return NULL; + return nullptr; // Create an empty block that will serve as the exit block for the CFG. Since // this is the first block added to the CFG, it will be implicitly registered // as the exit block. Succ = createBlock(); assert(Succ == &cfg->getExit()); - Block = NULL; // the EXIT block is empty. Create all other blocks lazily. + Block = nullptr; // the EXIT block is empty. Create all other blocks lazily. if (BuildOpts.AddImplicitDtors) if (const CXXDestructorDecl *DD = dyn_cast_or_null<CXXDestructorDecl>(D)) @@ -893,7 +894,7 @@ CFG* CFGBuilder::buildCFG(const Decl *D, Stmt *Statement) { CFGBlock *B = addStmt(Statement); if (badCFG) - return NULL; + return nullptr; // For C++ constructor add initializers to CFG. if (const CXXConstructorDecl *CD = dyn_cast_or_null<CXXConstructorDecl>(D)) { @@ -901,7 +902,7 @@ CFG* CFGBuilder::buildCFG(const Decl *D, Stmt *Statement) { E = CD->init_rend(); I != E; ++I) { B = addInitializer(*I); if (badCFG) - return NULL; + return nullptr; } } @@ -1156,7 +1157,7 @@ void CFGBuilder::addLocalScopeForStmt(Stmt *S) { if (!BuildOpts.AddImplicitDtors) return; - LocalScope *Scope = 0; + LocalScope *Scope = nullptr; // For compound statement we will be creating explicit scope. if (CompoundStmt *CS = dyn_cast<CompoundStmt>(S)) { @@ -1278,7 +1279,7 @@ void CFGBuilder::prependAutomaticObjDtorsWithTerminator(CFGBlock *Blk, CFGBlock *CFGBuilder::Visit(Stmt * S, AddStmtChoice asc) { if (!S) { badCFG = true; - return 0; + return nullptr; } if (Expr *E = dyn_cast<Expr>(S)) @@ -1503,9 +1504,10 @@ CFGBlock *CFGBuilder::VisitLogicalOperator(BinaryOperator *B) { appendStmt(ConfluenceBlock, B); if (badCFG) - return 0; + return nullptr; - return VisitLogicalOperator(B, 0, ConfluenceBlock, ConfluenceBlock).first; + return VisitLogicalOperator(B, nullptr, ConfluenceBlock, + ConfluenceBlock).first; } std::pair<CFGBlock*, CFGBlock*> @@ -1553,7 +1555,7 @@ CFGBuilder::VisitLogicalOperator(BinaryOperator *B, while (false); if (badCFG) - return std::make_pair((CFGBlock*)0, (CFGBlock*)0); + return std::make_pair(nullptr, nullptr); // Generate the blocks for evaluating the LHS. Expr *LHS = B->getLHS()->IgnoreParens(); @@ -1580,7 +1582,7 @@ CFGBuilder::VisitLogicalOperator(BinaryOperator *B, CFGBlock *EntryLHSBlock = addStmt(LHS); if (badCFG) - return std::make_pair((CFGBlock*)0, (CFGBlock*)0); + return std::make_pair(nullptr, nullptr); // See if this is a known constant. TryResult KnownVal = tryEvaluateBool(LHS); @@ -1646,7 +1648,7 @@ CFGBlock *CFGBuilder::VisitBreakStmt(BreakStmt *B) { // "break" is a control-flow statement. Thus we stop processing the current // block. if (badCFG) - return 0; + return nullptr; // Now create a new block that ends with the break statement. Block = createBlock(false); @@ -1734,7 +1736,7 @@ CFGBlock *CFGBuilder::VisitCallExpr(CallExpr *C, AddStmtChoice asc) { if (Block) { Succ = Block; if (badCFG) - return 0; + return nullptr; } if (NoReturn) @@ -1760,26 +1762,26 @@ CFGBlock *CFGBuilder::VisitChooseExpr(ChooseExpr *C, CFGBlock *ConfluenceBlock = Block ? Block : createBlock(); appendStmt(ConfluenceBlock, C); if (badCFG) - return 0; + return nullptr; AddStmtChoice alwaysAdd = asc.withAlwaysAdd(true); Succ = ConfluenceBlock; - Block = NULL; + Block = nullptr; CFGBlock *LHSBlock = Visit(C->getLHS(), alwaysAdd); if (badCFG) - return 0; + return nullptr; Succ = ConfluenceBlock; - Block = NULL; + Block = nullptr; CFGBlock *RHSBlock = Visit(C->getRHS(), alwaysAdd); if (badCFG) - return 0; + return nullptr; Block = createBlock(false); // See if this is a known constant. const TryResult& KnownVal = tryEvaluateBool(C->getCond()); - addSuccessor(Block, KnownVal.isFalse() ? NULL : LHSBlock); - addSuccessor(Block, KnownVal.isTrue() ? NULL : RHSBlock); + addSuccessor(Block, KnownVal.isFalse() ? nullptr : LHSBlock); + addSuccessor(Block, KnownVal.isTrue() ? nullptr : RHSBlock); Block->setTerminator(C); return addStmt(C->getCond()); } @@ -1797,7 +1799,7 @@ CFGBlock *CFGBuilder::VisitCompoundStmt(CompoundStmt *C) { LastBlock = newBlock; if (badCFG) - return NULL; + return nullptr; } return LastBlock; @@ -1806,14 +1808,14 @@ CFGBlock *CFGBuilder::VisitCompoundStmt(CompoundStmt *C) { CFGBlock *CFGBuilder::VisitConditionalOperator(AbstractConditionalOperator *C, AddStmtChoice asc) { const BinaryConditionalOperator *BCO = dyn_cast<BinaryConditionalOperator>(C); - const OpaqueValueExpr *opaqueValue = (BCO ? BCO->getOpaqueValue() : NULL); + const OpaqueValueExpr *opaqueValue = (BCO ? BCO->getOpaqueValue() : nullptr); // Create the confluence block that will "merge" the results of the ternary // expression. CFGBlock *ConfluenceBlock = Block ? Block : createBlock(); appendStmt(ConfluenceBlock, C); if (badCFG) - return 0; + return nullptr; AddStmtChoice alwaysAdd = asc.withAlwaysAdd(true); @@ -1822,14 +1824,14 @@ CFGBlock *CFGBuilder::VisitConditionalOperator(AbstractConditionalOperator *C, // value that is returned instead. // e.g: x ?: y is shorthand for: x ? x : y; Succ = ConfluenceBlock; - Block = NULL; - CFGBlock *LHSBlock = 0; + Block = nullptr; + CFGBlock *LHSBlock = nullptr; const Expr *trueExpr = C->getTrueExpr(); if (trueExpr != opaqueValue) { LHSBlock = Visit(C->getTrueExpr(), alwaysAdd); if (badCFG) - return 0; - Block = NULL; + return nullptr; + Block = nullptr; } else LHSBlock = ConfluenceBlock; @@ -1838,7 +1840,7 @@ CFGBlock *CFGBuilder::VisitConditionalOperator(AbstractConditionalOperator *C, Succ = ConfluenceBlock; CFGBlock *RHSBlock = Visit(C->getFalseExpr(), alwaysAdd); if (badCFG) - return 0; + return nullptr; // If the condition is a logical '&&' or '||', build a more accurate CFG. if (BinaryOperator *Cond = @@ -1880,7 +1882,7 @@ CFGBlock *CFGBuilder::VisitDeclStmt(DeclStmt *DS) { if (DS->isSingleDecl()) return VisitDeclSubExpr(DS); - CFGBlock *B = 0; + CFGBlock *B = nullptr; // Build an individual DeclStmt for each decl. for (DeclStmt::reverse_decl_iterator I = DS->decl_rbegin(), @@ -1921,16 +1923,16 @@ CFGBlock *CFGBuilder::VisitDeclSubExpr(DeclStmt *DS) { bool HasTemporaries = false; // Guard static initializers under a branch. - CFGBlock *blockAfterStaticInit = 0; + CFGBlock *blockAfterStaticInit = nullptr; if (BuildOpts.AddStaticInitBranches && VD->isStaticLocal()) { // For static variables, we need to create a branch to track // whether or not they are initialized. if (Block) { Succ = Block; - Block = 0; + Block = nullptr; if (badCFG) - return 0; + return nullptr; } blockAfterStaticInit = Succ; } @@ -1973,7 +1975,7 @@ CFGBlock *CFGBuilder::VisitDeclSubExpr(DeclStmt *DS) { // If the type of VD is a VLA, then we must process its size expressions. for (const VariableArrayType* VA = FindVA(VD->getType().getTypePtr()); - VA != 0; VA = FindVA(VA->getElementType().getTypePtr())) { + VA != nullptr; VA = FindVA(VA->getElementType().getTypePtr())) { if (CFGBlock *newBlock = addStmt(VA->getSizeExpr())) LastBlock = newBlock; } @@ -2020,7 +2022,7 @@ CFGBlock *CFGBuilder::VisitIfStmt(IfStmt *I) { if (Block) { Succ = Block; if (badCFG) - return 0; + return nullptr; } // Process the false branch. @@ -2031,7 +2033,7 @@ CFGBlock *CFGBuilder::VisitIfStmt(IfStmt *I) { // NULL out Block so that the recursive call to Visit will // create a new basic block. - Block = NULL; + Block = nullptr; // If branch is not a compound statement create implicit scope // and add destructors. @@ -2044,7 +2046,7 @@ CFGBlock *CFGBuilder::VisitIfStmt(IfStmt *I) { ElseBlock = sv.get(); else if (Block) { if (badCFG) - return 0; + return nullptr; } } @@ -2054,7 +2056,7 @@ CFGBlock *CFGBuilder::VisitIfStmt(IfStmt *I) { Stmt *Then = I->getThen(); assert(Then); SaveAndRestore<CFGBlock*> sv(Succ); - Block = NULL; + Block = nullptr; // If branch is not a compound statement create implicit scope // and add destructors. @@ -2071,7 +2073,7 @@ CFGBlock *CFGBuilder::VisitIfStmt(IfStmt *I) { addSuccessor(ThenBlock, sv.get()); } else if (Block) { if (badCFG) - return 0; + return nullptr; } } @@ -2159,10 +2161,10 @@ CFGBlock *CFGBuilder::VisitLabelStmt(LabelStmt *L) { // about. LabelBlock->setLabel(L); if (badCFG) - return 0; + return nullptr; // We set Block to NULL to allow lazy creation of a new block (if necessary); - Block = NULL; + Block = nullptr; // This block is now the implicit successor of other blocks. Succ = LabelBlock; @@ -2176,7 +2178,7 @@ CFGBlock *CFGBuilder::VisitLambdaExpr(LambdaExpr *E, AddStmtChoice asc) { et = E->capture_init_end(); it != et; ++it) { if (Expr *Init = *it) { CFGBlock *Tmp = Visit(Init); - if (Tmp != 0) + if (Tmp) LastBlock = Tmp; } } @@ -2206,7 +2208,7 @@ CFGBlock *CFGBuilder::VisitGotoStmt(GotoStmt *G) { } CFGBlock *CFGBuilder::VisitForStmt(ForStmt *F) { - CFGBlock *LoopSuccessor = NULL; + CFGBlock *LoopSuccessor = nullptr; // Save local scope position because in case of condition variable ScopePos // won't be restored when traversing AST. @@ -2229,7 +2231,7 @@ CFGBlock *CFGBuilder::VisitForStmt(ForStmt *F) { // block. if (Block) { if (badCFG) - return 0; + return nullptr; LoopSuccessor = Block; } else LoopSuccessor = Succ; @@ -2239,7 +2241,7 @@ CFGBlock *CFGBuilder::VisitForStmt(ForStmt *F) { SaveAndRestore<JumpTarget> save_break(BreakJumpTarget); BreakJumpTarget = JumpTarget(LoopSuccessor, ScopePos); - CFGBlock *BodyBlock = 0, *TransitionBlock = 0; + CFGBlock *BodyBlock = nullptr, *TransitionBlock = nullptr; // Now create the loop body. { @@ -2265,8 +2267,8 @@ CFGBlock *CFGBuilder::VisitForStmt(ForStmt *F) { if (Block) { assert(Block == Succ); if (badCFG) - return 0; - Block = 0; + return nullptr; + Block = nullptr; } // The starting block for the loop increment is the block that should @@ -2292,13 +2294,13 @@ CFGBlock *CFGBuilder::VisitForStmt(ForStmt *F) { BodyBlock = ContinueJumpTarget.block; } else if (badCFG) - return 0; + return nullptr; } // Because of short-circuit evaluation, the condition of the loop can span // multiple basic blocks. Thus we need the "Entry" and "Exit" blocks that // evaluate the condition. - CFGBlock *EntryConditionBlock = 0, *ExitConditionBlock = 0; + CFGBlock *EntryConditionBlock = nullptr, *ExitConditionBlock = nullptr; do { Expr *C = F->getCond(); @@ -2306,7 +2308,7 @@ CFGBlock *CFGBuilder::VisitForStmt(ForStmt *F) { // Specially handle logical operators, which have a slightly // more optimal CFG representation. if (BinaryOperator *Cond = - dyn_cast_or_null<BinaryOperator>(C ? C->IgnoreParens() : 0)) + dyn_cast_or_null<BinaryOperator>(C ? C->IgnoreParens() : nullptr)) if (Cond->isLogicalOp()) { std::tie(EntryConditionBlock, ExitConditionBlock) = VisitLogicalOperator(Cond, F, BodyBlock, LoopSuccessor); @@ -2339,16 +2341,17 @@ CFGBlock *CFGBuilder::VisitForStmt(ForStmt *F) { } if (Block && badCFG) - return 0; + return nullptr; KnownVal = tryEvaluateBool(C); } // Add the loop body entry as a successor to the condition. - addSuccessor(ExitConditionBlock, KnownVal.isFalse() ? NULL : BodyBlock); + addSuccessor(ExitConditionBlock, KnownVal.isFalse() ? nullptr : BodyBlock); // Link up the condition block with the code that follows the loop. (the // false branch). - addSuccessor(ExitConditionBlock, KnownVal.isTrue() ? NULL : LoopSuccessor); + addSuccessor(ExitConditionBlock, + KnownVal.isTrue() ? nullptr : LoopSuccessor); } while (false); @@ -2367,7 +2370,7 @@ CFGBlock *CFGBuilder::VisitForStmt(ForStmt *F) { // There is no loop initialization. We are thus basically a while loop. // NULL out Block to force lazy block construction. - Block = NULL; + Block = nullptr; Succ = EntryConditionBlock; return EntryConditionBlock; } @@ -2413,13 +2416,13 @@ CFGBlock *CFGBuilder::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) { // a DeclStmt and the other returns a DeclRefExpr. // - CFGBlock *LoopSuccessor = 0; + CFGBlock *LoopSuccessor = nullptr; if (Block) { if (badCFG) - return 0; + return nullptr; LoopSuccessor = Block; - Block = 0; + Block = nullptr; } else LoopSuccessor = Succ; @@ -2442,8 +2445,8 @@ CFGBlock *CFGBuilder::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) { AddStmtChoice::NotAlwaysAdd); if (Block) { if (badCFG) - return 0; - Block = 0; + return nullptr; + Block = nullptr; } // The condition block is the implicit successor for the loop body as well as @@ -2460,7 +2463,7 @@ CFGBlock *CFGBuilder::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) { // Add an intermediate block between the BodyBlock and the // EntryConditionBlock to represent the "loop back" transition, for looping // back to the head of the loop. - CFGBlock *LoopBackBlock = 0; + CFGBlock *LoopBackBlock = nullptr; Succ = LoopBackBlock = createBlock(); LoopBackBlock->setLoopTarget(S); @@ -2473,7 +2476,7 @@ CFGBlock *CFGBuilder::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) { BodyBlock = ContinueJumpTarget.block; // can happen for "for (X in Y) ;" else if (Block) { if (badCFG) - return 0; + return nullptr; } // This new body block is a successor to our "exit" condition block. @@ -2505,9 +2508,9 @@ CFGBlock *CFGBuilder::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) { // for diagnostic clients. if (SyncBlock) { if (badCFG) - return 0; + return nullptr; - Block = 0; + Block = nullptr; Succ = SyncBlock; } @@ -2550,7 +2553,7 @@ CFGBlock *CFGBuilder::VisitPseudoObjectExpr(PseudoObjectExpr *E) { } CFGBlock *CFGBuilder::VisitWhileStmt(WhileStmt *W) { - CFGBlock *LoopSuccessor = NULL; + CFGBlock *LoopSuccessor = nullptr; // Save local scope position because in case of condition variable ScopePos // won't be restored when traversing AST. @@ -2568,14 +2571,14 @@ CFGBlock *CFGBuilder::VisitWhileStmt(WhileStmt *W) { // block. if (Block) { if (badCFG) - return 0; + return nullptr; LoopSuccessor = Block; - Block = 0; + Block = nullptr; } else { LoopSuccessor = Succ; } - CFGBlock *BodyBlock = 0, *TransitionBlock = 0; + CFGBlock *BodyBlock = nullptr, *TransitionBlock = nullptr; // Process the loop body. { @@ -2609,13 +2612,13 @@ CFGBlock *CFGBuilder::VisitWhileStmt(WhileStmt *W) { if (!BodyBlock) BodyBlock = ContinueJumpTarget.block; // can happen for "while(...) ;" else if (Block && badCFG) - return 0; + return nullptr; } // Because of short-circuit evaluation, the condition of the loop can span // multiple basic blocks. Thus we need the "Entry" and "Exit" blocks that // evaluate the condition. - CFGBlock *EntryConditionBlock = 0, *ExitConditionBlock = 0; + CFGBlock *EntryConditionBlock = nullptr, *ExitConditionBlock = nullptr; do { Expr *C = W->getCond(); @@ -2651,16 +2654,17 @@ CFGBlock *CFGBuilder::VisitWhileStmt(WhileStmt *W) { } if (Block && badCFG) - return 0; + return nullptr; // See if this is a known constant. const TryResult& KnownVal = tryEvaluateBool(C); // Add the loop body entry as a successor to the condition. - addSuccessor(ExitConditionBlock, KnownVal.isFalse() ? NULL : BodyBlock); + addSuccessor(ExitConditionBlock, KnownVal.isFalse() ? nullptr : BodyBlock); // Link up the condition block with the code that follows the loop. (the // false branch). - addSuccessor(ExitConditionBlock, KnownVal.isTrue() ? NULL : LoopSuccessor); + addSuccessor(ExitConditionBlock, + KnownVal.isTrue() ? nullptr : LoopSuccessor); } while(false); @@ -2669,7 +2673,7 @@ CFGBlock *CFGBuilder::VisitWhileStmt(WhileStmt *W) { // There can be no more statements in the condition block since we loop back // to this block. NULL out Block to force lazy creation of another block. - Block = NULL; + Block = nullptr; // Return the condition block, which is the dominating block for the loop. Succ = EntryConditionBlock; @@ -2689,7 +2693,7 @@ CFGBlock *CFGBuilder::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) { // If we were in the middle of a block we stop processing that block. if (badCFG) - return 0; + return nullptr; // Create the new block. Block = createBlock(false); @@ -2705,7 +2709,7 @@ CFGBlock *CFGBuilder::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) { CFGBlock *CFGBuilder::VisitCXXThrowExpr(CXXThrowExpr *T) { // If we were in the middle of a block we stop processing that block. if (badCFG) - return 0; + return nullptr; // Create the new block. Block = createBlock(false); @@ -2723,13 +2727,13 @@ CFGBlock *CFGBuilder::VisitCXXThrowExpr(CXXThrowExpr *T) { } CFGBlock *CFGBuilder::VisitDoStmt(DoStmt *D) { - CFGBlock *LoopSuccessor = NULL; + CFGBlock *LoopSuccessor = nullptr; // "do...while" is a control-flow statement. Thus we stop processing the // current block. if (Block) { if (badCFG) - return 0; + return nullptr; LoopSuccessor = Block; } else LoopSuccessor = Succ; @@ -2750,7 +2754,7 @@ CFGBlock *CFGBuilder::VisitDoStmt(DoStmt *D) { EntryConditionBlock = addStmt(C); if (Block) { if (badCFG) - return 0; + return nullptr; } } @@ -2761,7 +2765,7 @@ CFGBlock *CFGBuilder::VisitDoStmt(DoStmt *D) { const TryResult &KnownVal = tryEvaluateBool(D->getCond()); // Process the loop body. - CFGBlock *BodyBlock = NULL; + CFGBlock *BodyBlock = nullptr; { assert(D->getBody()); @@ -2777,7 +2781,7 @@ CFGBlock *CFGBuilder::VisitDoStmt(DoStmt *D) { BreakJumpTarget = JumpTarget(LoopSuccessor, ScopePos); // NULL out Block to force lazy instantiation of blocks for the body. - Block = NULL; + Block = nullptr; // If body is not a compound statement create implicit scope // and add destructors. @@ -2791,7 +2795,7 @@ CFGBlock *CFGBuilder::VisitDoStmt(DoStmt *D) { BodyBlock = EntryConditionBlock; // can happen for "do ; while(...)" else if (Block) { if (badCFG) - return 0; + return nullptr; } if (!KnownVal.isFalse()) { @@ -2800,7 +2804,7 @@ CFGBlock *CFGBuilder::VisitDoStmt(DoStmt *D) { // empty block to represent the transition block for looping back to the // head of the loop. // FIXME: Can we do this more efficiently without adding another block? - Block = NULL; + Block = nullptr; Succ = BodyBlock; CFGBlock *LoopBackBlock = createBlock(); LoopBackBlock->setLoopTarget(D); @@ -2809,16 +2813,16 @@ CFGBlock *CFGBuilder::VisitDoStmt(DoStmt *D) { addSuccessor(ExitConditionBlock, LoopBackBlock); } else - addSuccessor(ExitConditionBlock, NULL); + addSuccessor(ExitConditionBlock, nullptr); } // Link up the condition block with the code that follows the loop. // (the false branch). - addSuccessor(ExitConditionBlock, KnownVal.isTrue() ? NULL : LoopSuccessor); + addSuccessor(ExitConditionBlock, KnownVal.isTrue() ? nullptr : LoopSuccessor); // There can be no more statements in the body block(s) since we loop back to // the body. NULL out Block to force lazy creation of another block. - Block = NULL; + Block = nullptr; // Return the loop body, which is the dominating block for the loop. Succ = BodyBlock; @@ -2829,7 +2833,7 @@ CFGBlock *CFGBuilder::VisitContinueStmt(ContinueStmt *C) { // "continue" is a control-flow statement. Thus we stop processing the // current block. if (badCFG) - return 0; + return nullptr; // Now create a new block that ends with the continue statement. Block = createBlock(false); @@ -2859,7 +2863,7 @@ CFGBlock *CFGBuilder::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E, if (E->isArgumentType()) { for (const VariableArrayType *VA =FindVA(E->getArgumentType().getTypePtr()); - VA != 0; VA = FindVA(VA->getElementType().getTypePtr())) + VA != nullptr; VA = FindVA(VA->getElementType().getTypePtr())) lastBlock = addStmt(VA->getSizeExpr()); } return lastBlock; @@ -2878,7 +2882,7 @@ CFGBlock *CFGBuilder::VisitStmtExpr(StmtExpr *SE, AddStmtChoice asc) { CFGBlock *CFGBuilder::VisitSwitchStmt(SwitchStmt *Terminator) { // "switch" is a control-flow statement. Thus we stop processing the current // block. - CFGBlock *SwitchSuccessor = NULL; + CFGBlock *SwitchSuccessor = nullptr; // Save local scope position because in case of condition variable ScopePos // won't be restored when traversing AST. @@ -2894,7 +2898,7 @@ CFGBlock *CFGBuilder::VisitSwitchStmt(SwitchStmt *Terminator) { if (Block) { if (badCFG) - return 0; + return nullptr; SwitchSuccessor = Block; } else SwitchSuccessor = Succ; @@ -2920,7 +2924,7 @@ CFGBlock *CFGBuilder::VisitSwitchStmt(SwitchStmt *Terminator) { // up to the switch. We also don't keep a pointer to the body, since all // control-flow from the switch goes to case/default statements. assert(Terminator->getBody() && "switch must contain a non-NULL body"); - Block = NULL; + Block = nullptr; // For pruning unreachable case statements, save the current state // for tracking the condition value. @@ -2932,7 +2936,7 @@ CFGBlock *CFGBuilder::VisitSwitchStmt(SwitchStmt *Terminator) { Expr::EvalResult result; bool b = tryEvaluate(Terminator->getCond(), result); SaveAndRestore<Expr::EvalResult*> save_switchCond(switchCond, - b ? &result : 0); + b ? &result : nullptr); // If body is not a compound statement create implicit scope // and add destructors. @@ -2942,7 +2946,7 @@ CFGBlock *CFGBuilder::VisitSwitchStmt(SwitchStmt *Terminator) { addStmt(Terminator->getBody()); if (Block) { if (badCFG) - return 0; + return nullptr; } // If we have no "default:" case, the default transition is to the code @@ -3015,7 +3019,7 @@ static bool shouldAddCase(bool &switchExclusivelyCovered, CFGBlock *CFGBuilder::VisitCaseStmt(CaseStmt *CS) { // CaseStmts are essentially labels, so they are the first statement in a // block. - CFGBlock *TopBlock = 0, *LastBlock = 0; + CFGBlock *TopBlock = nullptr, *LastBlock = nullptr; if (Stmt *Sub = CS->getSubStmt()) { // For deeply nested chains of CaseStmts, instead of doing a recursion @@ -3033,7 +3037,7 @@ CFGBlock *CFGBuilder::VisitCaseStmt(CaseStmt *CS) { addSuccessor(SwitchTerminatedBlock, shouldAddCase(switchExclusivelyCovered, switchCond, CS, *Context) - ? currentBlock : 0); + ? currentBlock : nullptr); LastBlock = currentBlock; CS = cast<CaseStmt>(Sub); @@ -3052,7 +3056,7 @@ CFGBlock *CFGBuilder::VisitCaseStmt(CaseStmt *CS) { CaseBlock->setLabel(CS); if (badCFG) - return 0; + return nullptr; // Add this block to the list of successors for the block with the switch // statement. @@ -3062,7 +3066,7 @@ CFGBlock *CFGBuilder::VisitCaseStmt(CaseStmt *CS) { CS, *Context)); // We set Block to NULL to allow lazy creation of a new block (if necessary) - Block = NULL; + Block = nullptr; if (TopBlock) { addSuccessor(LastBlock, CaseBlock); @@ -3089,7 +3093,7 @@ CFGBlock *CFGBuilder::VisitDefaultStmt(DefaultStmt *Terminator) { DefaultCaseBlock->setLabel(Terminator); if (badCFG) - return 0; + return nullptr; // Unlike case statements, we don't add the default block to the successors // for the switch statement immediately. This is done when we finish @@ -3098,7 +3102,7 @@ CFGBlock *CFGBuilder::VisitDefaultStmt(DefaultStmt *Terminator) { // be the last successor of a switch-terminated block. // We set Block to NULL to allow lazy creation of a new block (if necessary) - Block = NULL; + Block = nullptr; // This block is now the implicit successor of other blocks. Succ = DefaultCaseBlock; @@ -3109,11 +3113,11 @@ CFGBlock *CFGBuilder::VisitDefaultStmt(DefaultStmt *Terminator) { CFGBlock *CFGBuilder::VisitCXXTryStmt(CXXTryStmt *Terminator) { // "try"/"catch" is a control-flow statement. Thus we stop processing the // current block. - CFGBlock *TrySuccessor = NULL; + CFGBlock *TrySuccessor = nullptr; if (Block) { if (badCFG) - return 0; + return nullptr; TrySuccessor = Block; } else TrySuccessor = Succ; @@ -3129,13 +3133,13 @@ CFGBlock *CFGBuilder::VisitCXXTryStmt(CXXTryStmt *Terminator) { // The code after the try is the implicit successor. Succ = TrySuccessor; CXXCatchStmt *CS = Terminator->getHandler(h); - if (CS->getExceptionDecl() == 0) { + if (CS->getExceptionDecl() == nullptr) { HasCatchAll = true; } - Block = NULL; + Block = nullptr; CFGBlock *CatchBlock = VisitCXXCatchStmt(CS); - if (CatchBlock == 0) - return 0; + if (!CatchBlock) + return nullptr; // Add this block to the list of successors for the block with the try // statement. addSuccessor(NewTryTerminatedBlock, CatchBlock); @@ -3155,7 +3159,7 @@ CFGBlock *CFGBuilder::VisitCXXTryStmt(CXXTryStmt *Terminator) { cfg->addTryDispatchBlock(TryTerminatedBlock); assert(Terminator->getTryBlock() && "try must contain a non-NULL body"); - Block = NULL; + Block = nullptr; return addStmt(Terminator->getTryBlock()); } @@ -3194,10 +3198,10 @@ CFGBlock *CFGBuilder::VisitCXXCatchStmt(CXXCatchStmt *CS) { // Bail out if the CFG is bad. if (badCFG) - return 0; + return nullptr; // We set Block to NULL to allow lazy creation of a new block (if necessary) - Block = NULL; + Block = nullptr; return CatchBlock; } @@ -3230,10 +3234,10 @@ CFGBlock *CFGBuilder::VisitCXXForRangeStmt(CXXForRangeStmt *S) { // "for" is a control-flow statement. Thus we stop processing the current // block. - CFGBlock *LoopSuccessor = NULL; + CFGBlock *LoopSuccessor = nullptr; if (Block) { if (badCFG) - return 0; + return nullptr; LoopSuccessor = Block; } else LoopSuccessor = Succ; @@ -3252,7 +3256,7 @@ CFGBlock *CFGBuilder::VisitCXXForRangeStmt(CXXForRangeStmt *S) { Block = ConditionBlock; CFGBlock *BeginConditionBlock = addStmt(C); if (badCFG) - return 0; + return nullptr; assert(BeginConditionBlock == ConditionBlock && "condition block in for-range was unexpectedly complex"); (void)BeginConditionBlock; @@ -3278,7 +3282,7 @@ CFGBlock *CFGBuilder::VisitCXXForRangeStmt(CXXForRangeStmt *S) { // Generate increment code in its own basic block. This is the target of // continue statements. - Block = 0; + Block = nullptr; Succ = addStmt(S->getInc()); ContinueJumpTarget = JumpTarget(Succ, ContinueScopePos); @@ -3289,9 +3293,8 @@ CFGBlock *CFGBuilder::VisitCXXForRangeStmt(CXXForRangeStmt *S) { // Finish up the increment block and prepare to start the loop body. assert(Block); if (badCFG) - return 0; - Block = 0; - + return nullptr; + Block = nullptr; // Add implicit scope and dtors for loop variable. addLocalScopeAndDtors(S->getLoopVarStmt()); @@ -3299,18 +3302,19 @@ CFGBlock *CFGBuilder::VisitCXXForRangeStmt(CXXForRangeStmt *S) { // Populate a new block to contain the loop body and loop variable. addStmt(S->getBody()); if (badCFG) - return 0; + return nullptr; CFGBlock *LoopVarStmtBlock = addStmt(S->getLoopVarStmt()); if (badCFG) - return 0; - + return nullptr; + // This new body block is a successor to our condition block. - addSuccessor(ConditionBlock, KnownVal.isFalse() ? 0 : LoopVarStmtBlock); + addSuccessor(ConditionBlock, + KnownVal.isFalse() ? nullptr : LoopVarStmtBlock); } // Link up the condition block with the code that follows the loop (the // false branch). - addSuccessor(ConditionBlock, KnownVal.isTrue() ? 0 : LoopSuccessor); + addSuccessor(ConditionBlock, KnownVal.isTrue() ? nullptr : LoopSuccessor); // Add the initialization statements. Block = createBlock(); @@ -3424,7 +3428,7 @@ CFGBlock *CFGBuilder::VisitIndirectGotoStmt(IndirectGotoStmt *I) { // IndirectGoto is a control-flow statement. Thus we stop processing the // current block and create a new one. if (badCFG) - return 0; + return nullptr; Block = createBlock(false); Block->setTerminator(I); @@ -3438,7 +3442,7 @@ CFGBlock *CFGBuilder::VisitForTemporaryDtors(Stmt *E, bool BindToTemporary) { tryAgain: if (!E) { badCFG = true; - return NULL; + return nullptr; } switch (E->getStmtClass()) { default: @@ -3493,15 +3497,15 @@ CFGBlock *CFGBuilder::VisitBinaryOperatorForTemporaryDtors(BinaryOperator *E) { autoCreateBlock(); CFGBlock *ConfluenceBlock = VisitForTemporaryDtors(E->getLHS()); if (badCFG) - return NULL; + return nullptr; Succ = ConfluenceBlock; - Block = NULL; + Block = nullptr; CFGBlock *RHSBlock = VisitForTemporaryDtors(E->getRHS()); if (RHSBlock) { if (badCFG) - return NULL; + return nullptr; // If RHS expression did produce destructors we need to connect created // blocks to CFG in same manner as for binary operator itself. @@ -3521,12 +3525,12 @@ CFGBlock *CFGBuilder::VisitBinaryOperatorForTemporaryDtors(BinaryOperator *E) { // Link LHSBlock with RHSBlock exactly the same way as for binary operator // itself. if (E->getOpcode() == BO_LOr) { - addSuccessor(LHSBlock, KnownVal.isTrue() ? NULL : ConfluenceBlock); - addSuccessor(LHSBlock, KnownVal.isFalse() ? NULL : RHSBlock); + addSuccessor(LHSBlock, KnownVal.isTrue() ? nullptr : ConfluenceBlock); + addSuccessor(LHSBlock, KnownVal.isFalse() ? nullptr : RHSBlock); } else { assert (E->getOpcode() == BO_LAnd); - addSuccessor(LHSBlock, KnownVal.isFalse() ? NULL : RHSBlock); - addSuccessor(LHSBlock, KnownVal.isTrue() ? NULL : ConfluenceBlock); + addSuccessor(LHSBlock, KnownVal.isFalse() ? nullptr : RHSBlock); + addSuccessor(LHSBlock, KnownVal.isTrue() ? nullptr : ConfluenceBlock); } Block = LHSBlock; @@ -3586,29 +3590,29 @@ CFGBlock *CFGBuilder::VisitConditionalOperatorForTemporaryDtors( autoCreateBlock(); CFGBlock *ConfluenceBlock = VisitForTemporaryDtors(E->getCond()); if (badCFG) - return NULL; + return nullptr; if (BinaryConditionalOperator *BCO = dyn_cast<BinaryConditionalOperator>(E)) { ConfluenceBlock = VisitForTemporaryDtors(BCO->getCommon()); if (badCFG) - return NULL; + return nullptr; } // Try to add block with destructors for LHS expression. - CFGBlock *LHSBlock = NULL; + CFGBlock *LHSBlock = nullptr; Succ = ConfluenceBlock; - Block = NULL; + Block = nullptr; LHSBlock = VisitForTemporaryDtors(E->getTrueExpr(), BindToTemporary); if (badCFG) - return NULL; + return nullptr; // Try to add block with destructors for RHS expression; Succ = ConfluenceBlock; - Block = NULL; + Block = nullptr; CFGBlock *RHSBlock = VisitForTemporaryDtors(E->getFalseExpr(), BindToTemporary); if (badCFG) - return NULL; + return nullptr; if (!RHSBlock && !LHSBlock) { // If neither LHS nor RHS expression had temporaries to destroy don't create @@ -3627,7 +3631,7 @@ CFGBlock *CFGBuilder::VisitConditionalOperatorForTemporaryDtors( if (LHSBlock) { addSuccessor(Block, LHSBlock, !KnownVal.isFalse()); } else if (KnownVal.isFalse()) { - addSuccessor(Block, NULL); + addSuccessor(Block, nullptr); } else { addSuccessor(Block, ConfluenceBlock); std::reverse(ConfluenceBlock->pred_begin(), ConfluenceBlock->pred_end()); @@ -3708,7 +3712,7 @@ CFGImplicitDtor::getDestructorDecl(ASTContext &astContext) const { case CFGElement::MemberDtor: // Not yet supported. - return 0; + return nullptr; } llvm_unreachable("getKind() returned bogus value"); } @@ -3724,13 +3728,13 @@ bool CFGImplicitDtor::isNoReturn(ASTContext &astContext) const { //===----------------------------------------------------------------------===// CFGBlock::AdjacentBlock::AdjacentBlock(CFGBlock *B, bool IsReachable) - : ReachableBlock(IsReachable ? B : 0), - UnreachableBlock(!IsReachable ? B : 0, + : ReachableBlock(IsReachable ? B : nullptr), + UnreachableBlock(!IsReachable ? B : nullptr, B && IsReachable ? AB_Normal : AB_Unreachable) {} CFGBlock::AdjacentBlock::AdjacentBlock(CFGBlock *B, CFGBlock *AlternateBlock) : ReachableBlock(B), - UnreachableBlock(B == AlternateBlock ? 0 : AlternateBlock, + UnreachableBlock(B == AlternateBlock ? nullptr : AlternateBlock, B == AlternateBlock ? AB_Alternate : AB_Normal) {} void CFGBlock::addSuccessor(AdjacentBlock Succ, @@ -4330,16 +4334,16 @@ void CFGBlock::print(raw_ostream &OS, const CFG* cfg, /// printTerminator - A simple pretty printer of the terminator of a CFGBlock. void CFGBlock::printTerminator(raw_ostream &OS, const LangOptions &LO) const { - CFGBlockTerminatorPrint TPrinter(OS, NULL, PrintingPolicy(LO)); + CFGBlockTerminatorPrint TPrinter(OS, nullptr, PrintingPolicy(LO)); TPrinter.print(getTerminator()); } Stmt *CFGBlock::getTerminatorCondition(bool StripParens) { Stmt *Terminator = this->Terminator; if (!Terminator) - return NULL; + return nullptr; - Expr *E = NULL; + Expr *E = nullptr; switch (Terminator->getStmtClass()) { default: @@ -4396,7 +4400,7 @@ Stmt *CFGBlock::getTerminatorCondition(bool StripParens) { if (!StripParens) return E; - return E ? E->IgnoreParens() : NULL; + return E ? E->IgnoreParens() : nullptr; } //===----------------------------------------------------------------------===// @@ -4413,7 +4417,7 @@ void CFG::viewCFG(const LangOptions &LO) const { StmtPrinterHelper H(this, LO); GraphHelper = &H; llvm::ViewGraph(this,"CFG"); - GraphHelper = NULL; + GraphHelper = nullptr; #endif } |
