diff --git a/lib/Analysis/Expressions.cpp b/lib/Analysis/Expressions.cpp index 5e07150f2f4..395db2567c5 100644 --- a/lib/Analysis/Expressions.cpp +++ b/lib/Analysis/Expressions.cpp @@ -233,13 +233,13 @@ static inline ExprType negate(const ExprType &E, Value *V) { } -// 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 @@ ExprType llvm::ClassifyExpression(Value *Expr) { 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 @@ ExprType llvm::ClassifyExpression(Value *Expr) { } // 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 @@ ExprType llvm::ClassifyExpression(Value *Expr) { } // 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 @@ ExprType llvm::ClassifyExpression(Value *Expr) { } // 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(DestTy)) DestTy = Type::ULongTy; // Pointer types are represented as ulong diff --git a/lib/Analysis/InductionVariable.cpp b/lib/Analysis/InductionVariable.cpp index 8b805f8818e..b6025294948 100644 --- a/lib/Analysis/InductionVariable.cpp +++ b/lib/Analysis/InductionVariable.cpp @@ -89,8 +89,8 @@ InductionVariable::InductionVariable(PHINode *P, LoopInfo *LoopInfo): End(0) { 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 @@ InductionVariable::InductionVariable(PHINode *P, LoopInfo *LoopInfo): End(0) { } 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 @@ InductionVariable::InductionVariable(PHINode *P, LoopInfo *LoopInfo): End(0) { if (isa(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 e2f1029004b..25b41904d30 100644 --- a/lib/Transforms/ExprTypeConvert.cpp +++ b/lib/Transforms/ExprTypeConvert.cpp @@ -52,7 +52,7 @@ static bool MallocConvertibleToType(MallocInst *MI, const Type *Ty, 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 @@ static Instruction *ConvertMallocToType(MallocInst *MI, const Type *Ty, 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(Ty); const Type *ElType = AllocTy->getElementType(); diff --git a/lib/Transforms/TransformInternals.cpp b/lib/Transforms/TransformInternals.cpp index b553f03a41b..e02bd8bbccb 100644 --- a/lib/Transforms/TransformInternals.cpp +++ b/lib/Transforms/TransformInternals.cpp @@ -104,7 +104,7 @@ const Type *ConvertibleToGEP(const Type *Ty, Value *OffsetVal, // 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.