Implemented transfer function logic for unary '+'

llvm-svn: 47357

7 files changed, 42 insertions, 0 deletions

diff --git a/clang/Analysis/GRExprEngine.cpp b/clang/Analysis/GRExprEngine.cpp
index 243c0788769..75ced576f44 100644
--- a/clang/Analysis/GRExprEngine.cpp
+++ b/clang/Analysis/GRExprEngine.cpp
@@ -670,6 +670,12 @@ void GRExprEngine::VisitUnaryOperator(UnaryOperator* U,
         break;
       }
         
+      case UnaryOperator::Plus: {
+        const NonLValue& R1 = cast<NonLValue>(GetValue(St, U->getSubExpr()));
+        Nodify(Dst, U, N1, SetValue(St, U, EvalPlus(ValMgr, U, R1)));
+        break;
+      }
+        
       case UnaryOperator::Not: {
         const NonLValue& R1 = cast<NonLValue>(GetValue(St, U->getSubExpr()));
         Nodify(Dst, U, N1, SetValue(St, U, EvalComplement(ValMgr, R1)));
diff --git a/clang/Analysis/GRSimpleVals.cpp b/clang/Analysis/GRSimpleVals.cpp
index 443a7ddb759..a76acb3d1f3 100644
--- a/clang/Analysis/GRSimpleVals.cpp
+++ b/clang/Analysis/GRSimpleVals.cpp
@@ -112,6 +112,20 @@ NonLValue GRSimpleVals::EvalMinus(ValueManager& ValMgr, UnaryOperator* U,
   }
 }
 
+NonLValue GRSimpleVals::EvalPlus(ValueManager& ValMgr, UnaryOperator* U,
+                                 NonLValue X) {
+  
+  assert (!isa<UnknownVal>(X) && !isa<UninitializedVal>(X));
+  
+  switch (X.getSubKind()) {
+    case nonlval::ConcreteIntKind:
+      return cast<nonlval::ConcreteInt>(X).EvalPlus(ValMgr, U);
+    default:
+      return cast<NonLValue>(UnknownVal());
+  }
+}
+
+
 NonLValue GRSimpleVals::EvalComplement(ValueManager& ValMgr, NonLValue X) {
 
   assert (!isa<UnknownVal>(X) && !isa<UninitializedVal>(X));
diff --git a/clang/Analysis/GRSimpleVals.h b/clang/Analysis/GRSimpleVals.h
index 34b1d4f183c..3a73e41033d 100644
--- a/clang/Analysis/GRSimpleVals.h
+++ b/clang/Analysis/GRSimpleVals.h
@@ -36,6 +36,9 @@ public:
   virtual NonLValue EvalMinus(ValueManager& ValMgr, UnaryOperator* U,
                               NonLValue X);
   
+  virtual NonLValue EvalPlus(ValueManager& ValMgr, UnaryOperator* U,
+                             NonLValue X);
+  
   virtual NonLValue EvalComplement(ValueManager& ValMgr, NonLValue X);
   
   // Binary Operators.
diff --git a/clang/Analysis/RValues.cpp b/clang/Analysis/RValues.cpp
index 60277300718..c4041b866db 100644
--- a/clang/Analysis/RValues.cpp
+++ b/clang/Analysis/RValues.cpp
@@ -77,6 +77,13 @@ nonlval::ConcreteInt::EvalMinus(ValueManager& ValMgr, UnaryOperator* U) const {
   return ValMgr.getValue(-getValue()); 
 }
 
+nonlval::ConcreteInt
+nonlval::ConcreteInt::EvalPlus(ValueManager& ValMgr, UnaryOperator* U) const {
+  assert (U->getType() == U->getSubExpr()->getType());  
+  assert (U->getType()->isIntegerType());  
+  return ValMgr.getValue(getValue()); 
+}
+
 //===----------------------------------------------------------------------===//
 // Transfer function dispatch for LValues.
 //===----------------------------------------------------------------------===//
diff --git a/clang/include/clang/Analysis/PathSensitive/GRExprEngine.h b/clang/include/clang/Analysis/PathSensitive/GRExprEngine.h
index 5ae8012c07f..9220238ca0d 100644
--- a/clang/include/clang/Analysis/PathSensitive/GRExprEngine.h
+++ b/clang/include/clang/Analysis/PathSensitive/GRExprEngine.h
@@ -347,6 +347,14 @@ public:
     return TF->EvalMinus(ValMgr, U, X);    
   }
   
+  inline NonLValue EvalPlus(ValueManager& ValMgr, UnaryOperator* U,
+                             NonLValue X) {
+    if (isa<UnknownVal>(X) || isa<UninitializedVal>(X))
+      return X;    
+    
+    return TF->EvalPlus(ValMgr, U, X);    
+  }
+  
   inline NonLValue EvalComplement(ValueManager& ValMgr, NonLValue X) {
     if (isa<UnknownVal>(X) || isa<UninitializedVal>(X))
       return X;    
diff --git a/clang/include/clang/Analysis/PathSensitive/GRTransferFuncs.h b/clang/include/clang/Analysis/PathSensitive/GRTransferFuncs.h
index 53491d532e5..8aca43a89e2 100644
--- a/clang/include/clang/Analysis/PathSensitive/GRTransferFuncs.h
+++ b/clang/include/clang/Analysis/PathSensitive/GRTransferFuncs.h
@@ -35,6 +35,9 @@ public:
   virtual NonLValue EvalMinus(ValueManager& ValMgr, UnaryOperator* U,
                               NonLValue X) = 0;
 
+  virtual NonLValue EvalPlus(ValueManager& ValMgr, UnaryOperator* U,
+                             NonLValue X) = 0;
+  
   virtual NonLValue EvalComplement(ValueManager& ValMgr, NonLValue X) = 0;
 
   // Binary Operators.
diff --git a/clang/include/clang/Analysis/PathSensitive/RValues.h b/clang/include/clang/Analysis/PathSensitive/RValues.h
index 8c3b8197f32..beeb1c82166 100644
--- a/clang/include/clang/Analysis/PathSensitive/RValues.h
+++ b/clang/include/clang/Analysis/PathSensitive/RValues.h
@@ -198,6 +198,7 @@ namespace nonlval {
     
     ConcreteInt EvalComplement(ValueManager& ValMgr) const;
     ConcreteInt EvalMinus(ValueManager& ValMgr, UnaryOperator* U) const;
+    ConcreteInt EvalPlus(ValueManager& ValMgr, UnaryOperator* U) const;
     
     // Implement isa<T> support.
     static inline bool classof(const RValue* V) {