From b859fb49ed7eed80bfbd742664a4ad5601f6eba2 Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Wed, 9 Apr 2008 00:07:45 +0000 Subject: [PATCH] many cleanups to the pow optimizer. Allow it to handle powf, add support for pow(x, 2.0) -> x*x. llvm-svn: 49411 --- llvm/lib/Transforms/IPO/SimplifyLibCalls.cpp | 84 ++++++++++++-------- llvm/test/Transforms/SimplifyLibCalls/Pow.ll | 16 +++- 2 files changed, 62 insertions(+), 38 deletions(-) diff --git a/llvm/lib/Transforms/IPO/SimplifyLibCalls.cpp b/llvm/lib/Transforms/IPO/SimplifyLibCalls.cpp index ed32daa39882..24c56abde970 100644 --- a/llvm/lib/Transforms/IPO/SimplifyLibCalls.cpp +++ b/llvm/lib/Transforms/IPO/SimplifyLibCalls.cpp @@ -1133,52 +1133,68 @@ LLVMMemSetOptimization MemSet64Optimizer("llvm.memset.i64"); struct VISIBILITY_HIDDEN PowOptimization : public LibCallOptimization { public: /// @brief Default Constructor - PowOptimization() : LibCallOptimization("pow", + PowOptimization(const char *Name) : LibCallOptimization(Name, "Number of 'pow' calls simplified") {} /// @brief Make sure that the "pow" function has the right prototype - virtual bool ValidateCalledFunction(const Function* f, SimplifyLibCalls& SLC){ - // Just make sure this has 2 arguments - return (f->arg_size() == 2); + virtual bool ValidateCalledFunction(const Function *F, SimplifyLibCalls &SLC){ + // Just make sure this has 2 arguments of the same FP type, which match the + // result type. + const FunctionType *FT = F->getFunctionType(); + return FT->getNumParams() == 2 && + FT->getParamType(0) == FT->getParamType(1) && + FT->getParamType(0) == FT->getReturnType() && + FT->getParamType(0)->isFloatingPoint(); } /// @brief Perform the pow optimization. - virtual bool OptimizeCall(CallInst *ci, SimplifyLibCalls &SLC) { - const Type *Ty = cast(ci->getOperand(0))->getReturnType(); - if (Ty!=Type::FloatTy && Ty!=Type::DoubleTy) + virtual bool OptimizeCall(CallInst *CI, SimplifyLibCalls &SLC) { + const Type *Ty = CI->getType(); + if (Ty != Type::FloatTy && Ty != Type::DoubleTy) return false; // FIXME long double not yet supported - Value* base = ci->getOperand(1); - Value* expn = ci->getOperand(2); - if (ConstantFP *Op1 = dyn_cast(base)) { - if (Op1->isExactlyValue(1.0)) // pow(1.0,x) -> 1.0 - return ReplaceCallWith(ci, ConstantFP::get(Ty, + + Value *Op1 = CI->getOperand(1); + Value *Op2 = CI->getOperand(2); + if (ConstantFP *Op1C = dyn_cast(Op1)) { + if (Op1C->isExactlyValue(1.0)) // pow(1.0, x) -> 1.0 + return ReplaceCallWith(CI, Op1C); + } + + ConstantFP *Op2C = dyn_cast(Op2); + if (Op2C == 0) return false; + + if (Op2C->getValueAPF().isZero()) { + // pow(x, 0.0) -> 1.0 + return ReplaceCallWith(CI, ConstantFP::get(Ty, Ty==Type::FloatTy ? APFloat(1.0f) : APFloat(1.0))); - } else if (ConstantFP* Op2 = dyn_cast(expn)) { - if (Op2->getValueAPF().isZero()) { - // pow(x,0.0) -> 1.0 - return ReplaceCallWith(ci, ConstantFP::get(Ty, - Ty==Type::FloatTy ? APFloat(1.0f) : APFloat(1.0))); - } else if (Op2->isExactlyValue(0.5)) { - // pow(x,0.5) -> sqrt(x) - CallInst* sqrt_inst = CallInst::Create(SLC.get_sqrt(), base, - ci->getName()+".pow",ci); - return ReplaceCallWith(ci, sqrt_inst); - } else if (Op2->isExactlyValue(1.0)) { - // pow(x,1.0) -> x - return ReplaceCallWith(ci, base); - } else if (Op2->isExactlyValue(-1.0)) { - // pow(x,-1.0) -> 1.0/x - Value *div_inst = - BinaryOperator::createFDiv(ConstantFP::get(Ty, - Ty==Type::FloatTy ? APFloat(1.0f) : APFloat(1.0)), - base, ci->getName()+".pow", ci); - return ReplaceCallWith(ci, div_inst); - } + } else if (Op2C->isExactlyValue(0.5)) { + // pow(x, 0.5) -> sqrt(x) + Value *Sqrt = CallInst::Create(SLC.get_sqrt(), Op1, "sqrt", CI); + return ReplaceCallWith(CI, Sqrt); + } else if (Op2C->isExactlyValue(1.0)) { + // pow(x, 1.0) -> x + return ReplaceCallWith(CI, Op1); + } else if (Op2C->isExactlyValue(2.0)) { + // pow(x, 2.0) -> x*x + Value *Sq = BinaryOperator::createMul(Op1, Op1, "pow2", CI); + return ReplaceCallWith(CI, Sq); + } else if (Op2C->isExactlyValue(-1.0)) { + // pow(x, -1.0) -> 1.0/x + Value *div_inst = + BinaryOperator::createFDiv(ConstantFP::get(Ty, + Ty==Type::FloatTy ? APFloat(1.0f) : APFloat(1.0)), + Op1, CI->getName()+".pow", CI); + return ReplaceCallWith(CI, div_inst); } return false; // opt failed } -} PowOptimizer; +}; +PowOptimization PowFOptimizer("powf"); +PowOptimization PowOptimizer("pow"); +PowOptimization PowLOptimizer("powl"); + + /// This LibCallOptimization will simplify calls to the "printf" library /// function. It looks for cases where the result of printf is not used and the /// operation can be reduced to something simpler. diff --git a/llvm/test/Transforms/SimplifyLibCalls/Pow.ll b/llvm/test/Transforms/SimplifyLibCalls/Pow.ll index fa638ef78014..c039d80a2c90 100644 --- a/llvm/test/Transforms/SimplifyLibCalls/Pow.ll +++ b/llvm/test/Transforms/SimplifyLibCalls/Pow.ll @@ -1,11 +1,10 @@ ; Testcase for calls to the standard C "pow" function ; -; Equivalent to: http://gcc.gnu.org/ml/gcc-patches/2003-02/msg01786.html -; RUN: llvm-as < %s | opt -simplify-libcalls | llvm-dis | \ -; RUN: not grep {call double .pow} -; END. +; RUN: llvm-as < %s | opt -simplify-libcalls | llvm-dis | not grep {call .pow} + declare double @pow(double, double) +declare float @powf(float, float) define double @test1(double %X) { %Y = call double @pow( double %X, double 0.000000e+00 ) ; [#uses=1] @@ -22,3 +21,12 @@ define double @test3(double %X) { ret double %Y } +define double @test4(double %X) { + %Y = call double @pow( double %X, double 2.0) + ret double %Y +} + +define float @test4f(float %X) { + %Y = call float @powf( float %X, float 2.0) + ret float %Y +}