[InstSimplify] Fold (X || Y) ? X : Y --> X

[bcl5980]

Summary

(X || Y) ? X : Y --> X
https://alive2.llvm.org/ce/z/oRQJee

[bcl5980]

rebase code

[bcl5980]

rebase code

[bcl5980]

llvm/lib/Analysis/InstructionSimplify.cpp

4558

Hi @spatel , which way do you think is better here?

// (X || Y) ? X : Y --> X (commuted 2 ways)
if (match(Cond, m_c_LogicalOr(m_Specific(TrueVal), m_Specific(FalseVal))))
  return TrueVal;

// (X || Y) ? false : X --> false (commuted 2 ways)
if (match(Cond, m_c_LogicalOr(m_Specific(FalseVal), m_Value())) &&
    match(TrueVal, m_ZeroInt()))
  return ConstantInt::getFalse(Cond->getType());

or

if (match(Cond, m_LogicalOr(m_Value(X), m_Value(Y)))) {
  // (X || Y) ? X : Y --> X
  if ((X == TrueVal && Y == FalseVal) || (X == FalseVal && Y == TrueVal))
    return TrueVal;

  // (X || Y) ? false : X --> false (commuted 2 ways)
  if (match(TrueVal, m_ZeroInt()) && (X == FalseVal || Y == FalseVal))
    return ConstantInt::getFalse(Cond->getType());
}

[spatel]

LGTM

llvm/lib/Analysis/InstructionSimplify.cpp

4558

The current code (using m_Specific) is a little easier to read to me.

llvm/test/Transforms/InstSimplify/select-logical.ll

445

This could fold, but we don't match it currently, right? Add a TODO comment to be consistent with the previous patches.

[bcl5980]

add TODO for test

llvm/lib/Analysis/InstructionSimplify.cpp

static Value *simplifySelectInst(Value *Cond, Value *TrueVal, Value *FalseVal,
   assert(TrueVal->getType() == FalseVal->getType() &&
          "Select must have same types for true/false ops");
 
   if (Cond->getType() == TrueVal->getType()) {
     // select i1 Cond, i1 true, i1 false --> i1 Cond
     if (match(TrueVal, m_One()) && match(FalseVal, m_ZeroInt()))
       return Cond;
 
+    // (X || Y) ? X : Y --> X (commuted 2 ways)
+    if (match(Cond, m_c_LogicalOr(m_Specific(TrueVal), m_Specific(FalseVal))))
+      return TrueVal;
+
     // (X || Y) ? false : X --> false (commuted 2 ways)
     if (match(Cond, m_c_LogicalOr(m_Specific(FalseVal), m_Value())) &&
         match(TrueVal, m_ZeroInt()))
       return ConstantInt::getFalse(Cond->getType());
 
     Value *X, *Y;
     if (match(FalseVal, m_ZeroInt())) {
       // !(X || Y) && X --> false (commuted 2 ways)

llvm/test/Transforms/InstSimplify/select-logical.ll

;
   %r = select i1 %or, i1 false, i1 %z
   ret i1 %r
 }
 
 ; (X || Y) ? X : Y --> X
 
 define i1 @select_or_same_op(i1 %x, i1 %y) {
 ; CHECK-LABEL: @select_or_same_op(
-; CHECK-NEXT:    [[OR:%.*]] = or i1 [[X:%.*]], [[Y:%.*]]
-; CHECK-NEXT:    [[R:%.*]] = select i1 [[OR]], i1 [[X]], i1 [[Y]]
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 [[X:%.*]]
 ;
   %or = or i1 %x, %y
   %r = select i1 %or, i1 %x, i1 %y
   ret i1 %r
 }
 
 
 define i1 @select_or_same_op_commute(i1 %x, i1 %y) {
 ; CHECK-LABEL: @select_or_same_op_commute(
-; CHECK-NEXT:    [[OR:%.*]] = or i1 [[X:%.*]], [[Y:%.*]]
-; CHECK-NEXT:    [[R:%.*]] = select i1 [[OR]], i1 [[Y]], i1 [[X]]
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 [[Y:%.*]]
 ;
   %or = or i1 %x, %y
   %r = select i1 %or, i1 %y, i1 %x
   ret i1 %r
 }
 
 
 define <2 x i1> @select_or_same_op_vector1(<2 x i1> %x, <2 x i1> %y) {
 ; CHECK-LABEL: @select_or_same_op_vector1(
-; CHECK-NEXT:    [[OR:%.*]] = or <2 x i1> [[X:%.*]], [[Y:%.*]]
-; CHECK-NEXT:    [[R:%.*]] = select <2 x i1> [[OR]], <2 x i1> [[X]], <2 x i1> [[Y]]
-; CHECK-NEXT:    ret <2 x i1> [[R]]
+; CHECK-NEXT:    ret <2 x i1> [[X:%.*]]
 ;
   %or = or <2 x i1> %x, %y
   %r = select <2 x i1> %or, <2 x i1> %x, <2 x i1> %y
   ret <2 x i1> %r
 }
 
 
 define i1 @select_logic_or1_same_op(i1 %x, i1 %y) {
 ; CHECK-LABEL: @select_logic_or1_same_op(
-; CHECK-NEXT:    [[OR:%.*]] = select i1 [[X:%.*]], i1 true, i1 [[Y:%.*]]
-; CHECK-NEXT:    [[R:%.*]] = select i1 [[OR]], i1 [[X]], i1 [[Y]]
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 [[X:%.*]]
 ;
   %or = select i1 %x, i1 true, i1 %y
   %r = select i1 %or, i1 %x, i1 %y
   ret i1 %r
 }
 
 
 define i1 @select_logic_or2_same_op(i1 %x, i1 %y) {
 ; CHECK-LABEL: @select_logic_or2_same_op(
-; CHECK-NEXT:    [[OR:%.*]] = select i1 [[Y:%.*]], i1 true, i1 [[X:%.*]]
-; CHECK-NEXT:    [[R:%.*]] = select i1 [[OR]], i1 [[X]], i1 [[Y]]
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 [[X:%.*]]
 ;
   %or = select i1 %y, i1 true, i1 %x
   %r = select i1 %or, i1 %x, i1 %y
   ret i1 %r
 }
 
 
 define <2 x i1> @select_or_same_op_vector2(<2 x i1> %x, <2 x i1> %y) {
 ; CHECK-LABEL: @select_or_same_op_vector2(
-; CHECK-NEXT:    [[OR:%.*]] = select <2 x i1> [[X:%.*]], <2 x i1> <i1 true, i1 true>, <2 x i1> [[Y:%.*]]
-; CHECK-NEXT:    [[R:%.*]] = select <2 x i1> [[OR]], <2 x i1> [[X]], <2 x i1> [[Y]]
-; CHECK-NEXT:    ret <2 x i1> [[R]]
+; CHECK-NEXT:    ret <2 x i1> [[X:%.*]]
 ;
   %or = select <2 x i1> %x, <2 x i1> <i1 true, i1 true>, <2 x i1> %y
   %r = select <2 x i1> %or, <2 x i1> %x, <2 x i1> %y
   ret <2 x i1> %r
 }
 
+; TODO: this could transform to X
+; (X || Y) ? X : Y --> X
 
 define <2 x i1> @select_or_same_op_vector2_poison(<2 x i1> %x, <2 x i1> %y) {
 ; CHECK-LABEL: @select_or_same_op_vector2_poison(
 ; CHECK-NEXT:    [[OR:%.*]] = select <2 x i1> [[X:%.*]], <2 x i1> <i1 true, i1 poison>, <2 x i1> [[Y:%.*]]
 ; CHECK-NEXT:    [[R:%.*]] = select <2 x i1> [[OR]], <2 x i1> [[X]], <2 x i1> [[Y]]
 ; CHECK-NEXT:    ret <2 x i1> [[R]]
 ;
   %or = select <2 x i1> %x, <2 x i1> <i1 true, i1 poison>, <2 x i1> %y
   %r = select <2 x i1> %or, <2 x i1> %x, <2 x i1> %y
   ret <2 x i1> %r