[llvm-commits] [llvm] r137013 - in /llvm/trunk: lib/Analysis/ScalarEvolution.cpp lib/Transforms/Scalar/IndVarSimplify.cpp test/Transforms/IndVarSimplify/iv-fold.ll
Nick Lewycky
nicholas at mxc.ca
Sat Aug 6 14:10:07 PDT 2011
Andrew Trick wrote:
> Author: atrick
> Date: Sat Aug 6 02:00:37 2011
> New Revision: 137013
>
> URL: http://llvm.org/viewvc/llvm-project?rev=137013&view=rev
> Log:
> Made SCEV's UDiv expressions more canonical. When dividing a
> recurrence, the initial values low bits can sometimes be ignored.
>
> To take advantage of this, added FoldIVUser to IndVarSimplify to fold
> an IV operand into a udiv/lshr if the operator doesn't affect the
> result.
>
> -indvars -disable-iv-rewrite now transforms
>
> i = phi i4
> i1 = i0 + 1
> idx = i1>> (2 or more)
> i4 = i + 4
>
> into
>
> i = phi i4
> idx = i0>> ...
> i4 = i + 4
Clever! Is this something that instcombine or something else would not
have gotten anyways?
Is there any hope of applying the same trick to sdivs?
>
> Added:
> llvm/trunk/test/Transforms/IndVarSimplify/iv-fold.ll
> Modified:
> llvm/trunk/lib/Analysis/ScalarEvolution.cpp
> llvm/trunk/lib/Transforms/Scalar/IndVarSimplify.cpp
>
> Modified: llvm/trunk/lib/Analysis/ScalarEvolution.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/ScalarEvolution.cpp?rev=137013&r1=137012&r2=137013&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Analysis/ScalarEvolution.cpp (original)
> +++ llvm/trunk/lib/Analysis/ScalarEvolution.cpp Sat Aug 6 02:00:37 2011
> @@ -2051,12 +2051,13 @@
> ++MaxShiftAmt;
> IntegerType *ExtTy =
> IntegerType::get(getContext(), getTypeSizeInBits(Ty) + MaxShiftAmt);
> - // {X,+,N}/C --> {X/C,+,N/C} if safe and N/C can be folded.
> if (const SCEVAddRecExpr *AR = dyn_cast<SCEVAddRecExpr>(LHS))
> if (const SCEVConstant *Step =
> - dyn_cast<SCEVConstant>(AR->getStepRecurrence(*this)))
> - if (!Step->getValue()->getValue()
> - .urem(RHSC->getValue()->getValue())&&
> + dyn_cast<SCEVConstant>(AR->getStepRecurrence(*this))) {
> + // {X,+,N}/C --> {X/C,+,N/C} if safe and N/C can be folded.
> + const APInt&StepInt = Step->getValue()->getValue();
> + const APInt&DivInt = RHSC->getValue()->getValue();
> + if (!StepInt.urem(DivInt)&&
> getZeroExtendExpr(AR, ExtTy) ==
> getAddRecExpr(getZeroExtendExpr(AR->getStart(), ExtTy),
> getZeroExtendExpr(Step, ExtTy),
> @@ -2067,6 +2068,22 @@
> return getAddRecExpr(Operands, AR->getLoop(),
> SCEV::FlagNW);
> }
> + /// Get a canonical UDivExpr for a recurrence.
> + /// {X,+,N}/C => {Y,+,N}/C where Y=X-(X%N). Safe when C%N=0.
"//" not "///" so that this isn't a doxy-comment.
Nick
> + // We can currently only fold X%N if X is constant.
> + const SCEVConstant *StartC = dyn_cast<SCEVConstant>(AR->getStart());
> + if (StartC&& !DivInt.urem(StepInt)&&
> + getZeroExtendExpr(AR, ExtTy) ==
> + getAddRecExpr(getZeroExtendExpr(AR->getStart(), ExtTy),
> + getZeroExtendExpr(Step, ExtTy),
> + AR->getLoop(), SCEV::FlagAnyWrap)) {
> + const APInt&StartInt = StartC->getValue()->getValue();
> + const APInt&StartRem = StartInt.urem(StepInt);
> + if (StartRem != 0)
> + LHS = getAddRecExpr(getConstant(StartInt - StartRem), Step,
> + AR->getLoop(), SCEV::FlagNW);
> + }
> + }
> // (A*B)/C --> A*(B/C) if safe and B/C can be folded.
> if (const SCEVMulExpr *M = dyn_cast<SCEVMulExpr>(LHS)) {
> SmallVector<const SCEV *, 4> Operands;
>
> Modified: llvm/trunk/lib/Transforms/Scalar/IndVarSimplify.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/IndVarSimplify.cpp?rev=137013&r1=137012&r2=137013&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/Scalar/IndVarSimplify.cpp (original)
> +++ llvm/trunk/lib/Transforms/Scalar/IndVarSimplify.cpp Sat Aug 6 02:00:37 2011
> @@ -70,6 +70,7 @@
> STATISTIC(NumReplaced , "Number of exit values replaced");
> STATISTIC(NumLFTR , "Number of loop exit tests replaced");
> STATISTIC(NumElimIdentity, "Number of IV identities eliminated");
> +STATISTIC(NumElimOperand, "Number of IV operands folded into a use");
> STATISTIC(NumElimExt , "Number of IV sign/zero extends eliminated");
> STATISTIC(NumElimRem , "Number of IV remainder operations eliminated");
> STATISTIC(NumElimCmp , "Number of IV comparisons eliminated");
> @@ -142,6 +143,8 @@
> Value *IVOperand,
> bool IsSigned);
>
> + bool FoldIVUser(Instruction *UseInst, Instruction *IVOperand);
> +
> void SimplifyCongruentIVs(Loop *L);
>
> void RewriteIVExpressions(Loop *L, SCEVExpander&Rewriter);
> @@ -1298,6 +1301,66 @@
> return true;
> }
>
> +/// FoldIVUser - Fold an IV operand into its use. This removes increments of an
> +/// aligned IV when used by a instruction that ignores the low bits.
> +bool IndVarSimplify::FoldIVUser(Instruction *UseInst, Instruction *IVOperand) {
> + Value *IVSrc = 0;
> + unsigned OperIdx = 0;
> + const SCEV *FoldedExpr = 0;
> + switch (UseInst->getOpcode()) {
> + default:
> + return false;
> + case Instruction::UDiv:
> + case Instruction::LShr:
> + // We're only interested in the case where we know something about
> + // the numerator and have a constant denominator.
> + if (IVOperand != UseInst->getOperand(OperIdx) ||
> + !isa<ConstantInt>(UseInst->getOperand(1)))
> + return false;
> +
> + // Attempt to fold a binary operator with constant operand.
> + // e.g. ((I + 1)>> 2) => I>> 2
> + if (IVOperand->getNumOperands() != 2 ||
> + !isa<ConstantInt>(IVOperand->getOperand(1)))
> + return false;
> +
> + IVSrc = IVOperand->getOperand(0);
> + // IVSrc must be the (SCEVable) IV, since the other operand is const.
> + assert(SE->isSCEVable(IVSrc->getType())&& "Expect SCEVable IV operand");
> +
> + ConstantInt *D = cast<ConstantInt>(UseInst->getOperand(1));
> + if (UseInst->getOpcode() == Instruction::LShr) {
> + // Get a constant for the divisor. See createSCEV.
> + uint32_t BitWidth = cast<IntegerType>(UseInst->getType())->getBitWidth();
> + if (D->getValue().uge(BitWidth))
> + return false;
> +
> + D = ConstantInt::get(UseInst->getContext(),
> + APInt(BitWidth, 1).shl(D->getZExtValue()));
> + }
> + FoldedExpr = SE->getUDivExpr(SE->getSCEV(IVSrc), SE->getSCEV(D));
> + }
> + // We have something that might fold it's operand. Compare SCEVs.
> + if (!SE->isSCEVable(UseInst->getType()))
> + return false;
> +
> + // Bypass the operand if SCEV can prove it has no effect.
> + if (SE->getSCEV(UseInst) != FoldedExpr)
> + return false;
> +
> + DEBUG(dbgs()<< "INDVARS: Eliminated IV operand: "<< *IVOperand
> +<< " -> "<< *UseInst<< '\n');
> +
> + UseInst->setOperand(OperIdx, IVSrc);
> + assert(SE->getSCEV(UseInst) == FoldedExpr&& "bad SCEV with folded oper");
> +
> + ++NumElimOperand;
> + Changed = true;
> + if (IVOperand->use_empty())
> + DeadInsts.push_back(IVOperand);
> + return true;
> +}
> +
> /// pushIVUsers - Add all uses of Def to the current IV's worklist.
> ///
> static void pushIVUsers(
> @@ -1394,6 +1457,8 @@
> // Bypass back edges to avoid extra work.
> if (UseOper.first == CurrIV) continue;
>
> + FoldIVUser(UseOper.first, UseOper.second);
> +
> if (EliminateIVUser(UseOper.first, UseOper.second)) {
> pushIVUsers(UseOper.second, Simplified, SimpleIVUsers);
> continue;
>
> Added: llvm/trunk/test/Transforms/IndVarSimplify/iv-fold.ll
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Transforms/IndVarSimplify/iv-fold.ll?rev=137013&view=auto
> ==============================================================================
> --- llvm/trunk/test/Transforms/IndVarSimplify/iv-fold.ll (added)
> +++ llvm/trunk/test/Transforms/IndVarSimplify/iv-fold.ll Sat Aug 6 02:00:37 2011
> @@ -0,0 +1,56 @@
> +; RUN: opt< %s -indvars -disable-iv-rewrite -S | FileCheck %s
> +
> +target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n:32:64"
> +
> +; Indvars should be able to fold IV increments into shr when low bits are zero.
> +;
> +; CHECK: @foldIncShr
> +; CHECK: shr.1 = lshr i32 %0, 5
> +define i32 @foldIncShr(i32* %bitmap, i32 %bit_addr, i32 %nbits) nounwind {
> +entry:
> + br label %while.body
> +
> +while.body:
> + %0 = phi i32 [ 0, %entry ], [ %inc.2, %while.body ]
> + %shr = lshr i32 %0, 5
> + %arrayidx = getelementptr inbounds i32* %bitmap, i32 %shr
> + %tmp6 = load i32* %arrayidx, align 4
> + %inc.1 = add i32 %0, 1
> + %shr.1 = lshr i32 %inc.1, 5
> + %arrayidx.1 = getelementptr inbounds i32* %bitmap, i32 %shr.1
> + %tmp6.1 = load i32* %arrayidx.1, align 4
> + %inc.2 = add i32 %inc.1, 1
> + %exitcond.3 = icmp eq i32 %inc.2, 128
> + br i1 %exitcond.3, label %while.end, label %while.body
> +
> +while.end:
> + %r = add i32 %tmp6, %tmp6.1
> + ret i32 %r
> +}
> +
> +; Invdars should not fold an increment into shr unless 2^shiftBits is
> +; a multiple of the recurrence step.
> +;
> +; CHECK: @noFoldIncShr
> +; CHECK: shr.1 = lshr i32 %inc.1, 5
> +define i32 @noFoldIncShr(i32* %bitmap, i32 %bit_addr, i32 %nbits) nounwind {
> +entry:
> + br label %while.body
> +
> +while.body:
> + %0 = phi i32 [ 0, %entry ], [ %inc.3, %while.body ]
> + %shr = lshr i32 %0, 5
> + %arrayidx = getelementptr inbounds i32* %bitmap, i32 %shr
> + %tmp6 = load i32* %arrayidx, align 4
> + %inc.1 = add i32 %0, 1
> + %shr.1 = lshr i32 %inc.1, 5
> + %arrayidx.1 = getelementptr inbounds i32* %bitmap, i32 %shr.1
> + %tmp6.1 = load i32* %arrayidx.1, align 4
> + %inc.3 = add i32 %inc.1, 2
> + %exitcond.3 = icmp eq i32 %inc.3, 96
> + br i1 %exitcond.3, label %while.end, label %while.body
> +
> +while.end:
> + %r = add i32 %tmp6, %tmp6.1
> + ret i32 %r
> +}
>
>
> _______________________________________________
> 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