summaryrefslogtreecommitdiffstats
path: root/clang/lib
diff options
context:
space:
mode:
Diffstat (limited to 'clang/lib')
-rw-r--r--clang/lib/Analysis/BasicConstraintManager.cpp64
-rw-r--r--clang/lib/Analysis/BasicObjCFoundationChecks.cpp22
-rw-r--r--clang/lib/Analysis/BasicStore.cpp122
-rw-r--r--clang/lib/Analysis/BasicValueFactory.cpp48
-rw-r--r--clang/lib/Analysis/BugReporter.cpp18
-rw-r--r--clang/lib/Analysis/CFRefCount.cpp106
-rw-r--r--clang/lib/Analysis/CheckNSError.cpp10
-rw-r--r--clang/lib/Analysis/Environment.cpp30
-rw-r--r--clang/lib/Analysis/GRExprEngine.cpp258
-rw-r--r--clang/lib/Analysis/GRExprEngineInternalChecks.cpp12
-rw-r--r--clang/lib/Analysis/GRSimpleVals.cpp198
-rw-r--r--clang/lib/Analysis/GRSimpleVals.h28
-rw-r--r--clang/lib/Analysis/GRState.cpp20
-rw-r--r--clang/lib/Analysis/GRTransferFuncs.cpp8
-rw-r--r--clang/lib/Analysis/RValues.cpp244
-rw-r--r--clang/lib/Analysis/RegionStore.cpp18
16 files changed, 603 insertions, 603 deletions
diff --git a/clang/lib/Analysis/BasicConstraintManager.cpp b/clang/lib/Analysis/BasicConstraintManager.cpp
index 8d391bbb58c..aab1f5e7eb1 100644
--- a/clang/lib/Analysis/BasicConstraintManager.cpp
+++ b/clang/lib/Analysis/BasicConstraintManager.cpp
@@ -33,19 +33,19 @@ class VISIBILITY_HIDDEN BasicConstraintManager : public ConstraintManager {
public:
BasicConstraintManager(GRStateManager& statemgr) : StateMgr(statemgr) {}
- virtual const GRState* Assume(const GRState* St, RVal Cond,
+ virtual const GRState* Assume(const GRState* St, SVal Cond,
bool Assumption, bool& isFeasible);
- const GRState* Assume(const GRState* St, LVal Cond, bool Assumption,
+ const GRState* Assume(const GRState* St, Loc Cond, bool Assumption,
bool& isFeasible);
- const GRState* AssumeAux(const GRState* St, LVal Cond,bool Assumption,
+ const GRState* AssumeAux(const GRState* St, Loc Cond,bool Assumption,
bool& isFeasible);
- const GRState* Assume(const GRState* St, NonLVal Cond, bool Assumption,
+ const GRState* Assume(const GRState* St, NonLoc Cond, bool Assumption,
bool& isFeasible);
- const GRState* AssumeAux(const GRState* St, NonLVal Cond, bool Assumption,
+ const GRState* AssumeAux(const GRState* St, NonLoc Cond, bool Assumption,
bool& isFeasible);
const GRState* AssumeSymInt(const GRState* St, bool Assumption,
@@ -92,52 +92,52 @@ ConstraintManager* clang::CreateBasicConstraintManager(GRStateManager& StateMgr)
return new BasicConstraintManager(StateMgr);
}
-const GRState* BasicConstraintManager::Assume(const GRState* St, RVal Cond,
+const GRState* BasicConstraintManager::Assume(const GRState* St, SVal Cond,
bool Assumption, bool& isFeasible) {
if (Cond.isUnknown()) {
isFeasible = true;
return St;
}
- if (isa<NonLVal>(Cond))
- return Assume(St, cast<NonLVal>(Cond), Assumption, isFeasible);
+ if (isa<NonLoc>(Cond))
+ return Assume(St, cast<NonLoc>(Cond), Assumption, isFeasible);
else
- return Assume(St, cast<LVal>(Cond), Assumption, isFeasible);
+ return Assume(St, cast<Loc>(Cond), Assumption, isFeasible);
}
-const GRState* BasicConstraintManager::Assume(const GRState* St, LVal Cond,
+const GRState* BasicConstraintManager::Assume(const GRState* St, Loc Cond,
bool Assumption, bool& isFeasible) {
St = AssumeAux(St, Cond, Assumption, isFeasible);
// TF->EvalAssume(*this, St, Cond, Assumption, isFeasible)
return St;
}
-const GRState* BasicConstraintManager::AssumeAux(const GRState* St, LVal Cond,
+const GRState* BasicConstraintManager::AssumeAux(const GRState* St, Loc Cond,
bool Assumption, bool& isFeasible) {
BasicValueFactory& BasicVals = StateMgr.getBasicVals();
switch (Cond.getSubKind()) {
default:
- assert (false && "'Assume' not implemented for this LVal.");
+ assert (false && "'Assume' not implemented for this Loc.");
return St;
- case lval::SymbolValKind:
+ case loc::SymbolValKind:
if (Assumption)
- return AssumeSymNE(St, cast<lval::SymbolVal>(Cond).getSymbol(),
+ return AssumeSymNE(St, cast<loc::SymbolVal>(Cond).getSymbol(),
BasicVals.getZeroWithPtrWidth(), isFeasible);
else
- return AssumeSymEQ(St, cast<lval::SymbolVal>(Cond).getSymbol(),
+ return AssumeSymEQ(St, cast<loc::SymbolVal>(Cond).getSymbol(),
BasicVals.getZeroWithPtrWidth(), isFeasible);
- case lval::MemRegionKind:
- case lval::FuncValKind:
- case lval::GotoLabelKind:
- case lval::StringLiteralValKind:
+ case loc::MemRegionKind:
+ case loc::FuncValKind:
+ case loc::GotoLabelKind:
+ case loc::StringLiteralValKind:
isFeasible = Assumption;
return St;
- case lval::ConcreteIntKind: {
- bool b = cast<lval::ConcreteInt>(Cond).getValue() != 0;
+ case loc::ConcreteIntKind: {
+ bool b = cast<loc::ConcreteInt>(Cond).getValue() != 0;
isFeasible = b ? Assumption : !Assumption;
return St;
}
@@ -145,7 +145,7 @@ const GRState* BasicConstraintManager::AssumeAux(const GRState* St, LVal Cond,
}
const GRState*
-BasicConstraintManager::Assume(const GRState* St, NonLVal Cond, bool Assumption,
+BasicConstraintManager::Assume(const GRState* St, NonLoc Cond, bool Assumption,
bool& isFeasible) {
St = AssumeAux(St, Cond, Assumption, isFeasible);
// TF->EvalAssume() does nothing now.
@@ -153,17 +153,17 @@ BasicConstraintManager::Assume(const GRState* St, NonLVal Cond, bool Assumption,
}
const GRState*
-BasicConstraintManager::AssumeAux(const GRState* St,NonLVal Cond,
+BasicConstraintManager::AssumeAux(const GRState* St,NonLoc Cond,
bool Assumption, bool& isFeasible) {
BasicValueFactory& BasicVals = StateMgr.getBasicVals();
SymbolManager& SymMgr = StateMgr.getSymbolManager();
switch (Cond.getSubKind()) {
default:
- assert(false && "'Assume' not implemented for this NonLVal");
+ assert(false && "'Assume' not implemented for this NonLoc");
- case nonlval::SymbolValKind: {
- nonlval::SymbolVal& SV = cast<nonlval::SymbolVal>(Cond);
+ case nonloc::SymbolValKind: {
+ nonloc::SymbolVal& SV = cast<nonloc::SymbolVal>(Cond);
SymbolID sym = SV.getSymbol();
if (Assumption)
@@ -174,20 +174,20 @@ BasicConstraintManager::AssumeAux(const GRState* St,NonLVal Cond,
isFeasible);
}
- case nonlval::SymIntConstraintValKind:
+ case nonloc::SymIntConstraintValKind:
return
AssumeSymInt(St, Assumption,
- cast<nonlval::SymIntConstraintVal>(Cond).getConstraint(),
+ cast<nonloc::SymIntConstraintVal>(Cond).getConstraint(),
isFeasible);
- case nonlval::ConcreteIntKind: {
- bool b = cast<nonlval::ConcreteInt>(Cond).getValue() != 0;
+ case nonloc::ConcreteIntKind: {
+ bool b = cast<nonloc::ConcreteInt>(Cond).getValue() != 0;
isFeasible = b ? Assumption : !Assumption;
return St;
}
- case nonlval::LValAsIntegerKind:
- return AssumeAux(St, cast<nonlval::LValAsInteger>(Cond).getLVal(),
+ case nonloc::LocAsIntegerKind:
+ return AssumeAux(St, cast<nonloc::LocAsInteger>(Cond).getLoc(),
Assumption, isFeasible);
} // end switch
}
diff --git a/clang/lib/Analysis/BasicObjCFoundationChecks.cpp b/clang/lib/Analysis/BasicObjCFoundationChecks.cpp
index b3f534d1af0..8e322189e62 100644
--- a/clang/lib/Analysis/BasicObjCFoundationChecks.cpp
+++ b/clang/lib/Analysis/BasicObjCFoundationChecks.cpp
@@ -118,7 +118,7 @@ class VISIBILITY_HIDDEN BasicObjCFoundationChecks : public GRSimpleAPICheck {
typedef std::vector<BugReport*> ErrorsTy;
ErrorsTy Errors;
- RVal GetRVal(const GRState* St, Expr* E) { return VMgr->GetRVal(St, E); }
+ SVal GetSVal(const GRState* St, Expr* E) { return VMgr->GetSVal(St, E); }
bool isNSString(ObjCInterfaceType* T, const char* suffix);
bool AuditNSString(NodeTy* N, ObjCMessageExpr* ME);
@@ -193,8 +193,8 @@ bool BasicObjCFoundationChecks::Audit(ExplodedNode<GRState>* N,
return false;
}
-static inline bool isNil(RVal X) {
- return isa<lval::ConcreteInt>(X);
+static inline bool isNil(SVal X) {
+ return isa<loc::ConcreteInt>(X);
}
//===----------------------------------------------------------------------===//
@@ -214,7 +214,7 @@ bool BasicObjCFoundationChecks::CheckNilArg(NodeTy* N, unsigned Arg) {
Expr * E = ME->getArg(Arg);
- if (isNil(GetRVal(N->getState(), E))) {
+ if (isNil(GetSVal(N->getState(), E))) {
WarnNilArg(N, ME, Arg);
return true;
}
@@ -350,7 +350,7 @@ class VISIBILITY_HIDDEN AuditCFNumberCreate : public GRSimpleAPICheck {
IdentifierInfo* II;
GRStateManager* VMgr;
- RVal GetRVal(const GRState* St, Expr* E) { return VMgr->GetRVal(St, E); }
+ SVal GetSVal(const GRState* St, Expr* E) { return VMgr->GetSVal(St, E); }
public:
@@ -468,18 +468,18 @@ static const char* GetCFNumberTypeStr(uint64_t i) {
bool AuditCFNumberCreate::Audit(ExplodedNode<GRState>* N,GRStateManager&){
CallExpr* CE = cast<CallExpr>(cast<PostStmt>(N->getLocation()).getStmt());
Expr* Callee = CE->getCallee();
- RVal CallV = GetRVal(N->getState(), Callee);
- lval::FuncVal* FuncV = dyn_cast<lval::FuncVal>(&CallV);
+ SVal CallV = GetSVal(N->getState(), Callee);
+ loc::FuncVal* FuncV = dyn_cast<loc::FuncVal>(&CallV);
if (!FuncV || FuncV->getDecl()->getIdentifier() != II || CE->getNumArgs()!=3)
return false;
// Get the value of the "theType" argument.
- RVal TheTypeVal = GetRVal(N->getState(), CE->getArg(1));
+ SVal TheTypeVal = GetSVal(N->getState(), CE->getArg(1));
// FIXME: We really should allow ranges of valid theType values, and
// bifurcate the state appropriately.
- nonlval::ConcreteInt* V = dyn_cast<nonlval::ConcreteInt>(&TheTypeVal);
+ nonloc::ConcreteInt* V = dyn_cast<nonloc::ConcreteInt>(&TheTypeVal);
if (!V)
return false;
@@ -494,11 +494,11 @@ bool AuditCFNumberCreate::Audit(ExplodedNode<GRState>* N,GRStateManager&){
// Look at the value of the integer being passed by reference. Essentially
// we want to catch cases where the value passed in is not equal to the
// size of the type being created.
- RVal TheValueExpr = GetRVal(N->getState(), CE->getArg(2));
+ SVal TheValueExpr = GetSVal(N->getState(), CE->getArg(2));
// FIXME: Eventually we should handle arbitrary locations. We can do this
// by having an enhanced memory model that does low-level typing.
- lval::MemRegionVal* LV = dyn_cast<lval::MemRegionVal>(&TheValueExpr);
+ loc::MemRegionVal* LV = dyn_cast<loc::MemRegionVal>(&TheValueExpr);
if (!LV)
return false;
diff --git a/clang/lib/Analysis/BasicStore.cpp b/clang/lib/Analysis/BasicStore.cpp
index 9d8a9acda50..7998ef4613f 100644
--- a/clang/lib/Analysis/BasicStore.cpp
+++ b/clang/lib/Analysis/BasicStore.cpp
@@ -19,7 +19,7 @@
using namespace clang;
-typedef llvm::ImmutableMap<const VarDecl*,RVal> VarBindingsTy;
+typedef llvm::ImmutableMap<const VarDecl*,SVal> VarBindingsTy;
namespace {
@@ -34,23 +34,23 @@ public:
virtual ~BasicStoreManager() {}
- virtual RVal GetRVal(Store St, LVal LV, QualType T);
- virtual Store SetRVal(Store St, LVal LV, RVal V);
- virtual Store Remove(Store St, LVal LV);
+ virtual SVal GetSVal(Store St, Loc LV, QualType T);
+ virtual Store SetSVal(Store St, Loc LV, SVal V);
+ virtual Store Remove(Store St, Loc LV);
virtual Store getInitialStore();
virtual MemRegionManager& getRegionManager() { return MRMgr; }
// FIXME: Investigate what is using this. This method should be removed.
- virtual LVal getLVal(const VarDecl* VD) {
- return lval::MemRegionVal(MRMgr.getVarRegion(VD));
+ virtual Loc getLoc(const VarDecl* VD) {
+ return loc::MemRegionVal(MRMgr.getVarRegion(VD));
}
- RVal getLValueVar(const GRState* St, const VarDecl* VD);
- RVal getLValueIvar(const GRState* St, const ObjCIvarDecl* D, RVal Base);
- RVal getLValueField(const GRState* St, const FieldDecl* D, RVal Base);
- RVal getLValueElement(const GRState* St, RVal Base, RVal Offset);
+ SVal getLValueVar(const GRState* St, const VarDecl* VD);
+ SVal getLValueIvar(const GRState* St, const ObjCIvarDecl* D, SVal Base);
+ SVal getLValueField(const GRState* St, const FieldDecl* D, SVal Base);
+ SVal getLValueElement(const GRState* St, SVal Base, SVal Offset);
virtual Store
RemoveDeadBindings(Store store, Stmt* Loc, const LiveVariables& Live,
@@ -61,7 +61,7 @@ public:
virtual Store AddDecl(Store store,
const VarDecl* VD, Expr* Ex,
- RVal InitVal = UndefinedVal(), unsigned Count = 0);
+ SVal InitVal = UndefinedVal(), unsigned Count = 0);
static inline VarBindingsTy GetVarBindings(Store store) {
return VarBindingsTy(static_cast<const VarBindingsTy::TreeTy*>(store));
@@ -78,27 +78,27 @@ public:
StoreManager* clang::CreateBasicStoreManager(GRStateManager& StMgr) {
return new BasicStoreManager(StMgr);
}
-RVal BasicStoreManager::getLValueVar(const GRState* St, const VarDecl* VD) {
- return lval::MemRegionVal(MRMgr.getVarRegion(VD));
+SVal BasicStoreManager::getLValueVar(const GRState* St, const VarDecl* VD) {
+ return loc::MemRegionVal(MRMgr.getVarRegion(VD));
}
-RVal BasicStoreManager::getLValueIvar(const GRState* St, const ObjCIvarDecl* D,
- RVal Base) {
+SVal BasicStoreManager::getLValueIvar(const GRState* St, const ObjCIvarDecl* D,
+ SVal Base) {
return UnknownVal();
}
-RVal BasicStoreManager::getLValueField(const GRState* St, const FieldDecl* D,
- RVal Base) {
+SVal BasicStoreManager::getLValueField(const GRState* St, const FieldDecl* D,
+ SVal Base) {
return UnknownVal();
}
-RVal BasicStoreManager::getLValueElement(const GRState* St, RVal Base,
- RVal Offset) {
+SVal BasicStoreManager::getLValueElement(const GRState* St, SVal Base,
+ SVal Offset) {
return UnknownVal();
}
-RVal BasicStoreManager::GetRVal(Store St, LVal LV, QualType T) {
+SVal BasicStoreManager::GetSVal(Store St, Loc LV, QualType T) {
if (isa<UnknownVal>(LV))
return UnknownVal();
@@ -107,9 +107,9 @@ RVal BasicStoreManager::GetRVal(Store St, LVal LV, QualType T) {
switch (LV.getSubKind()) {
- case lval::MemRegionKind: {
+ case loc::MemRegionKind: {
VarRegion* R =
- dyn_cast<VarRegion>(cast<lval::MemRegionVal>(LV).getRegion());
+ dyn_cast<VarRegion>(cast<loc::MemRegionVal>(LV).getRegion());
if (!R)
return UnknownVal();
@@ -119,34 +119,34 @@ RVal BasicStoreManager::GetRVal(Store St, LVal LV, QualType T) {
return T ? *T : UnknownVal();
}
- case lval::SymbolValKind:
+ case loc::SymbolValKind:
return UnknownVal();
- case lval::ConcreteIntKind:
- // Some clients may call GetRVal with such an option simply because
- // they are doing a quick scan through their LVals (potentially to
+ case loc::ConcreteIntKind:
+ // Some clients may call GetSVal with such an option simply because
+ // they are doing a quick scan through their Locs (potentially to
// invalidate their bindings). Just return Undefined.
return UndefinedVal();
- case lval::FuncValKind:
+ case loc::FuncValKind:
return LV;
- case lval::StringLiteralValKind:
+ case loc::StringLiteralValKind:
// FIXME: Implement better support for fetching characters from strings.
return UnknownVal();
default:
- assert (false && "Invalid LVal.");
+ assert (false && "Invalid Loc.");
break;
}
return UnknownVal();
}
-Store BasicStoreManager::SetRVal(Store store, LVal LV, RVal V) {
+Store BasicStoreManager::SetSVal(Store store, Loc LV, SVal V) {
switch (LV.getSubKind()) {
- case lval::MemRegionKind: {
+ case loc::MemRegionKind: {
VarRegion* R =
- dyn_cast<VarRegion>(cast<lval::MemRegionVal>(LV).getRegion());
+ dyn_cast<VarRegion>(cast<loc::MemRegionVal>(LV).getRegion());
if (!R)
return store;
@@ -157,16 +157,16 @@ Store BasicStoreManager::SetRVal(Store store, LVal LV, RVal V) {
: VBFactory.Add(B, R->getDecl(), V).getRoot();
}
default:
- assert ("SetRVal for given LVal type not yet implemented.");
+ assert ("SetSVal for given Loc type not yet implemented.");
return store;
}
}
-Store BasicStoreManager::Remove(Store store, LVal LV) {
+Store BasicStoreManager::Remove(Store store, Loc LV) {
switch (LV.getSubKind()) {
- case lval::MemRegionKind: {
+ case loc::MemRegionKind: {
VarRegion* R =
- dyn_cast<VarRegion>(cast<lval::MemRegionVal>(LV).getRegion());
+ dyn_cast<VarRegion>(cast<loc::MemRegionVal>(LV).getRegion());
if (!R)
return store;
@@ -175,7 +175,7 @@ Store BasicStoreManager::Remove(Store store, LVal LV) {
return VBFactory.Remove(B,R->getDecl()).getRoot();
}
default:
- assert ("Remove for given LVal type not yet implemented.");
+ assert ("Remove for given Loc type not yet implemented.");
return store;
}
}
@@ -187,13 +187,13 @@ BasicStoreManager::RemoveDeadBindings(Store store, Stmt* Loc,
LiveSymbolsTy& LSymbols, DeadSymbolsTy& DSymbols) {
VarBindingsTy B = GetVarBindings(store);
- typedef RVal::symbol_iterator symbol_iterator;
+ typedef SVal::symbol_iterator symbol_iterator;
// Iterate over the variable bindings.
for (VarBindingsTy::iterator I=B.begin(), E=B.end(); I!=E ; ++I)
if (Liveness.isLive(Loc, I.getKey())) {
RegionRoots.push_back(MRMgr.getVarRegion(I.getKey()));
- RVal X = I.getData();
+ SVal X = I.getData();
for (symbol_iterator SI=X.symbol_begin(), SE=X.symbol_end(); SI!=SE; ++SI)
LSymbols.insert(*SI);
@@ -212,15 +212,15 @@ BasicStoreManager::RemoveDeadBindings(Store store, Stmt* Loc,
Marked.insert(R);
// FIXME: Do we need the QualType here, since regions are partially
// typed?
- RVal X = GetRVal(store, lval::MemRegionVal(R), QualType());
+ SVal X = GetSVal(store, loc::MemRegionVal(R), QualType());
for (symbol_iterator SI=X.symbol_begin(), SE=X.symbol_end(); SI!=SE; ++SI)
LSymbols.insert(*SI);
- if (!isa<lval::MemRegionVal>(X))
+ if (!isa<loc::MemRegionVal>(X))
continue;
- const lval::MemRegionVal& LVD = cast<lval::MemRegionVal>(X);
+ const loc::MemRegionVal& LVD = cast<loc::MemRegionVal>(X);
RegionRoots.push_back(cast<VarRegion>(LVD.getRegion()));
}
@@ -229,8 +229,8 @@ BasicStoreManager::RemoveDeadBindings(Store store, Stmt* Loc,
const VarRegion* R = cast<VarRegion>(MRMgr.getVarRegion(I.getKey()));
if (!Marked.count(R)) {
- store = Remove(store, lval::MemRegionVal(R));
- RVal X = I.getData();
+ store = Remove(store, loc::MemRegionVal(R));
+ SVal X = I.getData();
for (symbol_iterator SI=X.symbol_begin(), SE=X.symbol_end(); SI!=SE; ++SI)
if (!LSymbols.count(*SI)) DSymbols.insert(*SI);
@@ -260,15 +260,15 @@ Store BasicStoreManager::getInitialStore() {
// Only handle pointers and integers for now.
QualType T = VD->getType();
- if (LVal::IsLValType(T) || T->isIntegerType()) {
+ if (Loc::IsLocType(T) || T->isIntegerType()) {
// Initialize globals and parameters to symbolic values.
// Initialize local variables to undefined.
- RVal X = (VD->hasGlobalStorage() || isa<ParmVarDecl>(VD) ||
+ SVal X = (VD->hasGlobalStorage() || isa<ParmVarDecl>(VD) ||
isa<ImplicitParamDecl>(VD))
- ? RVal::GetSymbolValue(StateMgr.getSymbolManager(), VD)
+ ? SVal::GetSymbolValue(StateMgr.getSymbolManager(), VD)
: UndefinedVal();
- St = SetRVal(St, lval::MemRegionVal(MRMgr.getVarRegion(VD)), X);
+ St = SetSVal(St, loc::MemRegionVal(MRMgr.getVarRegion(VD)), X);
}
}
}
@@ -277,7 +277,7 @@ Store BasicStoreManager::getInitialStore() {
Store BasicStoreManager::AddDecl(Store store,
const VarDecl* VD, Expr* Ex,
- RVal InitVal, unsigned Count) {
+ SVal InitVal, unsigned Count) {
BasicValueFactory& BasicVals = StateMgr.getBasicVals();
SymbolManager& SymMgr = StateMgr.getSymbolManager();
@@ -307,35 +307,35 @@ Store BasicStoreManager::AddDecl(Store store,
// unsigned) zero;
if (!Ex) {
QualType T = VD->getType();
- if (LVal::IsLValType(T))
- store = SetRVal(store, getLVal(VD),
- lval::ConcreteInt(BasicVals.getValue(0, T)));
+ if (Loc::IsLocType(T))
+ store = SetSVal(store, getLoc(VD),
+ loc::ConcreteInt(BasicVals.getValue(0, T)));
else if (T->isIntegerType())
- store = SetRVal(store, getLVal(VD),
- nonlval::ConcreteInt(BasicVals.getValue(0, T)));
+ store = SetSVal(store, getLoc(VD),
+ nonloc::ConcreteInt(BasicVals.getValue(0, T)));
else {
// assert(0 && "ignore other types of variables");
}
} else {
- store = SetRVal(store, getLVal(VD), InitVal);
+ store = SetSVal(store, getLoc(VD), InitVal);
}
}
} else {
// Process local scalar variables.
QualType T = VD->getType();
- if (LVal::IsLValType(T) || T->isIntegerType()) {
- RVal V = Ex ? InitVal : UndefinedVal();
+ if (Loc::IsLocType(T) || T->isIntegerType()) {
+ SVal V = Ex ? InitVal : UndefinedVal();
if (Ex && InitVal.isUnknown()) {
// EXPERIMENTAL: "Conjured" symbols.
SymbolID Sym = SymMgr.getConjuredSymbol(Ex, Count);
- V = LVal::IsLValType(Ex->getType())
- ? cast<RVal>(lval::SymbolVal(Sym))
- : cast<RVal>(nonlval::SymbolVal(Sym));
+ V = Loc::IsLocType(Ex->getType())
+ ? cast<SVal>(loc::SymbolVal(Sym))
+ : cast<SVal>(nonloc::SymbolVal(Sym));
}
- store = SetRVal(store, getLVal(VD), V);
+ store = SetSVal(store, getLoc(VD), V);
}
}
diff --git a/clang/lib/Analysis/BasicValueFactory.cpp b/clang/lib/Analysis/BasicValueFactory.cpp
index a9bb2cec4bd..e20cf167892 100644
--- a/clang/lib/Analysis/BasicValueFactory.cpp
+++ b/clang/lib/Analysis/BasicValueFactory.cpp
@@ -18,31 +18,31 @@
using namespace clang;
-typedef std::pair<RVal, uintptr_t> RValData;
-typedef std::pair<RVal, RVal> RValPair;
+typedef std::pair<SVal, uintptr_t> SValData;
+typedef std::pair<SVal, SVal> SValPair;
namespace llvm {
-template<> struct FoldingSetTrait<RValData> {
- static inline void Profile(const RValData& X, llvm::FoldingSetNodeID& ID) {
+template<> struct FoldingSetTrait<SValData> {
+ static inline void Profile(const SValData& X, llvm::FoldingSetNodeID& ID) {
X.first.Profile(ID);
ID.AddPointer( (void*) X.second);
}
};
-template<> struct FoldingSetTrait<RValPair> {
- static inline void Profile(const RValPair& X, llvm::FoldingSetNodeID& ID) {
+template<> struct FoldingSetTrait<SValPair> {
+ static inline void Profile(const SValPair& X, llvm::FoldingSetNodeID& ID) {
X.first.Profile(ID);
X.second.Profile(ID);
}
};
}
-typedef llvm::FoldingSet<llvm::FoldingSetNodeWrapper<RValData> >
- PersistentRValsTy;
+typedef llvm::FoldingSet<llvm::FoldingSetNodeWrapper<SValData> >
+ PersistentSValsTy;
-typedef llvm::FoldingSet<llvm::FoldingSetNodeWrapper<RValPair> >
- PersistentRValPairsTy;
+typedef llvm::FoldingSet<llvm::FoldingSetNodeWrapper<SValPair> >
+ PersistentSValPairsTy;
BasicValueFactory::~BasicValueFactory() {
// Note that the dstor for the contents of APSIntSet will never be called,
@@ -51,8 +51,8 @@ BasicValueFactory::~BasicValueFactory() {
for (APSIntSetTy::iterator I=APSIntSet.begin(), E=APSIntSet.end(); I!=E; ++I)
I->getValue().~APSInt();
- delete (PersistentRValsTy*) PersistentRVals;
- delete (PersistentRValPairsTy*) PersistentRValPairs;
+ delete (PersistentSValsTy*) PersistentSVals;
+ delete (PersistentSValPairsTy*) PersistentSValPairs;
}
const llvm::APSInt& BasicValueFactory::getValue(const llvm::APSInt& X) {
@@ -197,20 +197,20 @@ BasicValueFactory::EvaluateAPSInt(BinaryOperator::Opcode Op,
}
-const std::pair<RVal, uintptr_t>&
-BasicValueFactory::getPersistentRValWithData(const RVal& V, uintptr_t Data) {
+const std::pair<SVal, uintptr_t>&
+BasicValueFactory::getPersistentSValWithData(const SVal& V, uintptr_t Data) {
// Lazily create the folding set.
- if (!PersistentRVals) PersistentRVals = new PersistentRValsTy();
+ if (!PersistentSVals) PersistentSVals = new PersistentSValsTy();
llvm::FoldingSetNodeID ID;
void* InsertPos;
V.Profile(ID);
ID.AddPointer((void*) Data);
- PersistentRValsTy& Map = *((PersistentRValsTy*) PersistentRVals);
+ PersistentSValsTy& Map = *((PersistentSValsTy*) PersistentSVals);
- typedef llvm::FoldingSetNodeWrapper<RValData> FoldNodeTy;
+ typedef llvm::FoldingSetNodeWrapper<SValData> FoldNodeTy;
FoldNodeTy* P = Map.FindNodeOrInsertPos(ID, InsertPos);
if (!P) {
@@ -222,20 +222,20 @@ BasicValueFactory::getPersistentRValWithData(const RVal& V, uintptr_t Data) {
return P->getValue();
}
-const std::pair<RVal, RVal>&
-BasicValueFactory::getPersistentRValPair(const RVal& V1, const RVal& V2) {
+const std::pair<SVal, SVal>&
+BasicValueFactory::getPersistentSValPair(const SVal& V1, const SVal& V2) {
// Lazily create the folding set.
- if (!PersistentRValPairs) PersistentRValPairs = new PersistentRValPairsTy();
+ if (!PersistentSValPairs) PersistentSValPairs = new PersistentSValPairsTy();
llvm::FoldingSetNodeID ID;
void* InsertPos;
V1.Profile(ID);
V2.Profile(ID);
- PersistentRValPairsTy& Map = *((PersistentRValPairsTy*) PersistentRValPairs);
+ PersistentSValPairsTy& Map = *((PersistentSValPairsTy*) PersistentSValPairs);
- typedef llvm::FoldingSetNodeWrapper<RValPair> FoldNodeTy;
+ typedef llvm::FoldingSetNodeWrapper<SValPair> FoldNodeTy;
FoldNodeTy* P = Map.FindNodeOrInsertPos(ID, InsertPos);
if (!P) {
@@ -247,8 +247,8 @@ BasicValueFactory::getPersistentRValPair(const RVal& V1, const RVal& V2) {
return P->getValue();
}
-const RVal* BasicValueFactory::getPersistentRVal(RVal X) {
- return &getPersistentRValWithData(X, 0).first;
+const SVal* BasicValueFactory::getPersistentSVal(SVal X) {
+ return &getPersistentSValWithData(X, 0).first;
}
diff --git a/clang/lib/Analysis/BugReporter.cpp b/clang/lib/Analysis/BugReporter.cpp
index 834567136f4..0663ddde417 100644
--- a/clang/lib/Analysis/BugReporter.cpp
+++ b/clang/lib/Analysis/BugReporter.cpp
@@ -292,7 +292,7 @@ MakeReportGraph(ExplodedGraph<GRState>* G, ExplodedNode<GRState>* N) {
static VarDecl* GetMostRecentVarDeclBinding(ExplodedNode<GRState>* N,
GRStateManager& VMgr,
- RVal X) {
+ SVal X) {
for ( ; N ; N = N->pred_empty() ? 0 : *N->pred_begin()) {
@@ -306,7 +306,7 @@ static VarDecl* GetMostRecentVarDeclBinding(ExplodedNode<GRState>* N,
if (!DR)
continue;
- RVal Y = VMgr.GetRVal(N->getState(), DR);
+ SVal Y = VMgr.GetSVal(N->getState(), DR);
if (X != Y)
continue;
@@ -341,13 +341,13 @@ public:
PathDiagnostic& pd, BugReporter& br)
: Sym(sym), PrevSt(prevst), S(s), VMgr(vmgr), Pred(pred), PD(pd), BR(br) {}
- bool HandleBinding(StoreManager& SMgr, Store store, MemRegion* R, RVal V) {
+ bool HandleBinding(StoreManager& SMgr, Store store, MemRegion* R, SVal V) {
SymbolID ScanSym;
- if (lval::SymbolVal* SV = dyn_cast<lval::SymbolVal>(&V))
+ if (loc::SymbolVal* SV = dyn_cast<loc::SymbolVal>(&V))
ScanSym = SV->getSymbol();
- else if (nonlval::SymbolVal* SV = dyn_cast<nonlval::SymbolVal>(&V))
+ else if (nonloc::SymbolVal* SV = dyn_cast<nonloc::SymbolVal>(&V))
ScanSym = SV->getSymbol();
else
return true;
@@ -356,7 +356,7 @@ public:
return true;
// Check if the previous state has this binding.
- RVal X = VMgr.GetRVal(PrevSt, lval::MemRegionVal(R));
+ SVal X = VMgr.GetSVal(PrevSt, loc::MemRegionVal(R));
if (X == V) // Same binding?
return true;
@@ -443,12 +443,12 @@ public:
PathDiagnostic& pd)
: N(n), S(s), BR(br), PD(pd) {}
- bool HandleBinding(StoreManager& SMgr, Store store, MemRegion* R, RVal V) {
+ bool HandleBinding(StoreManager& SMgr, Store store, MemRegion* R, SVal V) {
SymbolID ScanSym;
- if (lval::SymbolVal* SV = dyn_cast<lval::SymbolVal>(&V))
+ if (loc::SymbolVal* SV = dyn_cast<loc::SymbolVal>(&V))
ScanSym = SV->getSymbol();
- else if (nonlval::SymbolVal* SV = dyn_cast<nonlval::SymbolVal>(&V))
+ else if (nonloc::SymbolVal* SV = dyn_cast<nonloc::SymbolVal>(&V))
ScanSym = SV->getSymbol();
else
return true;
diff --git a/clang/lib/Analysis/CFRefCount.cpp b/clang/lib/Analysis/CFRefCount.cpp
index c63529aa055..9d632314b2d 100644
--- a/clang/lib/Analysis/CFRefCount.cpp
+++ b/clang/lib/Analysis/CFRefCount.cpp
@@ -1297,7 +1297,7 @@ public:
virtual void EvalCall(ExplodedNodeSet<GRState>& Dst,
GRExprEngine& Eng,
GRStmtNodeBuilder<GRState>& Builder,
- CallExpr* CE, RVal L,
+ CallExpr* CE, SVal L,
ExplodedNode<GRState>* Pred);
@@ -1319,7 +1319,7 @@ public:
GRExprEngine& Engine,
GRStmtNodeBuilder<GRState>& Builder,
Expr* E, ExplodedNode<GRState>* Pred,
- const GRState* St, RVal TargetLV, RVal Val);
+ const GRState* St, SVal TargetLV, SVal Val);
// End-of-path.
virtual void EvalEndPath(GRExprEngine& Engine,
@@ -1343,7 +1343,7 @@ public:
// Assumptions.
virtual const GRState* EvalAssume(GRStateManager& VMgr,
- const GRState* St, RVal Cond,
+ const GRState* St, SVal Cond,
bool Assumption, bool& isFeasible);
// Error iterators.
@@ -1473,10 +1473,10 @@ void CFRefCount::EvalSummary(ExplodedNodeSet<GRState>& Dst,
SymbolID ErrorSym = 0;
for (ExprIterator I = arg_beg; I != arg_end; ++I, ++idx) {
- RVal V = state.GetRVal(*I);
+ SVal V = state.GetSVal(*I);
- if (isa<lval::SymbolVal>(V)) {
- SymbolID Sym = cast<lval::SymbolVal>(V).getSymbol();
+ if (isa<loc::SymbolVal>(V)) {
+ SymbolID Sym = cast<loc::SymbolVal>(V).getSymbol();
if (RefBindings::data_type* T = state.get<RefBindings>(Sym))
if (Update(state, Sym, *T, GetArgE(Summ, idx), hasErr)) {
ErrorExpr = *I;
@@ -1484,12 +1484,12 @@ void CFRefCount::EvalSummary(ExplodedNodeSet<GRState>& Dst,
break;
}
}
- else if (isa<LVal>(V)) {
+ else if (isa<Loc>(V)) {
#if 0
// Nuke all arguments passed by reference.
- StateMgr.Unbind(StVals, cast<LVal>(V));
+ StateMgr.Unbind(StVals, cast<Loc>(V));
#else
- if (lval::MemRegionVal* MR = dyn_cast<lval::MemRegionVal>(&V)) {
+ if (loc::MemRegionVal* MR = dyn_cast<loc::MemRegionVal>(&V)) {
if (GetArgE(Summ, idx) == DoNothingByRef)
continue;
@@ -1506,10 +1506,10 @@ void CFRefCount::EvalSummary(ExplodedNodeSet<GRState>& Dst,
// disambiguate conjured symbols.
// Is the invalidated variable something that we were tracking?
- RVal X = state.GetRVal(*MR);
+ SVal X = state.GetSVal(*MR);
- if (isa<lval::SymbolVal>(X)) {
- SymbolID Sym = cast<lval::SymbolVal>(X).getSymbol();
+ if (isa<loc::SymbolVal>(X)) {
+ SymbolID Sym = cast<loc::SymbolVal>(X).getSymbol();
state = state.remove<RefBindings>(Sym);
}
@@ -1521,29 +1521,29 @@ void CFRefCount::EvalSummary(ExplodedNodeSet<GRState>& Dst,
SymbolID NewSym =
Eng.getSymbolManager().getConjuredSymbol(*I, T, Count);
- state = state.SetRVal(*MR,
- LVal::IsLValType(T)
- ? cast<RVal>(lval::SymbolVal(NewSym))
- : cast<RVal>(nonlval::SymbolVal(NewSym)));
+ state = state.SetSVal(*MR,
+ Loc::IsLocType(T)
+ ? cast<SVal>(loc::SymbolVal(NewSym))
+ : cast<SVal>(nonloc::SymbolVal(NewSym)));
}
else
- state = state.SetRVal(*MR, UnknownVal());
+ state = state.SetSVal(*MR, UnknownVal());
}
else {
// Nuke all other arguments passed by reference.
- state = state.Unbind(cast<LVal>(V));
+ state = state.Unbind(cast<Loc>(V));
}
#endif
}
- else if (isa<nonlval::LValAsInteger>(V))
- state = state.Unbind(cast<nonlval::LValAsInteger>(V).getLVal());
+ else if (isa<nonloc::LocAsInteger>(V))
+ state = state.Unbind(cast<nonloc::LocAsInteger>(V).getLoc());
}
// Evaluate the effect on the message receiver.
if (!ErrorExpr && Receiver) {
- RVal V = state.GetRVal(Receiver);
- if (isa<lval::SymbolVal>(V)) {
- SymbolID Sym = cast<lval::SymbolVal>(V).getSymbol();
+ SVal V = state.GetSVal(Receiver);
+ if (isa<loc::SymbolVal>(V)) {
+ SymbolID Sym = cast<loc::SymbolVal>(V).getSymbol();
if (const RefVal* T = state.get<RefBindings>(Sym))
if (Update(state, Sym, *T, GetReceiverE(Summ), hasErr)) {
ErrorExpr = Receiver;
@@ -1576,11 +1576,11 @@ void CFRefCount::EvalSummary(ExplodedNodeSet<GRState>& Dst,
unsigned Count = Builder.getCurrentBlockCount();
SymbolID Sym = Eng.getSymbolManager().getConjuredSymbol(Ex, Count);
- RVal X = LVal::IsLValType(Ex->getType())
- ? cast<RVal>(lval::SymbolVal(Sym))
- : cast<RVal>(nonlval::SymbolVal(Sym));
+ SVal X = Loc::IsLocType(Ex->getType())
+ ? cast<SVal>(loc::SymbolVal(Sym))
+ : cast<SVal>(nonloc::SymbolVal(Sym));
- state = state.SetRVal(Ex, X, false);
+ state = state.SetSVal(Ex, X, false);
}
break;
@@ -1589,15 +1589,15 @@ void CFRefCount::EvalSummary(ExplodedNodeSet<GRState>& Dst,
unsigned idx = RE.getIndex();
assert (arg_end >= arg_beg);
assert (idx < (unsigned) (arg_end - arg_beg));
- RVal V = state.GetRVal(*(arg_beg+idx));
- state = state.SetRVal(Ex, V, false);
+ SVal V = state.GetSVal(*(arg_beg+idx));
+ state = state.SetSVal(Ex, V, false);
break;
}
case RetEffect::ReceiverAlias: {
assert (Receiver);
- RVal V = state.GetRVal(Receiver);
- state = state.SetRVal(Ex, V, false);
+ SVal V = state.GetSVal(Receiver);
+ state = state.SetSVal(Ex, V, false);
break;
}
@@ -1608,7 +1608,7 @@ void CFRefCount::EvalSummary(ExplodedNodeSet<GRState>& Dst,
QualType RetT = GetReturnType(Ex, Eng.getContext());
state = state.set<RefBindings>(Sym, RefVal::makeOwned(RetT));
- state = state.SetRVal(Ex, lval::SymbolVal(Sym), false);
+ state = state.SetSVal(Ex, loc::SymbolVal(Sym), false);
#if 0
RefBindings B = GetRefBindings(StImpl);
@@ -1628,7 +1628,7 @@ void CFRefCount::EvalSummary(ExplodedNodeSet<GRState>& Dst,
QualType RetT = GetReturnType(Ex, Eng.getContext());
state = state.set<RefBindings>(Sym, RefVal::makeNotOwned(RetT));
- state = state.SetRVal(Ex, lval::SymbolVal(Sym), false);
+ state = state.SetSVal(Ex, loc::SymbolVal(Sym), false);
break;
}
}
@@ -1644,11 +1644,11 @@ void CFRefCount::EvalSummary(ExplodedNodeSet<GRState>& Dst,
void CFRefCount::EvalCall(ExplodedNodeSet<GRState>& Dst,
GRExprEngine& Eng,
GRStmtNodeBuilder<GRState>& Builder,
- CallExpr* CE, RVal L,
+ CallExpr* CE, SVal L,
ExplodedNode<GRState>* Pred) {
- RetainSummary* Summ = !isa<lval::FuncVal>(L) ? 0
- : Summaries.getSummary(cast<lval::FuncVal>(L).getDecl());
+ RetainSummary* Summ = !isa<loc::FuncVal>(L) ? 0
+ : Summaries.getSummary(cast<loc::FuncVal>(L).getDecl());
EvalSummary(Dst, Eng, Builder, CE, 0, Summ,
CE->arg_begin(), CE->arg_end(), Pred);
@@ -1669,10 +1669,10 @@ void CFRefCount::EvalObjCMessageExpr(ExplodedNodeSet<GRState>& Dst,
// FIXME: Wouldn't it be great if this code could be reduced? It's just
// a chain of lookups.
const GRState* St = Builder.GetState(Pred);
- RVal V = Eng.getStateManager().GetRVal(St, Receiver );
+ SVal V = Eng.getStateManager().GetSVal(St, Receiver );
- if (isa<lval::SymbolVal>(V)) {
- SymbolID Sym = cast<lval::SymbolVal>(V).getSymbol();
+ if (isa<loc::SymbolVal>(V)) {
+ SymbolID Sym = cast<loc::SymbolVal>(V).getSymbol();
if (const RefVal* T = St->get<RefBindings>(Sym)) {
QualType Ty = T->getType();
@@ -1702,29 +1702,29 @@ void CFRefCount::EvalStore(ExplodedNodeSet<GRState>& Dst,
GRExprEngine& Eng,
GRStmtNodeBuilder<GRState>& Builder,
Expr* E, ExplodedNode<GRState>* Pred,
- const GRState* St, RVal TargetLV, RVal Val) {
+ const GRState* St, SVal TargetLV, SVal Val) {
// Check if we have a binding for "Val" and if we are storing it to something
// we don't understand or otherwise the value "escapes" the function.
- if (!isa<lval::SymbolVal>(Val))
+ if (!isa<loc::SymbolVal>(Val))
return;
// Are we storing to something that causes the value to "escape"?
bool escapes = false;
- if (!isa<lval::MemRegionVal>(TargetLV))
+ if (!isa<loc::MemRegionVal>(TargetLV))
escapes = true;
else {
- MemRegion* R = cast<lval::MemRegionVal>(TargetLV).getRegion();
+ MemRegion* R = cast<loc::MemRegionVal>(TargetLV).getRegion();
escapes = !Eng.getStateManager().hasStackStorage(R);
}
if (!escapes)
return;
- SymbolID Sym = cast<lval::SymbolVal>(Val).getSymbol();
+ SymbolID Sym = cast<loc::SymbolVal>(Val).getSymbol();
GRStateRef state(St, Eng.getStateManager());
@@ -1849,13 +1849,13 @@ void CFRefCount::EvalReturn(ExplodedNodeSet<GRState>& Dst,
if (!RetE) return;
GRStateRef state(Builder.GetState(Pred), Eng.getStateManager());
- RVal V = state.GetRVal(RetE);
+ SVal V = state.GetSVal(RetE);
- if (!isa<lval::SymbolVal>(V))
+ if (!isa<loc::SymbolVal>(V))
return;
// Get the reference count binding (if any).
- SymbolID Sym = cast<lval::SymbolVal>(V).getSymbol();
+ SymbolID Sym = cast<loc::SymbolVal>(V).getSymbol();
const RefVal* T = state.get<RefBindings>(Sym);
if (!T)
@@ -1892,7 +1892,7 @@ void CFRefCount::EvalReturn(ExplodedNodeSet<GRState>& Dst,
const GRState* CFRefCount::EvalAssume(GRStateManager& VMgr,
const GRState* St,
- RVal Cond, bool Assumption,
+ SVal Cond, bool Assumption,
bool& isFeasible) {
// FIXME: We may add to the interface of EvalAssume the list of symbols
@@ -2303,9 +2303,9 @@ PathDiagnosticPiece* CFRefReport::VisitNode(ExplodedNode<GRState>* N,
for (Stmt::child_iterator I = S->child_begin(), E = S->child_end(); I!=E; ++I)
if (Expr* Exp = dyn_cast_or_null<Expr>(*I)) {
- RVal X = VSM.GetRVal(CurrSt, Exp);
+ SVal X = VSM.GetSVal(CurrSt, Exp);
- if (lval::SymbolVal* SV = dyn_cast<lval::SymbolVal>(&X))
+ if (loc::SymbolVal* SV = dyn_cast<loc::SymbolVal>(&X))
if (SV->getSymbol() == Sym) {
P->addRange(Exp->getSourceRange()); break;
}
@@ -2324,12 +2324,12 @@ class VISIBILITY_HIDDEN FindUniqueBinding :
public:
FindUniqueBinding(SymbolID sym) : Sym(sym), Binding(0), First(true) {}
- bool HandleBinding(StoreManager& SMgr, Store store, MemRegion* R, RVal val) {
- if (const lval::SymbolVal* SV = dyn_cast<lval::SymbolVal>(&val)) {
+ bool HandleBinding(StoreManager& SMgr, Store store, MemRegion* R, SVal val) {
+ if (const loc::SymbolVal* SV = dyn_cast<loc::SymbolVal>(&val)) {
if (SV->getSymbol() != Sym)
return true;
}
- else if (const nonlval::SymbolVal* SV=dyn_cast<nonlval::SymbolVal>(&val)) {
+ else if (const nonloc::SymbolVal* SV=dyn_cast<nonloc::SymbolVal>(&val)) {
if (SV->getSymbol() != Sym)
return true;
}
diff --git a/clang/lib/Analysis/CheckNSError.cpp b/clang/lib/Analysis/CheckNSError.cpp
index 6e52dd952d9..38d32a731dd 100644
--- a/clang/lib/Analysis/CheckNSError.cpp
+++ b/clang/lib/Analysis/CheckNSError.cpp
@@ -216,11 +216,11 @@ void NSErrorCheck::CheckParamDeref(VarDecl* Param, GRStateRef rootState,
GRExprEngine& Eng, GRBugReporter& BR,
bool isNSErrorWarning) {
- RVal ParamRVal = rootState.GetLValue(Param);
+ SVal ParamSVal = rootState.GetLValue(Param);
- // FIXME: For now assume that ParamRVal is symbolic. We need to generalize
+ // FIXME: For now assume that ParamSVal is symbolic. We need to generalize
// this later.
- lval::SymbolVal* SV = dyn_cast<lval::SymbolVal>(&ParamRVal);
+ loc::SymbolVal* SV = dyn_cast<loc::SymbolVal>(&ParamSVal);
if (!SV) return;
// Iterate over the implicit-null dereferences.
@@ -228,8 +228,8 @@ void NSErrorCheck::CheckParamDeref(VarDecl* Param, GRStateRef rootState,
E=Eng.implicit_null_derefs_end(); I!=E; ++I) {
GRStateRef state = GRStateRef((*I)->getState(), Eng.getStateManager());
- const RVal* X = state.get<GRState::NullDerefTag>();
- const lval::SymbolVal* SVX = dyn_cast_or_null<lval::SymbolVal>(X);
+ const SVal* X = state.get<GRState::NullDerefTag>();
+ const loc::SymbolVal* SVX = dyn_cast_or_null<loc::SymbolVal>(X);
if (!SVX || SVX->getSymbol() != SV->getSymbol()) continue;
// Emit an error.
diff --git a/clang/lib/Analysis/Environment.cpp b/clang/lib/Analysis/Environment.cpp
index f86c4fea716..a9afa6d86bd 100644
--- a/clang/lib/Analysis/Environment.cpp
+++ b/clang/lib/Analysis/Environment.cpp
@@ -18,14 +18,14 @@
using namespace clang;
-RVal Environment::GetRVal(Expr* E, BasicValueFactory& BasicVals) const {
+SVal Environment::GetSVal(Expr* E, BasicValueFactory& BasicVals) const {
for (;;) {
switch (E->getStmtClass()) {
case Stmt::AddrLabelExprClass:
- return LVal::MakeVal(cast<AddrLabelExpr>(E));
+ return Loc::MakeVal(cast<AddrLabelExpr>(E));
// ParenExprs are no-ops.
@@ -35,15 +35,15 @@ RVal Environment::GetRVal(Expr* E, BasicValueFactory& BasicVals) const {
case Stmt::CharacterLiteralClass: {
CharacterLiteral* C = cast<CharacterLiteral>(E);
- return NonLVal::MakeVal(BasicVals, C->getValue(), C->getType());
+ return NonLoc::MakeVal(BasicVals, C->getValue(), C->getType());
}
case Stmt::IntegerLiteralClass: {
- return NonLVal::MakeVal(BasicVals, cast<IntegerLiteral>(E));
+ return NonLoc::MakeVal(BasicVals, cast<IntegerLiteral>(E));
}
case Stmt::StringLiteralClass:
- return LVal::MakeVal(cast<StringLiteral>(E));
+ return Loc::MakeVal(cast<StringLiteral>(E));
// Casts where the source and target type are the same
// are no-ops. We blast through these to get the descendant
@@ -73,18 +73,18 @@ RVal Environment::GetRVal(Expr* E, BasicValueFactory& BasicVals) const {
return LookupExpr(E);
}
-RVal Environment::GetBlkExprRVal(Expr* E, BasicValueFactory& BasicVals) const {
+SVal Environment::GetBlkExprSVal(Expr* E, BasicValueFactory& BasicVals) const {
E = E->IgnoreParens();
switch (E->getStmtClass()) {
case Stmt::CharacterLiteralClass: {
CharacterLiteral* C = cast<CharacterLiteral>(E);
- return NonLVal::MakeVal(BasicVals, C->getValue(), C->getType());
+ return NonLoc::MakeVal(BasicVals, C->getValue(), C->getType());
}
case Stmt::IntegerLiteralClass: {
- return NonLVal::MakeVal(BasicVals, cast<IntegerLiteral>(E));
+ return NonLoc::MakeVal(BasicVals, cast<IntegerLiteral>(E));
}
default:
@@ -92,7 +92,7 @@ RVal Environment::GetBlkExprRVal(Expr* E, BasicValueFactory& BasicVals) const {
}
}
-Environment EnvironmentManager::SetRVal(const Environment& Env, Expr* E, RVal V,
+Environment EnvironmentManager::SetSVal(const Environment& Env, Expr* E, SVal V,
bool isBlkExpr, bool Invalidate) {
assert (E);
@@ -121,25 +121,25 @@ EnvironmentManager::RemoveDeadBindings(Environment Env, Stmt* Loc,
Expr* BlkExpr = I.getKey();
if (Liveness.isLive(Loc, BlkExpr)) {
- RVal X = I.getData();
+ SVal X = I.getData();
// If the block expr's value is a memory region, then mark that region.
- if (isa<lval::MemRegionVal>(X))
- DRoots.push_back(cast<lval::MemRegionVal>(X).getRegion());
+ if (isa<loc::MemRegionVal>(X))
+ DRoots.push_back(cast<loc::MemRegionVal>(X).getRegion());
// Mark all symbols in the block expr's value.
- for (RVal::symbol_iterator SI = X.symbol_begin(), SE = X.symbol_end();
+ for (SVal::symbol_iterator SI = X.symbol_begin(), SE = X.symbol_end();
SI != SE; ++SI) {
LSymbols.insert(*SI);
}
} else {
// The block expr is dead.
- RVal X = I.getData();
+ SVal X = I.getData();
// Do not misclean LogicalExpr or ConditionalOperator. It is dead at the
// beginning of itself, but we need its UndefinedVal to determine its
- // RVal.
+ // SVal.
if (X.isUndef() && cast<UndefinedVal>(X).getData())
continue;
diff --git a/clang/lib/Analysis/GRExprEngine.cpp b/clang/lib/Analysis/GRExprEngine.cpp
index bc7a00a5469..d8ab4b12756 100644
--- a/clang/lib/Analysis/GRExprEngine.cpp
+++ b/clang/lib/Analysis/GRExprEngine.cpp
@@ -302,7 +302,7 @@ void GRExprEngine::Visit(Stmt* S, NodeTy* Pred, NodeSet& Dst) {
}
else if (B->getOpcode() == BinaryOperator::Comma) {
const GRState* St = GetState(Pred);
- MakeNode(Dst, B, Pred, SetRVal(St, B, GetRVal(St, B->getRHS())));
+ MakeNode(Dst, B, Pred, SetSVal(St, B, GetSVal(St, B->getRHS())));
break;
}
@@ -385,7 +385,7 @@ void GRExprEngine::Visit(Stmt* S, NodeTy* Pred, NodeSet& Dst) {
assert (!SE->getSubStmt()->body_empty());
if (Expr* LastExpr = dyn_cast<Expr>(*SE->getSubStmt()->body_rbegin()))
- MakeNode(Dst, SE, Pred, SetRVal(St, SE, GetRVal(St, LastExpr)));
+ MakeNode(Dst, SE, Pred, SetSVal(St, SE, GetSVal(St, LastExpr)));
else
Dst.Add(Pred);
@@ -473,7 +473,7 @@ const GRState* GRExprEngine::MarkBranch(const GRState* St,
(Op == BinaryOperator::LOr && !branchTaken)
? B->getRHS() : B->getLHS();
- return SetBlkExprRVal(St, B, UndefinedVal(Ex));
+ return SetBlkExprSVal(St, B, UndefinedVal(Ex));
}
case Stmt::ConditionalOperatorClass: { // ?:
@@ -490,7 +490,7 @@ const GRState* GRExprEngine::MarkBranch(const GRState* St,
else
Ex = C->getRHS();
- return SetBlkExprRVal(St, C, UndefinedVal(Ex));
+ return SetBlkExprSVal(St, C, UndefinedVal(Ex));
}
case Stmt::ChooseExprClass: { // ?:
@@ -498,7 +498,7 @@ const GRState* GRExprEngine::MarkBranch(const GRState* St,
ChooseExpr* C = cast<ChooseExpr>(Terminator);
Expr* Ex = branchTaken ? C->getLHS() : C->getRHS();
- return SetBlkExprRVal(St, C, UndefinedVal(Ex));
+ return SetBlkExprSVal(St, C, UndefinedVal(Ex));
}
}
}
@@ -516,18 +516,18 @@ void GRExprEngine::ProcessBranch(Expr* Condition, Stmt* Term,
return;
}
- RVal V = GetRVal(PrevState, Condition);
+ SVal V = GetSVal(PrevState, Condition);
switch (V.getBaseKind()) {
default:
break;
- case RVal::UnknownKind:
+ case SVal::UnknownKind:
builder.generateNode(MarkBranch(PrevState, Term, true), true);
builder.generateNode(MarkBranch(PrevState, Term, false), false);
return;
- case RVal::UndefinedKind: {
+ case SVal::UndefinedKind: {
NodeTy* N = builder.generateNode(PrevState, true);
if (N) {
@@ -566,7 +566,7 @@ void GRExprEngine::ProcessBranch(Expr* Condition, Stmt* Term,
void GRExprEngine::ProcessIndirectGoto(IndirectGotoNodeBuilder& builder) {
const GRState* St = builder.getState();
- RVal V = GetRVal(St, builder.getTarget());
+ SVal V = GetSVal(St, builder.getTarget());
// Three possibilities:
//
@@ -577,8 +577,8 @@ void GRExprEngine::ProcessIndirectGoto(IndirectGotoNodeBuilder& builder) {
typedef IndirectGotoNodeBuilder::iterator iterator;
- if (isa<lval::GotoLabel>(V)) {
- LabelStmt* L = cast<lval::GotoLabel>(V).getLabel();
+ if (isa<loc::GotoLabel>(V)) {
+ LabelStmt* L = cast<loc::GotoLabel>(V).getLabel();
for (iterator I=builder.begin(), E=builder.end(); I != E; ++I) {
if (I.getLabel() == L) {
@@ -591,7 +591,7 @@ void GRExprEngine::ProcessIndirectGoto(IndirectGotoNodeBuilder& builder) {
return;
}
- if (isa<lval::ConcreteInt>(V) || isa<UndefinedVal>(V)) {
+ if (isa<loc::ConcreteInt>(V) || isa<UndefinedVal>(V)) {
// Dispatch to the first target and mark it as a sink.
NodeTy* N = builder.generateNode(builder.begin(), St, true);
UndefBranches.insert(N);
@@ -613,7 +613,7 @@ void GRExprEngine::VisitGuardedExpr(Expr* Ex, Expr* L, Expr* R,
assert (Ex == CurrentStmt && getCFG().isBlkExpr(Ex));
const GRState* St = GetState(Pred);
- RVal X = GetBlkExprRVal(St, Ex);
+ SVal X = GetBlkExprSVal(St, Ex);
assert (X.isUndef());
@@ -621,10 +621,10 @@ void GRExprEngine::VisitGuardedExpr(Expr* Ex, Expr* L, Expr* R,
assert (SE);
- X = GetBlkExprRVal(St, SE);
+ X = GetBlkExprSVal(St, SE);
// Make sure that we invalidate the previous binding.
- MakeNode(Dst, Ex, Pred, StateMgr.SetRVal(St, Ex, X, true, true));
+ MakeNode(Dst, Ex, Pred, StateMgr.SetSVal(St, Ex, X, true, true));
}
/// ProcessSwitch - Called by GRCoreEngine. Used to generate successor
@@ -635,7 +635,7 @@ void GRExprEngine::ProcessSwitch(SwitchNodeBuilder& builder) {
const GRState* St = builder.getState();
Expr* CondE = builder.getCondition();
- RVal CondV = GetRVal(St, CondE);
+ SVal CondV = GetSVal(St, CondE);
if (CondV.isUndef()) {
NodeTy* N = builder.generateDefaultCaseNode(St, true);
@@ -683,9 +683,9 @@ void GRExprEngine::ProcessSwitch(SwitchNodeBuilder& builder) {
// This should be easy once we have "ranges" for NonLVals.
do {
- nonlval::ConcreteInt CaseVal(getBasicVals().getValue(V1));
+ nonloc::ConcreteInt CaseVal(getBasicVals().getValue(V1));
- RVal Res = EvalBinOp(BinaryOperator::EQ, CondV, CaseVal);
+ SVal Res = EvalBinOp(BinaryOperator::EQ, CondV, CaseVal);
// Now "assume" that the case matches.
@@ -698,7 +698,7 @@ void GRExprEngine::ProcessSwitch(SwitchNodeBuilder& builder) {
// If CondV evaluates to a constant, then we know that this
// is the *only* case that we can take, so stop evaluating the
// others.
- if (isa<nonlval::ConcreteInt>(CondV))
+ if (isa<nonloc::ConcreteInt>(CondV))
return;
}
@@ -741,7 +741,7 @@ void GRExprEngine::VisitLogicalExpr(BinaryOperator* B, NodeTy* Pred,
assert (B == CurrentStmt && getCFG().isBlkExpr(B));
const GRState* St = GetState(Pred);
- RVal X = GetBlkExprRVal(St, B);
+ SVal X = GetBlkExprSVal(St, B);
assert (X.isUndef());
@@ -751,12 +751,12 @@ void GRExprEngine::VisitLogicalExpr(BinaryOperator* B, NodeTy* Pred,
if (Ex == B->getRHS()) {
- X = GetBlkExprRVal(St, Ex);
+ X = GetBlkExprSVal(St, Ex);
// Handle undefined values.
if (X.isUndef()) {
- MakeNode(Dst, B, Pred, SetBlkExprRVal(St, B, X));
+ MakeNode(Dst, B, Pred, SetBlkExprSVal(St, B, X));
return;
}
@@ -772,14 +772,14 @@ void GRExprEngine::VisitLogicalExpr(BinaryOperator* B, NodeTy* Pred,
if (isFeasible)
MakeNode(Dst, B, Pred,
- SetBlkExprRVal(NewState, B, MakeConstantVal(1U, B)));
+ SetBlkExprSVal(NewState, B, MakeConstantVal(1U, B)));
isFeasible = false;
NewState = Assume(St, X, false, isFeasible);
if (isFeasible)
MakeNode(Dst, B, Pred,
- SetBlkExprRVal(NewState, B, MakeConstantVal(0U, B)));
+ SetBlkExprSVal(NewState, B, MakeConstantVal(0U, B)));
}
else {
// We took the LHS expression. Depending on whether we are '&&' or
@@ -787,7 +787,7 @@ void GRExprEngine::VisitLogicalExpr(BinaryOperator* B, NodeTy* Pred,
// the short-circuiting.
X = MakeConstantVal( B->getOpcode() == BinaryOperator::LAnd ? 0U : 1U, B);
- MakeNode(Dst, B, Pred, SetBlkExprRVal(St, B, X));
+ MakeNode(Dst, B, Pred, SetBlkExprSVal(St, B, X));
}
}
@@ -804,7 +804,7 @@ void GRExprEngine::VisitDeclRefExpr(DeclRefExpr* Ex, NodeTy* Pred, NodeSet& Dst,
if (const VarDecl* VD = dyn_cast<VarDecl>(D)) {
- RVal V = StateMgr.GetLValue(St, VD);
+ SVal V = StateMgr.GetLValue(St, VD);
if (VD->getType()->isArrayType()) {
// C++ standard says array of type T should be implicitly converted to
@@ -813,12 +813,12 @@ void GRExprEngine::VisitDeclRefExpr(DeclRefExpr* Ex, NodeTy* Pred, NodeSet& Dst,
// this in a transfer function in the future. We represent both lvalue and
// rvalue of array of type T as the corresponding MemRegionVal of it.
- MakeNode(Dst, Ex, Pred, SetRVal(St, Ex, V));
+ MakeNode(Dst, Ex, Pred, SetSVal(St, Ex, V));
return;
}
if (asLValue)
- MakeNode(Dst, Ex, Pred, SetRVal(St, Ex, V));
+ MakeNode(Dst, Ex, Pred, SetSVal(St, Ex, V));
else
EvalLoad(Dst, Ex, Pred, St, V);
return;
@@ -827,17 +827,17 @@ void GRExprEngine::VisitDeclRefExpr(DeclRefExpr* Ex, NodeTy* Pred, NodeSet& Dst,
assert(!asLValue && "EnumConstantDecl does not have lvalue.");
BasicValueFactory& BasicVals = StateMgr.getBasicVals();
- RVal V = nonlval::ConcreteInt(BasicVals.getValue(ED->getInitVal()));
- MakeNode(Dst, Ex, Pred, SetRVal(St, Ex, V));
+ SVal V = nonloc::ConcreteInt(BasicVals.getValue(ED->getInitVal()));
+ MakeNode(Dst, Ex, Pred, SetSVal(St, Ex, V));
return;
} else if (const FunctionDecl* FD = dyn_cast<FunctionDecl>(D)) {
- // We return the lval::FuncVal for an FunctionDecl in both rvalue
+ // We return the loc::FuncVal for an FunctionDecl in both rvalue
// and lvalue contexts.
// FIXME: Does this need to be revised? We were getting cases in
// real code that did this.
- RVal V = lval::FuncVal(FD);
- MakeNode(Dst, Ex, Pred, SetRVal(St, Ex, V));
+ SVal V = loc::FuncVal(FD);
+ MakeNode(Dst, Ex, Pred, SetSVal(St, Ex, V));
return;
}
@@ -860,10 +860,10 @@ void GRExprEngine::VisitArraySubscriptExpr(ArraySubscriptExpr* A, NodeTy* Pred,
for (NodeSet::iterator I2=Tmp2.begin(), E2=Tmp2.end(); I2!=E2; ++I2) {
const GRState* St = GetState(*I2);
- RVal V = StateMgr.GetLValue(St, GetRVal(St, Base), GetRVal(St, Idx));
+ SVal V = StateMgr.GetLValue(St, GetSVal(St, Base), GetSVal(St, Idx));
if (asLValue)
- MakeNode(Dst, A, *I2, SetRVal(St, A, V));
+ MakeNode(Dst, A, *I2, SetSVal(St, A, V));
else
EvalLoad(Dst, A, *I2, St, V);
}
@@ -883,17 +883,17 @@ void GRExprEngine::VisitMemberExpr(MemberExpr* M, NodeTy* Pred,
// FIXME: Should we insert some assumption logic in here to determine
// if "Base" is a valid piece of memory? Before we put this assumption
// later when using FieldOffset lvals (which we no longer have).
- RVal L = StateMgr.GetLValue(St, M->getMemberDecl(), GetRVal(St, Base));
+ SVal L = StateMgr.GetLValue(St, M->getMemberDecl(), GetSVal(St, Base));
if (asLValue)
- MakeNode(Dst, M, *I, SetRVal(St, M, L));
+ MakeNode(Dst, M, *I, SetSVal(St, M, L));
else
EvalLoad(Dst, M, *I, St, L);
}
}
void GRExprEngine::EvalStore(NodeSet& Dst, Expr* Ex, NodeTy* Pred,
- const GRState* St, RVal location, RVal Val) {
+ const GRState* St, SVal location, SVal Val) {
assert (Builder && "GRStmtNodeBuilder must be defined.");
@@ -925,7 +925,7 @@ void GRExprEngine::EvalStore(NodeSet& Dst, Expr* Ex, NodeTy* Pred,
}
void GRExprEngine::EvalLoad(NodeSet& Dst, Expr* Ex, NodeTy* Pred,
- const GRState* St, RVal location,
+ const GRState* St, SVal location,
bool CheckOnly) {
// Evaluate the location (checks for bad dereferences).
@@ -948,15 +948,15 @@ void GRExprEngine::EvalLoad(NodeSet& Dst, Expr* Ex, NodeTy* Pred,
MakeNode(Dst, Ex, Pred, St, K);
else if (location.isUnknown()) {
// This is important. We must nuke the old binding.
- MakeNode(Dst, Ex, Pred, SetRVal(St, Ex, UnknownVal()), K);
+ MakeNode(Dst, Ex, Pred, SetSVal(St, Ex, UnknownVal()), K);
}
else
- MakeNode(Dst, Ex, Pred, SetRVal(St, Ex, GetRVal(St, cast<LVal>(location),
+ MakeNode(Dst, Ex, Pred, SetSVal(St, Ex, GetSVal(St, cast<Loc>(location),
Ex->getType())), K);
}
void GRExprEngine::EvalStore(NodeSet& Dst, Expr* Ex, Expr* StoreE, NodeTy* Pred,
- const GRState* St, RVal location, RVal Val) {
+ const GRState* St, SVal location, SVal Val) {
NodeSet TmpDst;
EvalStore(TmpDst, StoreE, Pred, St, location, Val);
@@ -967,7 +967,7 @@ void GRExprEngine::EvalStore(NodeSet& Dst, Expr* Ex, Expr* StoreE, NodeTy* Pred,
const GRState* GRExprEngine::EvalLocation(Expr* Ex, NodeTy* Pred,
const GRState* St,
- RVal location, bool isLoad) {
+ SVal location, bool isLoad) {
// Check for loads/stores from/to undefined values.
if (location.isUndef()) {
@@ -992,7 +992,7 @@ const GRState* GRExprEngine::EvalLocation(Expr* Ex, NodeTy* Pred,
//
// We add these assumptions.
- LVal LV = cast<LVal>(location);
+ Loc LV = cast<Loc>(location);
// "Assume" that the pointer is not NULL.
@@ -1008,7 +1008,7 @@ const GRState* GRExprEngine::EvalLocation(Expr* Ex, NodeTy* Pred,
if (isFeasibleNull) {
// Use the Generic Data Map to mark in the state what lval was null.
- const RVal* PersistentLV = getBasicVals().getPersistentRVal(LV);
+ const SVal* PersistentLV = getBasicVals().getPersistentSVal(LV);
StNull = StNull.set<GRState::NullDerefTag>(PersistentLV);
// We don't use "MakeNode" here because the node will be a sink
@@ -1066,14 +1066,14 @@ void GRExprEngine::VisitCall(CallExpr* CE, NodeTy* Pred,
for (NodeSet::iterator DI = DstTmp.begin(), DE = DstTmp.end(); DI!=DE; ++DI) {
const GRState* St = GetState(*DI);
- RVal L = GetRVal(St, Callee);
+ SVal L = GetSVal(St, Callee);
// FIXME: Add support for symbolic function calls (calls involving
// function pointer values that are symbolic).
// Check for undefined control-flow or calls to NULL.
- if (L.isUndef() || isa<lval::ConcreteInt>(L)) {
+ if (L.isUndef() || isa<loc::ConcreteInt>(L)) {
NodeTy* N = Builder->generateNode(CE, St, *DI);
if (N) {
@@ -1088,9 +1088,9 @@ void GRExprEngine::VisitCall(CallExpr* CE, NodeTy* Pred,
SaveAndRestore<bool> OldSink(Builder->BuildSinks);
- if (isa<lval::FuncVal>(L)) {
+ if (isa<loc::FuncVal>(L)) {
- FunctionDecl* FD = cast<lval::FuncVal>(L).getDecl();
+ FunctionDecl* FD = cast<loc::FuncVal>(L).getDecl();
if (FD->getAttr<NoReturnAttr>())
Builder->BuildSinks = true;
@@ -1113,10 +1113,10 @@ void GRExprEngine::VisitCall(CallExpr* CE, NodeTy* Pred,
if (!memcmp(s, "panic", 5)) Builder->BuildSinks = true;
else if (!memcmp(s, "error", 5)) {
if (CE->getNumArgs() > 0) {
- RVal X = GetRVal(St, *CE->arg_begin());
+ SVal X = GetSVal(St, *CE->arg_begin());
// FIXME: use Assume to inspect the possible symbolic value of
// X. Also check the specific signature of error().
- nonlval::ConcreteInt* CI = dyn_cast<nonlval::ConcreteInt>(&X);
+ nonloc::ConcreteInt* CI = dyn_cast<nonloc::ConcreteInt>(&X);
if (CI && CI->getValue() != 0)
Builder->BuildSinks = true;
}
@@ -1168,17 +1168,17 @@ void GRExprEngine::VisitCall(CallExpr* CE, NodeTy* Pred,
// Evaluate the call.
- if (isa<lval::FuncVal>(L)) {
+ if (isa<loc::FuncVal>(L)) {
- IdentifierInfo* Info = cast<lval::FuncVal>(L).getDecl()->getIdentifier();
+ IdentifierInfo* Info = cast<loc::FuncVal>(L).getDecl()->getIdentifier();
if (unsigned id = Info->getBuiltinID())
switch (id) {
case Builtin::BI__builtin_expect: {
// For __builtin_expect, just return the value of the subexpression.
assert (CE->arg_begin() != CE->arg_end());
- RVal X = GetRVal(St, *(CE->arg_begin()));
- MakeNode(Dst, CE, *DI, SetRVal(St, CE, X));
+ SVal X = GetSVal(St, *(CE->arg_begin()));
+ MakeNode(Dst, CE, *DI, SetSVal(St, CE, X));
continue;
}
@@ -1194,7 +1194,7 @@ void GRExprEngine::VisitCall(CallExpr* CE, NodeTy* Pred,
for (CallExpr::arg_iterator I = CE->arg_begin(), E = CE->arg_end();
I != E; ++I) {
- if (GetRVal(GetState(*DI), *I).isUndef()) {
+ if (GetSVal(GetState(*DI), *I).isUndef()) {
NodeTy* N = Builder->generateNode(CE, GetState(*DI), *DI);
if (N) {
@@ -1239,11 +1239,11 @@ void GRExprEngine::VisitObjCIvarRefExpr(ObjCIvarRefExpr* Ex,
for (NodeSet::iterator I=Tmp.begin(), E=Tmp.end(); I!=E; ++I) {
const GRState* St = GetState(*I);
- RVal BaseVal = GetRVal(St, Base);
- RVal location = StateMgr.GetLValue(St, Ex->getDecl(), BaseVal);
+ SVal BaseVal = GetSVal(St, Base);
+ SVal location = StateMgr.GetLValue(St, Ex->getDecl(), BaseVal);
if (asLValue)
- MakeNode(Dst, Ex, *I, SetRVal(St, Ex, location));
+ MakeNode(Dst, Ex, *I, SetSVal(St, Ex, location));
else
EvalLoad(Dst, Ex, *I, St, location);
}
@@ -1303,7 +1303,7 @@ void GRExprEngine::VisitObjCMessageExprDispatchHelper(ObjCMessageExpr* ME,
if (Expr* Receiver = ME->getReceiver()) {
- RVal L = GetRVal(St, Receiver);
+ SVal L = GetSVal(St, Receiver);
// Check for undefined control-flow or calls to NULL.
@@ -1374,7 +1374,7 @@ void GRExprEngine::VisitObjCMessageExprDispatchHelper(ObjCMessageExpr* ME,
for (ObjCMessageExpr::arg_iterator I = ME->arg_begin(), E = ME->arg_end();
I != E; ++I) {
- if (GetRVal(St, *I).isUndef()) {
+ if (GetSVal(St, *I).isUndef()) {
// Generate an error node for passing an uninitialized/undefined value
// as an argument to a message expression. This node is a sink.
@@ -1442,7 +1442,7 @@ void GRExprEngine::VisitCast(Expr* CastE, Expr* Ex, NodeTy* Pred, NodeSet& Dst){
for (NodeSet::iterator I1 = S1.begin(), E1 = S1.end(); I1 != E1; ++I1) {
NodeTy* N = *I1;
const GRState* St = GetState(N);
- RVal V = GetRVal(St, Ex);
+ SVal V = GetSVal(St, Ex);
// Unknown?
@@ -1454,7 +1454,7 @@ void GRExprEngine::VisitCast(Expr* CastE, Expr* Ex, NodeTy* Pred, NodeSet& Dst){
// Undefined?
if (V.isUndef()) {
- MakeNode(Dst, CastE, N, SetRVal(St, CastE, V));
+ MakeNode(Dst, CastE, N, SetSVal(St, CastE, V));
continue;
}
@@ -1463,35 +1463,35 @@ void GRExprEngine::VisitCast(Expr* CastE, Expr* Ex, NodeTy* Pred, NodeSet& Dst){
if (C.getCanonicalType(T).getUnqualifiedType() ==
C.getCanonicalType(ExTy).getUnqualifiedType()) {
- MakeNode(Dst, CastE, N, SetRVal(St, CastE, V));
+ MakeNode(Dst, CastE, N, SetSVal(St, CastE, V));
continue;
}
// Check for casts from pointers to integers.
- if (T->isIntegerType() && LVal::IsLValType(ExTy)) {
+ if (T->isIntegerType() && Loc::IsLocType(ExTy)) {
unsigned bits = getContext().getTypeSize(ExTy);
// FIXME: Determine if the number of bits of the target type is
// equal or exceeds the number of bits to store the pointer value.
// If not, flag an error.
- V = nonlval::LValAsInteger::Make(getBasicVals(), cast<LVal>(V), bits);
- MakeNode(Dst, CastE, N, SetRVal(St, CastE, V));
+ V = nonloc::LocAsInteger::Make(getBasicVals(), cast<Loc>(V), bits);
+ MakeNode(Dst, CastE, N, SetSVal(St, CastE, V));
continue;
}
// Check for casts from integers to pointers.
- if (LVal::IsLValType(T) && ExTy->isIntegerType())
- if (nonlval::LValAsInteger *LV = dyn_cast<nonlval::LValAsInteger>(&V)) {
+ if (Loc::IsLocType(T) && ExTy->isIntegerType())
+ if (nonloc::LocAsInteger *LV = dyn_cast<nonloc::LocAsInteger>(&V)) {
// Just unpackage the lval and return it.
- V = LV->getLVal();
- MakeNode(Dst, CastE, N, SetRVal(St, CastE, V));
+ V = LV->getLoc();
+ MakeNode(Dst, CastE, N, SetSVal(St, CastE, V));
continue;
}
// All other cases.
- MakeNode(Dst, CastE, N, SetRVal(St, CastE, EvalCast(V, CastE->getType())));
+ MakeNode(Dst, CastE, N, SetSVal(St, CastE, EvalCast(V, CastE->getType())));
}
}
@@ -1559,8 +1559,8 @@ void GRExprEngine::VisitSizeOfAlignOfTypeExpr(SizeOfAlignOfTypeExpr* Ex,
amt = getContext().getTypeAlign(T) / 8;
MakeNode(Dst, Ex, Pred,
- SetRVal(GetState(Pred), Ex,
- NonLVal::MakeVal(getBasicVals(), amt, Ex->getType())));
+ SetSVal(GetState(Pred), Ex,
+ NonLoc::MakeVal(getBasicVals(), amt, Ex->getType())));
}
@@ -1581,10 +1581,10 @@ void GRExprEngine::VisitUnaryOperator(UnaryOperator* U, NodeTy* Pred,
for (NodeSet::iterator I=Tmp.begin(), E=Tmp.end(); I!=E; ++I) {
const GRState* St = GetState(*I);
- RVal location = GetRVal(St, Ex);
+ SVal location = GetSVal(St, Ex);
if (asLValue)
- MakeNode(Dst, U, *I, SetRVal(St, U, location));
+ MakeNode(Dst, U, *I, SetSVal(St, U, location));
else
EvalLoad(Dst, U, *I, St, location);
}
@@ -1600,7 +1600,7 @@ void GRExprEngine::VisitUnaryOperator(UnaryOperator* U, NodeTy* Pred,
for (NodeSet::iterator I=Tmp.begin(), E=Tmp.end(); I!=E; ++I) {
- // FIXME: We don't have complex RValues yet.
+ // FIXME: We don't have complex SValues yet.
if (Ex->getType()->isAnyComplexType()) {
// Just report "Unknown."
Dst.Add(*I);
@@ -1610,7 +1610,7 @@ void GRExprEngine::VisitUnaryOperator(UnaryOperator* U, NodeTy* Pred,
// For all other types, UnaryOperator::Real is an identity operation.
assert (U->getType() == Ex->getType());
const GRState* St = GetState(*I);
- MakeNode(Dst, U, *I, SetRVal(St, U, GetRVal(St, Ex)));
+ MakeNode(Dst, U, *I, SetSVal(St, U, GetSVal(St, Ex)));
}
return;
@@ -1623,7 +1623,7 @@ void GRExprEngine::VisitUnaryOperator(UnaryOperator* U, NodeTy* Pred,
Visit(Ex, Pred, Tmp);
for (NodeSet::iterator I=Tmp.begin(), E=Tmp.end(); I!=E; ++I) {
- // FIXME: We don't have complex RValues yet.
+ // FIXME: We don't have complex SValues yet.
if (Ex->getType()->isAnyComplexType()) {
// Just report "Unknown."
Dst.Add(*I);
@@ -1633,8 +1633,8 @@ void GRExprEngine::VisitUnaryOperator(UnaryOperator* U, NodeTy* Pred,
// For all other types, UnaryOperator::Float returns 0.
assert (Ex->getType()->isIntegerType());
const GRState* St = GetState(*I);
- RVal X = NonLVal::MakeVal(getBasicVals(), 0, Ex->getType());
- MakeNode(Dst, U, *I, SetRVal(St, U, X));
+ SVal X = NonLoc::MakeVal(getBasicVals(), 0, Ex->getType());
+ MakeNode(Dst, U, *I, SetSVal(St, U, X));
}
return;
@@ -1659,7 +1659,7 @@ void GRExprEngine::VisitUnaryOperator(UnaryOperator* U, NodeTy* Pred,
for (NodeSet::iterator I=Tmp.begin(), E=Tmp.end(); I!=E; ++I) {
const GRState* St = GetState(*I);
- MakeNode(Dst, U, *I, SetRVal(St, U, GetRVal(St, Ex)));
+ MakeNode(Dst, U, *I, SetSVal(St, U, GetSVal(St, Ex)));
}
return;
@@ -1674,8 +1674,8 @@ void GRExprEngine::VisitUnaryOperator(UnaryOperator* U, NodeTy* Pred,
for (NodeSet::iterator I=Tmp.begin(), E=Tmp.end(); I!=E; ++I) {
const GRState* St = GetState(*I);
- RVal V = GetRVal(St, Ex);
- St = SetRVal(St, U, V);
+ SVal V = GetSVal(St, Ex);
+ St = SetSVal(St, U, V);
MakeNode(Dst, U, *I, St);
}
@@ -1695,7 +1695,7 @@ void GRExprEngine::VisitUnaryOperator(UnaryOperator* U, NodeTy* Pred,
const GRState* St = GetState(*I);
// Get the value of the subexpression.
- RVal V = GetRVal(St, Ex);
+ SVal V = GetSVal(St, Ex);
// Perform promotions.
// FIXME: This is the right thing to do, but it currently breaks
@@ -1703,7 +1703,7 @@ void GRExprEngine::VisitUnaryOperator(UnaryOperator* U, NodeTy* Pred,
// V = EvalCast(V, U->getType());
if (V.isUnknownOrUndef()) {
- MakeNode(Dst, U, *I, SetRVal(St, U, V));
+ MakeNode(Dst, U, *I, SetSVal(St, U, V));
continue;
}
@@ -1714,12 +1714,12 @@ void GRExprEngine::VisitUnaryOperator(UnaryOperator* U, NodeTy* Pred,
case UnaryOperator::Not:
// FIXME: Do we need to handle promotions?
- St = SetRVal(St, U, EvalComplement(cast<NonLVal>(V)));
+ St = SetSVal(St, U, EvalComplement(cast<NonLoc>(V)));
break;
case UnaryOperator::Minus:
// FIXME: Do we need to handle promotions?
- St = SetRVal(St, U, EvalMinus(U, cast<NonLVal>(V)));
+ St = SetSVal(St, U, EvalMinus(U, cast<NonLoc>(V)));
break;
case UnaryOperator::LNot:
@@ -1729,18 +1729,18 @@ void GRExprEngine::VisitUnaryOperator(UnaryOperator* U, NodeTy* Pred,
// Note: technically we do "E == 0", but this is the same in the
// transfer functions as "0 == E".
- if (isa<LVal>(V)) {
- lval::ConcreteInt X(getBasicVals().getZeroWithPtrWidth());
- RVal Result = EvalBinOp(BinaryOperator::EQ, cast<LVal>(V), X);
- St = SetRVal(St, U, Result);
+ if (isa<Loc>(V)) {
+ loc::ConcreteInt X(getBasicVals().getZeroWithPtrWidth());
+ SVal Result = EvalBinOp(BinaryOperator::EQ, cast<Loc>(V), X);
+ St = SetSVal(St, U, Result);
}
else {
- nonlval::ConcreteInt X(getBasicVals().getValue(0, Ex->getType()));
+ nonloc::ConcreteInt X(getBasicVals().getValue(0, Ex->getType()));
#if 0
- RVal Result = EvalBinOp(BinaryOperator::EQ, cast<NonLVal>(V), X);
- St = SetRVal(St, U, Result);
+ SVal Result = EvalBinOp(BinaryOperator::EQ, cast<NonLoc>(V), X);
+ St = SetSVal(St, U, Result);
#else
- EvalBinOp(Dst, U, BinaryOperator::EQ, cast<NonLVal>(V), X, *I);
+ EvalBinOp(Dst, U, BinaryOperator::EQ, cast<NonLoc>(V), X, *I);
continue;
#endif
}
@@ -1765,7 +1765,7 @@ void GRExprEngine::VisitUnaryOperator(UnaryOperator* U, NodeTy* Pred,
uint64_t size = getContext().getTypeSize(T) / 8;
const GRState* St = GetState(Pred);
- St = SetRVal(St, U, NonLVal::MakeVal(getBasicVals(), size, U->getType()));
+ St = SetSVal(St, U, NonLoc::MakeVal(getBasicVals(), size, U->getType()));
MakeNode(Dst, U, Pred, St);
return;
@@ -1782,7 +1782,7 @@ void GRExprEngine::VisitUnaryOperator(UnaryOperator* U, NodeTy* Pred,
for (NodeSet::iterator I = Tmp.begin(), E = Tmp.end(); I!=E; ++I) {
const GRState* St = GetState(*I);
- RVal V1 = GetRVal(St, Ex);
+ SVal V1 = GetSVal(St, Ex);
// Perform a load.
NodeSet Tmp2;
@@ -1791,11 +1791,11 @@ void GRExprEngine::VisitUnaryOperator(UnaryOperator* U, NodeTy* Pred,
for (NodeSet::iterator I2 = Tmp2.begin(), E2 = Tmp2.end(); I2!=E2; ++I2) {
St = GetState(*I2);
- RVal V2 = GetRVal(St, Ex);
+ SVal V2 = GetSVal(St, Ex);
// Propagate unknown and undefined values.
if (V2.isUnknownOrUndef()) {
- MakeNode(Dst, U, *I2, SetRVal(St, U, V2));
+ MakeNode(Dst, U, *I2, SetSVal(St, U, V2));
continue;
}
@@ -1804,8 +1804,8 @@ void GRExprEngine::VisitUnaryOperator(UnaryOperator* U, NodeTy* Pred,
BinaryOperator::Opcode Op = U->isIncrementOp() ? BinaryOperator::Add
: BinaryOperator::Sub;
- RVal Result = EvalBinOp(Op, V2, MakeConstantVal(1U, U));
- St = SetRVal(St, U, U->isPostfix() ? V2 : Result);
+ SVal Result = EvalBinOp(Op, V2, MakeConstantVal(1U, U));
+ St = SetSVal(St, U, U->isPostfix() ? V2 : Result);
// Perform the store.
EvalStore(Dst, U, *I2, St, V1, Result);
@@ -1842,7 +1842,7 @@ void GRExprEngine::VisitAsmStmtHelperInputs(AsmStmt* A,
if (I == E) {
// We have processed both the inputs and the outputs. All of the outputs
- // should evaluate to LVals. Nuke all of their values.
+ // should evaluate to Locs. Nuke all of their values.
// FIXME: Some day in the future it would be nice to allow a "plug-in"
// which interprets the inline asm and stores proper results in the
@@ -1853,11 +1853,11 @@ void GRExprEngine::VisitAsmStmtHelperInputs(AsmStmt* A,
for (AsmStmt::outputs_iterator OI = A->begin_outputs(),
OE = A->end_outputs(); OI != OE; ++OI) {
- RVal X = GetRVal(St, *OI);
- assert (!isa<NonLVal>(X)); // Should be an Lval, or unknown, undef.
+ SVal X = GetSVal(St, *OI);
+ assert (!isa<NonLoc>(X)); // Should be an Lval, or unknown, undef.
- if (isa<LVal>(X))
- St = SetRVal(St, cast<LVal>(X), UnknownVal());
+ if (isa<Loc>(X))
+ St = SetSVal(St, cast<Loc>(X), UnknownVal());
}
MakeNode(Dst, A, Pred, St);
@@ -1909,12 +1909,12 @@ void GRExprEngine::VisitReturnStmt(ReturnStmt* S, NodeTy* Pred, NodeSet& Dst) {
Visit(R, Pred, Tmp);
for (NodeSet::iterator I=Tmp.begin(), E=Tmp.end(); I!=E; ++I) {
- RVal X = GetRVal((*I)->getState(), R);
+ SVal X = GetSVal((*I)->getState(), R);
- if (isa<lval::MemRegionVal>(X)) {
+ if (isa<loc::MemRegionVal>(X)) {
// Determine if the value is on the stack.
- const MemRegion* R = cast<lval::MemRegionVal>(&X)->getRegion();
+ const MemRegion* R = cast<loc::MemRegionVal>(&X)->getRegion();
if (R && getStateManager().hasStackStorage(R)) {
@@ -1946,7 +1946,7 @@ void GRExprEngine::VisitReturnStmt(ReturnStmt* S, NodeTy* Pred, NodeSet& Dst) {
//===----------------------------------------------------------------------===//
bool GRExprEngine::CheckDivideZero(Expr* Ex, const GRState* St,
- NodeTy* Pred, RVal Denom) {
+ NodeTy* Pred, SVal Denom) {
// Divide by undefined? (potentially zero)
@@ -2003,7 +2003,7 @@ void GRExprEngine::VisitBinaryOperator(BinaryOperator* B,
for (NodeSet::iterator I1=Tmp1.begin(), E1=Tmp1.end(); I1 != E1; ++I1) {
- RVal LeftV = GetRVal((*I1)->getState(), LHS);
+ SVal LeftV = GetSVal((*I1)->getState(), LHS);
// Process the RHS.
@@ -2015,7 +2015,7 @@ void GRExprEngine::VisitBinaryOperator(BinaryOperator* B,
for (NodeSet::iterator I2=Tmp2.begin(), E2=Tmp2.end(); I2 != E2; ++I2) {
const GRState* St = GetState(*I2);
- RVal RightV = GetRVal(St, RHS);
+ SVal RightV = GetSVal(St, RHS);
BinaryOperator::Opcode Op = B->getOpcode();
switch (Op) {
@@ -2028,15 +2028,15 @@ void GRExprEngine::VisitBinaryOperator(BinaryOperator* B,
unsigned Count = Builder->getCurrentBlockCount();
SymbolID Sym = SymMgr.getConjuredSymbol(B->getRHS(), Count);
- RightV = LVal::IsLValType(B->getRHS()->getType())
- ? cast<RVal>(lval::SymbolVal(Sym))
- : cast<RVal>(nonlval::SymbolVal(Sym));
+ RightV = Loc::IsLocType(B->getRHS()->getType())
+ ? cast<SVal>(loc::SymbolVal(Sym))
+ : cast<SVal>(nonloc::SymbolVal(Sym));
}
// Simulate the effects of a "store": bind the value of the RHS
// to the L-Value represented by the LHS.
- EvalStore(Dst, B, LHS, *I2, SetRVal(St, B, RightV), LeftV, RightV);
+ EvalStore(Dst, B, LHS, *I2, SetSVal(St, B, RightV), LeftV, RightV);
continue;
}
@@ -2059,7 +2059,7 @@ void GRExprEngine::VisitBinaryOperator(BinaryOperator* B,
// Process non-assignements except commas or short-circuited
// logical expressions (LAnd and LOr).
- RVal Result = EvalBinOp(Op, LeftV, RightV);
+ SVal Result = EvalBinOp(Op, LeftV, RightV);
if (Result.isUnknown()) {
Dst.Add(*I2);
@@ -2081,7 +2081,7 @@ void GRExprEngine::VisitBinaryOperator(BinaryOperator* B,
// Otherwise, create a new node.
- MakeNode(Dst, B, *I2, SetRVal(St, B, Result));
+ MakeNode(Dst, B, *I2, SetSVal(St, B, Result));
continue;
}
}
@@ -2096,23 +2096,23 @@ void GRExprEngine::VisitBinaryOperator(BinaryOperator* B,
// Perform a load (the LHS). This performs the checks for
// null dereferences, and so on.
NodeSet Tmp3;
- RVal location = GetRVal(St, LHS);
+ SVal location = GetSVal(St, LHS);
EvalLoad(Tmp3, LHS, *I2, St, location);
for (NodeSet::iterator I3=Tmp3.begin(), E3=Tmp3.end(); I3!=E3; ++I3) {
St = GetState(*I3);
- RVal V = GetRVal(St, LHS);
+ SVal V = GetSVal(St, LHS);
// Propagate undefined values (left-side).
if (V.isUndef()) {
- EvalStore(Dst, B, LHS, *I3, SetRVal(St, B, V), location, V);
+ EvalStore(Dst, B, LHS, *I3, SetSVal(St, B, V), location, V);
continue;
}
// Propagate unknown values (left and right-side).
if (RightV.isUnknown() || V.isUnknown()) {
- EvalStore(Dst, B, LHS, *I3, SetRVal(St, B, UnknownVal()), location,
+ EvalStore(Dst, B, LHS, *I3, SetSVal(St, B, UnknownVal()), location,
UnknownVal());
continue;
}
@@ -2139,13 +2139,13 @@ void GRExprEngine::VisitBinaryOperator(BinaryOperator* B,
}
else if (RightV.isUndef()) {
// Propagate undefined values (right-side).
- EvalStore(Dst, B, LHS, *I3, SetRVal(St, B, RightV), location, RightV);
+ EvalStore(Dst, B, LHS, *I3, SetSVal(St, B, RightV), location, RightV);
continue;
}
// Compute the result of the operation.
- RVal Result = EvalCast(EvalBinOp(Op, V, RightV), B->getType());
+ SVal Result = EvalCast(EvalBinOp(Op, V, RightV), B->getType());
if (Result.isUndef()) {
@@ -2159,7 +2159,7 @@ void GRExprEngine::VisitBinaryOperator(BinaryOperator* B,
continue;
}
- EvalStore(Dst, B, LHS, *I3, SetRVal(St, B, Result), location, Result);
+ EvalStore(Dst, B, LHS, *I3, SetSVal(St, B, Result), location, Result);
}
}
}
@@ -2171,7 +2171,7 @@ void GRExprEngine::VisitBinaryOperator(BinaryOperator* B,
void GRExprEngine::EvalBinOp(ExplodedNodeSet<GRState>& Dst, Expr* Ex,
BinaryOperator::Opcode Op,
- NonLVal L, NonLVal R,
+ NonLoc L, NonLoc R,
ExplodedNode<GRState>* Pred) {
GRStateSet OStates;
@@ -2183,7 +2183,7 @@ void GRExprEngine::EvalBinOp(ExplodedNodeSet<GRState>& Dst, Expr* Ex,
void GRExprEngine::EvalBinOp(GRStateSet& OStates, const GRState* St,
Expr* Ex, BinaryOperator::Opcode Op,
- NonLVal L, NonLVal R) {
+ NonLoc L, NonLoc R) {
GRStateSet::AutoPopulate AP(OStates, St);
if (R.isValid()) getTF().EvalBinOpNN(OStates, StateMgr, St, Ex, Op, L, R);
@@ -2263,7 +2263,7 @@ struct VISIBILITY_HIDDEN DOTGraphTraits<GRExprEngine::NodeTy*> :
else if (GraphPrintCheckerState->isUndefDeref(N))
Out << "\\|Dereference of undefialied value.\\l";
else if (GraphPrintCheckerState->isUndefStore(N))
- Out << "\\|Store to Undefined LVal.";
+ Out << "\\|Store to Undefined Loc.";
else if (GraphPrintCheckerState->isExplicitBadDivide(N))
Out << "\\|Explicit divide-by zero or undefined value.";
else if (GraphPrintCheckerState->isImplicitBadDivide(N))
diff --git a/clang/lib/Analysis/GRExprEngineInternalChecks.cpp b/clang/lib/Analysis/GRExprEngineInternalChecks.cpp
index d61998c5a41..c313697b9ea 100644
--- a/clang/lib/Analysis/GRExprEngineInternalChecks.cpp
+++ b/clang/lib/Analysis/GRExprEngineInternalChecks.cpp
@@ -194,8 +194,8 @@ public:
assert (E && "Return expression cannot be NULL");
// Get the value associated with E.
- lval::MemRegionVal V =
- cast<lval::MemRegionVal>(Eng.getStateManager().GetRVal(N->getState(),
+ loc::MemRegionVal V =
+ cast<loc::MemRegionVal>(Eng.getStateManager().GetSVal(N->getState(),
E));
// Generate a report for this bug.
@@ -235,7 +235,7 @@ class VISIBILITY_HIDDEN UndefBranch : public BuiltinBug {
return Ex;
}
- bool MatchesCriteria(Expr* Ex) { return VM.GetRVal(St, Ex).isUndef(); }
+ bool MatchesCriteria(Expr* Ex) { return VM.GetSVal(St, Ex).isUndef(); }
};
public:
@@ -303,12 +303,12 @@ public:
CallExpr* CE = cast<CallExpr>(cast<PostStmt>(N->getLocation()).getStmt());
const GRState* state = N->getState();
- RVal X = VMgr.GetRVal(state, CE->getCallee());
+ SVal X = VMgr.GetSVal(state, CE->getCallee());
- if (!isa<lval::FuncVal>(X))
+ if (!isa<loc::FuncVal>(X))
return false;
- FunctionDecl* FD = dyn_cast<FunctionDecl>(cast<lval::FuncVal>(X).getDecl());
+ FunctionDecl* FD = dyn_cast<FunctionDecl>(cast<loc::FuncVal>(X).getDecl());
const NonNullAttr* Att = FD->getAttr<NonNullAttr>();
if (!Att)
diff --git a/clang/lib/Analysis/GRSimpleVals.cpp b/clang/lib/Analysis/GRSimpleVals.cpp
index 07ec3e8bffc..2b1d9b59fa6 100644
--- a/clang/lib/Analysis/GRSimpleVals.cpp
+++ b/clang/lib/Analysis/GRSimpleVals.cpp
@@ -36,32 +36,32 @@ GRTransferFuncs* clang::MakeGRSimpleValsTF() { return new GRSimpleVals(); }
// Transfer function for Casts.
//===----------------------------------------------------------------------===//
-RVal GRSimpleVals::EvalCast(GRExprEngine& Eng, NonLVal X, QualType T) {
+SVal GRSimpleVals::EvalCast(GRExprEngine& Eng, NonLoc X, QualType T) {
- if (!isa<nonlval::ConcreteInt>(X))
+ if (!isa<nonloc::ConcreteInt>(X))
return UnknownVal();
- bool isLValType = LVal::IsLValType(T);
+ bool isLocType = Loc::IsLocType(T);
// Only handle casts from integers to integers.
- if (!isLValType && !T->isIntegerType())
+ if (!isLocType && !T->isIntegerType())
return UnknownVal();
BasicValueFactory& BasicVals = Eng.getBasicVals();
- llvm::APSInt V = cast<nonlval::ConcreteInt>(X).getValue();
- V.setIsUnsigned(T->isUnsignedIntegerType() || LVal::IsLValType(T));
+ llvm::APSInt V = cast<nonloc::ConcreteInt>(X).getValue();
+ V.setIsUnsigned(T->isUnsignedIntegerType() || Loc::IsLocType(T));
V.extOrTrunc(Eng.getContext().getTypeSize(T));
- if (isLValType)
- return lval::ConcreteInt(BasicVals.getValue(V));
+ if (isLocType)
+ return loc::ConcreteInt(BasicVals.getValue(V));
else
- return nonlval::ConcreteInt(BasicVals.getValue(V));
+ return nonloc::ConcreteInt(BasicVals.getValue(V));
}
// Casts.
-RVal GRSimpleVals::EvalCast(GRExprEngine& Eng, LVal X, QualType T) {
+SVal GRSimpleVals::EvalCast(GRExprEngine& Eng, Loc X, QualType T) {
// Casts from pointers -> pointers, just return the lval.
//
@@ -69,43 +69,43 @@ RVal GRSimpleVals::EvalCast(GRExprEngine& Eng, LVal X, QualType T) {
// can be introduced by the frontend for corner cases, e.g
// casting from va_list* to __builtin_va_list&.
//
- if (LVal::IsLValType(T) || T->isReferenceType())
+ if (Loc::IsLocType(T) || T->isReferenceType())
return X;
assert (T->isIntegerType());
- if (!isa<lval::ConcreteInt>(X))
+ if (!isa<loc::ConcreteInt>(X))
return UnknownVal();
BasicValueFactory& BasicVals = Eng.getBasicVals();
- llvm::APSInt V = cast<lval::ConcreteInt>(X).getValue();
- V.setIsUnsigned(T->isUnsignedIntegerType() || LVal::IsLValType(T));
+ llvm::APSInt V = cast<loc::ConcreteInt>(X).getValue();
+ V.setIsUnsigned(T->isUnsignedIntegerType() || Loc::IsLocType(T));
V.extOrTrunc(Eng.getContext().getTypeSize(T));
- return nonlval::ConcreteInt(BasicVals.getValue(V));
+ return nonloc::ConcreteInt(BasicVals.getValue(V));
}
// Unary operators.
-RVal GRSimpleVals::EvalMinus(GRExprEngine& Eng, UnaryOperator* U, NonLVal X){
+SVal GRSimpleVals::EvalMinus(GRExprEngine& Eng, UnaryOperator* U, NonLoc X){
switch (X.getSubKind()) {
- case nonlval::ConcreteIntKind:
- return cast<nonlval::ConcreteInt>(X).EvalMinus(Eng.getBasicVals(), U);
+ case nonloc::ConcreteIntKind:
+ return cast<nonloc::ConcreteInt>(X).EvalMinus(Eng.getBasicVals(), U);
default:
return UnknownVal();
}
}
-RVal GRSimpleVals::EvalComplement(GRExprEngine& Eng, NonLVal X) {
+SVal GRSimpleVals::EvalComplement(GRExprEngine& Eng, NonLoc X) {
switch (X.getSubKind()) {
- case nonlval::ConcreteIntKind:
- return cast<nonlval::ConcreteInt>(X).EvalComplement(Eng.getBasicVals());
+ case nonloc::ConcreteIntKind:
+ return cast<nonloc::ConcreteInt>(X).EvalComplement(Eng.getBasicVals());
default:
return UnknownVal();
@@ -123,9 +123,9 @@ static unsigned char LNotOpMap[] = {
(unsigned char) BinaryOperator::EQ /* NE => EQ */
};
-RVal GRSimpleVals::DetermEvalBinOpNN(GRStateManager& StateMgr,
+SVal GRSimpleVals::DetermEvalBinOpNN(GRStateManager& StateMgr,
BinaryOperator::Opcode Op,
- NonLVal L, NonLVal R) {
+ NonLoc L, NonLoc R) {
BasicValueFactory& BasicVals = StateMgr.getBasicVals();
unsigned subkind = L.getSubKind();
@@ -136,14 +136,14 @@ RVal GRSimpleVals::DetermEvalBinOpNN(GRStateManager& StateMgr,
default:
return UnknownVal();
- case nonlval::SymIntConstraintValKind: {
+ case nonloc::SymIntConstraintValKind: {
// Logical not?
if (!(Op == BinaryOperator::EQ && R.isZeroConstant()))
return UnknownVal();
const SymIntConstraint& C =
- cast<nonlval::SymIntConstraintVal>(L).getConstraint();
+ cast<nonloc::SymIntConstraintVal>(L).getConstraint();
BinaryOperator::Opcode Opc = C.getOpcode();
@@ -163,19 +163,19 @@ RVal GRSimpleVals::DetermEvalBinOpNN(GRStateManager& StateMgr,
const SymIntConstraint& CNew =
BasicVals.getConstraint(C.getSymbol(), Opc, C.getInt());
- return nonlval::SymIntConstraintVal(CNew);
+ return nonloc::SymIntConstraintVal(CNew);
}
- case nonlval::ConcreteIntKind:
+ case nonloc::ConcreteIntKind:
- if (isa<nonlval::ConcreteInt>(R)) {
- const nonlval::ConcreteInt& L_CI = cast<nonlval::ConcreteInt>(L);
- const nonlval::ConcreteInt& R_CI = cast<nonlval::ConcreteInt>(R);
+ if (isa<nonloc::ConcreteInt>(R)) {
+ const nonloc::ConcreteInt& L_CI = cast<nonloc::ConcreteInt>(L);
+ const nonloc::ConcreteInt& R_CI = cast<nonloc::ConcreteInt>(R);
return L_CI.EvalBinOp(BasicVals, Op, R_CI);
}
else {
subkind = R.getSubKind();
- NonLVal tmp = R;
+ NonLoc tmp = R;
R = L;
L = tmp;
@@ -191,13 +191,13 @@ RVal GRSimpleVals::DetermEvalBinOpNN(GRStateManager& StateMgr,
continue;
}
- case nonlval::SymbolValKind:
- if (isa<nonlval::ConcreteInt>(R)) {
+ case nonloc::SymbolValKind:
+ if (isa<nonloc::ConcreteInt>(R)) {
const SymIntConstraint& C =
- BasicVals.getConstraint(cast<nonlval::SymbolVal>(L).getSymbol(), Op,
- cast<nonlval::ConcreteInt>(R).getValue());
+ BasicVals.getConstraint(cast<nonloc::SymbolVal>(L).getSymbol(), Op,
+ cast<nonloc::ConcreteInt>(R).getValue());
- return nonlval::SymIntConstraintVal(C);
+ return nonloc::SymIntConstraintVal(C);
}
else
return UnknownVal();
@@ -208,8 +208,8 @@ RVal GRSimpleVals::DetermEvalBinOpNN(GRStateManager& StateMgr,
// Binary Operators (except assignments and comma).
-RVal GRSimpleVals::EvalBinOp(GRExprEngine& Eng, BinaryOperator::Opcode Op,
- LVal L, LVal R) {
+SVal GRSimpleVals::EvalBinOp(GRExprEngine& Eng, BinaryOperator::Opcode Op,
+ Loc L, Loc R) {
switch (Op) {
@@ -226,52 +226,52 @@ RVal GRSimpleVals::EvalBinOp(GRExprEngine& Eng, BinaryOperator::Opcode Op,
// Pointer arithmetic.
-RVal GRSimpleVals::EvalBinOp(GRExprEngine& Eng, BinaryOperator::Opcode Op,
- LVal L, NonLVal R) {
+SVal GRSimpleVals::EvalBinOp(GRExprEngine& Eng, BinaryOperator::Opcode Op,
+ Loc L, NonLoc R) {
return UnknownVal();
}
-// Equality operators for LVals.
+// Equality operators for Locs.
-RVal GRSimpleVals::EvalEQ(GRExprEngine& Eng, LVal L, LVal R) {
+SVal GRSimpleVals::EvalEQ(GRExprEngine& Eng, Loc L, Loc R) {
BasicValueFactory& BasicVals = Eng.getBasicVals();
switch (L.getSubKind()) {
default:
- assert(false && "EQ not implemented for this LVal.");
+ assert(false && "EQ not implemented for this Loc.");
return UnknownVal();
- case lval::ConcreteIntKind:
+ case loc::ConcreteIntKind:
- if (isa<lval::ConcreteInt>(R)) {
- bool b = cast<lval::ConcreteInt>(L).getValue() ==
- cast<lval::ConcreteInt>(R).getValue();
+ if (isa<loc::ConcreteInt>(R)) {
+ bool b = cast<loc::ConcreteInt>(L).getValue() ==
+ cast<loc::ConcreteInt>(R).getValue();
- return NonLVal::MakeIntTruthVal(BasicVals, b);
+ return NonLoc::MakeIntTruthVal(BasicVals, b);
}
- else if (isa<lval::SymbolVal>(R)) {
+ else if (isa<loc::SymbolVal>(R)) {
const SymIntConstraint& C =
- BasicVals.getConstraint(cast<lval::SymbolVal>(R).getSymbol(),
+ BasicVals.getConstraint(cast<loc::SymbolVal>(R).getSymbol(),
BinaryOperator::EQ,
- cast<lval::ConcreteInt>(L).getValue());
+ cast<loc::ConcreteInt>(L).getValue());
- return nonlval::SymIntConstraintVal(C);
+ return nonloc::SymIntConstraintVal(C);
}
break;
- case lval::SymbolValKind: {
+ case loc::SymbolValKind: {
- if (isa<lval::ConcreteInt>(R)) {
+ if (isa<loc::ConcreteInt>(R)) {
const SymIntConstraint& C =
- BasicVals.getConstraint(cast<lval::SymbolVal>(L).getSymbol(),
+ BasicVals.getConstraint(cast<loc::SymbolVal>(L).getSymbol(),
BinaryOperator::EQ,
- cast<lval::ConcreteInt>(R).getValue());
+ cast<loc::ConcreteInt>(R).getValue());
- return nonlval::SymIntConstraintVal(C);
+ return nonloc::SymIntConstraintVal(C);
}
// FIXME: Implement == for lval Symbols. This is mainly useful
@@ -282,53 +282,53 @@ RVal GRSimpleVals::EvalEQ(GRExprEngine& Eng, LVal L, LVal R) {
return UnknownVal();
}
- case lval::MemRegionKind:
- case lval::FuncValKind:
- case lval::GotoLabelKind:
- case lval::StringLiteralValKind:
- return NonLVal::MakeIntTruthVal(BasicVals, L == R);
+ case loc::MemRegionKind:
+ case loc::FuncValKind:
+ case loc::GotoLabelKind:
+ case loc::StringLiteralValKind:
+ return NonLoc::MakeIntTruthVal(BasicVals, L == R);
}
- return NonLVal::MakeIntTruthVal(BasicVals, false);
+ return NonLoc::MakeIntTruthVal(BasicVals, false);
}
-RVal GRSimpleVals::EvalNE(GRExprEngine& Eng, LVal L, LVal R) {
+SVal GRSimpleVals::EvalNE(GRExprEngine& Eng, Loc L, Loc R) {
BasicValueFactory& BasicVals = Eng.getBasicVals();
switch (L.getSubKind()) {
default:
- assert(false && "NE not implemented for this LVal.");
+ assert(false && "NE not implemented for this Loc.");
return UnknownVal();
- case lval::ConcreteIntKind:
+ case loc::ConcreteIntKind:
- if (isa<lval::ConcreteInt>(R)) {
- bool b = cast<lval::ConcreteInt>(L).getValue() !=
- cast<lval::ConcreteInt>(R).getValue();
+ if (isa<loc::ConcreteInt>(R)) {
+ bool b = cast<loc::ConcreteInt>(L).getValue() !=
+ cast<loc::ConcreteInt>(R).getValue();
- return NonLVal::MakeIntTruthVal(BasicVals, b);
+ return NonLoc::MakeIntTruthVal(BasicVals, b);
}
- else if (isa<lval::SymbolVal>(R)) {
+ else if (isa<loc::SymbolVal>(R)) {
const SymIntConstraint& C =
- BasicVals.getConstraint(cast<lval::SymbolVal>(R).getSymbol(),
+ BasicVals.getConstraint(cast<loc::SymbolVal>(R).getSymbol(),
BinaryOperator::NE,
- cast<lval::ConcreteInt>(L).getValue());
+ cast<loc::ConcreteInt>(L).getValue());
- return nonlval::SymIntConstraintVal(C);
+ return nonloc::SymIntConstraintVal(C);
}
break;
- case lval::SymbolValKind: {
- if (isa<lval::ConcreteInt>(R)) {
+ case loc::SymbolValKind: {
+ if (isa<loc::ConcreteInt>(R)) {
const SymIntConstraint& C =
- BasicVals.getConstraint(cast<lval::SymbolVal>(L).getSymbol(),
+ BasicVals.getConstraint(cast<loc::SymbolVal>(L).getSymbol(),
BinaryOperator::NE,
- cast<lval::ConcreteInt>(R).getValue());
+ cast<loc::ConcreteInt>(R).getValue());
- return nonlval::SymIntConstraintVal(C);
+ return nonloc::SymIntConstraintVal(C);
}
// FIXME: Implement != for lval Symbols. This is mainly useful
@@ -341,14 +341,14 @@ RVal GRSimpleVals::EvalNE(GRExprEngine& Eng, LVal L, LVal R) {
break;
}
- case lval::MemRegionKind:
- case lval::FuncValKind:
- case lval::GotoLabelKind:
- case lval::StringLiteralValKind:
- return NonLVal::MakeIntTruthVal(BasicVals, L != R);
+ case loc::MemRegionKind:
+ case loc::FuncValKind:
+ case loc::GotoLabelKind:
+ case loc::StringLiteralValKind:
+ return NonLoc::MakeIntTruthVal(BasicVals, L != R);
}
- return NonLVal::MakeIntTruthVal(BasicVals, true);
+ return NonLoc::MakeIntTruthVal(BasicVals, true);
}
//===----------------------------------------------------------------------===//
@@ -358,23 +358,23 @@ RVal GRSimpleVals::EvalNE(GRExprEngine& Eng, LVal L, LVal R) {
void GRSimpleVals::EvalCall(ExplodedNodeSet<GRState>& Dst,
GRExprEngine& Eng,
GRStmtNodeBuilder<GRState>& Builder,
- CallExpr* CE, RVal L,
+ CallExpr* CE, SVal L,
ExplodedNode<GRState>* Pred) {
GRStateManager& StateMgr = Eng.getStateManager();
const GRState* St = Builder.GetState(Pred);
- // Invalidate all arguments passed in by reference (LVals).
+ // Invalidate all arguments passed in by reference (Locs).
for (CallExpr::arg_iterator I = CE->arg_begin(), E = CE->arg_end();
I != E; ++I) {
- RVal V = StateMgr.GetRVal(St, *I);
+ SVal V = StateMgr.GetSVal(St, *I);
- if (isa<LVal>(V))
- St = StateMgr.SetRVal(St, cast<LVal>(V), UnknownVal());
- else if (isa<nonlval::LValAsInteger>(V))
- St = StateMgr.SetRVal(St, cast<nonlval::LValAsInteger>(V).getLVal(),
+ if (isa<Loc>(V))
+ St = StateMgr.SetSVal(St, cast<Loc>(V), UnknownVal());
+ else if (isa<nonloc::LocAsInteger>(V))
+ St = StateMgr.SetSVal(St, cast<nonloc::LocAsInteger>(V).getLoc(),
UnknownVal());
}
@@ -385,11 +385,11 @@ void GRSimpleVals::EvalCall(ExplodedNodeSet<GRState>& Dst,
unsigned Count = Builder.getCurrentBlockCount();
SymbolID Sym = Eng.getSymbolManager().getConjuredSymbol(CE, Count);
- RVal X = LVal::IsLValType(CE->getType())
- ? cast<RVal>(lval::SymbolVal(Sym))
- : cast<RVal>(nonlval::SymbolVal(Sym));
+ SVal X = Loc::IsLocType(CE->getType())
+ ? cast<SVal>(loc::SymbolVal(Sym))
+ : cast<SVal>(nonloc::SymbolVal(Sym));
- St = StateMgr.SetRVal(St, CE, X, Eng.getCFG().isBlkExpr(CE), false);
+ St = StateMgr.SetSVal(St, CE, X, Eng.getCFG().isBlkExpr(CE), false);
}
Builder.MakeNode(Dst, CE, Pred, St);
@@ -415,10 +415,10 @@ void GRSimpleVals::EvalObjCMessageExpr(ExplodedNodeSet<GRState>& Dst,
for (ObjCMessageExpr::arg_iterator I = ME->arg_begin(), E = ME->arg_end();
I != E; ++I) {
- RVal V = StateMgr.GetRVal(St, *I);
+ SVal V = StateMgr.GetSVal(St, *I);
- if (isa<LVal>(V))
- St = StateMgr.SetRVal(St, cast<LVal>(V), UnknownVal());
+ if (isa<Loc>(V))
+ St = StateMgr.SetSVal(St, cast<Loc>(V), UnknownVal());
}
Builder.MakeNode(Dst, ME, Pred, St);
diff --git a/clang/lib/Analysis/GRSimpleVals.h b/clang/lib/Analysis/GRSimpleVals.h
index 720ccc1f203..ee32e8a99d0 100644
--- a/clang/lib/Analysis/GRSimpleVals.h
+++ b/clang/lib/Analysis/GRSimpleVals.h
@@ -27,9 +27,9 @@ class ASTContext;
class GRSimpleVals : public GRTransferFuncs {
protected:
- virtual RVal DetermEvalBinOpNN(GRStateManager& StateMgr,
+ virtual SVal DetermEvalBinOpNN(GRStateManager& StateMgr,
BinaryOperator::Opcode Op,
- NonLVal L, NonLVal R);
+ NonLoc L, NonLoc R);
public:
GRSimpleVals() {}
@@ -37,31 +37,31 @@ public:
// Casts.
- virtual RVal EvalCast(GRExprEngine& Engine, NonLVal V, QualType CastT);
- virtual RVal EvalCast(GRExprEngine& Engine, LVal V, QualType CastT);
+ virtual SVal EvalCast(GRExprEngine& Engine, NonLoc V, QualType CastT);
+ virtual SVal EvalCast(GRExprEngine& Engine, Loc V, QualType CastT);
// Unary Operators.
- virtual RVal EvalMinus(GRExprEngine& Engine, UnaryOperator* U, NonLVal X);
+ virtual SVal EvalMinus(GRExprEngine& Engine, UnaryOperator* U, NonLoc X);
- virtual RVal EvalComplement(GRExprEngine& Engine, NonLVal X);
+ virtual SVal EvalComplement(GRExprEngine& Engine, NonLoc X);
// Binary Operators.
- virtual RVal EvalBinOp(GRExprEngine& Engine, BinaryOperator::Opcode Op,
- LVal L, LVal R);
+ virtual SVal EvalBinOp(GRExprEngine& Engine, BinaryOperator::Opcode Op,
+ Loc L, Loc R);
// Pointer arithmetic.
- virtual RVal EvalBinOp(GRExprEngine& Engine, BinaryOperator::Opcode Op,
- LVal L, NonLVal R);
+ virtual SVal EvalBinOp(GRExprEngine& Engine, BinaryOperator::Opcode Op,
+ Loc L, NonLoc R);
// Calls.
virtual void EvalCall(ExplodedNodeSet<GRState>& Dst,
GRExprEngine& Engine,
GRStmtNodeBuilder<GRState>& Builder,
- CallExpr* CE, RVal L,
+ CallExpr* CE, SVal L,
ExplodedNode<GRState>* Pred);
virtual void EvalObjCMessageExpr(ExplodedNodeSet<GRState>& Dst,
@@ -77,10 +77,10 @@ public:
protected:
- // Equality operators for LVals.
+ // Equality operators for Locs.
- RVal EvalEQ(GRExprEngine& Engine, LVal L, LVal R);
- RVal EvalNE(GRExprEngine& Engine, LVal L, LVal R);
+ SVal EvalEQ(GRExprEngine& Engine, Loc L, Loc R);
+ SVal EvalNE(GRExprEngine& Engine, Loc L, Loc R);
};
} // end clang namespace
diff --git a/clang/lib/Analysis/GRState.cpp b/clang/lib/Analysis/GRState.cpp
index 49bc24aa7de..09275e28a78 100644
--- a/clang/lib/Analysis/GRState.cpp
+++ b/clang/lib/Analysis/GRState.cpp
@@ -59,11 +59,11 @@ GRStateManager::RemoveDeadBindings(const GRState* St, Stmt* Loc,
LSymbols, DSymbols);
}
-const GRState* GRStateManager::SetRVal(const GRState* St, LVal LV,
- RVal V) {
+const GRState* GRStateManager::SetSVal(const GRState* St, Loc LV,
+ SVal V) {
Store OldStore = St->getStore();
- Store NewStore = StoreMgr->SetRVal(OldStore, LV, V);
+ Store NewStore = StoreMgr->SetSVal(OldStore, LV, V);
if (NewStore == OldStore)
return St;
@@ -80,7 +80,7 @@ const GRState* GRStateManager::AddDecl(const GRState* St, const VarDecl* VD,
if (Ex)
NewStore = StoreMgr->AddDecl(OldStore, VD, Ex,
- GetRVal(St, Ex), Count);
+ GetSVal(St, Ex), Count);
else
NewStore = StoreMgr->AddDecl(OldStore, VD, Ex);
@@ -92,7 +92,7 @@ const GRState* GRStateManager::AddDecl(const GRState* St, const VarDecl* VD,
return getPersistentState(NewSt);
}
-const GRState* GRStateManager::Unbind(const GRState* St, LVal LV) {
+const GRState* GRStateManager::Unbind(const GRState* St, Loc LV) {
Store OldStore = St->getStore();
Store NewStore = StoreMgr->Remove(OldStore, LV);
@@ -240,18 +240,18 @@ const GRState* GRStateManager::addGDM(const GRState* St, void* Key, void* Data){
bool GRStateManager::isEqual(const GRState* state, Expr* Ex,
const llvm::APSInt& Y) {
- RVal V = GetRVal(state, Ex);
+ SVal V = GetSVal(state, Ex);
- if (lval::ConcreteInt* X = dyn_cast<lval::ConcreteInt>(&V))
+ if (loc::ConcreteInt* X = dyn_cast<loc::ConcreteInt>(&V))
return X->getValue() == Y;
- if (nonlval::ConcreteInt* X = dyn_cast<nonlval::ConcreteInt>(&V))
+ if (nonloc::ConcreteInt* X = dyn_cast<nonloc::ConcreteInt>(&V))
return X->getValue() == Y;
- if (nonlval::SymbolVal* X = dyn_cast<nonlval::SymbolVal>(&V))
+ if (nonloc::SymbolVal* X = dyn_cast<nonloc::SymbolVal>(&V))
return ConstraintMgr->isEqual(state, X->getSymbol(), Y);
- if (lval::SymbolVal* X = dyn_cast<lval::SymbolVal>(&V))
+ if (loc::SymbolVal* X = dyn_cast<loc::SymbolVal>(&V))
return ConstraintMgr->isEqual(state, X->getSymbol(), Y);
return false;
diff --git a/clang/lib/Analysis/GRTransferFuncs.cpp b/clang/lib/Analysis/GRTransferFuncs.cpp
index 03292d1c49b..4b8e42ed9d1 100644
--- a/clang/lib/Analysis/GRTransferFuncs.cpp
+++ b/clang/lib/Analysis/GRTransferFuncs.cpp
@@ -23,7 +23,7 @@ void GRTransferFuncs::EvalStore(ExplodedNodeSet<GRState>& Dst,
GRExprEngine& Eng,
GRStmtNodeBuilder<GRState>& Builder,
Expr* E, ExplodedNode<GRState>* Pred,
- const GRState* St, RVal TargetLV, RVal Val) {
+ const GRState* St, SVal TargetLV, SVal Val) {
// This code basically matches the "safety-net" logic of GRExprEngine:
// bind Val to TargetLV, and create a new node. We replicate it here
@@ -35,14 +35,14 @@ void GRTransferFuncs::EvalStore(ExplodedNodeSet<GRState>& Dst,
Builder.MakeNode(Dst, E, Pred, St);
else
Builder.MakeNode(Dst, E, Pred,
- Eng.getStateManager().SetRVal(St, cast<LVal>(TargetLV), Val));
+ Eng.getStateManager().SetSVal(St, cast<Loc>(TargetLV), Val));
}
void GRTransferFuncs::EvalBinOpNN(GRStateSet& OStates,
GRStateManager& StateMgr,
const GRState *St, Expr* Ex,
BinaryOperator::Opcode Op,
- NonLVal L, NonLVal R) {
+ NonLoc L, NonLoc R) {
- OStates.Add(StateMgr.SetRVal(St, Ex, DetermEvalBinOpNN(StateMgr, Op, L, R)));
+ OStates.Add(StateMgr.SetSVal(St, Ex, DetermEvalBinOpNN(StateMgr, Op, L, R)));
}
diff --git a/clang/lib/Analysis/RValues.cpp b/clang/lib/Analysis/RValues.cpp
index 551945ce26e..db1a8403fb8 100644
--- a/clang/lib/Analysis/RValues.cpp
+++ b/clang/lib/Analysis/RValues.cpp
@@ -7,7 +7,7 @@
//
//===----------------------------------------------------------------------===//
//
-// This file defines RVal, LVal, and NonLVal, classes that represent
+// This file defines SVal, Loc, and NonLoc, classes that represent
// abstract r-values for use with path-sensitive value tracking.
//
//===----------------------------------------------------------------------===//
@@ -25,23 +25,23 @@ using llvm::APSInt;
// Symbol Iteration.
//===----------------------------------------------------------------------===//
-RVal::symbol_iterator RVal::symbol_begin() const {
+SVal::symbol_iterator SVal::symbol_begin() const {
// FIXME: This is a rat's nest. Cleanup.
- if (isa<lval::SymbolVal>(this))
+ if (isa<loc::SymbolVal>(this))
return (symbol_iterator) (&Data);
- else if (isa<nonlval::SymbolVal>(this))
+ else if (isa<nonloc::SymbolVal>(this))
return (symbol_iterator) (&Data);
- else if (isa<nonlval::SymIntConstraintVal>(this)) {
+ else if (isa<nonloc::SymIntConstraintVal>(this)) {
const SymIntConstraint& C =
- cast<nonlval::SymIntConstraintVal>(this)->getConstraint();
+ cast<nonloc::SymIntConstraintVal>(this)->getConstraint();
return (symbol_iterator) &C.getSymbol();
}
- else if (isa<nonlval::LValAsInteger>(this)) {
- const nonlval::LValAsInteger& V = cast<nonlval::LValAsInteger>(*this);
- return V.getPersistentLVal().symbol_begin();
+ else if (isa<nonloc::LocAsInteger>(this)) {
+ const nonloc::LocAsInteger& V = cast<nonloc::LocAsInteger>(*this);
+ return V.getPersistentLoc().symbol_begin();
}
// FIXME: We need to iterate over the symbols of regions.
@@ -49,7 +49,7 @@ RVal::symbol_iterator RVal::symbol_begin() const {
return NULL;
}
-RVal::symbol_iterator RVal::symbol_end() const {
+SVal::symbol_iterator SVal::symbol_end() const {
symbol_iterator X = symbol_begin();
return X ? X+1 : NULL;
}
@@ -58,56 +58,56 @@ RVal::symbol_iterator RVal::symbol_end() const {
// Useful predicates.
//===----------------------------------------------------------------------===//
-bool RVal::isZeroConstant() const {
- if (isa<lval::ConcreteInt>(*this))
- return cast<lval::ConcreteInt>(*this).getValue() == 0;
- else if (isa<nonlval::ConcreteInt>(*this))
- return cast<nonlval::ConcreteInt>(*this).getValue() == 0;
+bool SVal::isZeroConstant() const {
+ if (isa<loc::ConcreteInt>(*this))
+ return cast<loc::ConcreteInt>(*this).getValue() == 0;
+ else if (isa<nonloc::ConcreteInt>(*this))
+ return cast<nonloc::ConcreteInt>(*this).getValue() == 0;
else
return false;
}
//===----------------------------------------------------------------------===//
-// Transfer function dispatch for Non-LVals.
+// Transfer function dispatch for Non-Locs.
//===----------------------------------------------------------------------===//
-RVal nonlval::ConcreteInt::EvalBinOp(BasicValueFactory& BasicVals,
+SVal nonloc::ConcreteInt::EvalBinOp(BasicValueFactory& BasicVals,
BinaryOperator::Opcode Op,
- const nonlval::ConcreteInt& R) const {
+ const nonloc::ConcreteInt& R) const {
const llvm::APSInt* X =
BasicVals.EvaluateAPSInt(Op, getValue(), R.getValue());
if (X)
- return nonlval::ConcreteInt(*X);
+ return nonloc::ConcreteInt(*X);
else
return UndefinedVal();
}
// Bitwise-Complement.
-nonlval::ConcreteInt
-nonlval::ConcreteInt::EvalComplement(BasicValueFactory& BasicVals) const {
+nonloc::ConcreteInt
+nonloc::ConcreteInt::EvalComplement(BasicValueFactory& BasicVals) const {
return BasicVals.getValue(~getValue());
}
// Unary Minus.
-nonlval::ConcreteInt
-nonlval::ConcreteInt::EvalMinus(BasicValueFactory& BasicVals, UnaryOperator* U) const {
+nonloc::ConcreteInt
+nonloc::ConcreteInt::EvalMinus(BasicValueFactory& BasicVals, UnaryOperator* U) const {
assert (U->getType() == U->getSubExpr()->getType());
assert (U->getType()->isIntegerType());
return BasicVals.getValue(-getValue());
}
//===----------------------------------------------------------------------===//
-// Transfer function dispatch for LVals.
+// Transfer function dispatch for Locs.
//===----------------------------------------------------------------------===//
-RVal
-lval::ConcreteInt::EvalBinOp(BasicValueFactory& BasicVals, BinaryOperator::Opcode Op,
- const lval::ConcreteInt& R) const {
+SVal
+loc::ConcreteInt::EvalBinOp(BasicValueFactory& BasicVals, BinaryOperator::Opcode Op,
+ const loc::ConcreteInt& R) const {
assert (Op == BinaryOperator::Add || Op == BinaryOperator::Sub ||
(Op >= BinaryOperator::LT && Op <= BinaryOperator::NE));
@@ -115,180 +115,180 @@ lval::ConcreteInt::EvalBinOp(BasicValueFactory& BasicVals, BinaryOperator::Opcod
const llvm::APSInt* X = BasicVals.EvaluateAPSInt(Op, getValue(), R.getValue());
if (X)
- return lval::ConcreteInt(*X);
+ return loc::ConcreteInt(*X);
else
return UndefinedVal();
}
-NonLVal LVal::EQ(BasicValueFactory& BasicVals, const LVal& R) const {
+NonLoc Loc::EQ(BasicValueFactory& BasicVals, const Loc& R) const {
switch (getSubKind()) {
default:
- assert(false && "EQ not implemented for this LVal.");
+ assert(false && "EQ not implemented for this Loc.");
break;
- case lval::ConcreteIntKind:
- if (isa<lval::ConcreteInt>(R)) {
- bool b = cast<lval::ConcreteInt>(this)->getValue() ==
- cast<lval::ConcreteInt>(R).getValue();
+ case loc::ConcreteIntKind:
+ if (isa<loc::ConcreteInt>(R)) {
+ bool b = cast<loc::ConcreteInt>(this)->getValue() ==
+ cast<loc::ConcreteInt>(R).getValue();
- return NonLVal::MakeIntTruthVal(BasicVals, b);
+ return NonLoc::MakeIntTruthVal(BasicVals, b);
}
- else if (isa<lval::SymbolVal>(R)) {
+ else if (isa<loc::SymbolVal>(R)) {
const SymIntConstraint& C =
- BasicVals.getConstraint(cast<lval::SymbolVal>(R).getSymbol(),
+ BasicVals.getConstraint(cast<loc::SymbolVal>(R).getSymbol(),
BinaryOperator::EQ,
- cast<lval::ConcreteInt>(this)->getValue());
+ cast<loc::ConcreteInt>(this)->getValue());
- return nonlval::SymIntConstraintVal(C);
+ return nonloc::SymIntConstraintVal(C);
}
break;
- case lval::SymbolValKind: {
- if (isa<lval::ConcreteInt>(R)) {
+ case loc::SymbolValKind: {
+ if (isa<loc::ConcreteInt>(R)) {
const SymIntConstraint& C =
- BasicVals.getConstraint(cast<lval::SymbolVal>(this)->getSymbol(),
+ BasicVals.getConstraint(cast<loc::SymbolVal>(this)->getSymbol(),
BinaryOperator::EQ,
- cast<lval::ConcreteInt>(R).getValue());
+ cast<loc::ConcreteInt>(R).getValue());
- return nonlval::SymIntConstraintVal(C);
+ return nonloc::SymIntConstraintVal(C);
}
- assert (!isa<lval::SymbolVal>(R) && "FIXME: Implement unification.");
+ assert (!isa<loc::SymbolVal>(R) && "FIXME: Implement unification.");
break;
}
- case lval::MemRegionKind:
- if (isa<lval::MemRegionVal>(R)) {
- bool b = cast<lval::MemRegionVal>(*this) == cast<lval::MemRegionVal>(R);
- return NonLVal::MakeIntTruthVal(BasicVals, b);
+ case loc::MemRegionKind:
+ if (isa<loc::MemRegionVal>(R)) {
+ bool b = cast<loc::MemRegionVal>(*this) == cast<loc::MemRegionVal>(R);
+ return NonLoc::MakeIntTruthVal(BasicVals, b);
}
break;
}
- return NonLVal::MakeIntTruthVal(BasicVals, false);
+ return NonLoc::MakeIntTruthVal(BasicVals, false);
}
-NonLVal LVal::NE(BasicValueFactory& BasicVals, const LVal& R) const {
+NonLoc Loc::NE(BasicValueFactory& BasicVals, const Loc& R) const {
switch (getSubKind()) {
default:
- assert(false && "NE not implemented for this LVal.");
+ assert(false && "NE not implemented for this Loc.");
break;
- case lval::ConcreteIntKind:
- if (isa<lval::ConcreteInt>(R)) {
- bool b = cast<lval::ConcreteInt>(this)->getValue() !=
- cast<lval::ConcreteInt>(R).getValue();
+ case loc::ConcreteIntKind:
+ if (isa<loc::ConcreteInt>(R)) {
+ bool b = cast<loc::ConcreteInt>(this)->getValue() !=
+ cast<loc::ConcreteInt>(R).getValue();
- return NonLVal::MakeIntTruthVal(BasicVals, b);
+ return NonLoc::MakeIntTruthVal(BasicVals, b);
}
- else if (isa<lval::SymbolVal>(R)) {
+ else if (isa<loc::SymbolVal>(R)) {
const SymIntConstraint& C =
- BasicVals.getConstraint(cast<lval::SymbolVal>(R).getSymbol(),
+ BasicVals.getConstraint(cast<loc::SymbolVal>(R).getSymbol(),
BinaryOperator::NE,
- cast<lval::ConcreteInt>(this)->getValue());
+ cast<loc::ConcreteInt>(this)->getValue());
- return nonlval::SymIntConstraintVal(C);
+ return nonloc::SymIntConstraintVal(C);
}
break;
- case lval::SymbolValKind: {
- if (isa<lval::ConcreteInt>(R)) {
+ case loc::SymbolValKind: {
+ if (isa<loc::ConcreteInt>(R)) {
const SymIntConstraint& C =
- BasicVals.getConstraint(cast<lval::SymbolVal>(this)->getSymbol(),
+ BasicVals.getConstraint(cast<loc::SymbolVal>(this)->getSymbol(),
BinaryOperator::NE,
- cast<lval::ConcreteInt>(R).getValue());
+ cast<loc::ConcreteInt>(R).getValue());
- return nonlval::SymIntConstraintVal(C);
+ return nonloc::SymIntConstraintVal(C);
}
- assert (!isa<lval::SymbolVal>(R) && "FIXME: Implement sym !=.");
+ assert (!isa<loc::SymbolVal>(R) && "FIXME: Implement sym !=.");
break;
}
- case lval::MemRegionKind:
- if (isa<lval::MemRegionVal>(R)) {
- bool b = cast<lval::MemRegionVal>(*this)==cast<lval::MemRegionVal>(R);
- return NonLVal::MakeIntTruthVal(BasicVals, b);
+ case loc::MemRegionKind:
+ if (isa<loc::MemRegionVal>(R)) {
+ bool b = cast<loc::MemRegionVal>(*this)==cast<loc::MemRegionVal>(R);
+ return NonLoc::MakeIntTruthVal(BasicVals, b);
}
break;
}
- return NonLVal::MakeIntTruthVal(BasicVals, true);
+ return NonLoc::MakeIntTruthVal(BasicVals, true);
}
//===----------------------------------------------------------------------===//
-// Utility methods for constructing Non-LVals.
+// Utility methods for constructing Non-Locs.
//===----------------------------------------------------------------------===//
-NonLVal NonLVal::MakeVal(BasicValueFactory& BasicVals, uint64_t X, QualType T) {
- return nonlval::ConcreteInt(BasicVals.getValue(X, T));
+NonLoc NonLoc::MakeVal(BasicValueFactory& BasicVals, uint64_t X, QualType T) {
+ return nonloc::ConcreteInt(BasicVals.getValue(X, T));
}
-NonLVal NonLVal::MakeVal(BasicValueFactory& BasicVals, IntegerLiteral* I) {
+NonLoc NonLoc::MakeVal(BasicValueFactory& BasicVals, IntegerLiteral* I) {
- return nonlval::ConcreteInt(BasicVals.getValue(APSInt(I->getValue(),
+ return nonloc::ConcreteInt(BasicVals.getValue(APSInt(I->getValue(),
I->getType()->isUnsignedIntegerType())));
}
-NonLVal NonLVal::MakeIntTruthVal(BasicValueFactory& BasicVals, bool b) {
- return nonlval::ConcreteInt(BasicVals.getTruthValue(b));
+NonLoc NonLoc::MakeIntTruthVal(BasicValueFactory& BasicVals, bool b) {
+ return nonloc::ConcreteInt(BasicVals.getTruthValue(b));
}
-RVal RVal::GetSymbolValue(SymbolManager& SymMgr, VarDecl* D) {
+SVal SVal::GetSymbolValue(SymbolManager& SymMgr, VarDecl* D) {
QualType T = D->getType();
- if (LVal::IsLValType(T))
- return lval::SymbolVal(SymMgr.getSymbol(D));
+ if (Loc::IsLocType(T))
+ return loc::SymbolVal(SymMgr.getSymbol(D));
- return nonlval::SymbolVal(SymMgr.getSymbol(D));
+ return nonloc::SymbolVal(SymMgr.getSymbol(D));
}
//===----------------------------------------------------------------------===//
-// Utility methods for constructing LVals.
+// Utility methods for constructing Locs.
//===----------------------------------------------------------------------===//
-LVal LVal::MakeVal(AddrLabelExpr* E) { return lval::GotoLabel(E->getLabel()); }
+Loc Loc::MakeVal(AddrLabelExpr* E) { return loc::GotoLabel(E->getLabel()); }
-LVal LVal::MakeVal(StringLiteral* S) {
- return lval::StringLiteralVal(S);
+Loc Loc::MakeVal(StringLiteral* S) {
+ return loc::StringLiteralVal(S);
}
//===----------------------------------------------------------------------===//
// Pretty-Printing.
//===----------------------------------------------------------------------===//
-void RVal::printStdErr() const { print(*llvm::cerr.stream()); }
+void SVal::printStdErr() const { print(*llvm::cerr.stream()); }
-void RVal::print(std::ostream& Out) const {
+void SVal::print(std::ostream& Out) const {
switch (getBaseKind()) {
case UnknownKind:
Out << "Invalid"; break;
- case NonLValKind:
- cast<NonLVal>(this)->print(Out); break;
+ case NonLocKind:
+ cast<NonLoc>(this)->print(Out); break;
- case LValKind:
- cast<LVal>(this)->print(Out); break;
+ case LocKind:
+ cast<Loc>(this)->print(Out); break;
case UndefinedKind:
Out << "Undefined"; break;
default:
- assert (false && "Invalid RVal.");
+ assert (false && "Invalid SVal.");
}
}
@@ -316,25 +316,25 @@ static void printOpcode(std::ostream& Out, BinaryOperator::Opcode Op) {
}
}
-void NonLVal::print(std::ostream& Out) const {
+void NonLoc::print(std::ostream& Out) const {
switch (getSubKind()) {
- case nonlval::ConcreteIntKind:
- Out << cast<nonlval::ConcreteInt>(this)->getValue().getZExtValue();
+ case nonloc::ConcreteIntKind:
+ Out << cast<nonloc::ConcreteInt>(this)->getValue().getZExtValue();
- if (cast<nonlval::ConcreteInt>(this)->getValue().isUnsigned())
+ if (cast<nonloc::ConcreteInt>(this)->getValue().isUnsigned())
Out << 'U';
break;
- case nonlval::SymbolValKind:
- Out << '$' << cast<nonlval::SymbolVal>(this)->getSymbol();
+ case nonloc::SymbolValKind:
+ Out << '$' << cast<nonloc::SymbolVal>(this)->getSymbol();
break;
- case nonlval::SymIntConstraintValKind: {
- const nonlval::SymIntConstraintVal& C =
- *cast<nonlval::SymIntConstraintVal>(this);
+ case nonloc::SymIntConstraintValKind: {
+ const nonloc::SymIntConstraintVal& C =
+ *cast<nonloc::SymIntConstraintVal>(this);
Out << '$' << C.getConstraint().getSymbol() << ' ';
printOpcode(Out, C.getConstraint().getOpcode());
@@ -346,54 +346,54 @@ void NonLVal::print(std::ostream& Out) const {
break;
}
- case nonlval::LValAsIntegerKind: {
- const nonlval::LValAsInteger& C = *cast<nonlval::LValAsInteger>(this);
- C.getLVal().print(Out);
+ case nonloc::LocAsIntegerKind: {
+ const nonloc::LocAsInteger& C = *cast<nonloc::LocAsInteger>(this);
+ C.getLoc().print(Out);
Out << " [as " << C.getNumBits() << " bit integer]";
break;
}
default:
- assert (false && "Pretty-printed not implemented for this NonLVal.");
+ assert (false && "Pretty-printed not implemented for this NonLoc.");
break;
}
}
-void LVal::print(std::ostream& Out) const {
+void Loc::print(std::ostream& Out) const {
switch (getSubKind()) {
- case lval::ConcreteIntKind:
- Out << cast<lval::ConcreteInt>(this)->getValue().getZExtValue()
- << " (LVal)";
+ case loc::ConcreteIntKind:
+ Out << cast<loc::ConcreteInt>(this)->getValue().getZExtValue()
+ << " (Loc)";
break;
- case lval::SymbolValKind:
- Out << '$' << cast<lval::SymbolVal>(this)->getSymbol();
+ case loc::SymbolValKind:
+ Out << '$' << cast<loc::SymbolVal>(this)->getSymbol();
break;
- case lval::GotoLabelKind:
+ case loc::GotoLabelKind:
Out << "&&"
- << cast<lval::GotoLabel>(this)->getLabel()->getID()->getName();
+ << cast<loc::GotoLabel>(this)->getLabel()->getID()->getName();
break;
- case lval::MemRegionKind:
- Out << '&' << cast<lval::MemRegionVal>(this)->getRegion()->getString();
+ case loc::MemRegionKind:
+ Out << '&' << cast<loc::MemRegionVal>(this)->getRegion()->getString();
break;
- case lval::FuncValKind:
+ case loc::FuncValKind:
Out << "function "
- << cast<lval::FuncVal>(this)->getDecl()->getIdentifier()->getName();
+ << cast<loc::FuncVal>(this)->getDecl()->getIdentifier()->getName();
break;
- case lval::StringLiteralValKind:
+ case loc::StringLiteralValKind:
Out << "literal \""
- << cast<lval::StringLiteralVal>(this)->getLiteral()->getStrData()
+ << cast<loc::StringLiteralVal>(this)->getLiteral()->getStrData()
<< "\"";
break;
default:
- assert (false && "Pretty-printing not implemented for this LVal.");
+ assert (false && "Pretty-printing not implemented for this Loc.");
break;
}
}
diff --git a/clang/lib/Analysis/RegionStore.cpp b/clang/lib/Analysis/RegionStore.cpp
index 7004c5558e4..6757f43ae10 100644
--- a/clang/lib/Analysis/RegionStore.cpp
+++ b/clang/lib/Analysis/RegionStore.cpp
@@ -23,7 +23,7 @@
using namespace clang;
-typedef llvm::ImmutableMap<const MemRegion*, RVal> RegionBindingsTy;
+typedef llvm::ImmutableMap<const MemRegion*, SVal> RegionBindingsTy;
namespace {
@@ -38,7 +38,7 @@ public:
virtual ~RegionStoreManager() {}
- Store SetRVal(Store St, LVal LV, RVal V);
+ Store SetSVal(Store St, Loc LV, SVal V);
Store getInitialStore();
@@ -49,10 +49,10 @@ public:
} // end anonymous namespace
-Store RegionStoreManager::SetRVal(Store store, LVal LV, RVal V) {
- assert(LV.getSubKind() == lval::MemRegionKind);
+Store RegionStoreManager::SetSVal(Store store, Loc LV, SVal V) {
+ assert(LV.getSubKind() == loc::MemRegionKind);
- MemRegion* R = cast<lval::MemRegionVal>(LV).getRegion();
+ MemRegion* R = cast<loc::MemRegionVal>(LV).getRegion();
if (!R)
return store;
@@ -79,16 +79,16 @@ Store RegionStoreManager::getInitialStore() {
QualType T = VD->getType();
// Only handle pointers and integers for now.
- if (LVal::IsLValType(T) || T->isIntegerType()) {
+ if (Loc::IsLocType(T) || T->isIntegerType()) {
MemRegion* R = MRMgr.getVarRegion(VD);
// Initialize globals and parameters to symbolic values.
// Initialize local variables to undefined.
- RVal X = (VD->hasGlobalStorage() || isa<ParmVarDecl>(VD) ||
+ SVal X = (VD->hasGlobalStorage() || isa<ParmVarDecl>(VD) ||
isa<ImplicitParamDecl>(VD))
- ? RVal::GetSymbolValue(StateMgr.getSymbolManager(), VD)
+ ? SVal::GetSymbolValue(StateMgr.getSymbolManager(), VD)
: UndefinedVal();
- St = SetRVal(St, lval::MemRegionVal(R), X);
+ St = SetSVal(St, loc::MemRegionVal(R), X);
}
}
}
OpenPOWER on IntegriCloud