Bug fix: Don't call RemoveDeadBindings more than once (can kill newly generated values to Block-Level Expressions).
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@48079 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/Analysis/GRExprEngine.cpp b/Analysis/GRExprEngine.cpp
index 3bf0151..b31f5e5 100644
--- a/Analysis/GRExprEngine.cpp
+++ b/Analysis/GRExprEngine.cpp
@@ -92,6 +92,16 @@
return StateMgr.SetRVal(St, LV, RV);
}
+ValueState* GRExprEngine::SetBlkExprRVal(ValueState* St, Expr* Ex, RVal V) {
+
+ if (!StateCleaned) {
+ St = RemoveDeadBindings(CurrentStmt, St);
+ StateCleaned = true;
+ }
+
+ return StateMgr.SetRVal(St, Ex, V, true, false);
+}
+
ValueState* GRExprEngine::MarkBranch(ValueState* St, Stmt* Terminator,
bool branchTaken) {
@@ -420,7 +430,10 @@
// dead mappings removed.
if (Dst.size() == 1 && *Dst.begin() == StmtEntryNode) {
- ValueState* St = RemoveDeadBindings(S, StmtEntryNode->getState());
+ ValueState* St =
+ StateCleaned ? StmtEntryNode->getState() :
+ RemoveDeadBindings(S, StmtEntryNode->getState());
+
builder.generateNode(S, St, StmtEntryNode);
}
@@ -442,7 +455,9 @@
// it to the block-level expression.
ValueState* St = Pred->getState();
- Nodify(Dst, D, Pred, SetRVal(St, D, GetRVal(St, D)));
+ RVal X = RVal::MakeVal(BasicVals, D);
+ RVal Y = isa<lval::DeclVal>(X) ? GetRVal(St, cast<lval::DeclVal>(X)) : X;
+ Nodify(Dst, D, Pred, SetBlkExprRVal(St, D, Y));
}
void GRExprEngine::VisitCall(CallExpr* CE, NodeTy* Pred,
@@ -1709,9 +1724,11 @@
Out << S->getStmtClassName() << ' ' << (void*) S << ' ';
S->printPretty(Out);
- Out << "\\lline="
- << GraphPrintSourceManager->getLineNumber(SLoc) << " col="
- << GraphPrintSourceManager->getColumnNumber(SLoc) << "\\l";
+ if (SLoc.isFileID()) {
+ Out << "\\lline="
+ << GraphPrintSourceManager->getLineNumber(SLoc) << " col="
+ << GraphPrintSourceManager->getColumnNumber(SLoc) << "\\l";
+ }
if (GraphPrintCheckerState->isImplicitNullDeref(N))
Out << "\\|Implicit-Null Dereference.\\l";
@@ -1750,9 +1767,11 @@
E.getSrc()->printTerminator(Out);
- Out << "\\lline="
- << GraphPrintSourceManager->getLineNumber(SLoc) << " col="
- << GraphPrintSourceManager->getColumnNumber(SLoc);
+ if (SLoc.isFileID()) {
+ Out << "\\lline="
+ << GraphPrintSourceManager->getLineNumber(SLoc) << " col="
+ << GraphPrintSourceManager->getColumnNumber(SLoc);
+ }
if (isa<SwitchStmt>(T)) {
Stmt* Label = E.getDst()->getLabel();
diff --git a/Analysis/RValues.cpp b/Analysis/RValues.cpp
index 9d5bd68..a4b4649 100644
--- a/Analysis/RValues.cpp
+++ b/Analysis/RValues.cpp
@@ -238,6 +238,36 @@
LVal LVal::MakeVal(AddrLabelExpr* E) { return lval::GotoLabel(E->getLabel()); }
//===----------------------------------------------------------------------===//
+// Utility methods for constructing RVals (both NonLVals and LVals).
+//===----------------------------------------------------------------------===//
+
+RVal RVal::MakeVal(BasicValueFactory& BasicVals, DeclRefExpr* E) {
+
+ ValueDecl* D = cast<DeclRefExpr>(E)->getDecl();
+
+ if (VarDecl* VD = dyn_cast<VarDecl>(D)) {
+ return lval::DeclVal(VD);
+ }
+ else if (EnumConstantDecl* ED = dyn_cast<EnumConstantDecl>(D)) {
+
+ // FIXME: Do we need to cache a copy of this enum, since it
+ // already has persistent storage? We do this because we
+ // are comparing states using pointer equality. Perhaps there is
+ // a better way, since APInts are fairly lightweight.
+
+ return nonlval::ConcreteInt(BasicVals.getValue(ED->getInitVal()));
+ }
+ else if (FunctionDecl* FD = dyn_cast<FunctionDecl>(D)) {
+ return lval::FuncVal(FD);
+ }
+
+ assert (false &&
+ "ValueDecl support for this ValueDecl not implemented.");
+
+ return UnknownVal();
+}
+
+//===----------------------------------------------------------------------===//
// Pretty-Printing.
//===----------------------------------------------------------------------===//
diff --git a/Analysis/ValueState.cpp b/Analysis/ValueState.cpp
index 4eb2a5e..4b097ee 100644
--- a/Analysis/ValueState.cpp
+++ b/Analysis/ValueState.cpp
@@ -232,28 +232,14 @@
// within the referenced variables.
case Stmt::DeclRefExprClass: {
-
- ValueDecl* D = cast<DeclRefExpr>(E)->getDecl();
-
- if (VarDecl* VD = dyn_cast<VarDecl>(D)) {
- return GetRVal(St, lval::DeclVal(VD));
- }
- else if (EnumConstantDecl* ED = dyn_cast<EnumConstantDecl>(D)) {
-
- // FIXME: Do we need to cache a copy of this enum, since it
- // already has persistent storage? We do this because we
- // are comparing states using pointer equality. Perhaps there is
- // a better way, since APInts are fairly lightweight.
- return nonlval::ConcreteInt(BasicVals.getValue(ED->getInitVal()));
- }
- else if (FunctionDecl* FD = dyn_cast<FunctionDecl>(D))
- return lval::FuncVal(FD);
+ // Check if this expression is a block-level expression. If so,
+ // return its value.
+ ValueState::ExprBindingsTy::TreeTy* T=St->BlockExprBindings.SlimFind(E);
+ if (T) return T->getValue().second;
- assert (false &&
- "ValueDecl support for this ValueDecl not implemented.");
-
- return UnknownVal();
+ RVal X = RVal::MakeVal(BasicVals, cast<DeclRefExpr>(E));
+ return isa<lval::DeclVal>(X) ? GetRVal(St, cast<lval::DeclVal>(X)) : X;
}
case Stmt::CharacterLiteralClass: {