[InstSimplify] peek through unsigned FP casts for sign-bit compares (PR36682)

[lebedev.ri]

Summary

This pattern came up in PR36682 / D44390
https://bugs.llvm.org/show_bug.cgi?id=36682
https://reviews.llvm.org/D44390
https://godbolt.org/g/oKvT5H

See also D44421, D44424

[lebedev.ri]

Rebased ontop of updated tests, moved to InstSimplify.
FIXME: should that code be in some other place, in some other function?

[lebedev.ri]

Rebased to fix test conflicts, NFC.

[spatel]

In D44425#1037229, @lebedev.ri wrote:

Rebased ontop of updated tests, moved to InstSimplify.
FIXME: should that code be in some other place, in some other function?

simplifyICmpWithConstant()? I think you'd have to put it above the m_APInt() check in that function in order to still get some of the vector tests with undef elements though.

test/Transforms/InstSimplify/cast-unsigned-icmp-cmp-0.ll

3–4

Please remove the datalayout comment.

6

Remove the 'FIXME' part of this.

10

This should be "m_Zero does not handle undef elements in vectors."

[lebedev.ri]

simplifyICmpWithConstant()? I think you'd have to put it above the m_APInt() check in that function in order to still get some of the vector tests with undef elements though.

Yep, thanks, looks less out-of-place there!

The GetCompareTy(RHS) change will be a preparatory NFC commit before the main commit.

[spatel]

LGTM.

lib/Analysis/InstructionSimplify.cpp

static void setLimitsForBinOp(BinaryOperator &BO, APInt &Lower, APInt &Upper) {
 
   default:
     break;
   }
 }
 
 static Value *simplifyICmpWithConstant(CmpInst::Predicate Pred, Value *LHS,
                                        Value *RHS) {
+  Type *ITy = GetCompareTy(RHS); // The return type.
+
+  Value *X;
+  // Sign-bit checks can be optimized to true/false after unsigned
+  // floating-point casts:
+  // icmp slt (bitcast (uitofp X)),  0 --> false
+  // icmp sgt (bitcast (uitofp X)), -1 --> true
+  if (match(LHS, m_BitCast(m_UIToFP(m_Value(X))))) {
+    if (Pred == ICmpInst::ICMP_SLT && match(RHS, m_Zero()))
+      return ConstantInt::getFalse(ITy);
+    if (Pred == ICmpInst::ICMP_SGT && match(RHS, m_AllOnes()))
+      return ConstantInt::getTrue(ITy);
+  }
+
   const APInt *C;
   if (!match(RHS, m_APInt(C)))
     return nullptr;
 
   // Rule out tautological comparisons (eg., ult 0 or uge 0).
   ConstantRange RHS_CR = ConstantRange::makeExactICmpRegion(Pred, *C);
   if (RHS_CR.isEmptySet())
-    return ConstantInt::getFalse(GetCompareTy(RHS));
+    return ConstantInt::getFalse(ITy);
   if (RHS_CR.isFullSet())
-    return ConstantInt::getTrue(GetCompareTy(RHS));
+    return ConstantInt::getTrue(ITy);
 
   // Find the range of possible values for binary operators.
   unsigned Width = C->getBitWidth();
   APInt Lower = APInt(Width, 0);
   APInt Upper = APInt(Width, 0);
   if (auto *BO = dyn_cast<BinaryOperator>(LHS))
     setLimitsForBinOp(*BO, Lower, Upper);
 
   ConstantRange LHS_CR =
       Lower != Upper ? ConstantRange(Lower, Upper) : ConstantRange(Width, true);
 
   if (auto *I = dyn_cast<Instruction>(LHS))
     if (auto *Ranges = I->getMetadata(LLVMContext::MD_range))
       LHS_CR = LHS_CR.intersectWith(getConstantRangeFromMetadata(*Ranges));
 
   if (!LHS_CR.isFullSet()) {
     if (RHS_CR.contains(LHS_CR))
-      return ConstantInt::getTrue(GetCompareTy(RHS));
+      return ConstantInt::getTrue(ITy);
     if (RHS_CR.inverse().contains(LHS_CR))
-      return ConstantInt::getFalse(GetCompareTy(RHS));
+      return ConstantInt::getFalse(ITy);
   }
 
   return nullptr;
 }
 
 /// TODO: A large part of this logic is duplicated in InstCombine's
 /// foldICmpBinOp(). We should be able to share that and avoid the code
 /// duplication.

test/Transforms/InstSimplify/cast-unsigned-icmp-cmp-0.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -instsimplify -S | FileCheck %s
 
-; target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-
 ; This is related to https://bugs.llvm.org/show_bug.cgi?id=36682
 
-; FIXME: All of these can be simplified to a constant true or false value.
+; All of these can be simplified to a constant true or false value.
 ;   * slt i32 %b, 0  -> false
 ;   * sgt i32 %b, -1 -> true
 
+; FIXME: m_Zero does not handle undef elements in vectors.
+
 define i1 @i32_cast_cmp_slt_int_0_uitofp_float(i32 %i) {
 ; CHECK-LABEL: @i32_cast_cmp_slt_int_0_uitofp_float(
-; CHECK-NEXT:    [[F:%.*]] = uitofp i32 [[I:%.*]] to float
-; CHECK-NEXT:    [[B:%.*]] = bitcast float [[F]] to i32
-; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[B]], 0
-; CHECK-NEXT:    ret i1 [[CMP]]
+; CHECK-NEXT:    ret i1 false
 ;
   %f = uitofp i32 %i to float
   %b = bitcast float %f to i32
   %cmp = icmp slt i32 %b, 0
   ret i1 %cmp
 }
 
 define <2 x i1> @i32_cast_cmp_slt_int_0_uitofp_float_vec(<2 x i32> %i) {
 ; CHECK-LABEL: @i32_cast_cmp_slt_int_0_uitofp_float_vec(
-; CHECK-NEXT:    [[F:%.*]] = uitofp <2 x i32> [[I:%.*]] to <2 x float>
-; CHECK-NEXT:    [[B:%.*]] = bitcast <2 x float> [[F]] to <2 x i32>
-; CHECK-NEXT:    [[CMP:%.*]] = icmp slt <2 x i32> [[B]], zeroinitializer
-; CHECK-NEXT:    ret <2 x i1> [[CMP]]
+; CHECK-NEXT:    ret <2 x i1> zeroinitializer
 ;
   %f = uitofp <2 x i32> %i to <2 x float>
   %b = bitcast <2 x float> %f to <2 x i32>
   %cmp = icmp slt <2 x i32> %b, <i32 0, i32 0>
   ret <2 x i1> %cmp
 }
 
 define <3 x i1> @i32_cast_cmp_slt_int_0_uitofp_float_vec_undef(<3 x i32> %i) {
 ; CHECK-LABEL: @i32_cast_cmp_slt_int_0_uitofp_float_vec_undef(
 ; CHECK-NEXT:    [[F:%.*]] = uitofp <3 x i32> [[I:%.*]] to <3 x float>
 ; CHECK-NEXT:    [[B:%.*]] = bitcast <3 x float> [[F]] to <3 x i32>
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt <3 x i32> [[B]], <i32 0, i32 undef, i32 0>
 ; CHECK-NEXT:    ret <3 x i1> [[CMP]]
 ;
   %f = uitofp <3 x i32> %i to <3 x float>
   %b = bitcast <3 x float> %f to <3 x i32>
   %cmp = icmp slt <3 x i32> %b, <i32 0, i32 undef, i32 0>
   ret <3 x i1> %cmp
 }
 
 define i1 @i32_cast_cmp_sgt_int_m1_uitofp_float(i32 %i) {
 ; CHECK-LABEL: @i32_cast_cmp_sgt_int_m1_uitofp_float(
-; CHECK-NEXT:    [[F:%.*]] = uitofp i32 [[I:%.*]] to float
-; CHECK-NEXT:    [[B:%.*]] = bitcast float [[F]] to i32
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i32 [[B]], -1
-; CHECK-NEXT:    ret i1 [[CMP]]
+; CHECK-NEXT:    ret i1 true
 ;
   %f = uitofp i32 %i to float
   %b = bitcast float %f to i32
   %cmp = icmp sgt i32 %b, -1
   ret i1 %cmp
 }
 
 define <2 x i1> @i32_cast_cmp_sgt_int_m1_uitofp_float_vec(<2 x i32> %i) {
 ; CHECK-LABEL: @i32_cast_cmp_sgt_int_m1_uitofp_float_vec(
-; CHECK-NEXT:    [[F:%.*]] = uitofp <2 x i32> [[I:%.*]] to <2 x float>
-; CHECK-NEXT:    [[B:%.*]] = bitcast <2 x float> [[F]] to <2 x i32>
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt <2 x i32> [[B]], <i32 -1, i32 -1>
-; CHECK-NEXT:    ret <2 x i1> [[CMP]]
+; CHECK-NEXT:    ret <2 x i1> <i1 true, i1 true>
 ;
   %f = uitofp <2 x i32> %i to <2 x float>
   %b = bitcast <2 x float> %f to <2 x i32>
   %cmp = icmp sgt <2 x i32> %b, <i32 -1, i32 -1>
   ret <2 x i1> %cmp
 }
 
 define <3 x i1> @i32_cast_cmp_sgt_int_m1_uitofp_float_vec_undef(<3 x i32> %i) {
 ; CHECK-LABEL: @i32_cast_cmp_sgt_int_m1_uitofp_float_vec_undef(
-; CHECK-NEXT:    [[F:%.*]] = uitofp <3 x i32> [[I:%.*]] to <3 x float>
-; CHECK-NEXT:    [[B:%.*]] = bitcast <3 x float> [[F]] to <3 x i32>
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt <3 x i32> [[B]], <i32 -1, i32 undef, i32 -1>
-; CHECK-NEXT:    ret <3 x i1> [[CMP]]
+; CHECK-NEXT:    ret <3 x i1> <i1 true, i1 true, i1 true>
 ;
   %f = uitofp <3 x i32> %i to <3 x float>
   %b = bitcast <3 x float> %f to <3 x i32>
   %cmp = icmp sgt <3 x i32> %b, <i32 -1, i32 undef, i32 -1>
   ret <3 x i1> %cmp
 }
 
 define i1 @i32_cast_cmp_slt_int_0_uitofp_double(i32 %i) {
 ; CHECK-LABEL: @i32_cast_cmp_slt_int_0_uitofp_double(
-; CHECK-NEXT:    [[F:%.*]] = uitofp i32 [[I:%.*]] to double
-; CHECK-NEXT:    [[B:%.*]] = bitcast double [[F]] to i64
-; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i64 [[B]], 0
-; CHECK-NEXT:    ret i1 [[CMP]]
+; CHECK-NEXT:    ret i1 false
 ;
   %f = uitofp i32 %i to double
   %b = bitcast double %f to i64
   %cmp = icmp slt i64 %b, 0
   ret i1 %cmp
 }
 
 define <2 x i1> @i32_cast_cmp_slt_int_0_uitofp_double_vec(<2 x i32> %i) {
 ; CHECK-LABEL: @i32_cast_cmp_slt_int_0_uitofp_double_vec(
-; CHECK-NEXT:    [[F:%.*]] = uitofp <2 x i32> [[I:%.*]] to <2 x double>
-; CHECK-NEXT:    [[B:%.*]] = bitcast <2 x double> [[F]] to <2 x i64>
-; CHECK-NEXT:    [[CMP:%.*]] = icmp slt <2 x i64> [[B]], zeroinitializer
-; CHECK-NEXT:    ret <2 x i1> [[CMP]]
+; CHECK-NEXT:    ret <2 x i1> zeroinitializer
 ;
   %f = uitofp <2 x i32> %i to <2 x double>
   %b = bitcast <2 x double> %f to <2 x i64>
   %cmp = icmp slt <2 x i64> %b, <i64 0, i64 0>
   ret <2 x i1> %cmp
 }
 
 define <3 x i1> @i32_cast_cmp_slt_int_0_uitofp_double_vec_undef(<3 x i32> %i) {
 ; CHECK-LABEL: @i32_cast_cmp_slt_int_0_uitofp_double_vec_undef(
 ; CHECK-NEXT:    [[F:%.*]] = uitofp <3 x i32> [[I:%.*]] to <3 x double>
 ; CHECK-NEXT:    [[B:%.*]] = bitcast <3 x double> [[F]] to <3 x i64>
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt <3 x i64> [[B]], <i64 0, i64 undef, i64 0>
 ; CHECK-NEXT:    ret <3 x i1> [[CMP]]
 ;
   %f = uitofp <3 x i32> %i to <3 x double>
   %b = bitcast <3 x double> %f to <3 x i64>
   %cmp = icmp slt <3 x i64> %b, <i64 0, i64 undef, i64 0>
   ret <3 x i1> %cmp
 }
 
 define i1 @i32_cast_cmp_sgt_int_m1_uitofp_double(i32 %i) {
 ; CHECK-LABEL: @i32_cast_cmp_sgt_int_m1_uitofp_double(
-; CHECK-NEXT:    [[F:%.*]] = uitofp i32 [[I:%.*]] to double
-; CHECK-NEXT:    [[B:%.*]] = bitcast double [[F]] to i64
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i64 [[B]], -1
-; CHECK-NEXT:    ret i1 [[CMP]]
+; CHECK-NEXT:    ret i1 true
 ;
   %f = uitofp i32 %i to double
   %b = bitcast double %f to i64
   %cmp = icmp sgt i64 %b, -1
   ret i1 %cmp
 }
 
 define <2 x i1> @i32_cast_cmp_sgt_int_m1_uitofp_double_vec(<2 x i32> %i) {
 ; CHECK-LABEL: @i32_cast_cmp_sgt_int_m1_uitofp_double_vec(
-; CHECK-NEXT:    [[F:%.*]] = uitofp <2 x i32> [[I:%.*]] to <2 x double>
-; CHECK-NEXT:    [[B:%.*]] = bitcast <2 x double> [[F]] to <2 x i64>
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt <2 x i64> [[B]], <i64 -1, i64 -1>
-; CHECK-NEXT:    ret <2 x i1> [[CMP]]
+; CHECK-NEXT:    ret <2 x i1> <i1 true, i1 true>
 ;
   %f = uitofp <2 x i32> %i to <2 x double>
   %b = bitcast <2 x double> %f to <2 x i64>
   %cmp = icmp sgt <2 x i64> %b, <i64 -1, i64 -1>
   ret <2 x i1> %cmp
 }
 
 define <3 x i1> @i32_cast_cmp_sgt_int_m1_uitofp_double_vec_undef(<3 x i32> %i) {
 ; CHECK-LABEL: @i32_cast_cmp_sgt_int_m1_uitofp_double_vec_undef(
-; CHECK-NEXT:    [[F:%.*]] = uitofp <3 x i32> [[I:%.*]] to <3 x double>
-; CHECK-NEXT:    [[B:%.*]] = bitcast <3 x double> [[F]] to <3 x i64>
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt <3 x i64> [[B]], <i64 -1, i64 undef, i64 -1>
-; CHECK-NEXT:    ret <3 x i1> [[CMP]]
+; CHECK-NEXT:    ret <3 x i1> <i1 true, i1 true, i1 true>
 ;
   %f = uitofp <3 x i32> %i to <3 x double>
   %b = bitcast <3 x double> %f to <3 x i64>
   %cmp = icmp sgt <3 x i64> %b, <i64 -1, i64 undef, i64 -1>
   ret <3 x i1> %cmp
 }
 
 define i1 @i32_cast_cmp_slt_int_0_uitofp_half(i32 %i) {
 ; CHECK-LABEL: @i32_cast_cmp_slt_int_0_uitofp_half(
-; CHECK-NEXT:    [[F:%.*]] = uitofp i32 [[I:%.*]] to half
-; CHECK-NEXT:    [[B:%.*]] = bitcast half [[F]] to i16
-; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i16 [[B]], 0
-; CHECK-NEXT:    ret i1 [[CMP]]
+; CHECK-NEXT:    ret i1 false
 ;
   %f = uitofp i32 %i to half
   %b = bitcast half %f to i16
   %cmp = icmp slt i16 %b, 0
   ret i1 %cmp
 }
 
 define <2 x i1> @i32_cast_cmp_slt_int_0_uitofp_half_vec(<2 x i32> %i) {
 ; CHECK-LABEL: @i32_cast_cmp_slt_int_0_uitofp_half_vec(
-; CHECK-NEXT:    [[F:%.*]] = uitofp <2 x i32> [[I:%.*]] to <2 x half>
-; CHECK-NEXT:    [[B:%.*]] = bitcast <2 x half> [[F]] to <2 x i16>
-; CHECK-NEXT:    [[CMP:%.*]] = icmp slt <2 x i16> [[B]], zeroinitializer
-; CHECK-NEXT:    ret <2 x i1> [[CMP]]
+; CHECK-NEXT:    ret <2 x i1> zeroinitializer
 ;
   %f = uitofp <2 x i32> %i to <2 x half>
   %b = bitcast <2 x half> %f to <2 x i16>
   %cmp = icmp slt <2 x i16> %b, <i16 0, i16 0>
   ret <2 x i1> %cmp
 }
 
 define <3 x i1> @i32_cast_cmp_slt_int_0_uitofp_half_vec_undef(<3 x i32> %i) {
 ; CHECK-LABEL: @i32_cast_cmp_slt_int_0_uitofp_half_vec_undef(
 ; CHECK-NEXT:    [[F:%.*]] = uitofp <3 x i32> [[I:%.*]] to <3 x half>
 ; CHECK-NEXT:    [[B:%.*]] = bitcast <3 x half> [[F]] to <3 x i16>
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt <3 x i16> [[B]], <i16 0, i16 undef, i16 0>
 ; CHECK-NEXT:    ret <3 x i1> [[CMP]]
 ;
   %f = uitofp <3 x i32> %i to <3 x half>
   %b = bitcast <3 x half> %f to <3 x i16>
   %cmp = icmp slt <3 x i16> %b, <i16 0, i16 undef, i16 0>
   ret <3 x i1> %cmp
 }
 
 define i1 @i32_cast_cmp_sgt_int_m1_uitofp_half(i32 %i) {
 ; CHECK-LABEL: @i32_cast_cmp_sgt_int_m1_uitofp_half(
-; CHECK-NEXT:    [[F:%.*]] = uitofp i32 [[I:%.*]] to half
-; CHECK-NEXT:    [[B:%.*]] = bitcast half [[F]] to i16
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i16 [[B]], -1
-; CHECK-NEXT:    ret i1 [[CMP]]
+; CHECK-NEXT:    ret i1 true
 ;
   %f = uitofp i32 %i to half
   %b = bitcast half %f to i16
   %cmp = icmp sgt i16 %b, -1
   ret i1 %cmp
 }
 
 define <2 x i1> @i32_cast_cmp_sgt_int_m1_uitofp_half_vec(<2 x i32> %i) {
 ; CHECK-LABEL: @i32_cast_cmp_sgt_int_m1_uitofp_half_vec(
-; CHECK-NEXT:    [[F:%.*]] = uitofp <2 x i32> [[I:%.*]] to <2 x half>
-; CHECK-NEXT:    [[B:%.*]] = bitcast <2 x half> [[F]] to <2 x i16>
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt <2 x i16> [[B]], <i16 -1, i16 -1>
-; CHECK-NEXT:    ret <2 x i1> [[CMP]]
+; CHECK-NEXT:    ret <2 x i1> <i1 true, i1 true>
 ;
   %f = uitofp <2 x i32> %i to <2 x half>
   %b = bitcast <2 x half> %f to <2 x i16>
   %cmp = icmp sgt <2 x i16> %b, <i16 -1, i16 -1>
   ret <2 x i1> %cmp
 }
 
 define <3 x i1> @i32_cast_cmp_sgt_int_m1_uitofp_half_vec_undef(<3 x i32> %i) {
 ; CHECK-LABEL: @i32_cast_cmp_sgt_int_m1_uitofp_half_vec_undef(
-; CHECK-NEXT:    [[F:%.*]] = uitofp <3 x i32> [[I:%.*]] to <3 x half>
-; CHECK-NEXT:    [[B:%.*]] = bitcast <3 x half> [[F]] to <3 x i16>
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt <3 x i16> [[B]], <i16 -1, i16 undef, i16 -1>
-; CHECK-NEXT:    ret <3 x i1> [[CMP]]
+; CHECK-NEXT:    ret <3 x i1> <i1 true, i1 true, i1 true>
 ;
   %f = uitofp <3 x i32> %i to <3 x half>
   %b = bitcast <3 x half> %f to <3 x i16>
   %cmp = icmp sgt <3 x i16> %b, <i16 -1, i16 undef, i16 -1>
   ret <3 x i1> %cmp
 }