From: Ted Kremenek <kremenek@apple.com>
Date: Mon, 1 Oct 2007 20:33:52 +0000 (+0000)
Subject: Migrated LiveVariables and UninitializedVariables to now use the
X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=11e7218db51efc825ec24e80d5b071892ca268bd;p=clang

Migrated LiveVariables and UninitializedVariables to now use the
tracked BlkExpr information now maintained by the CFG class.


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

diff --git a/AST/CFG.cpp b/AST/CFG.cpp
index 3755fa6369..3e6f8cc2e7 100644
--- a/AST/CFG.cpp
+++ b/AST/CFG.cpp
@@ -949,11 +949,13 @@ static BlkExprMapTy* PopulateBlkExprMap(CFG& cfg) {
 }
 
 bool CFG::isBlkExpr(const Stmt* S) {
+  assert (S != NULL);
   if (const Expr* E = dyn_cast<Expr>(S)) return getBlkExprNum(E);
   else return true;  // Statements are by default "block-level expressions."
 }
 
 CFG::BlkExprNumTy CFG::getBlkExprNum(const Expr* E) {
+  assert(E != NULL);
   if (!BlkExprMap) { BlkExprMap = (void*) PopulateBlkExprMap(*this); }
   
   BlkExprMapTy* M = reinterpret_cast<BlkExprMapTy*>(BlkExprMap);
diff --git a/Analysis/DeadStores.cpp b/Analysis/DeadStores.cpp
index 3c3117cf09..1b85138029 100644
--- a/Analysis/DeadStores.cpp
+++ b/Analysis/DeadStores.cpp
@@ -76,7 +76,7 @@ public:
 namespace clang {
 
 void CheckDeadStores(CFG& cfg, ASTContext &Ctx, Diagnostic &Diags) {
-  LiveVariables L;
+  LiveVariables L(cfg);
   L.runOnCFG(cfg);
   DeadStoreObs A(Ctx, Diags);
   L.runOnAllBlocks(cfg,A);
diff --git a/Analysis/LiveVariables.cpp b/Analysis/LiveVariables.cpp
index f8c3d378d9..b4220ef9bd 100644
--- a/Analysis/LiveVariables.cpp
+++ b/Analysis/LiveVariables.cpp
@@ -31,18 +31,16 @@ using namespace clang;
 //===----------------------------------------------------------------------===//      
 
 namespace {
-class RegisterDeclsExprs : public CFGRecStmtDeclVisitor<RegisterDeclsExprs> {  
+class RegisterDecls : public CFGRecStmtDeclVisitor<RegisterDecls> {  
   LiveVariables::AnalysisDataTy& AD;
 public:
-  RegisterDeclsExprs(LiveVariables::AnalysisDataTy& ad) : AD(ad) {}
-  
+  RegisterDecls(LiveVariables::AnalysisDataTy& ad) : AD(ad) {}  
   void VisitVarDecl(VarDecl* VD) { AD.Register(VD); }
-  void BlockStmt_VisitExpr(Expr* E) { AD.Register(E); }
-};  
+};
 } // end anonymous namespace
 
 void LiveVariables::InitializeValues(const CFG& cfg) {
-  RegisterDeclsExprs R(getAnalysisData());
+  RegisterDecls R(getAnalysisData());
   cfg.VisitBlockStmts(R);
 }
 
@@ -58,10 +56,8 @@ static const bool Dead = false;
 class TransferFuncs : public CFGStmtVisitor<TransferFuncs> {
   LiveVariables::AnalysisDataTy& AD;
   LiveVariables::ValTy LiveState;
-  bool ExprLiveness;
 public:
-  TransferFuncs(LiveVariables::AnalysisDataTy& ad) : AD(ad), 
-                                                     ExprLiveness(Dead) {}
+  TransferFuncs(LiveVariables::AnalysisDataTy& ad) : AD(ad) {}
 
   LiveVariables::ValTy& getVal() { return LiveState; }
   
@@ -71,16 +67,26 @@ public:
   void VisitDeclStmt(DeclStmt* DS);
   void VisitUnaryOperator(UnaryOperator* U);
   void VisitStmt(Stmt* S);
-  void BlockStmt_VisitExpr(Expr *E);
+  void VisitExpr(Expr* E);
+  void BlockStmt_VisitExpr(Expr *E);    
+  void Visit(Stmt *S);
   
   DeclRefExpr* FindDeclRef(Stmt *S);
-  
-  void Visit(Stmt *S) {
-    if (AD.Observer) AD.Observer->ObserveStmt(S,AD,LiveState);
-    static_cast<CFGStmtVisitor<TransferFuncs>*>(this)->Visit(S);
-  }
 };
+
+void TransferFuncs::VisitExpr(Expr * E) {
+  if (AD.getCFG().isBlkExpr(E)) return;
+  else VisitStmt(E);
+}
+      
+void TransferFuncs::VisitStmt(Stmt* S) { VisitChildren(S); }
+
+void TransferFuncs::Visit(Stmt *S) {
+  if (AD.Observer)
+    AD.Observer->ObserveStmt(S,AD,LiveState);
   
+  static_cast<CFGStmtVisitor<TransferFuncs>*>(this)->Visit(S);
+}
 
 void TransferFuncs::VisitDeclRefExpr(DeclRefExpr* DR) {
   if (VarDecl* V = dyn_cast<VarDecl>(DR->getDecl())) 
@@ -151,17 +157,12 @@ void TransferFuncs::VisitAssign(BinaryOperator* B) {
 void TransferFuncs::VisitDeclStmt(DeclStmt* DS) {
   // Declarations effectively "kill" a variable since they cannot
   // possibly be live before they are declared.
-  for (ScopedDecl* D = DS->getDecl(); D != NULL ; D = D->getNextDeclarator())
+  for (ScopedDecl* D = DS->getDecl(); D != NULL; D = D->getNextDeclarator())
     LiveState(D,AD) = Dead;
 }
   
-void TransferFuncs::VisitStmt(Stmt* S) {
-  if (AD.isTracked(static_cast<Expr*>(S))) return;
-  else VisitChildren(S); 
-}
-  
 void TransferFuncs::BlockStmt_VisitExpr(Expr* E) {
-  assert (AD.isTracked(E));
+  assert (AD.getCFG().isBlkExpr(E));
   static_cast<CFGStmtVisitor<TransferFuncs>*>(this)->Visit(E);
 }
   
diff --git a/Analysis/UninitializedValues.cpp b/Analysis/UninitializedValues.cpp
index 58b95fcffb..a18319a62b 100644
--- a/Analysis/UninitializedValues.cpp
+++ b/Analysis/UninitializedValues.cpp
@@ -28,19 +28,18 @@ using namespace clang;
 
 namespace {
 
-class RegisterDeclsExprs : public CFGRecStmtDeclVisitor<RegisterDeclsExprs> {  
+class RegisterDecls : public CFGRecStmtDeclVisitor<RegisterDecls> {  
   UninitializedValues::AnalysisDataTy& AD;
 public:
-  RegisterDeclsExprs(UninitializedValues::AnalysisDataTy& ad) :  AD(ad) {}
+  RegisterDecls(UninitializedValues::AnalysisDataTy& ad) :  AD(ad) {}
   
   void VisitBlockVarDecl(BlockVarDecl* VD) { AD.Register(VD); }
-  void BlockStmt_VisitExpr(Expr* E) { AD.Register(E); }
 };
   
 } // end anonymous namespace
 
 void UninitializedValues::InitializeValues(const CFG& cfg) {
-  RegisterDeclsExprs R(this->getAnalysisData());
+  RegisterDecls R(getAnalysisData());
   cfg.VisitBlockStmts(R);
 }
 
@@ -77,7 +76,6 @@ public:
 static const bool Initialized = true;
 static const bool Uninitialized = false;  
 
-
 bool TransferFuncs::VisitDeclRefExpr(DeclRefExpr* DR) {
   if (BlockVarDecl* VD = dyn_cast<BlockVarDecl>(DR->getDecl())) {
     if (AD.Observer) AD.Observer->ObserveDeclRefExpr(V,AD,DR,VD);
@@ -230,7 +228,7 @@ void CheckUninitializedValues(CFG& cfg, ASTContext &Ctx, Diagnostic &Diags,
                               bool FullUninitTaint) {
   
   // Compute the unitialized values information.
-  UninitializedValues U;
+  UninitializedValues U(cfg);
   U.getAnalysisData().FullUninitTaint = FullUninitTaint;
   Solver S(U);
   S.runOnCFG(cfg);
diff --git a/Driver/ASTStreamers.cpp b/Driver/ASTStreamers.cpp
index c0ae401720..61490d3401 100644
--- a/Driver/ASTStreamers.cpp
+++ b/Driver/ASTStreamers.cpp
@@ -222,7 +222,7 @@ namespace {
     }
 
     virtual void VisitCFG(CFG& C) {
-      LiveVariables L;
+      LiveVariables L(C);
       L.runOnCFG(C);
       L.dumpBlockLiveness(*SM);
     }
diff --git a/include/clang/Analysis/ExprDeclBitVector.h b/include/clang/Analysis/ExprDeclBitVector.h
index 8cda9538a8..4cd9faa260 100644
--- a/include/clang/Analysis/ExprDeclBitVector.h
+++ b/include/clang/Analysis/ExprDeclBitVector.h
@@ -17,6 +17,7 @@
 #ifndef LLVM_CLANG_EXPRDECLBVDVAL_H
 #define LLVM_CLANG_EXPRDECLBVDVAL_H
 
+#include "clang/AST/CFG.h"
 #include "llvm/ADT/BitVector.h"
 #include "llvm/ADT/DenseMap.h"
 
@@ -130,36 +131,25 @@ struct ExprDeclBitVector_Types {
   //===--------------------------------------------------------------------===//
 
   class AnalysisDataTy : public DeclBitVector_Types::AnalysisDataTy {
+    CFG* cfg;
   public:
-    typedef llvm::DenseMap<const Expr*, unsigned > EMapTy;    
-    typedef EMapTy::const_iterator expr_iterator;
-
-  protected:
-    EMapTy EMap;
-    unsigned NExprs;
-
-  public:
-    
-    AnalysisDataTy() : NExprs(0) {}
+    AnalysisDataTy() {}
     virtual ~AnalysisDataTy() {}
+
+    void setCFG(CFG* c) { cfg = c; }
+    CFG& getCFG() { assert(cfg && "CFG should not be NULL."); return *cfg; }
     
-    bool isTracked(const Expr* E) { return EMap.find(E) != EMap.end(); }
+    bool isTracked(const Expr* E) { return cfg->isBlkExpr(E); }
     using DeclBitVector_Types::AnalysisDataTy::isTracked;
 
     unsigned getIdx(const Expr* E) const {
-      EMapTy::const_iterator I = EMap.find(E);
-      assert (I != EMap.end());
-      return I->second;
-    }    
+      CFG::BlkExprNumTy I = cfg->getBlkExprNum(E);
+      assert(I && "expression not tracked for bitvector.");
+      return I;
+    }
     using DeclBitVector_Types::AnalysisDataTy::getIdx;
     
-    unsigned getNumExprs() const { return NExprs; }
-    
-    void Register(const Expr* E) { if (!isTracked(E)) EMap[E] = NExprs++; }    
-    using DeclBitVector_Types::AnalysisDataTy::Register;
-    
-    expr_iterator begin_expr() const { return EMap.begin(); }
-    expr_iterator end_expr() const { return EMap.end(); }
+    unsigned getNumExprs() const { return cfg->getNumBlkExprs(); }
   };
 
   //===--------------------------------------------------------------------===//
diff --git a/include/clang/Analysis/LiveVariables.h b/include/clang/Analysis/LiveVariables.h
index 08f37e0b56..ce80fc281e 100644
--- a/include/clang/Analysis/LiveVariables.h
+++ b/include/clang/Analysis/LiveVariables.h
@@ -65,7 +65,7 @@ class LiveVariables : public DataflowValues<LiveVariables_ValueTypes,
 public:
   typedef LiveVariables_ValueTypes::ObserverTy ObserverTy;
     
-  LiveVariables() {}
+  LiveVariables(CFG& cfg) { getAnalysisData().setCFG(&cfg); }
   
   /// IsLive - Return true if a variable is live at beginning of a
   /// specified block.
diff --git a/include/clang/Analysis/UninitializedValues.h b/include/clang/Analysis/UninitializedValues.h
index 86af05929d..3c15c809e2 100644
--- a/include/clang/Analysis/UninitializedValues.h
+++ b/include/clang/Analysis/UninitializedValues.h
@@ -63,7 +63,7 @@ class UninitializedValues :
 public:
   typedef UninitializedValues_ValueTypes::ObserverTy ObserverTy;
 
-  UninitializedValues() {}
+  UninitializedValues(CFG &cfg) { getAnalysisData().setCFG(&cfg); }
   
   /// IntializeValues - Create initial dataflow values and meta data for
   ///  a given CFG.  This is intended to be called by the dataflow solver.