Renamed class GREngine => GRCoreEngine.

Renamed class GRConstants => GRExprEngine.

This was done with a Perl script, and will result in 80 col. violations that
I will gradually fix up.

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

diff --git a/Analysis/GRBlockCounter.cpp b/Analysis/GRBlockCounter.cpp
index def87c2c47b468ba653218f5668fb1e05f3f13b0..9dd601b720b65b51000d37e40798599306216472 100644 (file)
--- a/Analysis/GRBlockCounter.cpp
+++ b/Analysis/GRBlockCounter.cpp
@@ -9,7 +9,7 @@
 //
 //  This file defines GRBlockCounter, an abstract data type used to count
 //  the number of times a given block has been visited along a path
-//  analyzed by GREngine.
+//  analyzed by GRCoreEngine.
 //
 //===----------------------------------------------------------------------===//
 

diff --git a/Analysis/GRConstants.cpp b/Analysis/GRConstants.cpp
index dad8b08cf3a10b40624ad85469f006c92f431f3d..e2373e8b2d78ae4cd4306aedef44f7b4b05d1b42 100644 (file)
--- a/Analysis/GRConstants.cpp
+++ b/Analysis/GRConstants.cpp
@@ -1,4 +1,4 @@
-//===-- GRConstants.cpp - Simple, Path-Sens. Constant Prop. ------*- C++ -*-==//
+//===-- GRExprEngine.cpp - Simple, Path-Sens. Constant Prop. ------*- C++ -*-==//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -18,7 +18,7 @@
 #include "RValues.h"
 #include "ValueState.h"
 
-#include "clang/Analysis/PathSensitive/GREngine.h"
+#include "clang/Analysis/PathSensitive/GRCoreEngine.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/Analysis/Analyses/LiveVariables.h"
@@ -61,14 +61,14 @@ using llvm::APSInt;
 
 namespace {
   
-class VISIBILITY_HIDDEN GRConstants {
+class VISIBILITY_HIDDEN GRExprEngine {
     
 public:
   typedef ValueStateManager::StateTy StateTy;
-  typedef GRStmtNodeBuilder<GRConstants> StmtNodeBuilder;
-  typedef GRBranchNodeBuilder<GRConstants> BranchNodeBuilder;
-  typedef GRIndirectGotoNodeBuilder<GRConstants> IndirectGotoNodeBuilder;
-  typedef ExplodedGraph<GRConstants> GraphTy;
+  typedef GRStmtNodeBuilder<GRExprEngine> StmtNodeBuilder;
+  typedef GRBranchNodeBuilder<GRExprEngine> BranchNodeBuilder;
+  typedef GRIndirectGotoNodeBuilder<GRExprEngine> IndirectGotoNodeBuilder;
+  typedef ExplodedGraph<GRExprEngine> GraphTy;
   typedef GraphTy::NodeTy NodeTy;
   
   class NodeSet {
@@ -136,7 +136,7 @@ protected:
   bool StateCleaned;
   
 public:
-  GRConstants(GraphTy& g) : G(g), Liveness(G.getCFG(), G.getFunctionDecl()),
+  GRExprEngine(GraphTy& g) : G(g), Liveness(G.getCFG(), G.getFunctionDecl()),
       Builder(NULL),
       StateMgr(G.getContext(), G.getAllocator()),
       ValMgr(StateMgr.getValueManager()),
@@ -185,15 +185,15 @@ public:
   null_iterator null_begin() { return ExplicitNullDeref.begin(); }
   null_iterator null_end() { return ExplicitNullDeref.end(); }
 
-  /// ProcessStmt - Called by GREngine. Used to generate new successor
+  /// ProcessStmt - Called by GRCoreEngine. Used to generate new successor
   ///  nodes by processing the 'effects' of a block-level statement.
   void ProcessStmt(Stmt* S, StmtNodeBuilder& builder);    
   
-  /// ProcessBranch - Called by GREngine.  Used to generate successor
+  /// ProcessBranch - Called by GRCoreEngine.  Used to generate successor
   ///  nodes by processing the 'effects' of a branch condition.
   void ProcessBranch(Expr* Condition, Stmt* Term, BranchNodeBuilder& builder);
 
-  /// ProcessIndirectGoto - Called by GREngine.  Used to generate successor
+  /// ProcessIndirectGoto - Called by GRCoreEngine.  Used to generate successor
   ///  nodes by processing the 'effects' of a computed goto jump.
   void ProcessIndirectGoto(IndirectGotoNodeBuilder& builder);
   
@@ -309,8 +309,8 @@ public:
 } // end anonymous namespace
 
 
-GRConstants::StateTy
-GRConstants::SetValue(StateTy St, Expr* S, const RValue& V) {
+GRExprEngine::StateTy
+GRExprEngine::SetValue(StateTy St, Expr* S, const RValue& V) {
 
   if (!StateCleaned) {
     St = RemoveDeadBindings(CurrentStmt, St);
@@ -329,8 +329,8 @@ GRConstants::SetValue(StateTy St, Expr* S, const RValue& V) {
   return StateMgr.SetValue(St, S, isBlkExpr, V);
 }
 
-const GRConstants::StateTy::BufferTy&
-GRConstants::SetValue(StateTy St, Expr* S, const RValue::BufferTy& RB,
+const GRExprEngine::StateTy::BufferTy&
+GRExprEngine::SetValue(StateTy St, Expr* S, const RValue::BufferTy& RB,
                       StateTy::BufferTy& RetBuf) {
   
   assert (RetBuf.empty());
@@ -341,8 +341,8 @@ GRConstants::SetValue(StateTy St, Expr* S, const RValue::BufferTy& RB,
   return RetBuf;
 }
 
-GRConstants::StateTy
-GRConstants::SetValue(StateTy St, const LValue& LV, const RValue& V) {
+GRExprEngine::StateTy
+GRExprEngine::SetValue(StateTy St, const LValue& LV, const RValue& V) {
   
   if (LV.isUnknown())
     return St;
@@ -355,7 +355,7 @@ GRConstants::SetValue(StateTy St, const LValue& LV, const RValue& V) {
   return StateMgr.SetValue(St, LV, V);
 }
 
-void GRConstants::ProcessBranch(Expr* Condition, Stmt* Term,
+void GRExprEngine::ProcessBranch(Expr* Condition, Stmt* Term,
                                 BranchNodeBuilder& builder) {
 
   // Remove old bindings for subexpressions.
@@ -429,9 +429,9 @@ void GRConstants::ProcessBranch(Expr* Condition, Stmt* Term,
     builder.markInfeasible(false);
 }
 
-/// ProcessIndirectGoto - Called by GREngine.  Used to generate successor
+/// ProcessIndirectGoto - Called by GRCoreEngine.  Used to generate successor
 ///  nodes by processing the 'effects' of a computed goto jump.
-void GRConstants::ProcessIndirectGoto(IndirectGotoNodeBuilder& builder) {
+void GRExprEngine::ProcessIndirectGoto(IndirectGotoNodeBuilder& builder) {
 
   StateTy St = builder.getState();  
   LValue V = cast<LValue>(GetValue(St, builder.getTarget()));
@@ -474,7 +474,7 @@ void GRConstants::ProcessIndirectGoto(IndirectGotoNodeBuilder& builder) {
     builder.generateNode(I, St);
 }
 
-void GRConstants::VisitLogicalExpr(BinaryOperator* B, NodeTy* Pred,
+void GRExprEngine::VisitLogicalExpr(BinaryOperator* B, NodeTy* Pred,
                                    NodeSet& Dst) {
 
   bool hasR2;
@@ -531,7 +531,7 @@ void GRConstants::VisitLogicalExpr(BinaryOperator* B, NodeTy* Pred,
 
 
 
-void GRConstants::ProcessStmt(Stmt* S, StmtNodeBuilder& builder) {
+void GRExprEngine::ProcessStmt(Stmt* S, StmtNodeBuilder& builder) {
   Builder = &builder;
 
   StmtEntryNode = builder.getLastNode();
@@ -553,8 +553,8 @@ void GRConstants::ProcessStmt(Stmt* S, StmtNodeBuilder& builder) {
   Builder = NULL;
 }
 
-GRConstants::NodeTy*
-GRConstants::Nodify(NodeSet& Dst, Stmt* S, NodeTy* Pred, StateTy St) {
+GRExprEngine::NodeTy*
+GRExprEngine::Nodify(NodeSet& Dst, Stmt* S, NodeTy* Pred, StateTy St) {
  
   // If the state hasn't changed, don't generate a new node.
   if (St == Pred->getState())
@@ -565,14 +565,14 @@ GRConstants::Nodify(NodeSet& Dst, Stmt* S, NodeTy* Pred, StateTy St) {
   return N;
 }
 
-void GRConstants::Nodify(NodeSet& Dst, Stmt* S, NodeTy* Pred,
+void GRExprEngine::Nodify(NodeSet& Dst, Stmt* S, NodeTy* Pred,
                          const StateTy::BufferTy& SB) {
   
   for (StateTy::BufferTy::const_iterator I=SB.begin(), E=SB.end(); I!=E; ++I)
     Nodify(Dst, S, Pred, *I);
 }
 
-void GRConstants::VisitDeclRefExpr(DeclRefExpr* D, NodeTy* Pred, NodeSet& Dst) {
+void GRExprEngine::VisitDeclRefExpr(DeclRefExpr* D, NodeTy* Pred, NodeSet& Dst) {
   if (D != CurrentStmt) {
     Dst.Add(Pred); // No-op. Simply propagate the current state unchanged.
     return;
@@ -587,7 +587,7 @@ void GRConstants::VisitDeclRefExpr(DeclRefExpr* D, NodeTy* Pred, NodeSet& Dst) {
          SetValue(St, D, GetValue(St, lval::DeclVal(D->getDecl()))));
 }
 
-void GRConstants::VisitCast(Expr* CastE, Expr* E, NodeTy* Pred, NodeSet& Dst) {
+void GRExprEngine::VisitCast(Expr* CastE, Expr* E, NodeTy* Pred, NodeSet& Dst) {
   
   QualType T = CastE->getType();
 
@@ -608,8 +608,8 @@ void GRConstants::VisitCast(Expr* CastE, Expr* E, NodeTy* Pred, NodeSet& Dst) {
   }
 }
 
-void GRConstants::VisitDeclStmt(DeclStmt* DS, GRConstants::NodeTy* Pred,
-                                GRConstants::NodeSet& Dst) {
+void GRExprEngine::VisitDeclStmt(DeclStmt* DS, GRExprEngine::NodeTy* Pred,
+                                GRExprEngine::NodeSet& Dst) {
   
   StateTy St = Pred->getState();
   
@@ -627,7 +627,7 @@ void GRConstants::VisitDeclStmt(DeclStmt* DS, GRConstants::NodeTy* Pred,
 }
 
 
-void GRConstants::VisitGuardedExpr(Expr* S, Expr* LHS, Expr* RHS,
+void GRExprEngine::VisitGuardedExpr(Expr* S, Expr* LHS, Expr* RHS,
                                    NodeTy* Pred, NodeSet& Dst) {
   
   StateTy St = Pred->getState();
@@ -639,7 +639,7 @@ void GRConstants::VisitGuardedExpr(Expr* S, Expr* LHS, Expr* RHS,
 }
 
 /// VisitSizeOfAlignOfTypeExpr - Transfer function for sizeof(type).
-void GRConstants::VisitSizeOfAlignOfTypeExpr(SizeOfAlignOfTypeExpr* S,
+void GRExprEngine::VisitSizeOfAlignOfTypeExpr(SizeOfAlignOfTypeExpr* S,
                                              NodeTy* Pred,
                                              NodeSet& Dst) {
   
@@ -660,9 +660,9 @@ void GRConstants::VisitSizeOfAlignOfTypeExpr(SizeOfAlignOfTypeExpr* S,
   
 }
 
-void GRConstants::VisitUnaryOperator(UnaryOperator* U,
-                                     GRConstants::NodeTy* Pred,
-                                     GRConstants::NodeSet& Dst) {
+void GRExprEngine::VisitUnaryOperator(UnaryOperator* U,
+                                     GRExprEngine::NodeTy* Pred,
+                                     GRExprEngine::NodeSet& Dst) {
   
   NodeSet S1;
   UnaryOperator::Opcode Op = U->getOpcode();
@@ -842,8 +842,8 @@ void GRConstants::VisitUnaryOperator(UnaryOperator* U,
   }
 }
 
-void GRConstants::VisitAssignmentLHS(Expr* E, GRConstants::NodeTy* Pred,
-                                     GRConstants::NodeSet& Dst) {
+void GRExprEngine::VisitAssignmentLHS(Expr* E, GRExprEngine::NodeTy* Pred,
+                                     GRExprEngine::NodeSet& Dst) {
 
   if (isa<DeclRefExpr>(E)) {
     Dst.Add(Pred);
@@ -860,9 +860,9 @@ void GRConstants::VisitAssignmentLHS(Expr* E, GRConstants::NodeTy* Pred,
   Visit(E, Pred, Dst);
 }
 
-void GRConstants::VisitBinaryOperator(BinaryOperator* B,
-                                      GRConstants::NodeTy* Pred,
-                                      GRConstants::NodeSet& Dst) {
+void GRExprEngine::VisitBinaryOperator(BinaryOperator* B,
+                                      GRExprEngine::NodeTy* Pred,
+                                      GRExprEngine::NodeSet& Dst) {
   NodeSet S1;
   
   if (B->isAssignmentOp())
@@ -956,8 +956,8 @@ void GRConstants::VisitBinaryOperator(BinaryOperator* B,
 }
 
 
-void GRConstants::Visit(Stmt* S, GRConstants::NodeTy* Pred,
-                        GRConstants::NodeSet& Dst) {
+void GRExprEngine::Visit(Stmt* S, GRExprEngine::NodeTy* Pred,
+                        GRExprEngine::NodeSet& Dst) {
 
   // FIXME: add metadata to the CFG so that we can disable
   //  this check when we KNOW that there is no block-level subexpression.
@@ -1066,7 +1066,7 @@ void GRConstants::Visit(Stmt* S, GRConstants::NodeTy* Pred,
 // "Assume" logic.
 //===----------------------------------------------------------------------===//
 
-GRConstants::StateTy GRConstants::Assume(StateTy St, LValue Cond,
+GRExprEngine::StateTy GRExprEngine::Assume(StateTy St, LValue Cond,
                                          bool Assumption, 
                                          bool& isFeasible) {    
   
@@ -1096,7 +1096,7 @@ GRConstants::StateTy GRConstants::Assume(StateTy St, LValue Cond,
   }
 }
 
-GRConstants::StateTy GRConstants::Assume(StateTy St, NonLValue Cond,
+GRExprEngine::StateTy GRExprEngine::Assume(StateTy St, NonLValue Cond,
                                          bool Assumption, 
                                          bool& isFeasible) {
   
@@ -1132,8 +1132,8 @@ GRConstants::StateTy GRConstants::Assume(StateTy St, NonLValue Cond,
   }
 }
 
-GRConstants::StateTy
-GRConstants::AssumeSymNE(StateTy St, SymbolID sym,
+GRExprEngine::StateTy
+GRExprEngine::AssumeSymNE(StateTy St, SymbolID sym,
                          const llvm::APSInt& V, bool& isFeasible) {
 
   // First, determine if sym == X, where X != V.
@@ -1155,8 +1155,8 @@ GRConstants::AssumeSymNE(StateTy St, SymbolID sym,
   return StateMgr.AddNE(St, sym, V);
 }
 
-GRConstants::StateTy
-GRConstants::AssumeSymEQ(StateTy St, SymbolID sym,
+GRExprEngine::StateTy
+GRExprEngine::AssumeSymEQ(StateTy St, SymbolID sym,
                          const llvm::APSInt& V, bool& isFeasible) {
   
   // First, determine if sym == X, where X != V.
@@ -1178,8 +1178,8 @@ GRConstants::AssumeSymEQ(StateTy St, SymbolID sym,
   return StateMgr.AddEQ(St, sym, V);
 }
 
-GRConstants::StateTy
-GRConstants::AssumeSymInt(StateTy St, bool Assumption,
+GRExprEngine::StateTy
+GRExprEngine::AssumeSymInt(StateTy St, bool Assumption,
                           const SymIntConstraint& C, bool& isFeasible) {
   
   switch (C.getOpcode()) {
@@ -1206,20 +1206,20 @@ GRConstants::AssumeSymInt(StateTy St, bool Assumption,
 //===----------------------------------------------------------------------===//
 
 #ifndef NDEBUG
-static GRConstants* GraphPrintCheckerState;
+static GRExprEngine* GraphPrintCheckerState;
 
 namespace llvm {
 template<>
-struct VISIBILITY_HIDDEN DOTGraphTraits<GRConstants::NodeTy*> :
+struct VISIBILITY_HIDDEN DOTGraphTraits<GRExprEngine::NodeTy*> :
   public DefaultDOTGraphTraits {
     
-  static void PrintVarBindings(std::ostream& Out, GRConstants::StateTy St) {
+  static void PrintVarBindings(std::ostream& Out, GRExprEngine::StateTy St) {
 
     Out << "Variables:\\l";
     
     bool isFirst = true;
     
-    for (GRConstants::StateTy::vb_iterator I=St.vb_begin(),
+    for (GRExprEngine::StateTy::vb_iterator I=St.vb_begin(),
                                            E=St.vb_end(); I!=E;++I) {        
 
       if (isFirst)
@@ -1234,11 +1234,11 @@ struct VISIBILITY_HIDDEN DOTGraphTraits<GRConstants::NodeTy*> :
   }
     
     
-  static void PrintSubExprBindings(std::ostream& Out, GRConstants::StateTy St) {
+  static void PrintSubExprBindings(std::ostream& Out, GRExprEngine::StateTy St) {
     
     bool isFirst = true;
     
-    for (GRConstants::StateTy::seb_iterator I=St.seb_begin(), E=St.seb_end();
+    for (GRExprEngine::StateTy::seb_iterator I=St.seb_begin(), E=St.seb_end();
                                             I != E;++I) {        
       
       if (isFirst) {
@@ -1255,11 +1255,11 @@ struct VISIBILITY_HIDDEN DOTGraphTraits<GRConstants::NodeTy*> :
     }
   }
     
-  static void PrintBlkExprBindings(std::ostream& Out, GRConstants::StateTy St) {
+  static void PrintBlkExprBindings(std::ostream& Out, GRExprEngine::StateTy St) {
         
     bool isFirst = true;
 
-    for (GRConstants::StateTy::beb_iterator I=St.beb_begin(), E=St.beb_end();
+    for (GRExprEngine::StateTy::beb_iterator I=St.beb_begin(), E=St.beb_end();
                                             I != E; ++I) {      
       if (isFirst) {
         Out << "\\l\\lBlock-level Expressions:\\l";
@@ -1275,7 +1275,7 @@ struct VISIBILITY_HIDDEN DOTGraphTraits<GRConstants::NodeTy*> :
     }
   }
     
-  static void PrintEQ(std::ostream& Out, GRConstants::StateTy St) {
+  static void PrintEQ(std::ostream& Out, GRExprEngine::StateTy St) {
     ValueState::ConstantEqTy CE = St.getImpl()->ConstantEq;
     
     if (CE.isEmpty())
@@ -1287,7 +1287,7 @@ struct VISIBILITY_HIDDEN DOTGraphTraits<GRConstants::NodeTy*> :
       Out << "\\l $" << I.getKey() << " : " << I.getData()->toString();
   }
     
-  static void PrintNE(std::ostream& Out, GRConstants::StateTy St) {
+  static void PrintNE(std::ostream& Out, GRExprEngine::StateTy St) {
     ValueState::ConstantNotEqTy NE = St.getImpl()->ConstantNotEq;
     
     if (NE.isEmpty())
@@ -1312,7 +1312,7 @@ struct VISIBILITY_HIDDEN DOTGraphTraits<GRConstants::NodeTy*> :
     }
   }    
     
-  static std::string getNodeLabel(const GRConstants::NodeTy* N, void*) {
+  static std::string getNodeLabel(const GRExprEngine::NodeTy* N, void*) {
     std::ostringstream Out;
 
     // Program Location.
@@ -1386,16 +1386,16 @@ struct VISIBILITY_HIDDEN DOTGraphTraits<GRConstants::NodeTy*> :
 #endif
 
 namespace clang {
-void RunGRConstants(CFG& cfg, FunctionDecl& FD, ASTContext& Ctx,
+void RunGRExprEngine(CFG& cfg, FunctionDecl& FD, ASTContext& Ctx,
                     Diagnostic& Diag) {
   
-  GREngine<GRConstants> Engine(cfg, FD, Ctx);
+  GRCoreEngine<GRExprEngine> Engine(cfg, FD, Ctx);
   Engine.ExecuteWorkList();
   
   // Look for explicit-Null dereferences and warn about them.
-  GRConstants* CheckerState = &Engine.getCheckerState();
+  GRExprEngine* CheckerState = &Engine.getCheckerState();
   
-  for (GRConstants::null_iterator I=CheckerState->null_begin(),
+  for (GRExprEngine::null_iterator I=CheckerState->null_begin(),
                                   E=CheckerState->null_end(); I!=E; ++I) {
     
     const PostStmt& L = cast<PostStmt>((*I)->getLocation());
@@ -1408,7 +1408,7 @@ void RunGRConstants(CFG& cfg, FunctionDecl& FD, ASTContext& Ctx,
   
 #ifndef NDEBUG
   GraphPrintCheckerState = CheckerState;
-  llvm::ViewGraph(*Engine.getGraph().roots_begin(),"GRConstants");
+  llvm::ViewGraph(*Engine.getGraph().roots_begin(),"GRExprEngine");
   GraphPrintCheckerState = NULL;
 #endif  
 }

diff --git a/Analysis/GREngine.cpp b/Analysis/GREngine.cpp
index a15bcb5ba966b2bc44fa009127ac8e42ec6332e3..5a4ae81ecdc973bbb20ed770d3b7a52781fe41e6 100644 (file)
--- a/Analysis/GREngine.cpp
+++ b/Analysis/GREngine.cpp
@@ -1,4 +1,4 @@
-//==- GREngine.cpp - Path-Sensitive Dataflow Engine ----------------*- C++ -*-//
+//==- GRCoreEngine.cpp - Path-Sensitive Dataflow Engine ----------------*- C++ -*-//
 //             
 //                     The LLVM Compiler Infrastructure
 //
@@ -12,7 +12,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "clang/Analysis/PathSensitive/GREngine.h"
+#include "clang/Analysis/PathSensitive/GRCoreEngine.h"
 #include "clang/AST/Expr.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Casting.h"
@@ -51,7 +51,7 @@ GRWorkList::~GRWorkList() {}
 GRWorkList* GRWorkList::MakeDFS() { return new DFS(); }
 
 /// ExecuteWorkList - Run the worklist algorithm for a maximum number of steps.
-bool GREngineImpl::ExecuteWorkList(unsigned Steps) {
+bool GRCoreEngineImpl::ExecuteWorkList(unsigned Steps) {
   
   if (G->num_roots() == 0) { // Initialize the analysis by constructing
     // the root if none exists.
@@ -113,7 +113,7 @@ bool GREngineImpl::ExecuteWorkList(unsigned Steps) {
   return WList->hasWork();
 }
 
-void GREngineImpl::HandleBlockEdge(const BlockEdge& L, ExplodedNodeImpl* Pred) {
+void GRCoreEngineImpl::HandleBlockEdge(const BlockEdge& L, ExplodedNodeImpl* Pred) {
   
   CFGBlock* Blk = L.getDst();
   
@@ -143,7 +143,7 @@ void GREngineImpl::HandleBlockEdge(const BlockEdge& L, ExplodedNodeImpl* Pred) {
   GenerateNode(BlockEntrance(Blk), Pred->State, Pred);
 }
 
-void GREngineImpl::HandleBlockEntrance(const BlockEntrance& L,
+void GRCoreEngineImpl::HandleBlockEntrance(const BlockEntrance& L,
                                        ExplodedNodeImpl* Pred) {
   
   // Increment the block counter.
@@ -161,7 +161,7 @@ void GREngineImpl::HandleBlockEntrance(const BlockEntrance& L,
 }
 
 
-void GREngineImpl::HandleBlockExit(CFGBlock * B, ExplodedNodeImpl* Pred) {
+void GRCoreEngineImpl::HandleBlockExit(CFGBlock * B, ExplodedNodeImpl* Pred) {
   
   if (Stmt* Term = B->getTerminator()) {
     switch (Term->getStmtClass()) {
@@ -225,7 +225,7 @@ void GREngineImpl::HandleBlockExit(CFGBlock * B, ExplodedNodeImpl* Pred) {
   GenerateNode(BlockEdge(getCFG(),B,*(B->succ_begin())), Pred->State, Pred);
 }
 
-void GREngineImpl::HandleBranch(Expr* Cond, Stmt* Term, CFGBlock * B,
+void GRCoreEngineImpl::HandleBranch(Expr* Cond, Stmt* Term, CFGBlock * B,
                                 ExplodedNodeImpl* Pred) {
   assert (B->succ_size() == 2);
 
@@ -235,7 +235,7 @@ void GREngineImpl::HandleBranch(Expr* Cond, Stmt* Term, CFGBlock * B,
   ProcessBranch(Cond, Term, Builder);
 }
 
-void GREngineImpl::HandlePostStmt(const PostStmt& L, CFGBlock* B,
+void GRCoreEngineImpl::HandlePostStmt(const PostStmt& L, CFGBlock* B,
                                   unsigned StmtIdx, ExplodedNodeImpl* Pred) {
   
   assert (!B->empty());
@@ -263,7 +263,7 @@ static void PopulateParentMap(Stmt* Parent, ParentMapTy& M) {
 
 /// GenerateNode - Utility method to generate nodes, hook up successors,
 ///  and add nodes to the worklist.
-void GREngineImpl::GenerateNode(const ProgramPoint& Loc, void* State,
+void GRCoreEngineImpl::GenerateNode(const ProgramPoint& Loc, void* State,
                                 ExplodedNodeImpl* Pred) {
   
   bool IsNew;
@@ -281,7 +281,7 @@ void GREngineImpl::GenerateNode(const ProgramPoint& Loc, void* State,
 }
 
 GRStmtNodeBuilderImpl::GRStmtNodeBuilderImpl(CFGBlock* b, unsigned idx,
-                                     ExplodedNodeImpl* N, GREngineImpl* e)
+                                     ExplodedNodeImpl* N, GRCoreEngineImpl* e)
   : Eng(*e), B(*b), Idx(idx), LastNode(N), Populated(false) {
   Deferred.insert(N);
 }

diff --git a/Analysis/RValues.h b/Analysis/RValues.h
index ffc5e4a57d4630e25e418a1c7d59660d0f9629d6..2f500fea681e20702b91b42e9b64f407646292ff 100644 (file)
--- a/Analysis/RValues.h
+++ b/Analysis/RValues.h
@@ -17,7 +17,7 @@
 
 // FIXME: reduce the number of includes.
 
-#include "clang/Analysis/PathSensitive/GREngine.h"
+#include "clang/Analysis/PathSensitive/GRCoreEngine.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/ASTContext.h"

diff --git a/Analysis/ValueState.h b/Analysis/ValueState.h
index 8ea699452a639c61e3f30f2226078900d6aa215d..5ddcfb6b99f0d3260f23d0533da7f0a16b9cfd1e 100644 (file)
--- a/Analysis/ValueState.h
+++ b/Analysis/ValueState.h
@@ -18,7 +18,7 @@
 
 #include "RValues.h"
 
-#include "clang/Analysis/PathSensitive/GREngine.h"
+#include "clang/Analysis/PathSensitive/GRCoreEngine.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/ASTContext.h"
@@ -112,7 +112,7 @@ public:
 ///  tracking. It is really just a "smart pointer", wrapping a pointer
 ///  to ValueStateImpl object.  Making this class a smart pointer means that its
 ///  size is always the size of a pointer, which allows easy conversion to
-///  void* when being handled by GREngine.  It also forces us to unique states;
+///  void* when being handled by GRCoreEngine.  It also forces us to unique states;
 ///  consequently, a ValueStateImpl* with a specific address will always refer
 ///  to the unique state with those values.
 class ValueState {

diff --git a/include/clang/Analysis/PathSensitive/ExplodedGraph.h b/include/clang/Analysis/PathSensitive/ExplodedGraph.h
index 7b52003c6bfb0c5b1f5310e4491d23eea7e0d569..acc97084ec9d1aca595402784ed522651f0adc4b 100644 (file)
--- a/include/clang/Analysis/PathSensitive/ExplodedGraph.h
+++ b/include/clang/Analysis/PathSensitive/ExplodedGraph.h
@@ -26,7 +26,7 @@
 
 namespace clang {
 
-class GREngineImpl;
+class GRCoreEngineImpl;
 class ExplodedNodeImpl;
 class GRStmtNodeBuilderImpl;
 class GRBranchNodeBuilderImpl;
@@ -39,7 +39,7 @@ class FunctionDecl;
 class ExplodedNodeImpl : public llvm::FoldingSetNode {
 protected:
   friend class ExplodedGraphImpl;
-  friend class GREngineImpl;
+  friend class GRCoreEngineImpl;
   friend class GRStmtNodeBuilderImpl;
   friend class GRBranchNodeBuilderImpl;
   friend class GRIndirectGotoNodeBuilderImpl;
@@ -194,7 +194,7 @@ public:
 
 class ExplodedGraphImpl {
 protected:
-  friend class GREngineImpl;
+  friend class GRCoreEngineImpl;
   friend class GRStmtNodeBuilderImpl;
   friend class GRBranchNodeBuilderImpl;
   friend class GRIndirectGotoNodeBuilderImpl;
@@ -231,7 +231,7 @@ protected:
 
   /// getNodeImpl - Retrieve the node associated with a (Location,State)
   ///  pair, where 'State' is represented as an opaque void*.  This method
-  ///  is intended to be used only by GREngineImpl.
+  ///  is intended to be used only by GRCoreEngineImpl.
   virtual ExplodedNodeImpl* getNodeImpl(const ProgramPoint& L, void* State,
                                         bool* IsNew) = 0;
 

diff --git a/include/clang/Analysis/PathSensitive/GRBlockCounter.h b/include/clang/Analysis/PathSensitive/GRBlockCounter.h
index 4197a8fd851b81a21dae92ffdd4f4b95e585f4f5..b4fd2704b81a6e5e5e34e1b0e2437d1a4f2caff2 100644 (file)
--- a/include/clang/Analysis/PathSensitive/GRBlockCounter.h
+++ b/include/clang/Analysis/PathSensitive/GRBlockCounter.h
@@ -9,7 +9,7 @@
 //
 //  This file defines GRBlockCounter, an abstract data type used to count
 //  the number of times a given block has been visited along a path
-//  analyzed by GREngine.
+//  analyzed by GRCoreEngine.
 //
 //===----------------------------------------------------------------------===//
 

diff --git a/include/clang/Analysis/PathSensitive/GREngine.h b/include/clang/Analysis/PathSensitive/GREngine.h
index bceb1b85944fa04c33dee96da15151b46533c6bb..4dd2b6464ad51bac042eb0a511f18ea4804cd283 100644 (file)
--- a/include/clang/Analysis/PathSensitive/GREngine.h
+++ b/include/clang/Analysis/PathSensitive/GREngine.h
@@ -1,4 +1,4 @@
-//==- GREngine.h - Path-Sensitive Dataflow Engine ------------------*- C++ -*-//
+//==- GRCoreEngine.h - Path-Sensitive Dataflow Engine ------------------*- C++ -*-//
 //             
 //                     The LLVM Compiler Infrastructure
 //
@@ -31,15 +31,15 @@ class GRWorkList;
 class LabelStmt;
 
 //===----------------------------------------------------------------------===//
-/// GREngineImpl - Implements the core logic of the graph-reachability analysis.
+/// GRCoreEngineImpl - Implements the core logic of the graph-reachability analysis.
 ///   It traverses the CFG and generates the ExplodedGraph. Program "states"
-///   are treated as opaque void pointers.  The template class GREngine
-///   (which subclasses GREngineImpl) provides the matching component
+///   are treated as opaque void pointers.  The template class GRCoreEngine
+///   (which subclasses GRCoreEngineImpl) provides the matching component
 ///   to the engine that knows the actual types for states.  Note that this
 ///   engine only dispatches to transfer functions as the statement and
 ///   block-level.  The analyses themselves must implement any transfer
 ///   function logic and the sub-expression level (if any).
-class GREngineImpl {
+class GRCoreEngineImpl {
 protected:
   friend class GRStmtNodeBuilderImpl;
   friend class GRBranchNodeBuilderImpl;
@@ -72,7 +72,7 @@ protected:
   
   /// getInitialState - Gets the void* representing the initial 'state'
   ///  of the analysis.  This is simply a wrapper (implemented
-  ///  in GREngine) that performs type erasure on the initial
+  ///  in GRCoreEngine) that performs type erasure on the initial
   ///  state returned by the checker object.
   virtual void* getInitialState() = 0;
   
@@ -95,11 +95,11 @@ protected:
   virtual void ProcessIndirectGoto(GRIndirectGotoNodeBuilderImpl& Builder) = 0;
 
 private:
-  GREngineImpl(const GREngineImpl&); // Do not implement.
-  GREngineImpl& operator=(const GREngineImpl&);
+  GRCoreEngineImpl(const GRCoreEngineImpl&); // Do not implement.
+  GRCoreEngineImpl& operator=(const GRCoreEngineImpl&);
   
 protected:  
-  GREngineImpl(ExplodedGraphImpl* g, GRWorkList* wl)
+  GRCoreEngineImpl(ExplodedGraphImpl* g, GRWorkList* wl)
     : G(g), WList(wl), BCounterFactory(g->getAllocator()) {}
   
 public:
@@ -107,13 +107,13 @@ public:
   ///  steps.  Returns true if there is still simulation state on the worklist.
   bool ExecuteWorkList(unsigned Steps = 1000000);
   
-  virtual ~GREngineImpl() {}
+  virtual ~GRCoreEngineImpl() {}
   
   CFG& getCFG() { return G->getCFG(); }
 };
   
 class GRStmtNodeBuilderImpl {
-  GREngineImpl& Eng;
+  GRCoreEngineImpl& Eng;
   CFGBlock& B;
   const unsigned Idx;
   ExplodedNodeImpl* LastNode;  
@@ -127,7 +127,7 @@ class GRStmtNodeBuilderImpl {
   
 public:
   GRStmtNodeBuilderImpl(CFGBlock* b, unsigned idx,
-                    ExplodedNodeImpl* N, GREngineImpl* e);      
+                    ExplodedNodeImpl* N, GRCoreEngineImpl* e);      
   
   ~GRStmtNodeBuilderImpl();
   
@@ -183,7 +183,7 @@ public:
 };
   
 class GRBranchNodeBuilderImpl {
-  GREngineImpl& Eng;
+  GRCoreEngineImpl& Eng;
   CFGBlock* Src;
   CFGBlock* DstT;
   CFGBlock* DstF;
@@ -197,7 +197,7 @@ class GRBranchNodeBuilderImpl {
   
 public:
   GRBranchNodeBuilderImpl(CFGBlock* src, CFGBlock* dstT, CFGBlock* dstF,
-                          ExplodedNodeImpl* pred, GREngineImpl* e) 
+                          ExplodedNodeImpl* pred, GRCoreEngineImpl* e) 
   : Eng(*e), Src(src), DstT(dstT), DstF(dstF), Pred(pred),
     GeneratedTrue(false), GeneratedFalse(false) {}
   
@@ -262,7 +262,7 @@ public:
 };
   
 class GRIndirectGotoNodeBuilderImpl {
-  GREngineImpl& Eng;
+  GRCoreEngineImpl& Eng;
   CFGBlock* Src;
   CFGBlock& DispatchBlock;
   Expr* E;
@@ -270,7 +270,7 @@ class GRIndirectGotoNodeBuilderImpl {
 public:
   GRIndirectGotoNodeBuilderImpl(ExplodedNodeImpl* pred, CFGBlock* src,
                                 Expr* e, CFGBlock* dispatch,
-                                GREngineImpl* eng)
+                                GRCoreEngineImpl* eng)
   : Eng(*eng), Src(src), DispatchBlock(*dispatch), E(e), Pred(pred) {}
   
 
@@ -334,7 +334,7 @@ public:
 
   
 template<typename CHECKER>
-class GREngine : public GREngineImpl {
+class GRCoreEngine : public GRCoreEngineImpl {
 public:
   typedef CHECKER                                CheckerTy; 
   typedef typename CheckerTy::StateTy            StateTy;
@@ -372,20 +372,20 @@ protected:
   }
   
 public:  
-  /// Construct a GREngine object to analyze the provided CFG using
+  /// Construct a GRCoreEngine object to analyze the provided CFG using
   ///  a DFS exploration of the exploded graph.
-  GREngine(CFG& cfg, FunctionDecl& fd, ASTContext& ctx)
-    : GREngineImpl(new GraphTy(cfg, fd, ctx), GRWorkList::MakeDFS()),
+  GRCoreEngine(CFG& cfg, FunctionDecl& fd, ASTContext& ctx)
+    : GRCoreEngineImpl(new GraphTy(cfg, fd, ctx), GRWorkList::MakeDFS()),
       Checker(static_cast<GraphTy*>(G.get())->getCheckerState()) {}
   
-  /// Construct a GREngine object to analyze the provided CFG and to
+  /// Construct a GRCoreEngine object to analyze the provided CFG and to
   ///  use the provided worklist object to execute the worklist algorithm.
-  ///  The GREngine object assumes ownership of 'wlist'.
-  GREngine(CFG& cfg, FunctionDecl& fd, ASTContext& ctx, GRWorkList* wlist)
-    : GREngineImpl(new GraphTy(cfg, fd, ctx), wlist),
+  ///  The GRCoreEngine object assumes ownership of 'wlist'.
+  GRCoreEngine(CFG& cfg, FunctionDecl& fd, ASTContext& ctx, GRWorkList* wlist)
+    : GRCoreEngineImpl(new GraphTy(cfg, fd, ctx), wlist),
       Checker(static_cast<GraphTy*>(G.get())->getCheckerState()) {}
   
-  virtual ~GREngine() {}
+  virtual ~GRCoreEngine() {}
   
   /// getGraph - Returns the exploded graph.
   GraphTy& getGraph() {

diff --git a/include/clang/Analysis/PathSensitive/GRWorkList.h b/include/clang/Analysis/PathSensitive/GRWorkList.h
index b18da6be29ce5531df89202b24d237f8a9f1f6bc..401e35042e7323e61f52f8024244b665b5841397 100644 (file)
--- a/include/clang/Analysis/PathSensitive/GRWorkList.h
+++ b/include/clang/Analysis/PathSensitive/GRWorkList.h
@@ -1,4 +1,4 @@
-//==- GRWorkList.h - Worklist class used by GREngine ---------------*- C++ -*-//
+//==- GRWorkList.h - Worklist class used by GRCoreEngine ---------------*- C++ -*-//
 //             
 //                     The LLVM Compiler Infrastructure
 //
@@ -8,7 +8,7 @@
 //===----------------------------------------------------------------------===//
 //
 //  This file defines GRWorkList, a pure virtual class that represents an
-//  opaque worklist used by GREngine to explore the reachability state space.
+//  opaque worklist used by GRCoreEngine to explore the reachability state space.
 //
 //===----------------------------------------------------------------------===//