From c3f261de2d3a48d412ec4a9ce44b3b4a3982dddb Mon Sep 17 00:00:00 2001
From: Ted Kremenek <kremenek@apple.com>
Date: Thu, 14 Feb 2008 18:40:24 +0000
Subject: [PATCH] Migrated transfer functions for unary "~" and "-" to
 GRTransferFuncs/GRSimpleVals.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@47126 91177308-0d34-0410-b5e6-96231b3b80d8
---
 Analysis/GRExprEngine.cpp                     | 12 ++++++++--
 Analysis/GRSimpleVals.cpp                     | 24 ++++++++++++++++++-
 Analysis/GRSimpleVals.h                       |  9 +++++++
 Analysis/RValues.cpp                          | 17 -------------
 .../Analysis/PathSensitive/GRTransferFuncs.h  |  8 +++++++
 .../clang/Analysis/PathSensitive/RValues.h    |  3 ---
 6 files changed, 50 insertions(+), 23 deletions(-)

diff --git a/Analysis/GRExprEngine.cpp b/Analysis/GRExprEngine.cpp
index 3ff4c4bdfe..9ec43d911c 100644
--- a/Analysis/GRExprEngine.cpp
+++ b/Analysis/GRExprEngine.cpp
@@ -325,6 +325,14 @@ public:
     return TF.EvalCast(ValMgr, R, CastExpr);
   }
   
+  inline NonLValue EvalMinus(ValueManager& ValMgr, UnaryOperator* U,
+                              NonLValue X) {
+    return TF.EvalMinus(ValMgr, U, X);    
+  }
+  
+  inline NonLValue EvalComplement(ValueManager& ValMgr, NonLValue X) {
+    return TF.EvalComplement(ValMgr, X);
+  }
 };
 } // end anonymous namespace
 
@@ -839,13 +847,13 @@ void GRExprEngine::VisitUnaryOperator(UnaryOperator* U,
         
       case UnaryOperator::Minus: {
         const NonLValue& R1 = cast<NonLValue>(GetValue(St, U->getSubExpr()));
-        Nodify(Dst, U, N1, SetValue(St, U, R1.EvalMinus(ValMgr, U)));
+        Nodify(Dst, U, N1, SetValue(St, U, EvalMinus(ValMgr, U, R1)));
         break;
       }
         
       case UnaryOperator::Not: {
         const NonLValue& R1 = cast<NonLValue>(GetValue(St, U->getSubExpr()));
-        Nodify(Dst, U, N1, SetValue(St, U, R1.EvalComplement(ValMgr)));
+        Nodify(Dst, U, N1, SetValue(St, U, EvalComplement(ValMgr, R1)));
         break;
       }
         
diff --git a/Analysis/GRSimpleVals.cpp b/Analysis/GRSimpleVals.cpp
index 447eb44f0e..a2711c73b4 100644
--- a/Analysis/GRSimpleVals.cpp
+++ b/Analysis/GRSimpleVals.cpp
@@ -56,4 +56,26 @@ RValue GRSimpleVals::EvalCast(ValueManager& ValMgr, LValue X, Expr* CastExpr) {
   V.extOrTrunc(ValMgr.getContext().getTypeSize(T, CastExpr->getLocStart()));
 
   return nonlval::ConcreteInt(ValMgr.getValue(V));
-}
\ No newline at end of file
+}
+
+// Unary operators.
+
+NonLValue GRSimpleVals::EvalMinus(ValueManager& ValMgr, UnaryOperator* U,
+                                  NonLValue X) {
+  
+  switch (X.getSubKind()) {
+    case nonlval::ConcreteIntKind:
+      return cast<nonlval::ConcreteInt>(X).EvalMinus(ValMgr, U);
+    default:
+      return cast<NonLValue>(UnknownVal());
+  }
+}
+
+NonLValue GRSimpleVals::EvalComplement(ValueManager& ValMgr, NonLValue X) {
+  switch (X.getSubKind()) {
+    case nonlval::ConcreteIntKind:
+      return cast<nonlval::ConcreteInt>(X).EvalComplement(ValMgr);
+    default:
+      return cast<NonLValue>(UnknownVal());
+  }
+}
diff --git a/Analysis/GRSimpleVals.h b/Analysis/GRSimpleVals.h
index 4c9c6890ba..373be305ea 100644
--- a/Analysis/GRSimpleVals.h
+++ b/Analysis/GRSimpleVals.h
@@ -25,8 +25,17 @@ public:
   GRSimpleVals() {}
   virtual ~GRSimpleVals() {}
   
+  // Casts.
+  
   virtual RValue EvalCast(ValueManager& ValMgr, NonLValue V, Expr* CastExpr);
   virtual RValue EvalCast(ValueManager& ValMgr, LValue V, Expr* CastExpr);
+  
+  // Unary Operators.
+  
+  virtual NonLValue EvalMinus(ValueManager& ValMgr, UnaryOperator* U,
+                              NonLValue X);
+  
+  virtual NonLValue EvalComplement(ValueManager& ValMgr, NonLValue X);
 };
   
   
diff --git a/Analysis/RValues.cpp b/Analysis/RValues.cpp
index 06d29550a1..17425aff5a 100644
--- a/Analysis/RValues.cpp
+++ b/Analysis/RValues.cpp
@@ -243,14 +243,6 @@ nonlval::ConcreteInt::EvalBinaryOp(ValueManager& ValMgr,
 
   // Bitwise-Complement.
 
-NonLValue NonLValue::EvalComplement(ValueManager& ValMgr) const {
-  switch (getSubKind()) {
-    case nonlval::ConcreteIntKind:
-      return cast<nonlval::ConcreteInt>(this)->EvalComplement(ValMgr);
-    default:
-      return cast<NonLValue>(UnknownVal());
-  }
-}
 
 nonlval::ConcreteInt
 nonlval::ConcreteInt::EvalComplement(ValueManager& ValMgr) const {
@@ -259,15 +251,6 @@ nonlval::ConcreteInt::EvalComplement(ValueManager& ValMgr) const {
 
   // Unary Minus.
 
-NonLValue NonLValue::EvalMinus(ValueManager& ValMgr, UnaryOperator* U) const {
-  switch (getSubKind()) {
-    case nonlval::ConcreteIntKind:
-      return cast<nonlval::ConcreteInt>(this)->EvalMinus(ValMgr, U);
-    default:
-      return cast<NonLValue>(UnknownVal());
-  }
-}
-
 nonlval::ConcreteInt
 nonlval::ConcreteInt::EvalMinus(ValueManager& ValMgr, UnaryOperator* U) const {
   assert (U->getType() == U->getSubExpr()->getType());  
diff --git a/include/clang/Analysis/PathSensitive/GRTransferFuncs.h b/include/clang/Analysis/PathSensitive/GRTransferFuncs.h
index 7e8b38d86c..54f118bf80 100644
--- a/include/clang/Analysis/PathSensitive/GRTransferFuncs.h
+++ b/include/clang/Analysis/PathSensitive/GRTransferFuncs.h
@@ -24,11 +24,19 @@ public:
   GRTransferFuncs() {}
   virtual ~GRTransferFuncs() {}
   
+  // Casts.
+  
   RValue EvalCast(ValueManager& ValMgr, RValue V, Expr* CastExpr);
   virtual RValue EvalCast(ValueManager& ValMgr, NonLValue V, Expr* CastExpr) =0;
   virtual RValue EvalCast(ValueManager& ValMgr, LValue V, Expr* CastExpr) = 0;
 
+  // Unary Operators.
   
+  virtual NonLValue EvalMinus(ValueManager& ValMgr, UnaryOperator* U,
+                              NonLValue X) = 0;
+
+  virtual NonLValue EvalComplement(ValueManager& ValMgr, NonLValue X) = 0;
+
   
 };
   
diff --git a/include/clang/Analysis/PathSensitive/RValues.h b/include/clang/Analysis/PathSensitive/RValues.h
index 8d84498a0b..d3b958366f 100644
--- a/include/clang/Analysis/PathSensitive/RValues.h
+++ b/include/clang/Analysis/PathSensitive/RValues.h
@@ -325,9 +325,6 @@ public:
   NonLValue EvalBinaryOp(ValueManager& ValMgr,
                                BinaryOperator::Opcode Op,
                                const NonLValue& RHS) const;
-
-  NonLValue EvalMinus(ValueManager& ValMgr, UnaryOperator* U) const;
-  NonLValue EvalComplement(ValueManager& ValMgr) const;
   
   // Utility methods to create NonLValues.
   static NonLValue GetValue(ValueManager& ValMgr, uint64_t X, QualType T,
-- 
2.40.0