[InstCombine] peek through unsigned FP casts for zero-equality 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 D44416

[lebedev.ri]

Just use isEquality().

[lebedev.ri]

Rebased ontop of updated tests.

[lebedev.ri]

This comment was removed by lebedev.ri.

[spatel]

LGTM. See inline for a couple of nits.

lib/Transforms/InstCombine/InstCombineCompares.cpp

4516

Don't need braces for the single-line 'if' clause.

test/Transforms/InstCombine/cast-unsigned-icmp-eqcmp-0.ll

4

Remove unnecessary comment line.

[lebedev.ri]

Thank you for the review!

lib/Transforms/InstCombine/InstCombineCompares.cpp

4516

It occupies more than one line though.
But ok, if you insist.

test/Transforms/InstCombine/cast-unsigned-icmp-eqcmp-0.ll

4

For future reference, could you please clarify *when* target datalayout should be specified in tests?

[spatel]

lib/Transforms/InstCombine/InstCombineCompares.cpp

4516

It's a fuzzy rule, so I was just going by the formatting of the code above this.

test/Transforms/InstCombine/cast-unsigned-icmp-eqcmp-0.ll

4

Sure - it should be specified when it affects the outcome. For instcombine, this would be when endianness or type legality is used to determine if/how a transform fires. So you'd see some query of the datalayout in the code.

Note that in this case, the line is commented out, so it definitely doesn't add anything to the test....unless I've missed some reason for it to be specified as a comment?

[lebedev.ri]

lib/Transforms/InstCombine/InstCombineCompares.cpp

4516

Ok, consistency reason is good.

test/Transforms/InstCombine/cast-unsigned-icmp-eqcmp-0.ll

4

Note that in this case, the line is commented out, so it definitely doesn't add anything to the test....

Oops, i kinda missed that :)

unless I've missed some reason for it to be specified as a comment?

Not that i know of.

Ok, will drop it.

[lebedev.ri]

This comment was removed by lebedev.ri.

lib/Transforms/InstCombine/InstCombineCompares.cpp

if (Op0->getType()->isPointerTy() && I.isEquality()) {
     if (auto *Alloca = dyn_cast<AllocaInst>(GetUnderlyingObject(Op0, DL)))
       if (Instruction *New = foldAllocaCmp(I, Alloca, Op1))
         return New;
     if (auto *Alloca = dyn_cast<AllocaInst>(GetUnderlyingObject(Op1, DL)))
       if (Instruction *New = foldAllocaCmp(I, Alloca, Op0))
         return New;
   }
 
+  // Zero-equality checks are preserved through unsigned floating-point casts:
+  // icmp eq (bitcast (uitofp X)), 0 --> icmp eq X, 0
+  // icmp ne (bitcast (uitofp X)), 0 --> icmp ne X, 0
+  Value *X;
+  if (match(Op0, m_BitCast(m_UIToFP(m_Value(X))))) {
+    if ((Pred == ICmpInst::ICMP_EQ || Pred == ICmpInst::ICMP_NE) &&
+        match(Op1, m_Zero()))
+      return new ICmpInst(Pred, X, ConstantInt::getNullValue(X->getType()));
+  }
+
   // Test to see if the operands of the icmp are casted versions of other
   // values.  If the ptr->ptr cast can be stripped off both arguments, we do so
   // now.
   if (BitCastInst *CI = dyn_cast<BitCastInst>(Op0)) {
     if (Op0->getType()->isPointerTy() &&
         (isa<Constant>(Op1) || isa<BitCastInst>(Op1))) {
       // We keep moving the cast from the left operand over to the right
       // operand, where it can often be eliminated completely.

test/Transforms/InstCombine/cast-unsigned-icmp-eqcmp-0.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -instcombine -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 are true tests.
 ; In *all* of these, uitofp and bitcast should be instcombine'd out.
 
+; FIXME: vector cases are not handled. The matchers should look through undef.
+
 define i1 @i32_cast_cmp_eq_int_0_uitofp_float(i32 %i) {
 ; CHECK-LABEL: @i32_cast_cmp_eq_int_0_uitofp_float(
-; CHECK-NEXT:    [[F:%.*]] = uitofp i32 [[I:%.*]] to float
-; CHECK-NEXT:    [[B:%.*]] = bitcast float [[F]] to i32
-; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[B]], 0
+; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[I:%.*]], 0
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %f = uitofp i32 %i to float
   %b = bitcast float %f to i32
   %cmp = icmp eq i32 %b, 0
   ret i1 %cmp
 }
 
 define <3 x i1> @i32_cast_cmp_eq_int_0_uitofp_float_vec(<3 x i32> %i) {
 ; CHECK-LABEL: @i32_cast_cmp_eq_int_0_uitofp_float_vec(
 ; 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 eq <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 eq <3 x i32> %b, <i32 0, i32 undef, i32 0>
   ret <3 x i1> %cmp
 }
 
 define i1 @i32_cast_cmp_ne_int_0_uitofp_float(i32 %i) {
 ; CHECK-LABEL: @i32_cast_cmp_ne_int_0_uitofp_float(
-; CHECK-NEXT:    [[F:%.*]] = uitofp i32 [[I:%.*]] to float
-; CHECK-NEXT:    [[B:%.*]] = bitcast float [[F]] to i32
-; CHECK-NEXT:    [[CMP:%.*]] = icmp ne i32 [[B]], 0
+; CHECK-NEXT:    [[CMP:%.*]] = icmp ne i32 [[I:%.*]], 0
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %f = uitofp i32 %i to float
   %b = bitcast float %f to i32
   %cmp = icmp ne i32 %b, 0
   ret i1 %cmp
 }
 
 define <3 x i1> @i32_cast_cmp_ne_int_0_uitofp_float_vec(<3 x i32> %i) {
 ; CHECK-LABEL: @i32_cast_cmp_ne_int_0_uitofp_float_vec(
 ; 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 ne <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 ne <3 x i32> %b, <i32 0, i32 undef, i32 0>
   ret <3 x i1> %cmp
 }
 
 define i1 @i32_cast_cmp_eq_int_0_uitofp_double(i32 %i) {
 ; CHECK-LABEL: @i32_cast_cmp_eq_int_0_uitofp_double(
-; CHECK-NEXT:    [[F:%.*]] = uitofp i32 [[I:%.*]] to double
-; CHECK-NEXT:    [[B:%.*]] = bitcast double [[F]] to i64
-; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i64 [[B]], 0
+; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[I:%.*]], 0
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %f = uitofp i32 %i to double
   %b = bitcast double %f to i64
   %cmp = icmp eq i64 %b, 0
   ret i1 %cmp
 }
 
 define <3 x i1> @i32_cast_cmp_eq_int_0_uitofp_double_vec(<3 x i32> %i) {
 ; CHECK-LABEL: @i32_cast_cmp_eq_int_0_uitofp_double_vec(
 ; 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 eq <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 eq <3 x i64> %b, <i64 0, i64 undef, i64 0>
   ret <3 x i1> %cmp
 }
 
 define i1 @i32_cast_cmp_ne_int_0_uitofp_double(i32 %i) {
 ; CHECK-LABEL: @i32_cast_cmp_ne_int_0_uitofp_double(
-; CHECK-NEXT:    [[F:%.*]] = uitofp i32 [[I:%.*]] to double
-; CHECK-NEXT:    [[B:%.*]] = bitcast double [[F]] to i64
-; CHECK-NEXT:    [[CMP:%.*]] = icmp ne i64 [[B]], 0
+; CHECK-NEXT:    [[CMP:%.*]] = icmp ne i32 [[I:%.*]], 0
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %f = uitofp i32 %i to double
   %b = bitcast double %f to i64
   %cmp = icmp ne i64 %b, 0
   ret i1 %cmp
 }
 
 define <3 x i1> @i32_cast_cmp_ne_int_0_uitofp_double_vec(<3 x i32> %i) {
 ; CHECK-LABEL: @i32_cast_cmp_ne_int_0_uitofp_double_vec(
 ; 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 ne <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 ne <3 x i64> %b, <i64 0, i64 undef, i64 0>
   ret <3 x i1> %cmp
 }
 
 define i1 @i32_cast_cmp_eq_int_0_uitofp_half(i32 %i) {
 ; CHECK-LABEL: @i32_cast_cmp_eq_int_0_uitofp_half(
-; CHECK-NEXT:    [[F:%.*]] = uitofp i32 [[I:%.*]] to half
-; CHECK-NEXT:    [[B:%.*]] = bitcast half [[F]] to i16
-; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i16 [[B]], 0
+; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[I:%.*]], 0
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %f = uitofp i32 %i to half
   %b = bitcast half %f to i16
   %cmp = icmp eq i16 %b, 0
   ret i1 %cmp
 }
 
 define <3 x i1> @i32_cast_cmp_eq_int_0_uitofp_half_vec(<3 x i32> %i) {
 ; CHECK-LABEL: @i32_cast_cmp_eq_int_0_uitofp_half_vec(
 ; 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 eq <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 eq <3 x i16> %b, <i16 0, i16 undef, i16 0>
   ret <3 x i1> %cmp
 }
 
 define i1 @i32_cast_cmp_ne_int_0_uitofp_half(i32 %i) {
 ; CHECK-LABEL: @i32_cast_cmp_ne_int_0_uitofp_half(
-; CHECK-NEXT:    [[F:%.*]] = uitofp i32 [[I:%.*]] to half
-; CHECK-NEXT:    [[B:%.*]] = bitcast half [[F]] to i16
-; CHECK-NEXT:    [[CMP:%.*]] = icmp ne i16 [[B]], 0
+; CHECK-NEXT:    [[CMP:%.*]] = icmp ne i32 [[I:%.*]], 0
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %f = uitofp i32 %i to half
   %b = bitcast half %f to i16
   %cmp = icmp ne i16 %b, 0
   ret i1 %cmp
 }
 
 define <3 x i1> @i32_cast_cmp_ne_int_0_uitofp_half_vec(<3 x i32> %i) {
 ; CHECK-LABEL: @i32_cast_cmp_ne_int_0_uitofp_half_vec(
 ; 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 ne <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 ne <3 x i16> %b, <i16 0, i16 undef, i16 0>
   ret <3 x i1> %cmp
 }
 
 define i1 @i64_cast_cmp_eq_int_0_uitofp_float(i64 %i) {
 ; CHECK-LABEL: @i64_cast_cmp_eq_int_0_uitofp_float(
-; CHECK-NEXT:    [[F:%.*]] = uitofp i64 [[I:%.*]] to float
-; CHECK-NEXT:    [[B:%.*]] = bitcast float [[F]] to i32
-; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[B]], 0
+; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i64 [[I:%.*]], 0
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %f = uitofp i64 %i to float
   %b = bitcast float %f to i32
   %cmp = icmp eq i32 %b, 0
   ret i1 %cmp
 }
 
 define <3 x i1> @i64_cast_cmp_eq_int_0_uitofp_float_vec(<3 x i64> %i) {
 ; CHECK-LABEL: @i64_cast_cmp_eq_int_0_uitofp_float_vec(
 ; CHECK-NEXT:    [[F:%.*]] = uitofp <3 x i64> [[I:%.*]] to <3 x float>
 ; CHECK-NEXT:    [[B:%.*]] = bitcast <3 x float> [[F]] to <3 x i32>
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq <3 x i32> [[B]], <i32 0, i32 undef, i32 0>
 ; CHECK-NEXT:    ret <3 x i1> [[CMP]]
 ;
   %f = uitofp <3 x i64> %i to  <3 x float>
   %b = bitcast <3 x float> %f to <3 x i32>
   %cmp = icmp eq <3 x i32> %b, <i32 0, i32 undef, i32 0>
   ret <3 x i1> %cmp
 }
 
 define i1 @i64_cast_cmp_ne_int_0_uitofp_float(i64 %i) {
 ; CHECK-LABEL: @i64_cast_cmp_ne_int_0_uitofp_float(
-; CHECK-NEXT:    [[F:%.*]] = uitofp i64 [[I:%.*]] to float
-; CHECK-NEXT:    [[B:%.*]] = bitcast float [[F]] to i32
-; CHECK-NEXT:    [[CMP:%.*]] = icmp ne i32 [[B]], 0
+; CHECK-NEXT:    [[CMP:%.*]] = icmp ne i64 [[I:%.*]], 0
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %f = uitofp i64 %i to float
   %b = bitcast float %f to i32
   %cmp = icmp ne i32 %b, 0
   ret i1 %cmp
 }
 
 define <3 x i1> @i64_cast_cmp_ne_int_0_uitofp_float_vec(<3 x i64> %i) {
 ; CHECK-LABEL: @i64_cast_cmp_ne_int_0_uitofp_float_vec(
 ; CHECK-NEXT:    [[F:%.*]] = uitofp <3 x i64> [[I:%.*]] to <3 x float>
 ; CHECK-NEXT:    [[B:%.*]] = bitcast <3 x float> [[F]] to <3 x i32>
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ne <3 x i32> [[B]], <i32 0, i32 undef, i32 0>
 ; CHECK-NEXT:    ret <3 x i1> [[CMP]]
 ;
   %f = uitofp <3 x i64> %i to  <3 x float>
   %b = bitcast <3 x float> %f to <3 x i32>
   %cmp = icmp ne <3 x i32> %b, <i32 0, i32 undef, i32 0>
   ret <3 x i1> %cmp
 }
 
 define i1 @i64_cast_cmp_eq_int_0_uitofp_double(i64 %i) {
 ; CHECK-LABEL: @i64_cast_cmp_eq_int_0_uitofp_double(
-; CHECK-NEXT:    [[F:%.*]] = uitofp i64 [[I:%.*]] to double
-; CHECK-NEXT:    [[B:%.*]] = bitcast double [[F]] to i64
-; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i64 [[B]], 0
+; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i64 [[I:%.*]], 0
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %f = uitofp i64 %i to double
   %b = bitcast double %f to i64
   %cmp = icmp eq i64 %b, 0
   ret i1 %cmp
 }
 
 define <3 x i1> @i64_cast_cmp_eq_int_0_uitofp_double_vec(<3 x i64> %i) {
 ; CHECK-LABEL: @i64_cast_cmp_eq_int_0_uitofp_double_vec(
 ; CHECK-NEXT:    [[F:%.*]] = uitofp <3 x i64> [[I:%.*]] to <3 x double>
 ; CHECK-NEXT:    [[B:%.*]] = bitcast <3 x double> [[F]] to <3 x i64>
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq <3 x i64> [[B]], <i64 0, i64 undef, i64 0>
 ; CHECK-NEXT:    ret <3 x i1> [[CMP]]
 ;
   %f = uitofp <3 x i64> %i to  <3 x double>
   %b = bitcast <3 x double> %f to <3 x i64>
   %cmp = icmp eq <3 x i64> %b, <i64 0, i64 undef, i64 0>
   ret <3 x i1> %cmp
 }
 
 define i1 @i64_cast_cmp_ne_int_0_uitofp_double(i64 %i) {
 ; CHECK-LABEL: @i64_cast_cmp_ne_int_0_uitofp_double(
-; CHECK-NEXT:    [[F:%.*]] = uitofp i64 [[I:%.*]] to double
-; CHECK-NEXT:    [[B:%.*]] = bitcast double [[F]] to i64
-; CHECK-NEXT:    [[CMP:%.*]] = icmp ne i64 [[B]], 0
+; CHECK-NEXT:    [[CMP:%.*]] = icmp ne i64 [[I:%.*]], 0
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %f = uitofp i64 %i to double
   %b = bitcast double %f to i64
   %cmp = icmp ne i64 %b, 0
   ret i1 %cmp
 }
 
 define <3 x i1> @i64_cast_cmp_ne_int_0_uitofp_double_vec(<3 x i64> %i) {
 ; CHECK-LABEL: @i64_cast_cmp_ne_int_0_uitofp_double_vec(
 ; CHECK-NEXT:    [[F:%.*]] = uitofp <3 x i64> [[I:%.*]] to <3 x double>
 ; CHECK-NEXT:    [[B:%.*]] = bitcast <3 x double> [[F]] to <3 x i64>
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ne <3 x i64> [[B]], <i64 0, i64 undef, i64 0>
 ; CHECK-NEXT:    ret <3 x i1> [[CMP]]
 ;
   %f = uitofp <3 x i64> %i to  <3 x double>
   %b = bitcast <3 x double> %f to <3 x i64>
   %cmp = icmp ne <3 x i64> %b, <i64 0, i64 undef, i64 0>
   ret <3 x i1> %cmp
 }
 
 define i1 @i64_cast_cmp_eq_int_0_uitofp_half(i64 %i) {
 ; CHECK-LABEL: @i64_cast_cmp_eq_int_0_uitofp_half(
-; CHECK-NEXT:    [[F:%.*]] = uitofp i64 [[I:%.*]] to half
-; CHECK-NEXT:    [[B:%.*]] = bitcast half [[F]] to i16
-; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i16 [[B]], 0
+; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i64 [[I:%.*]], 0
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %f = uitofp i64 %i to half
   %b = bitcast half %f to i16
   %cmp = icmp eq i16 %b, 0
   ret i1 %cmp
 }
 
 define <3 x i1> @i64_cast_cmp_eq_int_0_uitofp_half_vec(<3 x i64> %i) {
 ; CHECK-LABEL: @i64_cast_cmp_eq_int_0_uitofp_half_vec(
 ; CHECK-NEXT:    [[F:%.*]] = uitofp <3 x i64> [[I:%.*]] to <3 x half>
 ; CHECK-NEXT:    [[B:%.*]] = bitcast <3 x half> [[F]] to <3 x i16>
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq <3 x i16> [[B]], <i16 0, i16 undef, i16 0>
 ; CHECK-NEXT:    ret <3 x i1> [[CMP]]
 ;
   %f = uitofp <3 x i64> %i to  <3 x half>
   %b = bitcast <3 x half> %f to <3 x i16>
   %cmp = icmp eq <3 x i16> %b, <i16 0, i16 undef, i16 0>
   ret <3 x i1> %cmp
 }
 
 define i1 @i64_cast_cmp_ne_int_0_uitofp_half(i64 %i) {
 ; CHECK-LABEL: @i64_cast_cmp_ne_int_0_uitofp_half(
-; CHECK-NEXT:    [[F:%.*]] = uitofp i64 [[I:%.*]] to half
-; CHECK-NEXT:    [[B:%.*]] = bitcast half [[F]] to i16
-; CHECK-NEXT:    [[CMP:%.*]] = icmp ne i16 [[B]], 0
+; CHECK-NEXT:    [[CMP:%.*]] = icmp ne i64 [[I:%.*]], 0
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %f = uitofp i64 %i to half
   %b = bitcast half %f to i16
   %cmp = icmp ne i16 %b, 0
   ret i1 %cmp
 }
 
 define <3 x i1> @i64_cast_cmp_ne_int_0_uitofp_half_vec(<3 x i64> %i) {
 ; CHECK-LABEL: @i64_cast_cmp_ne_int_0_uitofp_half_vec(
 ; CHECK-NEXT:    [[F:%.*]] = uitofp <3 x i64> [[I:%.*]] to <3 x half>
 ; CHECK-NEXT:    [[B:%.*]] = bitcast <3 x half> [[F]] to <3 x i16>
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ne <3 x i16> [[B]], <i16 0, i16 undef, i16 0>
 ; CHECK-NEXT:    ret <3 x i1> [[CMP]]
 ;
   %f = uitofp <3 x i64> %i to  <3 x half>
   %b = bitcast <3 x half> %f to <3 x i16>
   %cmp = icmp ne <3 x i16> %b, <i16 0, i16 undef, i16 0>
   ret <3 x i1> %cmp
 }
 
 define i1 @i16_cast_cmp_eq_int_0_uitofp_float(i16 %i) {
 ; CHECK-LABEL: @i16_cast_cmp_eq_int_0_uitofp_float(
-; CHECK-NEXT:    [[F:%.*]] = uitofp i16 [[I:%.*]] to float
-; CHECK-NEXT:    [[B:%.*]] = bitcast float [[F]] to i32
-; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[B]], 0
+; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i16 [[I:%.*]], 0
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %f = uitofp i16 %i to float
   %b = bitcast float %f to i32
   %cmp = icmp eq i32 %b, 0
   ret i1 %cmp
 }
 
 define <3 x i1> @i16_cast_cmp_eq_int_0_uitofp_float_vec(<3 x i16> %i) {
 ; CHECK-LABEL: @i16_cast_cmp_eq_int_0_uitofp_float_vec(
 ; CHECK-NEXT:    [[F:%.*]] = uitofp <3 x i16> [[I:%.*]] to <3 x float>
 ; CHECK-NEXT:    [[B:%.*]] = bitcast <3 x float> [[F]] to <3 x i32>
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq <3 x i32> [[B]], <i32 0, i32 undef, i32 0>
 ; CHECK-NEXT:    ret <3 x i1> [[CMP]]
 ;
   %f = uitofp <3 x i16> %i to  <3 x float>
   %b = bitcast <3 x float> %f to <3 x i32>
   %cmp = icmp eq <3 x i32> %b, <i32 0, i32 undef, i32 0>
   ret <3 x i1> %cmp
 }
 
 define i1 @i16_cast_cmp_ne_int_0_uitofp_float(i16 %i) {
 ; CHECK-LABEL: @i16_cast_cmp_ne_int_0_uitofp_float(
-; CHECK-NEXT:    [[F:%.*]] = uitofp i16 [[I:%.*]] to float
-; CHECK-NEXT:    [[B:%.*]] = bitcast float [[F]] to i32
-; CHECK-NEXT:    [[CMP:%.*]] = icmp ne i32 [[B]], 0
+; CHECK-NEXT:    [[CMP:%.*]] = icmp ne i16 [[I:%.*]], 0
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %f = uitofp i16 %i to float
   %b = bitcast float %f to i32
   %cmp = icmp ne i32 %b, 0
   ret i1 %cmp
 }
 
 define <3 x i1> @i16_cast_cmp_ne_int_0_uitofp_float_vec(<3 x i16> %i) {
 ; CHECK-LABEL: @i16_cast_cmp_ne_int_0_uitofp_float_vec(
 ; CHECK-NEXT:    [[F:%.*]] = uitofp <3 x i16> [[I:%.*]] to <3 x float>
 ; CHECK-NEXT:    [[B:%.*]] = bitcast <3 x float> [[F]] to <3 x i32>
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ne <3 x i32> [[B]], <i32 0, i32 undef, i32 0>
 ; CHECK-NEXT:    ret <3 x i1> [[CMP]]
 ;
   %f = uitofp <3 x i16> %i to  <3 x float>
   %b = bitcast <3 x float> %f to <3 x i32>
   %cmp = icmp ne <3 x i32> %b, <i32 0, i32 undef, i32 0>
   ret <3 x i1> %cmp
 }
 
 define i1 @i16_cast_cmp_eq_int_0_uitofp_double(i16 %i) {
 ; CHECK-LABEL: @i16_cast_cmp_eq_int_0_uitofp_double(
-; CHECK-NEXT:    [[F:%.*]] = uitofp i16 [[I:%.*]] to double
-; CHECK-NEXT:    [[B:%.*]] = bitcast double [[F]] to i64
-; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i64 [[B]], 0
+; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i16 [[I:%.*]], 0
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %f = uitofp i16 %i to double
   %b = bitcast double %f to i64
   %cmp = icmp eq i64 %b, 0
   ret i1 %cmp
 }
 
 define <3 x i1> @i16_cast_cmp_eq_int_0_uitofp_double_vec(<3 x i16> %i) {
 ; CHECK-LABEL: @i16_cast_cmp_eq_int_0_uitofp_double_vec(
 ; CHECK-NEXT:    [[F:%.*]] = uitofp <3 x i16> [[I:%.*]] to <3 x double>
 ; CHECK-NEXT:    [[B:%.*]] = bitcast <3 x double> [[F]] to <3 x i64>
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq <3 x i64> [[B]], <i64 0, i64 undef, i64 0>
 ; CHECK-NEXT:    ret <3 x i1> [[CMP]]
 ;
   %f = uitofp <3 x i16> %i to  <3 x double>
   %b = bitcast <3 x double> %f to <3 x i64>
   %cmp = icmp eq <3 x i64> %b, <i64 0, i64 undef, i64 0>
   ret <3 x i1> %cmp
 }
 
 define i1 @i16_cast_cmp_ne_int_0_uitofp_double(i16 %i) {
 ; CHECK-LABEL: @i16_cast_cmp_ne_int_0_uitofp_double(
-; CHECK-NEXT:    [[F:%.*]] = uitofp i16 [[I:%.*]] to double
-; CHECK-NEXT:    [[B:%.*]] = bitcast double [[F]] to i64
-; CHECK-NEXT:    [[CMP:%.*]] = icmp ne i64 [[B]], 0
+; CHECK-NEXT:    [[CMP:%.*]] = icmp ne i16 [[I:%.*]], 0
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %f = uitofp i16 %i to double
   %b = bitcast double %f to i64
   %cmp = icmp ne i64 %b, 0
   ret i1 %cmp
 }
 
 define <3 x i1> @i16_cast_cmp_ne_int_0_uitofp_double_vec(<3 x i16> %i) {
 ; CHECK-LABEL: @i16_cast_cmp_ne_int_0_uitofp_double_vec(
 ; CHECK-NEXT:    [[F:%.*]] = uitofp <3 x i16> [[I:%.*]] to <3 x double>
 ; CHECK-NEXT:    [[B:%.*]] = bitcast <3 x double> [[F]] to <3 x i64>
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ne <3 x i64> [[B]], <i64 0, i64 undef, i64 0>
 ; CHECK-NEXT:    ret <3 x i1> [[CMP]]
 ;
   %f = uitofp <3 x i16> %i to  <3 x double>
   %b = bitcast <3 x double> %f to <3 x i64>
   %cmp = icmp ne <3 x i64> %b, <i64 0, i64 undef, i64 0>
   ret <3 x i1> %cmp
 }
 
 define i1 @i16_cast_cmp_eq_int_0_uitofp_half(i16 %i) {
 ; CHECK-LABEL: @i16_cast_cmp_eq_int_0_uitofp_half(
-; CHECK-NEXT:    [[F:%.*]] = uitofp i16 [[I:%.*]] to half
-; CHECK-NEXT:    [[B:%.*]] = bitcast half [[F]] to i16
-; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i16 [[B]], 0
+; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i16 [[I:%.*]], 0
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %f = uitofp i16 %i to half
   %b = bitcast half %f to i16
   %cmp = icmp eq i16 %b, 0
   ret i1 %cmp
 }
 
 define <3 x i1> @i16_cast_cmp_eq_int_0_uitofp_half_vec(<3 x i16> %i) {
 ; CHECK-LABEL: @i16_cast_cmp_eq_int_0_uitofp_half_vec(
 ; CHECK-NEXT:    [[F:%.*]] = uitofp <3 x i16> [[I:%.*]] to <3 x half>
 ; CHECK-NEXT:    [[B:%.*]] = bitcast <3 x half> [[F]] to <3 x i16>
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq <3 x i16> [[B]], <i16 0, i16 undef, i16 0>
 ; CHECK-NEXT:    ret <3 x i1> [[CMP]]
 ;
   %f = uitofp <3 x i16> %i to  <3 x half>
   %b = bitcast <3 x half> %f to <3 x i16>
   %cmp = icmp eq <3 x i16> %b, <i16 0, i16 undef, i16 0>
   ret <3 x i1> %cmp
 }
 
 define i1 @i16_cast_cmp_ne_int_0_uitofp_half(i16 %i) {
 ; CHECK-LABEL: @i16_cast_cmp_ne_int_0_uitofp_half(
-; CHECK-NEXT:    [[F:%.*]] = uitofp i16 [[I:%.*]] to half
-; CHECK-NEXT:    [[B:%.*]] = bitcast half [[F]] to i16
-; CHECK-NEXT:    [[CMP:%.*]] = icmp ne i16 [[B]], 0
+; CHECK-NEXT:    [[CMP:%.*]] = icmp ne i16 [[I:%.*]], 0
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %f = uitofp i16 %i to half
   %b = bitcast half %f to i16
   %cmp = icmp ne i16 %b, 0
   ret i1 %cmp
 }