Convert tabs to spaces

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

7 files changed, 28 insertions, 28 deletions

diff --git a/lib/Analysis/DataStructure/EquivClassGraphs.cpp b/lib/Analysis/DataStructure/EquivClassGraphs.cpp
index e9b324aed6..26544cebed 100644
--- a/lib/Analysis/DataStructure/EquivClassGraphs.cpp
+++ b/lib/Analysis/DataStructure/EquivClassGraphs.cpp
@@ -180,11 +180,11 @@ void EquivClassGraphs::buildIndirectFunctionSets(Module &M) {
         // This is the first callee from this call site.
         LastInst = I->first;
         FirstFunc = I->second;
-	// Instead of storing the lastInst For Indirection call Sites we store
-	// the DSNode for the function ptr arguemnt
-	Function *thisFunc = LastInst->getParent()->getParent();
+        // Instead of storing the lastInst For Indirection call Sites we store
+        // the DSNode for the function ptr arguemnt
+        Function *thisFunc = LastInst->getParent()->getParent();
         DSGraph &TFG = CBU->getDSGraph(*thisFunc);
-	DSNode *calleeNode = TFG.getNodeForValue(CS.getCalledValue()).getNode();
+        DSNode *calleeNode = TFG.getNodeForValue(CS.getCalledValue()).getNode();
         OneCalledFunction[calleeNode] = FirstFunc;
         FuncECs.insert(I->second);
       } else {
@@ -192,9 +192,9 @@ void EquivClassGraphs::buildIndirectFunctionSets(Module &M) {
         // Union the callee in with the other functions.
         FuncECs.unionSets(FirstFunc, I->second);
 #ifndef NDEBUG
-	Function *thisFunc = LastInst->getParent()->getParent();
+        Function *thisFunc = LastInst->getParent()->getParent();
         DSGraph &TFG = CBU->getDSGraph(*thisFunc);
-	DSNode *calleeNode = TFG.getNodeForValue(CS.getCalledValue()).getNode();
+        DSNode *calleeNode = TFG.getNodeForValue(CS.getCalledValue()).getNode();
         assert(OneCalledFunction.count(calleeNode) > 0 && "Missed a call?");
 #endif
       }
diff --git a/lib/Analysis/Expressions.cpp b/lib/Analysis/Expressions.cpp
index 9ec78a9750..f625b2e671 100644
--- a/lib/Analysis/Expressions.cpp
+++ b/lib/Analysis/Expressions.cpp
@@ -38,7 +38,7 @@ ExprType::ExprType(Value *Val) {
 }
 
 ExprType::ExprType(const ConstantInt *scale, Value *var,
-		   const ConstantInt *offset) {
+                   const ConstantInt *offset) {
   Scale = var ? scale : 0; Var = var; Offset = offset;
   ExprTy = Scale ? ScaledLinear : (Var ? Linear : Constant);
   if (Scale && Scale->isNullValue()) {  // Simplify 0*Var + const
@@ -169,7 +169,7 @@ static inline const ConstantInt *Mul(const ConstantInt *Arg1,
   Constant *Result = ConstantExpr::get(Instruction::Mul, (Constant*)Arg1,
                                        (Constant*)Arg2);
   assert(Result && Result->getType() == Arg1->getType() &&
-	 "Couldn't perform multiplication!");
+         "Couldn't perform multiplication!");
   ConstantInt *ResultI = cast<ConstantInt>(Result);
 
   // Check to see if the result is one of the special cases that we want to
@@ -207,15 +207,15 @@ static ExprType handleAddition(ExprType Left, ExprType Right, Value *V) {
   switch (Left.ExprTy) {
   case ExprType::Constant:
         return ExprType(Right.Scale, Right.Var,
-			DefZero(Right.Offset, Ty) + DefZero(Left.Offset, Ty));
+                        DefZero(Right.Offset, Ty) + DefZero(Left.Offset, Ty));
   case ExprType::Linear:              // RHS side must be linear or scaled
   case ExprType::ScaledLinear:        // RHS must be scaled
     if (Left.Var != Right.Var)        // Are they the same variables?
       return V;                       //   if not, we don't know anything!
 
     return ExprType(DefOne(Left.Scale  , Ty) + DefOne(Right.Scale , Ty),
-		    Right.Var,
-		    DefZero(Left.Offset, Ty) + DefZero(Right.Offset, Ty));
+                    Right.Var,
+                    DefZero(Left.Offset, Ty) + DefZero(Right.Offset, Ty));
   default:
     assert(0 && "Dont' know how to handle this case!");
     return ExprType();
@@ -233,7 +233,7 @@ static inline ExprType negate(const ExprType &E, Value *V) {
   if (NegOne == 0) return V;  // Couldn't subtract values...
 
   return ExprType(DefOne (E.Scale , Ty) * NegOne, E.Var,
-		  DefZero(E.Offset, Ty) * NegOne);
+                  DefZero(E.Offset, Ty) * NegOne);
 }
 
 
@@ -283,7 +283,7 @@ ExprType llvm::ClassifyExpr(Value *Expr) {
     ExprType Left(ClassifyExpr(I->getOperand(0)));
     if (Right.Offset == 0) return Left;   // shl x, 0 = x
     assert(Right.Offset->getType() == Type::UByteTy &&
-	   "Shift amount must always be a unsigned byte!");
+           "Shift amount must always be a unsigned byte!");
     uint64_t ShiftAmount = cast<ConstantUInt>(Right.Offset)->getValue();
     ConstantInt *Multiplier = getUnsignedConstant(1ULL << ShiftAmount, Ty);
 
@@ -301,7 +301,7 @@ ExprType llvm::ClassifyExpr(Value *Expr) {
       return Expr;
 
     return ExprType(DefOne(Left.Scale, Ty) * Multiplier, Left.Var,
-		    DefZero(Left.Offset, Ty) * Multiplier);
+                    DefZero(Left.Offset, Ty) * Multiplier);
   }  // end case Instruction::Shl
 
   case Instruction::Mul: {
@@ -316,7 +316,7 @@ ExprType llvm::ClassifyExpr(Value *Expr) {
     const ConstantInt *Offs = Left.Offset;
     if (Offs == 0) return ExprType();
     return ExprType( DefOne(Right.Scale , Ty) * Offs, Right.Var,
-		    DefZero(Right.Offset, Ty) * Offs);
+                    DefZero(Right.Offset, Ty) * Offs);
   } // end case Instruction::Mul
 
   case Instruction::Cast: {
diff --git a/lib/Analysis/IPA/FindUsedTypes.cpp b/lib/Analysis/IPA/FindUsedTypes.cpp
index 83b994b53e..a71efb09a4 100644
--- a/lib/Analysis/IPA/FindUsedTypes.cpp
+++ b/lib/Analysis/IPA/FindUsedTypes.cpp
@@ -50,8 +50,8 @@ void FindUsedTypes::IncorporateValue(const Value *V) {
   if (const Constant *C = dyn_cast<Constant>(V)) {
     if (!isa<GlobalValue>(C))
       for (User::const_op_iterator OI = C->op_begin(), OE = C->op_end();
-	   OI != OE; ++OI)
-	IncorporateValue(*OI);
+           OI != OE; ++OI)
+        IncorporateValue(*OI);
   }
 }
 
diff --git a/lib/Analysis/IPA/GlobalsModRef.cpp b/lib/Analysis/IPA/GlobalsModRef.cpp
index 4ffd91ad2b..20422bf318 100644
--- a/lib/Analysis/IPA/GlobalsModRef.cpp
+++ b/lib/Analysis/IPA/GlobalsModRef.cpp
@@ -109,8 +109,8 @@ namespace {
       if (FunctionRecord *FR = getFunctionInfo(F))
         if (FR->FunctionEffect == 0)
           return DoesNotAccessMemory;
-	else if ((FR->FunctionEffect & Mod) == 0)
-	  return OnlyReadsMemory;
+        else if ((FR->FunctionEffect & Mod) == 0)
+          return OnlyReadsMemory;
       return AliasAnalysis::getModRefBehavior(F, CS, Info);
     }
 
diff --git a/lib/Analysis/IntervalPartition.cpp b/lib/Analysis/IntervalPartition.cpp
index e71f400f4a..d12c0fdbc7 100644
--- a/lib/Analysis/IntervalPartition.cpp
+++ b/lib/Analysis/IntervalPartition.cpp
@@ -56,7 +56,7 @@ void IntervalPartition::addIntervalToPartition(Interval *I) {
 void IntervalPartition::updatePredecessors(Interval *Int) {
   BasicBlock *Header = Int->getHeaderNode();
   for (Interval::succ_iterator I = Int->Successors.begin(),
-	                       E = Int->Successors.end(); I != E; ++I)
+         E = Int->Successors.end(); I != E; ++I)
     getBlockInterval(*I)->Predecessors.push_back(Header);
 }
 
diff --git a/lib/Analysis/LoopInfo.cpp b/lib/Analysis/LoopInfo.cpp
index 8559d9a6b7..16d036c089 100644
--- a/lib/Analysis/LoopInfo.cpp
+++ b/lib/Analysis/LoopInfo.cpp
@@ -109,7 +109,7 @@ void LoopInfo::Calculate(const DominatorSet &DS) {
   BasicBlock *RootNode = DS.getRoot();
 
   for (df_iterator<BasicBlock*> NI = df_begin(RootNode),
-	 NE = df_end(RootNode); NI != NE; ++NI)
+         NE = df_end(RootNode); NI != NE; ++NI)
     if (Loop *L = ConsiderForLoop(*NI, DS))
       TopLevelLoops.push_back(L);
 }
@@ -191,7 +191,7 @@ Loop *LoopInfo::ConsiderForLoop(BasicBlock *BB, const DominatorSet &DS) {
 
   // If there are any loops nested within this loop, create them now!
   for (std::vector<BasicBlock*>::iterator I = L->Blocks.begin(),
-	 E = L->Blocks.end(); I != E; ++I)
+         E = L->Blocks.end(); I != E; ++I)
     if (Loop *NewLoop = ConsiderForLoop(*I, DS)) {
       L->SubLoops.push_back(NewLoop);
       NewLoop->ParentLoop = L;
@@ -201,7 +201,7 @@ Loop *LoopInfo::ConsiderForLoop(BasicBlock *BB, const DominatorSet &DS) {
   // loop can be found for them.
   //
   for (std::vector<BasicBlock*>::iterator I = L->Blocks.begin(),
-	 E = L->Blocks.end(); I != E; ++I) {
+         E = L->Blocks.end(); I != E; ++I) {
     std::map<BasicBlock*, Loop*>::iterator BBMI = BBMap.lower_bound(*I);
     if (BBMI == BBMap.end() || BBMI->first != *I)  // Not in map yet...
       BBMap.insert(BBMI, std::make_pair(*I, L));   // Must be at this level
diff --git a/lib/Analysis/PostDominators.cpp b/lib/Analysis/PostDominators.cpp
index b727c2f353..381b03c714 100644
--- a/lib/Analysis/PostDominators.cpp
+++ b/lib/Analysis/PostDominators.cpp
@@ -88,7 +88,7 @@ bool PostDominatorSet::runOnFunction(Function &F) {
           if (Roots.size() > 1)
             WorkingSet.insert(0);
         }
-	
+
         WorkingSet.insert(BB);           // A block always dominates itself
         DomSetType &BBSet = Doms[BB];
         if (BBSet != WorkingSet) {
@@ -138,8 +138,8 @@ void ImmediatePostDominators::calcIDoms(const DominatorSetBase &DS) {
       // dominator set size will be one less than BB's...
       //
       if (DS.getDominators(*I).size() == DomSetSize - 1) {
-	IDoms[BB] = *I;
-	break;
+        IDoms[BB] = *I;
+        break;
       }
     }
   }
@@ -196,7 +196,7 @@ void PostDominatorTree::calculate(const PostDominatorSet &DS) {
           //
           Node *IDomNode = Nodes[*I];
           assert(IDomNode && "No node for IDOM?");
-	
+
           // Add a new tree node for this BasicBlock, and link it as a child of
           // IDomNode
           Nodes[BB] = IDomNode->addChild(new Node(BB, IDomNode));
@@ -240,7 +240,7 @@ PostDominanceFrontier::calculate(const PostDominatorTree &DT,
     DomSetType::const_iterator CDFI = ChildDF.begin(), CDFE = ChildDF.end();
     for (; CDFI != CDFE; ++CDFI) {
       if (!Node->dominates(DT[*CDFI]))
-	S.insert(*CDFI);
+        S.insert(*CDFI);
     }
   }