This is an archive of the discontinued LLVM Phabricator instance.

Differential D44421

[InstSimplify] [NFC] Add tests for peeking through unsigned FP casts for sign compares (PR36682)
ClosedPublic

Authored by lebedev.ri on Mar 13 2018, 4:58 AM.

Details

Reviewers
spatel
majnemer
efriedma
arsenm
Commits
rG978aae761422: [InstSimplify] [NFC] Add tests for peeking through unsigned FP casts for sign…
rL327535: [InstSimplify] [NFC] Add tests for peeking through unsigned FP casts for sign…
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

Looking at the IR pattern in question, as per alive-nj, for all the type combinations i checked
(input: i16, i32, i64; intermediate: half/i16, float/i32, double/i64)
for the following icmp comparisons the uitofp+bitcast+icmp can be evaluated to a boolean:

  • slt 0
  • sgt -1

I did not check vectors, but i'm guessing it's the same there.

alive-sign.txt3 KBDownload




Thus all these cases are in the testcase (along with the vector variant with additional undef element in the middle).

There are no negative patterns here (unless alive-nj lied/is broken), all of these should be optimized.
Diff Detail
Repository 
rL LLVM 
Event Timeline
lebedev.ri created this revision.Mar 13 2018, 4:58 AM
Herald added a subscriber: wdng.  ·  View Herald TranscriptMar 13 2018, 4:58 AM
lebedev.ri updated this revision to Diff 138157.Mar 13 2018, 5:04 AM
Added a comment to the test
lebedev.ri mentioned this in D44425: [InstSimplify] peek through unsigned FP casts for sign-bit compares (PR36682).Mar 13 2018, 7:06 AM
lebedev.ri added a child revision: D44425: [InstSimplify] peek through unsigned FP casts for sign-bit compares (PR36682).
lebedev.ri mentioned this in D44367: [InstCombine] peek through FP casts for sign-bit compares (PR36682).Mar 13 2018, 7:12 AM
spatel added inline comments.Mar 13 2018, 1:57 PM
test/Transforms/InstCombine/cast-unsigned-icmp-cmp-0.ll


8–11
If the result of the fold is a constant, then the test (and the transform) can go in InstSimplify rather than InstCombine.

Also, as with my earlier comment, I appreciate the thorough testing, but I don't think we need 30+ tests of this fold. Some variation between data widths and vectors should give us enough coverage. There should be at least one vector test *without* undef in the zero constant because that shows a different result currently.
lebedev.ri added inline comments.Mar 13 2018, 2:01 PM
test/Transforms/InstCombine/cast-unsigned-icmp-cmp-0.ll


8–11
Ok, got it, will update patches accordingly.
lebedev.ri updated this revision to Diff 138380.Mar 14 2018, 9:04 AM
lebedev.ri marked 2 inline comments as done.
lebedev.ri retitled this revision from [InstCombine] [NFC] Add tests for peeking through unsigned FP casts for sign compares (PR36682) to [InstSimplify] [NFC] Add tests for peeking through unsigned FP casts for sign compares (PR36682).
Reduced amount of test patterns while improving test coverage.
spatel accepted this revision.Mar 14 2018, 9:40 AM
Thanks - that's better coverage. LGTM.
test/Transforms/InstSimplify/cast-unsigned-icmp-cmp-0.ll


8–9 ↗(On Diff #138380)
The wording is confusing. I'd make this:

; FIXME: All of these can be simplified to a constant true or false value.
This revision is now accepted and ready to land.Mar 14 2018, 9:40 AM
Closed by commit rL327535: [InstSimplify] [NFC] Add tests for peeking through unsigned FP casts for sign… (authored by lebedevri).  ·  Explain WhyMar 14 2018, 10:33 AM
This revision was automatically updated to reflect the committed changes.
spatel added inline comments.Mar 14 2018, 10:38 AM
llvm/trunk/test/Transforms/InstSimplify/cast-unsigned-icmp-cmp-0.ll


2–5 ↗(On Diff #138404)
Sorry - I didn't catch this before. Why are we doing anything with -instcombine here? We should only be running -instsimplify on this file.
lebedev.ri added inline comments.Mar 14 2018, 10:42 AM
llvm/trunk/test/Transforms/InstSimplify/cast-unsigned-icmp-cmp-0.ll


2–5 ↗(On Diff #138404)
You commented on the explanation note :)

)I moved it here from the next diff before commit, should have done that earlier)
lebedev.ri added inline comments.Mar 14 2018, 10:47 AM
llvm/trunk/test/Transforms/InstSimplify/cast-unsigned-icmp-cmp-0.ll


2–5 ↗(On Diff #138404)
Uhm, yeah, i was thinking of something else, that instcombine transform would not be valid anyway:



$ ~/src/alive-nj/run.py /tmp/slt.txt 
----------                                                                      
Name: slt
  %f   = uitofp i32 %i to float
  %b   = bitcast float %f to i32
  %cmp = icmp slt i32 %b, 0
=>
  %cmp = icmp slt i32 %i, 0

ERROR: Mismatch in values for i1 %cmp                                           

Example:
  i32 %i = 0x80000000 (2147483648, -2147483648)
float %f = 1*(2**31)
  i32 %b = 0x0f800000 (260046848)
source: 0x0 (0)
target: 0x1 (1, -1)

$ ~/src/alive-nj/run.py /tmp/sgt.txt
----------                                                                      
Name: sgt
  %f   = uitofp i32 %i to float
  %b   = bitcast float %f to i32
  %cmp = icmp sgt i32 %b, -1
=>
  %cmp = icmp sgt i32 %i, -1

ERROR: Mismatch in values for i1 %cmp                                           

Example:
  i32 %i = 0x80000000 (2147483648, -2147483648)
float %f = 1*(2**31)
  i32 %b = 0x0f800000 (260046848)
source: 0x1 (1, -1)
target: 0x0 (0)



Sorry, let me remove that pass..
spatel added inline comments.Mar 14 2018, 10:50 AM
llvm/trunk/test/Transforms/InstSimplify/cast-unsigned-icmp-cmp-0.ll


2–5 ↗(On Diff #138404)
I'm confused. We're going to add code to -instsimplify, so these tests should be only for that pass. Why is -instcombine in the RUN line?
lebedev.ri added inline comments.Mar 14 2018, 10:56 AM
llvm/trunk/test/Transforms/InstSimplify/cast-unsigned-icmp-cmp-0.ll


2–5 ↗(On Diff #138404)
; NOTE: we run instcombine first,
; to make sure that it does *NOT* drop uitofp+bitcast here.



In other words, i *thought* that running instcombine first would make sure that

a combine to drop uitofp+bitcast from that case won't be added to instcombine.

If it would be added, then we wouldn't be able to simplify to a boolean here.



But such a fold would be invalid, so there is zero point in running instcombine

in this case, thus i will now drop that pass from the runline.
Diffusion mentioned this in rL327541: [InstSimplify] [NFC] cast-unsigned-icmp-cmp-0.ll - don't run instcombine.Mar 14 2018, 11:01 AM
lebedev.ri added inline comments.Mar 14 2018, 11:02 AM
llvm/trunk/test/Transforms/InstSimplify/cast-unsigned-icmp-cmp-0.ll


2–5 ↗(On Diff #138404)
rL327541, sorry for the noise :(
Diffusion mentioned this in rL327642: [InstSimplify] peek through unsigned FP casts for sign-bit compares (PR36682).Mar 15 2018, 9:23 AM
Revision Contents
PathSize
test/
Transforms/
InstCombine/
479 lines
Diff 138157
test/Transforms/InstCombine/cast-unsigned-icmp-cmp-0.ll
  • This file was added.
; 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.

; *All* of these can be instcombine'd to a boolean:

;   * slt i32 %b, 0  -> false

;   * sgt i32 %b, -1 -> true

spatelUnsubmitted
Done
ReplyInline Actions
If the result of the fold is a constant, then the test (and the transform) can go in InstSimplify rather than InstCombine.

Also, as with my earlier comment, I appreciate the thorough testing, but I don't think we need 30+ tests of this fold. Some variation between data widths and vectors should give us enough coverage. There should be at least one vector test *without* undef in the zero constant because that shows a different result currently.
spatel: If the result of the fold is a constant, then the test (and the transform) can go in…
lebedev.riAuthorUnsubmitted
Done
ReplyInline Actions
Ok, got it, will update patches accordingly.
lebedev.ri: Ok, got it, will update patches accordingly.


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]]

;

  %f = uitofp i32 %i to float

  %b = bitcast float %f to i32

  %cmp = icmp slt i32 %b, 0

  ret i1 %cmp

}



define <3 x i1> @i32_cast_cmp_slt_int_0_uitofp_float_vec(<3 x i32> %i) {

; CHECK-LABEL: @i32_cast_cmp_slt_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 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]]

;

  %f = uitofp i32 %i to float

  %b = bitcast float %f to i32

  %cmp = icmp sgt i32 %b, -1

  ret i1 %cmp

}



define <3 x i1> @i32_cast_cmp_sgt_int_m1_uitofp_float_vec(<3 x i32> %i) {

; CHECK-LABEL: @i32_cast_cmp_sgt_int_m1_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 sgt <3 x i32> [[B]], <i32 -1, i32 undef, i32 -1>

; 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 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]]

;

  %f = uitofp i32 %i to double

  %b = bitcast double %f to i64

  %cmp = icmp slt i64 %b, 0

  ret i1 %cmp

}



define <3 x i1> @i32_cast_cmp_slt_int_0_uitofp_double_vec(<3 x i32> %i) {

; CHECK-LABEL: @i32_cast_cmp_slt_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 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]]

;

  %f = uitofp i32 %i to double

  %b = bitcast double %f to i64

  %cmp = icmp sgt i64 %b, -1

  ret i1 %cmp

}



define <3 x i1> @i32_cast_cmp_sgt_int_m1_uitofp_double_vec(<3 x i32> %i) {

; CHECK-LABEL: @i32_cast_cmp_sgt_int_m1_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 sgt <3 x i64> [[B]], <i64 -1, i64 undef, i64 -1>

; 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 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]]

;

  %f = uitofp i32 %i to half

  %b = bitcast half %f to i16

  %cmp = icmp slt i16 %b, 0

  ret i1 %cmp

}



define <3 x i1> @i32_cast_cmp_slt_int_0_uitofp_half_vec(<3 x i32> %i) {

; CHECK-LABEL: @i32_cast_cmp_slt_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 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]]

;

  %f = uitofp i32 %i to half

  %b = bitcast half %f to i16

  %cmp = icmp sgt i16 %b, -1

  ret i1 %cmp

}



define <3 x i1> @i32_cast_cmp_sgt_int_m1_uitofp_half_vec(<3 x i32> %i) {

; CHECK-LABEL: @i32_cast_cmp_sgt_int_m1_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 sgt <3 x i16> [[B]], <i16 -1, i16 undef, i16 -1>

; 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 sgt <3 x i16> %b, <i16 -1, i16 undef, i16 -1>

  ret <3 x i1> %cmp

}



define i1 @i64_cast_cmp_slt_int_0_uitofp_float(i64 %i) {

; CHECK-LABEL: @i64_cast_cmp_slt_int_0_uitofp_float(

; CHECK-NEXT:    [[F:%.*]] = uitofp i64 [[I:%.*]] to float

; CHECK-NEXT:    [[B:%.*]] = bitcast float [[F]] to i32

; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[B]], 0

; CHECK-NEXT:    ret i1 [[CMP]]

;

  %f = uitofp i64 %i to float

  %b = bitcast float %f to i32

  %cmp = icmp slt i32 %b, 0

  ret i1 %cmp

}



define <3 x i1> @i64_cast_cmp_slt_int_0_uitofp_float_vec(<3 x i64> %i) {

; CHECK-LABEL: @i64_cast_cmp_slt_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 slt <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 slt <3 x i32> %b, <i32 0, i32 undef, i32 0>

  ret <3 x i1> %cmp

}



define i1 @i64_cast_cmp_sgt_int_m1_uitofp_float(i64 %i) {

; CHECK-LABEL: @i64_cast_cmp_sgt_int_m1_uitofp_float(

; CHECK-NEXT:    [[F:%.*]] = uitofp i64 [[I:%.*]] to float

; CHECK-NEXT:    [[B:%.*]] = bitcast float [[F]] to i32

; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i32 [[B]], -1

; CHECK-NEXT:    ret i1 [[CMP]]

;

  %f = uitofp i64 %i to float

  %b = bitcast float %f to i32

  %cmp = icmp sgt i32 %b, -1

  ret i1 %cmp

}



define <3 x i1> @i64_cast_cmp_sgt_int_m1_uitofp_float_vec(<3 x i64> %i) {

; CHECK-LABEL: @i64_cast_cmp_sgt_int_m1_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 sgt <3 x i32> [[B]], <i32 -1, i32 undef, i32 -1>

; 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 sgt <3 x i32> %b, <i32 -1, i32 undef, i32 -1>

  ret <3 x i1> %cmp

}



define i1 @i64_cast_cmp_slt_int_0_uitofp_double(i64 %i) {

; CHECK-LABEL: @i64_cast_cmp_slt_int_0_uitofp_double(

; CHECK-NEXT:    [[F:%.*]] = uitofp i64 [[I:%.*]] to double

; CHECK-NEXT:    [[B:%.*]] = bitcast double [[F]] to i64

; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i64 [[B]], 0

; CHECK-NEXT:    ret i1 [[CMP]]

;

  %f = uitofp i64 %i to double

  %b = bitcast double %f to i64

  %cmp = icmp slt i64 %b, 0

  ret i1 %cmp

}



define <3 x i1> @i64_cast_cmp_slt_int_0_uitofp_double_vec(<3 x i64> %i) {

; CHECK-LABEL: @i64_cast_cmp_slt_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 slt <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 slt <3 x i64> %b, <i64 0, i64 undef, i64 0>

  ret <3 x i1> %cmp

}



define i1 @i64_cast_cmp_sgt_int_m1_uitofp_double(i64 %i) {

; CHECK-LABEL: @i64_cast_cmp_sgt_int_m1_uitofp_double(

; CHECK-NEXT:    [[F:%.*]] = uitofp i64 [[I:%.*]] to double

; CHECK-NEXT:    [[B:%.*]] = bitcast double [[F]] to i64

; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i64 [[B]], -1

; CHECK-NEXT:    ret i1 [[CMP]]

;

  %f = uitofp i64 %i to double

  %b = bitcast double %f to i64

  %cmp = icmp sgt i64 %b, -1

  ret i1 %cmp

}



define <3 x i1> @i64_cast_cmp_sgt_int_m1_uitofp_double_vec(<3 x i64> %i) {

; CHECK-LABEL: @i64_cast_cmp_sgt_int_m1_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 sgt <3 x i64> [[B]], <i64 -1, i64 undef, i64 -1>

; 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 sgt <3 x i64> %b, <i64 -1, i64 undef, i64 -1>

  ret <3 x i1> %cmp

}



define i1 @i64_cast_cmp_slt_int_0_uitofp_half(i64 %i) {

; CHECK-LABEL: @i64_cast_cmp_slt_int_0_uitofp_half(

; CHECK-NEXT:    [[F:%.*]] = uitofp i64 [[I:%.*]] to half

; CHECK-NEXT:    [[B:%.*]] = bitcast half [[F]] to i16

; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i16 [[B]], 0

; CHECK-NEXT:    ret i1 [[CMP]]

;

  %f = uitofp i64 %i to half

  %b = bitcast half %f to i16

  %cmp = icmp slt i16 %b, 0

  ret i1 %cmp

}



define <3 x i1> @i64_cast_cmp_slt_int_0_uitofp_half_vec(<3 x i64> %i) {

; CHECK-LABEL: @i64_cast_cmp_slt_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 slt <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 slt <3 x i16> %b, <i16 0, i16 undef, i16 0>

  ret <3 x i1> %cmp

}



define i1 @i64_cast_cmp_sgt_int_m1_uitofp_half(i64 %i) {

; CHECK-LABEL: @i64_cast_cmp_sgt_int_m1_uitofp_half(

; CHECK-NEXT:    [[F:%.*]] = uitofp i64 [[I:%.*]] to half

; CHECK-NEXT:    [[B:%.*]] = bitcast half [[F]] to i16

; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i16 [[B]], -1

; CHECK-NEXT:    ret i1 [[CMP]]

;

  %f = uitofp i64 %i to half

  %b = bitcast half %f to i16

  %cmp = icmp sgt i16 %b, -1

  ret i1 %cmp

}



define <3 x i1> @i64_cast_cmp_sgt_int_m1_uitofp_half_vec(<3 x i64> %i) {

; CHECK-LABEL: @i64_cast_cmp_sgt_int_m1_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 sgt <3 x i16> [[B]], <i16 -1, i16 undef, i16 -1>

; 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 sgt <3 x i16> %b, <i16 -1, i16 undef, i16 -1>

  ret <3 x i1> %cmp

}



define i1 @i16_cast_cmp_slt_int_0_uitofp_float(i16 %i) {

; CHECK-LABEL: @i16_cast_cmp_slt_int_0_uitofp_float(

; CHECK-NEXT:    [[F:%.*]] = uitofp i16 [[I:%.*]] to float

; CHECK-NEXT:    [[B:%.*]] = bitcast float [[F]] to i32

; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[B]], 0

; CHECK-NEXT:    ret i1 [[CMP]]

;

  %f = uitofp i16 %i to float

  %b = bitcast float %f to i32

  %cmp = icmp slt i32 %b, 0

  ret i1 %cmp

}



define <3 x i1> @i16_cast_cmp_slt_int_0_uitofp_float_vec(<3 x i16> %i) {

; CHECK-LABEL: @i16_cast_cmp_slt_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 slt <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 slt <3 x i32> %b, <i32 0, i32 undef, i32 0>

  ret <3 x i1> %cmp

}



define i1 @i16_cast_cmp_sgt_int_m1_uitofp_float(i16 %i) {

; CHECK-LABEL: @i16_cast_cmp_sgt_int_m1_uitofp_float(

; CHECK-NEXT:    [[F:%.*]] = uitofp i16 [[I:%.*]] to float

; CHECK-NEXT:    [[B:%.*]] = bitcast float [[F]] to i32

; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i32 [[B]], -1

; CHECK-NEXT:    ret i1 [[CMP]]

;

  %f = uitofp i16 %i to float

  %b = bitcast float %f to i32

  %cmp = icmp sgt i32 %b, -1

  ret i1 %cmp

}



define <3 x i1> @i16_cast_cmp_sgt_int_m1_uitofp_float_vec(<3 x i16> %i) {

; CHECK-LABEL: @i16_cast_cmp_sgt_int_m1_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 sgt <3 x i32> [[B]], <i32 -1, i32 undef, i32 -1>

; 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 sgt <3 x i32> %b, <i32 -1, i32 undef, i32 -1>

  ret <3 x i1> %cmp

}



define i1 @i16_cast_cmp_slt_int_0_uitofp_double(i16 %i) {

; CHECK-LABEL: @i16_cast_cmp_slt_int_0_uitofp_double(

; CHECK-NEXT:    [[F:%.*]] = uitofp i16 [[I:%.*]] to double

; CHECK-NEXT:    [[B:%.*]] = bitcast double [[F]] to i64

; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i64 [[B]], 0

; CHECK-NEXT:    ret i1 [[CMP]]

;

  %f = uitofp i16 %i to double

  %b = bitcast double %f to i64

  %cmp = icmp slt i64 %b, 0

  ret i1 %cmp

}



define <3 x i1> @i16_cast_cmp_slt_int_0_uitofp_double_vec(<3 x i16> %i) {

; CHECK-LABEL: @i16_cast_cmp_slt_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 slt <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 slt <3 x i64> %b, <i64 0, i64 undef, i64 0>

  ret <3 x i1> %cmp

}



define i1 @i16_cast_cmp_sgt_int_m1_uitofp_double(i16 %i) {

; CHECK-LABEL: @i16_cast_cmp_sgt_int_m1_uitofp_double(

; CHECK-NEXT:    [[F:%.*]] = uitofp i16 [[I:%.*]] to double

; CHECK-NEXT:    [[B:%.*]] = bitcast double [[F]] to i64

; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i64 [[B]], -1

; CHECK-NEXT:    ret i1 [[CMP]]

;

  %f = uitofp i16 %i to double

  %b = bitcast double %f to i64

  %cmp = icmp sgt i64 %b, -1

  ret i1 %cmp

}



define <3 x i1> @i16_cast_cmp_sgt_int_m1_uitofp_double_vec(<3 x i16> %i) {

; CHECK-LABEL: @i16_cast_cmp_sgt_int_m1_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 sgt <3 x i64> [[B]], <i64 -1, i64 undef, i64 -1>

; 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 sgt <3 x i64> %b, <i64 -1, i64 undef, i64 -1>

  ret <3 x i1> %cmp

}



define i1 @i16_cast_cmp_slt_int_0_uitofp_half(i16 %i) {

; CHECK-LABEL: @i16_cast_cmp_slt_int_0_uitofp_half(

; CHECK-NEXT:    [[F:%.*]] = uitofp i16 [[I:%.*]] to half

; CHECK-NEXT:    [[B:%.*]] = bitcast half [[F]] to i16

; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i16 [[B]], 0

; CHECK-NEXT:    ret i1 [[CMP]]

;

  %f = uitofp i16 %i to half

  %b = bitcast half %f to i16

  %cmp = icmp slt i16 %b, 0

  ret i1 %cmp

}



define <3 x i1> @i16_cast_cmp_slt_int_0_uitofp_half_vec(<3 x i16> %i) {

; CHECK-LABEL: @i16_cast_cmp_slt_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 slt <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 slt <3 x i16> %b, <i16 0, i16 undef, i16 0>

  ret <3 x i1> %cmp

}



define i1 @i16_cast_cmp_sgt_int_m1_uitofp_half(i16 %i) {

; CHECK-LABEL: @i16_cast_cmp_sgt_int_m1_uitofp_half(

; CHECK-NEXT:    [[F:%.*]] = uitofp i16 [[I:%.*]] to half

; CHECK-NEXT:    [[B:%.*]] = bitcast half [[F]] to i16

; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i16 [[B]], -1

; CHECK-NEXT:    ret i1 [[CMP]]

;

  %f = uitofp i16 %i to half

  %b = bitcast half %f to i16

  %cmp = icmp sgt i16 %b, -1

  ret i1 %cmp

}



define <3 x i1> @i16_cast_cmp_sgt_int_m1_uitofp_half_vec(<3 x i16> %i) {

; CHECK-LABEL: @i16_cast_cmp_sgt_int_m1_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 sgt <3 x i16> [[B]], <i16 -1, i16 undef, i16 -1>

; 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 sgt <3 x i16> %b, <i16 -1, i16 undef, i16 -1>

  ret <3 x i1> %cmp

}