commit c6fbdcdb3b84d8a6bffa59b0848a8f53cf0bd11a
author Ted Kremenek <kremenek@apple.com> Fri Feb 15 23:15:23 2008 +0000
committer Ted Kremenek <kremenek@apple.com> Fri Feb 15 23:15:23 2008 +0000
tree 8b6df42d78bb36f32ab309857ee21f6bf17ca8f2
parent a674349df307a3e9528805c4cbe03a0feff8779b

Refactored code for transfer functions for binary operators involving two LValues.

Fixed bug in transfer functions for sizeof(*); we were incorrectly evaluating to
a value of the wrong type.

Fixed bug in transfer functions for compound assignments where we did not properly
handle assignments involving dereferences of symbolic values.


git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@47190 91177308-0d34-0410-b5e6-96231b3b80d8

Analysis/GRExprEngine.cpp

diff --git a/Analysis/GRExprEngine.cpp b/Analysis/GRExprEngine.cpp
index 33f7f51..4bcdd5f 100644
--- a/Analysis/GRExprEngine.cpp
+++ b/Analysis/GRExprEngine.cpp
@@ -473,7 +473,7 @@
   
   Nodify(Dst, S, Pred,
          SetValue(Pred->getState(), S,
-                  NonLValue::GetValue(ValMgr, size, getContext().IntTy, L)));
+                  NonLValue::GetValue(ValMgr, size, S->getType(), L)));
   
 }
 
@@ -573,7 +573,7 @@
                 
         Nodify(Dst, U, N1,
                SetValue(St, U, NonLValue::GetValue(ValMgr, size,
-                                                   getContext().IntTy, L)));
+                                                   U->getType(), L)));
         
         break;
       }
@@ -730,15 +730,20 @@
               Result = EvalBinaryOp(ValMgr, Op, L1, L2);
             }
             else {
+              QualType T1 = B->getLHS()->getType();
+              QualType T2 = B->getRHS()->getType();
+              
               // An operation between two variables of a non-lvalue type.
               Result =
                 EvalBinaryOp(ValMgr, Op,
-                             cast<NonLValue>(GetValue(N1->getState(), L1)),
-                             cast<NonLValue>(GetValue(N2->getState(), L2)));
+                            cast<NonLValue>(GetValue(N1->getState(), L1, &T1)),
+                            cast<NonLValue>(GetValue(N2->getState(), L2, &T2)));
             }
           }
           else { // Any other operation between two Non-LValues.
-            const NonLValue& R1 = cast<NonLValue>(GetValue(N1->getState(), L1));
+            QualType T = B->getLHS()->getType();
+            const NonLValue& R1 = cast<NonLValue>(GetValue(N1->getState(),
+                                                           L1, &T));
             const NonLValue& R2 = cast<NonLValue>(V2);
             Result = EvalBinaryOp(ValMgr, Op, R1, R2);
           }

Analysis/GRSimpleVals.cpp

diff --git a/Analysis/GRSimpleVals.cpp b/Analysis/GRSimpleVals.cpp
index c9827d9..75dc256 100644
--- a/Analysis/GRSimpleVals.cpp
+++ b/Analysis/GRSimpleVals.cpp
@@ -163,6 +163,24 @@
 }
 
 
+// Binary Operators (except assignments and comma).
+
+RValue GRSimpleVals::EvalBinaryOp(ValueManager& ValMgr,
+                                  BinaryOperator::Opcode Op,
+                                  LValue LHS, LValue RHS) {
+  
+  switch (Op) {
+    default:
+      return UnknownVal();
+      
+    case BinaryOperator::EQ:
+      return EvalEQ(ValMgr, LHS, RHS);
+      
+    case BinaryOperator::NE:
+      return EvalNE(ValMgr, LHS, RHS);      
+  }
+}
+
 // Pointer arithmetic.
 
 LValue GRSimpleVals::EvalBinaryOp(ValueManager& ValMgr,

Analysis/GRSimpleVals.h

diff --git a/Analysis/GRSimpleVals.h b/Analysis/GRSimpleVals.h
index b00dd3c..34b1d4f 100644
--- a/Analysis/GRSimpleVals.h
+++ b/Analysis/GRSimpleVals.h
@@ -44,14 +44,19 @@
                                  BinaryOperator::Opcode Op,
                                  NonLValue LHS, NonLValue RHS);
   
+  virtual RValue EvalBinaryOp(ValueManager& ValMgr,
+                              BinaryOperator::Opcode Op,
+                              LValue LHS, LValue RHS);
+  
   // Pointer arithmetic.
   
   virtual LValue EvalBinaryOp(ValueManager& ValMgr, BinaryOperator::Opcode Op,
                               LValue LHS, NonLValue RHS);  
   
+protected:
   // Equality operators for LValues.
-  virtual NonLValue EvalEQ(ValueManager& ValMgr, LValue LHS, LValue RHS);
-  virtual NonLValue EvalNE(ValueManager& ValMgr, LValue LHS, LValue RHS);
+  NonLValue EvalEQ(ValueManager& ValMgr, LValue LHS, LValue RHS);
+  NonLValue EvalNE(ValueManager& ValMgr, LValue LHS, LValue RHS);
 };
   
   

Analysis/GRTransferFuncs.cpp

diff --git a/Analysis/GRTransferFuncs.cpp b/Analysis/GRTransferFuncs.cpp
index 33663d6..3716ed9 100644
--- a/Analysis/GRTransferFuncs.cpp
+++ b/Analysis/GRTransferFuncs.cpp
@@ -39,21 +39,3 @@
   
   return X;
 }
-
-// Binary Operators (except assignments and comma).
-
-RValue GRTransferFuncs::EvalBinaryOp(ValueManager& ValMgr,
-                                     BinaryOperator::Opcode Op,
-                                     LValue LHS, LValue RHS) {
-  
-  switch (Op) {
-    default:
-      assert (false && "Not yet implemented.");
-      
-    case BinaryOperator::EQ:
-      return EvalEQ(ValMgr, LHS, RHS);
-      
-    case BinaryOperator::NE:
-      return EvalNE(ValMgr, LHS, RHS);
-  }
-}
\ No newline at end of file