This patch did the following renaming. There should be no functional changes.
RVal => SVal
LVal => Loc
NonLVal => NonLoc
lval => loc
nonlval => nonloc
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@57671 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/lib/Analysis/CFRefCount.cpp b/lib/Analysis/CFRefCount.cpp
index c63529a..9d63231 100644
--- a/lib/Analysis/CFRefCount.cpp
+++ b/lib/Analysis/CFRefCount.cpp
@@ -1297,7 +1297,7 @@
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 @@
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 @@
// 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 @@
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 @@
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 @@
// 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 @@
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 @@
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 @@
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 @@
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 @@
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::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 @@
// 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 @@
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 @@
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 @@
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 @@
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 @@
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;
}