diff --git a/lib/Analysis/Expressions.cpp b/lib/Analysis/Expressions.cpp
index 5e07150..395db25 100644
--- a/lib/Analysis/Expressions.cpp
+++ b/lib/Analysis/Expressions.cpp
@@ -233,13 +233,13 @@
 }
 
 
-// ClassifyExpression: Analyze an expression to determine the complexity of the
-// expression, and which other values it depends on.  
+// ClassifyExpr: Analyze an expression to determine the complexity of the
+// expression, and which other values it depends on.
 //
 // Note that this analysis cannot get into infinite loops because it treats PHI
 // nodes as being an unknown linear expression.
 //
-ExprType llvm::ClassifyExpression(Value *Expr) {
+ExprType llvm::ClassifyExpr(Value *Expr) {
   assert(Expr != 0 && "Can't classify a null expression!");
   if (Expr->getType() == Type::FloatTy || Expr->getType() == Type::DoubleTy)
     return Expr;   // FIXME: Can't handle FP expressions
@@ -266,14 +266,14 @@
 
   switch (I->getOpcode()) {       // Handle each instruction type separately
   case Instruction::Add: {
-    ExprType Left (ClassifyExpression(I->getOperand(0)));
-    ExprType Right(ClassifyExpression(I->getOperand(1)));
+    ExprType Left (ClassifyExpr(I->getOperand(0)));
+    ExprType Right(ClassifyExpr(I->getOperand(1)));
     return handleAddition(Left, Right, I);
   }  // end case Instruction::Add
 
   case Instruction::Sub: {
-    ExprType Left (ClassifyExpression(I->getOperand(0)));
-    ExprType Right(ClassifyExpression(I->getOperand(1)));
+    ExprType Left (ClassifyExpr(I->getOperand(0)));
+    ExprType Right(ClassifyExpr(I->getOperand(1)));
     ExprType RightNeg = negate(Right, I);
     if (RightNeg.Var == I && !RightNeg.Offset && !RightNeg.Scale)
       return I;   // Could not negate value...
@@ -281,9 +281,9 @@
   }  // end case Instruction::Sub
 
   case Instruction::Shl: { 
-    ExprType Right(ClassifyExpression(I->getOperand(1)));
+    ExprType Right(ClassifyExpr(I->getOperand(1)));
     if (Right.ExprTy != ExprType::Constant) break;
-    ExprType Left(ClassifyExpression(I->getOperand(0)));
+    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!");
@@ -308,8 +308,8 @@
   }  // end case Instruction::Shl
 
   case Instruction::Mul: {
-    ExprType Left (ClassifyExpression(I->getOperand(0)));
-    ExprType Right(ClassifyExpression(I->getOperand(1)));
+    ExprType Left (ClassifyExpr(I->getOperand(0)));
+    ExprType Right(ClassifyExpr(I->getOperand(1)));
     if (Left.ExprTy > Right.ExprTy)
       std::swap(Left, Right);   // Make left be simpler than right
 
@@ -323,7 +323,7 @@
   } // end case Instruction::Mul
 
   case Instruction::Cast: {
-    ExprType Src(ClassifyExpression(I->getOperand(0)));
+    ExprType Src(ClassifyExpr(I->getOperand(0)));
     const Type *DestTy = I->getType();
     if (isa<PointerType>(DestTy))
       DestTy = Type::ULongTy;  // Pointer types are represented as ulong
diff --git a/lib/Analysis/InductionVariable.cpp b/lib/Analysis/InductionVariable.cpp
index 8b805f8..b602529 100644
--- a/lib/Analysis/InductionVariable.cpp
+++ b/lib/Analysis/InductionVariable.cpp
@@ -89,8 +89,8 @@
   Value *V2 = Phi->getIncomingValue(1);
 
   if (L == 0) {  // No loop information?  Base everything on expression analysis
-    ExprType E1 = ClassifyExpression(V1);
-    ExprType E2 = ClassifyExpression(V2);
+    ExprType E1 = ClassifyExpr(V1);
+    ExprType E2 = ClassifyExpr(V2);
 
     if (E1.ExprTy > E2.ExprTy)        // Make E1 be the simpler expression
       std::swap(E1, E2);
@@ -152,7 +152,7 @@
     }
 
     if (Step == 0) {                  // Unrecognized step value...
-      ExprType StepE = ClassifyExpression(V2);
+      ExprType StepE = ClassifyExpr(V2);
       if (StepE.ExprTy != ExprType::Linear ||
           StepE.Var != Phi) return;
 
@@ -160,7 +160,7 @@
       if (isa<PointerType>(ETy)) ETy = Type::ULongTy;
       Step  = (Value*)(StepE.Offset ? StepE.Offset : ConstantInt::get(ETy, 0));
     } else {   // We were able to get a step value, simplify with expr analysis
-      ExprType StepE = ClassifyExpression(Step);
+      ExprType StepE = ClassifyExpr(Step);
       if (StepE.ExprTy == ExprType::Linear && StepE.Offset == 0) {
         // No offset from variable?  Grab the variable
         Step = StepE.Var;
diff --git a/lib/Transforms/ExprTypeConvert.cpp b/lib/Transforms/ExprTypeConvert.cpp
index e2f1029..25b4190 100644
--- a/lib/Transforms/ExprTypeConvert.cpp
+++ b/lib/Transforms/ExprTypeConvert.cpp
@@ -52,7 +52,7 @@
   if (!Ty->isSized()) return false;      // Can only alloc something with a size
 
   // Analyze the number of bytes allocated...
-  ExprType Expr = ClassifyExpression(MI->getArraySize());
+  ExprType Expr = ClassifyExpr(MI->getArraySize());
 
   // Get information about the base datatype being allocated, before & after
   int ReqTypeSize = TD.getTypeSize(Ty);
@@ -89,7 +89,7 @@
   BasicBlock::iterator It = BB->end();
 
   // Analyze the number of bytes allocated...
-  ExprType Expr = ClassifyExpression(MI->getArraySize());
+  ExprType Expr = ClassifyExpr(MI->getArraySize());
 
   const PointerType *AllocTy = cast<PointerType>(Ty);
   const Type *ElType = AllocTy->getElementType();
diff --git a/lib/Transforms/TransformInternals.cpp b/lib/Transforms/TransformInternals.cpp
index b553f03..e02bd8b 100644
--- a/lib/Transforms/TransformInternals.cpp
+++ b/lib/Transforms/TransformInternals.cpp
@@ -104,7 +104,7 @@
   // See if the cast is of an integer expression that is either a constant,
   // or a value scaled by some amount with a possible offset.
   //
-  ExprType Expr = ClassifyExpression(OffsetVal);
+  ExprType Expr = ClassifyExpr(OffsetVal);
 
   // Get the offset and scale values if they exists...
   // A scale of zero with Expr.Var != 0 means a scale of 1.