commit dedf2bd5a34dac25e4245f58bb902ced6b64edd9
author Misha Brukman <brukman+llvm@gmail.com> Fri Apr 22 04:01:18 2005 +0000
committer Misha Brukman <brukman+llvm@gmail.com> Fri Apr 22 04:01:18 2005 +0000
tree 8ae45f7a66e26530d3f60616f44557d31dc2cee7
parent 00876a2808f1a8061f7e0852c7949fc5074ecb04

Convert tabs to spaces


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

lib/Analysis/Expressions.cpp

diff --git a/lib/Analysis/Expressions.cpp b/lib/Analysis/Expressions.cpp
index 9ec78a9..f625b2e 100644
--- a/lib/Analysis/Expressions.cpp
+++ b/lib/Analysis/Expressions.cpp
@@ -38,7 +38,7 @@
 }
 
 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 @@
   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 @@
   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 @@
   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 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 @@
       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 @@
     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: {