Static analyzer: Remove a bunch of outdated SymbolData objects and
their associated APIs. We no longer need separate SymbolData objects
for fields, variables, etc. Instead, we now associated symbols with
the "rvalue" of a MemRegion (i.e., the value stored at that region).
Now we only have two kinds of SymbolData objects: SymbolRegionRValue
and SymbolConjured.
This cleanup also makes the distinction between a SymbolicRegion and a
symbolic value that is a location much clearer. A SymbolicRegion
represents a chunk of symbolic memory, while a symbolic location is
just a "pointer" with different possible values. Without any specific
knowledge, a symbolic location resolves (i.e., via a dereference) to a
SymbolicRegion. In the future, when we do better alias reasoning, a
symbolic location can become an alias for another location, thus
merging the constraints on the referred SymbolicRegion with the other
region.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@62769 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/lib/Analysis/BasicConstraintManager.cpp b/lib/Analysis/BasicConstraintManager.cpp
index 450c38f..c875691 100644
--- a/lib/Analysis/BasicConstraintManager.cpp
+++ b/lib/Analysis/BasicConstraintManager.cpp
@@ -204,13 +204,12 @@
case nonloc::SymbolValKind: {
nonloc::SymbolVal& SV = cast<nonloc::SymbolVal>(Cond);
SymbolRef sym = SV.getSymbol();
-
+ QualType T = SymMgr.getType(sym);
+
if (Assumption)
- return AssumeSymNE(St, sym, BasicVals.getValue(0, SymMgr.getType(sym)),
- isFeasible);
+ return AssumeSymNE(St, sym, BasicVals.getValue(0, T), isFeasible);
else
- return AssumeSymEQ(St, sym, BasicVals.getValue(0, SymMgr.getType(sym)),
- isFeasible);
+ return AssumeSymEQ(St, sym, BasicVals.getValue(0, T), isFeasible);
}
case nonloc::SymIntConstraintValKind:
diff --git a/lib/Analysis/BasicStore.cpp b/lib/Analysis/BasicStore.cpp
index 7315ec7..a36a239 100644
--- a/lib/Analysis/BasicStore.cpp
+++ b/lib/Analysis/BasicStore.cpp
@@ -454,12 +454,13 @@
if (Loc::IsLocType(T) || T->isIntegerType()) {
// Initialize globals and parameters to symbolic values.
// Initialize local variables to undefined.
+ const MemRegion *R = StateMgr.getRegion(VD);
SVal X = (VD->hasGlobalStorage() || isa<ParmVarDecl>(VD) ||
isa<ImplicitParamDecl>(VD))
- ? SVal::GetSymbolValue(StateMgr.getSymbolManager(), VD)
- : UndefinedVal();
+ ? SVal::GetRValueSymbolVal(StateMgr.getSymbolManager(), R)
+ : UndefinedVal();
- St = BindInternal(St, Loc::MakeVal(MRMgr.getVarRegion(VD)), X);
+ St = BindInternal(St, Loc::MakeVal(R), X);
}
}
}
diff --git a/lib/Analysis/RegionStore.cpp b/lib/Analysis/RegionStore.cpp
index 3faae70..5a13a1d 100644
--- a/lib/Analysis/RegionStore.cpp
+++ b/lib/Analysis/RegionStore.cpp
@@ -552,8 +552,7 @@
// We treat function parameters as symbolic values.
if (const VarRegion* VR = dyn_cast<VarRegion>(R))
if (isa<ParmVarDecl>(VR->getDecl()))
- return SVal::MakeSymbolValue(getSymbolManager(), VR,
- VR->getRValueType(getContext()));
+ return SVal::GetRValueSymbolVal(getSymbolManager(), VR);
if (MRMgr.onStack(R) || MRMgr.onHeap(R)) {
// All stack variables are considered to have undefined values
@@ -564,8 +563,7 @@
}
// All other values are symbolic.
- return SVal::MakeSymbolValue(getSymbolManager(), R,
- cast<TypedRegion>(R)->getRValueType(getContext()));
+ return SVal::GetRValueSymbolVal(getSymbolManager(), R);
// FIXME: consider default values for elements and fields.
}
@@ -603,8 +601,7 @@
if (MRMgr.onStack(FR) || MRMgr.onHeap(FR))
FieldValue = UndefinedVal();
else
- FieldValue = SVal::MakeSymbolValue(getSymbolManager(), FR,
- FR->getRValueType(getContext()));
+ FieldValue = SVal::GetRValueSymbolVal(getSymbolManager(), FR);
}
StructVal = getBasicVals().consVals(FieldValue, StructVal);
diff --git a/lib/Analysis/SVals.cpp b/lib/Analysis/SVals.cpp
index 6cc5e91..6847764 100644
--- a/lib/Analysis/SVals.cpp
+++ b/lib/Analysis/SVals.cpp
@@ -286,38 +286,14 @@
return nonloc::CompoundVal(BasicVals.getCompoundValData(T, Vals));
}
-SVal SVal::MakeSymbolValue(SymbolManager& SymMgr, const MemRegion* R,
- QualType T) {
- if (Loc::IsLocType(T))
- return Loc::MakeVal(SymMgr.getSymbol(R));
- else
- return NonLoc::MakeVal(SymMgr.getSymbol(R));
-}
-
-SVal SVal::GetSymbolValue(SymbolManager& SymMgr, VarDecl* D) {
-
- QualType T = D->getType();
+SVal SVal::GetRValueSymbolVal(SymbolManager& SymMgr, const MemRegion* R) {
+ SymbolRef sym = SymMgr.getRegionRValueSymbol(R);
+
+ if (const TypedRegion* TR = cast<TypedRegion>(R))
+ if (Loc::IsLocType(TR->getRValueType(SymMgr.getContext())))
+ return Loc::MakeVal(sym);
- if (Loc::IsLocType(T))
- return loc::SymbolVal(SymMgr.getSymbol(D));
-
- return nonloc::SymbolVal(SymMgr.getSymbol(D));
-}
-
-SVal SVal::getSymbolValue(SymbolManager& SymMgr, const MemRegion* R,
- const llvm::APSInt* Idx, QualType T) {
- if (Loc::IsLocType(T))
- return loc::SymbolVal(SymMgr.getElementSymbol(R, Idx));
- else
- return nonloc::SymbolVal(SymMgr.getElementSymbol(R, Idx));
-}
-
-SVal SVal::getSymbolValue(SymbolManager& SymMgr, const MemRegion* R,
- const FieldDecl* FD, QualType T) {
- if (Loc::IsLocType(T))
- return loc::SymbolVal(SymMgr.getFieldSymbol(R, FD));
- else
- return nonloc::SymbolVal(SymMgr.getFieldSymbol(R, FD));
+ return NonLoc::MakeVal(sym);
}
nonloc::LocAsInteger nonloc::LocAsInteger::Make(BasicValueFactory& Vals, Loc V,
diff --git a/lib/Analysis/SymbolManager.cpp b/lib/Analysis/SymbolManager.cpp
index d0099e1..54ba7b1 100644
--- a/lib/Analysis/SymbolManager.cpp
+++ b/lib/Analysis/SymbolManager.cpp
@@ -22,99 +22,23 @@
os << getNumber();
}
-SymbolRef SymbolManager::getSymbol(const MemRegion* R) {
- switch (R->getKind()) {
- default:
- assert(0 && "unprocessed region");
- case MemRegion::VarRegionKind:
- return getSymbol(cast<VarRegion>(R)->getDecl());
-
- case MemRegion::ElementRegionKind: {
- const ElementRegion* ER = cast<ElementRegion>(R);
- const llvm::APSInt& Idx =
- cast<nonloc::ConcreteInt>(ER->getIndex()).getValue();
- return getElementSymbol(ER->getSuperRegion(), &Idx);
- }
-
- case MemRegion::FieldRegionKind: {
- const FieldRegion* FR = cast<FieldRegion>(R);
- return getFieldSymbol(FR->getSuperRegion(), FR->getDecl());
- }
- }
-}
-
-SymbolRef SymbolManager::getSymbol(const VarDecl* D) {
-
- assert (isa<ParmVarDecl>(D) || isa<ImplicitParamDecl>(D) ||
- D->hasGlobalStorage());
-
+SymbolRef SymbolManager::getRegionRValueSymbol(const MemRegion* R) {
llvm::FoldingSetNodeID profile;
-
- const ParmVarDecl* PD = dyn_cast<ParmVarDecl>(D);
-
- if (PD)
- SymbolDataParmVar::Profile(profile, PD);
- else
- SymbolDataGlobalVar::Profile(profile, D);
-
- void* InsertPos;
-
- SymbolData* SD = DataSet.FindNodeOrInsertPos(profile, InsertPos);
- if (SD)
- return SD->getSymbol();
+ SymbolRegionRValue::Profile(profile, R);
+ void* InsertPos;
+ SymbolData* SD = DataSet.FindNodeOrInsertPos(profile, InsertPos);
+ if (SD) return SD->getSymbol();
- if (PD) {
- SD = (SymbolData*) BPAlloc.Allocate<SymbolDataParmVar>();
- new (SD) SymbolDataParmVar(SymbolCounter, PD);
- }
- else {
- SD = (SymbolData*) BPAlloc.Allocate<SymbolDataGlobalVar>();
- new (SD) SymbolDataGlobalVar(SymbolCounter, D);
- }
-
+ SD = (SymbolData*) BPAlloc.Allocate<SymbolRegionRValue>();
+ new (SD) SymbolRegionRValue(SymbolCounter, R);
DataSet.InsertNode(SD, InsertPos);
-
- DataMap[SymbolCounter] = SD;
+ DataMap[SymbolCounter] = SD;
return SymbolCounter++;
-}
-SymbolRef SymbolManager::getElementSymbol(const MemRegion* R,
- const llvm::APSInt* Idx){
- llvm::FoldingSetNodeID ID;
- SymbolDataElement::Profile(ID, R, Idx);
- void* InsertPos;
- SymbolData* SD = DataSet.FindNodeOrInsertPos(ID, InsertPos);
-
- if (SD)
- return SD->getSymbol();
-
- SD = (SymbolData*) BPAlloc.Allocate<SymbolDataElement>();
- new (SD) SymbolDataElement(SymbolCounter, R, Idx);
-
- DataSet.InsertNode(SD, InsertPos);
- DataMap[SymbolCounter] = SD;
- return SymbolCounter++;
}
-SymbolRef SymbolManager::getFieldSymbol(const MemRegion* R, const FieldDecl* D) {
- llvm::FoldingSetNodeID ID;
- SymbolDataField::Profile(ID, R, D);
- void* InsertPos;
- SymbolData* SD = DataSet.FindNodeOrInsertPos(ID, InsertPos);
-
- if (SD)
- return SD->getSymbol();
-
- SD = (SymbolData*) BPAlloc.Allocate<SymbolDataField>();
- new (SD) SymbolDataField(SymbolCounter, R, D);
-
- DataSet.InsertNode(SD, InsertPos);
- DataMap[SymbolCounter] = SD;
- return SymbolCounter++;
-}
-
-SymbolRef SymbolManager::getConjuredSymbol(Stmt* E, QualType T, unsigned Count) {
+SymbolRef SymbolManager::getConjuredSymbol(Stmt* E, QualType T, unsigned Count){
llvm::FoldingSetNodeID profile;
SymbolConjured::Profile(profile, E, T, Count);
@@ -141,20 +65,15 @@
}
-QualType SymbolData::getType(const SymbolManager& SymMgr) const {
- switch (getKind()) {
- default:
- assert (false && "getType() not implemented for this symbol.");
-
- case ParmKind:
- return cast<SymbolDataParmVar>(this)->getDecl()->getType();
+QualType SymbolConjured::getType(ASTContext&) const {
+ return T;
+}
- case GlobalKind:
- return cast<SymbolDataGlobalVar>(this)->getDecl()->getType();
-
- case ConjuredKind:
- return cast<SymbolConjured>(this)->getType();
- }
+QualType SymbolRegionRValue::getType(ASTContext& C) const {
+ if (const TypedRegion* TR = dyn_cast<TypedRegion>(R))
+ return TR->getRValueType(C);
+
+ return QualType();
}
SymbolManager::~SymbolManager() {}
@@ -172,7 +91,7 @@
return true;
}
-bool SymbolReaper::isLive(SymbolRef sym) {
+bool SymbolReaper::isLive(SymbolRef sym) {
return TheLiving.contains(sym);
}