1 files changed, 30 insertions, 30 deletions

diff --git a/lib/Analysis/SVals.cpp b/lib/Analysis/SVals.cpp
index 91674b82ed..688b7ff6e1 100644
--- a/lib/Analysis/SVals.cpp
+++ b/lib/Analysis/SVals.cpp
@@ -58,7 +58,7 @@ const FunctionDecl *SVal::getAsFunctionDecl() const {
   return NULL;
 }
 
-/// getAsLocSymbol - If this SVal is a location (subclasses Loc) and 
+/// getAsLocSymbol - If this SVal is a location (subclasses Loc) and
 ///  wraps a symbol, return that SymbolRef.  Otherwise return 0.
 // FIXME: should we consider SymbolRef wrapped in CodeTextRegion?
 SymbolRef SVal::getAsLocSymbol() const {
@@ -76,11 +76,11 @@ SymbolRef SVal::getAsLocSymbol() const {
 SymbolRef SVal::getAsSymbol() const {
   if (const nonloc::SymbolVal *X = dyn_cast<nonloc::SymbolVal>(this))
     return X->getSymbol();
-  
+
   if (const nonloc::SymExprVal *X = dyn_cast<nonloc::SymExprVal>(this))
     if (SymbolRef Y = dyn_cast<SymbolData>(X->getSymbolicExpression()))
       return Y;
-  
+
   return getAsLocSymbol();
 }
 
@@ -89,7 +89,7 @@ SymbolRef SVal::getAsSymbol() const {
 const SymExpr *SVal::getAsSymbolicExpression() const {
   if (const nonloc::SymExprVal *X = dyn_cast<nonloc::SymExprVal>(this))
     return X->getSymbolicExpression();
-  
+
   return getAsSymbol();
 }
 
@@ -115,13 +115,13 @@ bool SVal::symbol_iterator::operator!=(const symbol_iterator &X) const {
 
 SVal::symbol_iterator::symbol_iterator(const SymExpr *SE) {
   itr.push_back(SE);
-  while (!isa<SymbolData>(itr.back())) expand();  
+  while (!isa<SymbolData>(itr.back())) expand();
 }
 
 SVal::symbol_iterator& SVal::symbol_iterator::operator++() {
   assert(!itr.empty() && "attempting to iterate on an 'end' iterator");
   assert(isa<SymbolData>(itr.back()));
-  itr.pop_back();         
+  itr.pop_back();
   if (!itr.empty())
     while (!isa<SymbolData>(itr.back())) expand();
   return *this;
@@ -135,17 +135,17 @@ SymbolRef SVal::symbol_iterator::operator*() {
 void SVal::symbol_iterator::expand() {
   const SymExpr *SE = itr.back();
   itr.pop_back();
-    
+
   if (const SymIntExpr *SIE = dyn_cast<SymIntExpr>(SE)) {
     itr.push_back(SIE->getLHS());
     return;
-  }  
+  }
   else if (const SymSymExpr *SSE = dyn_cast<SymSymExpr>(SE)) {
     itr.push_back(SSE->getLHS());
     itr.push_back(SSE->getRHS());
     return;
   }
-  
+
   assert(false && "unhandled expansion case");
 }
 
@@ -189,10 +189,10 @@ bool SVal::isZeroConstant() const {
 
 SVal nonloc::ConcreteInt::evalBinOp(ValueManager &ValMgr,
                                     BinaryOperator::Opcode Op,
-                                    const nonloc::ConcreteInt& R) const {  
+                                    const nonloc::ConcreteInt& R) const {
   const llvm::APSInt* X =
     ValMgr.getBasicValueFactory().EvaluateAPSInt(Op, getValue(), R.getValue());
-  
+
   if (X)
     return nonloc::ConcreteInt(*X);
   else
@@ -215,12 +215,12 @@ nonloc::ConcreteInt nonloc::ConcreteInt::evalMinus(ValueManager &ValMgr) const {
 SVal loc::ConcreteInt::EvalBinOp(BasicValueFactory& BasicVals,
                                  BinaryOperator::Opcode Op,
                                  const loc::ConcreteInt& R) const {
-  
+
   assert (Op == BinaryOperator::Add || Op == BinaryOperator::Sub ||
           (Op >= BinaryOperator::LT && Op <= BinaryOperator::NE));
-  
+
   const llvm::APSInt* X = BasicVals.EvaluateAPSInt(Op, getValue(), R.getValue());
-  
+
   if (X)
     return loc::ConcreteInt(*X);
   else
@@ -234,40 +234,40 @@ SVal loc::ConcreteInt::EvalBinOp(BasicValueFactory& BasicVals,
 void SVal::dump() const { dumpToStream(llvm::errs()); }
 
 void SVal::dumpToStream(llvm::raw_ostream& os) const {
-  switch (getBaseKind()) {      
+  switch (getBaseKind()) {
     case UnknownKind:
       os << "Invalid";
-      break;      
+      break;
     case NonLocKind:
       cast<NonLoc>(this)->dumpToStream(os);
-      break;      
+      break;
     case LocKind:
       cast<Loc>(this)->dumpToStream(os);
-      break;      
+      break;
     case UndefinedKind:
       os << "Undefined";
-      break;      
+      break;
     default:
       assert (false && "Invalid SVal.");
   }
 }
 
 void NonLoc::dumpToStream(llvm::raw_ostream& os) const {
-  switch (getSubKind()) {  
+  switch (getSubKind()) {
     case nonloc::ConcreteIntKind:
       os << cast<nonloc::ConcreteInt>(this)->getValue().getZExtValue();
       if (cast<nonloc::ConcreteInt>(this)->getValue().isUnsigned())
-        os << 'U';      
-      break;      
+        os << 'U';
+      break;
     case nonloc::SymbolValKind:
       os << '$' << cast<nonloc::SymbolVal>(this)->getSymbol();
-      break;     
+      break;
     case nonloc::SymExprValKind: {
       const nonloc::SymExprVal& C = *cast<nonloc::SymExprVal>(this);
       const SymExpr *SE = C.getSymbolicExpression();
       os << SE;
       break;
-    }    
+    }
     case nonloc::LocAsIntegerKind: {
       const nonloc::LocAsInteger& C = *cast<nonloc::LocAsInteger>(this);
       os << C.getLoc() << " [as " << C.getNumBits() << " bit integer]";
@@ -278,7 +278,7 @@ void NonLoc::dumpToStream(llvm::raw_ostream& os) const {
       os << "compoundVal{";
       bool first = true;
       for (nonloc::CompoundVal::iterator I=C.begin(), E=C.end(); I!=E; ++I) {
-        if (first) { 
+        if (first) {
           os << ' '; first = false;
         }
         else
@@ -294,24 +294,24 @@ void NonLoc::dumpToStream(llvm::raw_ostream& os) const {
       os << "lazyCompoundVal{" << (void*) C.getState() << ',' << C.getRegion()
          << '}';
       break;
-    }            
+    }
     default:
       assert (false && "Pretty-printed not implemented for this NonLoc.");
       break;
   }
 }
 
-void Loc::dumpToStream(llvm::raw_ostream& os) const {  
-  switch (getSubKind()) {        
+void Loc::dumpToStream(llvm::raw_ostream& os) const {
+  switch (getSubKind()) {
     case loc::ConcreteIntKind:
       os << cast<loc::ConcreteInt>(this)->getValue().getZExtValue() << " (Loc)";
-      break;      
+      break;
     case loc::GotoLabelKind:
       os << "&&" << cast<loc::GotoLabel>(this)->getLabel()->getID()->getName();
       break;
     case loc::MemRegionKind:
       os << '&' << cast<loc::MemRegionVal>(this)->getRegion()->getString();
-      break;      
+      break;
     default:
       assert(false && "Pretty-printing not implemented for this Loc.");
       break;