[llvm-commits] [llvm] r130694 - in /llvm/trunk: lib/Analysis/InstructionSimplify.cpp lib/Transforms/InstCombine/InstCombineMulDivRem.cpp test/Transforms/InstSimplify/rem.ll
Eric Christopher
echristo at apple.com
Mon May 2 10:16:43 PDT 2011
Hi Duncan,
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)) {
Mind cleaning these up?
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