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 136a29da5f2a7d097be7f0d31e83783aaa1bc953..6ea5b771638e1ac326adff26bcbc0e1b16a8a886 100644 (file)
--- 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 519a3e4c6fce854319508f1b9179081e109c951b..69a81ef1b675b865acb3bde8d9085b0b43fc411e 100644 (file)
--- 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<NonLoc>(X)) : X;
+    return X.isValid() ? svalBuilder.EvalMinus(cast<NonLoc>(X)) : X;
   }
 
   SVal EvalComplement(SVal X) {
-    return X.isValid() ? SVator.EvalComplement(cast<NonLoc>(X)) : X;
+    return X.isValid() ? svalBuilder.EvalComplement(cast<NonLoc>(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<NonLoc>(R), T) : R;
+    return R.isValid() ? svalBuilder.EvalBinOpNN(state,op,L, cast<NonLoc>(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 9192ca7b86140e7e291a9fa38a8794fa6b30b328..22e0cc683cf7be72f164631a9d72d2a24fbfa98e 100644 (file)
--- 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 b81e9c150234e30f1ba0cfbc73bdf545ce90358f..98b4f21f31bf7181c694077a7146b8b78b633a26 100644 (file)
--- 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<SValuator> SVator;
+  /// svalBuilder - SValBuilder object that creates SVals from expressions.
+  llvm::OwningPtr<SValBuilder> 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 0ed04fb14aba5f5c907ccad78ddfc5cbd4e8432e..5f564014131bb66254f02f72d3fc0ad79ca3a7b5 100644 (file)
--- 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 00b524a9bee62312667dba2c154e10fa14fc05c2..c137e7d6f7d4a8ad0a0f615dad8505725837287c 100644 (file)
--- a/lib/Checker/BasicObjCFoundationChecks.cpp
+++ b/lib/Checker/BasicObjCFoundationChecks.cpp
@@ -413,8 +413,8 @@ void CFRetainReleaseChecker::PreVisitCallExpr(CheckerContext& C,
   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 057e474626f6b3f39f53ebb7fcea6f895e60c6bc..6761a7a567afa30a9038545e886624daedcd8148 100644 (file)
--- 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 e6f24dd78dddac61a897a230cbf0898e0cc1c42e..e55f733ff9278b512c68f807c46798a5d3f352fa 100644 (file)
--- 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 a75e196e37693735a259d98d38c2b2acae987858..c60eca8fc0960b0ba231b5c379e497c327ac0e87 100644 (file)
--- 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<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 @@ 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<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 6676fe5e7a36606397c14c21f96f9f46767b1dd7..bb10f614754b6a72ed4c530704d7d650d4eacf50 100644 (file)
--- 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 fc0913bc2f729f293b22e127b9cd647259a2a84f..3aa087b52c7ecd2511d504a037551bd13d556878 100644 (file)
--- 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 86b6f816589c4314de5857b8115f45d1daa209b4..4a55cee1e290b892589371995d25c4fd995f9490 100644 (file)
--- 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 2456b1d65914ce74c3d76501b5f6be10d5794ce9..5f7984c30f61fe86a8a639021f32bd7e16e69920 100644 (file)
--- 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<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 @@ void MallocChecker::ReallocMem(CheckerContext &C, const CallExpr *CE) {
   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 @@ void MallocChecker::ReallocMem(CheckerContext &C, const CallExpr *CE) {
     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 @@ 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 02de0a84a4e486c6b2e2dc3d469b37c4541dee27..15989ecdb95e9a4e6e54578873a1e8f0ec9fa994 100644 (file)
--- a/lib/Checker/OSAtomicChecker.cpp
+++ b/lib/Checker/OSAtomicChecker.cpp
@@ -142,10 +142,10 @@ bool OSAtomicChecker::EvalOSAtomicCompareAndSwap(CheckerContext &C,
     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 @@ bool OSAtomicChecker::EvalOSAtomicCompareAndSwap(CheckerContext &C,
       // 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 ae0dedff39372c7764833cc26d629a5be9b97115..cde8ab978db3379bed5e28a4d729fa33d5d54ca1 100644 (file)
--- 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<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 @@ SVal RegionStoreManager::EvalBinOp(BinaryOperator::Opcode Op, Loc L, NonLoc R,
   //  (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 @@ SVal RegionStoreManager::RetrieveVar(Store store, const VarRegion *R) {
           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 73bd86771f3406bfc460fc2a5e9806452c8d647d..8bc95941c0159525ef95ebb1fac8acab341b2f80 100644 (file)
--- 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<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 @@ 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 04496e1e3332ab9eb3825becd596fcf3f05f3012..3fdf7902c206534679df6c90a2f8aab8571427b6 100644 (file)
--- 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 782cd4f5e68b001be006346321fd292854a9241a..b8cad7a5cc004cee2bb6d9c976cade52116d1b78 100644 (file)
--- 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<nonloc::ConcreteInt>(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<nonloc::ConcreteInt>(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 2e03009b1ce9ae49218723f98b041628d90a57d6..1259d19cf08d52cc9b5a5e02c9ce03fb05f0223a 100644 (file)
--- 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<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 @@ 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<nonloc::ConcreteInt>(Offset)) {
     if (isa<ElementRegion>(BaseRegion->StripCasts()))
       return UnknownVal();

diff --git a/lib/Checker/UnixAPIChecker.cpp b/lib/Checker/UnixAPIChecker.cpp
index 59a83f77ab9e252e9978339055db3c53a9392b6b..93d1de24d24189491e2080a24aef9ad522e18a60 100644 (file)
--- a/lib/Checker/UnixAPIChecker.cpp
+++ b/lib/Checker/UnixAPIChecker.cpp
@@ -101,9 +101,9 @@ static void CheckOpen(CheckerContext &C, UnixAPIChecker &UC,
   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 0800b8be1881bf14b3452df8e34b00be3f9861ca..214db93cb5603cd8a4848a3b51e9c4750d832b30 100644 (file)
--- 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<NonLoc>(SV.EvalCast(sizeD, SizeTy, SE->getType()));
 

diff --git a/lib/Checker/ValueManager.cpp b/lib/Checker/ValueManager.cpp
index 8b7cd7bbdb688e74828324bba12b3df16dc3ed9f..484e48e0c5c5562fb7e1908ee25b714bbc309537 100644 (file)
--- 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<NonLoc>(V), ArrayIndexTy);
+  return svalBuilder->EvalCastNL(cast<NonLoc>(V), ArrayIndexTy);
 }
 
 DefinedOrUnknownSVal