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/GRExprEngine.cpp b/lib/Analysis/GRExprEngine.cpp
index bc7a00a..d8ab4b1 100644
--- a/lib/Analysis/GRExprEngine.cpp
+++ b/lib/Analysis/GRExprEngine.cpp
@@ -302,7 +302,7 @@
}
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 @@
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 @@
(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 @@
else
Ex = C->getRHS();
- return SetBlkExprRVal(St, C, UndefinedVal(Ex));
+ return SetBlkExprSVal(St, C, UndefinedVal(Ex));
}
case Stmt::ChooseExprClass: { // ?:
@@ -498,7 +498,7 @@
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 @@
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::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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
// 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 @@
// 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 @@
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 @@
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 @@
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 @@
// 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 @@
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 @@
// 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 @@
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 @@
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 @@
// 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::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 @@
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 @@
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 @@
//
// 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 @@
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 @@
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 @@
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 @@
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 @@
// 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
// 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 @@
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 @@
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 @@
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 @@
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 @@
// 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 @@
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 @@
// 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 @@
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 @@
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 @@
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 @@
// 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 @@
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 @@
// 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
//===----------------------------------------------------------------------===//
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 @@
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 @@
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 @@
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 @@
// 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 @@
// 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 @@
// 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 @@
}
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 @@
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::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(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 @@
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))