From 23684a026c060a2a62291edadfb7b848f897c0cd Mon Sep 17 00:00:00 2001 From: Bill Wendling Date: Mon, 1 Dec 2008 01:07:11 +0000 Subject: [PATCH] Implement ((A|B)&1)|(B&-2) -> (A&1) | B transformation. This also takes care of permutations of this pattern. llvm-svn: 60312 --- lib/Target/README.txt | 6 -- .../Scalar/InstructionCombining.cpp | 67 +++++++++++++++++++ test/Transforms/InstCombine/and-or.ll | 39 +++++++++++ 3 files changed, 106 insertions(+), 6 deletions(-) create mode 100644 test/Transforms/InstCombine/and-or.ll diff --git a/lib/Target/README.txt b/lib/Target/README.txt index 17b830d5d4a..fb6b0cd53d5 100644 --- a/lib/Target/README.txt +++ b/lib/Target/README.txt @@ -1147,12 +1147,6 @@ There's an unnecessary zext in the generated code with "clang //===---------------------------------------------------------------------===// -int a(int a, int b) {return ((a|b)&1) | (b&-2);} -Should be combined to "(a&1)|b". Currently not optimized with "clang --emit-llvm-bc | opt -std-compile-opts". - -//===---------------------------------------------------------------------===// - int a(unsigned b) {return ((b << 31) | (b << 30)) >> 31;} Should be combined to "((b >> 1) | b) & 1". Currently not optimized with "clang -emit-llvm-bc | opt -std-compile-opts". diff --git a/lib/Transforms/Scalar/InstructionCombining.cpp b/lib/Transforms/Scalar/InstructionCombining.cpp index 9cb1875b958..4e2e8a409bc 100644 --- a/lib/Transforms/Scalar/InstructionCombining.cpp +++ b/lib/Transforms/Scalar/InstructionCombining.cpp @@ -4649,6 +4649,73 @@ Instruction *InstCombiner::visitOr(BinaryOperator &I) { } } + // ((A|B)&1)|(B&-2) -> (A&1) | B + if (match(Op0, m_And(m_Or(m_Value(A), m_Value(B)), m_Value(C))) || + match(Op0, m_And(m_Value(C), m_Or(m_Value(A), m_Value(B))))) { + if (ConstantInt *CI = dyn_cast(C)) { + if (CI->getValue() == 1) { + Value *V1 = 0, *C2 = 0; + if (match(Op1, m_And(m_Value(V1), m_Value(C2)))) { + ConstantInt *CI2 = dyn_cast(C2); + + if (!CI2) { + std::swap(V1, C2); + CI2 = dyn_cast(C2); + } + + if (CI2) { + APInt NegTwo = -APInt(CI2->getValue().getBitWidth(), 2, true); + if (CI2->getValue().eq(NegTwo)) { + if (V1 == B) { + Instruction *NewOp = + InsertNewInstBefore(BinaryOperator::CreateAnd(A, CI), I); + return BinaryOperator::CreateOr(NewOp, B); + } + if (V1 == A) { + Instruction *NewOp = + InsertNewInstBefore(BinaryOperator::CreateAnd(B, CI), I); + return BinaryOperator::CreateOr(NewOp, A); + } + } + } + } + } + } + } + // (B&-2)|((A|B)&1) -> (A&1) | B + if (match(Op1, m_And(m_Or(m_Value(A), m_Value(B)), m_Value(C))) || + match(Op1, m_And(m_Value(C), m_Or(m_Value(A), m_Value(B))))) { + if (ConstantInt *CI = dyn_cast(C)) { + if (CI->getValue() == 1) { + Value *V1 = 0, *C2 = 0; + if (match(Op0, m_And(m_Value(V1), m_Value(C2)))) { + ConstantInt *CI2 = dyn_cast(C2); + + if (!CI2) { + std::swap(V1, C2); + CI2 = dyn_cast(C2); + } + + if (CI2) { + APInt NegTwo = -APInt(CI2->getValue().getBitWidth(), 2, true); + if (CI2->getValue().eq(NegTwo)) { + if (V1 == B) { + Instruction *NewOp = + InsertNewInstBefore(BinaryOperator::CreateAnd(A, CI), I); + return BinaryOperator::CreateOr(NewOp, B); + } + if (V1 == A) { + Instruction *NewOp = + InsertNewInstBefore(BinaryOperator::CreateAnd(B, CI), I); + return BinaryOperator::CreateOr(NewOp, A); + } + } + } + } + } + } + } + if (match(Op0, m_Not(m_Value(A)))) { // ~A | Op1 if (A == Op1) // ~A | A == -1 return ReplaceInstUsesWith(I, Constant::getAllOnesValue(I.getType())); diff --git a/test/Transforms/InstCombine/and-or.ll b/test/Transforms/InstCombine/and-or.ll new file mode 100644 index 00000000000..38ad842e015 --- /dev/null +++ b/test/Transforms/InstCombine/and-or.ll @@ -0,0 +1,39 @@ +; RUN: llvm-as < %s | opt -instcombine | llvm-dis | grep {and i32 %a, 1} | count 4 +; RUN: llvm-as < %s | opt -instcombine | llvm-dis | grep {or i32 %0, %b} | count 4 + + +define i32 @func1(i32 %a, i32 %b) nounwind readnone { +entry: + %0 = or i32 %b, %a ; [#uses=1] + %1 = and i32 %0, 1 ; [#uses=1] + %2 = and i32 %b, -2 ; [#uses=1] + %3 = or i32 %1, %2 ; [#uses=1] + ret i32 %3 +} + +define i32 @func2(i32 %a, i32 %b) nounwind readnone { +entry: + %0 = or i32 %a, %b ; [#uses=1] + %1 = and i32 1, %0 ; [#uses=1] + %2 = and i32 -2, %b ; [#uses=1] + %3 = or i32 %1, %2 ; [#uses=1] + ret i32 %3 +} + +define i32 @func3(i32 %a, i32 %b) nounwind readnone { +entry: + %0 = or i32 %b, %a ; [#uses=1] + %1 = and i32 %0, 1 ; [#uses=1] + %2 = and i32 %b, -2 ; [#uses=1] + %3 = or i32 %2, %1 ; [#uses=1] + ret i32 %3 +} + +define i32 @func4(i32 %a, i32 %b) nounwind readnone { +entry: + %0 = or i32 %a, %b ; [#uses=1] + %1 = and i32 1, %0 ; [#uses=1] + %2 = and i32 -2, %b ; [#uses=1] + %3 = or i32 %2, %1 ; [#uses=1] + ret i32 %3 +}