Rename 'SValuator' to 'SValBuilder'. The new name
reflects what the class actually does.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@120605 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/lib/Checker/AdjustedReturnValueChecker.cpp b/lib/Checker/AdjustedReturnValueChecker.cpp
index 0ed04fb..5f56401 100644
--- a/lib/Checker/AdjustedReturnValueChecker.cpp
+++ b/lib/Checker/AdjustedReturnValueChecker.cpp
@@ -88,8 +88,8 @@
if (expectedResultTy != actualResultTy) {
// FIXME: Do more checking and actual emit an error. At least performing
// the cast avoids some assertion failures elsewhere.
- SValuator &SVator = C.getSValuator();
- V = SVator.EvalCast(V, expectedResultTy, actualResultTy);
+ SValBuilder &svalBuilder = C.getSValBuilder();
+ V = svalBuilder.EvalCast(V, expectedResultTy, actualResultTy);
C.GenerateNode(state->BindExpr(CE, V));
}
}
diff --git a/lib/Checker/BasicObjCFoundationChecks.cpp b/lib/Checker/BasicObjCFoundationChecks.cpp
index 00b524a..c137e7d 100644
--- a/lib/Checker/BasicObjCFoundationChecks.cpp
+++ b/lib/Checker/BasicObjCFoundationChecks.cpp
@@ -413,8 +413,8 @@
DefinedSVal Zero = cast<DefinedSVal>(ValMgr.makeZeroVal(Arg->getType()));
// Make an expression asserting that they're equal.
- SValuator &SVator = ValMgr.getSValuator();
- DefinedOrUnknownSVal ArgIsNull = SVator.EvalEQ(state, Zero, *DefArgVal);
+ SValBuilder &svalBuilder = ValMgr.getSValBuilder();
+ DefinedOrUnknownSVal ArgIsNull = svalBuilder.EvalEQ(state, Zero, *DefArgVal);
// Are they equal?
const GRState *stateTrue, *stateFalse;
diff --git a/lib/Checker/BuiltinFunctionChecker.cpp b/lib/Checker/BuiltinFunctionChecker.cpp
index 057e474..6761a7a 100644
--- a/lib/Checker/BuiltinFunctionChecker.cpp
+++ b/lib/Checker/BuiltinFunctionChecker.cpp
@@ -70,9 +70,9 @@
ValueManager& ValMgr = C.getValueManager();
DefinedOrUnknownSVal Extent = R->getExtent(ValMgr);
- SValuator& SVator = ValMgr.getSValuator();
+ SValBuilder& svalBuilder = ValMgr.getSValBuilder();
DefinedOrUnknownSVal ExtentMatchesSizeArg =
- SVator.EvalEQ(state, Extent, Size);
+ svalBuilder.EvalEQ(state, Extent, Size);
state = state->Assume(ExtentMatchesSizeArg, true);
C.GenerateNode(state->BindExpr(CE, loc::MemRegionVal(R)));
diff --git a/lib/Checker/CMakeLists.txt b/lib/Checker/CMakeLists.txt
index e6f24dd..e55f733 100644
--- a/lib/Checker/CMakeLists.txt
+++ b/lib/Checker/CMakeLists.txt
@@ -66,10 +66,10 @@
RegionStore.cpp
ReturnPointerRangeChecker.cpp
ReturnUndefChecker.cpp
+ SValBuilder.cpp
SVals.cpp
- SValuator.cpp
SimpleConstraintManager.cpp
- SimpleSValuator.cpp
+ SimpleSValBuilder.cpp
StackAddrLeakChecker.cpp
Store.cpp
StreamChecker.cpp
diff --git a/lib/Checker/CStringChecker.cpp b/lib/Checker/CStringChecker.cpp
index a75e196..c60eca8 100644
--- a/lib/Checker/CStringChecker.cpp
+++ b/lib/Checker/CStringChecker.cpp
@@ -122,7 +122,7 @@
return std::pair<const GRState*, const GRState *>(state, state);
ValueManager &ValMgr = C.getValueManager();
- SValuator &SV = ValMgr.getSValuator();
+ SValBuilder &SV = ValMgr.getSValBuilder();
DefinedOrUnknownSVal Zero = ValMgr.makeZeroVal(Ty);
DefinedOrUnknownSVal ValIsZero = SV.EvalEQ(state, *Val, Zero);
@@ -245,7 +245,7 @@
return NULL;
ValueManager &VM = C.getValueManager();
- SValuator &SV = VM.getSValuator();
+ SValBuilder &SV = VM.getSValBuilder();
ASTContext &Ctx = C.getASTContext();
QualType SizeTy = Size->getType();
@@ -313,7 +313,7 @@
return NULL;
ValueManager &VM = state->getStateManager().getValueManager();
- SValuator &SV = VM.getSValuator();
+ SValBuilder &SV = VM.getSValBuilder();
ASTContext &Ctx = VM.getContext();
const GRState *stateTrue, *stateFalse;
@@ -716,7 +716,7 @@
const GRState *state = C.getState();
ValueManager &ValMgr = C.getValueManager();
- SValuator &SV = ValMgr.getSValuator();
+ SValBuilder &SV = ValMgr.getSValBuilder();
// See if the size argument is zero.
SVal SizeVal = state->getSVal(Size);
@@ -850,7 +850,7 @@
if (loc::MemRegionVal *DstRegVal = dyn_cast<loc::MemRegionVal>(&DstVal)) {
// If the length is known, we can check for an overflow.
if (NonLoc *KnownStrLen = dyn_cast<NonLoc>(&StrLen)) {
- SValuator &SV = C.getSValuator();
+ SValBuilder &SV = C.getSValBuilder();
SVal LastElement = SV.EvalBinOpLN(state, BO_Add,
*DstRegVal, *KnownStrLen,
diff --git a/lib/Checker/CastSizeChecker.cpp b/lib/Checker/CastSizeChecker.cpp
index 6676fe5..bb10f61 100644
--- a/lib/Checker/CastSizeChecker.cpp
+++ b/lib/Checker/CastSizeChecker.cpp
@@ -60,8 +60,8 @@
ValueManager &ValMgr = C.getValueManager();
SVal Extent = SR->getExtent(ValMgr);
- SValuator &SVator = ValMgr.getSValuator();
- const llvm::APSInt *ExtentInt = SVator.getKnownValue(state, Extent);
+ SValBuilder &svalBuilder = ValMgr.getSValBuilder();
+ const llvm::APSInt *ExtentInt = svalBuilder.getKnownValue(state, Extent);
if (!ExtentInt)
return;
diff --git a/lib/Checker/GRExprEngine.cpp b/lib/Checker/GRExprEngine.cpp
index fc0913b..3aa087b 100644
--- a/lib/Checker/GRExprEngine.cpp
+++ b/lib/Checker/GRExprEngine.cpp
@@ -326,7 +326,7 @@
*this),
SymMgr(StateMgr.getSymbolManager()),
ValMgr(StateMgr.getValueManager()),
- SVator(ValMgr.getSValuator()),
+ svalBuilder(ValMgr.getSValBuilder()),
EntryNode(NULL), CurrentStmt(NULL),
NSExceptionII(NULL), NSExceptionInstanceRaiseSelectors(NULL),
RaiseSel(GetNullarySelector("raise", getContext())),
@@ -1597,7 +1597,7 @@
do {
nonloc::ConcreteInt CaseVal(getBasicVals().getValue(V1.Val.getInt()));
- DefinedOrUnknownSVal Res = SVator.EvalEQ(DefaultSt ? DefaultSt : state,
+ DefinedOrUnknownSVal Res = svalBuilder.EvalEQ(DefaultSt ? DefaultSt : state,
CondV, CaseVal);
// Now "assume" that the case matches.
@@ -2691,12 +2691,12 @@
case CK_AnyPointerToBlockPointerCast:
case CK_ObjCObjectLValueCast: {
- // Delegate to SValuator to process.
+ // Delegate to SValBuilder to process.
for (ExplodedNodeSet::iterator I = S2.begin(), E = S2.end(); I != E; ++I) {
ExplodedNode* N = *I;
const GRState* state = GetState(N);
SVal V = state->getSVal(Ex);
- V = SVator.EvalCast(V, T, ExTy);
+ V = svalBuilder.EvalCast(V, T, ExTy);
state = state->BindExpr(CastE, V);
MakeNode(Dst, CastE, N, state);
}
@@ -3268,12 +3268,12 @@
// propagate that constraint.
if (Loc::IsLocType(U->getType())) {
DefinedOrUnknownSVal Constraint =
- SVator.EvalEQ(state, V2, ValMgr.makeZeroVal(U->getType()));
+ svalBuilder.EvalEQ(state, V2, ValMgr.makeZeroVal(U->getType()));
if (!state->Assume(Constraint, true)) {
// It isn't feasible for the original value to be null.
// Propagate this constraint.
- Constraint = SVator.EvalEQ(state, SymVal,
+ Constraint = svalBuilder.EvalEQ(state, SymVal,
ValMgr.makeZeroVal(U->getType()));
@@ -3516,10 +3516,10 @@
QualType RTy = getContext().getCanonicalType(RHS->getType());
// Promote LHS.
- V = SVator.EvalCast(V, CLHSTy, LTy);
+ V = svalBuilder.EvalCast(V, CLHSTy, LTy);
// Compute the result of the operation.
- SVal Result = SVator.EvalCast(EvalBinOp(state, Op, V, RightV, CTy),
+ SVal Result = svalBuilder.EvalCast(EvalBinOp(state, Op, V, RightV, CTy),
B->getType(), CTy);
// EXPERIMENTAL: "Conjured" symbols.
@@ -3538,12 +3538,12 @@
LHSVal = ValMgr.getConjuredSymbolVal(NULL, B->getRHS(), LTy, Count);
// However, we need to convert the symbol to the computation type.
- Result = SVator.EvalCast(LHSVal, CTy, LTy);
+ Result = svalBuilder.EvalCast(LHSVal, CTy, LTy);
}
else {
// The left-hand side may bind to a different value then the
// computation type.
- LHSVal = SVator.EvalCast(Result, LTy, CTy);
+ LHSVal = svalBuilder.EvalCast(Result, LTy, CTy);
}
EvalStore(Tmp3, B, LHS, *I4, state->BindExpr(B, Result),
diff --git a/lib/Checker/GRState.cpp b/lib/Checker/GRState.cpp
index 86b6f81..4a55cee 100644
--- a/lib/Checker/GRState.cpp
+++ b/lib/Checker/GRState.cpp
@@ -238,10 +238,10 @@
// Build an expression for 0 <= Idx < UpperBound.
// This is the same as Idx + MIN < UpperBound + MIN, if overflow is allowed.
- // FIXME: This should probably be part of SValuator.
+ // FIXME: This should probably be part of SValBuilder.
GRStateManager &SM = getStateManager();
ValueManager &VM = SM.getValueManager();
- SValuator &SV = VM.getSValuator();
+ SValBuilder &SV = VM.getSValBuilder();
ASTContext &Ctx = VM.getContext();
// Get the offset: the minimum value of the array index type.
diff --git a/lib/Checker/MallocChecker.cpp b/lib/Checker/MallocChecker.cpp
index 2456b1d..5f7984c 100644
--- a/lib/Checker/MallocChecker.cpp
+++ b/lib/Checker/MallocChecker.cpp
@@ -241,9 +241,9 @@
DefinedOrUnknownSVal Extent = R->getExtent(ValMgr);
DefinedOrUnknownSVal DefinedSize = cast<DefinedOrUnknownSVal>(Size);
- SValuator &SVator = ValMgr.getSValuator();
+ SValBuilder &svalBuilder = ValMgr.getSValBuilder();
DefinedOrUnknownSVal ExtentMatchesSize =
- SVator.EvalEQ(state, Extent, DefinedSize);
+ svalBuilder.EvalEQ(state, Extent, DefinedSize);
state = state->Assume(ExtentMatchesSize, true);
SymbolRef Sym = RetVal.getAsLocSymbol();
@@ -504,9 +504,9 @@
DefinedOrUnknownSVal Arg0Val=cast<DefinedOrUnknownSVal>(state->getSVal(Arg0));
ValueManager &ValMgr = C.getValueManager();
- SValuator &SVator = C.getSValuator();
+ SValBuilder &svalBuilder = C.getSValBuilder();
- DefinedOrUnknownSVal PtrEQ = SVator.EvalEQ(state, Arg0Val, ValMgr.makeNull());
+ DefinedOrUnknownSVal PtrEQ = svalBuilder.EvalEQ(state, Arg0Val, ValMgr.makeNull());
// If the ptr is NULL, the call is equivalent to malloc(size).
if (const GRState *stateEqual = state->Assume(PtrEQ, true)) {
@@ -527,7 +527,7 @@
const Expr *Arg1 = CE->getArg(1);
DefinedOrUnknownSVal Arg1Val =
cast<DefinedOrUnknownSVal>(stateNotEqual->getSVal(Arg1));
- DefinedOrUnknownSVal SizeZero = SVator.EvalEQ(stateNotEqual, Arg1Val,
+ DefinedOrUnknownSVal SizeZero = svalBuilder.EvalEQ(stateNotEqual, Arg1Val,
ValMgr.makeIntValWithPtrWidth(0, false));
if (const GRState *stateSizeZero = stateNotEqual->Assume(SizeZero, true)) {
@@ -552,11 +552,11 @@
const GRState *state = C.getState();
ValueManager &ValMgr = C.getValueManager();
- SValuator &SVator = C.getSValuator();
+ SValBuilder &svalBuilder = C.getSValBuilder();
SVal Count = state->getSVal(CE->getArg(0));
SVal EleSize = state->getSVal(CE->getArg(1));
- SVal TotalSize = SVator.EvalBinOp(state, BO_Mul, Count, EleSize,
+ SVal TotalSize = svalBuilder.EvalBinOp(state, BO_Mul, Count, EleSize,
ValMgr.getContext().getSizeType());
SVal Zero = ValMgr.makeZeroVal(ValMgr.getContext().CharTy);
diff --git a/lib/Checker/OSAtomicChecker.cpp b/lib/Checker/OSAtomicChecker.cpp
index 02de0a8..15989ec 100644
--- a/lib/Checker/OSAtomicChecker.cpp
+++ b/lib/Checker/OSAtomicChecker.cpp
@@ -142,10 +142,10 @@
DefinedOrUnknownSVal oldValueVal =
cast<DefinedOrUnknownSVal>(oldValueVal_untested);
- SValuator &SVator = Engine.getSValuator();
+ SValBuilder &svalBuilder = Engine.getSValBuilder();
// Perform the comparison.
- DefinedOrUnknownSVal Cmp = SVator.EvalEQ(stateLoad,theValueVal,oldValueVal);
+ DefinedOrUnknownSVal Cmp = svalBuilder.EvalEQ(stateLoad,theValueVal,oldValueVal);
const GRState *stateEqual = stateLoad->Assume(Cmp, true);
@@ -158,7 +158,7 @@
// Handle implicit value casts.
if (const TypedRegion *R =
dyn_cast_or_null<TypedRegion>(location.getAsRegion())) {
- val = SVator.EvalCast(val,R->getValueType(), newValueExpr->getType());
+ val = svalBuilder.EvalCast(val,R->getValueType(), newValueExpr->getType());
}
Engine.EvalStore(TmpStore, NULL, theValueExpr, N,
diff --git a/lib/Checker/RegionStore.cpp b/lib/Checker/RegionStore.cpp
index ae0dedf..cde8ab9 100644
--- a/lib/Checker/RegionStore.cpp
+++ b/lib/Checker/RegionStore.cpp
@@ -756,8 +756,8 @@
const MemRegion *R,
QualType EleTy) {
SVal Size = cast<SubRegion>(R)->getExtent(ValMgr);
- SValuator &SVator = ValMgr.getSValuator();
- const llvm::APSInt *SizeInt = SVator.getKnownValue(state, Size);
+ SValBuilder &svalBuilder = ValMgr.getSValBuilder();
+ const llvm::APSInt *SizeInt = svalBuilder.getKnownValue(state, Size);
if (!SizeInt)
return UnknownVal();
@@ -911,7 +911,7 @@
// (b) 0 + symbolic index
if (Base) {
if (nonloc::ConcreteInt *Offset = dyn_cast<nonloc::ConcreteInt>(&R)) {
- // FIXME: Should use SValuator here.
+ // FIXME: Should use SValBuilder here.
SVal NewIdx =
Base->evalBinOp(ValMgr, Op,
cast<nonloc::ConcreteInt>(ValMgr.convertToArrayIndex(*Offset)));
@@ -1307,8 +1307,8 @@
if (const IntegerLiteral *IL =
dyn_cast<IntegerLiteral>(Init->IgnoreParenCasts())) {
const nonloc::ConcreteInt &V = ValMgr.makeIntVal(IL);
- return ValMgr.getSValuator().EvalCast(V, Init->getType(),
- IL->getType());
+ return ValMgr.getSValBuilder().EvalCast(V, Init->getType(),
+ IL->getType());
}
}
diff --git a/lib/Checker/SValuator.cpp b/lib/Checker/SValBuilder.cpp
similarity index 92%
rename from lib/Checker/SValuator.cpp
rename to lib/Checker/SValBuilder.cpp
index 73bd867..8bc9594 100644
--- a/lib/Checker/SValuator.cpp
+++ b/lib/Checker/SValBuilder.cpp
@@ -1,4 +1,4 @@
-// SValuator.cpp - Basic class for all SValuator implementations --*- C++ -*--//
+// SValBuilder.cpp - Basic class for all SValBuilder implementations -*- C++ -*-
//
// The LLVM Compiler Infrastructure
//
@@ -7,18 +7,18 @@
//
//===----------------------------------------------------------------------===//
//
-// This file defines SValuator, the base class for all (complete) SValuator
+// This file defines SValBuilder, the base class for all (complete) SValBuilder
// implementations.
//
//===----------------------------------------------------------------------===//
-#include "clang/Checker/PathSensitive/SValuator.h"
+#include "clang/Checker/PathSensitive/SValBuilder.h"
#include "clang/Checker/PathSensitive/GRState.h"
using namespace clang;
-SVal SValuator::EvalBinOp(const GRState *ST, BinaryOperator::Opcode Op,
+SVal SValBuilder::EvalBinOp(const GRState *ST, BinaryOperator::Opcode Op,
SVal L, SVal R, QualType T) {
if (L.isUndef() || R.isUndef())
@@ -46,7 +46,7 @@
return EvalBinOpNN(ST, Op, cast<NonLoc>(L), cast<NonLoc>(R), T);
}
-DefinedOrUnknownSVal SValuator::EvalEQ(const GRState *ST,
+DefinedOrUnknownSVal SValBuilder::EvalEQ(const GRState *ST,
DefinedOrUnknownSVal L,
DefinedOrUnknownSVal R) {
return cast<DefinedOrUnknownSVal>(EvalBinOp(ST, BO_EQ, L, R,
@@ -54,7 +54,7 @@
}
// FIXME: should rewrite according to the cast kind.
-SVal SValuator::EvalCast(SVal val, QualType castTy, QualType originalTy) {
+SVal SValBuilder::EvalCast(SVal val, QualType castTy, QualType originalTy) {
if (val.isUnknownOrUndef() || castTy == originalTy)
return val;
diff --git a/lib/Checker/SimpleConstraintManager.cpp b/lib/Checker/SimpleConstraintManager.cpp
index 04496e1..3fdf790 100644
--- a/lib/Checker/SimpleConstraintManager.cpp
+++ b/lib/Checker/SimpleConstraintManager.cpp
@@ -121,7 +121,7 @@
static BinaryOperator::Opcode NegateComparison(BinaryOperator::Opcode op) {
// FIXME: This should probably be part of BinaryOperator, since this isn't
- // the only place it's used. (This code was copied from SimpleSValuator.cpp.)
+ // the only place it's used. (This code was copied from SimpleSValBuilder.cpp.)
switch (op) {
default:
assert(false && "Invalid opcode.");
diff --git a/lib/Checker/SimpleSValuator.cpp b/lib/Checker/SimpleSValBuilder.cpp
similarity index 96%
rename from lib/Checker/SimpleSValuator.cpp
rename to lib/Checker/SimpleSValBuilder.cpp
index 782cd4f..b8cad7a 100644
--- a/lib/Checker/SimpleSValuator.cpp
+++ b/lib/Checker/SimpleSValBuilder.cpp
@@ -1,4 +1,4 @@
-// SimpleSValuator.cpp - A basic SValuator ------------------------*- C++ -*--//
+// SimpleSValBuilder.cpp - A basic SValBuilder -----------------------*- C++ -*-
//
// The LLVM Compiler Infrastructure
//
@@ -7,24 +7,24 @@
//
//===----------------------------------------------------------------------===//
//
-// This file defines SimpleSValuator, a basic implementation of SValuator.
+// This file defines SimpleSValBuilder, a basic implementation of SValBuilder.
//
//===----------------------------------------------------------------------===//
-#include "clang/Checker/PathSensitive/SValuator.h"
+#include "clang/Checker/PathSensitive/SValBuilder.h"
#include "clang/Checker/PathSensitive/GRState.h"
using namespace clang;
namespace {
-class SimpleSValuator : public SValuator {
+class SimpleSValBuilder : public SValBuilder {
protected:
virtual SVal EvalCastNL(NonLoc val, QualType castTy);
virtual SVal EvalCastL(Loc val, QualType castTy);
public:
- SimpleSValuator(ValueManager &valMgr) : SValuator(valMgr) {}
- virtual ~SimpleSValuator() {}
+ SimpleSValBuilder(ValueManager &valMgr) : SValBuilder(valMgr) {}
+ virtual ~SimpleSValBuilder() {}
virtual SVal EvalMinus(NonLoc val);
virtual SVal EvalComplement(NonLoc val);
@@ -44,15 +44,15 @@
};
} // end anonymous namespace
-SValuator *clang::CreateSimpleSValuator(ValueManager &valMgr) {
- return new SimpleSValuator(valMgr);
+SValBuilder *clang::createSimpleSValBuilder(ValueManager &valMgr) {
+ return new SimpleSValBuilder(valMgr);
}
//===----------------------------------------------------------------------===//
// Transfer function for Casts.
//===----------------------------------------------------------------------===//
-SVal SimpleSValuator::EvalCastNL(NonLoc val, QualType castTy) {
+SVal SimpleSValBuilder::EvalCastNL(NonLoc val, QualType castTy) {
bool isLocType = Loc::IsLocType(castTy);
@@ -104,7 +104,7 @@
return ValMgr.makeIntVal(i);
}
-SVal SimpleSValuator::EvalCastL(Loc val, QualType castTy) {
+SVal SimpleSValBuilder::EvalCastL(Loc val, QualType castTy) {
// Casts from pointers -> pointers, just return the lval.
//
@@ -142,7 +142,7 @@
// Transfer function for unary operators.
//===----------------------------------------------------------------------===//
-SVal SimpleSValuator::EvalMinus(NonLoc val) {
+SVal SimpleSValBuilder::EvalMinus(NonLoc val) {
switch (val.getSubKind()) {
case nonloc::ConcreteIntKind:
return cast<nonloc::ConcreteInt>(val).evalMinus(ValMgr);
@@ -151,7 +151,7 @@
}
}
-SVal SimpleSValuator::EvalComplement(NonLoc X) {
+SVal SimpleSValBuilder::EvalComplement(NonLoc X) {
switch (X.getSubKind()) {
case nonloc::ConcreteIntKind:
return cast<nonloc::ConcreteInt>(X).evalComplement(ValMgr);
@@ -191,7 +191,7 @@
}
}
-SVal SimpleSValuator::MakeSymIntVal(const SymExpr *LHS,
+SVal SimpleSValBuilder::MakeSymIntVal(const SymExpr *LHS,
BinaryOperator::Opcode op,
const llvm::APSInt &RHS,
QualType resultTy) {
@@ -266,7 +266,7 @@
return ValMgr.makeNonLoc(LHS, op, RHS, resultTy);
}
-SVal SimpleSValuator::EvalBinOpNN(const GRState *state,
+SVal SimpleSValBuilder::EvalBinOpNN(const GRState *state,
BinaryOperator::Opcode op,
NonLoc lhs, NonLoc rhs,
QualType resultTy) {
@@ -515,7 +515,7 @@
}
// FIXME: all this logic will change if/when we have MemRegion::getLocation().
-SVal SimpleSValuator::EvalBinOpLL(const GRState *state,
+SVal SimpleSValBuilder::EvalBinOpLL(const GRState *state,
BinaryOperator::Opcode op,
Loc lhs, Loc rhs,
QualType resultTy) {
@@ -812,7 +812,7 @@
}
}
-SVal SimpleSValuator::EvalBinOpLN(const GRState *state,
+SVal SimpleSValBuilder::EvalBinOpLN(const GRState *state,
BinaryOperator::Opcode op,
Loc lhs, NonLoc rhs, QualType resultTy) {
// Special case: 'rhs' is an integer that has the same width as a pointer and
@@ -872,7 +872,7 @@
rhs, resultTy);
}
-const llvm::APSInt *SimpleSValuator::getKnownValue(const GRState *state,
+const llvm::APSInt *SimpleSValBuilder::getKnownValue(const GRState *state,
SVal V) {
if (V.isUnknownOrUndef())
return NULL;
diff --git a/lib/Checker/Store.cpp b/lib/Checker/Store.cpp
index 2e03009..1259d19 100644
--- a/lib/Checker/Store.cpp
+++ b/lib/Checker/Store.cpp
@@ -225,9 +225,9 @@
}
if (const Loc *L = dyn_cast<Loc>(&V))
- return ValMgr.getSValuator().EvalCastL(*L, castTy);
+ return ValMgr.getSValBuilder().EvalCastL(*L, castTy);
else if (const NonLoc *NL = dyn_cast<NonLoc>(&V))
- return ValMgr.getSValuator().EvalCastNL(*NL, castTy);
+ return ValMgr.getSValBuilder().EvalCastNL(*NL, castTy);
return V;
}
@@ -309,7 +309,7 @@
// Only allow non-integer offsets if the base region has no offset itself.
// FIXME: This is a somewhat arbitrary restriction. We should be using
- // SValuator here to add the two offsets without checking their types.
+ // SValBuilder here to add the two offsets without checking their types.
if (!isa<nonloc::ConcreteInt>(Offset)) {
if (isa<ElementRegion>(BaseRegion->StripCasts()))
return UnknownVal();
diff --git a/lib/Checker/UnixAPIChecker.cpp b/lib/Checker/UnixAPIChecker.cpp
index 59a83f7..93d1de2 100644
--- a/lib/Checker/UnixAPIChecker.cpp
+++ b/lib/Checker/UnixAPIChecker.cpp
@@ -101,9 +101,9 @@
NonLoc ocreateFlag =
cast<NonLoc>(C.getValueManager().makeIntVal(UC.Val_O_CREAT.getValue(),
oflagsEx->getType()));
- SVal maskedFlagsUC = C.getSValuator().EvalBinOpNN(state, BO_And,
- oflags, ocreateFlag,
- oflagsEx->getType());
+ SVal maskedFlagsUC = C.getSValBuilder().EvalBinOpNN(state, BO_And,
+ oflags, ocreateFlag,
+ oflagsEx->getType());
if (maskedFlagsUC.isUnknownOrUndef())
return;
DefinedSVal maskedFlags = cast<DefinedSVal>(maskedFlagsUC);
diff --git a/lib/Checker/VLASizeChecker.cpp b/lib/Checker/VLASizeChecker.cpp
index 0800b8b..214db93 100644
--- a/lib/Checker/VLASizeChecker.cpp
+++ b/lib/Checker/VLASizeChecker.cpp
@@ -108,7 +108,7 @@
// Convert the array length to size_t.
ValueManager &ValMgr = C.getValueManager();
- SValuator &SV = ValMgr.getSValuator();
+ SValBuilder &SV = ValMgr.getSValBuilder();
QualType SizeTy = Ctx.getSizeType();
NonLoc ArrayLength = cast<NonLoc>(SV.EvalCast(sizeD, SizeTy, SE->getType()));
diff --git a/lib/Checker/ValueManager.cpp b/lib/Checker/ValueManager.cpp
index 8b7cd7b..484e48e 100644
--- a/lib/Checker/ValueManager.cpp
+++ b/lib/Checker/ValueManager.cpp
@@ -67,7 +67,7 @@
return V;
}
- return SVator->EvalCastNL(cast<NonLoc>(V), ArrayIndexTy);
+ return svalBuilder->EvalCastNL(cast<NonLoc>(V), ArrayIndexTy);
}
DefinedOrUnknownSVal