[llvm] r311789 - [InstCombine] Don't fall back to only calling computeKnownBits if the upper bit of Add/Sub is demanded.

[Andrew Adams via llvm-commits]

I have a buildbot breakage that started nearby this commit. This looks like
the most likely culprit. Bug report here:

https://bugs.llvm.org/show_bug.cgi?id=34349

- Andrew

On Fri, Aug 25, 2017 at 11:39 AM, Craig Topper via llvm-commits <
llvm-commits at lists.llvm.org> wrote:

> Author: ctopper
> Date: Fri Aug 25 11:39:40 2017
> New Revision: 311789
>
> URL: http://llvm.org/viewvc/llvm-project?rev=311789&view=rev
> Log:
> [InstCombine] Don't fall back to only calling computeKnownBits if the
> upper bit of Add/Sub is demanded.
>
> Just create an all 1s demanded mask and continue recursing like normal.
> The recursive calls should be able to handle an all 1s mask and do the
> right thing.
>
> The only time we should care about knowing whether the upper bit was
> demanded is when we need to know if we should clear the NSW/NUW flags.
>
> Now that we have a consistent path through the code for all cases, use
> KnownBits::computeForAddSub to compute the known bits at the end since we
> already have the LHS and RHS.
>
> My larger goal here is to move the code that turns add into xor if only 1
> bit is demanded and no bits below it are non-zero from
> InstCombiner::OptAndOp to here. This will allow it to be more general
> instead of just looking for 'add' and 'and' with constant RHS.
>
> Differential Revision: https://reviews.llvm.org/D36486
>
> Modified:
>     llvm/trunk/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp
>
> Modified: llvm/trunk/lib/Transforms/InstCombine/
> InstCombineSimplifyDemanded.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/
> Transforms/InstCombine/InstCombineSimplifyDemanded.
> cpp?rev=311789&r1=311788&r2=311789&view=diff
> ============================================================
> ==================
> --- llvm/trunk/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp
> (original)
> +++ llvm/trunk/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp
> Fri Aug 25 11:39:40 2017
> @@ -396,38 +396,39 @@ Value *InstCombiner::SimplifyDemandedUse
>      /// If the high-bits of an ADD/SUB are not demanded, then we do not
> care
>      /// about the high bits of the operands.
>      unsigned NLZ = DemandedMask.countLeadingZeros();
> -    if (NLZ > 0) {
> -      // Right fill the mask of bits for this ADD/SUB to demand the most
> -      // significant bit and all those below it.
> -      APInt DemandedFromOps(APInt::getLowBitsSet(BitWidth,
> BitWidth-NLZ));
> -      if (ShrinkDemandedConstant(I, 0, DemandedFromOps) ||
> -          SimplifyDemandedBits(I, 0, DemandedFromOps, LHSKnown, Depth +
> 1) ||
> -          ShrinkDemandedConstant(I, 1, DemandedFromOps) ||
> -          SimplifyDemandedBits(I, 1, DemandedFromOps, RHSKnown, Depth +
> 1)) {
> +    // Right fill the mask of bits for this ADD/SUB to demand the most
> +    // significant bit and all those below it.
> +    APInt DemandedFromOps(APInt::getLowBitsSet(BitWidth, BitWidth-NLZ));
> +    if (ShrinkDemandedConstant(I, 0, DemandedFromOps) ||
> +        SimplifyDemandedBits(I, 0, DemandedFromOps, LHSKnown, Depth + 1)
> ||
> +        ShrinkDemandedConstant(I, 1, DemandedFromOps) ||
> +        SimplifyDemandedBits(I, 1, DemandedFromOps, RHSKnown, Depth + 1))
> {
> +      if (NLZ > 0) {
>          // Disable the nsw and nuw flags here: We can no longer guarantee
> that
>          // we won't wrap after simplification. Removing the nsw/nuw flags
> is
>          // legal here because the top bit is not demanded.
>          BinaryOperator &BinOP = *cast<BinaryOperator>(I);
>          BinOP.setHasNoSignedWrap(false);
>          BinOP.setHasNoUnsignedWrap(false);
> -        return I;
>        }
> -
> -      // If we are known to be adding/subtracting zeros to every bit below
> -      // the highest demanded bit, we just return the other side.
> -      if (DemandedFromOps.isSubsetOf(RHSKnown.Zero))
> -        return I->getOperand(0);
> -      // We can't do this with the LHS for subtraction, unless we are only
> -      // demanding the LSB.
> -      if ((I->getOpcode() == Instruction::Add ||
> -           DemandedFromOps.isOneValue()) &&
> -          DemandedFromOps.isSubsetOf(LHSKnown.Zero))
> -        return I->getOperand(1);
> +      return I;
>      }
>
> -    // Otherwise just hand the add/sub off to computeKnownBits to fill in
> -    // the known zeros and ones.
> -    computeKnownBits(V, Known, Depth, CxtI);
> +    // If we are known to be adding/subtracting zeros to every bit below
> +    // the highest demanded bit, we just return the other side.
> +    if (DemandedFromOps.isSubsetOf(RHSKnown.Zero))
> +      return I->getOperand(0);
> +    // We can't do this with the LHS for subtraction, unless we are only
> +    // demanding the LSB.
> +    if ((I->getOpcode() == Instruction::Add ||
> +         DemandedFromOps.isOneValue()) &&
> +        DemandedFromOps.isSubsetOf(LHSKnown.Zero))
> +      return I->getOperand(1);
> +
> +    // Otherwise just compute the known bits of the result.
> +    bool NSW = cast<OverflowingBinaryOperator>(I)->hasNoUnsignedWrap();
> +    Known = KnownBits::computeForAddSub(I->getOpcode() ==
> Instruction::Add,
> +                                        NSW, LHSKnown, RHSKnown);
>      break;
>    }
>    case Instruction::Shl: {
>
>
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at lists.llvm.org
> http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-commits
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-commits/attachments/20170828/3bd07ac5/attachment.html>