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/GRSimpleVals.cpp b/lib/Analysis/GRSimpleVals.cpp
index 07ec3e8..2b1d9b5 100644
--- a/lib/Analysis/GRSimpleVals.cpp
+++ b/lib/Analysis/GRSimpleVals.cpp
@@ -36,32 +36,32 @@
// 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 @@
// 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 @@
(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 @@
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 @@
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 @@
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 @@
// 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 @@
// 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 @@
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 @@
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 @@
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 @@
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 @@
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);