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/BasicConstraintManager.cpp b/lib/Analysis/BasicConstraintManager.cpp
index 8d391bb..aab1f5e 100644
--- a/lib/Analysis/BasicConstraintManager.cpp
+++ b/lib/Analysis/BasicConstraintManager.cpp
@@ -33,19 +33,19 @@
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 @@
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::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 @@
}
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 @@
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
}