6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-04-06 09:44:39 +00:00
Code Issues Projects Releases Wiki Activity

Move InstCombine's knowledge of fdiv to SimplifyInstruction().

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@124534 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Frits van Bommel 2011-01-29 15:26:31 +00:00
parent 9136782d27
commit 1fca2c32cc
5 changed files with 47 additions and 18 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
include/llvm/Analysis/InstructionSimplify.h
View File

@ -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.

26
lib/Analysis/InstructionSimplify.cpp
View File

@ -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<UndefValue>(Op0))
return Op0;
// X / undef -> undef
if (isa<UndefValue>(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;

1
lib/Transforms/InstCombine/InstCombine.h
View File

@ -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);

14
lib/Transforms/InstCombine/InstCombineMulDivRem.cpp
View File

@ -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<UndefValue>(Op0))
return ReplaceInstUsesWith(I, Op0);
// X / undef -> undef
if (isa<UndefValue>(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.

17
test/Transforms/InstSimplify/fdiv.ll Normal file
View File

@ -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
}