Cleanup various declarations of 'Stmt*' to be 'Stmt *', etc. in libAnalyzer and libStaticAnalyzer[*]. It was highly inconsistent, and very ugly to look at.

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

20 files changed, 509 insertions, 509 deletions

diff --git a/lib/StaticAnalyzer/Core/BasicConstraintManager.cpp b/lib/StaticAnalyzer/Core/BasicConstraintManager.cpp
index 0518740dad..b9f145ef08 100644
--- a/lib/StaticAnalyzer/Core/BasicConstraintManager.cpp
+++ b/lib/StaticAnalyzer/Core/BasicConstraintManager.cpp
@@ -35,12 +35,12 @@ namespace clang {
 namespace ento {
 template<>
 struct GRStateTrait<ConstNotEq> : public GRStatePartialTrait<ConstNotEqTy> {
-  static inline void* GDMIndex() { return &ConstNotEqIndex; }
+  static inline void *GDMIndex() { return &ConstNotEqIndex; }
 };
 
 template<>
 struct GRStateTrait<ConstEq> : public GRStatePartialTrait<ConstEqTy> {
-  static inline void* GDMIndex() { return &ConstEqIndex; }
+  static inline void *GDMIndex() { return &ConstEqIndex; }
 };
 }
 }
@@ -56,43 +56,43 @@ public:
     : SimpleConstraintManager(subengine), 
       ISetFactory(statemgr.getAllocator()) {}
 
-  const GRState *assumeSymNE(const GRState* state, SymbolRef sym,
+  const GRState *assumeSymNE(const GRState *state, SymbolRef sym,
                              const llvm::APSInt& V,
                              const llvm::APSInt& Adjustment);
 
-  const GRState *assumeSymEQ(const GRState* state, SymbolRef sym,
+  const GRState *assumeSymEQ(const GRState *state, SymbolRef sym,
                              const llvm::APSInt& V,
                              const llvm::APSInt& Adjustment);
 
-  const GRState *assumeSymLT(const GRState* state, SymbolRef sym,
+  const GRState *assumeSymLT(const GRState *state, SymbolRef sym,
                              const llvm::APSInt& V,
                              const llvm::APSInt& Adjustment);
 
-  const GRState *assumeSymGT(const GRState* state, SymbolRef sym,
+  const GRState *assumeSymGT(const GRState *state, SymbolRef sym,
                              const llvm::APSInt& V,
                              const llvm::APSInt& Adjustment);
 
-  const GRState *assumeSymGE(const GRState* state, SymbolRef sym,
+  const GRState *assumeSymGE(const GRState *state, SymbolRef sym,
                              const llvm::APSInt& V,
                              const llvm::APSInt& Adjustment);
 
-  const GRState *assumeSymLE(const GRState* state, SymbolRef sym,
+  const GRState *assumeSymLE(const GRState *state, SymbolRef sym,
                              const llvm::APSInt& V,
                              const llvm::APSInt& Adjustment);
 
-  const GRState* AddEQ(const GRState* state, SymbolRef sym, const llvm::APSInt& V);
+  const GRState *AddEQ(const GRState *state, SymbolRef sym, const llvm::APSInt& V);
 
-  const GRState* AddNE(const GRState* state, SymbolRef sym, const llvm::APSInt& V);
+  const GRState *AddNE(const GRState *state, SymbolRef sym, const llvm::APSInt& V);
 
-  const llvm::APSInt* getSymVal(const GRState* state, SymbolRef sym) const;
-  bool isNotEqual(const GRState* state, SymbolRef sym, const llvm::APSInt& V)
+  const llvm::APSInt* getSymVal(const GRState *state, SymbolRef sym) const;
+  bool isNotEqual(const GRState *state, SymbolRef sym, const llvm::APSInt& V)
       const;
-  bool isEqual(const GRState* state, SymbolRef sym, const llvm::APSInt& V)
+  bool isEqual(const GRState *state, SymbolRef sym, const llvm::APSInt& V)
       const;
 
-  const GRState* removeDeadBindings(const GRState* state, SymbolReaper& SymReaper);
+  const GRState *removeDeadBindings(const GRState *state, SymbolReaper& SymReaper);
 
-  void print(const GRState* state, raw_ostream& Out,
+  void print(const GRState *state, raw_ostream &Out,
              const char* nl, const char *sep);
 };
 
@@ -229,13 +229,13 @@ BasicConstraintManager::assumeSymLE(const GRState *state, SymbolRef sym,
   return state;
 }
 
-const GRState* BasicConstraintManager::AddEQ(const GRState* state, SymbolRef sym,
+const GRState *BasicConstraintManager::AddEQ(const GRState *state, SymbolRef sym,
                                              const llvm::APSInt& V) {
   // Create a new state with the old binding replaced.
   return state->set<ConstEq>(sym, &state->getBasicVals().getValue(V));
 }
 
-const GRState* BasicConstraintManager::AddNE(const GRState* state, SymbolRef sym,
+const GRState *BasicConstraintManager::AddNE(const GRState *state, SymbolRef sym,
                                              const llvm::APSInt& V) {
 
   // First, retrieve the NE-set associated with the given symbol.
@@ -249,13 +249,13 @@ const GRState* BasicConstraintManager::AddNE(const GRState* state, SymbolRef sym
   return state->set<ConstNotEq>(sym, S);
 }
 
-const llvm::APSInt* BasicConstraintManager::getSymVal(const GRState* state,
+const llvm::APSInt* BasicConstraintManager::getSymVal(const GRState *state,
                                                       SymbolRef sym) const {
   const ConstEqTy::data_type* T = state->get<ConstEq>(sym);
   return T ? *T : NULL;
 }
 
-bool BasicConstraintManager::isNotEqual(const GRState* state, SymbolRef sym,
+bool BasicConstraintManager::isNotEqual(const GRState *state, SymbolRef sym,
                                         const llvm::APSInt& V) const {
 
   // Retrieve the NE-set associated with the given symbol.
@@ -265,7 +265,7 @@ bool BasicConstraintManager::isNotEqual(const GRState* state, SymbolRef sym,
   return T ? T->contains(&state->getBasicVals().getValue(V)) : false;
 }
 
-bool BasicConstraintManager::isEqual(const GRState* state, SymbolRef sym,
+bool BasicConstraintManager::isEqual(const GRState *state, SymbolRef sym,
                                      const llvm::APSInt& V) const {
   // Retrieve the EQ-set associated with the given symbol.
   const ConstEqTy::data_type* T = state->get<ConstEq>(sym);
@@ -276,7 +276,7 @@ bool BasicConstraintManager::isEqual(const GRState* state, SymbolRef sym,
 /// Scan all symbols referenced by the constraints. If the symbol is not alive
 /// as marked in LSymbols, mark it as dead in DSymbols.
 const GRState*
-BasicConstraintManager::removeDeadBindings(const GRState* state,
+BasicConstraintManager::removeDeadBindings(const GRState *state,
                                            SymbolReaper& SymReaper) {
 
   ConstEqTy CE = state->get<ConstEq>();
@@ -301,7 +301,7 @@ BasicConstraintManager::removeDeadBindings(const GRState* state,
   return state->set<ConstNotEq>(CNE);
 }
 
-void BasicConstraintManager::print(const GRState* state, raw_ostream& Out,
+void BasicConstraintManager::print(const GRState *state, raw_ostream &Out,
                                    const char* nl, const char *sep) {
   // Print equality constraints.
 
diff --git a/lib/StaticAnalyzer/Core/BasicValueFactory.cpp b/lib/StaticAnalyzer/Core/BasicValueFactory.cpp
index f08c1fdbdb..fe96700772 100644
--- a/lib/StaticAnalyzer/Core/BasicValueFactory.cpp
+++ b/lib/StaticAnalyzer/Core/BasicValueFactory.cpp
@@ -70,7 +70,7 @@ BasicValueFactory::~BasicValueFactory() {
 
 const llvm::APSInt& BasicValueFactory::getValue(const llvm::APSInt& X) {
   llvm::FoldingSetNodeID ID;
-  void* InsertPos;
+  void *InsertPos;
   typedef llvm::FoldingSetNodeWrapper<llvm::APSInt> FoldNodeTy;
 
   X.Profile(ID);
@@ -113,7 +113,7 @@ BasicValueFactory::getCompoundValData(QualType T,
 
   llvm::FoldingSetNodeID ID;
   CompoundValData::Profile(ID, T, Vals);
-  void* InsertPos;
+  void *InsertPos;
 
   CompoundValData* D = CompoundValDataSet.FindNodeOrInsertPos(ID, InsertPos);
 
@@ -131,7 +131,7 @@ BasicValueFactory::getLazyCompoundValData(const StoreRef &store,
                                           const TypedValueRegion *region) {
   llvm::FoldingSetNodeID ID;
   LazyCompoundValData::Profile(ID, store, region);
-  void* InsertPos;
+  void *InsertPos;
 
   LazyCompoundValData *D =
     LazyCompoundValDataSet.FindNodeOrInsertPos(ID, InsertPos);
@@ -243,7 +243,7 @@ BasicValueFactory::getPersistentSValWithData(const SVal& V, uintptr_t Data) {
   if (!PersistentSVals) PersistentSVals = new PersistentSValsTy();
 
   llvm::FoldingSetNodeID ID;
-  void* InsertPos;
+  void *InsertPos;
   V.Profile(ID);
   ID.AddPointer((void*) Data);
 
@@ -268,7 +268,7 @@ BasicValueFactory::getPersistentSValPair(const SVal& V1, const SVal& V2) {
   if (!PersistentSValPairs) PersistentSValPairs = new PersistentSValPairsTy();
 
   llvm::FoldingSetNodeID ID;
-  void* InsertPos;
+  void *InsertPos;
   V1.Profile(ID);
   V2.Profile(ID);
 
diff --git a/lib/StaticAnalyzer/Core/BlockCounter.cpp b/lib/StaticAnalyzer/Core/BlockCounter.cpp
index ed52b6b012..74d761e1ec 100644
--- a/lib/StaticAnalyzer/Core/BlockCounter.cpp
+++ b/lib/StaticAnalyzer/Core/BlockCounter.cpp
@@ -48,11 +48,11 @@ public:
 
 typedef llvm::ImmutableMap<CountKey, unsigned> CountMap;
 
-static inline CountMap GetMap(void* D) {
+static inline CountMap GetMap(void *D) {
   return CountMap(static_cast<CountMap::TreeTy*>(D));
 }
 
-static inline CountMap::Factory& GetFactory(void* F) {
+static inline CountMap::Factory& GetFactory(void *F) {
   return *static_cast<CountMap::Factory*>(F);
 }
 
diff --git a/lib/StaticAnalyzer/Core/BugReporter.cpp b/lib/StaticAnalyzer/Core/BugReporter.cpp
index 0d0ea8b889..67a5e48a1e 100644
--- a/lib/StaticAnalyzer/Core/BugReporter.cpp
+++ b/lib/StaticAnalyzer/Core/BugReporter.cpp
@@ -59,26 +59,26 @@ void BugReporterContext::addVisitor(BugReporterVisitor* visitor) {
 // Helper routines for walking the ExplodedGraph and fetching statements.
 //===----------------------------------------------------------------------===//
 
-static inline const Stmt* GetStmt(const ProgramPoint &P) {
+static inline const Stmt *GetStmt(const ProgramPoint &P) {
   if (const StmtPoint* SP = dyn_cast<StmtPoint>(&P))
     return SP->getStmt();
-  else if (const BlockEdge* BE = dyn_cast<BlockEdge>(&P))
+  else if (const BlockEdge *BE = dyn_cast<BlockEdge>(&P))
     return BE->getSrc()->getTerminator();
 
   return 0;
 }
 
 static inline const ExplodedNode*
-GetPredecessorNode(const ExplodedNode* N) {
+GetPredecessorNode(const ExplodedNode *N) {
   return N->pred_empty() ? NULL : *(N->pred_begin());
 }
 
 static inline const ExplodedNode*
-GetSuccessorNode(const ExplodedNode* N) {
+GetSuccessorNode(const ExplodedNode *N) {
   return N->succ_empty() ? NULL : *(N->succ_begin());
 }
 
-static const Stmt* GetPreviousStmt(const ExplodedNode* N) {
+static const Stmt *GetPreviousStmt(const ExplodedNode *N) {
   for (N = GetPredecessorNode(N); N; N = GetPredecessorNode(N))
     if (const Stmt *S = GetStmt(N->getLocation()))
       return S;
@@ -86,7 +86,7 @@ static const Stmt* GetPreviousStmt(const ExplodedNode* N) {
   return 0;
 }
 
-static const Stmt* GetNextStmt(const ExplodedNode* N) {
+static const Stmt *GetNextStmt(const ExplodedNode *N) {
   for (N = GetSuccessorNode(N); N; N = GetSuccessorNode(N))
     if (const Stmt *S = GetStmt(N->getLocation())) {
       // Check if the statement is '?' or '&&'/'||'.  These are "merges",
@@ -116,7 +116,7 @@ static const Stmt* GetNextStmt(const ExplodedNode* N) {
 }
 
 static inline const Stmt*
-GetCurrentOrPreviousStmt(const ExplodedNode* N) {
+GetCurrentOrPreviousStmt(const ExplodedNode *N) {
   if (const Stmt *S = GetStmt(N->getLocation()))
     return S;
 
@@ -124,7 +124,7 @@ GetCurrentOrPreviousStmt(const ExplodedNode* N) {
 }
 
 static inline const Stmt*
-GetCurrentOrNextStmt(const ExplodedNode* N) {
+GetCurrentOrNextStmt(const ExplodedNode *N) {
   if (const Stmt *S = GetStmt(N->getLocation()))
     return S;
 
@@ -145,7 +145,7 @@ public:
   NodeMapClosure(NodeBackMap *m) : M(*m) {}
   ~NodeMapClosure() {}
 
-  const ExplodedNode* getOriginalNode(const ExplodedNode* N) {
+  const ExplodedNode *getOriginalNode(const ExplodedNode *N) {
     NodeBackMap::iterator I = M.find(N);
     return I == M.end() ? 0 : I->second;
   }
@@ -165,10 +165,10 @@ public:
     addVisitor(R);
   }
 
-  PathDiagnosticLocation ExecutionContinues(const ExplodedNode* N);
+  PathDiagnosticLocation ExecutionContinues(const ExplodedNode *N);
 
-  PathDiagnosticLocation ExecutionContinues(llvm::raw_string_ostream& os,
-                                            const ExplodedNode* N);
+  PathDiagnosticLocation ExecutionContinues(llvm::raw_string_ostream &os,
+                                            const ExplodedNode *N);
 
   Decl const &getCodeDecl() { return R->getErrorNode()->getCodeDecl(); }
 
@@ -193,7 +193,7 @@ public:
 } // end anonymous namespace
 
 PathDiagnosticLocation
-PathDiagnosticBuilder::ExecutionContinues(const ExplodedNode* N) {
+PathDiagnosticBuilder::ExecutionContinues(const ExplodedNode *N) {
   if (const Stmt *S = GetNextStmt(N))
     return PathDiagnosticLocation(S, getSourceManager());
 
@@ -202,8 +202,8 @@ PathDiagnosticBuilder::ExecutionContinues(const ExplodedNode* N) {
 }
 
 PathDiagnosticLocation
-PathDiagnosticBuilder::ExecutionContinues(llvm::raw_string_ostream& os,
-                                          const ExplodedNode* N) {
+PathDiagnosticBuilder::ExecutionContinues(llvm::raw_string_ostream &os,
+                                          const ExplodedNode *N) {
 
   // Slow, but probably doesn't matter.
   if (os.str().empty())
@@ -253,7 +253,7 @@ static bool IsNested(const Stmt *S, ParentMap &PM) {
 
 PathDiagnosticLocation
 PathDiagnosticBuilder::getEnclosingStmtLocation(const Stmt *S) {
-  assert(S && "Null Stmt* passed to getEnclosingStmtLocation");
+  assert(S && "Null Stmt *passed to getEnclosingStmtLocation");
   ParentMap &P = getParentMap();
   SourceManager &SMgr = getSourceManager();
 
@@ -347,7 +347,7 @@ PathDiagnosticBuilder::getEnclosingStmtLocation(const Stmt *S) {
 //===----------------------------------------------------------------------===//
 
 static const VarDecl*
-GetMostRecentVarDeclBinding(const ExplodedNode* N,
+GetMostRecentVarDeclBinding(const ExplodedNode *N,
                             GRStateManager& VMgr, SVal X) {
 
   for ( ; N ; N = N->pred_empty() ? 0 : *N->pred_begin()) {
@@ -357,7 +357,7 @@ GetMostRecentVarDeclBinding(const ExplodedNode* N,
     if (!isa<PostStmt>(P))
       continue;
 
-    const DeclRefExpr* DR = dyn_cast<DeclRefExpr>(cast<PostStmt>(P).getStmt());
+    const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(cast<PostStmt>(P).getStmt());
 
     if (!DR)
       continue;
@@ -367,7 +367,7 @@ GetMostRecentVarDeclBinding(const ExplodedNode* N,
     if (X != Y)
       continue;
 
-    const VarDecl* VD = dyn_cast<VarDecl>(DR->getDecl());
+    const VarDecl *VD = dyn_cast<VarDecl>(DR->getDecl());
 
     if (!VD)
       continue;
@@ -383,17 +383,17 @@ class NotableSymbolHandler
 : public StoreManager::BindingsHandler {
 
   SymbolRef Sym;
-  const GRState* PrevSt;
-  const Stmt* S;
+  const GRState *PrevSt;
+  const Stmt *S;
   GRStateManager& VMgr;
-  const ExplodedNode* Pred;
+  const ExplodedNode *Pred;
   PathDiagnostic& PD;
   BugReporter& BR;
 
 public:
 
-  NotableSymbolHandler(SymbolRef sym, const GRState* prevst, const Stmt* s,
-                       GRStateManager& vmgr, const ExplodedNode* pred,
+  NotableSymbolHandler(SymbolRef sym, const GRState *prevst, const Stmt *s,
+                       GRStateManager& vmgr, const ExplodedNode *pred,
                        PathDiagnostic& pd, BugReporter& br)
   : Sym(sym), PrevSt(prevst), S(s), VMgr(vmgr), Pred(pred), PD(pd), BR(br) {}
 
@@ -422,14 +422,14 @@ public:
         return true;
 
       // What variable did we assign to?
-      DeclRefExpr* DR = dyn_cast<DeclRefExpr>(B->getLHS()->IgnoreParenCasts());
+      DeclRefExpr *DR = dyn_cast<DeclRefExpr>(B->getLHS()->IgnoreParenCasts());
 
       if (!DR)
         return true;
 
       VD = dyn_cast<VarDecl>(DR->getDecl());
     }
-    else if (const DeclStmt* DS = dyn_cast<DeclStmt>(S)) {
+    else if (const DeclStmt *DS = dyn_cast<DeclStmt>(S)) {
       // FIXME: Eventually CFGs won't have DeclStmts.  Right now we
       //  assume that each DeclStmt has a single Decl.  This invariant
       //  holds by construction in the CFG.
@@ -440,7 +440,7 @@ public:
       return true;
 
     // What is the most recently referenced variable with this binding?
-    const VarDecl* MostRecent = GetMostRecentVarDeclBinding(Pred, VMgr, V);
+    const VarDecl *MostRecent = GetMostRecentVarDeclBinding(Pred, VMgr, V);
 
     if (!MostRecent)
       return true;
@@ -460,13 +460,13 @@ public:
 };
 }
 
-static void HandleNotableSymbol(const ExplodedNode* N,
-                                const Stmt* S,
+static void HandleNotableSymbol(const ExplodedNode *N,
+                                const Stmt *S,
                                 SymbolRef Sym, BugReporter& BR,
                                 PathDiagnostic& PD) {
 
-  const ExplodedNode* Pred = N->pred_empty() ? 0 : *N->pred_begin();
-  const GRState* PrevSt = Pred ? Pred->getState() : 0;
+  const ExplodedNode *Pred = N->pred_empty() ? 0 : *N->pred_begin();
+  const GRState *PrevSt = Pred ? Pred->getState() : 0;
 
   if (!PrevSt)
     return;
@@ -483,13 +483,13 @@ class ScanNotableSymbols
 : public StoreManager::BindingsHandler {
 
   llvm::SmallSet<SymbolRef, 10> AlreadyProcessed;
-  const ExplodedNode* N;
-  const Stmt* S;
+  const ExplodedNode *N;
+  const Stmt *S;
   GRBugReporter& BR;
   PathDiagnostic& PD;
 
 public:
-  ScanNotableSymbols(const ExplodedNode* n, const Stmt* s,
+  ScanNotableSymbols(const ExplodedNode *n, const Stmt *s,
                      GRBugReporter& br, PathDiagnostic& pd)
   : N(n), S(s), BR(br), PD(pd) {}
 
@@ -526,7 +526,7 @@ static void GenerateMinimalPathDiagnostic(PathDiagnostic& PD,
                                           const ExplodedNode *N) {
 
   SourceManager& SMgr = PDB.getSourceManager();
-  const ExplodedNode* NextNode = N->pred_empty()
+  const ExplodedNode *NextNode = N->pred_empty()
                                         ? NULL : *(N->pred_begin());
   while (NextNode) {
     N = NextNode;
@@ -534,10 +534,10 @@ static void GenerateMinimalPathDiagnostic(PathDiagnostic& PD,
 
     ProgramPoint P = N->getLocation();
 
-    if (const BlockEdge* BE = dyn_cast<BlockEdge>(&P)) {
-      const CFGBlock* Src = BE->getSrc();
-      const CFGBlock* Dst = BE->getDst();
-      const Stmt* T = Src->getTerminator();
+    if (const BlockEdge *BE = dyn_cast<BlockEdge>(&P)) {
+      const CFGBlock *Src = BE->getSrc();
+      const CFGBlock *Dst = BE->getDst();
+      const Stmt *T = Src->getTerminator();
 
       if (!T)
         continue;
@@ -550,7 +550,7 @@ static void GenerateMinimalPathDiagnostic(PathDiagnostic& PD,
 
         case Stmt::GotoStmtClass:
         case Stmt::IndirectGotoStmtClass: {
-          const Stmt* S = GetNextStmt(N);
+          const Stmt *S = GetNextStmt(N);
 
           if (!S)
             continue;
@@ -571,7 +571,7 @@ static void GenerateMinimalPathDiagnostic(PathDiagnostic& PD,
           std::string sbuf;
           llvm::raw_string_ostream os(sbuf);
 
-          if (const Stmt* S = Dst->getLabel()) {
+          if (const Stmt *S = Dst->getLabel()) {
             PathDiagnosticLocation End(S, SMgr);
 
             switch (S->getStmtClass()) {
@@ -587,16 +587,16 @@ static void GenerateMinimalPathDiagnostic(PathDiagnostic& PD,
 
               case Stmt::CaseStmtClass: {
                 os << "Control jumps to 'case ";
-                const CaseStmt* Case = cast<CaseStmt>(S);
-                const Expr* LHS = Case->getLHS()->IgnoreParenCasts();
+                const CaseStmt *Case = cast<CaseStmt>(S);
+                const Expr *LHS = Case->getLHS()->IgnoreParenCasts();
 
                 // Determine if it is an enum.
                 bool GetRawInt = true;
 
-                if (const DeclRefExpr* DR = dyn_cast<DeclRefExpr>(LHS)) {
+                if (const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(LHS)) {
                   // FIXME: Maybe this should be an assertion.  Are there cases
                   // were it is not an EnumConstantDecl?
-                  const EnumConstantDecl* D =
+                  const EnumConstantDecl *D =
                     dyn_cast<EnumConstantDecl>(DR->getDecl());
 
                   if (D) {
@@ -783,12 +783,12 @@ static void GenerateMinimalPathDiagnostic(PathDiagnostic& PD,
     if (NextNode) {
       for (BugReporterContext::visitor_iterator I = PDB.visitor_begin(),
            E = PDB.visitor_end(); I!=E; ++I) {
-        if (PathDiagnosticPiece* p = (*I)->VisitNode(N, NextNode, PDB))
+        if (PathDiagnosticPiece *p = (*I)->VisitNode(N, NextNode, PDB))
           PD.push_front(p);
       }
     }
 
-    if (const PostStmt* PS = dyn_cast<PostStmt>(&P)) {
+    if (const PostStmt *PS = dyn_cast<PostStmt>(&P)) {
       // Scan the region bindings, and see if a "notable" symbol has a new
       // lval binding.
       ScanNotableSymbols SNS(N, PS->getStmt(), PDB.getBugReporter(), PD);
@@ -1125,7 +1125,7 @@ static void GenerateExtensivePathDiagnostic(PathDiagnostic& PD,
                                             const ExplodedNode *N) {
   EdgeBuilder EB(PD, PDB);
 
-  const ExplodedNode* NextNode = N->pred_empty() ? NULL : *(N->pred_begin());
+  const ExplodedNode *NextNode = N->pred_empty() ? NULL : *(N->pred_begin());
   while (NextNode) {
     N = NextNode;
     NextNode = GetPredecessorNode(N);
@@ -1190,7 +1190,7 @@ static void GenerateExtensivePathDiagnostic(PathDiagnostic& PD,
 
     for (BugReporterContext::visitor_iterator I = PDB.visitor_begin(),
          E = PDB.visitor_end(); I!=E; ++I) {
-      if (PathDiagnosticPiece* p = (*I)->VisitNode(N, NextNode, PDB)) {
+      if (PathDiagnosticPiece *p = (*I)->VisitNode(N, NextNode, PDB)) {
         const PathDiagnosticLocation &Loc = p->getLocation();
         EB.addEdge(Loc, true);
         PD.push_front(p);
@@ -1214,11 +1214,11 @@ void BugType::FlushReports(BugReporter &BR) {}
 BugReport::~BugReport() {}
 RangedBugReport::~RangedBugReport() {}
 
-const Stmt* BugReport::getStmt() const {
+const Stmt *BugReport::getStmt() const {
   ProgramPoint ProgP = ErrorNode->getLocation();
   const Stmt *S = NULL;
 
-  if (BlockEntrance* BE = dyn_cast<BlockEntrance>(&ProgP)) {
+  if (BlockEntrance *BE = dyn_cast<BlockEntrance>(&ProgP)) {
     CFGBlock &Exit = ProgP.getLocationContext()->getCFG()->getExit();
     if (BE->getBlock() == &Exit)
       S = GetPreviousStmt(ErrorNode);
@@ -1230,8 +1230,8 @@ const Stmt* BugReport::getStmt() const {
 }
 
 PathDiagnosticPiece*
-BugReport::getEndPath(BugReporterContext& BRC,
-                      const ExplodedNode* EndPathNode) {
+BugReport::getEndPath(BugReporterContext &BRC,
+                      const ExplodedNode *EndPathNode) {
 
   const ProgramPoint &PP = EndPathNode->getLocation();
   PathDiagnosticLocation L;
@@ -1246,7 +1246,7 @@ BugReport::getEndPath(BugReporterContext& BRC,
   }
 
   if (!L.isValid()) {
-    const Stmt* S = getStmt();
+    const Stmt *S = getStmt();
 
     if (!S)
       return NULL;
@@ -1259,7 +1259,7 @@ BugReport::getEndPath(BugReporterContext& BRC,
 
   // Only add the statement itself as a range if we didn't specify any
   // special ranges for this report.
-  PathDiagnosticPiece* P = new PathDiagnosticEventPiece(L, getDescription(),
+  PathDiagnosticPiece *P = new PathDiagnosticEventPiece(L, getDescription(),
                                                         Beg == End);
 
   for (; Beg != End; ++Beg)
@@ -1270,7 +1270,7 @@ BugReport::getEndPath(BugReporterContext& BRC,
 
 std::pair<BugReport::ranges_iterator, BugReport::ranges_iterator>
 BugReport::getRanges() const {
-  if (const Expr* E = dyn_cast_or_null<Expr>(getStmt())) {
+  if (const Expr *E = dyn_cast_or_null<Expr>(getStmt())) {
     R = E->getSourceRange();
     assert(R.isValid());
     return std::make_pair(&R, &R+1);
@@ -1281,7 +1281,7 @@ BugReport::getRanges() const {
 
 SourceLocation BugReport::getLocation() const {
   if (ErrorNode)
-    if (const Stmt* S = GetCurrentOrPreviousStmt(ErrorNode)) {
+    if (const Stmt *S = GetCurrentOrPreviousStmt(ErrorNode)) {
       // For member expressions, return the location of the '.' or '->'.
       if (const MemberExpr *ME = dyn_cast<MemberExpr>(S))
         return ME->getMemberLoc();
@@ -1295,8 +1295,8 @@ SourceLocation BugReport::getLocation() const {
   return FullSourceLoc();
 }
 
-PathDiagnosticPiece* BugReport::VisitNode(const ExplodedNode* N,
-                                          const ExplodedNode* PrevN,
+PathDiagnosticPiece *BugReport::VisitNode(const ExplodedNode *N,
+                                          const ExplodedNode *PrevN,
                                           BugReporterContext &BRC) {
   return NULL;
 }
@@ -1405,10 +1405,10 @@ MakeReportGraph(const ExplodedGraph* G,
   llvm::DenseMap<const void*,unsigned> Visited;
 
   unsigned cnt = 0;
-  const ExplodedNode* Root = 0;
+  const ExplodedNode *Root = 0;
 
   while (!WS.empty()) {
-    const ExplodedNode* Node = WS.front();
+    const ExplodedNode *Node = WS.front();
     WS.pop();
 
     if (Visited.find(Node) != Visited.end())
@@ -1441,7 +1441,7 @@ MakeReportGraph(const ExplodedGraph* G,
 
     // Create the equivalent node in the new graph with the same state
     // and location.
-    ExplodedNode* NewN = GNew->getNode(N->getLocation(), N->getState());
+    ExplodedNode *NewN = GNew->getNode(N->getLocation(), N->getState());
 
     // Store the mapping to the original node.
     llvm::DenseMap<const void*, const void*>::iterator IMitr=InverseMap.find(N);
@@ -1611,7 +1611,7 @@ void GRBugReporter::GeneratePathDiagnostic(PathDiagnostic& PD,
   // Start building the path diagnostic...
   PathDiagnosticBuilder PDB(*this, R, BackMap.get(), getPathDiagnosticClient());
 
-  if (PathDiagnosticPiece* Piece = R->getEndPath(PDB, N))
+  if (PathDiagnosticPiece *Piece = R->getEndPath(PDB, N))
     PD.push_back(Piece);
   else
     return;
@@ -1683,7 +1683,7 @@ FindReportInEquivalenceClass(BugReportEquivClass& EQ,
   // to 'Nodes'.  Any of the reports will serve as a "representative" report.
   if (!BT.isSuppressOnSink()) {
     for (BugReportEquivClass::iterator I=EQ.begin(), E=EQ.end(); I!=E; ++I) {
-      const ExplodedNode* N = I->getErrorNode();
+      const ExplodedNode *N = I->getErrorNode();
       if (N) {
         R = *I;
         bugReports.push_back(R);
@@ -1878,7 +1878,7 @@ void BugReporter::FlushReport(BugReportEquivClass& EQ) {
     return;
 
   if (D->empty()) {
-    PathDiagnosticPiece* piece =
+    PathDiagnosticPiece *piece =
       new PathDiagnosticEventPiece(L, exampleReport->getDescription());
 
     for ( ; Beg != End; ++Beg) piece->addRange(*Beg);
diff --git a/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp b/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp
index de4780e54d..e8500e3ba8 100644
--- a/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp
+++ b/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp
@@ -88,9 +88,9 @@ public:
     ID.Add(V);
   }
 
-  PathDiagnosticPiece* VisitNode(const ExplodedNode *N,
+  PathDiagnosticPiece *VisitNode(const ExplodedNode *N,
                                  const ExplodedNode *PrevN,
-                                 BugReporterContext& BRC) {
+                                 BugReporterContext &BRC) {
 
     if (satisfied)
       return NULL;
@@ -220,7 +220,7 @@ public:
 };
 
 
-static void registerFindLastStore(BugReporterContext& BRC, const MemRegion *R,
+static void registerFindLastStore(BugReporterContext &BRC, const MemRegion *R,
                                   SVal V) {
   BRC.addVisitor(new FindLastStoreBRVisitor(V, R));
 }
@@ -240,9 +240,9 @@ public:
     ID.Add(Constraint);
   }
 
-  PathDiagnosticPiece* VisitNode(const ExplodedNode *N,
+  PathDiagnosticPiece *VisitNode(const ExplodedNode *N,
                                  const ExplodedNode *PrevN,
-                                 BugReporterContext& BRC) {
+                                 BugReporterContext &BRC) {
     if (isSatisfied)
       return NULL;
 
@@ -296,15 +296,15 @@ public:
 };
 } // end anonymous namespace
 
-static void registerTrackConstraint(BugReporterContext& BRC,
+static void registerTrackConstraint(BugReporterContext &BRC,
                                     DefinedSVal Constraint,
                                     bool Assumption) {
   BRC.addVisitor(new TrackConstraintBRVisitor(Constraint, Assumption));
 }
 
-void bugreporter::registerTrackNullOrUndefValue(BugReporterContext& BRC,
+void bugreporter::registerTrackNullOrUndefValue(BugReporterContext &BRC,
                                                 const void *data,
-                                                const ExplodedNode* N) {
+                                                const ExplodedNode *N) {
 
   const Stmt *S = static_cast<const Stmt*>(data);
 
@@ -365,9 +365,9 @@ void bugreporter::registerTrackNullOrUndefValue(BugReporterContext& BRC,
   }
 }
 
-void bugreporter::registerFindLastStore(BugReporterContext& BRC,
+void bugreporter::registerFindLastStore(BugReporterContext &BRC,
                                         const void *data,
-                                        const ExplodedNode* N) {
+                                        const ExplodedNode *N) {
 
   const MemRegion *R = static_cast<const MemRegion*>(data);
 
@@ -394,9 +394,9 @@ public:
     ID.AddPointer(&x);
   }
 
-  PathDiagnosticPiece* VisitNode(const ExplodedNode *N,
+  PathDiagnosticPiece *VisitNode(const ExplodedNode *N,
                                  const ExplodedNode *PrevN,
-                                 BugReporterContext& BRC) {
+                                 BugReporterContext &BRC) {
 
     const PostStmt *P = N->getLocationAs<PostStmt>();
     if (!P)
diff --git a/lib/StaticAnalyzer/Core/CFRefCount.cpp b/lib/StaticAnalyzer/Core/CFRefCount.cpp
index 46aacd473f..3b08fb7fdc 100644
--- a/lib/StaticAnalyzer/Core/CFRefCount.cpp
+++ b/lib/StaticAnalyzer/Core/CFRefCount.cpp
@@ -304,10 +304,10 @@ public:
     ID.Add(T);
   }
 
-  void print(raw_ostream& Out) const;
+  void print(raw_ostream &Out) const;
 };
 
-void RefVal::print(raw_ostream& Out) const {
+void RefVal::print(raw_ostream &Out) const {
   if (!T.isNull())
     Out << "Tracked Type:" << T.getAsString() << '\n';
 
@@ -398,7 +398,7 @@ namespace clang {
 namespace ento {
   template<>
   struct GRStateTrait<RefBindings> : public GRStatePartialTrait<RefBindings> {
-    static void* GDMIndex() {
+    static void *GDMIndex() {
       static int RefBIndex = 0;
       return &RefBIndex;
     }
@@ -490,10 +490,10