From 73e3709b2ce8721e36c8113ff7abb01e5bd6e69c Mon Sep 17 00:00:00 2001 From: Dinesh Dwivedi Date: Fri, 27 Jun 2014 07:47:35 +0000 Subject: [PATCH] Added instruction combine to transform few more negative values addition to subtraction (Part 3) This patch enables transforms for (x + (~(y | c) + 1) --> x - (y | c) if c is odd Differential Revision: http://reviews.llvm.org/D4210 llvm-svn: 211881 --- .../InstCombine/InstCombineAddSub.cpp | 98 +++++++++-------- test/Transforms/InstCombine/add2.ll | 101 +++++++++++------- 2 files changed, 121 insertions(+), 78 deletions(-) diff --git a/lib/Transforms/InstCombine/InstCombineAddSub.cpp b/lib/Transforms/InstCombine/InstCombineAddSub.cpp index 6aede84a352..f8d7e0ecf44 100644 --- a/lib/Transforms/InstCombine/InstCombineAddSub.cpp +++ b/lib/Transforms/InstCombine/InstCombineAddSub.cpp @@ -954,56 +954,70 @@ bool InstCombiner::WillNotOverflowUnsignedAdd(Value *LHS, Value *RHS) { return true; return false; - } +} // Checks if any operand is negative and we can convert add to sub. - // This function checks for following negative patterns - // ADD(XOR(OR(Z, NOT(C)), C)), 1) == NEG(AND(Z, C)) - // ADD(XOR(AND(Z, C), C), 1) == NEG(OR(Z, ~C)) if C is odd - // TODO: XOR(AND(Z, C), (C + 1)) == NEG(OR(Z, ~C)) if C is even - Value *checkForNegativeOperand(BinaryOperator &I, - InstCombiner::BuilderTy *Builder) { - Value *LHS = I.getOperand(0), *RHS = I.getOperand(1); +// This function checks for following negative patterns +// ADD(XOR(OR(Z, NOT(C)), C)), 1) == NEG(AND(Z, C)) +// ADD(XOR(AND(Z, C), C), 1) == NEG(OR(Z, ~C)) +// XOR(AND(Z, C), (C + 1)) == NEG(OR(Z, ~C)) if C is even +Value *checkForNegativeOperand(BinaryOperator &I, + InstCombiner::BuilderTy *Builder) { + Value *LHS = I.getOperand(0), *RHS = I.getOperand(1); - // This function creates 2 instructions to replace ADD, we need at least one - // of LHS or RHS to have one use to ensure benefit in transform. - if (!LHS->hasOneUse() && !RHS->hasOneUse()) - return nullptr; + // This function creates 2 instructions to replace ADD, we need at least one + // of LHS or RHS to have one use to ensure benefit in transform. + if (!LHS->hasOneUse() && !RHS->hasOneUse()) + return nullptr; - Value *X = nullptr, *Y = nullptr, *Z = nullptr; - const APInt *C1 = nullptr, *C2 = nullptr; + Value *X = nullptr, *Y = nullptr, *Z = nullptr; + const APInt *C1 = nullptr, *C2 = nullptr; - // if ONE is on other side, swap - if (match(RHS, m_Add(m_Value(X), m_One()))) - std::swap(LHS, RHS); + // if ONE is on other side, swap + if (match(RHS, m_Add(m_Value(X), m_One()))) + std::swap(LHS, RHS); - if (match(LHS, m_Add(m_Value(X), m_One()))) { - // if XOR on other side, swap - if (match(RHS, m_Xor(m_Value(Y), m_APInt(C1)))) - std::swap(X, RHS); + if (match(LHS, m_Add(m_Value(X), m_One()))) { + // if XOR on other side, swap + if (match(RHS, m_Xor(m_Value(Y), m_APInt(C1)))) + std::swap(X, RHS); - if (match(X, m_Xor(m_Value(Y), m_APInt(C1)))) { - // X = XOR(Y, C1), Y = OR(Z, C2), C2 = NOT(C1) ==> X == NOT(AND(Z, C1)) - // ADD(ADD(X, 1), RHS) == ADD(X, ADD(RHS, 1)) == SUB(RHS, AND(Z, C1)) - if (match(Y, m_Or(m_Value(Z), m_APInt(C2))) && (*C2 == ~(*C1))) { - Value *NewAnd = Builder->CreateAnd(Z, *C1); - return Builder->CreateSub(RHS, NewAnd, "sub"); - } else if (C1->countTrailingZeros() == 0) { - // if C1 is ODD and - // X = XOR(Y, C1), Y = AND(Z, C2), C2 == C1 ==> X == NOT(OR(Z, ~C1)) - // ADD(ADD(X, 1), RHS) == ADD(X, ADD(RHS, 1)) == SUB(RHS, OR(Z, ~C1)) - if (match(Y, m_And(m_Value(Z), m_APInt(C2))) && (*C1 == *C2)) { - Value *NewOr = Builder->CreateOr(Z, ~(*C1)); - return Builder->CreateSub(RHS, NewOr, "sub"); - } - } - } - } + if (match(X, m_Xor(m_Value(Y), m_APInt(C1)))) { + // X = XOR(Y, C1), Y = OR(Z, C2), C2 = NOT(C1) ==> X == NOT(AND(Z, C1)) + // ADD(ADD(X, 1), RHS) == ADD(X, ADD(RHS, 1)) == SUB(RHS, AND(Z, C1)) + if (match(Y, m_Or(m_Value(Z), m_APInt(C2))) && (*C2 == ~(*C1))) { + Value *NewAnd = Builder->CreateAnd(Z, *C1); + return Builder->CreateSub(RHS, NewAnd, "sub"); + } else if (match(Y, m_And(m_Value(Z), m_APInt(C2))) && (*C1 == *C2)) { + // X = XOR(Y, C1), Y = AND(Z, C2), C2 == C1 ==> X == NOT(OR(Z, ~C1)) + // ADD(ADD(X, 1), RHS) == ADD(X, ADD(RHS, 1)) == SUB(RHS, OR(Z, ~C1)) + Value *NewOr = Builder->CreateOr(Z, ~(*C1)); + return Builder->CreateSub(RHS, NewOr, "sub"); + } + } + } - return nullptr; - } + // Restore LHS and RHS + LHS = I.getOperand(0); + RHS = I.getOperand(1); - Instruction *InstCombiner::visitAdd(BinaryOperator &I) { + // if XOR is on other side, swap + if (match(RHS, m_Xor(m_Value(Y), m_APInt(C1)))) + std::swap(LHS, RHS); + + // C2 is ODD + // LHS = XOR(Y, C1), Y = AND(Z, C2), C1 == (C2 + 1) => LHS == NEG(OR(Z, ~C2)) + // ADD(LHS, RHS) == SUB(RHS, OR(Z, ~C2)) + if (match(LHS, m_Xor(m_Value(Y), m_APInt(C1)))) + if (C1->countTrailingZeros() == 0) + if (match(Y, m_And(m_Value(Z), m_APInt(C2))) && *C1 == (*C2 + 1)) { + Value *NewOr = Builder->CreateOr(Z, ~(*C2)); + return Builder->CreateSub(RHS, NewOr, "sub"); + } + return nullptr; +} + +Instruction *InstCombiner::visitAdd(BinaryOperator &I) { bool Changed = SimplifyAssociativeOrCommutative(I); Value *LHS = I.getOperand(0), *RHS = I.getOperand(1); @@ -1579,7 +1593,7 @@ Instruction *InstCombiner::visitSub(BinaryOperator &I) { match(Op1, m_Trunc(m_PtrToInt(m_Value(RHSOp))))) if (Value *Res = OptimizePointerDifference(LHSOp, RHSOp, I.getType())) return ReplaceInstUsesWith(I, Res); - } + } return nullptr; } diff --git a/test/Transforms/InstCombine/add2.ll b/test/Transforms/InstCombine/add2.ll index 1737b258971..d7eac4b0fd2 100644 --- a/test/Transforms/InstCombine/add2.ll +++ b/test/Transforms/InstCombine/add2.ll @@ -87,17 +87,22 @@ define i16 @test9(i16 %a) { ; CHECK-NEXT: ret i16 %d } -define i32 @test10(i32 %x) { - %x.not = or i32 %x, -1431655766 - %neg = xor i32 %x.not, 1431655765 - %add = add i32 %x, 1 +; y + (~((x >> 3) & 0x55555555) + 1) -> y - ((x >> 3) & 0x55555555) +define i32 @test10(i32 %x, i32 %y) { + %shr = ashr i32 %x, 3 + %shr.not = or i32 %shr, -1431655766 + %neg = xor i32 %shr.not, 1431655765 + %add = add i32 %y, 1 %add1 = add i32 %add, %neg ret i32 %add1 ; CHECK-LABEL: @test10( -; CHECK-NEXT: [[AND:%[a-z0-9]+]] = and i32 %x, -1431655766 -; CHECK-NEXT: ret i32 [[AND]] +; CHECK-NEXT: [[SHR:%[a-z0-9]+]] = ashr i32 %x, 3 +; CHECK-NEXT: [[AND:%[a-z0-9]+]] = and i32 [[SHR]], 1431655765 +; CHECK-NEXT: [[SUB:%[a-z0-9]+]] = sub i32 %y, [[AND]] +; CHECK-NEXT: ret i32 [[SUB]] } +; y + (~(x & 0x55555555) + 1) -> y - (x & 0x55555555) define i32 @test11(i32 %x, i32 %y) { %x.not = or i32 %x, -1431655766 %neg = xor i32 %x.not, 1431655765 @@ -110,20 +115,20 @@ define i32 @test11(i32 %x, i32 %y) { ; CHECK-NEXT: ret i32 [[SUB]] } +; (y + 1) + ~(x & 0x55555555) -> y - (x & 0x55555555) define i32 @test12(i32 %x, i32 %y) { - %shr = ashr i32 %x, 3 - %shr.not = or i32 %shr, -1431655766 - %neg = xor i32 %shr.not, 1431655765 - %add = add i32 %y, 1 - %add1 = add i32 %add, %neg + %add = add nsw i32 %y, 1 + %x.not = or i32 %x, -1431655766 + %neg = xor i32 %x.not, 1431655765 + %add1 = add nsw i32 %add, %neg ret i32 %add1 ; CHECK-LABEL: @test12( -; CHECK-NEXT: [[SHR:%[a-z0-9]+]] = ashr i32 %x, 3 -; CHECK-NEXT: [[AND:%[a-z0-9]+]] = and i32 [[SHR]], 1431655765 +; CHECK-NEXT: [[AND:%[a-z0-9]+]] = and i32 %x, 1431655765 ; CHECK-NEXT: [[SUB:%[a-z0-9]+]] = sub i32 %y, [[AND]] ; CHECK-NEXT: ret i32 [[SUB]] } +; y + (~(x & 0x55555556) + 1) -> y - (x & 0x55555556) define i32 @test13(i32 %x, i32 %y) { %x.not = or i32 %x, -1431655767 %neg = xor i32 %x.not, 1431655766 @@ -136,43 +141,67 @@ define i32 @test13(i32 %x, i32 %y) { ; CHECK-NEXT: ret i32 [[SUB]] } +; (y + 1) + ~(x & 0x55555556) -> y - (x & 0x55555556) define i32 @test14(i32 %x, i32 %y) { - %shr = ashr i32 %x, 3 - %shr.not = or i32 %shr, -1431655767 - %neg = xor i32 %shr.not, 1431655766 - %add = add i32 %y, 1 - %add1 = add i32 %add, %neg + %add = add nsw i32 %y, 1 + %x.not = or i32 %x, -1431655767 + %neg = xor i32 %x.not, 1431655766 + %add1 = add nsw i32 %add, %neg ret i32 %add1 ; CHECK-LABEL: @test14( -; CHECK-NEXT: [[SHR:%[a-z0-9]+]] = ashr i32 %x, 3 -; CHECK-NEXT: [[AND:%[a-z0-9]+]] = and i32 [[SHR]], 1431655766 +; CHECK-NEXT: [[AND:%[a-z0-9]+]] = and i32 %x, 1431655766 ; CHECK-NEXT: [[SUB:%[a-z0-9]+]] = sub i32 %y, [[AND]] ; CHECK-NEXT: ret i32 [[SUB]] } +; y + (~(x | 0x55555556) + 1) -> y - (x | 0x55555556) define i32 @test15(i32 %x, i32 %y) { - %x.not = and i32 %x, -1431655767 - %neg = xor i32 %x.not, -1431655767 - %add = add i32 %y, 1 - %add1 = add i32 %add, %neg - ret i32 %add1 + %x.not = and i32 %x, -1431655767 + %neg = xor i32 %x.not, -1431655767 + %add = add i32 %y, 1 + %add1 = add i32 %add, %neg + ret i32 %add1 ; CHECK-LABEL: @test15( -; CHECK-NEXT: [[OR:%[a-z0-9]+]] = or i32 %x, 1431655766 -; CHECK-NEXT: [[SUB:%[a-z0-9]+]] = sub i32 %y, [[OR]] +; CHECK-NEXT: [[AND:%[a-z0-9]+]] = or i32 %x, 1431655766 +; CHECK-NEXT: [[SUB:%[a-z0-9]+]] = sub i32 %y, [[AND]] ; CHECK-NEXT: ret i32 [[SUB]] } +; (y + 1) + ~(x | 0x55555556) -> y - (x | 0x555555556) define i32 @test16(i32 %x, i32 %y) { - %shr = ashr i32 %x, 3 - %shr.not = and i32 %shr, -1431655767 - %neg = xor i32 %shr.not, -1431655767 - %add = add i32 %y, 1 - %add1 = add i32 %add, %neg - ret i32 %add1 + %add = add nsw i32 %y, 1 + %x.not = and i32 %x, -1431655767 + %neg = xor i32 %x.not, -1431655767 + %add1 = add nsw i32 %add, %neg + ret i32 %add1 ; CHECK-LABEL: @test16( -; CHECK-NEXT: [[SHR:%[a-z0-9]+]] = ashr i32 %x, 3 -; CHECK-NEXT: [[OR:%[a-z0-9]+]] = or i32 [[SHR]], 1431655766 -; CHECK-NEXT: [[SUB:%[a-z0-9]+]] = sub i32 %y, [[OR]] +; CHECK-NEXT: [[AND:%[a-z0-9]+]] = or i32 %x, 1431655766 +; CHECK-NEXT: [[SUB:%[a-z0-9]+]] = sub i32 %y, [[AND]] +; CHECK-NEXT: ret i32 [[SUB]] +} + +; y + (~(x | 0x55555555) + 1) -> y - (x | 0x55555555) +define i32 @test17(i32 %x, i32 %y) { + %x.not = and i32 %x, -1431655766 + %add2 = xor i32 %x.not, -1431655765 + %add1 = add nsw i32 %add2, %y + ret i32 %add1 +; CHECK-LABEL: @test17( +; CHECK-NEXT: [[AND:%[a-z0-9]+]] = or i32 %x, 1431655765 +; CHECK-NEXT: [[SUB:%[a-z0-9]+]] = sub i32 %y, [[AND]] +; CHECK-NEXT: ret i32 [[SUB]] +} + +; (y + 1) + ~(x | 0x55555555) -> y - (x | 0x55555555) +define i32 @test18(i32 %x, i32 %y) { + %add = add nsw i32 %y, 1 + %x.not = and i32 %x, -1431655766 + %neg = xor i32 %x.not, -1431655766 + %add1 = add nsw i32 %add, %neg + ret i32 %add1 +; CHECK-LABEL: @test18( +; CHECK-NEXT: [[AND:%[a-z0-9]+]] = or i32 %x, 1431655765 +; CHECK-NEXT: [[SUB:%[a-z0-9]+]] = sub i32 %y, [[AND]] ; CHECK-NEXT: ret i32 [[SUB]] }