From 1fca2c32cc99197215d3fd32a4ad05214c74edd1 Mon Sep 17 00:00:00 2001 From: Frits van Bommel Date: Sat, 29 Jan 2011 15:26:31 +0000 Subject: [PATCH] Move InstCombine's knowledge of fdiv to SimplifyInstruction(). git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@124534 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Analysis/InstructionSimplify.h | 7 ++++- lib/Analysis/InstructionSimplify.cpp | 26 +++++++++++++++++-- lib/Transforms/InstCombine/InstCombine.h | 1 - .../InstCombine/InstCombineMulDivRem.cpp | 14 ---------- test/Transforms/InstSimplify/fdiv.ll | 17 ++++++++++++ 5 files changed, 47 insertions(+), 18 deletions(-) create mode 100644 test/Transforms/InstSimplify/fdiv.ll diff --git a/include/llvm/Analysis/InstructionSimplify.h b/include/llvm/Analysis/InstructionSimplify.h index d39432d072b..9ad7bc6e8a5 100644 --- a/include/llvm/Analysis/InstructionSimplify.h +++ b/include/llvm/Analysis/InstructionSimplify.h @@ -48,7 +48,12 @@ namespace llvm { /// SimplifyUDivInst - Given operands for a UDiv, see if we can /// fold the result. If not, this returns null. Value *SimplifyUDivInst(Value *LHS, Value *RHS, const TargetData *TD = 0, - const DominatorTree *DT = 0); + const DominatorTree *DT = 0); + + /// SimplifyFDivInst - Given operands for an FDiv, see if we can + /// fold the result. If not, this returns null. + Value *SimplifyFDivInst(Value *LHS, Value *RHS, const TargetData *TD = 0, + const DominatorTree *DT = 0); /// SimplifyShlInst - Given operands for a Shl, see if we can /// fold the result. If not, this returns null. diff --git a/lib/Analysis/InstructionSimplify.cpp b/lib/Analysis/InstructionSimplify.cpp index 16cdfeb838f..c1fa6fcca63 100644 --- a/lib/Analysis/InstructionSimplify.cpp +++ b/lib/Analysis/InstructionSimplify.cpp @@ -837,7 +837,7 @@ static Value *SimplifySDivInst(Value *Op0, Value *Op1, const TargetData *TD, } Value *llvm::SimplifySDivInst(Value *Op0, Value *Op1, const TargetData *TD, - const DominatorTree *DT) { + const DominatorTree *DT) { return ::SimplifySDivInst(Op0, Op1, TD, DT, RecursionLimit); } @@ -852,10 +852,28 @@ static Value *SimplifyUDivInst(Value *Op0, Value *Op1, const TargetData *TD, } Value *llvm::SimplifyUDivInst(Value *Op0, Value *Op1, const TargetData *TD, - const DominatorTree *DT) { + const DominatorTree *DT) { return ::SimplifyUDivInst(Op0, Op1, TD, DT, RecursionLimit); } +static Value *SimplifyFDivInst(Value *Op0, Value *Op1, const TargetData *TD, + const DominatorTree *DT, unsigned MaxRecurse) { + // undef / X -> undef (the undef could be a snan). + if (isa(Op0)) + return Op0; + + // X / undef -> undef + if (isa(Op1)) + return Op1; + + return 0; +} + +Value *llvm::SimplifyFDivInst(Value *Op0, Value *Op1, const TargetData *TD, + const DominatorTree *DT) { + return ::SimplifyFDivInst(Op0, Op1, TD, DT, RecursionLimit); +} + /// SimplifyShift - Given operands for an Shl, LShr or AShr, see if we can /// fold the result. If not, this returns null. static Value *SimplifyShift(unsigned Opcode, Value *Op0, Value *Op1, @@ -1760,6 +1778,7 @@ static Value *SimplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS, case Instruction::Mul: return SimplifyMulInst(LHS, RHS, TD, DT, MaxRecurse); case Instruction::SDiv: return SimplifySDivInst(LHS, RHS, TD, DT, MaxRecurse); case Instruction::UDiv: return SimplifyUDivInst(LHS, RHS, TD, DT, MaxRecurse); + case Instruction::FDiv: return SimplifyFDivInst(LHS, RHS, TD, DT, MaxRecurse); case Instruction::Shl: return SimplifyShlInst(LHS, RHS, TD, DT, MaxRecurse); case Instruction::LShr: return SimplifyLShrInst(LHS, RHS, TD, DT, MaxRecurse); case Instruction::AShr: return SimplifyAShrInst(LHS, RHS, TD, DT, MaxRecurse); @@ -1847,6 +1866,9 @@ Value *llvm::SimplifyInstruction(Instruction *I, const TargetData *TD, case Instruction::UDiv: Result = SimplifyUDivInst(I->getOperand(0), I->getOperand(1), TD, DT); break; + case Instruction::FDiv: + Result = SimplifyFDivInst(I->getOperand(0), I->getOperand(1), TD, DT); + break; case Instruction::Shl: Result = SimplifyShlInst(I->getOperand(0), I->getOperand(1), TD, DT); break; diff --git a/lib/Transforms/InstCombine/InstCombine.h b/lib/Transforms/InstCombine/InstCombine.h index 450e7f0a398..ef49790d148 100644 --- a/lib/Transforms/InstCombine/InstCombine.h +++ b/lib/Transforms/InstCombine/InstCombine.h @@ -118,7 +118,6 @@ public: Instruction *commonIDivTransforms(BinaryOperator &I); Instruction *visitUDiv(BinaryOperator &I); Instruction *visitSDiv(BinaryOperator &I); - Instruction *visitFDiv(BinaryOperator &I); Value *FoldAndOfICmps(ICmpInst *LHS, ICmpInst *RHS); Value *FoldAndOfFCmps(FCmpInst *LHS, FCmpInst *RHS); Instruction *visitAnd(BinaryOperator &I); diff --git a/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp b/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp index b5b98411f59..32b2a0ac0ee 100644 --- a/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp +++ b/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp @@ -473,20 +473,6 @@ Instruction *InstCombiner::visitSDiv(BinaryOperator &I) { return 0; } -Instruction *InstCombiner::visitFDiv(BinaryOperator &I) { - Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1); - - // undef / X -> undef (the undef could be a snan). - if (isa(Op0)) - return ReplaceInstUsesWith(I, Op0); - - // X / undef -> undef - if (isa(Op1)) - return ReplaceInstUsesWith(I, Op1); - - return 0; -} - /// This function implements the transforms on rem instructions that work /// regardless of the kind of rem instruction it is (urem, srem, or frem). It /// is used by the visitors to those instructions. diff --git a/test/Transforms/InstSimplify/fdiv.ll b/test/Transforms/InstSimplify/fdiv.ll new file mode 100644 index 00000000000..9d85154b240 --- /dev/null +++ b/test/Transforms/InstSimplify/fdiv.ll @@ -0,0 +1,17 @@ +; RUN: opt < %s -instsimplify -S | FileCheck %s + +define double @fdiv_of_undef(double %X) { +; CHECK: @fdiv_of_undef +; undef / X -> undef + %r = fdiv double undef, %X + ret double %r +; CHECK: ret double undef +} + +define double @fdiv_by_undef(double %X) { +; CHECK: @fdiv_by_undef +; X / undef -> undef + %r = fdiv double %X, undef + ret double %r +; CHECK: ret double undef +} -- 2.34.1