[InstCombine] Add bswap(logic_op(bswap(x), y)) regression test case; NFC

[austin880625]

Summary

Fold the following case on IR InstCombine pass. This patch includes the new test cases for this optimization

bswap(logic_op(x, bswap(y))) -> logic_op(bswap(x), y)
bswap(logic_op(bswap(x), y)) -> logic_op(x, bswap(y))
bswap(logic_op(bswap(x), bswap(y))) -> logic_op(x, y) with multi-use

[goldstein.w.n]

llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp

1693

I don't see how this is correct if we only have 1 bswap:
https://alive2.llvm.org/ce/z/zBErQk

Also this apples for bitreverse as well.

llvm/test/Transforms/InstCombine/bswap-fold.ll

542

Can you split the new tests to a seperate patch so we can see the diff generated?

[goldstein.w.n]

llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp

1632

nit, but since we already have the scope for ::bswap case, can you just declare V before the match.

[goldstein.w.n]

llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp

1682

Can you move this to a helper function that takes an Intrisinic ID so we can reuse for bitreverse?

1693

I don't see how this is correct if we only have 1 bswap:
https://alive2.llvm.org/ce/z/zBErQk

Also this apples for bitreverse as well.

Nevermind, saw this as standalone, missed it was in the bswap case.

[austin880625]

hi, thanks for the reviewing! I'll keep working on the suggestions and update here once I've done(probably in 2-3 days)

[austin880625]

llvm/test/Transforms/InstCombine/bswap-fold.ll

542

Just to confirm(newbie here), are the following separated patches you want:

1. first one in old implementation and new tests with FileCheck lines generated with old opt
2. second one with my actual code change, and the new tests with updated FileCheck lines generated with the changed opt. And the patch is based diff-ed with the first one?

[goldstein.w.n]

llvm/test/Transforms/InstCombine/bswap-fold.ll

542

Just to confirm(newbie here), are the following separated patches you want:

1. first one in old implementation and new tests with FileCheck lines generated with old opt
2. second one with my actual code change, and the new tests with updated FileCheck lines generated with the changed opt. And the patch is based diff-ed with the first one?

Yeah. You can create series using the 'edit related revisions' then make the test-patch the "parent".
For example:
Tests: D149520
Impl: D149521

and if click 'stack' you see the relationship between the two.

542

Just to confirm(newbie here), are the following separated patches you want:

1. first one in old implementation and new tests with FileCheck lines generated with old opt
2. second one with my actual code change, and the new tests with updated FileCheck lines generated with the changed opt. And the patch is based diff-ed with the first one?

Yeah. You can create series using the 'edit related revisions' then make the test-patch the "parent".
For example:
Tests: D149520
Impl: D149521

and if click 'stack' you see the relationship between the two.

542

And welcome! Thank you for the patch!

[austin880625]

separate test and implementation

[austin880625]

@goldstein.w.n I updated the diff on this revision (as test) and created another D149699 as updated implementation. Let me know if I did anything wrong here, thanks!

[goldstein.w.n]

In D149577#4313910, @austin880625 wrote:

@goldstein.w.n I updated the diff on this revision (as test) and created another D149699 as updated implementation. Let me know if I did anything wrong here, thanks!

You created the series properly.

Can you update the summary/title of the two commits to reflect what they are now.

So D149577 doesn't need a summary but the title should be something along the lines of:
"[InstCombine] Add tests for (logic_op (bswap X), Y); NFC"

D149699 should have basically the same title/commit as you originally had (as you have here now).

[austin880625]

add test cases for CodeGen(DAGCombiner)

[austin880625]

contains changes for InstCombine only

[goldstein.w.n]

llvm/test/Transforms/InstCombine/bswap-fold.ll

781

your *_rhs_* tests appear to have the bswap still on the lhs.

[austin880625]

add bswap(logic_op(bswap(x), bswap(y))) -> logic_op(x, y) case with multi-use

[goldstein.w.n]

LGTM.

[RKSimon]

LGTM

[RKSimon]

@austin880625 Do you have commit access, if not please can you post your github email address so I can push the changes for you

[austin880625]

In D149577#4324950, @RKSimon wrote:

@austin880625 Do you have commit access, if not please can you post your github email address so I can push the changes for you

@RKSimon I don't, can you use this one: [e-mail] . Thanks!

llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp

if ((N0.getOpcode() == ISD::SHL || N0.getOpcode() == ISD::SRL) &&
     if (ShAmt && ShAmt->getAPIntValue().ult(BW) &&
         ShAmt->getZExtValue() % 8 == 0) {
       SDValue NewSwap = DAG.getNode(ISD::BSWAP, DL, VT, N0.getOperand(0));
       unsigned InverseShift = N0.getOpcode() == ISD::SHL ? ISD::SRL : ISD::SHL;
       return DAG.getNode(InverseShift, DL, VT, NewSwap, N0.getOperand(1));
     }
   }
 
+  // fold (bswap (logic_op(bswap(x),y))) -> logic_op(x,bswap(y))
+  // Need to ensure logic_op and bswap(x) doesn't have other uses
+  if (ISD::isBitwiseLogicOp(N0.getOpcode()) && N0.hasOneUse()) {
+    SDValue OldLHS = N0.getOperand(0);
+    SDValue OldRHS = N0.getOperand(1);
+
+    if (OldLHS.getOpcode() == ISD::BSWAP && OldLHS.hasOneUse()) {
+      SDValue NewSwap = DAG.getNode(ISD::BSWAP, DL, VT, OldRHS);
+      return DAG.getNode(N0.getOpcode(), DL, VT, OldLHS.getOperand(0), NewSwap);
+    } else if (OldRHS.getOpcode() == ISD::BSWAP && OldRHS.hasOneUse()) {
+      SDValue NewSwap = DAG.getNode(ISD::BSWAP, DL, VT, OldLHS);
+      return DAG.getNode(N0.getOpcode(), DL, VT, OldRHS.getOperand(0), NewSwap);
+    }
+  }
+
   return SDValue();
 }
 
 SDValue DAGCombiner::visitBITREVERSE(SDNode *N) {
   SDValue N0 = N->getOperand(0);
   EVT VT = N->getValueType(0);
 
   // fold (bitreverse c1) -> c2

llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp

static Value *SimplifyBSwap(BinaryOperator &I,
   if (!match(OldLHS, m_BSwap(m_Value(NewLHS))))
     return nullptr;
 
   Value *NewRHS;
   const APInt *C;
 
   if (match(OldRHS, m_BSwap(m_Value(NewRHS)))) {
     // OP( BSWAP(x), BSWAP(y) ) -> BSWAP( OP(x, y) )
-    if (!OldLHS->hasOneUse() && !OldRHS->hasOneUse())
+    if (!OldLHS->hasOneUse() || !OldRHS->hasOneUse())
       return nullptr;
     // NewRHS initialized by the matcher.
   } else if (match(OldRHS, m_APInt(C))) {
     // OP( BSWAP(x), CONSTANT ) -> BSWAP( OP(x, BSWAP(CONSTANT) ) )
     if (!OldLHS->hasOneUse())
       return nullptr;
     NewRHS = ConstantInt::get(I.getType(), C->byteSwap());
   } else

llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp

if (match(II->getArgOperand(0), m_ZExt(m_Value(X))) &&
       return SelectInst::Create(X, ConstantInt::get(Ty, SignBit),
                                 ConstantInt::getNullValue(Ty));
     }
     break;
   }
   case Intrinsic::bswap: {
     Value *IIOperand = II->getArgOperand(0);
 
+    // The duplicate bswap might not come from real world code, but can be
+    // introduced by other optimizations
+    // e.g. bswap(logic_op(bswap(x), bswap(y)))
+    // --> bswap(bswap(logic_op(x, y)))
+    if (Value * V; match(IIOperand, m_BSwap(m_Value(V)))) {
+      return replaceInstUsesWith(CI, V);
+    }
+
     // Try to canonicalize bswap-of-logical-shift-by-8-bit-multiple as
     // inverse-shift-of-bswap:
     // bswap (shl X, Y) --> lshr (bswap X), Y
     // bswap (lshr X, Y) --> shl (bswap X), Y
     Value *X, *Y;
     if (match(IIOperand, m_OneUse(m_LogicalShift(m_Value(X), m_Value(Y))))) {
       // The transform allows undef vector elements, so try a constant match
       // first. If knownbits can handle that case, that clause could be removed.
case Intrinsic::bswap: {
 
     // bswap(trunc(bswap(x))) -> trunc(lshr(x, c))
     if (match(IIOperand, m_Trunc(m_BSwap(m_Value(X))))) {
       unsigned C = X->getType()->getScalarSizeInBits() - BW;
       Value *CV = ConstantInt::get(X->getType(), C);
       Value *V = Builder.CreateLShr(X, CV);
       return new TruncInst(V, IIOperand->getType());
     }
+
+    // bswap(logic_op(bswap(x), y)) --> logic_op(x, bswap(y))
+    if (match(IIOperand, m_OneUse(m_BitwiseLogic(m_Value(X), m_Value(Y))))) {
+      Value *OldSwap;
+      BinaryOperator::BinaryOps Op =
+          cast<BinaryOperator>(IIOperand)->getOpcode();
+
+      // At least one side need to be bswap so that the number of bswap can be
+      // reduced
+      // We also need to ensure the operands whose bswap is being removed have
+      // no other uses
+      if (match(X, m_BSwap(m_Value(OldSwap))) && X->hasOneUse()) {
+        Value *NewSwap = Builder.CreateUnaryIntrinsic(Intrinsic::bswap, Y);
+        return BinaryOperator::Create(Op, OldSwap, NewSwap);
+      } else if (match(Y, m_BSwap(m_Value(OldSwap))) && Y->hasOneUse()) {
+        Value *NewSwap = Builder.CreateUnaryIntrinsic(Intrinsic::bswap, X);
+        return BinaryOperator::Create(Op, NewSwap, OldSwap);
+      }
+    }
     break;
   }
   case Intrinsic::masked_load:
     if (Value *SimplifiedMaskedOp = simplifyMaskedLoad(*II))
       return replaceInstUsesWith(CI, SimplifiedMaskedOp);
     break;
   case Intrinsic::masked_store:
     return simplifyMaskedStore(*II);

llvm/test/Transforms/InstCombine/bswap-fold.ll

;
   %t4 = mul i64 %t3, %t1 ; to increase use count of the bswaps
   %t5 = mul i64 %t4, %t2 ; to increase use count of the bswaps
   ret i64 %t5
 }
 
 define i64 @bs_and64_multiuse2(i64 %a, i64 %b) #0 {
 ; CHECK-LABEL: @bs_and64_multiuse2(
 ; CHECK-NEXT:    [[T1:%.*]] = tail call i64 @llvm.bswap.i64(i64 [[A:%.*]])
-; CHECK-NEXT:    [[TMP1:%.*]] = and i64 [[A]], [[B:%.*]]
-; CHECK-NEXT:    [[T3:%.*]] = call i64 @llvm.bswap.i64(i64 [[TMP1]])
+; CHECK-NEXT:    [[T2:%.*]] = tail call i64 @llvm.bswap.i64(i64 [[B:%.*]])
+; CHECK-NEXT:    [[T3:%.*]] = and i64 [[T1]], [[T2]]
 ; CHECK-NEXT:    [[T4:%.*]] = mul i64 [[T3]], [[T1]]
 ; CHECK-NEXT:    ret i64 [[T4]]
 ;
   %t1 = tail call i64 @llvm.bswap.i64(i64 %a)
   %t2 = tail call i64 @llvm.bswap.i64(i64 %b)
   %t3 = and i64 %t1, %t2
   %t4 = mul i64 %t3, %t1 ; to increase use count of the bswaps
   ret i64 %t4
 }
 
 define i64 @bs_and64_multiuse3(i64 %a, i64 %b) #0 {
 ; CHECK-LABEL: @bs_and64_multiuse3(
+; CHECK-NEXT:    [[T1:%.*]] = tail call i64 @llvm.bswap.i64(i64 [[A:%.*]])
 ; CHECK-NEXT:    [[T2:%.*]] = tail call i64 @llvm.bswap.i64(i64 [[B:%.*]])
-; CHECK-NEXT:    [[TMP1:%.*]] = and i64 [[A:%.*]], [[B]]
-; CHECK-NEXT:    [[T3:%.*]] = call i64 @llvm.bswap.i64(i64 [[TMP1]])
+; CHECK-NEXT:    [[T3:%.*]] = and i64 [[T1]], [[T2]]
 ; CHECK-NEXT:    [[T4:%.*]] = mul i64 [[T3]], [[T2]]
 ; CHECK-NEXT:    ret i64 [[T4]]
 ;
   %t1 = tail call i64 @llvm.bswap.i64(i64 %a)
   %t2 = tail call i64 @llvm.bswap.i64(i64 %b)
   %t3 = and i64 %t1, %t2
   %t4 = mul i64 %t3, %t2 ; to increase use count of the bswaps
   ret i64 %t4
 }
 
 define i64 @bs_and64i_multiuse(i64 %a, i64 %b) #0 {
 ; CHECK-LABEL: @bs_and64i_multiuse(
 ; CHECK-NEXT:    [[T1:%.*]] = tail call i64 @llvm.bswap.i64(i64 [[A:%.*]])
 ; CHECK-NEXT:    [[T2:%.*]] = and i64 [[T1]], 1000000001
 ; CHECK-NEXT:    [[T3:%.*]] = mul i64 [[T2]], [[T1]]
 ; CHECK-NEXT:    ret i64 [[T3]]
 ;
   %t1 = tail call i64 @llvm.bswap.i64(i64 %a)
   %t2 = and i64 %t1, 1000000001
   %t3 = mul i64 %t2, %t1 ; to increase use count of the bswap
   ret i64 %t3
 }
 
 
+; Issue#62236
+; Fold: BSWAP( OP( BSWAP(x), y ) ) -> OP( x, BSWAP(y) )
+define i16 @bs_and_lhs_bs16(i16 %a, i16 %b) #0 {
+; CHECK-LABEL: @bs_and_lhs_bs16(
+; CHECK-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[B:%.*]])
+; CHECK-NEXT:    [[TMP2:%.*]] = and i16 [[TMP1]], [[A:%.*]]
+; CHECK-NEXT:    ret i16 [[TMP2]]
+;
+  %1 = tail call i16 @llvm.bswap.i16(i16 %a)
+  %2 = and i16 %1, %b
+  %3 = tail call i16 @llvm.bswap.i16(i16 %2)
+  ret i16 %3
+}
+
+define i16 @bs_or_lhs_bs16(i16 %a, i16 %b) #0 {
+; CHECK-LABEL: @bs_or_lhs_bs16(
+; CHECK-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[B:%.*]])
+; CHECK-NEXT:    [[TMP2:%.*]] = or i16 [[TMP1]], [[A:%.*]]
+; CHECK-NEXT:    ret i16 [[TMP2]]
+;
+  %1 = tail call i16 @llvm.bswap.i16(i16 %a)
+  %2 = or i16 %1, %b
+  %3 = tail call i16 @llvm.bswap.i16(i16 %2)
+  ret i16 %3
+}
+
+define i16 @bs_xor_lhs_bs16(i16 %a, i16 %b) #0 {
+; CHECK-LABEL: @bs_xor_lhs_bs16(
+; CHECK-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[B:%.*]])
+; CHECK-NEXT:    [[TMP2:%.*]] = xor i16 [[TMP1]], [[A:%.*]]
+; CHECK-NEXT:    ret i16 [[TMP2]]
+;
+  %1 = tail call i16 @llvm.bswap.i16(i16 %a)
+  %2 = xor i16 %1, %b
+  %3 = tail call i16 @llvm.bswap.i16(i16 %2)
+  ret i16 %3
+}
+
+define i16 @bs_and_rhs_bs16(i16 %a, i16 %b) #0 {
+; CHECK-LABEL: @bs_and_rhs_bs16(
+; CHECK-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[A:%.*]])
+; CHECK-NEXT:    [[TMP2:%.*]] = and i16 [[TMP1]], [[B:%.*]]
+; CHECK-NEXT:    ret i16 [[TMP2]]
+;
+  %1 = tail call i16 @llvm.bswap.i16(i16 %b)
+  %2 = and i16 %1, %a
+  %3 = tail call i16 @llvm.bswap.i16(i16 %2)
+  ret i16 %3
+}
+
+define i16 @bs_or_rhs_bs16(i16 %a, i16 %b) #0 {
+; CHECK-LABEL: @bs_or_rhs_bs16(
+; CHECK-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[A:%.*]])
+; CHECK-NEXT:    [[TMP2:%.*]] = or i16 [[TMP1]], [[B:%.*]]
+; CHECK-NEXT:    ret i16 [[TMP2]]
+;
+  %1 = tail call i16 @llvm.bswap.i16(i16 %b)
+  %2 = or i16 %1, %a
+  %3 = tail call i16 @llvm.bswap.i16(i16 %2)
+  ret i16 %3
+}
+
+define i16 @bs_xor_rhs_bs16(i16 %a, i16 %b) #0 {
+; CHECK-LABEL: @bs_xor_rhs_bs16(
+; CHECK-NEXT:    [[TMP1:%.*]] = call i16 @llvm.bswap.i16(i16 [[A:%.*]])
+; CHECK-NEXT:    [[TMP2:%.*]] = xor i16 [[TMP1]], [[B:%.*]]
+; CHECK-NEXT:    ret i16 [[TMP2]]
+;
+  %1 = tail call i16 @llvm.bswap.i16(i16 %b)
+  %2 = xor i16 %1, %a
+  %3 = tail call i16 @llvm.bswap.i16(i16 %2)
+  ret i16 %3
+}
+
+define i32 @bs_and_rhs_bs32(i32 %a, i32 %b) #0 {
+; CHECK-LABEL: @bs_and_rhs_bs32(
+; CHECK-NEXT:    [[TMP1:%.*]] = call i32 @llvm.bswap.i32(i32 [[A:%.*]])
+; CHECK-NEXT:    [[TMP2:%.*]] = and i32 [[TMP1]], [[B:%.*]]
+; CHECK-NEXT:    ret i32 [[TMP2]]
+;
+  %1 = tail call i32 @llvm.bswap.i32(i32 %b)
+  %2 = and i32 %1, %a
+  %3 = tail call i32 @llvm.bswap.i32(i32 %2)
+  ret i32 %3
+}
+
+define i32 @bs_or_rhs_bs32(i32 %a, i32 %b) #0 {
+; CHECK-LABEL: @bs_or_rhs_bs32(
+; CHECK-NEXT:    [[TMP1:%.*]] = call i32 @llvm.bswap.i32(i32 [[A:%.*]])
+; CHECK-NEXT:    [[TMP2:%.*]] = or i32 [[TMP1]], [[B:%.*]]
+; CHECK-NEXT:    ret i32 [[TMP2]]
+;
+  %1 = tail call i32 @llvm.bswap.i32(i32 %b)
+  %2 = or i32 %1, %a
+  %3 = tail call i32 @llvm.bswap.i32(i32 %2)
+  ret i32 %3
+}
+
+define i32 @bs_xor_rhs_bs32(i32 %a, i32 %b) #0 {
+; CHECK-LABEL: @bs_xor_rhs_bs32(
+; CHECK-NEXT:    [[TMP1:%.*]] = call i32 @llvm.bswap.i32(i32 [[A:%.*]])
+; CHECK-NEXT:    [[TMP2:%.*]] = xor i32 [[TMP1]], [[B:%.*]]
+; CHECK-NEXT:    ret i32 [[TMP2]]
+;
+  %1 = tail call i32 @llvm.bswap.i32(i32 %b)
+  %2 = xor i32 %1, %a
+  %3 = tail call i32 @llvm.bswap.i32(i32 %2)
+  ret i32 %3
+}
+
+define i64 @bs_and_rhs_bs64(i64 %a, i64 %b) #0 {
+; CHECK-LABEL: @bs_and_rhs_bs64(
+; CHECK-NEXT:    [[TMP1:%.*]] = call i64 @llvm.bswap.i64(i64 [[A:%.*]])
+; CHECK-NEXT:    [[TMP2:%.*]] = and i64 [[TMP1]], [[B:%.*]]
+; CHECK-NEXT:    ret i64 [[TMP2]]
+;
+  %1 = tail call i64 @llvm.bswap.i64(i64 %b)
+  %2 = and i64 %1, %a
+  %3 = tail call i64 @llvm.bswap.i64(i64 %2)
+  ret i64 %3
+}
+
+define i64 @bs_or_rhs_bs64(i64 %a, i64 %b) #0 {
+; CHECK-LABEL: @bs_or_rhs_bs64(
+; CHECK-NEXT:    [[TMP1:%.*]] = call i64 @llvm.bswap.i64(i64 [[A:%.*]])
+; CHECK-NEXT:    [[TMP2:%.*]] = or i64 [[TMP1]], [[B:%.*]]
+; CHECK-NEXT:    ret i64 [[TMP2]]
+;
+  %1 = tail call i64 @llvm.bswap.i64(i64 %b)
+  %2 = or i64 %1, %a
+  %3 = tail call i64 @llvm.bswap.i64(i64 %2)
+  ret i64 %3
+}
+
+define i64 @bs_xor_rhs_bs64(i64 %a, i64 %b) #0 {
+; CHECK-LABEL: @bs_xor_rhs_bs64(
+; CHECK-NEXT:    [[TMP1:%.*]] = call i64 @llvm.bswap.i64(i64 [[A:%.*]])
+; CHECK-NEXT:    [[TMP2:%.*]] = xor i64 [[TMP1]], [[B:%.*]]
+; CHECK-NEXT:    ret i64 [[TMP2]]
+;
+  %1 = tail call i64 @llvm.bswap.i64(i64 %b)
+  %2 = xor i64 %1, %a
+  %3 = tail call i64 @llvm.bswap.i64(i64 %2)
+  ret i64 %3
+}
+
+define <2 x i32> @bs_and_rhs_i32vec(<2 x i32> %a, <2 x i32> %b) #0 {
+; CHECK-LABEL: @bs_and_rhs_i32vec(
+; CHECK-NEXT:    [[TMP1:%.*]] = call <2 x i32> @llvm.bswap.v2i32(<2 x i32> [[A:%.*]])
+; CHECK-NEXT:    [[TMP2:%.*]] = and <2 x i32> [[TMP1]], [[B:%.*]]
+; CHECK-NEXT:    ret <2 x i32> [[TMP2]]
+;
+  %1 = tail call <2 x i32> @llvm.bswap.v2i32(<2 x i32> %b)
+  %2 = and <2 x i32> %1, %a
+  %3 = tail call <2 x i32> @llvm.bswap.v2i32(<2 x i32> %2)
+  ret <2 x i32> %3
+}
+
+define <2 x i32> @bs_or_rhs_i32vec(<2 x i32> %a, <2 x i32> %b) #0 {
+; CHECK-LABEL: @bs_or_rhs_i32vec(
+; CHECK-NEXT:    [[TMP1:%.*]] = call <2 x i32> @llvm.bswap.v2i32(<2 x i32> [[A:%.*]])
+; CHECK-NEXT:    [[TMP2:%.*]] = or <2 x i32> [[TMP1]], [[B:%.*]]
+; CHECK-NEXT:    ret <2 x i32> [[TMP2]]
+;
+  %1 = tail call <2 x i32> @llvm.bswap.v2i32(<2 x i32> %b)
+  %2 = or <2 x i32> %1, %a
+  %3 = tail call <2 x i32> @llvm.bswap.v2i32(<2 x i32> %2)
+  ret <2 x i32> %3
+}
+
+define <2 x i32> @bs_xor_rhs_i32vec(<2 x i32> %a, <2 x i32> %b) #0 {
+; CHECK-LABEL: @bs_xor_rhs_i32vec(
+; CHECK-NEXT:    [[TMP1:%.*]] = call <2 x i32> @llvm.bswap.v2i32(<2 x i32> [[A:%.*]])
+; CHECK-NEXT:    [[TMP2:%.*]] = xor <2 x i32> [[TMP1]], [[B:%.*]]
+; CHECK-NEXT:    ret <2 x i32> [[TMP2]]
+;
+  %1 = tail call <2 x i32> @llvm.bswap.v2i32(<2 x i32> %b)
+  %2 = xor <2 x i32> %1, %a
+  %3 = tail call <2 x i32> @llvm.bswap.v2i32(<2 x i32> %2)
+  ret <2 x i32> %3
+}
+
+define i64 @bs_and_rhs_bs64_multiuse1(i64 %a, i64 %b) #0 {
+; CHECK-LABEL: @bs_and_rhs_bs64_multiuse1(
+; CHECK-NEXT:    [[TMP1:%.*]] = tail call i64 @llvm.bswap.i64(i64 [[B:%.*]])
+; CHECK-NEXT:    [[TMP2:%.*]] = and i64 [[TMP1]], [[A:%.*]]
+; CHECK-NEXT:    [[TMP3:%.*]] = tail call i64 @llvm.bswap.i64(i64 [[TMP2]])
+; CHECK-NEXT:    [[TMP4:%.*]] = mul i64 [[TMP2]], [[TMP3]]
+; CHECK-NEXT:    ret i64 [[TMP4]]
+;
+  %1 = tail call i64 @llvm.bswap.i64(i64 %b)
+  %2 = and i64 %1, %a
+  %3 = tail call i64 @llvm.bswap.i64(i64 %2)
+  %4 = mul i64 %2, %3 ;increase use of logical op
+  ret i64 %4
+}
+
+define i64 @bs_and_rhs_bs64_multiuse2(i64 %a, i64 %b) #0 {
+; CHECK-LABEL: @bs_and_rhs_bs64_multiuse2(
+; CHECK-NEXT:    [[TMP1:%.*]] = tail call i64 @llvm.bswap.i64(i64 [[B:%.*]])
+; CHECK-NEXT:    [[TMP2:%.*]] = and i64 [[TMP1]], [[A:%.*]]
+; CHECK-NEXT:    [[TMP3:%.*]] = tail call i64 @llvm.bswap.i64(i64 [[TMP2]])
+; CHECK-NEXT:    [[TMP4:%.*]] = mul i64 [[TMP1]], [[TMP3]]
+; CHECK-NEXT:    ret i64 [[TMP4]]
+;
+  %1 = tail call i64 @llvm.bswap.i64(i64 %b)
+  %2 = and i64 %1, %a
+  %3 = tail call i64 @llvm.bswap.i64(i64 %2)
+  %4 = mul i64 %1, %3 ;increase use of inner bswap
+  ret i64 %4
+}
+
+define i64 @bs_all_operand64(i64 %a, i64 %b) #0 {
+; CHECK-LABEL: @bs_all_operand64(
+; CHECK-NEXT:    [[TMP1:%.*]] = and i64 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    ret i64 [[TMP1]]
+;
+  %1 = tail call i64 @llvm.bswap.i64(i64 %a)
+  %2 = tail call i64 @llvm.bswap.i64(i64 %b)
+  %3 = and i64 %1, %2
+  %4 = tail call i64 @llvm.bswap.i64(i64 %3)
+  ret i64 %4
+}
+
+
 define i64 @bs_active_high8(i64 %0) {
 ; CHECK-LABEL: @bs_active_high8(
 ; CHECK-NEXT:    [[TMP2:%.*]] = and i64 [[TMP0:%.*]], 255
 ; CHECK-NEXT:    ret i64 [[TMP2]]
 ;
   %2 = shl i64 %0, 56
   %3 = call i64 @llvm.bswap.i64(i64 %2)
   ret i64 %3
 }
 
 define i32 @bs_active_high7(i32 %0) {
 ; CHECK-LABEL: @bs_active_high7(
 ; CHECK-NEXT:    [[TMP2:%.*]] = lshr i32 [[TMP0:%.*]], 24
 ; CHECK-NEXT:    [[TMP3:%.*]] = and i32 [[TMP2]], 254
 ; CHECK-NEXT:    ret i32 [[TMP3]]
 ;
   %2 = and i32 %0, -33554432  ; 0xfe000000
   %3 = call i32 @llvm.bswap.i32(i32 %2)
   ret i32 %3
 }
 
 define <2 x i64> @bs_active_high4(<2 x i64> %0) {
 ; CHECK-LABEL: @bs_active_high4(