Remove tabs, and whitespace cleanups.

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

1 files changed, 103 insertions, 103 deletions

diff --git a/lib/Analysis/GRExprEngineInternalChecks.cpp b/lib/Analysis/GRExprEngineInternalChecks.cpp
index ab19a6a94a..ab6874ad60 100644
--- a/lib/Analysis/GRExprEngineInternalChecks.cpp
+++ b/lib/Analysis/GRExprEngineInternalChecks.cpp
@@ -48,15 +48,15 @@ public:
   BuiltinBugReport(BugType& bt, const char* desc,
                    ExplodedNode *n)
   : RangedBugReport(bt, desc, n) {}
-  
+
   BuiltinBugReport(BugType& bt, const char *shortDesc, const char *desc,
                    ExplodedNode *n)
-  : RangedBugReport(bt, shortDesc, desc, n) {}  
-  
+  : RangedBugReport(bt, shortDesc, desc, n) {}
+
   void registerInitialVisitors(BugReporterContext& BRC,
                                const ExplodedNode* N);
-};  
-  
+};
+
 class VISIBILITY_HIDDEN BuiltinBug : public BugType {
   GRExprEngine &Eng;
 protected:
@@ -69,30 +69,30 @@ public:
     : BugType(n, "Logic errors"), Eng(*eng), desc(n) {}
 
   const std::string &getDescription() const { return desc; }
-  
+
   virtual void FlushReportsImpl(BugReporter& BR, GRExprEngine& Eng) {}
 
   void FlushReports(BugReporter& BR) { FlushReportsImpl(BR, Eng); }
-  
+
   virtual void registerInitialVisitors(BugReporterContext& BRC,
                                        const ExplodedNode* N,
                                        BuiltinBugReport *R) {}
-  
+
   template <typename ITER> void Emit(BugReporter& BR, ITER I, ITER E);
 };
-  
-  
+
+
 template <typename ITER>
 void BuiltinBug::Emit(BugReporter& BR, ITER I, ITER E) {
   for (; I != E; ++I) BR.EmitReport(new BuiltinBugReport(*this, desc.c_str(),
                                                          GetNode(I)));
-}  
+}
 
 void BuiltinBugReport::registerInitialVisitors(BugReporterContext& BRC,
                                                const ExplodedNode* N) {
   static_cast<BuiltinBug&>(getBugType()).registerInitialVisitors(BRC, N, this);
-}  
-  
+}
+
 class VISIBILITY_HIDDEN NullDeref : public BuiltinBug {
 public:
   NullDeref(GRExprEngine* eng)
@@ -101,14 +101,14 @@ public:
   void FlushReportsImpl(BugReporter& BR, GRExprEngine& Eng) {
     Emit(BR, Eng.null_derefs_begin(), Eng.null_derefs_end());
   }
-  
+
   void registerInitialVisitors(BugReporterContext& BRC,
                                const ExplodedNode* N,
                                BuiltinBugReport *R) {
     registerTrackNullOrUndefValue(BRC, GetDerefExpr(N), N);
   }
 };
-  
+
 class VISIBILITY_HIDDEN NilReceiverStructRet : public BuiltinBug {
 public:
   NilReceiverStructRet(GRExprEngine* eng) :
@@ -133,7 +133,7 @@ public:
       BR.EmitReport(R);
     }
   }
-  
+
   void registerInitialVisitors(BugReporterContext& BRC,
                                const ExplodedNode* N,
                                BuiltinBugReport *R) {
@@ -146,12 +146,12 @@ public:
   NilReceiverLargerThanVoidPtrRet(GRExprEngine* eng) :
     BuiltinBug(eng,
                "'nil' receiver with return type larger than sizeof(void *)") {}
-  
+
   void FlushReportsImpl(BugReporter& BR, GRExprEngine& Eng) {
     for (GRExprEngine::nil_receiver_larger_than_voidptr_ret_iterator
          I=Eng.nil_receiver_larger_than_voidptr_ret_begin(),
          E=Eng.nil_receiver_larger_than_voidptr_ret_end(); I!=E; ++I) {
-      
+
       std::string sbuf;
       llvm::raw_string_ostream os(sbuf);
       PostStmt P = cast<PostStmt>((*I)->getLocation());
@@ -162,28 +162,28 @@ public:
       << "' and of size "
       << Eng.getContext().getTypeSize(ME->getType()) / 8
       << " bytes) to be garbage or otherwise undefined.";
-      
+
       BuiltinBugReport *R = new BuiltinBugReport(*this, os.str().c_str(), *I);
       R->addRange(ME->getReceiver()->getSourceRange());
       BR.EmitReport(R);
     }
-  }    
+  }
   void registerInitialVisitors(BugReporterContext& BRC,
                                const ExplodedNode* N,
                                BuiltinBugReport *R) {
     registerTrackNullOrUndefValue(BRC, GetReceiverExpr(N), N);
   }
 };
-  
+
 class VISIBILITY_HIDDEN UndefinedDeref : public BuiltinBug {
 public:
   UndefinedDeref(GRExprEngine* eng)
     : BuiltinBug(eng,"Dereference of undefined pointer value") {}
-  
+
   void FlushReportsImpl(BugReporter& BR, GRExprEngine& Eng) {
     Emit(BR, Eng.undef_derefs_begin(), Eng.undef_derefs_end());
   }
-  
+
   void registerInitialVisitors(BugReporterContext& BRC,
                                const ExplodedNode* N,
                                BuiltinBugReport *R) {
@@ -196,30 +196,30 @@ public:
   DivZero(GRExprEngine* eng = 0)
     : BuiltinBug(eng,"Division-by-zero",
                  "Division by zero or undefined value.") {}
-  
+
   void registerInitialVisitors(BugReporterContext& BRC,
                                const ExplodedNode* N,
                                BuiltinBugReport *R) {
     registerTrackNullOrUndefValue(BRC, GetDenomExpr(N), N);
   }
 };
-  
+
 class VISIBILITY_HIDDEN UndefResult : public BuiltinBug {
 public:
   UndefResult(GRExprEngine* eng) : BuiltinBug(eng,"Undefined result",
                              "Result of operation is undefined.") {}
-  
+
   void FlushReportsImpl(BugReporter& BR, GRExprEngine& Eng) {
     Emit(BR, Eng.undef_results_begin(), Eng.undef_results_end());
   }
 };
-  
+
 class VISIBILITY_HIDDEN BadCall : public BuiltinBug {
 public:
   BadCall(GRExprEngine *eng = 0)
   : BuiltinBug(eng, "Invalid function call",
         "Called function pointer is a null or undefined pointer value") {}
-  
+
   void registerInitialVisitors(BugReporterContext& BRC,
                                const ExplodedNode* N,
                                BuiltinBugReport *R) {
@@ -234,57 +234,57 @@ public:
   ArgReport(BugType& bt, const char* desc, ExplodedNode *n,
          const Stmt *arg)
   : BuiltinBugReport(bt, desc, n), Arg(arg) {}
-  
+
   ArgReport(BugType& bt, const char *shortDesc, const char *desc,
                    ExplodedNode *n, const Stmt *arg)
-  : BuiltinBugReport(bt, shortDesc, desc, n), Arg(arg) {}  
-  
-  const Stmt *getArg() const { return Arg; }  
+  : BuiltinBugReport(bt, shortDesc, desc, n), Arg(arg) {}
+
+  const Stmt *getArg() const { return Arg; }
 };
 
 class VISIBILITY_HIDDEN BadArg : public BuiltinBug {
-public:  
-  BadArg(GRExprEngine* eng=0) : BuiltinBug(eng,"Uninitialized argument",  
+public:
+  BadArg(GRExprEngine* eng=0) : BuiltinBug(eng,"Uninitialized argument",
     "Pass-by-value argument in function call is undefined.") {}
 
   BadArg(GRExprEngine* eng, const char* d)
     : BuiltinBug(eng,"Uninitialized argument", d) {}
-  
+
   void registerInitialVisitors(BugReporterContext& BRC,
                                const ExplodedNode* N,
                                BuiltinBugReport *R) {
     registerTrackNullOrUndefValue(BRC, static_cast<ArgReport*>(R)->getArg(),
                                   N);
-  }  
+  }
 };
-  
+
 class VISIBILITY_HIDDEN BadMsgExprArg : public BadArg {
 public:
-  BadMsgExprArg(GRExprEngine* eng) 
+  BadMsgExprArg(GRExprEngine* eng)
     : BadArg(eng,"Pass-by-value argument in message expression is undefined"){}
-  
+
   void FlushReportsImpl(BugReporter& BR, GRExprEngine& Eng) {
     for (GRExprEngine::UndefArgsTy::iterator I=Eng.msg_expr_undef_arg_begin(),
-         E = Eng.msg_expr_undef_arg_end(); I!=E; ++I) {      
+         E = Eng.msg_expr_undef_arg_end(); I!=E; ++I) {
       // Generate a report for this bug.
       ArgReport *report = new ArgReport(*this, desc.c_str(), I->first,
                                         I->second);
       report->addRange(I->second->getSourceRange());
       BR.EmitReport(report);
-    }    
-  } 
+    }
+  }
 };
-  
+
 class VISIBILITY_HIDDEN BadReceiver : public BuiltinBug {
-public:  
+public:
   BadReceiver(GRExprEngine* eng)
   : BuiltinBug(eng,"Uninitialized receiver",
                "Receiver in message expression is an uninitialized value") {}
-  
+
   void FlushReportsImpl(BugReporter& BR, GRExprEngine& Eng) {
     for (GRExprEngine::ErrorNodes::iterator I=Eng.undef_receivers_begin(),
          End = Eng.undef_receivers_end(); I!=End; ++I) {
-      
+
       // Generate a report for this bug.
       BuiltinBugReport *report = new BuiltinBugReport(*this, desc.c_str(), *I);
       ExplodedNode* N = *I;
@@ -300,14 +300,14 @@ public:
                                const ExplodedNode* N,
                                BuiltinBugReport *R) {
     registerTrackNullOrUndefValue(BRC, GetReceiverExpr(N), N);
-  } 
+  }
 };
 
 class VISIBILITY_HIDDEN RetStack : public BuiltinBug {
 public:
   RetStack(GRExprEngine* eng)
     : BuiltinBug(eng, "Return of address to stack-allocated memory") {}
-  
+
   void FlushReportsImpl(BugReporter& BR, GRExprEngine& Eng) {
     for (GRExprEngine::ret_stackaddr_iterator I=Eng.ret_stackaddr_begin(),
          End = Eng.ret_stackaddr_end(); I!=End; ++I) {
@@ -316,42 +316,42 @@ public:
       const Stmt *S = cast<PostStmt>(N->getLocation()).getStmt();
       const Expr* E = cast<ReturnStmt>(S)->getRetValue();
       assert(E && "Return expression cannot be NULL");
-      
+
       // Get the value associated with E.
       loc::MemRegionVal V = cast<loc::MemRegionVal>(N->getState()->getSVal(E));
-      
+
       // Generate a report for this bug.
       std::string buf;
       llvm::raw_string_ostream os(buf);
       SourceRange R;
-      
+
       // Check if the region is a compound literal.
-      if (const CompoundLiteralRegion* CR = 
+      if (const CompoundLiteralRegion* CR =
             dyn_cast<CompoundLiteralRegion>(V.getRegion())) {
-        
+
         const CompoundLiteralExpr* CL = CR->getLiteralExpr();
         os << "Address of stack memory associated with a compound literal "
               "declared on line "
             << BR.getSourceManager()
                     .getInstantiationLineNumber(CL->getLocStart())
             << " returned.";
-        
+
         R = CL->getSourceRange();
       }
       else if (const AllocaRegion* AR = dyn_cast<AllocaRegion>(V.getRegion())) {
         const Expr* ARE = AR->getExpr();
         SourceLocation L = ARE->getLocStart();
         R = ARE->getSourceRange();
-        
+
         os << "Address of stack memory allocated by call to alloca() on line "
            << BR.getSourceManager().getInstantiationLineNumber(L)
            << " returned.";
-      }      
-      else {        
+      }
+      else {
         os << "Address of stack memory associated with local variable '"
            << V.getRegion()->getString() << "' returned.";
       }
-      
+
       RangedBugReport *report = new RangedBugReport(*this, os.str().c_str(), N);
       report->addRange(E->getSourceRange());
       if (R.isValid()) report->addRange(R);
@@ -359,51 +359,51 @@ public:
     }
   }
 };
-  
+
 class VISIBILITY_HIDDEN RetUndef : public BuiltinBug {
 public:
   RetUndef(GRExprEngine* eng) : BuiltinBug(eng, "Uninitialized return value",
               "Uninitialized or undefined value returned to caller.") {}
-  
+
   void FlushReportsImpl(BugReporter& BR, GRExprEngine& Eng) {
     Emit(BR, Eng.ret_undef_begin(), Eng.ret_undef_end());
   }
-  
+
   void registerInitialVisitors(BugReporterContext& BRC,
                                const ExplodedNode* N,
                                BuiltinBugReport *R) {
     registerTrackNullOrUndefValue(BRC, GetRetValExpr(N), N);
-  }    
+  }
 };
 
 class VISIBILITY_HIDDEN UndefBranch : public BuiltinBug {
   struct VISIBILITY_HIDDEN FindUndefExpr {
     GRStateManager& VM;
     const GRState* St;
-    
+
     FindUndefExpr(GRStateManager& V, const GRState* S) : VM(V), St(S) {}
-    
-    Expr* FindExpr(Expr* Ex) {      
+
+    Expr* FindExpr(Expr* Ex) {
       if (!MatchesCriteria(Ex))
         return 0;
-      
+
       for (Stmt::child_iterator I=Ex->child_begin(), E=Ex->child_end();I!=E;++I)
         if (Expr* ExI = dyn_cast_or_null<Expr>(*I)) {
           Expr* E2 = FindExpr(ExI);
           if (E2) return E2;
         }
-      
+
       return Ex;
     }
-    
+
     bool MatchesCriteria(Expr* Ex) { return St->getSVal(Ex).isUndef(); }
   };
-  
+
 public:
   UndefBranch(GRExprEngine *eng)
     : BuiltinBug(eng,"Use of uninitialized value",
                  "Branch condition evaluates to an uninitialized value.") {}
-  
+
   void FlushReportsImpl(BugReporter& BR, GRExprEngine& Eng) {
     for (GRExprEngine::undef_branch_iterator I=Eng.undef_branches_begin(),
          E=Eng.undef_branches_end(); I!=E; ++I) {
@@ -442,7 +442,7 @@ public:
       BR.EmitReport(R);
     }
   }
-  
+
   void registerInitialVisitors(BugReporterContext& BRC,
                                const ExplodedNode* N,
                                BuiltinBugReport *R) {
@@ -461,12 +461,12 @@ public:
     Emit(BR, Eng.explicit_oob_memacc_begin(), Eng.explicit_oob_memacc_end());
   }
 };
-  
+
 class VISIBILITY_HIDDEN BadSizeVLA : public BuiltinBug {
 public:
   BadSizeVLA(GRExprEngine* eng) :
     BuiltinBug(eng, "Bad variable-length array (VLA) size") {}
-  
+
   void FlushReportsImpl(BugReporter& BR, GRExprEngine& Eng) {
     for (GRExprEngine::ErrorNodes::iterator
           I = Eng.ExplicitBadSizedVLA.begin(),
@@ -475,26 +475,26 @@ public:
       // Determine whether this was a 'zero-sized' VLA or a VLA with an
       // undefined size.
       ExplodedNode* N = *I;
-      PostStmt PS = cast<PostStmt>(N->getLocation());      
+      PostStmt PS = cast<PostStmt>(N->getLocation());
       const DeclStmt *DS = cast<DeclStmt>(PS.getStmt());
       VarDecl* VD = cast<VarDecl>(*DS->decl_begin());
       QualType T = Eng.getContext().getCanonicalType(VD->getType());
       VariableArrayType* VT = cast<VariableArrayType>(T);
       Expr* SizeExpr = VT->getSizeExpr();
-      
+
       std::string buf;
       llvm::raw_string_ostream os(buf);
       os << "The expression used to specify the number of elements in the "
             "variable-length array (VLA) '"
          << VD->getNameAsString() << "' evaluates to ";
-      
+
       bool isUndefined = N->getState()->getSVal(SizeExpr).isUndef();
-      
+
       if (isUndefined)
         os << "an undefined or garbage value.";
       else
         os << "0. VLAs with no elements have undefined behavior.";
-      
+
       std::string shortBuf;
       llvm::raw_string_ostream os_short(shortBuf);
       os_short << "Variable-length array '" << VD->getNameAsString() << "' "
@@ -508,7 +508,7 @@ public:
       BR.EmitReport(report);
     }
   }
-  
+
   void registerInitialVisitors(BugReporterContext& BRC,
                                const ExplodedNode* N,
                                BuiltinBugReport *R) {
@@ -524,7 +524,7 @@ class VISIBILITY_HIDDEN CheckAttrNonNull :
     public CheckerVisitor<CheckAttrNonNull> {
 
   BugType *BT;
-  
+
 public:
   CheckAttrNonNull() : BT(0) {}
   ~CheckAttrNonNull() {}
@@ -537,73 +537,73 @@ public:
   void PreVisitCallExpr(CheckerContext &C, const CallExpr *CE) {
     const GRState *state = C.getState();
     const GRState *originalState = state;
-    
+
     // Check if the callee has a 'nonnull' attribute.
     SVal X = state->getSVal(CE->getCallee());
-    
+
     const FunctionDecl* FD = X.getAsFunctionDecl();
     if (!FD)
       return;
 
-    const NonNullAttr* Att = FD->getAttr<NonNullAttr>();    
+    const NonNullAttr* Att = FD->getAttr<NonNullAttr>();
     if (!Att)
       return;
-    
+
     // Iterate through the arguments of CE and check them for null.
     unsigned idx = 0;
-    
+
     for (CallExpr::const_arg_iterator I=CE->arg_begin(), E=CE->arg_end(); I!=E;
          ++I, ++idx) {
-    
+
       if (!Att->isNonNull(idx))
         continue;
-      
+
       const SVal &V = state->getSVal(*I);
       const DefinedSVal *DV = dyn_cast<DefinedSVal>(&V);
-      
+
       if (!DV)
         continue;
-      
+
       ConstraintManager &CM = C.getConstraintManager();
       const GRState *stateNotNull, *stateNull;
       llvm::tie(stateNotNull, stateNull) = CM.AssumeDual(state, *DV);
-      
+
       if (stateNull && !stateNotNull) {
         // Generate an error node.  Check for a null node in case
         // we cache out.
         if (ExplodedNode *errorNode = C.GenerateNode(CE, stateNull, true)) {
-                  
+
           // Lazily allocate the BugType object if it hasn't already been
           // created. Ownership is transferred to the BugReporter object once
           // the BugReport is passed to 'EmitWarning'.
           if (!BT)
             BT = new BugType("Argument with 'nonnull' attribute passed null",
                              "API");
-          
+
           EnhancedBugReport *R =
             new EnhancedBugReport(*BT,
                                   "Null pointer passed as an argument to a "
                                   "'nonnull' parameter", errorNode);
-          
+
           // Highlight the range of the argument that was null.
           const Expr *arg = *I;
           R->addRange(arg->getSourceRange());
           R->addVisitorCreator(registerTrackNullOrUndefValue, arg);
-          
+
           // Emit the bug report.
           C.EmitReport(R);
         }
-        
+
         // Always return.  Either we cached out or we just emitted an error.
         return;
       }
-      
+
       // If a pointer value passed the check we should assume that it is
       // indeed not null from this point forward.
       assert(stateNotNull);
       state = stateNotNull;
     }
-   
+
     // If we reach here all of the arguments passed the nonnull check.
     // If 'state' has been updated generated a new node.
     if (state != originalState)
@@ -614,7 +614,7 @@ public:
 
 // Undefined arguments checking.
 namespace {
-class VISIBILITY_HIDDEN CheckUndefinedArg 
+class VISIBILITY_HIDDEN CheckUndefinedArg
   : public CheckerVisitor<CheckUndefinedArg> {
 
   BadArg *BT;
@@ -690,7 +690,7 @@ public:
   void PreVisitBinaryOperator(CheckerContext &C, const BinaryOperator *B);
 };
 
-void CheckBadDiv::PreVisitBinaryOperator(CheckerContext &C, 
+void CheckBadDiv::PreVisitBinaryOperator(CheckerContext &C,
                                          const BinaryOperator *B) {
   BinaryOperator::Opcode Op = B->getOpcode();
   if (Op != BinaryOperator::Div &&
@@ -719,19 +719,19 @@ void CheckBadDiv::PreVisitBinaryOperator(CheckerContext &C,
   // Handle the case where 'Denom' is UnknownVal.
   const DefinedSVal *DV = dyn_cast<DefinedSVal>(&Denom);
 
-  if (!DV)  
+  if (!DV)
     return;
 
   // Check for divide by zero.
   ConstraintManager &CM = C.getConstraintManager();
   const GRState *stateNotZero, *stateZero;
   llvm::tie(stateNotZero, stateZero) = CM.AssumeDual(C.getState(), *DV);
-  
+
   if (stateZero && !stateNotZero) {
     if (ExplodedNode *N = C.GenerateNode(B, stateZero, true)) {
       if (!BT)
         BT = new DivZero();
-   
+
       C.EmitReport(new BuiltinBugReport(*BT, BT->getDescription().c_str(), N));
     }
     return;
@@ -764,7 +764,7 @@ void GRExprEngine::RegisterInternalChecks() {
   BR.Register(new BadSizeVLA(this));
   BR.Register(new NilReceiverStructRet(this));
   BR.Register(new NilReceiverLargerThanVoidPtrRet(this));
-  
+
   // The following checks do not need to have their associated BugTypes
   // explicitly registered with the BugReporter.  If they issue any BugReports,
   // their associated BugType will get registered with the BugReporter