[InstCombine] Support BitTests in ThreeWayComparison. General case, part 2

[mkazantsev]

Summary

In this patch we continue supporting BitTests of the highest bit in the ThreeWayComparison
matcher in the InstCombine (see problem's description in the message of D45854).

This patch adds support for the transform of

%c2 = icmp slt %a, 0
%select1 = select %c2, %Less, %Greater

to

(%a s>> 31) - (%Less - %Greater) | %Greater

which is an alternative to

(%a s>> 31) - (%Less - %Greater) + %Greater

which applies if (%Less - %Greater) & %Greater == 0.

This is a part of fix of the bug 37147.

[lebedev.ri]

Please upload all patches with the full context (-U99999).

[mkazantsev]

Added context

[mkazantsev]

Formatted tests.

[mkazantsev]

We will try another approach to deal with the problem, see discussion in review of D45862.

[mkazantsev]

Abandoning in favour of D46086

lib/Transforms/InstCombine/InstCombineCompares.cpp

if (match(RHS, m_Zero())) {
       if (match(SI->getFalseValue(),
                 m_Add(m_And(m_AShr(m_Specific(LHS), m_Specific(ShiftValue)),
                             m_ConstantInt(LessMinusGreater)),
                       m_ConstantInt(Greater)))) {
         APInt LessI = LessMinusGreater->getValue() + Greater->getValue();
         Less = ConstantInt::get(Greater->getContext(), LessI);
         return true;
       }
+
+      // Try to recognize:
+      //   select i1 (a < 0), i32 Less, i32 Greater
+      // simplified in form:
+      //   (a s>> 31) & (Less - Greater) | Greater
+      // It is used instead of the pattern above in case if we can prove that
+      // ((Less - Greater) & Greater) = 0.
+      if (match(SI->getFalseValue(),
+                m_Or(m_And(m_AShr(m_Specific(LHS), m_Specific(ShiftValue)),
+                           m_ConstantInt(LessMinusGreater)),
+                     m_ConstantInt(Greater))) &&
+          (LessMinusGreater->getValue() & Greater->getValue()).isNullValue()) {
+        APInt LessI = LessMinusGreater->getValue() + Greater->getValue();
+        Less = ConstantInt::get(Greater->getContext(), LessI);
+        return true;
+      }
     }
   }
   return false;
 }
 
 Instruction *InstCombiner::foldICmpSelectConstant(ICmpInst &Cmp,
                                                   SelectInst *Select,
                                                   ConstantInt *C) {

test/Transforms/InstCombine/three-way-comparison.ll

 
 callfoo:
   call void @foo(i32 %select2)
   br label %exit
 
 exit:
   ret i32 42
 }
+
+; Same as @compare_against_arbitrary_value, but now the three-way comparison
+; returns not idiomatic comparator's result (-1, 0, 1) but some other constants.
+define i32 @compare_against_arbitrary_value_non_idiomatic_2(i32 %x, i32 %c) {
+
+; TODO: We can prove that if %x s< %c then %x != c, so there should be no actual
+;       calculations in callfoo block. @foo can be invoked with 425.
+
+; CHECK-LABEL: @compare_against_arbitrary_value_non_idiomatic_2
+; CHECK:       entry:
+; CHECK-NEXT:    [[COND:%.*]] = icmp sgt i32 %x, %c
+; CHECK-NEXT:    br i1 [[COND]], label %callfoo, label %exit
+; CHECK:       callfoo:
+; CHECK-NEXT:    call void @foo(i32 425)
+; CHECK-NEXT:    br label %exit
+; CHECK:       exit:
+; CHECK-NEXT:    ret i32 42
+
+entry:
+  %cmp1 = icmp eq i32 %x, %c
+  %cmp2 = icmp slt i32 %x, %c
+  %select1 = select i1 %cmp2, i32 -5, i32 425
+  %select2 = select i1 %cmp1, i32 0, i32 %select1
+  %cond = icmp sgt i32 %select2, 0
+  br i1 %cond, label %callfoo, label %exit
+
+callfoo:
+  call void @foo(i32 %select2)
+  br label %exit
+
+exit:
+  ret i32 42
+}
+
+define i32 @compare_against_zero_non_idiomatic_or(i32 %x) {
+
+; TODO: We can prove that if %x s< %c then %x != c, so there should be no actual
+;       calculations in callfoo block. @foo can be invoked with 425.
+
+; CHECK-LABEL: @compare_against_zero_non_idiomatic_or
+; CHECK:       entry:
+; CHECK-NEXT:    [[COND:%.*]] = icmp sgt i32 %x, 0
+; CHECK-NEXT:    br i1 [[COND]], label %callfoo, label %exit
+; CHECK:       callfoo:
+; CHECK-NEXT:    [[SHR:%.*]] = ashr i32 %x, 31
+; CHECK-NEXT:    [[AND:%.*]] = and i32 [[SHR]], -430
+; CHECK-NEXT:    [[ADD:%.*]] = or i32 [[AND]], 425
+; CHECK-NEXT:    call void @foo(i32 [[ADD]])
+; CHECK-NEXT:    br label %exit
+; CHECK:       exit:
+; CHECK-NEXT:    ret i32 42
+
+entry:
+  %cmp1 = icmp eq i32 %x, 0
+  %cmp2 = icmp slt i32 %x, 0
+  %select1 = select i1 %cmp2, i32 -5, i32 425
+  %select2 = select i1 %cmp1, i32 0, i32 %select1
+  %cond = icmp sgt i32 %select2, 0
+  br i1 %cond, label %callfoo, label %exit
+
+callfoo:
+  call void @foo(i32 %select2)
+  br label %exit
+
+exit:
+  ret i32 42
+}