2 files changed, 33 insertions, 33 deletions

diff --git a/include/clang/Analysis/Analyses/LiveVariables.h b/include/clang/Analysis/Analyses/LiveVariables.h
index b41cd684e951c..17f772da0c6da 100644
--- a/include/clang/Analysis/Analyses/LiveVariables.h
+++ b/include/clang/Analysis/Analyses/LiveVariables.h
@@ -23,7 +23,7 @@ namespace clang {
 class Stmt;
 class DeclRefExpr;
 class SourceManager;
-  
+
 struct LiveVariables_ValueTypes {
 
   struct ObserverTy;
@@ -35,77 +35,77 @@ struct LiveVariables_ValueTypes {
   // (so that we don't explore such expressions twice).  We also want
   // to compute liveness information for block-level expressions, since these
   // act as "temporary" values.
-  
+
   struct AnalysisDataTy : public StmtDeclBitVector_Types::AnalysisDataTy {
     ObserverTy* Observer;
     ValTy AlwaysLive;
-    
+
     AnalysisDataTy() : Observer(NULL) {}
   };
-  
+
   //===-----------------------------------------------------===//
   // ObserverTy - Observer for uninitialized values queries.
   //===-----------------------------------------------------===//
 
   struct ObserverTy {
     virtual ~ObserverTy() {}
-    
+
     /// ObserveStmt - A callback invoked right before invoking the
     ///  liveness transfer function on the given statement.
-    virtual void ObserveStmt(Stmt* S, const AnalysisDataTy& AD, 
+    virtual void ObserveStmt(Stmt* S, const AnalysisDataTy& AD,
                              const ValTy& V) {}
-    
+
     virtual void ObserverKill(DeclRefExpr* DR) {}
   };
 };
 
 class LiveVariables : public DataflowValues<LiveVariables_ValueTypes,
                                             dataflow::backward_analysis_tag> {
-                                              
-                                              
+
+
 public:
   typedef LiveVariables_ValueTypes::ObserverTy ObserverTy;
-    
+
   LiveVariables(ASTContext& Ctx, CFG& cfg);
-  
+
   /// IsLive - Return true if a variable is live at beginning of a
   /// specified block.
   bool isLive(const CFGBlock* B, const VarDecl* D) const;
-                                              
+
   /// IsLive - Returns true if a variable is live at the beginning of the
   ///  the statement.  This query only works if liveness information
   ///  has been recorded at the statement level (see runOnAllBlocks), and
   ///  only returns liveness information for block-level expressions.
   bool isLive(const Stmt* S, const VarDecl* D) const;
-                                              
+
   /// IsLive - Returns true the block-level expression "value" is live
   ///  before the given block-level expression (see runOnAllBlocks).
   bool isLive(const Stmt* Loc, const Stmt* StmtVal) const;
-  
+
   /// IsLive - Return true if a variable is live according to the
   ///  provided livness bitvector.
   bool isLive(const ValTy& V, const VarDecl* D) const;
-  
+
   /// dumpLiveness - Print to stderr the liveness information encoded
   ///  by a specified bitvector.
   void dumpLiveness(const ValTy& V, SourceManager& M) const;
-  
+
   /// dumpBlockLiveness - Print to stderr the liveness information
   ///  associated with each basic block.
   void dumpBlockLiveness(SourceManager& M) const;
-  
+
   /// getNumDecls - Return the number of variables (declarations) that
   ///  whose liveness status is being tracked by the dataflow
   ///  analysis.
   unsigned getNumDecls() const { return getAnalysisData().getNumDecls(); }
-    
+
   /// IntializeValues - This routine can perform extra initialization, but
   ///  for LiveVariables this does nothing since all that logic is in
-  ///  the constructor.                                              
+  ///  the constructor.
   void InitializeValues(const CFG& cfg) {}
-  
+
   void runOnCFG(CFG& cfg);
-                                              
+
   /// runOnAllBlocks - Propagate the dataflow values once for each block,
   ///  starting from the current dataflow values.  'recordStmtValues' indicates
   ///  whether the method should store dataflow values per each individual
diff --git a/include/clang/Analysis/Analyses/UninitializedValues.h b/include/clang/Analysis/Analyses/UninitializedValues.h
index 7a9da03e4bd28..8a967c3f6edce 100644
--- a/include/clang/Analysis/Analyses/UninitializedValues.h
+++ b/include/clang/Analysis/Analyses/UninitializedValues.h
@@ -24,7 +24,7 @@ namespace clang {
   class Expr;
   class DeclRefExpr;
   class VarDecl;
-  
+
 /// UninitializedValues_ValueTypes - Utility class to wrap type declarations
 ///   for dataflow values and dataflow analysis state for the
 ///   Unitialized Values analysis.
@@ -32,39 +32,39 @@ class UninitializedValues_ValueTypes {
 public:
 
   struct ObserverTy;
-  
-  struct AnalysisDataTy : public StmtDeclBitVector_Types::AnalysisDataTy {    
+
+  struct AnalysisDataTy : public StmtDeclBitVector_Types::AnalysisDataTy {
     AnalysisDataTy() : Observer(NULL), FullUninitTaint(true) {}
     virtual ~AnalysisDataTy() {};
-    
+
     ObserverTy* Observer;
     bool FullUninitTaint;
   };
-  
+
   typedef StmtDeclBitVector_Types::ValTy ValTy;
-  
+
   //===--------------------------------------------------------------------===//
   // ObserverTy - Observer for querying DeclRefExprs that use an uninitalized
   //   value.
   //===--------------------------------------------------------------------===//
-  
+
   struct ObserverTy {
     virtual ~ObserverTy();
-    virtual void ObserveDeclRefExpr(ValTy& Val, AnalysisDataTy& AD, 
+    virtual void ObserveDeclRefExpr(ValTy& Val, AnalysisDataTy& AD,
                                     DeclRefExpr* DR, VarDecl* VD) = 0;
-  };  
+  };
 };
 
 /// UninitializedValues - Objects of this class encapsulate dataflow analysis
 ///  information regarding what variable declarations in a function are
 ///  potentially unintialized.
-class UninitializedValues : 
-  public DataflowValues<UninitializedValues_ValueTypes> {  
+class UninitializedValues :
+  public DataflowValues<UninitializedValues_ValueTypes> {
 public:
   typedef UninitializedValues_ValueTypes::ObserverTy ObserverTy;
 
   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.
   void InitializeValues(const CFG& cfg);