From: Ted Kremenek Date: Wed, 1 Dec 2010 21:28:31 +0000 (+0000) Subject: Rename 'SValuator' to 'SValBuilder'. The new name X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=846eabd187be4bfe992e8bca131166b734d86e0d;p=clang 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/include/clang/Checker/PathSensitive/Checker.h b/include/clang/Checker/PathSensitive/Checker.h index 136a29da5f..6ea5b77163 100644 --- a/include/clang/Checker/PathSensitive/Checker.h +++ b/include/clang/Checker/PathSensitive/Checker.h @@ -91,8 +91,8 @@ public: return Eng.getValueManager(); } - SValuator &getSValuator() { - return Eng.getSValuator(); + SValBuilder &getSValBuilder() { + return Eng.getSValBuilder(); } ExplodedNode *GenerateNode(bool autoTransition = true) { diff --git a/include/clang/Checker/PathSensitive/GRExprEngine.h b/include/clang/Checker/PathSensitive/GRExprEngine.h index 519a3e4c6f..69a81ef1b6 100644 --- a/include/clang/Checker/PathSensitive/GRExprEngine.h +++ b/include/clang/Checker/PathSensitive/GRExprEngine.h @@ -53,8 +53,8 @@ class GRExprEngine : public GRSubEngine { /// ValMgr - Object that manages/creates SVals. ValueManager &ValMgr; - /// SVator - SValuator object that creates SVals from expressions. - SValuator &SVator; + /// svalBuilder - SValBuilder object that creates SVals from expressions. + SValBuilder &svalBuilder; /// EntryNode - The immediate predecessor node. ExplodedNode* EntryNode; @@ -136,7 +136,7 @@ public: virtual AnalysisManager &getAnalysisManager() { return AMgr; } - SValuator &getSValuator() { return SVator; } + SValBuilder &getSValBuilder() { return svalBuilder; } GRTransferFuncs& getTF() { return *TF; } @@ -484,28 +484,28 @@ public: const Expr *Ex); SVal EvalMinus(SVal X) { - return X.isValid() ? SVator.EvalMinus(cast(X)) : X; + return X.isValid() ? svalBuilder.EvalMinus(cast(X)) : X; } SVal EvalComplement(SVal X) { - return X.isValid() ? SVator.EvalComplement(cast(X)) : X; + return X.isValid() ? svalBuilder.EvalComplement(cast(X)) : X; } public: SVal EvalBinOp(const GRState *state, BinaryOperator::Opcode op, NonLoc L, NonLoc R, QualType T) { - return SVator.EvalBinOpNN(state, op, L, R, T); + return svalBuilder.EvalBinOpNN(state, op, L, R, T); } SVal EvalBinOp(const GRState *state, BinaryOperator::Opcode op, NonLoc L, SVal R, QualType T) { - return R.isValid() ? SVator.EvalBinOpNN(state,op,L, cast(R), T) : R; + return R.isValid() ? svalBuilder.EvalBinOpNN(state,op,L, cast(R), T) : R; } SVal EvalBinOp(const GRState *ST, BinaryOperator::Opcode Op, SVal LHS, SVal RHS, QualType T) { - return SVator.EvalBinOp(ST, Op, LHS, RHS, T); + return svalBuilder.EvalBinOp(ST, Op, LHS, RHS, T); } protected: diff --git a/include/clang/Checker/PathSensitive/SValuator.h b/include/clang/Checker/PathSensitive/SValBuilder.h similarity index 83% rename from include/clang/Checker/PathSensitive/SValuator.h rename to include/clang/Checker/PathSensitive/SValBuilder.h index 9192ca7b86..22e0cc683c 100644 --- a/include/clang/Checker/PathSensitive/SValuator.h +++ b/include/clang/Checker/PathSensitive/SValBuilder.h @@ -1,4 +1,4 @@ -// SValuator.h - Construction of SVals from evaluating expressions -*- C++ -*--- +// SValBuilder.h - Construction of SVals from evaluating expressions -*- C++ -*- // // The LLVM Compiler Infrastructure // @@ -7,13 +7,13 @@ // //===----------------------------------------------------------------------===// // -// This file defines SValuator, a class that defines the interface for +// This file defines SValBuilder, a class that defines the interface for // "symbolical evaluators" which construct an SVal from an expression. // //===----------------------------------------------------------------------===// -#ifndef LLVM_CLANG_ANALYSIS_SVALUATOR -#define LLVM_CLANG_ANALYSIS_SVALUATOR +#ifndef LLVM_CLANG_ANALYSIS_SVALBUILDER +#define LLVM_CLANG_ANALYSIS_SVALBUILDER #include "clang/AST/Expr.h" #include "clang/Checker/PathSensitive/SVals.h" @@ -23,7 +23,7 @@ namespace clang { class GRState; class ValueManager; -class SValuator { +class SValBuilder { friend class ValueManager; protected: ValueManager &ValMgr; @@ -35,8 +35,8 @@ public: virtual SVal EvalCastL(Loc val, QualType castTy) = 0; public: - SValuator(ValueManager &valMgr) : ValMgr(valMgr) {} - virtual ~SValuator() {} + SValBuilder(ValueManager &valMgr) : ValMgr(valMgr) {} + virtual ~SValBuilder() {} SVal EvalCast(SVal V, QualType castTy, QualType originalType); @@ -64,7 +64,7 @@ public: DefinedOrUnknownSVal R); }; -SValuator* CreateSimpleSValuator(ValueManager &valMgr); +SValBuilder* createSimpleSValBuilder(ValueManager &valMgr); } // end clang namespace #endif diff --git a/include/clang/Checker/PathSensitive/ValueManager.h b/include/clang/Checker/PathSensitive/ValueManager.h index b81e9c1502..98b4f21f31 100644 --- a/include/clang/Checker/PathSensitive/ValueManager.h +++ b/include/clang/Checker/PathSensitive/ValueManager.h @@ -21,7 +21,7 @@ #include "clang/Checker/PathSensitive/SVals.h" #include "clang/Checker/PathSensitive/BasicValueFactory.h" #include "clang/Checker/PathSensitive/SymbolManager.h" -#include "clang/Checker/PathSensitive/SValuator.h" +#include "clang/Checker/PathSensitive/SValBuilder.h" #include "clang/AST/ExprCXX.h" namespace llvm { class BumpPtrAllocator; } @@ -38,8 +38,8 @@ class ValueManager { /// SymMgr - Object that manages the symbol information. SymbolManager SymMgr; - /// SVator - SValuator object that creates SVals from expressions. - llvm::OwningPtr SVator; + /// svalBuilder - SValBuilder object that creates SVals from expressions. + llvm::OwningPtr svalBuilder; MemRegionManager MemMgr; @@ -57,7 +57,7 @@ public: ArrayIndexTy(context.IntTy), ArrayIndexWidth(context.getTypeSize(ArrayIndexTy)) { // FIXME: Generalize later. - SVator.reset(clang::CreateSimpleSValuator(*this)); + svalBuilder.reset(clang::createSimpleSValBuilder(*this)); } // Accessors to submanagers. @@ -73,7 +73,7 @@ public: SymbolManager &getSymbolManager() { return SymMgr; } const SymbolManager &getSymbolManager() const { return SymMgr; } - SValuator &getSValuator() { return *SVator.get(); } + SValBuilder &getSValBuilder() { return *svalBuilder.get(); } MemRegionManager &getRegionManager() { return MemMgr; } const MemRegionManager &getRegionManager() const { return MemMgr; } diff --git a/lib/Checker/AdjustedReturnValueChecker.cpp b/lib/Checker/AdjustedReturnValueChecker.cpp index 0ed04fb14a..5f56401413 100644 --- a/lib/Checker/AdjustedReturnValueChecker.cpp +++ b/lib/Checker/AdjustedReturnValueChecker.cpp @@ -88,8 +88,8 @@ void AdjustedReturnValueChecker::PostVisitCallExpr(CheckerContext &C, 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 00b524a9be..c137e7d6f7 100644 --- a/lib/Checker/BasicObjCFoundationChecks.cpp +++ b/lib/Checker/BasicObjCFoundationChecks.cpp @@ -413,8 +413,8 @@ void CFRetainReleaseChecker::PreVisitCallExpr(CheckerContext& C, DefinedSVal Zero = cast(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 057e474626..6761a7a567 100644 --- a/lib/Checker/BuiltinFunctionChecker.cpp +++ b/lib/Checker/BuiltinFunctionChecker.cpp @@ -70,9 +70,9 @@ bool BuiltinFunctionChecker::EvalCallExpr(CheckerContext &C,const CallExpr *CE){ 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 e6f24dd78d..e55f733ff9 100644 --- a/lib/Checker/CMakeLists.txt +++ b/lib/Checker/CMakeLists.txt @@ -66,10 +66,10 @@ add_clang_library(clangChecker 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 a75e196e37..c60eca8fc0 100644 --- a/lib/Checker/CStringChecker.cpp +++ b/lib/Checker/CStringChecker.cpp @@ -122,7 +122,7 @@ CStringChecker::AssumeZero(CheckerContext &C, const GRState *state, SVal V, return std::pair(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 @@ const GRState *CStringChecker::CheckBufferAccess(CheckerContext &C, 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 @@ const GRState *CStringChecker::CheckOverlap(CheckerContext &C, 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 @@ void CStringChecker::EvalMemcmp(CheckerContext &C, const CallExpr *CE) { 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 @@ void CStringChecker::EvalStrcpyCommon(CheckerContext &C, const CallExpr *CE, if (loc::MemRegionVal *DstRegVal = dyn_cast(&DstVal)) { // If the length is known, we can check for an overflow. if (NonLoc *KnownStrLen = dyn_cast(&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 6676fe5e7a..bb10f61475 100644 --- a/lib/Checker/CastSizeChecker.cpp +++ b/lib/Checker/CastSizeChecker.cpp @@ -60,8 +60,8 @@ void CastSizeChecker::PreVisitCastExpr(CheckerContext &C, const CastExpr *CE) { 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 fc0913bc2f..3aa087b52c 100644 --- a/lib/Checker/GRExprEngine.cpp +++ b/lib/Checker/GRExprEngine.cpp @@ -326,7 +326,7 @@ GRExprEngine::GRExprEngine(AnalysisManager &mgr, GRTransferFuncs *tf) *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 @@ void GRExprEngine::ProcessSwitch(GRSwitchNodeBuilder& builder) { 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 @@ void GRExprEngine::VisitCast(const CastExpr *CastE, const Expr *Ex, 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 @@ void GRExprEngine::VisitUnaryOperator(const UnaryOperator* U, // 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 @@ void GRExprEngine::VisitBinaryOperator(const BinaryOperator* B, 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 @@ void GRExprEngine::VisitBinaryOperator(const BinaryOperator* B, 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 86b6f81658..4a55cee1e2 100644 --- a/lib/Checker/GRState.cpp +++ b/lib/Checker/GRState.cpp @@ -238,10 +238,10 @@ const GRState *GRState::AssumeInBound(DefinedOrUnknownSVal Idx, // 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 2456b1d659..5f7984c30f 100644 --- a/lib/Checker/MallocChecker.cpp +++ b/lib/Checker/MallocChecker.cpp @@ -241,9 +241,9 @@ const GRState *MallocChecker::MallocMemAux(CheckerContext &C, DefinedOrUnknownSVal Extent = R->getExtent(ValMgr); DefinedOrUnknownSVal DefinedSize = cast(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 @@ void MallocChecker::ReallocMem(CheckerContext &C, const CallExpr *CE) { DefinedOrUnknownSVal Arg0Val=cast(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 @@ void MallocChecker::ReallocMem(CheckerContext &C, const CallExpr *CE) { const Expr *Arg1 = CE->getArg(1); DefinedOrUnknownSVal Arg1Val = cast(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 @@ void MallocChecker::CallocMem(CheckerContext &C, const CallExpr *CE) { 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 02de0a84a4..15989ecdb9 100644 --- a/lib/Checker/OSAtomicChecker.cpp +++ b/lib/Checker/OSAtomicChecker.cpp @@ -142,10 +142,10 @@ bool OSAtomicChecker::EvalOSAtomicCompareAndSwap(CheckerContext &C, DefinedOrUnknownSVal oldValueVal = cast(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 @@ bool OSAtomicChecker::EvalOSAtomicCompareAndSwap(CheckerContext &C, // Handle implicit value casts. if (const TypedRegion *R = dyn_cast_or_null(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 ae0dedff39..cde8ab978d 100644 --- a/lib/Checker/RegionStore.cpp +++ b/lib/Checker/RegionStore.cpp @@ -756,8 +756,8 @@ DefinedOrUnknownSVal RegionStoreManager::getSizeInElements(const GRState *state, const MemRegion *R, QualType EleTy) { SVal Size = cast(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 @@ SVal RegionStoreManager::EvalBinOp(BinaryOperator::Opcode Op, Loc L, NonLoc R, // (b) 0 + symbolic index if (Base) { if (nonloc::ConcreteInt *Offset = dyn_cast(&R)) { - // FIXME: Should use SValuator here. + // FIXME: Should use SValBuilder here. SVal NewIdx = Base->evalBinOp(ValMgr, Op, cast(ValMgr.convertToArrayIndex(*Offset))); @@ -1307,8 +1307,8 @@ SVal RegionStoreManager::RetrieveVar(Store store, const VarRegion *R) { if (const IntegerLiteral *IL = dyn_cast(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 73bd86771f..8bc95941c0 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 @@ SVal SValuator::EvalBinOp(const GRState *ST, BinaryOperator::Opcode Op, return EvalBinOpNN(ST, Op, cast(L), cast(R), T); } -DefinedOrUnknownSVal SValuator::EvalEQ(const GRState *ST, +DefinedOrUnknownSVal SValBuilder::EvalEQ(const GRState *ST, DefinedOrUnknownSVal L, DefinedOrUnknownSVal R) { return cast(EvalBinOp(ST, BO_EQ, L, R, @@ -54,7 +54,7 @@ DefinedOrUnknownSVal SValuator::EvalEQ(const GRState *ST, } // 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 04496e1e33..3fdf7902c2 100644 --- a/lib/Checker/SimpleConstraintManager.cpp +++ b/lib/Checker/SimpleConstraintManager.cpp @@ -121,7 +121,7 @@ const GRState *SimpleConstraintManager::Assume(const GRState *state, 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 782cd4f5e6..b8cad7a5cc 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 @@ public: }; } // 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 @@ SVal SimpleSValuator::EvalCastNL(NonLoc val, QualType castTy) { 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 @@ SVal SimpleSValuator::EvalCastL(Loc val, QualType castTy) { // Transfer function for unary operators. //===----------------------------------------------------------------------===// -SVal SimpleSValuator::EvalMinus(NonLoc val) { +SVal SimpleSValBuilder::EvalMinus(NonLoc val) { switch (val.getSubKind()) { case nonloc::ConcreteIntKind: return cast(val).evalMinus(ValMgr); @@ -151,7 +151,7 @@ SVal SimpleSValuator::EvalMinus(NonLoc val) { } } -SVal SimpleSValuator::EvalComplement(NonLoc X) { +SVal SimpleSValBuilder::EvalComplement(NonLoc X) { switch (X.getSubKind()) { case nonloc::ConcreteIntKind: return cast(X).evalComplement(ValMgr); @@ -191,7 +191,7 @@ static BinaryOperator::Opcode ReverseComparison(BinaryOperator::Opcode op) { } } -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 @@ SVal SimpleSValuator::MakeSymIntVal(const SymExpr *LHS, 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 @@ SVal SimpleSValuator::EvalBinOpNN(const GRState *state, } // 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::EvalBinOpLL(const GRState *state, } } -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 @@ SVal SimpleSValuator::EvalBinOpLN(const GRState *state, 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 2e03009b1c..1259d19cf0 100644 --- a/lib/Checker/Store.cpp +++ b/lib/Checker/Store.cpp @@ -225,9 +225,9 @@ SVal StoreManager::CastRetrievedVal(SVal V, const TypedRegion *R, } if (const Loc *L = dyn_cast(&V)) - return ValMgr.getSValuator().EvalCastL(*L, castTy); + return ValMgr.getSValBuilder().EvalCastL(*L, castTy); else if (const NonLoc *NL = dyn_cast(&V)) - return ValMgr.getSValuator().EvalCastNL(*NL, castTy); + return ValMgr.getSValBuilder().EvalCastNL(*NL, castTy); return V; } @@ -309,7 +309,7 @@ SVal StoreManager::getLValueElement(QualType elementType, NonLoc Offset, // 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(Offset)) { if (isa(BaseRegion->StripCasts())) return UnknownVal(); diff --git a/lib/Checker/UnixAPIChecker.cpp b/lib/Checker/UnixAPIChecker.cpp index 59a83f77ab..93d1de24d2 100644 --- a/lib/Checker/UnixAPIChecker.cpp +++ b/lib/Checker/UnixAPIChecker.cpp @@ -101,9 +101,9 @@ static void CheckOpen(CheckerContext &C, UnixAPIChecker &UC, NonLoc ocreateFlag = cast(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(maskedFlagsUC); diff --git a/lib/Checker/VLASizeChecker.cpp b/lib/Checker/VLASizeChecker.cpp index 0800b8be18..214db93cb5 100644 --- a/lib/Checker/VLASizeChecker.cpp +++ b/lib/Checker/VLASizeChecker.cpp @@ -108,7 +108,7 @@ void VLASizeChecker::PreVisitDeclStmt(CheckerContext &C, const DeclStmt *DS) { // 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(SV.EvalCast(sizeD, SizeTy, SE->getType())); diff --git a/lib/Checker/ValueManager.cpp b/lib/Checker/ValueManager.cpp index 8b7cd7bbdb..484e48e0c5 100644 --- a/lib/Checker/ValueManager.cpp +++ b/lib/Checker/ValueManager.cpp @@ -67,7 +67,7 @@ SVal ValueManager::convertToArrayIndex(SVal V) { return V; } - return SVator->EvalCastNL(cast(V), ArrayIndexTy); + return svalBuilder->EvalCastNL(cast(V), ArrayIndexTy); } DefinedOrUnknownSVal