From 72639102e52a49f04ff8d9d02aa84e8b2d2a2cc2 Mon Sep 17 00:00:00 2001
From: Ted Kremenek <kremenek@apple.com>
Date: Tue, 19 Feb 2008 02:01:16 +0000
Subject: [PATCH] Added back explicit state/node creation when visiting
 IntegerLiterals and CharacterLiterals.  This may not be a permanent solution;
 it doesn't cost that much, however, to create a few additional states, and
 solves a whole bunch of edge cases when handling ?, ||, and &&.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@47299 91177308-0d34-0410-b5e6-96231b3b80d8
---
 Analysis/GRExprEngine.cpp | 27 ++++++++++++++++++++++++++-
 Analysis/ValueState.cpp   |  3 ++-
 2 files changed, 28 insertions(+), 2 deletions(-)

diff --git a/Analysis/GRExprEngine.cpp b/Analysis/GRExprEngine.cpp
index 4ea7819497..8df9e5f305 100644
--- a/Analysis/GRExprEngine.cpp
+++ b/Analysis/GRExprEngine.cpp
@@ -839,7 +839,7 @@ void GRExprEngine::Visit(Stmt* S, NodeTy* Pred, NodeSet& Dst) {
       
     default:
       // Cases we intentionally have "default" handle:
-      //   AddrLabelExpr, CharacterLiteral, IntegerLiteral
+      //   AddrLabelExpr
       
       Dst.Add(Pred); // No-op. Simply propagate the current state unchanged.
       break;
@@ -873,6 +873,19 @@ void GRExprEngine::Visit(Stmt* S, NodeTy* Pred, NodeSet& Dst) {
       break;
     }
       
+      // While explicitly creating a node+state for visiting a CharacterLiteral
+      // seems wasteful, it also solves a bunch of problems when handling
+      // the ?, &&, and ||.
+      
+    case Stmt::CharacterLiteralClass: {
+      CharacterLiteral* C = cast<CharacterLiteral>(S);
+      StateTy St = Pred->getState();
+      NonLValue X = NonLValue::GetValue(ValMgr, C->getValue(), C->getType(),
+                                        C->getLoc());
+      Nodify(Dst, C, Pred, SetValue(St, C, X));
+      break;      
+    }
+      
     case Stmt::ChooseExprClass: { // __builtin_choose_expr
       ChooseExpr* C = cast<ChooseExpr>(S);
       VisitGuardedExpr(C, C->getLHS(), C->getRHS(), Pred, Dst);
@@ -897,6 +910,18 @@ void GRExprEngine::Visit(Stmt* S, NodeTy* Pred, NodeSet& Dst) {
       VisitDeclStmt(cast<DeclStmt>(S), Pred, Dst);
       break;
       
+      // While explicitly creating a node+state for visiting an IntegerLiteral
+      // seems wasteful, it also solves a bunch of problems when handling
+      // the ?, &&, and ||.
+      
+    case Stmt::IntegerLiteralClass: {      
+      StateTy St = Pred->getState();
+      IntegerLiteral* I = cast<IntegerLiteral>(S);
+      NonLValue X = NonLValue::GetValue(ValMgr, I);
+      Nodify(Dst, I, Pred, SetValue(St, I, X));
+      break;      
+    }
+      
     case Stmt::ImplicitCastExprClass: {
       ImplicitCastExpr* C = cast<ImplicitCastExpr>(S);
       VisitCast(C, C->getSubExpr(), Pred, Dst);
diff --git a/Analysis/ValueState.cpp b/Analysis/ValueState.cpp
index 0f29def4a0..963864662a 100644
--- a/Analysis/ValueState.cpp
+++ b/Analysis/ValueState.cpp
@@ -232,7 +232,7 @@ RValue ValueStateManager::GetValue(ValueState St, Expr* E, bool* hasVal) {
         
         // Integer literals evaluate to an RValue.  Simply retrieve the
         // RValue for the literal.
-        
+#if 0        
       case Stmt::IntegerLiteralClass:
         return NonLValue::GetValue(ValMgr, cast<IntegerLiteral>(E));
         
@@ -242,6 +242,7 @@ RValue ValueStateManager::GetValue(ValueState St, Expr* E, bool* hasVal) {
         return NonLValue::GetValue(ValMgr, C->getValue(), C->getType(),
                                    C->getLoc());
       }
+#endif        
 
         // Casts where the source and target type are the same
         // are no-ops.  We blast through these to get the descendant
-- 
2.40.0