[llvm-commits] [llvm] r130694 - in /llvm/trunk: lib/Analysis/InstructionSimplify.cpp lib/Transforms/InstCombine/InstCombineMulDivRem.cpp test/Transforms/InstSimplify/rem.ll
Duncan Sands
baldrick at free.fr
Mon May 2 11:58:26 PDT 2011
Hi Eric,
> This put a few warnings into the build:
>
> /Volumes/Data/sources/llvm-clean/lib/Analysis/InstructionSimplify.cpp:916:8: warning:
> unused variable 'isSigned' [-Wunused-variable]
> bool isSigned = Opcode == Instruction::SRem;
>
>
> /Volumes/Data/sources/llvm-clean/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp:506:20: warning:
> unused variable 'RHS' [-Wunused-variable]
> if (ConstantInt *RHS = dyn_cast<ConstantInt>(Op1)) {
sorry about that - looks like I need to increase my -O level :)
> Mind cleaning these up?
Done!
Ciao, Duncan.
>
> Thanks!
>
> -eric
>
> On May 2, 2011, at 9:27 AM, Duncan Sands wrote:
>
>> Author: baldrick
>> Date: Mon May 2 11:27:02 2011
>> New Revision: 130694
>>
>> URL: http://llvm.org/viewvc/llvm-project?rev=130694&view=rev
>> Log:
>> Move some rem transforms out of instcombine and into instsimplify.
>> This automagically provides a transform noticed by my super-optimizer
>> as occurring quite often: "rem x, (select cond, x, 1)" -> 0.
>>
>> Added:
>> llvm/trunk/test/Transforms/InstSimplify/rem.ll
>> Modified:
>> llvm/trunk/lib/Analysis/InstructionSimplify.cpp
>> llvm/trunk/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp
>>
>> Modified: llvm/trunk/lib/Analysis/InstructionSimplify.cpp
>> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/InstructionSimplify.cpp?rev=130694&r1=130693&r2=130694&view=diff
>> ==============================================================================
>> --- llvm/trunk/lib/Analysis/InstructionSimplify.cpp (original)
>> +++ llvm/trunk/lib/Analysis/InstructionSimplify.cpp Mon May 2 11:27:02 2011
>> @@ -901,6 +901,111 @@
>> return ::SimplifyFDivInst(Op0, Op1, TD, DT, RecursionLimit);
>> }
>>
>> +/// SimplifyRem - Given operands for an SRem or URem, see if we can
>> +/// fold the result. If not, this returns null.
>> +static Value *SimplifyRem(Instruction::BinaryOps Opcode, Value *Op0, Value *Op1,
>> + const TargetData *TD, const DominatorTree *DT,
>> + unsigned MaxRecurse) {
>> + if (Constant *C0 = dyn_cast<Constant>(Op0)) {
>> + if (Constant *C1 = dyn_cast<Constant>(Op1)) {
>> + Constant *Ops[] = { C0, C1 };
>> + return ConstantFoldInstOperands(Opcode, C0->getType(), Ops, 2, TD);
>> + }
>> + }
>> +
>> + bool isSigned = Opcode == Instruction::SRem;
>> +
>> + // X % undef -> undef
>> + if (match(Op1, m_Undef()))
>> + return Op1;
>> +
>> + // undef % X -> 0
>> + if (match(Op0, m_Undef()))
>> + return Constant::getNullValue(Op0->getType());
>> +
>> + // 0 % X -> 0, we don't need to preserve faults!
>> + if (match(Op0, m_Zero()))
>> + return Op0;
>> +
>> + // X % 0 -> undef, we don't need to preserve faults!
>> + if (match(Op1, m_Zero()))
>> + return UndefValue::get(Op0->getType());
>> +
>> + // X % 1 -> 0
>> + if (match(Op1, m_One()))
>> + return Constant::getNullValue(Op0->getType());
>> +
>> + if (Op0->getType()->isIntegerTy(1))
>> + // It can't be remainder by zero, hence it must be remainder by one.
>> + return Constant::getNullValue(Op0->getType());
>> +
>> + // X % X -> 0
>> + if (Op0 == Op1)
>> + return Constant::getNullValue(Op0->getType());
>> +
>> + // If the operation is with the result of a select instruction, check whether
>> + // operating on either branch of the select always yields the same value.
>> + if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1))
>> + if (Value *V = ThreadBinOpOverSelect(Opcode, Op0, Op1, TD, DT, MaxRecurse))
>> + return V;
>> +
>> + // If the operation is with the result of a phi instruction, check whether
>> + // operating on all incoming values of the phi always yields the same value.
>> + if (isa<PHINode>(Op0) || isa<PHINode>(Op1))
>> + if (Value *V = ThreadBinOpOverPHI(Opcode, Op0, Op1, TD, DT, MaxRecurse))
>> + return V;
>> +
>> + return 0;
>> +}
>> +
>> +/// SimplifySRemInst - Given operands for an SRem, see if we can
>> +/// fold the result. If not, this returns null.
>> +static Value *SimplifySRemInst(Value *Op0, Value *Op1, const TargetData *TD,
>> + const DominatorTree *DT, unsigned MaxRecurse) {
>> + if (Value *V = SimplifyRem(Instruction::SRem, Op0, Op1, TD, DT, MaxRecurse))
>> + return V;
>> +
>> + return 0;
>> +}
>> +
>> +Value *llvm::SimplifySRemInst(Value *Op0, Value *Op1, const TargetData *TD,
>> + const DominatorTree *DT) {
>> + return ::SimplifySRemInst(Op0, Op1, TD, DT, RecursionLimit);
>> +}
>> +
>> +/// SimplifyURemInst - Given operands for a URem, see if we can
>> +/// fold the result. If not, this returns null.
>> +static Value *SimplifyURemInst(Value *Op0, Value *Op1, const TargetData *TD,
>> + const DominatorTree *DT, unsigned MaxRecurse) {
>> + if (Value *V = SimplifyRem(Instruction::URem, Op0, Op1, TD, DT, MaxRecurse))
>> + return V;
>> +
>> + return 0;
>> +}
>> +
>> +Value *llvm::SimplifyURemInst(Value *Op0, Value *Op1, const TargetData *TD,
>> + const DominatorTree *DT) {
>> + return ::SimplifyURemInst(Op0, Op1, TD, DT, RecursionLimit);
>> +}
>> +
>> +static Value *SimplifyFRemInst(Value *Op0, Value *Op1, const TargetData *,
>> + const DominatorTree *, unsigned) {
>> + // undef % X -> undef (the undef could be a snan).
>> + if (match(Op0, m_Undef()))
>> + return Op0;
>> +
>> + // X % undef -> undef
>> + if (match(Op1, m_Undef()))
>> + return Op1;
>> +
>> + return 0;
>> +}
>> +
>> +Value *llvm::SimplifyFRemInst(Value *Op0, Value *Op1, const TargetData *TD,
>> + const DominatorTree *DT) {
>> + return ::SimplifyFRemInst(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,
>> @@ -1994,6 +2099,9 @@
>> 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::SRem: return SimplifySRemInst(LHS, RHS, TD, DT, MaxRecurse);
>> + case Instruction::URem: return SimplifyURemInst(LHS, RHS, TD, DT, MaxRecurse);
>> + case Instruction::FRem: return SimplifyFRemInst(LHS, RHS, TD, DT, MaxRecurse);
>> case Instruction::Shl:
>> return SimplifyShlInst(LHS, RHS, /*isNSW*/false, /*isNUW*/false,
>> TD, DT, MaxRecurse);
>> @@ -2088,6 +2196,15 @@
>> case Instruction::FDiv:
>> Result = SimplifyFDivInst(I->getOperand(0), I->getOperand(1), TD, DT);
>> break;
>> + case Instruction::SRem:
>> + Result = SimplifySRemInst(I->getOperand(0), I->getOperand(1), TD, DT);
>> + break;
>> + case Instruction::URem:
>> + Result = SimplifyURemInst(I->getOperand(0), I->getOperand(1), TD, DT);
>> + break;
>> + case Instruction::FRem:
>> + Result = SimplifyFRemInst(I->getOperand(0), I->getOperand(1), TD, DT);
>> + break;
>> case Instruction::Shl:
>> Result = SimplifyShlInst(I->getOperand(0), I->getOperand(1),
>> cast<BinaryOperator>(I)->hasNoSignedWrap(),
>>
>> Modified: llvm/trunk/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp
>> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp?rev=130694&r1=130693&r2=130694&view=diff
>> ==============================================================================
>> --- llvm/trunk/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp (original)
>> +++ llvm/trunk/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp Mon May 2 11:27:02 2011
>> @@ -492,28 +492,6 @@
>> 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.
>> -/// @brief Transforms common to all three rem instructions
>> -Instruction *InstCombiner::commonRemTransforms(BinaryOperator&I) {
>> - Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
>> -
>> - if (isa<UndefValue>(Op0)) { // undef % X -> 0
>> - if (I.getType()->isFPOrFPVectorTy())
>> - return ReplaceInstUsesWith(I, Op0); // X % undef -> undef (could be SNaN)
>> - return ReplaceInstUsesWith(I, Constant::getNullValue(I.getType()));
>> - }
>> - if (isa<UndefValue>(Op1))
>> - return ReplaceInstUsesWith(I, Op1); // X % undef -> undef
>> -
>> - // Handle cases involving: rem X, (select Cond, Y, Z)
>> - if (isa<SelectInst>(Op1)&& SimplifyDivRemOfSelect(I))
>> - return&I;
>> -
>> - return 0;
>> -}
>> -
>> /// This function implements the transforms common to both integer remainder
>> /// instructions (urem and srem). It is called by the visitors to those integer
>> /// remainder instructions.
>> @@ -521,26 +499,11 @@
>> Instruction *InstCombiner::commonIRemTransforms(BinaryOperator&I) {
>> Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
>>
>> - if (Instruction *common = commonRemTransforms(I))
>> - return common;
>> -
>> - // X % X == 0
>> - if (Op0 == Op1)
>> - return ReplaceInstUsesWith(I, Constant::getNullValue(I.getType()));
>> -
>> - // 0 % X == 0 for integer, we don't need to preserve faults!
>> - if (Constant *LHS = dyn_cast<Constant>(Op0))
>> - if (LHS->isNullValue())
>> - return ReplaceInstUsesWith(I, Constant::getNullValue(I.getType()));
>> + // Handle cases involving: rem X, (select Cond, Y, Z)
>> + if (isa<SelectInst>(Op1)&& SimplifyDivRemOfSelect(I))
>> + return&I;
>>
>> if (ConstantInt *RHS = dyn_cast<ConstantInt>(Op1)) {
>> - // X % 0 == undef, we don't need to preserve faults!
>> - if (RHS->equalsInt(0))
>> - return ReplaceInstUsesWith(I, UndefValue::get(I.getType()));
>> -
>> - if (RHS->equalsInt(1)) // X % 1 == 0
>> - return ReplaceInstUsesWith(I, Constant::getNullValue(I.getType()));
>> -
>> if (Instruction *Op0I = dyn_cast<Instruction>(Op0)) {
>> if (SelectInst *SI = dyn_cast<SelectInst>(Op0I)) {
>> if (Instruction *R = FoldOpIntoSelect(I, SI))
>> @@ -562,6 +525,9 @@
>> Instruction *InstCombiner::visitURem(BinaryOperator&I) {
>> Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
>>
>> + if (Value *V = SimplifyURemInst(Op0, Op1, TD))
>> + return ReplaceInstUsesWith(I, V);
>> +
>> if (Instruction *common = commonIRemTransforms(I))
>> return common;
>>
>> @@ -602,6 +568,9 @@
>> Instruction *InstCombiner::visitSRem(BinaryOperator&I) {
>> Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
>>
>> + if (Value *V = SimplifySRemInst(Op0, Op1, TD))
>> + return ReplaceInstUsesWith(I, V);
>> +
>> // Handle the integer rem common cases
>> if (Instruction *Common = commonIRemTransforms(I))
>> return Common;
>> @@ -660,6 +629,14 @@
>> }
>>
>> Instruction *InstCombiner::visitFRem(BinaryOperator&I) {
>> - return commonRemTransforms(I);
>> -}
>> + Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
>>
>> + if (Value *V = SimplifyFRemInst(Op0, Op1, TD))
>> + return ReplaceInstUsesWith(I, V);
>> +
>> + // Handle cases involving: rem X, (select Cond, Y, Z)
>> + if (isa<SelectInst>(Op1)&& SimplifyDivRemOfSelect(I))
>> + return&I;
>> +
>> + return 0;
>> +}
>>
>> Added: llvm/trunk/test/Transforms/InstSimplify/rem.ll
>> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Transforms/InstSimplify/rem.ll?rev=130694&view=auto
>> ==============================================================================
>> --- llvm/trunk/test/Transforms/InstSimplify/rem.ll (added)
>> +++ llvm/trunk/test/Transforms/InstSimplify/rem.ll Mon May 2 11:27:02 2011
>> @@ -0,0 +1,17 @@
>> +; RUN: opt< %s -instsimplify -S | FileCheck %s
>> +
>> +define i32 @select1(i32 %x, i1 %b) {
>> +; CHECK: @select1
>> + %rhs = select i1 %b, i32 %x, i32 1
>> + %rem = srem i32 %x, %rhs
>> + ret i32 %rem
>> +; CHECK: ret i32 0
>> +}
>> +
>> +define i32 @select2(i32 %x, i1 %b) {
>> +; CHECK: @select2
>> + %rhs = select i1 %b, i32 %x, i32 1
>> + %rem = urem i32 %x, %rhs
>> + ret i32 %rem
>> +; CHECK: ret i32 0
>> +}
>>
>>
>> _______________________________________________
>> llvm-commits mailing list
>> llvm-commits at cs.uiuc.edu
>> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
>
More information about the llvm-commits
mailing list