[llvm] r335258 - [InstCombine] simplify binops before trying other folds
Mikhail Zolotukhin via llvm-commits
llvm-commits at lists.llvm.org
Fri Jul 13 12:40:51 PDT 2018
It works, thanks!
Michael
> On Jul 12, 2018, at 6:28 PM, Sanjay Patel <spatel at rotateright.com> wrote:
>
> This should fix it:
> https://reviews.llvm.org/rL336965 <https://reviews.llvm.org/rL336965>
>
> On Thu, Jul 12, 2018 at 7:03 PM, Michael Zolotukhin <mzolotukhin at apple.com <mailto:mzolotukhin at apple.com>> wrote:
> Great, thank you!
>
> Michael
>
>
>> On Jul 12, 2018, at 5:56 PM, Sanjay Patel <spatel at rotateright.com <mailto:spatel at rotateright.com>> wrote:
>>
>> I'll post a fix soon. Running tests locally to make sure I didn't break anything else!
>>
>> On Thu, Jul 12, 2018 at 6:31 PM, Michael Zolotukhin <mzolotukhin at apple.com <mailto:mzolotukhin at apple.com>> wrote:
>>
>>
>>> On Jul 12, 2018, at 5:19 PM, Sanjay Patel <spatel at rotateright.com <mailto:spatel at rotateright.com>> wrote:
>>>
>>> Thanks for letting me know. Not sure how it would've changed, but I'll take a look.
>>>
>>> I see that bugpoint doesn't reduce this further. Any chance that you did that manually?
>> Yeah, I’ve already run it through bugpoint. I didn’t try to reduce it further, but in the debugger I saw the following scenario:
>> (lldb) p CxtI.dump()
>> %C3 = and i1 %C7, %C5
>> (lldb) p LHS->dump()
>> %C7 = icmp slt i16 %L7, 0
>> (lldb) p RHS->dump()
>> %C5 = icmp slt i16 %L7, 1
>>
>> And then we abort in the switch on PredL where we don’t have a handler for PredL=SLT. Maybe it’s been relying on some canonicalization which no longer happens?
>>
>> Thanks,
>> Michael
>>
>>>
>>> My first guess is that we are missing something in InstSimplify because InstCombine is assuming the easy combination of cmps are already gone.
>>>
>>> On Thu, Jul 12, 2018 at 3:52 PM, Mikhail Zolotukhin <mzolotukhin at apple.com <mailto:mzolotukhin at apple.com>> wrote:
>>> Hi Sanjay,
>>>
>>> Our fuzzer-bot detected a failure after this change. Here is a reproducer:
>>>
>>> $ cat fuzz.ll
>>> source_filename = "M"
>>> target triple = "x86_64-apple-darwin17.6.0"
>>>
>>> define void @f() {
>>> BB:
>>> %A8 = alloca i16
>>> %L7 = load i16, i16* %A8
>>> %G21 = getelementptr i16, i16* %A8, i8 -1
>>> %B11 = udiv i16 %L7, -1
>>> %G4 = getelementptr i16, i16* %A8, i16 %B11
>>> %L2 = load i16, i16* %G4
>>> %L = load i16, i16* %G4
>>> %B23 = mul i16 %B11, %B11
>>> %L4 = load i16, i16* %A8
>>> %B21 = sdiv i16 %L7, %L4
>>> %B7 = sub i16 0, %B21
>>> %B18 = mul i16 %B23, %B7
>>> %C10 = icmp ugt i16 %L, %B11
>>> %B20 = and i16 %L7, %L2
>>> %B1 = mul i1 %C10, true
>>> %C5 = icmp sle i16 %B21, %L
>>> %C11 = icmp ule i16 %B21, %L
>>> %C7 = icmp slt i16 %B20, 0
>>> %B29 = srem i16 %L4, %B18
>>> %B15 = add i1 %C7, %C10
>>> %B19 = add i1 %C11, %B15
>>> %C6 = icmp sge i1 %C11, %B19
>>> %B33 = or i16 %B29, %L4
>>> %C13 = icmp uge i1 %C5, %B1
>>> %C3 = icmp ult i1 %C13, %C6
>>> store i16 undef, i16* %G21
>>> %C18 = icmp ule i1 %C10, %C7
>>> %G26 = getelementptr i1, i1* null, i1 %C3
>>> store i16 %B33, i16* undef
>>> store i1 %C18, i1* undef
>>> store i1* %G26, i1** undef
>>> ret void
>>> }
>>>
>>> $ bin/opt -instcombine fuzz.ll -disable-output
>>> Unknown integer condition code!
>>> UNREACHABLE executed at /Users/mvzolotu/devel/mono/llvm-project/llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp:1034!
>>>
>>> I took a look at the code of foldAndOfICmps, and indeed we don’t have a code to handle %I1=%X < 0, %I2=%X < 1, %I3 = %I1 && %I2.
>>> What would be the best way to handle it (and why didn’t we hit it before)?
>>>
>>> Thanks,
>>> Michael
>>>
>>>> On Jun 21, 2018, at 10:06 AM, Sanjay Patel via llvm-commits <llvm-commits at lists.llvm.org <mailto:llvm-commits at lists.llvm.org>> wrote:
>>>>
>>>> Author: spatel
>>>> Date: Thu Jun 21 10:06:36 2018
>>>> New Revision: 335258
>>>>
>>>> URL: http://llvm.org/viewvc/llvm-project?rev=335258&view=rev <http://llvm.org/viewvc/llvm-project?rev=335258&view=rev>
>>>> Log:
>>>> [InstCombine] simplify binops before trying other folds
>>>>
>>>> This is outwardly NFC from what I can tell, but it should be more efficient
>>>> to simplify first (despite the name, SimplifyAssociativeOrCommutative does
>>>> not actually simplify as InstSimplify does - it creates/morphs instructions).
>>>>
>>>> This should make it easier to refactor duplicated code that runs for all binops.
>>>>
>>>> Modified:
>>>> llvm/trunk/lib/Transforms/InstCombine/InstCombineAddSub.cpp
>>>> llvm/trunk/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp
>>>> llvm/trunk/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp
>>>> llvm/trunk/lib/Transforms/InstCombine/InstCombineShifts.cpp
>>>>
>>>> Modified: llvm/trunk/lib/Transforms/InstCombine/InstCombineAddSub.cpp
>>>> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/InstCombine/InstCombineAddSub.cpp?rev=335258&r1=335257&r2=335258&view=diff <http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/InstCombine/InstCombineAddSub.cpp?rev=335258&r1=335257&r2=335258&view=diff>
>>>> ==============================================================================
>>>> --- llvm/trunk/lib/Transforms/InstCombine/InstCombineAddSub.cpp (original)
>>>> +++ llvm/trunk/lib/Transforms/InstCombine/InstCombineAddSub.cpp Thu Jun 21 10:06:36 2018
>>>> @@ -1121,13 +1121,12 @@ static Instruction *canonicalizeLowbitMa
>>>> }
>>>>
>>>> Instruction *InstCombiner::visitAdd(BinaryOperator &I) {
>>>> - bool Changed = SimplifyAssociativeOrCommutative(I);
>>>> - Value *LHS = I.getOperand(0), *RHS = I.getOperand(1);
>>>> - if (Value *V =
>>>> - SimplifyAddInst(LHS, RHS, I.hasNoSignedWrap(), I.hasNoUnsignedWrap(),
>>>> - SQ.getWithInstruction(&I)))
>>>> + if (Value *V = SimplifyAddInst(I.getOperand(0), I.getOperand(1),
>>>> + I.hasNoSignedWrap(), I.hasNoUnsignedWrap(),
>>>> + SQ.getWithInstruction(&I)))
>>>> return replaceInstUsesWith(I, V);
>>>>
>>>> + bool Changed = SimplifyAssociativeOrCommutative(I);
>>>> if (Instruction *X = foldShuffledBinop(I))
>>>> return X;
>>>>
>>>> @@ -1140,6 +1139,7 @@ Instruction *InstCombiner::visitAdd(Bina
>>>>
>>>> // FIXME: This should be moved into the above helper function to allow these
>>>> // transforms for general constant or constant splat vectors.
>>>> + Value *LHS = I.getOperand(0), *RHS = I.getOperand(1);
>>>> Type *Ty = I.getType();
>>>> if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) {
>>>> Value *XorLHS = nullptr; ConstantInt *XorRHS = nullptr;
>>>> @@ -1378,18 +1378,19 @@ Instruction *InstCombiner::visitAdd(Bina
>>>> }
>>>>
>>>> Instruction *InstCombiner::visitFAdd(BinaryOperator &I) {
>>>> - bool Changed = SimplifyAssociativeOrCommutative(I);
>>>> - Value *LHS = I.getOperand(0), *RHS = I.getOperand(1);
>>>> - if (Value *V = SimplifyFAddInst(LHS, RHS, I.getFastMathFlags(),
>>>> + if (Value *V = SimplifyFAddInst(I.getOperand(0), I.getOperand(1),
>>>> + I.getFastMathFlags(),
>>>> SQ.getWithInstruction(&I)))
>>>> return replaceInstUsesWith(I, V);
>>>>
>>>> + bool Changed = SimplifyAssociativeOrCommutative(I);
>>>> if (Instruction *X = foldShuffledBinop(I))
>>>> return X;
>>>>
>>>> if (Instruction *FoldedFAdd = foldBinOpIntoSelectOrPhi(I))
>>>> return FoldedFAdd;
>>>>
>>>> + Value *LHS = I.getOperand(0), *RHS = I.getOperand(1);
>>>> Value *X;
>>>> // (-X) + Y --> Y - X
>>>> if (match(LHS, m_FNeg(m_Value(X))))
>>>> @@ -1555,10 +1556,9 @@ Value *InstCombiner::OptimizePointerDiff
>>>> }
>>>>
>>>> Instruction *InstCombiner::visitSub(BinaryOperator &I) {
>>>> - Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
>>>> - if (Value *V =
>>>> - SimplifySubInst(Op0, Op1, I.hasNoSignedWrap(), I.hasNoUnsignedWrap(),
>>>> - SQ.getWithInstruction(&I)))
>>>> + if (Value *V = SimplifySubInst(I.getOperand(0), I.getOperand(1),
>>>> + I.hasNoSignedWrap(), I.hasNoUnsignedWrap(),
>>>> + SQ.getWithInstruction(&I)))
>>>> return replaceInstUsesWith(I, V);
>>>>
>>>> if (Instruction *X = foldShuffledBinop(I))
>>>> @@ -1569,6 +1569,7 @@ Instruction *InstCombiner::visitSub(Bina
>>>> return replaceInstUsesWith(I, V);
>>>>
>>>> // If this is a 'B = x-(-A)', change to B = x+A.
>>>> + Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
>>>> if (Value *V = dyn_castNegVal(Op1)) {
>>>> BinaryOperator *Res = BinaryOperator::CreateAdd(Op0, V);
>>>>
>>>> @@ -1808,8 +1809,8 @@ Instruction *InstCombiner::visitSub(Bina
>>>> }
>>>>
>>>> Instruction *InstCombiner::visitFSub(BinaryOperator &I) {
>>>> - Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
>>>> - if (Value *V = SimplifyFSubInst(Op0, Op1, I.getFastMathFlags(),
>>>> + if (Value *V = SimplifyFSubInst(I.getOperand(0), I.getOperand(1),
>>>> + I.getFastMathFlags(),
>>>> SQ.getWithInstruction(&I)))
>>>> return replaceInstUsesWith(I, V);
>>>>
>>>> @@ -1818,6 +1819,7 @@ Instruction *InstCombiner::visitFSub(Bin
>>>>
>>>> // Subtraction from -0.0 is the canonical form of fneg.
>>>> // fsub nsz 0, X ==> fsub nsz -0.0, X
>>>> + Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
>>>> if (I.hasNoSignedZeros() && match(Op0, m_PosZeroFP()))
>>>> return BinaryOperator::CreateFNegFMF(Op1, &I);
>>>>
>>>>
>>>> Modified: llvm/trunk/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp
>>>> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp?rev=335258&r1=335257&r2=335258&view=diff <http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp?rev=335258&r1=335257&r2=335258&view=diff>
>>>> ==============================================================================
>>>> --- llvm/trunk/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp (original)
>>>> +++ llvm/trunk/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp Thu Jun 21 10:06:36 2018
>>>> @@ -1401,11 +1401,11 @@ Instruction *InstCombiner::narrowMaskedB
>>>> // here. We should standardize that construct where it is needed or choose some
>>>> // other way to ensure that commutated variants of patterns are not missed.
>>>> Instruction *InstCombiner::visitAnd(BinaryOperator &I) {
>>>> - bool Changed = SimplifyAssociativeOrCommutative(I);
>>>> - Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
>>>> - if (Value *V = SimplifyAndInst(Op0, Op1, SQ.getWithInstruction(&I)))
>>>> + if (Value *V = SimplifyAndInst(I.getOperand(0), I.getOperand(1),
>>>> + SQ.getWithInstruction(&I)))
>>>> return replaceInstUsesWith(I, V);
>>>>
>>>> + bool Changed = SimplifyAssociativeOrCommutative(I);
>>>> if (Instruction *X = foldShuffledBinop(I))
>>>> return X;
>>>>
>>>> @@ -1425,6 +1425,7 @@ Instruction *InstCombiner::visitAnd(Bina
>>>> if (Value *V = SimplifyBSwap(I, Builder))
>>>> return replaceInstUsesWith(I, V);
>>>>
>>>> + Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
>>>> const APInt *C;
>>>> if (match(Op1, m_APInt(C))) {
>>>> Value *X, *Y;
>>>> @@ -2015,11 +2016,11 @@ Value *InstCombiner::foldOrOfICmps(ICmpI
>>>> // here. We should standardize that construct where it is needed or choose some
>>>> // other way to ensure that commutated variants of patterns are not missed.
>>>> Instruction *InstCombiner::visitOr(BinaryOperator &I) {
>>>> - bool Changed = SimplifyAssociativeOrCommutative(I);
>>>> - Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
>>>> - if (Value *V = SimplifyOrInst(Op0, Op1, SQ.getWithInstruction(&I)))
>>>> + if (Value *V = SimplifyOrInst(I.getOperand(0), I.getOperand(1),
>>>> + SQ.getWithInstruction(&I)))
>>>> return replaceInstUsesWith(I, V);
>>>>
>>>> + bool Changed = SimplifyAssociativeOrCommutative(I);
>>>> if (Instruction *X = foldShuffledBinop(I))
>>>> return X;
>>>>
>>>> @@ -2046,6 +2047,7 @@ Instruction *InstCombiner::visitOr(Binar
>>>> if (Instruction *BSwap = MatchBSwap(I))
>>>> return BSwap;
>>>>
>>>> + Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
>>>> {
>>>> Value *A;
>>>> const APInt *C;
>>>> @@ -2468,11 +2470,11 @@ static Instruction *visitMaskedMerge(Bin
>>>> // here. We should standardize that construct where it is needed or choose some
>>>> // other way to ensure that commutated variants of patterns are not missed.
>>>> Instruction *InstCombiner::visitXor(BinaryOperator &I) {
>>>> - bool Changed = SimplifyAssociativeOrCommutative(I);
>>>> - Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
>>>> - if (Value *V = SimplifyXorInst(Op0, Op1, SQ.getWithInstruction(&I)))
>>>> + if (Value *V = SimplifyXorInst(I.getOperand(0), I.getOperand(1),
>>>> + SQ.getWithInstruction(&I)))
>>>> return replaceInstUsesWith(I, V);
>>>>
>>>> + bool Changed = SimplifyAssociativeOrCommutative(I);
>>>> if (Instruction *X = foldShuffledBinop(I))
>>>> return X;
>>>>
>>>> @@ -2492,6 +2494,7 @@ Instruction *InstCombiner::visitXor(Bina
>>>> return replaceInstUsesWith(I, V);
>>>>
>>>> // A^B --> A|B iff A and B have no bits set in common.
>>>> + Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
>>>> if (haveNoCommonBitsSet(Op0, Op1, DL, &AC, &I, &DT))
>>>> return BinaryOperator::CreateOr(Op0, Op1);
>>>>
>>>>
>>>> Modified: llvm/trunk/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp
>>>> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp?rev=335258&r1=335257&r2=335258&view=diff <http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp?rev=335258&r1=335257&r2=335258&view=diff>
>>>> ==============================================================================
>>>> --- llvm/trunk/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp (original)
>>>> +++ llvm/trunk/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp Thu Jun 21 10:06:36 2018
>>>> @@ -126,11 +126,11 @@ static Constant *getLogBase2(Type *Ty, C
>>>> }
>>>>
>>>> Instruction *InstCombiner::visitMul(BinaryOperator &I) {
>>>> - bool Changed = SimplifyAssociativeOrCommutative(I);
>>>> - Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
>>>> - if (Value *V = SimplifyMulInst(Op0, Op1, SQ.getWithInstruction(&I)))
>>>> + if (Value *V = SimplifyMulInst(I.getOperand(0), I.getOperand(1),
>>>> + SQ.getWithInstruction(&I)))
>>>> return replaceInstUsesWith(I, V);
>>>>
>>>> + bool Changed = SimplifyAssociativeOrCommutative(I);
>>>> if (Instruction *X = foldShuffledBinop(I))
>>>> return X;
>>>>
>>>> @@ -138,6 +138,7 @@ Instruction *InstCombiner::visitMul(Bina
>>>> return replaceInstUsesWith(I, V);
>>>>
>>>> // X * -1 == 0 - X
>>>> + Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
>>>> if (match(Op1, m_AllOnes())) {
>>>> BinaryOperator *BO = BinaryOperator::CreateNeg(Op0, I.getName());
>>>> if (I.hasNoSignedWrap())
>>>> @@ -406,12 +407,12 @@ Instruction *InstCombiner::visitMul(Bina
>>>> }
>>>>
>>>> Instruction *InstCombiner::visitFMul(BinaryOperator &I) {
>>>> - bool Changed = SimplifyAssociativeOrCommutative(I);
>>>> - Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
>>>> - if (Value *V = SimplifyFMulInst(Op0, Op1, I.getFastMathFlags(),
>>>> + if (Value *V = SimplifyFMulInst(I.getOperand(0), I.getOperand(1),
>>>> + I.getFastMathFlags(),
>>>> SQ.getWithInstruction(&I)))
>>>> return replaceInstUsesWith(I, V);
>>>>
>>>> + bool Changed = SimplifyAssociativeOrCommutative(I);
>>>> if (Instruction *X = foldShuffledBinop(I))
>>>> return X;
>>>>
>>>> @@ -419,6 +420,7 @@ Instruction *InstCombiner::visitFMul(Bin
>>>> return FoldedMul;
>>>>
>>>> // X * -1.0 --> -X
>>>> + Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
>>>> if (match(Op1, m_SpecificFP(-1.0)))
>>>> return BinaryOperator::CreateFNegFMF(Op0, &I);
>>>>
>>>> @@ -936,8 +938,8 @@ static Instruction *narrowUDivURem(Binar
>>>> }
>>>>
>>>> Instruction *InstCombiner::visitUDiv(BinaryOperator &I) {
>>>> - Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
>>>> - if (Value *V = SimplifyUDivInst(Op0, Op1, SQ.getWithInstruction(&I)))
>>>> + if (Value *V = SimplifyUDivInst(I.getOperand(0), I.getOperand(1),
>>>> + SQ.getWithInstruction(&I)))
>>>> return replaceInstUsesWith(I, V);
>>>>
>>>> if (Instruction *X = foldShuffledBinop(I))
>>>> @@ -948,6 +950,7 @@ Instruction *InstCombiner::visitUDiv(Bin
>>>> return Common;
>>>>
>>>> // (x lshr C1) udiv C2 --> x udiv (C2 << C1)
>>>> + Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
>>>> {
>>>> Value *X;
>>>> const APInt *C1, *C2;
>>>> @@ -1004,8 +1007,8 @@ Instruction *InstCombiner::visitUDiv(Bin
>>>> }
>>>>
>>>> Instruction *InstCombiner::visitSDiv(BinaryOperator &I) {
>>>> - Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
>>>> - if (Value *V = SimplifySDivInst(Op0, Op1, SQ.getWithInstruction(&I)))
>>>> + if (Value *V = SimplifySDivInst(I.getOperand(0), I.getOperand(1),
>>>> + SQ.getWithInstruction(&I)))
>>>> return replaceInstUsesWith(I, V);
>>>>
>>>> if (Instruction *X = foldShuffledBinop(I))
>>>> @@ -1015,6 +1018,7 @@ Instruction *InstCombiner::visitSDiv(Bin
>>>> if (Instruction *Common = commonIDivTransforms(I))
>>>> return Common;
>>>>
>>>> + Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
>>>> const APInt *Op1C;
>>>> if (match(Op1, m_APInt(Op1C))) {
>>>> // sdiv X, -1 == -X
>>>> @@ -1147,8 +1151,8 @@ static Instruction *foldFDivConstantDivi
>>>> }
>>>>
>>>> Instruction *InstCombiner::visitFDiv(BinaryOperator &I) {
>>>> - Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
>>>> - if (Value *V = SimplifyFDivInst(Op0, Op1, I.getFastMathFlags(),
>>>> + if (Value *V = SimplifyFDivInst(I.getOperand(0), I.getOperand(1),
>>>> + I.getFastMathFlags(),
>>>> SQ.getWithInstruction(&I)))
>>>> return replaceInstUsesWith(I, V);
>>>>
>>>> @@ -1161,6 +1165,7 @@ Instruction *InstCombiner::visitFDiv(Bin
>>>> if (Instruction *R = foldFDivConstantDividend(I))
>>>> return R;
>>>>
>>>> + Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
>>>> if (isa<Constant>(Op0))
>>>> if (SelectInst *SI = dyn_cast<SelectInst>(Op1))
>>>> if (Instruction *R = FoldOpIntoSelect(I, SI))
>>>> @@ -1276,8 +1281,8 @@ Instruction *InstCombiner::commonIRemTra
>>>> }
>>>>
>>>> Instruction *InstCombiner::visitURem(BinaryOperator &I) {
>>>> - Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
>>>> - if (Value *V = SimplifyURemInst(Op0, Op1, SQ.getWithInstruction(&I)))
>>>> + if (Value *V = SimplifyURemInst(I.getOperand(0), I.getOperand(1),
>>>> + SQ.getWithInstruction(&I)))
>>>> return replaceInstUsesWith(I, V);
>>>>
>>>> if (Instruction *X = foldShuffledBinop(I))
>>>> @@ -1290,6 +1295,7 @@ Instruction *InstCombiner::visitURem(Bin
>>>> return NarrowRem;
>>>>
>>>> // X urem Y -> X and Y-1, where Y is a power of 2,
>>>> + Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
>>>> if (isKnownToBeAPowerOfTwo(Op1, /*OrZero*/ true, 0, &I)) {
>>>> Constant *N1 = Constant::getAllOnesValue(I.getType());
>>>> Value *Add = Builder.CreateAdd(Op1, N1);
>>>> @@ -1314,8 +1320,8 @@ Instruction *InstCombiner::visitURem(Bin
>>>> }
>>>>
>>>> Instruction *InstCombiner::visitSRem(BinaryOperator &I) {
>>>> - Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
>>>> - if (Value *V = SimplifySRemInst(Op0, Op1, SQ.getWithInstruction(&I)))
>>>> + if (Value *V = SimplifySRemInst(I.getOperand(0), I.getOperand(1),
>>>> + SQ.getWithInstruction(&I)))
>>>> return replaceInstUsesWith(I, V);
>>>>
>>>> if (Instruction *X = foldShuffledBinop(I))
>>>> @@ -1325,6 +1331,7 @@ Instruction *InstCombiner::visitSRem(Bin
>>>> if (Instruction *Common = commonIRemTransforms(I))
>>>> return Common;
>>>>
>>>> + Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
>>>> {
>>>> const APInt *Y;
>>>> // X % -Y -> X % Y
>>>> @@ -1386,8 +1393,8 @@ Instruction *InstCombiner::visitSRem(Bin
>>>> }
>>>>
>>>> Instruction *InstCombiner::visitFRem(BinaryOperator &I) {
>>>> - Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
>>>> - if (Value *V = SimplifyFRemInst(Op0, Op1, I.getFastMathFlags(),
>>>> + if (Value *V = SimplifyFRemInst(I.getOperand(0), I.getOperand(1),
>>>> + I.getFastMathFlags(),
>>>> SQ.getWithInstruction(&I)))
>>>> return replaceInstUsesWith(I, V);
>>>>
>>>>
>>>> Modified: llvm/trunk/lib/Transforms/InstCombine/InstCombineShifts.cpp
>>>> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/InstCombine/InstCombineShifts.cpp?rev=335258&r1=335257&r2=335258&view=diff <http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/InstCombine/InstCombineShifts.cpp?rev=335258&r1=335257&r2=335258&view=diff>
>>>> ==============================================================================
>>>> --- llvm/trunk/lib/Transforms/InstCombine/InstCombineShifts.cpp (original)
>>>> +++ llvm/trunk/lib/Transforms/InstCombine/InstCombineShifts.cpp Thu Jun 21 10:06:36 2018
>>>> @@ -588,10 +588,9 @@ Instruction *InstCombiner::FoldShiftByCo
>>>> }
>>>>
>>>> Instruction *InstCombiner::visitShl(BinaryOperator &I) {
>>>> - Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
>>>> - if (Value *V =
>>>> - SimplifyShlInst(Op0, Op1, I.hasNoSignedWrap(), I.hasNoUnsignedWrap(),
>>>> - SQ.getWithInstruction(&I)))
>>>> + if (Value *V = SimplifyShlInst(I.getOperand(0), I.getOperand(1),
>>>> + I.hasNoSignedWrap(), I.hasNoUnsignedWrap(),
>>>> + SQ.getWithInstruction(&I)))
>>>> return replaceInstUsesWith(I, V);
>>>>
>>>> if (Instruction *X = foldShuffledBinop(I))
>>>> @@ -600,11 +599,12 @@ Instruction *InstCombiner::visitShl(Bina
>>>> if (Instruction *V = commonShiftTransforms(I))
>>>> return V;
>>>>
>>>> + Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
>>>> Type *Ty = I.getType();
>>>> const APInt *ShAmtAPInt;
>>>> if (match(Op1, m_APInt(ShAmtAPInt))) {
>>>> unsigned ShAmt = ShAmtAPInt->getZExtValue();
>>>> - unsigned BitWidth = I.getType()->getScalarSizeInBits();
>>>> + unsigned BitWidth = Ty->getScalarSizeInBits();
>>>>
>>>> // shl (zext X), ShAmt --> zext (shl X, ShAmt)
>>>> // This is only valid if X would have zeros shifted out.
>>>> @@ -693,9 +693,8 @@ Instruction *InstCombiner::visitShl(Bina
>>>> }
>>>>
>>>> Instruction *InstCombiner::visitLShr(BinaryOperator &I) {
>>>> - Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
>>>> - if (Value *V =
>>>> - SimplifyLShrInst(Op0, Op1, I.isExact(), SQ.getWithInstruction(&I)))
>>>> + if (Value *V = SimplifyLShrInst(I.getOperand(0), I.getOperand(1), I.isExact(),
>>>> + SQ.getWithInstruction(&I)))
>>>> return replaceInstUsesWith(I, V);
>>>>
>>>> if (Instruction *X = foldShuffledBinop(I))
>>>> @@ -704,6 +703,7 @@ Instruction *InstCombiner::visitLShr(Bin
>>>> if (Instruction *R = commonShiftTransforms(I))
>>>> return R;
>>>>
>>>> + Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
>>>> Type *Ty = I.getType();
>>>> const APInt *ShAmtAPInt;
>>>> if (match(Op1, m_APInt(ShAmtAPInt))) {
>>>> @@ -821,9 +821,8 @@ Instruction *InstCombiner::visitLShr(Bin
>>>> }
>>>>
>>>> Instruction *InstCombiner::visitAShr(BinaryOperator &I) {
>>>> - Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
>>>> - if (Value *V =
>>>> - SimplifyAShrInst(Op0, Op1, I.isExact(), SQ.getWithInstruction(&I)))
>>>> + if (Value *V = SimplifyAShrInst(I.getOperand(0), I.getOperand(1), I.isExact(),
>>>> + SQ.getWithInstruction(&I)))
>>>> return replaceInstUsesWith(I, V);
>>>>
>>>> if (Instruction *X = foldShuffledBinop(I))
>>>> @@ -832,6 +831,7 @@ Instruction *InstCombiner::visitAShr(Bin
>>>> if (Instruction *R = commonShiftTransforms(I))
>>>> return R;
>>>>
>>>> + Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
>>>> Type *Ty = I.getType();
>>>> unsigned BitWidth = Ty->getScalarSizeInBits();
>>>> const APInt *ShAmtAPInt;
>>>>
>>>>
>>>> _______________________________________________
>>>> llvm-commits mailing list
>>>> llvm-commits at lists.llvm.org <mailto:llvm-commits at lists.llvm.org>
>>>> http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-commits <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/20180713/7b65a60a/attachment.html>
More information about the llvm-commits
mailing list