[InstCombine] transform bitcasted bitwise logic ops with constants (PR26702)

[spatel]

Summary

Given that we're not actually deleting any instructions in the included regression tests, I think we would call this a canonicalization step.

The motivation comes from the example in PR26702:
https://llvm.org/bugs/show_bug.cgi?id=26702

If we hoist the bitwise logic ahead of the bitcast, the previously unoptimizable example of:

define <4 x i32> @is_negative(<4 x i32> %x) {
  %lobit = ashr <4 x i32> %x, <i32 31, i32 31, i32 31, i32 31>
  %not = xor <4 x i32> %lobit, <i32 -1, i32 -1, i32 -1, i32 -1>
  %bc = bitcast <4 x i32> %not to <2 x i64>
  %notnot = xor <2 x i64> %bc, <i64 -1, i64 -1>
  %bc2 = bitcast <2 x i64> %notnot to <4 x i32>
  ret <4 x i32> %bc2
}

Simplifies to the expected:

define <4 x i32> @is_negative(<4 x i32> %x) {
  %lobit = ashr <4 x i32> %x, <i32 31, i32 31, i32 31, i32 31>
  ret <4 x i32> %lobit
}

[spatel]

Ping.

[mehdi_amini]

LGTM.

[spatel]

Thanks, Mehdi!

llvm/trunk/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp

 Instruction *InstCombiner::foldCastedBitwiseLogic(BinaryOperator &I) {
   auto LogicOpc = I.getOpcode();
   assert((LogicOpc == Instruction::And || LogicOpc == Instruction::Or ||
           LogicOpc == Instruction::Xor) &&
          "Unexpected opcode for bitwise logic folding");
 
   Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
   CastInst *Cast0 = dyn_cast<CastInst>(Op0);
+  if (!Cast0)
+    return nullptr;
+
+  // This must be a cast from an integer or integer vector source type to allow
+  // transformation of the logic operation to the source type.
+  Type *DestTy = I.getType();
+  Type *SrcTy = Cast0->getSrcTy();
+  if (!SrcTy->isIntOrIntVectorTy())
+    return nullptr;
+
+  // If one operand is a bitcast and the other is a constant, move the logic
+  // operation ahead of the bitcast. That is, do the logic operation in the
+  // original type. This can eliminate useless bitcasts and allow normal
+  // combines that would otherwise be impeded by the bitcast. Canonicalization
+  // ensures that if there is a constant operand, it will be the second operand.
+  Value *BC = nullptr;
+  Constant *C = nullptr;
+  if ((match(Op0, m_BitCast(m_Value(BC))) && match(Op1, m_Constant(C)))) {
+    // A bitcast of a constant will be removed.
+    Value *NewConstant = Builder->CreateBitCast(C, SrcTy);
+    Value *NewOp = Builder->CreateBinOp(LogicOpc, BC, NewConstant, I.getName());
+    return CastInst::CreateBitOrPointerCast(NewOp, DestTy);
+  }
+
   CastInst *Cast1 = dyn_cast<CastInst>(Op1);
-  if (!Cast0 || !Cast1)
+  if (!Cast1)
     return nullptr;
 
-  // The casts must be of the same type, and this must be a cast from an integer
-  // or integer vector source type.
+  // Both operands of the logic operation are casts. The casts must be of the
+  // same type for reduction.
   auto CastOpcode = Cast0->getOpcode();
-  Type *SrcTy = Cast0->getSrcTy();
-  if ((CastOpcode != Cast1->getOpcode()) || (SrcTy != Cast1->getSrcTy()) ||
-      !SrcTy->isIntOrIntVectorTy())
+  if (CastOpcode != Cast1->getOpcode() || SrcTy != Cast1->getSrcTy())
     return nullptr;
 
   Value *Cast0Src = Cast0->getOperand(0);
   Value *Cast1Src = Cast1->getOperand(0);
-  Type *DestTy = I.getType();
 
   // fold (logic (cast A), (cast B)) -> (cast (logic A, B))
 
   // Only do this if the casts both really cause code to be generated.
   if ((!isa<ICmpInst>(Cast0Src) || !isa<ICmpInst>(Cast1Src)) &&
       ShouldOptimizeCast(CastOpcode, Cast0Src, DestTy) &&
       ShouldOptimizeCast(CastOpcode, Cast1Src, DestTy)) {
     Value *NewOp = Builder->CreateBinOp(LogicOpc, Cast0Src, Cast1Src,

llvm/trunk/test/Transforms/InstCombine/bitcast-bigendian.ll

define <2 x float> @test6(float %A){
   %tmp35 = bitcast i64 %mask20 to <2 x float>     ; <<2 x float>> [#uses=1]
   ret <2 x float> %tmp35
 ; CHECK-LABEL: @test6(
 ; CHECK-NEXT: insertelement <2 x float> undef, float %A, i32 0
 ; CHECK-NEXT: insertelement <2 x float> {{.*}}, float 4.200000e+01, i32 1
 ; CHECK: ret
 }
 
-; FIXME: Do the logic in the original type for the following 3 tests.
-
 ; Verify that 'xor' of vector and constant is done as a vector bitwise op before the bitcast.
 
 define <2 x i32> @xor_bitcast_vec_to_vec(<1 x i64> %a) {
   %t1 = bitcast <1 x i64> %a to <2 x i32>
   %t2 = xor <2 x i32> <i32 1, i32 2>, %t1
   ret <2 x i32> %t2
 
 ; CHECK-LABEL: @xor_bitcast_vec_to_vec(
-; CHECK-NEXT:  %t1 = bitcast <1 x i64> %a to <2 x i32>
-; CHECK-NEXT:  %t2 = xor <2 x i32> %t1, <i32 1, i32 2>
+; CHECK-NEXT:  %t21 = xor <1 x i64> %a, <i64 4294967298> 
+; CHECK-NEXT:  %t2 = bitcast <1 x i64> %t21 to <2 x i32>
 ; CHECK-NEXT:  ret <2 x i32> %t2
 }
 
 ; Verify that 'and' of integer and constant is done as a vector bitwise op before the bitcast.
 
 define i64 @and_bitcast_vec_to_int(<2 x i32> %a) {
   %t1 = bitcast <2 x i32> %a to i64
   %t2 = and i64 %t1, 3
   ret i64 %t2
 
 ; CHECK-LABEL: @and_bitcast_vec_to_int(
-; CHECK-NEXT:  %t1 = bitcast <2 x i32> %a to i64
-; CHECK-NEXT:  %t2 = and i64 %t1, 3
+; CHECK-NEXT:  %t21 = and <2 x i32> %a, <i32 0, i32 3>
+; CHECK-NEXT:  %t2 = bitcast <2 x i32> %t21 to i64
 ; CHECK-NEXT:  ret i64 %t2
 }
 
 ; Verify that 'or' of vector and constant is done as an integer bitwise op before the bitcast.
 
 define <2 x i32> @or_bitcast_int_to_vec(i64 %a) {
   %t1 = bitcast i64 %a to <2 x i32>
   %t2 = or <2 x i32> %t1, <i32 1, i32 2>
   ret <2 x i32> %t2
 
 ; CHECK-LABEL: @or_bitcast_int_to_vec(
-; CHECK-NEXT:  %t1 = bitcast i64 %a to <2 x i32>
-; CHECK-NEXT:  %t2 = or <2 x i32> %t1, <i32 1, i32 2>
+; CHECK-NEXT:  %t21 = or i64 %a, 4294967298
+; CHECK-NEXT:  %t2 = bitcast i64 %t21 to <2 x i32>
 ; CHECK-NEXT:  ret <2 x i32> %t2
 }
 

llvm/trunk/test/Transforms/InstCombine/bitcast.ll

define <2 x i32> @xor_two_vector_bitcasts(<1 x i64> %a, <1 x i64> %b) {
   ret <2 x i32> %t3
 
 ; CHECK-LABEL: @xor_two_vector_bitcasts(
 ; CHECK-NEXT:  %t31 = xor <1 x i64> %a, %b
 ; CHECK-NEXT:  %t3 = bitcast <1 x i64> %t31 to <2 x i32>
 ; CHECK-NEXT:  ret <2 x i32> %t3
 }
 
-; FIXME: Do the logic in the original type for the following 3 tests.
-
 ; Verify that 'xor' of vector and constant is done as a vector bitwise op before the bitcast.
 
 define <2 x i32> @xor_bitcast_vec_to_vec(<1 x i64> %a) {
   %t1 = bitcast <1 x i64> %a to <2 x i32>
   %t2 = xor <2 x i32> <i32 1, i32 2>, %t1
   ret <2 x i32> %t2
 
 ; CHECK-LABEL: @xor_bitcast_vec_to_vec(
-; CHECK-NEXT:  %t1 = bitcast <1 x i64> %a to <2 x i32>
-; CHECK-NEXT:  %t2 = xor <2 x i32> %t1, <i32 1, i32 2>
+; CHECK-NEXT:  %t21 = xor <1 x i64> %a, <i64 8589934593> 
+; CHECK-NEXT:  %t2 = bitcast <1 x i64> %t21 to <2 x i32>
 ; CHECK-NEXT:  ret <2 x i32> %t2
 }
 
 ; Verify that 'and' of integer and constant is done as a vector bitwise op before the bitcast.
 
 define i64 @and_bitcast_vec_to_int(<2 x i32> %a) {
   %t1 = bitcast <2 x i32> %a to i64
   %t2 = and i64 %t1, 3
   ret i64 %t2
 
 ; CHECK-LABEL: @and_bitcast_vec_to_int(
-; CHECK-NEXT:  %t1 = bitcast <2 x i32> %a to i64
-; CHECK-NEXT:  %t2 = and i64 %t1, 3
+; CHECK-NEXT:  %t21 = and <2 x i32> %a, <i32 3, i32 0>
+; CHECK-NEXT:  %t2 = bitcast <2 x i32> %t21 to i64
 ; CHECK-NEXT:  ret i64 %t2
 }
 
 ; Verify that 'or' of vector and constant is done as an integer bitwise op before the bitcast.
 
 define <2 x i32> @or_bitcast_int_to_vec(i64 %a) {
   %t1 = bitcast i64 %a to <2 x i32>
   %t2 = or <2 x i32> %t1, <i32 1, i32 2>
   ret <2 x i32> %t2
 
 ; CHECK-LABEL: @or_bitcast_int_to_vec(
-; CHECK-NEXT:  %t1 = bitcast i64 %a to <2 x i32>
-; CHECK-NEXT:  %t2 = or <2 x i32> %t1, <i32 1, i32 2>
+; CHECK-NEXT:  %t21 = or i64 %a, 8589934593
+; CHECK-NEXT:  %t2 = bitcast i64 %t21 to <2 x i32>
 ; CHECK-NEXT:  ret <2 x i32> %t2
 }
 
 ; Optimize bitcasts that are extracting low element of vector.  This happens
 ; because of SRoA.
 ; rdar://7892780
 define float @test2(<2 x float> %A, <2 x i32> %B) {
   %tmp28 = bitcast <2 x float> %A to i64  ; <i64> [#uses=2]