[InstCombine] Add a few more patterns for folding select of select

[aqjune]

Summary

This is a patch that folds select of select to salvage some optimizations after select -> and/or folding is disabled.

select (select a, true, b), c, false -> select a, c, false
select c, (select a, true, b), false -> select c, a, false
  if c implies that b is false (isImpliedCondition).

https://alive2.llvm.org/ce/z/ANatjt, https://alive2.llvm.org/ce/z/rv8zTB

sel (sel c, a, false), true, (sel !c, b, false) -> sel c, a, b
sel (sel !c, a, false), true, (sel c, b, false) -> sel c, b, a

https://alive2.llvm.org/ce/z/U2kp-t, https://alive2.llvm.org/ce/z/bc88EE

See D101191

[nikic]

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

2732

This is pretty hard to understand, I think it will be more obvious if you match both patterns separately and use Builder.CreateSelect here instead of modifying all three operands in place.

llvm/test/Transforms/InstCombine/select-safe-transforms.ll

187

Missing test for the second variant?

[aqjune]

address comments

[aqjune]

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

2732

Hope this new code addresses the concern.

[spatel]

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

2732

Don't need to use the Builder?

return SelectInst::Create(C1, A, B);
...
return SelectInst::Create(C2, B, A);

[aqjune]

Use SelectInst::Create

[spatel]

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

2706

Better to make the type explicit here and the next block, so it is obvious:

Optional<bool> Res = isImpliedCondition...

llvm/test/Transforms/InstCombine/select-safe-transforms.ll

156

How is this test different than the one above it?
Is the comment about complexity-based ordering copy/pasted here? I'm not seeing why it is necessary in these tests (could we just pass in an i1 argument to the function?).

[aqjune]

Address comments

[aqjune]

minor update

[aqjune]

llvm/test/Transforms/InstCombine/select-safe-transforms.ll

156

Yes, it was redundant, I fixed it

[nikic]

LGTM

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

 //===- InstCombineSelect.cpp ----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
if (match(CondVal, m_Select(m_Value(A), m_Value(B), m_Zero())) &&
       return replaceOperand(SI, 0, A);
 
     if (Value *S = SimplifyWithOpReplaced(TrueVal, CondVal, One, SQ,
                                           /* AllowRefinement */ true))
       return replaceOperand(SI, 1, S);
     if (Value *S = SimplifyWithOpReplaced(FalseVal, CondVal, Zero, SQ,
                                           /* AllowRefinement */ true))
       return replaceOperand(SI, 2, S);
+
+    // select (select a, true, b), c, false -> select a, c, false
+    // select c, (select a, true, b), false -> select c, a, false
+    //   if c implies that b is false.
+    if (match(CondVal, m_Select(m_Value(A), m_One(), m_Value(B))) &&
+        match(FalseVal, m_Zero())) {
+      auto Res = isImpliedCondition(TrueVal, B, DL);
+      if (Res && *Res == false)
+        return replaceOperand(SI, 0, A);
+    }
+    if (match(TrueVal, m_Select(m_Value(A), m_One(), m_Value(B))) &&
+        match(FalseVal, m_Zero())) {
+      auto Res = isImpliedCondition(CondVal, B, DL);
+      if (Res && *Res == false)
+        return replaceOperand(SI, 1, A);
+    }
+
+    // sel (sel c, a, false), true, (sel !c, b, false) -> sel c, a, b
+    // sel (sel !c, a, false), true, (sel c, b, false) -> sel c, b, a
+    Value *C1, *C2;
+    if (match(CondVal, m_Select(m_Value(C1), m_Value(A), m_Zero())) &&
+        match(TrueVal, m_One()) &&
+        match(FalseVal, m_Select(m_Value(C2), m_Value(B), m_Zero()))) {
+      int AIdx = 0;
+      if (match(C2, m_Not(m_Specific(C1)))) // first case
+        AIdx = 1;
+      else if (match(C1, m_Not(m_Specific(C2)))) // second case
+        AIdx = 2;
+
+      if (AIdx) {
+        replaceOperand(SI, 0, AIdx == 1 ? C1 : C2);
+        replaceOperand(SI, AIdx, A);
+        replaceOperand(SI, 3 - AIdx, B);
+        return &SI;
+      }
+    }
   }
 
   // Selecting between two integer or vector splat integer constants?
   //
   // Note that we don't handle a scalar select of vectors:
   // select i1 %c, <2 x i8> <1, 1>, <2 x i8> <0, 0>
   // because that may need 3 instructions to splat the condition value:
   // extend, insertelement, shufflevector.

llvm/test/Transforms/InstCombine/select-safe-transforms.ll

;
   %sel = select <2 x i1> %c, <2 x i1> <i1 icmp eq (i8* @glb, i8* inttoptr (i64 1234 to i8*)), i1 false>, <2 x i1> %comp
   %res = xor <2 x i1> %sel, <i1 true, i1 true>
   ret <2 x i1> %res
 }
 
 define i1 @and_orn_cmp_1_logical(i32 %a, i32 %b, i32 %c) {
 ; CHECK-LABEL: @and_orn_cmp_1_logical(
 ; CHECK-NEXT:    [[X:%.*]] = icmp sgt i32 [[A:%.*]], [[B:%.*]]
-; CHECK-NEXT:    [[X_INV:%.*]] = icmp sle i32 [[A]], [[B]]
 ; CHECK-NEXT:    [[Y:%.*]] = icmp ugt i32 [[C:%.*]], 42
-; CHECK-NEXT:    [[OR:%.*]] = select i1 [[Y]], i1 true, i1 [[X_INV]]
-; CHECK-NEXT:    [[AND:%.*]] = select i1 [[X]], i1 [[OR]], i1 false
+; CHECK-NEXT:    [[AND:%.*]] = select i1 [[X]], i1 [[Y]], i1 false
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
   %x = icmp sgt i32 %a, %b
   %x_inv = icmp sle i32 %a, %b
   %y = icmp ugt i32 %c, 42      ; thwart complexity-based ordering
   %or = select i1 %y, i1 true, i1 %x_inv
   %and = select i1 %x, i1 %or, i1 false
   ret i1 %and
 }
 
 define i1 @andn_or_cmp_1_logical(i37 %a, i37 %b, i37 %c) {
 ; CHECK-LABEL: @andn_or_cmp_1_logical(
-; CHECK-NEXT:    [[X:%.*]] = icmp sgt i37 [[A:%.*]], [[B:%.*]]
-; CHECK-NEXT:    [[X_INV:%.*]] = icmp sle i37 [[A]], [[B]]
+; CHECK-NEXT:    [[X_INV:%.*]] = icmp sle i37 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    [[Y:%.*]] = icmp ugt i37 [[C:%.*]], 42
-; CHECK-NEXT:    [[OR:%.*]] = select i1 [[Y]], i1 true, i1 [[X]]
-; CHECK-NEXT:    [[AND:%.*]] = select i1 [[X_INV]], i1 [[OR]], i1 false
+; CHECK-NEXT:    [[AND:%.*]] = select i1 [[X_INV]], i1 [[Y]], i1 false
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
   %x = icmp sgt i37 %a, %b
   %x_inv = icmp sle i37 %a, %b
   %y = icmp ugt i37 %c, 42      ; thwart complexity-based ordering
   %or = select i1 %y, i1 true, i1 %x
   %and = select i1 %x_inv, i1 %or, i1 false
   ret i1 %and
 }
 
 define i1 @andn_or_cmp_2_logical(i16 %a, i16 %b, i16 %c) {
 ; CHECK-LABEL: @andn_or_cmp_2_logical(
-; CHECK-NEXT:    [[X:%.*]] = icmp sge i16 [[A:%.*]], [[B:%.*]]
-; CHECK-NEXT:    [[X_INV:%.*]] = icmp slt i16 [[A]], [[B]]
+; CHECK-NEXT:    [[X_INV:%.*]] = icmp slt i16 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    [[Y:%.*]] = icmp ugt i16 [[C:%.*]], 42
-; CHECK-NEXT:    [[OR:%.*]] = select i1 [[Y]], i1 true, i1 [[X]]
-; CHECK-NEXT:    [[AND:%.*]] = select i1 [[OR]], i1 [[X_INV]], i1 false
+; CHECK-NEXT:    [[AND:%.*]] = select i1 [[Y]], i1 [[X_INV]], i1 false
 ; CHECK-NEXT:    ret i1 [[AND]]
 ;
   %x = icmp sge i16 %a, %b
   %x_inv = icmp slt i16 %a, %b
   %y = icmp ugt i16 %c, 42      ; thwart complexity-based ordering
   %or = select i1 %y, i1 true, i1 %x
   %and = select i1 %or, i1 %x_inv, i1 false
   ret i1 %and
 }
 
 define i1 @bools_logical(i1 %a, i1 %b, i1 %c) {
 ; CHECK-LABEL: @bools_logical(
-; CHECK-NEXT:    [[NOT:%.*]] = xor i1 [[C:%.*]], true
-; CHECK-NEXT:    [[AND1:%.*]] = select i1 [[NOT]], i1 [[A:%.*]], i1 false
-; CHECK-NEXT:    [[AND2:%.*]] = select i1 [[C]], i1 [[B:%.*]], i1 false
-; CHECK-NEXT:    [[OR:%.*]] = select i1 [[AND1]], i1 true, i1 [[AND2]]
+; CHECK-NEXT:    [[OR:%.*]] = select i1 [[C:%.*]], i1 [[B:%.*]], i1 [[A:%.*]]
 ; CHECK-NEXT:    ret i1 [[OR]]
 ;
   %not = xor i1 %c, -1
   %and1 = select i1 %not, i1 %a, i1 false
   %and2 = select i1 %c, i1 %b, i1 false
   %or = select i1 %and1, i1 true, i1 %and2
   ret i1 %or
 }