r214998 - Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer."
Rui Ueyama
ruiu at google.com
Wed Aug 6 15:01:54 PDT 2014
Author: ruiu
Date: Wed Aug 6 17:01:54 2014
New Revision: 214998
URL: http://llvm.org/viewvc/llvm-project?rev=214998&view=rev
Log:
Revert "Fix modelling of non-lifetime-extended temporary destructors in the analyzer."
This reverts commit r214962 because after the change the
following code doesn't compile with -Wreturn-type -Werror.
#include <cstdlib>
class NoReturn {
public:
~NoReturn() __attribute__((noreturn)) { exit(1); }
};
int check() {
true ? NoReturn() : NoReturn();
}
Modified:
cfe/trunk/include/clang/StaticAnalyzer/Core/PathSensitive/CoreEngine.h
cfe/trunk/include/clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h
cfe/trunk/include/clang/StaticAnalyzer/Core/PathSensitive/SubEngine.h
cfe/trunk/lib/Analysis/CFG.cpp
cfe/trunk/lib/StaticAnalyzer/Core/CoreEngine.cpp
cfe/trunk/lib/StaticAnalyzer/Core/ExprEngine.cpp
cfe/trunk/test/Analysis/temp-obj-dtors-cfg-output.cpp
cfe/trunk/test/Analysis/temporaries.cpp
Modified: cfe/trunk/include/clang/StaticAnalyzer/Core/PathSensitive/CoreEngine.h
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/StaticAnalyzer/Core/PathSensitive/CoreEngine.h?rev=214998&r1=214997&r2=214998&view=diff
==============================================================================
--- cfe/trunk/include/clang/StaticAnalyzer/Core/PathSensitive/CoreEngine.h (original)
+++ cfe/trunk/include/clang/StaticAnalyzer/Core/PathSensitive/CoreEngine.h Wed Aug 6 17:01:54 2014
@@ -95,8 +95,6 @@ private:
void HandleBranch(const Stmt *Cond, const Stmt *Term, const CFGBlock *B,
ExplodedNode *Pred);
- void HandleCleanupTemporaryBranch(const CXXBindTemporaryExpr *BTE,
- const CFGBlock *B, ExplodedNode *Pred);
/// Handle conditional logic for running static initializers.
void HandleStaticInit(const DeclStmt *DS, const CFGBlock *B,
Modified: cfe/trunk/include/clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h?rev=214998&r1=214997&r2=214998&view=diff
==============================================================================
--- cfe/trunk/include/clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h (original)
+++ cfe/trunk/include/clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h Wed Aug 6 17:01:54 2014
@@ -227,15 +227,6 @@ public:
const CFGBlock *DstT,
const CFGBlock *DstF) override;
- /// Called by CoreEngine.
- /// Used to generate successor nodes for temporary destructors depending
- /// on whether the corresponding constructor was visited.
- void processCleanupTemporaryBranch(const CXXBindTemporaryExpr *BTE,
- NodeBuilderContext &BldCtx,
- ExplodedNode *Pred, ExplodedNodeSet &Dst,
- const CFGBlock *DstT,
- const CFGBlock *DstF) override;
-
/// Called by CoreEngine. Used to processing branching behavior
/// at static initalizers.
void processStaticInitializer(const DeclStmt *DS,
@@ -417,11 +408,7 @@ public:
void VisitIncrementDecrementOperator(const UnaryOperator* U,
ExplodedNode *Pred,
ExplodedNodeSet &Dst);
-
- void VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *BTE,
- ExplodedNodeSet &PreVisit,
- ExplodedNodeSet &Dst);
-
+
void VisitCXXCatchStmt(const CXXCatchStmt *CS, ExplodedNode *Pred,
ExplodedNodeSet &Dst);
Modified: cfe/trunk/include/clang/StaticAnalyzer/Core/PathSensitive/SubEngine.h
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/StaticAnalyzer/Core/PathSensitive/SubEngine.h?rev=214998&r1=214997&r2=214998&view=diff
==============================================================================
--- cfe/trunk/include/clang/StaticAnalyzer/Core/PathSensitive/SubEngine.h (original)
+++ cfe/trunk/include/clang/StaticAnalyzer/Core/PathSensitive/SubEngine.h Wed Aug 6 17:01:54 2014
@@ -72,16 +72,6 @@ public:
const CFGBlock *DstT,
const CFGBlock *DstF) = 0;
- /// Called by CoreEngine.
- /// Used to generate successor nodes for temporary destructors depending
- /// on whether the corresponding constructor was visited.
- virtual void processCleanupTemporaryBranch(const CXXBindTemporaryExpr *BTE,
- NodeBuilderContext &BldCtx,
- ExplodedNode *Pred,
- ExplodedNodeSet &Dst,
- const CFGBlock *DstT,
- const CFGBlock *DstF) = 0;
-
/// Called by CoreEngine. Used to processing branching behavior
/// at static initalizers.
virtual void processStaticInitializer(const DeclStmt *DS,
Modified: cfe/trunk/lib/Analysis/CFG.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Analysis/CFG.cpp?rev=214998&r1=214997&r2=214998&view=diff
==============================================================================
--- cfe/trunk/lib/Analysis/CFG.cpp (original)
+++ cfe/trunk/lib/Analysis/CFG.cpp Wed Aug 6 17:01:54 2014
@@ -300,7 +300,7 @@ class CFGBuilder {
CFGBlock *SwitchTerminatedBlock;
CFGBlock *DefaultCaseBlock;
CFGBlock *TryTerminatedBlock;
-
+
// Current position in local scope.
LocalScope::const_iterator ScopePos;
@@ -410,75 +410,16 @@ private:
CFGBlock *VisitChildren(Stmt *S);
CFGBlock *VisitNoRecurse(Expr *E, AddStmtChoice asc);
- /// When creating the CFG for temporary destructors, we want to mirror the
- /// branch structure of the corresponding constructor calls.
- /// Thus, while visiting a statement for temporary destructors, we keep a
- /// context to keep track of the following information:
- /// - whether a subexpression is executed unconditionally
- /// - if a subexpression is executed conditionally, the first
- /// CXXBindTemporaryExpr we encounter in that subexpression (which
- /// corresponds to the last temporary destructor we have to call for this
- /// subexpression) and the CFG block at that point (which will become the
- /// successor block when inserting the decision point).
- ///
- /// That way, we can build the branch structure for temporary destructors as
- /// follows:
- /// 1. If a subexpression is executed unconditionally, we add the temporary
- /// destructor calls to the current block.
- /// 2. If a subexpression is executed conditionally, when we encounter a
- /// CXXBindTemporaryExpr:
- /// a) If it is the first temporary destructor call in the subexpression,
- /// we remember the CXXBindTemporaryExpr and the current block in the
- /// TempDtorContext; we start a new block, and insert the temporary
- /// destructor call.
- /// b) Otherwise, add the temporary destructor call to the current block.
- /// 3. When we finished visiting a conditionally executed subexpression,
- /// and we found at least one temporary constructor during the visitation
- /// (2.a has executed), we insert a decision block that uses the
- /// CXXBindTemporaryExpr as terminator, and branches to the current block
- /// if the CXXBindTemporaryExpr was marked executed, and otherwise
- /// branches to the stored successor.
- struct TempDtorContext {
- TempDtorContext(bool IsConditional)
- : IsConditional(IsConditional),
- Succ(nullptr),
- TerminatorExpr(nullptr) {}
-
- /// Returns whether we need to start a new branch for a temporary destructor
- /// call. This is the case when the the temporary destructor is
- /// conditionally executed, and it is the first one we encounter while
- /// visiting a subexpression - other temporary destructors at the same level
- /// will be added to the same block and are executed under the same
- /// condition.
- bool needsTempDtorBranch() const {
- return IsConditional && !TerminatorExpr;
- }
-
- /// Remember the successor S of a temporary destructor decision branch for
- /// the corresponding CXXBindTemporaryExpr E.
- void setDecisionPoint(CFGBlock *S, CXXBindTemporaryExpr *E) {
- Succ = S;
- TerminatorExpr = E;
- }
-
- const bool IsConditional;
- CFGBlock *Succ;
- CXXBindTemporaryExpr *TerminatorExpr;
- };
-
// Visitors to walk an AST and generate destructors of temporaries in
// full expression.
- CFGBlock *VisitForTemporaryDtors(Stmt *E, bool BindToTemporary,
- TempDtorContext &Context);
- CFGBlock *VisitChildrenForTemporaryDtors(Stmt *E, TempDtorContext &Context);
- CFGBlock *VisitBinaryOperatorForTemporaryDtors(BinaryOperator *E,
- TempDtorContext &Context);
- CFGBlock *VisitCXXBindTemporaryExprForTemporaryDtors(
- CXXBindTemporaryExpr *E, bool BindToTemporary, TempDtorContext &Context);
- CFGBlock *VisitConditionalOperatorForTemporaryDtors(
- AbstractConditionalOperator *E, bool BindToTemporary,
- TempDtorContext &Context);
- void InsertTempDtorDecisionBlock(const TempDtorContext &Context);
+ CFGBlock *VisitForTemporaryDtors(Stmt *E, bool BindToTemporary = false);
+ CFGBlock *VisitChildrenForTemporaryDtors(Stmt *E);
+ CFGBlock *VisitBinaryOperatorForTemporaryDtors(BinaryOperator *E);
+ CFGBlock *VisitCXXBindTemporaryExprForTemporaryDtors(CXXBindTemporaryExpr *E,
+ bool BindToTemporary);
+ CFGBlock *
+ VisitConditionalOperatorForTemporaryDtors(AbstractConditionalOperator *E,
+ bool BindToTemporary);
// NYS == Not Yet Supported
CFGBlock *NYS() {
@@ -1069,9 +1010,7 @@ CFGBlock *CFGBuilder::addInitializer(CXX
if (BuildOpts.AddTemporaryDtors && HasTemporaries) {
// Generate destructors for temporaries in initialization expression.
- TempDtorContext Context(/*IsConditional=*/false);
- VisitForTemporaryDtors(cast<ExprWithCleanups>(Init)->getSubExpr(),
- /*BindToTemporary=*/false, Context);
+ VisitForTemporaryDtors(cast<ExprWithCleanups>(Init)->getSubExpr());
}
}
@@ -2028,9 +1967,7 @@ CFGBlock *CFGBuilder::VisitDeclSubExpr(D
if (BuildOpts.AddTemporaryDtors && HasTemporaries) {
// Generate destructors for temporaries in initialization expression.
- TempDtorContext Context(/*IsConditional=*/false);
- VisitForTemporaryDtors(cast<ExprWithCleanups>(Init)->getSubExpr(),
- /*BindToTemporary=*/false, Context);
+ VisitForTemporaryDtors(cast<ExprWithCleanups>(Init)->getSubExpr());
}
}
@@ -3410,8 +3347,7 @@ CFGBlock *CFGBuilder::VisitExprWithClean
if (BuildOpts.AddTemporaryDtors) {
// If adding implicit destructors visit the full expression for adding
// destructors of temporaries.
- TempDtorContext Context(/*IsConditional=*/false);
- VisitForTemporaryDtors(E->getSubExpr(), false, Context);
+ VisitForTemporaryDtors(E->getSubExpr());
// Full expression has to be added as CFGStmt so it will be sequenced
// before destructors of it's temporaries.
@@ -3520,8 +3456,7 @@ CFGBlock *CFGBuilder::VisitIndirectGotoS
return addStmt(I->getTarget());
}
-CFGBlock *CFGBuilder::VisitForTemporaryDtors(Stmt *E, bool BindToTemporary,
- TempDtorContext &Context) {
+CFGBlock *CFGBuilder::VisitForTemporaryDtors(Stmt *E, bool BindToTemporary) {
assert(BuildOpts.AddImplicitDtors && BuildOpts.AddTemporaryDtors);
tryAgain:
@@ -3531,20 +3466,19 @@ tryAgain:
}
switch (E->getStmtClass()) {
default:
- return VisitChildrenForTemporaryDtors(E, Context);
+ return VisitChildrenForTemporaryDtors(E);
case Stmt::BinaryOperatorClass:
- return VisitBinaryOperatorForTemporaryDtors(cast<BinaryOperator>(E),
- Context);
+ return VisitBinaryOperatorForTemporaryDtors(cast<BinaryOperator>(E));
case Stmt::CXXBindTemporaryExprClass:
return VisitCXXBindTemporaryExprForTemporaryDtors(
- cast<CXXBindTemporaryExpr>(E), BindToTemporary, Context);
+ cast<CXXBindTemporaryExpr>(E), BindToTemporary);
case Stmt::BinaryConditionalOperatorClass:
case Stmt::ConditionalOperatorClass:
return VisitConditionalOperatorForTemporaryDtors(
- cast<AbstractConditionalOperator>(E), BindToTemporary, Context);
+ cast<AbstractConditionalOperator>(E), BindToTemporary);
case Stmt::ImplicitCastExprClass:
// For implicit cast we want BindToTemporary to be passed further.
@@ -3573,7 +3507,7 @@ tryAgain:
// Visit the skipped comma operator left-hand sides for other temporaries.
for (const Expr *CommaLHS : CommaLHSs) {
VisitForTemporaryDtors(const_cast<Expr *>(CommaLHS),
- /*BindToTemporary=*/false, Context);
+ /*BindToTemporary=*/false);
}
goto tryAgain;
}
@@ -3589,8 +3523,7 @@ tryAgain:
auto *LE = cast<LambdaExpr>(E);
CFGBlock *B = Block;
for (Expr *Init : LE->capture_inits()) {
- if (CFGBlock *R = VisitForTemporaryDtors(
- Init, /*BindToTemporary=*/false, Context))
+ if (CFGBlock *R = VisitForTemporaryDtors(Init))
B = R;
}
return B;
@@ -3606,13 +3539,7 @@ tryAgain:
}
}
-CFGBlock *CFGBuilder::VisitChildrenForTemporaryDtors(Stmt *E,
- TempDtorContext &Context) {
- if (isa<LambdaExpr>(E)) {
- // Do not visit the children of lambdas; they have their own CFGs.
- return Block;
- }
-
+CFGBlock *CFGBuilder::VisitChildrenForTemporaryDtors(Stmt *E) {
// When visiting children for destructors we want to visit them in reverse
// order that they will appear in the CFG. Because the CFG is built
// bottom-up, this means we visit them in their natural order, which
@@ -3620,99 +3547,165 @@ CFGBlock *CFGBuilder::VisitChildrenForTe
CFGBlock *B = Block;
for (Stmt::child_range I = E->children(); I; ++I) {
if (Stmt *Child = *I)
- if (CFGBlock *R = VisitForTemporaryDtors(Child, false, Context))
+ if (CFGBlock *R = VisitForTemporaryDtors(Child))
B = R;
}
return B;
}
-CFGBlock *CFGBuilder::VisitBinaryOperatorForTemporaryDtors(
- BinaryOperator *E, TempDtorContext &Context) {
+CFGBlock *CFGBuilder::VisitBinaryOperatorForTemporaryDtors(BinaryOperator *E) {
if (E->isLogicalOp()) {
- VisitForTemporaryDtors(E->getLHS(), false, Context);
- // We do not know at CFG-construction time whether the right-hand-side was
- // executed, thus we add a branch node that depends on the temporary
- // constructor call.
- TempDtorContext RHSContext(/*IsConditional=*/true);
- VisitForTemporaryDtors(E->getRHS(), false, RHSContext);
- InsertTempDtorDecisionBlock(RHSContext);
- return Block;
+ // Destructors for temporaries in LHS expression should be called after
+ // those for RHS expression. Even if this will unnecessarily create a block,
+ // this block will be used at least by the full expression.
+ autoCreateBlock();
+ CFGBlock *ConfluenceBlock = VisitForTemporaryDtors(E->getLHS());
+ if (badCFG)
+ return nullptr;
+
+ Succ = ConfluenceBlock;
+ Block = nullptr;
+ CFGBlock *RHSBlock = VisitForTemporaryDtors(E->getRHS());
+
+ if (RHSBlock) {
+ if (badCFG)
+ return nullptr;
+
+ // If RHS expression did produce destructors we need to connect created
+ // blocks to CFG in same manner as for binary operator itself.
+ CFGBlock *LHSBlock = createBlock(false);
+ LHSBlock->setTerminator(CFGTerminator(E, true));
+
+ // For binary operator LHS block is before RHS in list of predecessors
+ // of ConfluenceBlock.
+ std::reverse(ConfluenceBlock->pred_begin(),
+ ConfluenceBlock->pred_end());
+
+ // See if this is a known constant.
+ TryResult KnownVal = tryEvaluateBool(E->getLHS());
+ if (KnownVal.isKnown() && (E->getOpcode() == BO_LOr))
+ KnownVal.negate();
+
+ // Link LHSBlock with RHSBlock exactly the same way as for binary operator
+ // itself.
+ if (E->getOpcode() == BO_LOr) {
+ addSuccessor(LHSBlock, KnownVal.isTrue() ? nullptr : ConfluenceBlock);
+ addSuccessor(LHSBlock, KnownVal.isFalse() ? nullptr : RHSBlock);
+ } else {
+ assert (E->getOpcode() == BO_LAnd);
+ addSuccessor(LHSBlock, KnownVal.isFalse() ? nullptr : RHSBlock);
+ addSuccessor(LHSBlock, KnownVal.isTrue() ? nullptr : ConfluenceBlock);
+ }
+
+ Block = LHSBlock;
+ return LHSBlock;
+ }
+
+ Block = ConfluenceBlock;
+ return ConfluenceBlock;
}
if (E->isAssignmentOp()) {
// For assignment operator (=) LHS expression is visited
// before RHS expression. For destructors visit them in reverse order.
- CFGBlock *RHSBlock = VisitForTemporaryDtors(E->getRHS(), false, Context);
- CFGBlock *LHSBlock = VisitForTemporaryDtors(E->getLHS(), false, Context);
+ CFGBlock *RHSBlock = VisitForTemporaryDtors(E->getRHS());
+ CFGBlock *LHSBlock = VisitForTemporaryDtors(E->getLHS());
return LHSBlock ? LHSBlock : RHSBlock;
}
// For any other binary operator RHS expression is visited before
// LHS expression (order of children). For destructors visit them in reverse
// order.
- CFGBlock *LHSBlock = VisitForTemporaryDtors(E->getLHS(), false, Context);
- CFGBlock *RHSBlock = VisitForTemporaryDtors(E->getRHS(), false, Context);
+ CFGBlock *LHSBlock = VisitForTemporaryDtors(E->getLHS());
+ CFGBlock *RHSBlock = VisitForTemporaryDtors(E->getRHS());
return RHSBlock ? RHSBlock : LHSBlock;
}
CFGBlock *CFGBuilder::VisitCXXBindTemporaryExprForTemporaryDtors(
- CXXBindTemporaryExpr *E, bool BindToTemporary, TempDtorContext &Context) {
+ CXXBindTemporaryExpr *E, bool BindToTemporary) {
// First add destructors for temporaries in subexpression.
- CFGBlock *B = VisitForTemporaryDtors(E->getSubExpr(), false, Context);
+ CFGBlock *B = VisitForTemporaryDtors(E->getSubExpr());
if (!BindToTemporary) {
// If lifetime of temporary is not prolonged (by assigning to constant
// reference) add destructor for it.
+ // If the destructor is marked as a no-return destructor, we need to create
+ // a new block for the destructor which does not have as a successor
+ // anything built thus far. Control won't flow out of this block.
const CXXDestructorDecl *Dtor = E->getTemporary()->getDestructor();
-
if (Dtor->isNoReturn()) {
- // If the destructor is marked as a no-return destructor, we need to
- // create a new block for the destructor which does not have as a
- // successor anything built thus far. Control won't flow out of this
- // block.
- if (B) Succ = B;
+ Succ = B;
Block = createNoReturnBlock();
- } else if (Context.needsTempDtorBranch()) {
- // If we need to introduce a branch, we add a new block that we will hook
- // up to a decision block later.
- if (B) Succ = B;
- Block = createBlock();
} else {
autoCreateBlock();
}
- if (Context.needsTempDtorBranch()) {
- Context.setDecisionPoint(Succ, E);
- }
- appendTemporaryDtor(Block, E);
+ appendTemporaryDtor(Block, E);
B = Block;
}
return B;
}
-void CFGBuilder::InsertTempDtorDecisionBlock(const TempDtorContext &Context) {
- if (!Context.TerminatorExpr) {
- // If no temporary was found, we do not need to insert a decision point.
- return;
+CFGBlock *CFGBuilder::VisitConditionalOperatorForTemporaryDtors(
+ AbstractConditionalOperator *E, bool BindToTemporary) {
+ // First add destructors for condition expression. Even if this will
+ // unnecessarily create a block, this block will be used at least by the full
+ // expression.
+ autoCreateBlock();
+ CFGBlock *ConfluenceBlock = VisitForTemporaryDtors(E->getCond());
+ if (badCFG)
+ return nullptr;
+ if (BinaryConditionalOperator *BCO
+ = dyn_cast<BinaryConditionalOperator>(E)) {
+ ConfluenceBlock = VisitForTemporaryDtors(BCO->getCommon());
+ if (badCFG)
+ return nullptr;
}
- assert(Context.TerminatorExpr);
- CFGBlock *Decision = createBlock(false);
- Decision->setTerminator(CFGTerminator(Context.TerminatorExpr, true));
- addSuccessor(Decision, Block);
- addSuccessor(Decision, Context.Succ);
- Block = Decision;
-}
-CFGBlock *CFGBuilder::VisitConditionalOperatorForTemporaryDtors(
- AbstractConditionalOperator *E, bool BindToTemporary,
- TempDtorContext &Context) {
- VisitForTemporaryDtors(E->getCond(), false, Context);
- TempDtorContext TrueContext(/*IsConditional=*/true);
- VisitForTemporaryDtors(E->getTrueExpr(), BindToTemporary, TrueContext);
- InsertTempDtorDecisionBlock(TrueContext);
- TempDtorContext FalseContext(/*IsConditional=*/true);
- VisitForTemporaryDtors(E->getFalseExpr(), BindToTemporary, FalseContext);
- InsertTempDtorDecisionBlock(FalseContext);
+ // Try to add block with destructors for LHS expression.
+ CFGBlock *LHSBlock = nullptr;
+ Succ = ConfluenceBlock;
+ Block = nullptr;
+ LHSBlock = VisitForTemporaryDtors(E->getTrueExpr(), BindToTemporary);
+ if (badCFG)
+ return nullptr;
+
+ // Try to add block with destructors for RHS expression;
+ Succ = ConfluenceBlock;
+ Block = nullptr;
+ CFGBlock *RHSBlock = VisitForTemporaryDtors(E->getFalseExpr(),
+ BindToTemporary);
+ if (badCFG)
+ return nullptr;
+
+ if (!RHSBlock && !LHSBlock) {
+ // If neither LHS nor RHS expression had temporaries to destroy don't create
+ // more blocks.
+ Block = ConfluenceBlock;
+ return Block;
+ }
+
+ Block = createBlock(false);
+ Block->setTerminator(CFGTerminator(E, true));
+ assert(Block->getTerminator().isTemporaryDtorsBranch());
+
+ // See if this is a known constant.
+ const TryResult &KnownVal = tryEvaluateBool(E->getCond());
+
+ if (LHSBlock) {
+ addSuccessor(Block, LHSBlock, !KnownVal.isFalse());
+ } else if (KnownVal.isFalse()) {
+ addSuccessor(Block, nullptr);
+ } else {
+ addSuccessor(Block, ConfluenceBlock);
+ std::reverse(ConfluenceBlock->pred_begin(), ConfluenceBlock->pred_end());
+ }
+
+ if (!RHSBlock)
+ RHSBlock = ConfluenceBlock;
+
+ addSuccessor(Block, RHSBlock, !KnownVal.isTrue());
+
return Block;
}
Modified: cfe/trunk/lib/StaticAnalyzer/Core/CoreEngine.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/StaticAnalyzer/Core/CoreEngine.cpp?rev=214998&r1=214997&r2=214998&view=diff
==============================================================================
--- cfe/trunk/lib/StaticAnalyzer/Core/CoreEngine.cpp (original)
+++ cfe/trunk/lib/StaticAnalyzer/Core/CoreEngine.cpp Wed Aug 6 17:01:54 2014
@@ -14,7 +14,6 @@
#include "clang/StaticAnalyzer/Core/PathSensitive/CoreEngine.h"
#include "clang/AST/Expr.h"
-#include "clang/AST/ExprCXX.h"
#include "clang/AST/StmtCXX.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h"
@@ -347,11 +346,6 @@ void CoreEngine::HandleBlockExit(const C
default:
llvm_unreachable("Analysis for this terminator not implemented.");
- case Stmt::CXXBindTemporaryExprClass:
- HandleCleanupTemporaryBranch(
- cast<CXXBindTemporaryExpr>(B->getTerminator().getStmt()), B, Pred);
- return;
-
// Model static initializers.
case Stmt::DeclStmtClass:
HandleStaticInit(cast<DeclStmt>(Term), B, Pred);
@@ -467,17 +461,6 @@ void CoreEngine::HandleBranch(const Stmt
enqueue(Dst);
}
-void CoreEngine::HandleCleanupTemporaryBranch(const CXXBindTemporaryExpr *BTE,
- const CFGBlock *B,
- ExplodedNode *Pred) {
- assert(B->succ_size() == 2);
- NodeBuilderContext Ctx(*this, B, Pred);
- ExplodedNodeSet Dst;
- SubEng.processCleanupTemporaryBranch(BTE, Ctx, Pred, Dst, *(B->succ_begin()),
- *(B->succ_begin() + 1));
- // Enqueue the new frontier onto the worklist.
- enqueue(Dst);
-}
void CoreEngine::HandleStaticInit(const DeclStmt *DS, const CFGBlock *B,
ExplodedNode *Pred) {
Modified: cfe/trunk/lib/StaticAnalyzer/Core/ExprEngine.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/StaticAnalyzer/Core/ExprEngine.cpp?rev=214998&r1=214997&r2=214998&view=diff
==============================================================================
--- cfe/trunk/lib/StaticAnalyzer/Core/ExprEngine.cpp (original)
+++ cfe/trunk/lib/StaticAnalyzer/Core/ExprEngine.cpp Wed Aug 6 17:01:54 2014
@@ -51,15 +51,6 @@ STATISTIC(NumMaxBlockCountReachedInInlin
STATISTIC(NumTimesRetriedWithoutInlining,
"The # of times we re-evaluated a call without inlining");
-typedef std::pair<const CXXBindTemporaryExpr *, const StackFrameContext *>
- CXXBindTemporaryContext;
-
-// Keeps track of whether CXXBindTemporaryExpr nodes have been evaluated.
-// The StackFrameContext assures that nested calls due to inlined recursive
-// functions do not interfere.
-REGISTER_TRAIT_WITH_PROGRAMSTATE(InitializedTemporariesSet,
- llvm::ImmutableSet<CXXBindTemporaryContext>)
-
//===----------------------------------------------------------------------===//
// Engine construction and deletion.
//===----------------------------------------------------------------------===//
@@ -668,59 +659,13 @@ void ExprEngine::ProcessMemberDtor(const
void ExprEngine::ProcessTemporaryDtor(const CFGTemporaryDtor D,
ExplodedNode *Pred,
ExplodedNodeSet &Dst) {
- ExplodedNodeSet CleanDtorState;
- StmtNodeBuilder StmtBldr(Pred, CleanDtorState, *currBldrCtx);
- ProgramStateRef State = Pred->getState();
- assert(State->contains<InitializedTemporariesSet>(
- std::make_pair(D.getBindTemporaryExpr(), Pred->getStackFrame())));
- State = State->remove<InitializedTemporariesSet>(
- std::make_pair(D.getBindTemporaryExpr(), Pred->getStackFrame()));
- StmtBldr.generateNode(D.getBindTemporaryExpr(), Pred, State);
QualType varType = D.getBindTemporaryExpr()->getSubExpr()->getType();
- assert(CleanDtorState.size() == 1);
- ExplodedNode *CleanPred = *CleanDtorState.begin();
- // FIXME: Inlining of temporary destructors is not supported yet anyway, so
- // we just put a NULL region for now. This will need to be changed later.
- VisitCXXDestructor(varType, nullptr, D.getBindTemporaryExpr(),
- /*IsBase=*/false, CleanPred, Dst);
-}
-
-void ExprEngine::processCleanupTemporaryBranch(const CXXBindTemporaryExpr *BTE,
- NodeBuilderContext &BldCtx,
- ExplodedNode *Pred,
- ExplodedNodeSet &Dst,
- const CFGBlock *DstT,
- const CFGBlock *DstF) {
- BranchNodeBuilder TempDtorBuilder(Pred, Dst, BldCtx, DstT, DstF);
- if (Pred->getState()->contains<InitializedTemporariesSet>(
- std::make_pair(BTE, Pred->getStackFrame()))) {
- TempDtorBuilder.markInfeasible(false);
- TempDtorBuilder.generateNode(Pred->getState(), true, Pred);
- } else {
- TempDtorBuilder.markInfeasible(true);
- TempDtorBuilder.generateNode(Pred->getState(), false, Pred);
- }
-}
-void ExprEngine::VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *BTE,
- ExplodedNodeSet &PreVisit,
- ExplodedNodeSet &Dst) {
- if (!getAnalysisManager().options.includeTemporaryDtorsInCFG()) {
- // In case we don't have temporary destructors in the CFG, do not mark
- // the initialization - we would otherwise never clean it up.
- Dst = PreVisit;
- return;
- }
- StmtNodeBuilder StmtBldr(PreVisit, Dst, *currBldrCtx);
- for (ExplodedNode *Node : PreVisit) {
- ProgramStateRef State = Node->getState();
- assert(!State->contains<InitializedTemporariesSet>(
- std::make_pair(BTE, Node->getStackFrame())));
- State = State->add<InitializedTemporariesSet>(
- std::make_pair(BTE, Node->getStackFrame()));
- StmtBldr.generateNode(BTE, Node, State);
- }
+ // FIXME: Inlining of temporary destructors is not supported yet anyway, so we
+ // just put a NULL region for now. This will need to be changed later.
+ VisitCXXDestructor(varType, nullptr, D.getBindTemporaryExpr(),
+ /*IsBase=*/ false, Pred, Dst);
}
void ExprEngine::Visit(const Stmt *S, ExplodedNode *Pred,
@@ -828,17 +773,6 @@ void ExprEngine::Visit(const Stmt *S, Ex
// Handled due to fully linearised CFG.
break;
- case Stmt::CXXBindTemporaryExprClass: {
- Bldr.takeNodes(Pred);
- ExplodedNodeSet PreVisit;
- getCheckerManager().runCheckersForPreStmt(PreVisit, Pred, S, *this);
- ExplodedNodeSet Next;
- VisitCXXBindTemporaryExpr(cast<CXXBindTemporaryExpr>(S), PreVisit, Next);
- getCheckerManager().runCheckersForPostStmt(Dst, Next, S, *this);
- Bldr.addNodes(Dst);
- break;
- }
-
// Cases not handled yet; but will handle some day.
case Stmt::DesignatedInitExprClass:
case Stmt::ExtVectorElementExprClass:
@@ -876,6 +810,7 @@ void ExprEngine::Visit(const Stmt *S, Ex
case Stmt::SizeOfPackExprClass:
case Stmt::StringLiteralClass:
case Stmt::ObjCStringLiteralClass:
+ case Stmt::CXXBindTemporaryExprClass:
case Stmt::CXXPseudoDestructorExprClass:
case Stmt::SubstNonTypeTemplateParmExprClass:
case Stmt::CXXNullPtrLiteralExprClass: {
@@ -1470,8 +1405,11 @@ static const Stmt *ResolveCondition(cons
if (!BO || !BO->isLogicalOp())
return Condition;
- assert(!B->getTerminator().isTemporaryDtorsBranch() &&
- "Temporary destructor branches handled by processBindTemporary.");
+ // FIXME: This is a workaround until we handle temporary destructor branches
+ // correctly; currently, temporary destructor branches lead to blocks that
+ // only have a terminator (and no statements). These blocks violate the
+ // invariant this function assumes.
+ if (B->getTerminator().isTemporaryDtorsBranch()) return Condition;
// For logical operations, we still have the case where some branches
// use the traditional "merge" approach and others sink the branch
@@ -1500,8 +1438,6 @@ void ExprEngine::processBranch(const Stm
ExplodedNodeSet &Dst,
const CFGBlock *DstT,
const CFGBlock *DstF) {
- assert((!Condition || !isa<CXXBindTemporaryExpr>(Condition)) &&
- "CXXBindTemporaryExprs are handled by processBindTemporary.");
const LocationContext *LCtx = Pred->getLocationContext();
PrettyStackTraceLocationContext StackCrashInfo(LCtx);
currBldrCtx = &BldCtx;
@@ -1665,29 +1601,10 @@ void ExprEngine::processIndirectGoto(Ind
builder.generateNode(I, state);
}
-#if 0
-static bool stackFrameDoesNotContainInitializedTemporaries(ExplodedNode &Pred) {
- const StackFrameContext* Frame = Pred.getStackFrame();
- const llvm::ImmutableSet<CXXBindTemporaryContext> &Set =
- Pred.getState()->get<InitializedTemporariesSet>();
- return std::find_if(Set.begin(), Set.end(),
- [&](const CXXBindTemporaryContext &Ctx) {
- if (Ctx.second == Frame) {
- Ctx.first->dump();
- llvm::errs() << "\n";
- }
- return Ctx.second == Frame;
- }) == Set.end();
-}
-#endif
-
/// ProcessEndPath - Called by CoreEngine. Used to generate end-of-path
/// nodes when the control reaches the end of a function.
void ExprEngine::processEndOfFunction(NodeBuilderContext& BC,
ExplodedNode *Pred) {
- // FIXME: Assert that stackFrameDoesNotContainInitializedTemporaries(*Pred)).
- // We currently cannot enable this assert, as lifetime extended temporaries
- // are not modelled correctly.
PrettyStackTraceLocationContext CrashInfo(Pred->getLocationContext());
StateMgr.EndPath(Pred->getState());
Modified: cfe/trunk/test/Analysis/temp-obj-dtors-cfg-output.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/test/Analysis/temp-obj-dtors-cfg-output.cpp?rev=214998&r1=214997&r2=214998&view=diff
==============================================================================
--- cfe/trunk/test/Analysis/temp-obj-dtors-cfg-output.cpp (original)
+++ cfe/trunk/test/Analysis/temp-obj-dtors-cfg-output.cpp Wed Aug 6 17:01:54 2014
@@ -324,7 +324,7 @@ int testConsistencyNestedNormalReturn(bo
// CHECK: [B3]
// CHECK: 1: [B5.8] && [B4.5]
// CHECK: 2: [B5.3]([B3.1])
-// CHECK: T: (Temp Dtor) [B4.2]
+// CHECK: T: (Temp Dtor) [B5.8] && ...
// CHECK: Preds (2): B4 B5
// CHECK: Succs (2): B2 B1
// CHECK: [B4]
@@ -354,7 +354,7 @@ int testConsistencyNestedNormalReturn(bo
// CHECK: [B7]
// CHECK: 1: [B9.5] && [B8.5]
// CHECK: 2: bool a = A() && B();
-// CHECK: T: (Temp Dtor) [B8.2]
+// CHECK: T: (Temp Dtor) [B9.5] && ...
// CHECK: Preds (2): B8 B9
// CHECK: Succs (2): B6 B5
// CHECK: [B8]
@@ -390,9 +390,9 @@ int testConsistencyNestedNormalReturn(bo
// CHECK: [B3]
// CHECK: 1: [B5.8] || [B4.5]
// CHECK: 2: [B5.3]([B3.1])
-// CHECK: T: (Temp Dtor) [B4.2]
+// CHECK: T: (Temp Dtor) [B5.8] || ...
// CHECK: Preds (2): B4 B5
-// CHECK: Succs (2): B2 B1
+// CHECK: Succs (2): B1 B2
// CHECK: [B4]
// CHECK: 1: B() (CXXConstructExpr, class B)
// CHECK: 2: [B4.1] (BindTemporary)
@@ -420,9 +420,9 @@ int testConsistencyNestedNormalReturn(bo
// CHECK: [B7]
// CHECK: 1: [B9.5] || [B8.5]
// CHECK: 2: bool a = A() || B();
-// CHECK: T: (Temp Dtor) [B8.2]
+// CHECK: T: (Temp Dtor) [B9.5] || ...
// CHECK: Preds (2): B8 B9
-// CHECK: Succs (2): B6 B5
+// CHECK: Succs (2): B5 B6
// CHECK: [B8]
// CHECK: 1: B() (CXXConstructExpr, class B)
// CHECK: 2: [B8.1] (BindTemporary)
@@ -442,11 +442,11 @@ int testConsistencyNestedNormalReturn(bo
// CHECK: Succs (2): B7 B8
// CHECK: [B0 (EXIT)]
// CHECK: Preds (1): B1
-// CHECK: [B12 (ENTRY)]
-// CHECK: Succs (1): B11
+// CHECK: [B11 (ENTRY)]
+// CHECK: Succs (1): B10
// CHECK: [B1]
// CHECK: 1: int b;
-// CHECK: 2: [B8.5].~A() (Implicit destructor)
+// CHECK: 2: [B7.5].~A() (Implicit destructor)
// CHECK: Preds (2): B2 B3
// CHECK: Succs (1): B0
// CHECK: [B2]
@@ -477,66 +477,63 @@ int testConsistencyNestedNormalReturn(bo
// CHECK: [B5]
// CHECK: 1: ~A() (Temporary object destructor)
// CHECK: 2: ~A() (Temporary object destructor)
-// CHECK: Preds (1): B6
+// CHECK: Preds (1): B7
// CHECK: Succs (1): B4
// CHECK: [B6]
-// CHECK: T: (Temp Dtor) [B9.2]
-// CHECK: Preds (2): B7 B8
-// CHECK: Succs (2): B5 B4
-// CHECK: [B7]
// CHECK: 1: ~A() (Temporary object destructor)
// CHECK: 2: ~A() (Temporary object destructor)
// CHECK: 3: ~A() (Temporary object destructor)
// CHECK: 4: ~B() (Temporary object destructor)
-// CHECK: Preds (1): B8
-// CHECK: Succs (1): B6
-// CHECK: [B8]
-// CHECK: 1: [B11.5] ? [B9.6] : [B10.15]
-// CHECK: 2: [B8.1] (ImplicitCastExpr, NoOp, const class A)
-// CHECK: 3: [B8.2]
-// CHECK: 4: [B8.3] (CXXConstructExpr, class A)
+// CHECK: Preds (1): B7
+// CHECK: Succs (1): B4
+// CHECK: [B7]
+// CHECK: 1: [B10.5] ? [B8.6] : [B9.15]
+// CHECK: 2: [B7.1] (ImplicitCastExpr, NoOp, const class A)
+// CHECK: 3: [B7.2]
+// CHECK: 4: [B7.3] (CXXConstructExpr, class A)
// CHECK: 5: A a = B() ? A() : A(B());
-// CHECK: T: (Temp Dtor) [B10.2]
-// CHECK: Preds (2): B9 B10
-// CHECK: Succs (2): B7 B6
-// CHECK: [B9]
+// CHECK: T: (Temp Dtor) [B10.5] ? ... : ...
+// CHECK: Preds (2): B8 B9
+// CHECK: Succs (2): B5 B6
+// CHECK: [B8]
// CHECK: 1: A() (CXXConstructExpr, class A)
+// CHECK: 2: [B8.1] (BindTemporary)
+// CHECK: 3: [B8.2] (ImplicitCastExpr, NoOp, const class A)
+// CHECK: 4: [B8.3]
+// CHECK: 5: [B8.4] (CXXConstructExpr, class A)
+// CHECK: 6: [B8.5] (BindTemporary)
+// CHECK: Preds (1): B10
+// CHECK: Succs (1): B7
+// CHECK: [B9]
+// CHECK: 1: B() (CXXConstructExpr, class B)
// CHECK: 2: [B9.1] (BindTemporary)
-// CHECK: 3: [B9.2] (ImplicitCastExpr, NoOp, const class A)
-// CHECK: 4: [B9.3]
-// CHECK: 5: [B9.4] (CXXConstructExpr, class A)
+// CHECK: 3: [B9.2].operator A
+// CHECK: 4: [B9.2]
+// CHECK: 5: [B9.4] (ImplicitCastExpr, UserDefinedConversion, class A)
// CHECK: 6: [B9.5] (BindTemporary)
-// CHECK: Preds (1): B11
-// CHECK: Succs (1): B8
+// CHECK: 7: [B9.6] (ImplicitCastExpr, NoOp, const class A)
+// CHECK: 8: [B9.7]
+// CHECK: 9: [B9.8] (CXXConstructExpr, class A)
+// CHECK: 10: [B9.9] (BindTemporary)
+// CHECK: 11: A([B9.10]) (CXXFunctionalCastExpr, ConstructorConversion, class A)
+// CHECK: 12: [B9.11] (ImplicitCastExpr, NoOp, const class A)
+// CHECK: 13: [B9.12]
+// CHECK: 14: [B9.13] (CXXConstructExpr, class A)
+// CHECK: 15: [B9.14] (BindTemporary)
+// CHECK: Preds (1): B10
+// CHECK: Succs (1): B7
// CHECK: [B10]
// CHECK: 1: B() (CXXConstructExpr, class B)
// CHECK: 2: [B10.1] (BindTemporary)
-// CHECK: 3: [B10.2].operator A
+// CHECK: 3: [B10.2].operator bool
// CHECK: 4: [B10.2]
-// CHECK: 5: [B10.4] (ImplicitCastExpr, UserDefinedConversion, class A)
-// CHECK: 6: [B10.5] (BindTemporary)
-// CHECK: 7: [B10.6] (ImplicitCastExpr, NoOp, const class A)
-// CHECK: 8: [B10.7]
-// CHECK: 9: [B10.8] (CXXConstructExpr, class A)
-// CHECK: 10: [B10.9] (BindTemporary)
-// CHECK: 11: A([B10.10]) (CXXFunctionalCastExpr, ConstructorConversion, class A)
-// CHECK: 12: [B10.11] (ImplicitCastExpr, NoOp, const class A)
-// CHECK: 13: [B10.12]
-// CHECK: 14: [B10.13] (CXXConstructExpr, class A)
-// CHECK: 15: [B10.14] (BindTemporary)
+// CHECK: 5: [B10.4] (ImplicitCastExpr, UserDefinedConversion, _Bool)
+// CHECK: T: [B10.5] ? ... : ...
// CHECK: Preds (1): B11
-// CHECK: Succs (1): B8
-// CHECK: [B11]
-// CHECK: 1: B() (CXXConstructExpr, class B)
-// CHECK: 2: [B11.1] (BindTemporary)
-// CHECK: 3: [B11.2].operator bool
-// CHECK: 4: [B11.2]
-// CHECK: 5: [B11.4] (ImplicitCastExpr, UserDefinedConversion, _Bool)
-// CHECK: T: [B11.5] ? ... : ...
-// CHECK: Preds (1): B12
-// CHECK: Succs (2): B9 B10
+// CHECK: Succs (2): B8 B9
// CHECK: [B0 (EXIT)]
// CHECK: Preds (1): B1
+// CHECK: C() : b_(true)
// CHECK: [B2 (ENTRY)]
// CHECK: Succs (1): B1
// CHECK: [B1]
@@ -546,10 +543,12 @@ int testConsistencyNestedNormalReturn(bo
// CHECK: Succs (1): B0
// CHECK: [B0 (EXIT)]
// CHECK: Preds (1): B1
+// CHECK: ~C()
// CHECK: [B1 (ENTRY)]
// CHECK: Succs (1): B0
// CHECK: [B0 (EXIT)]
// CHECK: Preds (1): B1
+// CHECK: operator bool()
// CHECK: [B2 (ENTRY)]
// CHECK: Succs (1): B1
// CHECK: [B1]
@@ -561,6 +560,7 @@ int testConsistencyNestedNormalReturn(bo
// CHECK: Succs (1): B0
// CHECK: [B0 (EXIT)]
// CHECK: Preds (1): B1
+// CHECK: D() : b_(true)
// CHECK: [B2 (ENTRY)]
// CHECK: Succs (1): B1
// CHECK: [B1]
@@ -570,6 +570,7 @@ int testConsistencyNestedNormalReturn(bo
// CHECK: Succs (1): B0
// CHECK: [B0 (EXIT)]
// CHECK: Preds (1): B1
+// CHECK: operator bool()
// CHECK: [B2 (ENTRY)]
// CHECK: Succs (1): B1
// CHECK: [B1]
@@ -581,6 +582,7 @@ int testConsistencyNestedNormalReturn(bo
// CHECK: Succs (1): B0
// CHECK: [B0 (EXIT)]
// CHECK: Preds (1): B1
+// CHECK: int test_cond_unnamed_custom_destructor()
// CHECK: [B4 (ENTRY)]
// CHECK: Succs (1): B3
// CHECK: [B1]
@@ -605,6 +607,7 @@ int testConsistencyNestedNormalReturn(bo
// CHECK: Succs (2): B2 B1
// CHECK: [B0 (EXIT)]
// CHECK: Preds (2): B1 B2
+// CHECK: int test_cond_named_custom_destructor()
// CHECK: [B5 (ENTRY)]
// CHECK: Succs (1): B4
// CHECK: [B1]
@@ -639,6 +642,7 @@ int testConsistencyNestedNormalReturn(bo
// CHECK: Succs (2): B3 B2
// CHECK: [B0 (EXIT)]
// CHECK: Preds (3): B1 B2 B3
+// CHECK: int test_cond_unnamed_auto_destructor()
// CHECK: [B4 (ENTRY)]
// CHECK: Succs (1): B3
// CHECK: [B1]
@@ -661,6 +665,7 @@ int testConsistencyNestedNormalReturn(bo
// CHECK: Succs (2): B2 B1
// CHECK: [B0 (EXIT)]
// CHECK: Preds (2): B1 B2
+// CHECK: int test_cond_named_auto_destructor()
// CHECK: [B4 (ENTRY)]
// CHECK: Succs (1): B3
// CHECK: [B1]
@@ -688,285 +693,272 @@ int testConsistencyNestedNormalReturn(bo
// CHECK: Succs (2): B2 B1
// CHECK: [B0 (EXIT)]
// CHECK: Preds (2): B1 B2
-// CHECK: [B16 (ENTRY)]
-// CHECK: Succs (1): B15
+// CHECK: [B14 (ENTRY)]
+// CHECK: Succs (1): B13
// CHECK: [B1]
// CHECK: 1: ~B() (Temporary object destructor)
// CHECK: 2: int b;
-// CHECK: 3: [B12.4].~A() (Implicit destructor)
+// CHECK: 3: [B10.4].~A() (Implicit destructor)
// CHECK: Preds (2): B2 B3
// CHECK: Succs (1): B0
// CHECK: [B2]
// CHECK: 1: ~A() (Temporary object destructor)
// CHECK: 2: ~A() (Temporary object destructor)
-// CHECK: Preds (1): B3
+// CHECK: Preds (1): B4
// CHECK: Succs (1): B1
// CHECK: [B3]
-// CHECK: T: (Temp Dtor) [B6.2]
-// CHECK: Preds (2): B4 B5
-// CHECK: Succs (2): B2 B1
-// CHECK: [B4]
// CHECK: 1: ~A() (Temporary object destructor)
// CHECK: 2: ~A() (Temporary object destructor)
// CHECK: 3: ~A() (Temporary object destructor)
// CHECK: 4: ~B() (Temporary object destructor)
-// CHECK: Preds (1): B5
-// CHECK: Succs (1): B3
+// CHECK: Preds (1): B4
+// CHECK: Succs (1): B1
+// CHECK: [B4]
+// CHECK: 1: [B7.8] ? [B5.6] : [B6.15]
+// CHECK: 2: [B4.1] (ImplicitCastExpr, NoOp, const class A)
+// CHECK: 3: [B4.2]
+// CHECK: 4: [B7.3]([B4.3])
+// CHECK: T: (Temp Dtor) [B7.8] ? ... : ...
+// CHECK: Preds (2): B5 B6
+// CHECK: Succs (2): B2 B3
// CHECK: [B5]
-// CHECK: 1: [B8.8] ? [B6.6] : [B7.15]
-// CHECK: 2: [B5.1] (ImplicitCastExpr, NoOp, const class A)
-// CHECK: 3: [B5.2]
-// CHECK: 4: [B8.3]([B5.3])
-// CHECK: T: (Temp Dtor) [B7.2]
-// CHECK: Preds (2): B6 B7
-// CHECK: Succs (2): B4 B3
-// CHECK: [B6]
// CHECK: 1: A() (CXXConstructExpr, class A)
+// CHECK: 2: [B5.1] (BindTemporary)
+// CHECK: 3: [B5.2] (ImplicitCastExpr, NoOp, const class A)
+// CHECK: 4: [B5.3]
+// CHECK: 5: [B5.4] (CXXConstructExpr, class A)
+// CHECK: 6: [B5.5] (BindTemporary)
+// CHECK: Preds (1): B7
+// CHECK: Succs (1): B4
+// CHECK: [B6]
+// CHECK: 1: B() (CXXConstructExpr, class B)
// CHECK: 2: [B6.1] (BindTemporary)
-// CHECK: 3: [B6.2] (ImplicitCastExpr, NoOp, const class A)
-// CHECK: 4: [B6.3]
-// CHECK: 5: [B6.4] (CXXConstructExpr, class A)
+// CHECK: 3: [B6.2].operator A
+// CHECK: 4: [B6.2]
+// CHECK: 5: [B6.4] (ImplicitCastExpr, UserDefinedConversion, class A)
// CHECK: 6: [B6.5] (BindTemporary)
-// CHECK: Preds (1): B8
-// CHECK: Succs (1): B5
+// CHECK: 7: [B6.6] (ImplicitCastExpr, NoOp, const class A)
+// CHECK: 8: [B6.7]
+// CHECK: 9: [B6.8] (CXXConstructExpr, class A)
+// CHECK: 10: [B6.9] (BindTemporary)
+// CHECK: 11: A([B6.10]) (CXXFunctionalCastExpr, ConstructorConversion, class A)
+// CHECK: 12: [B6.11] (ImplicitCastExpr, NoOp, const class A)
+// CHECK: 13: [B6.12]
+// CHECK: 14: [B6.13] (CXXConstructExpr, class A)
+// CHECK: 15: [B6.14] (BindTemporary)
+// CHECK: Preds (1): B7
+// CHECK: Succs (1): B4
// CHECK: [B7]
-// CHECK: 1: B() (CXXConstructExpr, class B)
-// CHECK: 2: [B7.1] (BindTemporary)
-// CHECK: 3: [B7.2].operator A
-// CHECK: 4: [B7.2]
-// CHECK: 5: [B7.4] (ImplicitCastExpr, UserDefinedConversion, class A)
-// CHECK: 6: [B7.5] (BindTemporary)
-// CHECK: 7: [B7.6] (ImplicitCastExpr, NoOp, const class A)
-// CHECK: 8: [B7.7]
-// CHECK: 9: [B7.8] (CXXConstructExpr, class A)
-// CHECK: 10: [B7.9] (BindTemporary)
-// CHECK: 11: A([B7.10]) (CXXFunctionalCastExpr, ConstructorConversion, class A)
-// CHECK: 12: [B7.11] (ImplicitCastExpr, NoOp, const class A)
-// CHECK: 13: [B7.12]
-// CHECK: 14: [B7.13] (CXXConstructExpr, class A)
-// CHECK: 15: [B7.14] (BindTemporary)
-// CHECK: Preds (1): B8
-// CHECK: Succs (1): B5
-// CHECK: [B8]
// CHECK: 1: ~B() (Temporary object destructor)
// CHECK: 2: foo
-// CHECK: 3: [B8.2] (ImplicitCastExpr, FunctionToPointerDecay, void (*)(const class A &))
+// CHECK: 3: [B7.2] (ImplicitCastExpr, FunctionToPointerDecay, void (*)(const class A &))
// CHECK: 4: B() (CXXConstructExpr, class B)
-// CHECK: 5: [B8.4] (BindTemporary)
-// CHECK: 6: [B8.5].operator bool
-// CHECK: 7: [B8.5]
-// CHECK: 8: [B8.7] (ImplicitCastExpr, UserDefinedConversion, _Bool)
-// CHECK: T: [B8.8] ? ... : ...
-// CHECK: Preds (2): B9 B10
-// CHECK: Succs (2): B6 B7
+// CHECK: 5: [B7.4] (BindTemporary)
+// CHECK: 6: [B7.5].operator bool
+// CHECK: 7: [B7.5]
+// CHECK: 8: [B7.7] (ImplicitCastExpr, UserDefinedConversion, _Bool)
+// CHECK: T: [B7.8] ? ... : ...
+// CHECK: Preds (2): B8 B9
+// CHECK: Succs (2): B5 B6
+// CHECK: [B8]
+// CHECK: 1: ~A() (Temporary object destructor)
+// CHECK: Preds (1): B10
+// CHECK: Succs (1): B7
// CHECK: [B9]
// CHECK: 1: ~A() (Temporary object destructor)
+// CHECK: 2: ~A() (Temporary object destructor)
+// CHECK: 3: ~B() (Temporary object destructor)
// CHECK: Preds (1): B10
-// CHECK: Succs (1): B8
+// CHECK: Succs (1): B7
// CHECK: [B10]
-// CHECK: T: (Temp Dtor) [B13.2]
+// CHECK: 1: [B13.5] ? [B11.6] : [B12.15]
+// CHECK: 2: [B10.1] (ImplicitCastExpr, NoOp, const class A)
+// CHECK: 3: [B10.2]
+// CHECK: 4: const A &a = B() ? A() : A(B());
+// CHECK: T: (Temp Dtor) [B13.5] ? ... : ...
// CHECK: Preds (2): B11 B12
-// CHECK: Succs (2): B9 B8
+// CHECK: Succs (2): B8 B9
// CHECK: [B11]
-// CHECK: 1: ~A() (Temporary object destructor)
-// CHECK: 2: ~A() (Temporary object destructor)
-// CHECK: 3: ~B() (Temporary object destructor)
-// CHECK: Preds (1): B12
+// CHECK: 1: A() (CXXConstructExpr, class A)
+// CHECK: 2: [B11.1] (BindTemporary)
+// CHECK: 3: [B11.2] (ImplicitCastExpr, NoOp, const class A)
+// CHECK: 4: [B11.3]
+// CHECK: 5: [B11.4] (CXXConstructExpr, class A)
+// CHECK: 6: [B11.5] (BindTemporary)
+// CHECK: Preds (1): B13
// CHECK: Succs (1): B10
// CHECK: [B12]
-// CHECK: 1: [B15.5] ? [B13.6] : [B14.15]
-// CHECK: 2: [B12.1] (ImplicitCastExpr, NoOp, const class A)
-// CHECK: 3: [B12.2]
-// CHECK: 4: const A &a = B() ? A() : A(B());
-// CHECK: T: (Temp Dtor) [B14.2]
-// CHECK: Preds (2): B13 B14
-// CHECK: Succs (2): B11 B10
-// CHECK: [B13]
-// CHECK: 1: A() (CXXConstructExpr, class A)
-// CHECK: 2: [B13.1] (BindTemporary)
-// CHECK: 3: [B13.2] (ImplicitCastExpr, NoOp, const class A)
-// CHECK: 4: [B13.3]
-// CHECK: 5: [B13.4] (CXXConstructExpr, class A)
-// CHECK: 6: [B13.5] (BindTemporary)
-// CHECK: Preds (1): B15
-// CHECK: Succs (1): B12
-// CHECK: [B14]
// CHECK: 1: B() (CXXConstructExpr, class B)
-// CHECK: 2: [B14.1] (BindTemporary)
-// CHECK: 3: [B14.2].operator A
-// CHECK: 4: [B14.2]
-// CHECK: 5: [B14.4] (ImplicitCastExpr, UserDefinedConversion, class A)
-// CHECK: 6: [B14.5] (BindTemporary)
-// CHECK: 7: [B14.6] (ImplicitCastExpr, NoOp, const class A)
-// CHECK: 8: [B14.7]
-// CHECK: 9: [B14.8] (CXXConstructExpr, class A)
-// CHECK: 10: [B14.9] (BindTemporary)
-// CHECK: 11: A([B14.10]) (CXXFunctionalCastExpr, ConstructorConversion, class A)
-// CHECK: 12: [B14.11] (ImplicitCastExpr, NoOp, const class A)
-// CHECK: 13: [B14.12]
-// CHECK: 14: [B14.13] (CXXConstructExpr, class A)
-// CHECK: 15: [B14.14] (BindTemporary)
-// CHECK: Preds (1): B15
-// CHECK: Succs (1): B12
-// CHECK: [B15]
+// CHECK: 2: [B12.1] (BindTemporary)
+// CHECK: 3: [B12.2].operator A
+// CHECK: 4: [B12.2]
+// CHECK: 5: [B12.4] (ImplicitCastExpr, UserDefinedConversion, class A)
+// CHECK: 6: [B12.5] (BindTemporary)
+// CHECK: 7: [B12.6] (ImplicitCastExpr, NoOp, const class A)
+// CHECK: 8: [B12.7]
+// CHECK: 9: [B12.8] (CXXConstructExpr, class A)
+// CHECK: 10: [B12.9] (BindTemporary)
+// CHECK: 11: A([B12.10]) (CXXFunctionalCastExpr, ConstructorConversion, class A)
+// CHECK: 12: [B12.11] (ImplicitCastExpr, NoOp, const class A)
+// CHECK: 13: [B12.12]
+// CHECK: 14: [B12.13] (CXXConstructExpr, class A)
+// CHECK: 15: [B12.14] (BindTemporary)
+// CHECK: Preds (1): B13
+// CHECK: Succs (1): B10
+// CHECK: [B13]
// CHECK: 1: B() (CXXConstructExpr, class B)
-// CHECK: 2: [B15.1] (BindTemporary)
-// CHECK: 3: [B15.2].operator bool
-// CHECK: 4: [B15.2]
-// CHECK: 5: [B15.4] (ImplicitCastExpr, UserDefinedConversion, _Bool)
-// CHECK: T: [B15.5] ? ... : ...
-// CHECK: Preds (1): B16
-// CHECK: Succs (2): B13 B14
+// CHECK: 2: [B13.1] (BindTemporary)
+// CHECK: 3: [B13.2].operator bool
+// CHECK: 4: [B13.2]
+// CHECK: 5: [B13.4] (ImplicitCastExpr, UserDefinedConversion, _Bool)
+// CHECK: T: [B13.5] ? ... : ...
+// CHECK: Preds (1): B14
+// CHECK: Succs (2): B11 B12
// CHECK: [B0 (EXIT)]
// CHECK: Preds (1): B1
-// CHECK: [B9 (ENTRY)]
-// CHECK: Succs (1): B8
+// CHECK: [B8 (ENTRY)]
+// CHECK: Succs (1): B7
// CHECK: [B1]
-// CHECK: 1: int b;
-// CHECK: 2: [B5.5].~A() (Implicit destructor)
+// CHECK: 1: ~A() (Temporary object destructor)
+// CHECK: 2: int b;
+// CHECK: 3: [B4.5].~A() (Implicit destructor)
// CHECK: Preds (2): B2 B3
// CHECK: Succs (1): B0
// CHECK: [B2]
// CHECK: 1: ~A() (Temporary object destructor)
-// CHECK: Preds (1): B3
+// CHECK: Preds (1): B4
// CHECK: Succs (1): B1
// CHECK: [B3]
-// CHECK: T: (Temp Dtor) [B6.4]
-// CHECK: Preds (2): B4 B5
-// CHECK: Succs (2): B2 B1
-// CHECK: [B4]
// CHECK: 1: ~A() (Temporary object destructor)
// CHECK: 2: ~A() (Temporary object destructor)
-// CHECK: Preds (1): B5
-// CHECK: Succs (1): B3
-// CHECK: [B5]
-// CHECK: 1: [B8.2] ?: [B7.6]
-// CHECK: 2: [B5.1] (ImplicitCastExpr, NoOp, const class A)
-// CHECK: 3: [B5.2]
-// CHECK: 4: [B5.3] (CXXConstructExpr, class A)
+// CHECK: Preds (1): B4
+// CHECK: Succs (1): B1
+// CHECK: [B4]
+// CHECK: 1: [B7.2] ?: [B6.6]
+// CHECK: 2: [B4.1] (ImplicitCastExpr, NoOp, const class A)
+// CHECK: 3: [B4.2]
+// CHECK: 4: [B4.3] (CXXConstructExpr, class A)
// CHECK: 5: A a = A() ?: A();
-// CHECK: T: (Temp Dtor) [B7.2]
-// CHECK: Preds (2): B6 B7
-// CHECK: Succs (2): B4 B3
+// CHECK: T: (Temp Dtor) [B7.5] ? ... : ...
+// CHECK: Preds (2): B5 B6
+// CHECK: Succs (2): B2 B3
+// CHECK: [B5]
+// CHECK: 1: [B7.2] (ImplicitCastExpr, NoOp, const class A)
+// CHECK: 2: [B5.1]
+// CHECK: 3: [B5.2] (CXXConstructExpr, class A)
+// CHECK: 4: [B5.3] (BindTemporary)
+// CHECK: Preds (1): B7
+// CHECK: Succs (1): B4
// CHECK: [B6]
-// CHECK: 1: [B8.2] (ImplicitCastExpr, NoOp, const class A)
-// CHECK: 2: [B6.1]
-// CHECK: 3: [B6.2] (CXXConstructExpr, class A)
-// CHECK: 4: [B6.3] (BindTemporary)
-// CHECK: Preds (1): B8
-// CHECK: Succs (1): B5
+// CHECK: 1: A() (CXXConstructExpr, class A)
+// CHECK: 2: [B6.1] (BindTemporary)
+// CHECK: 3: [B6.2] (ImplicitCastExpr, NoOp, const class A)
+// CHECK: 4: [B6.3]
+// CHECK: 5: [B6.4] (CXXConstructExpr, class A)
+// CHECK: 6: [B6.5] (BindTemporary)
+// CHECK: Preds (1): B7
+// CHECK: Succs (1): B4
// CHECK: [B7]
// CHECK: 1: A() (CXXConstructExpr, class A)
// CHECK: 2: [B7.1] (BindTemporary)
-// CHECK: 3: [B7.2] (ImplicitCastExpr, NoOp, const class A)
-// CHECK: 4: [B7.3]
-// CHECK: 5: [B7.4] (CXXConstructExpr, class A)
-// CHECK: 6: [B7.5] (BindTemporary)
+// CHECK: 3: [B7.2].operator bool
+// CHECK: 4: [B7.2]
+// CHECK: 5: [B7.4] (ImplicitCastExpr, UserDefinedConversion, _Bool)
+// CHECK: T: [B7.5] ? ... : ...
// CHECK: Preds (1): B8
-// CHECK: Succs (1): B5
-// CHECK: [B8]
-// CHECK: 1: A() (CXXConstructExpr, class A)
-// CHECK: 2: [B8.1] (BindTemporary)
-// CHECK: 3: [B8.2].operator bool
-// CHECK: 4: [B8.2]
-// CHECK: 5: [B8.4] (ImplicitCastExpr, UserDefinedConversion, _Bool)
-// CHECK: T: [B8.5] ? ... : ...
-// CHECK: Preds (1): B9
-// CHECK: Succs (2): B6 B7
+// CHECK: Succs (2): B5 B6
// CHECK: [B0 (EXIT)]
// CHECK: Preds (1): B1
-// CHECK: [B14 (ENTRY)]
-// CHECK: Succs (1): B13
+// CHECK: [B13 (ENTRY)]
+// CHECK: Succs (1): B12
// CHECK: [B1]
-// CHECK: 1: int b;
-// CHECK: 2: [B10.4].~A() (Implicit destructor)
+// CHECK: 1: ~A() (Temporary object destructor)
+// CHECK: 2: int b;
+// CHECK: 3: [B9.4].~A() (Implicit destructor)
// CHECK: Preds (2): B2 B3
// CHECK: Succs (1): B0
// CHECK: [B2]
// CHECK: 1: ~A() (Temporary object destructor)
-// CHECK: Preds (1): B3
+// CHECK: Preds (1): B4
// CHECK: Succs (1): B1
// CHECK: [B3]
-// CHECK: T: (Temp Dtor) [B6.4]
-// CHECK: Preds (2): B4 B5
-// CHECK: Succs (2): B2 B1
-// CHECK: [B4]
// CHECK: 1: ~A() (Temporary object destructor)
// CHECK: 2: ~A() (Temporary object destructor)
-// CHECK: Preds (1): B5
-// CHECK: Succs (1): B3
+// CHECK: Preds (1): B4
+// CHECK: Succs (1): B1
+// CHECK: [B4]
+// CHECK: 1: [B7.5] ?: [B6.6]
+// CHECK: 2: [B4.1] (ImplicitCastExpr, NoOp, const class A)
+// CHECK: 3: [B4.2]
+// CHECK: 4: [B7.3]([B4.3])
+// CHECK: T: (Temp Dtor) [B7.8] ? ... : ...
+// CHECK: Preds (2): B5 B6
+// CHECK: Succs (2): B2 B3
// CHECK: [B5]
-// CHECK: 1: [B8.4] ?: [B7.6]
-// CHECK: 2: [B5.1] (ImplicitCastExpr, NoOp, const class A)
-// CHECK: 3: [B5.2]
-// CHECK: 4: [B8.2]([B5.3])
-// CHECK: T: (Temp Dtor) [B7.2]
-// CHECK: Preds (2): B6 B7
-// CHECK: Succs (2): B4 B3
+// CHECK: 1: [B7.5] (ImplicitCastExpr, NoOp, const class A)
+// CHECK: 2: [B5.1]
+// CHECK: 3: [B5.2] (CXXConstructExpr, class A)
+// CHECK: 4: [B5.3] (BindTemporary)
+// CHECK: Preds (1): B7
+// CHECK: Succs (1): B4
// CHECK: [B6]
-// CHECK: 1: [B8.4] (ImplicitCastExpr, NoOp, const class A)
-// CHECK: 2: [B6.1]
-// CHECK: 3: [B6.2] (CXXConstructExpr, class A)
-// CHECK: 4: [B6.3] (BindTemporary)
-// CHECK: Preds (1): B8
-// CHECK: Succs (1): B5
-// CHECK: [B7]
// CHECK: 1: A() (CXXConstructExpr, class A)
-// CHECK: 2: [B7.1] (BindTemporary)
-// CHECK: 3: [B7.2] (ImplicitCastExpr, NoOp, const class A)
-// CHECK: 4: [B7.3]
-// CHECK: 5: [B7.4] (CXXConstructExpr, class A)
-// CHECK: 6: [B7.5] (BindTemporary)
-// CHECK: Preds (1): B8
-// CHECK: Succs (1): B5
+// CHECK: 2: [B6.1] (BindTemporary)
+// CHECK: 3: [B6.2] (ImplicitCastExpr, NoOp, const class A)
+// CHECK: 4: [B6.3]
+// CHECK: 5: [B6.4] (CXXConstructExpr, class A)
+// CHECK: 6: [B6.5] (BindTemporary)
+// CHECK: Preds (1): B7
+// CHECK: Succs (1): B4
+// CHECK: [B7]
+// CHECK: 1: ~A() (Temporary object destructor)
+// CHECK: 2: foo
+// CHECK: 3: [B7.2] (ImplicitCastExpr, FunctionToPointerDecay, void (*)(const class A &))
+// CHECK: 4: A() (CXXConstructExpr, class A)
+// CHECK: 5: [B7.4] (BindTemporary)
+// CHECK: 6: [B7.5].operator bool
+// CHECK: 7: [B7.5]
+// CHECK: 8: [B7.7] (ImplicitCastExpr, UserDefinedConversion, _Bool)
+// CHECK: T: [B7.8] ? ... : ...
+// CHECK: Preds (2): B9 B8
+// CHECK: Succs (2): B5 B6
// CHECK: [B8]
-// CHECK: 1: foo
-// CHECK: 2: [B8.1] (ImplicitCastExpr, FunctionToPointerDecay, void (*)(const class A &))
-// CHECK: 3: A() (CXXConstructExpr, class A)
-// CHECK: 4: [B8.3] (BindTemporary)
-// CHECK: 5: [B8.4].operator bool
-// CHECK: 6: [B8.4]
-// CHECK: 7: [B8.6] (ImplicitCastExpr, UserDefinedConversion, _Bool)
-// CHECK: T: [B8.7] ? ... : ...
-// CHECK: Preds (2): B9 B10
-// CHECK: Succs (2): B6 B7
-// CHECK: [B9]
// CHECK: 1: ~A() (Temporary object destructor)
-// CHECK: Preds (1): B10
-// CHECK: Succs (1): B8
-// CHECK: [B10]
-// CHECK: 1: [B13.2] ?: [B12.6]
-// CHECK: 2: [B10.1] (ImplicitCastExpr, NoOp, const class A)
-// CHECK: 3: [B10.2]
+// CHECK: Preds (1): B9
+// CHECK: Succs (1): B7
+// CHECK: [B9]
+// CHECK: 1: [B12.2] ?: [B11.6]
+// CHECK: 2: [B9.1] (ImplicitCastExpr, NoOp, const class A)
+// CHECK: 3: [B9.2]
// CHECK: 4: const A &a = A() ?: A();
-// CHECK: T: (Temp Dtor) [B12.2]
-// CHECK: Preds (2): B11 B12
-// CHECK: Succs (2): B9 B8
+// CHECK: T: (Temp Dtor) [B12.5] ? ... : ...
+// CHECK: Preds (2): B10 B11
+// CHECK: Succs (2): B7 B8
+// CHECK: [B10]
+// CHECK: 1: [B12.2] (ImplicitCastExpr, NoOp, const class A)
+// CHECK: 2: [B10.1]
+// CHECK: 3: [B10.2] (CXXConstructExpr, class A)
+// CHECK: 4: [B10.3] (BindTemporary)
+// CHECK: Preds (1): B12
+// CHECK: Succs (1): B9
// CHECK: [B11]
-// CHECK: 1: [B13.2] (ImplicitCastExpr, NoOp, const class A)
-// CHECK: 2: [B11.1]
-// CHECK: 3: [B11.2] (CXXConstructExpr, class A)
-// CHECK: 4: [B11.3] (BindTemporary)
-// CHECK: Preds (1): B13
-// CHECK: Succs (1): B10
+// CHECK: 1: A() (CXXConstructExpr, class A)
+// CHECK: 2: [B11.1] (BindTemporary)
+// CHECK: 3: [B11.2] (ImplicitCastExpr, NoOp, const class A)
+// CHECK: 4: [B11.3]
+// CHECK: 5: [B11.4] (CXXConstructExpr, class A)
+// CHECK: 6: [B11.5] (BindTemporary)
+// CHECK: Preds (1): B12
+// CHECK: Succs (1): B9
// CHECK: [B12]
// CHECK: 1: A() (CXXConstructExpr, class A)
// CHECK: 2: [B12.1] (BindTemporary)
-// CHECK: 3: [B12.2] (ImplicitCastExpr, NoOp, const class A)
-// CHECK: 4: [B12.3]
-// CHECK: 5: [B12.4] (CXXConstructExpr, class A)
-// CHECK: 6: [B12.5] (BindTemporary)
+// CHECK: 3: [B12.2].operator bool
+// CHECK: 4: [B12.2]
+// CHECK: 5: [B12.4] (ImplicitCastExpr, UserDefinedConversion, _Bool)
+// CHECK: T: [B12.5] ? ... : ...
// CHECK: Preds (1): B13
-// CHECK: Succs (1): B10
-// CHECK: [B13]
-// CHECK: 1: A() (CXXConstructExpr, class A)
-// CHECK: 2: [B13.1] (BindTemporary)
-// CHECK: 3: [B13.2].operator bool
-// CHECK: 4: [B13.2]
-// CHECK: 5: [B13.4] (ImplicitCastExpr, UserDefinedConversion, _Bool)
-// CHECK: T: [B13.5] ? ... : ...
-// CHECK: Preds (1): B14
-// CHECK: Succs (2): B11 B12
+// CHECK: Succs (2): B10 B11
// CHECK: [B0 (EXIT)]
// CHECK: Preds (1): B1
// CHECK: [B2 (ENTRY)]
@@ -1097,7 +1089,6 @@ int testConsistencyNestedNormalReturn(bo
// CHECK: Succs (1): B2
// CHECK: [B1]
// CHECK: 1: int b;
-// CHECK: Preds (1): B2(Unreachable)
// CHECK: Succs (1): B0
// CHECK: [B2 (NORETURN)]
// CHECK: 1: int a;
@@ -1114,7 +1105,6 @@ int testConsistencyNestedNormalReturn(bo
// CHECK: Succs (1): B2
// CHECK: [B1]
// CHECK: 1: int b;
-// CHECK: Preds (1): B2(Unreachable)
// CHECK: Succs (1): B0
// CHECK: [B2 (NORETURN)]
// CHECK: 1: int a;
@@ -1127,6 +1117,7 @@ int testConsistencyNestedNormalReturn(bo
// CHECK: Succs (1): B0
// CHECK: [B0 (EXIT)]
// CHECK: Preds (2): B1 B2
+// CHECK: int testConsistencyNestedSimple(bool value)
// CHECK: [B9 (ENTRY)]
// CHECK: Succs (1): B8
// CHECK: [B1]
@@ -1141,7 +1132,7 @@ int testConsistencyNestedNormalReturn(bo
// CHECK: Succs (1): B0
// CHECK: [B3]
// CHECK: T: if [B5.1]
-// CHECK: Preds (2): B4(Unreachable) B5
+// CHECK: Preds (1): B5
// CHECK: Succs (2): B2 B1
// CHECK: [B4 (NORETURN)]
// CHECK: 1: ~NoReturn() (Temporary object destructor)
@@ -1149,9 +1140,9 @@ int testConsistencyNestedNormalReturn(bo
// CHECK: Succs (1): B0
// CHECK: [B5]
// CHECK: 1: [B7.3] || [B6.7]
-// CHECK: T: (Temp Dtor) [B6.4]
+// CHECK: T: (Temp Dtor) [B7.3] || ...
// CHECK: Preds (2): B6 B7
-// CHECK: Succs (2): B4 B3
+// CHECK: Succs (2): B3 B4
// CHECK: [B6]
// CHECK: 1: check
// CHECK: 2: [B6.1] (ImplicitCastExpr, FunctionToPointerDecay, _Bool (*)(const class NoReturn &))
@@ -1177,6 +1168,7 @@ int testConsistencyNestedNormalReturn(bo
// CHECK: Succs (2): B7 B1
// CHECK: [B0 (EXIT)]
// CHECK: Preds (3): B1 B2 B4
+// CHECK: int testConsistencyNestedComplex(bool value)
// CHECK: [B10 (ENTRY)]
// CHECK: Succs (1): B9
// CHECK: [B1]
@@ -1191,7 +1183,7 @@ int testConsistencyNestedNormalReturn(bo
// CHECK: Succs (1): B0
// CHECK: [B3]
// CHECK: T: if [B5.1]
-// CHECK: Preds (2): B4(Unreachable) B5
+// CHECK: Preds (1): B5
// CHECK: Succs (2): B2 B1
// CHECK: [B4 (NORETURN)]
// CHECK: 1: ~NoReturn() (Temporary object destructor)
@@ -1199,9 +1191,9 @@ int testConsistencyNestedNormalReturn(bo
// CHECK: Succs (1): B0
// CHECK: [B5]
// CHECK: 1: [B8.3] || [B7.3] || [B6.7]
-// CHECK: T: (Temp Dtor) [B6.4]
+// CHECK: T: (Temp Dtor) [B8.3] || [B7.3] || ...
// CHECK: Preds (3): B6 B7 B8
-// CHECK: Succs (2): B4 B3
+// CHECK: Succs (2): B3 B4
// CHECK: [B6]
// CHECK: 1: check
// CHECK: 2: [B6.1] (ImplicitCastExpr, FunctionToPointerDecay, _Bool (*)(const class NoReturn &))
@@ -1234,6 +1226,7 @@ int testConsistencyNestedNormalReturn(bo
// CHECK: Succs (2): B8 B1
// CHECK: [B0 (EXIT)]
// CHECK: Preds (3): B1 B2 B4
+// CHECK: int testConsistencyNestedNormalReturn(bool value)
// CHECK: [B10 (ENTRY)]
// CHECK: Succs (1): B9
// CHECK: [B1]
@@ -1248,7 +1241,7 @@ int testConsistencyNestedNormalReturn(bo
// CHECK: Succs (1): B0
// CHECK: [B3]
// CHECK: T: if [B5.1]
-// CHECK: Preds (2): B4(Unreachable) B5
+// CHECK: Preds (1): B5
// CHECK: Succs (2): B2 B1
// CHECK: [B4 (NORETURN)]
// CHECK: 1: ~NoReturn() (Temporary object destructor)
@@ -1256,9 +1249,9 @@ int testConsistencyNestedNormalReturn(bo
// CHECK: Succs (1): B0
// CHECK: [B5]
// CHECK: 1: [B8.3] || [B7.2] || [B6.7]
-// CHECK: T: (Temp Dtor) [B6.4]
+// CHECK: T: (Temp Dtor) [B8.3] || [B7.2] || ...
// CHECK: Preds (3): B6 B7 B8
-// CHECK: Succs (2): B4 B3
+// CHECK: Succs (2): B3 B4
// CHECK: [B6]
// CHECK: 1: check
// CHECK: 2: [B6.1] (ImplicitCastExpr, FunctionToPointerDecay, _Bool (*)(const class NoReturn &))
Modified: cfe/trunk/test/Analysis/temporaries.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/test/Analysis/temporaries.cpp?rev=214998&r1=214997&r2=214998&view=diff
==============================================================================
--- cfe/trunk/test/Analysis/temporaries.cpp (original)
+++ cfe/trunk/test/Analysis/temporaries.cpp Wed Aug 6 17:01:54 2014
@@ -1,9 +1,8 @@
// RUN: %clang_cc1 -analyze -analyzer-checker=core,debug.ExprInspection -verify -w -std=c++03 %s
// RUN: %clang_cc1 -analyze -analyzer-checker=core,debug.ExprInspection -verify -w -std=c++11 %s
-// RUN: %clang_cc1 -analyze -analyzer-checker=core,debug.ExprInspection -DTEMPORARY_DTORS -verify -w -analyzer-config cfg-temporary-dtors=true %s -std=c++11
+// RUN: %clang_cc1 -analyze -analyzer-checker=core,debug.ExprInspection -DTEMPORARY_DTORS -verify -w -analyzer-config cfg-temporary-dtors=true %s
extern bool clang_analyzer_eval(bool);
-extern bool clang_analyzer_warnIfReached();
struct Trivial {
Trivial(int x) : value(x) {}
@@ -112,13 +111,13 @@ namespace compound_literals {
}
namespace destructors {
- struct Dtor {
- ~Dtor();
- };
- extern bool coin();
- extern bool check(const Dtor &);
-
void testPR16664andPR18159Crash() {
+ struct Dtor {
+ ~Dtor();
+ };
+ extern bool coin();
+ extern bool check(const Dtor &);
+
// Regression test: we used to assert here when tmp dtors are enabled.
// PR16664 and PR18159
if (coin() && (coin() || coin() || check(Dtor()))) {
@@ -194,7 +193,8 @@ namespace destructors {
(i == 4 || i == 4 ||
compute(i == 5 && (i == 4 || check(NoReturnDtor()))))) ||
i != 4) {
- clang_analyzer_eval(true); // no warning, unreachable code
+ // FIXME: This shouldn't cause a warning.
+ clang_analyzer_eval(true); // expected-warning{{TRUE}}
}
}
@@ -211,7 +211,8 @@ namespace destructors {
void testConsistencyNestedComplex(bool value) {
if (value) {
if (!value || !value || check(NoReturnDtor())) {
- clang_analyzer_eval(true); // no warning, unreachable code
+ // FIXME: This shouldn't cause a warning.
+ clang_analyzer_eval(true); // expected-warning{{TRUE}}
}
}
}
@@ -224,112 +225,6 @@ namespace destructors {
}
}
}
- // PR16664 and PR18159
- void testConsistencyNestedComplexMidBranch(bool value) {
- if (value) {
- if (!value || !value || check(NoReturnDtor()) || value) {
- clang_analyzer_eval(true); // no warning, unreachable code
- }
- }
- }
-
- // PR16664 and PR18159
- void testConsistencyNestedComplexNestedBranch(bool value) {
- if (value) {
- if (!value || (!value || check(NoReturnDtor()) || value)) {
- clang_analyzer_eval(true); // no warning, unreachable code
- }
- }
- }
-
- // PR16664 and PR18159
- void testConsistencyNestedVariableModification(bool value) {
- bool other = true;
- if (value) {
- if (!other || !value || (other = false) || check(NoReturnDtor()) ||
- !other) {
- clang_analyzer_eval(true); // no warning, unreachable code
- }
- }
- }
-
- void testTernaryNoReturnTrueBranch(bool value) {
- if (value) {
- bool b = value && value ? check(NoReturnDtor()) : true;
- clang_analyzer_eval(true); // no warning, unreachable code
- }
- }
- void testTernaryNoReturnFalseBranch(bool value) {
- if (value) {
- bool b = !value && !value ? true : check(NoReturnDtor());
- clang_analyzer_eval(true); // no warning, unreachable code
- }
- }
- void testTernaryIgnoreNoreturnBranch(bool value) {
- if (value) {
- bool b = !value && !value ? check(NoReturnDtor()) : true;
- clang_analyzer_eval(true); // expected-warning{{TRUE}}
- }
- }
-
- void testLoop() {
- for (int i = 0; i < 10; ++i) {
- if (i < 3 && (i >= 2 || check(NoReturnDtor()))) {
- clang_analyzer_eval(true); // no warning, unreachable code
- }
- }
- }
-
- bool testRecursiveFrames(bool isInner) {
- if (isInner ||
- (clang_analyzer_warnIfReached(), false) || // expected-warning{{REACHABLE}}
- check(NoReturnDtor()) ||
- testRecursiveFrames(true)) {
- clang_analyzer_warnIfReached(); // expected-warning{{REACHABLE}}
- }
- }
- void testRecursiveFramesStart() { testRecursiveFrames(false); }
-
- void testLambdas() {
- // This is the test we would like to write:
- // []() { check(NoReturnDtor()); } != nullptr || check(Dtor());
- // But currently the analyzer stops when it encounters a lambda:
- [] {};
- // The CFG for this now looks correct, but we still do not reach the line
- // below.
- clang_analyzer_warnIfReached(); // FIXME: Should warn.
- }
-
- void testGnuExpressionStatements(int v) {
- ({ ++v; v == 10 || check(NoReturnDtor()); v == 42; }) || v == 23;
- clang_analyzer_warnIfReached(); // expected-warning{{REACHABLE}}
-
- ({ ++v; check(NoReturnDtor()); v == 42; }) || v == 23;
- clang_analyzer_warnIfReached(); // no warning, unreachable code
- }
-
- void testGnuExpressionStatementsDestructionPoint(int v) {
- // In normal context, the temporary destructor runs at the end of the full
- // statement, thus the last statement is reached.
- (++v, check(NoReturnDtor()), v == 42),
- clang_analyzer_warnIfReached(); // expected-warning{{REACHABLE}}
-
- // GNU expression statements execute temporary destructors within the
- // blocks, thus the last statement is not reached.
- ({ ++v; check(NoReturnDtor()); v == 42; }),
- clang_analyzer_warnIfReached(); // no warning, unreachable code
- }
-
- void testMultipleTemporaries(bool value) {
- if (value) {
- // FIXME: Find a way to verify construction order.
- // ~Dtor should run before ~NoReturnDtor() because construction order is
- // guaranteed by comma operator.
- if (!value || check((NoReturnDtor(), Dtor())) || value) {
- clang_analyzer_eval(true); // no warning, unreachable code
- }
- }
- }
void testBinaryOperatorShortcut(bool value) {
if (value) {
@@ -339,52 +234,6 @@ namespace destructors {
}
}
- void testIfAtEndOfLoop() {
- int y = 0;
- while (true) {
- if (y > 0) {
- clang_analyzer_warnIfReached(); // expected-warning{{REACHABLE}}
- }
- ++y;
- // Test that the CFG gets hooked up correctly when temporary destructors
- // are handled after a statically known branch condition.
- if (true) (void)0; else (void)check(NoReturnDtor());
- }
- }
-
- void testTernaryAtEndOfLoop() {
- int y = 0;
- while (true) {
- if (y > 0) {
- clang_analyzer_warnIfReached(); // expected-warning{{REACHABLE}}
- }
- ++y;
- // Test that the CFG gets hooked up correctly when temporary destructors
- // are handled after a statically known branch condition.
- true ? (void)0 : (void)check(NoReturnDtor());
- }
- }
-
- void testNoReturnInComplexCondition() {
- check(Dtor()) &&
- (check(NoReturnDtor()) || check(NoReturnDtor())) && check(Dtor());
- clang_analyzer_warnIfReached(); // expected-warning{{REACHABLE}}
- }
-
- void testSequencingOfConditionalTempDtors(bool b) {
- b || (check(Dtor()), check(NoReturnDtor()));
- clang_analyzer_warnIfReached(); // expected-warning{{REACHABLE}}
- }
-
- void testSequencingOfConditionalTempDtors2(bool b) {
- (b || check(Dtor())), check(NoReturnDtor());
- clang_analyzer_warnIfReached(); // no warning, unreachable code
- }
-
- void testSequencingOfConditionalTempDtorsWithinBinaryOperators(bool b) {
- b || (check(Dtor()) + check(NoReturnDtor()));
- clang_analyzer_warnIfReached(); // expected-warning{{REACHABLE}}
- }
#endif // TEMPORARY_DTORS
}
More information about the cfe-commits
mailing list