1; RUN: opt < %s -float2int -S | FileCheck %s
2; RUN: opt < %s -passes='float2int' -S | FileCheck %s
3
4;
5; Positive tests
6;
7
8; CHECK-LABEL: @simple1
9; CHECK:  %1 = zext i8 %a to i32
10; CHECK:  %2 = add i32 %1, 1
11; CHECK:  %3 = trunc i32 %2 to i16
12; CHECK:  ret i16 %3
13define i16 @simple1(i8 %a) {
14  %1 = uitofp i8 %a to float
15  %2 = fadd float %1, 1.0
16  %3 = fptoui float %2 to i16
17  ret i16 %3
18}
19
20; CHECK-LABEL: @simple2
21; CHECK:  %1 = zext i8 %a to i32
22; CHECK:  %2 = sub i32 %1, 1
23; CHECK:  %3 = trunc i32 %2 to i8
24; CHECK:  ret i8 %3
25define i8 @simple2(i8 %a) {
26  %1 = uitofp i8 %a to float
27  %2 = fsub float %1, 1.0
28  %3 = fptoui float %2 to i8
29  ret i8 %3
30}
31
32; CHECK-LABEL: @simple3
33; CHECK:  %1 = zext i8 %a to i32
34; CHECK:  %2 = sub i32 %1, 1
35; CHECK:  ret i32 %2
36define i32 @simple3(i8 %a) {
37  %1 = uitofp i8 %a to float
38  %2 = fsub float %1, 1.0
39  %3 = fptoui float %2 to i32
40  ret i32 %3
41}
42
43; CHECK-LABEL: @cmp
44; CHECK:  %1 = zext i8 %a to i32
45; CHECK:  %2 = zext i8 %b to i32
46; CHECK:  %3 = icmp slt i32 %1, %2
47; CHECK:  ret i1 %3
48define i1 @cmp(i8 %a, i8 %b) {
49  %1 = uitofp i8 %a to float
50  %2 = uitofp i8 %b to float
51  %3 = fcmp ult float %1, %2
52  ret i1 %3
53}
54
55; CHECK-LABEL: @simple4
56; CHECK:  %1 = zext i32 %a to i64
57; CHECK:  %2 = add i64 %1, 1
58; CHECK:  %3 = trunc i64 %2 to i32
59; CHECK:  ret i32 %3
60define i32 @simple4(i32 %a) {
61  %1 = uitofp i32 %a to double
62  %2 = fadd double %1, 1.0
63  %3 = fptoui double %2 to i32
64  ret i32 %3
65}
66
67; CHECK-LABEL: @simple5
68; CHECK:  %1 = zext i8 %a to i32
69; CHECK:  %2 = zext i8 %b to i32
70; CHECK:  %3 = add i32 %1, 1
71; CHECK:  %4 = mul i32 %3, %2
72; CHECK:  ret i32 %4
73define i32 @simple5(i8 %a, i8 %b) {
74  %1 = uitofp i8 %a to float
75  %2 = uitofp i8 %b to float
76  %3 = fadd float %1, 1.0
77  %4 = fmul float %3, %2
78  %5 = fptoui float %4 to i32
79  ret i32 %5
80}
81
82; CHECK-LABEL: @simple6
83; CHECK:  %1 = uitofp i8 %a to float
84; CHECK:  %2 = uitofp i8 %b to float
85; CHECK:  %3 = fneg float %1
86; CHECK:  %4 = fmul float %3, %2
87; CHECK:  %5 = fptoui float %4 to i32
88; CHECK:  ret i32 %5
89define i32 @simple6(i8 %a, i8 %b) {
90  %1 = uitofp i8 %a to float
91  %2 = uitofp i8 %b to float
92  %3 = fneg float %1
93  %4 = fmul float %3, %2
94  %5 = fptoui float %4 to i32
95  ret i32 %5
96}
97
98; The two chains don't interact - failure of one shouldn't
99; cause failure of the other.
100
101; CHECK-LABEL: @multi1
102; CHECK:  %1 = zext i8 %a to i32
103; CHECK:  %2 = zext i8 %b to i32
104; CHECK:  %fc = uitofp i8 %c to float
105; CHECK:  %x1 = add i32 %1, %2
106; CHECK:  %z = fadd float %fc, %d
107; CHECK:  %w = fptoui float %z to i32
108; CHECK:  %r = add i32 %x1, %w
109; CHECK:  ret i32 %r
110define i32 @multi1(i8 %a, i8 %b, i8 %c, float %d) {
111  %fa = uitofp i8 %a to float
112  %fb = uitofp i8 %b to float
113  %fc = uitofp i8 %c to float
114  %x = fadd float %fa, %fb
115  %y = fptoui float %x to i32
116  %z = fadd float %fc, %d
117  %w = fptoui float %z to i32
118  %r = add i32 %y, %w
119  ret i32 %r
120}
121
122; CHECK-LABEL: @simple_negzero
123; CHECK:  %1 = zext i8 %a to i32
124; CHECK:  %2 = add i32 %1, 0
125; CHECK:  %3 = trunc i32 %2 to i16
126; CHECK:  ret i16 %3
127define i16 @simple_negzero(i8 %a) {
128  %1 = uitofp i8 %a to float
129  %2 = fadd fast float %1, -0.0
130  %3 = fptoui float %2 to i16
131  ret i16 %3
132}
133
134; CHECK-LABEL: @simple_negative
135; CHECK: %1 = sext i8 %call to i32
136; CHECK: %mul1 = mul i32 %1, -3
137; CHECK: %2 = trunc i32 %mul1 to i8
138; CHECK: %conv3 = sext i8 %2 to i32
139; CHECK: ret i32 %conv3
140define i32 @simple_negative(i8 %call) {
141  %conv1 = sitofp i8 %call to float
142  %mul = fmul float %conv1, -3.000000e+00
143  %conv2 = fptosi float %mul to i8
144  %conv3 = sext i8 %conv2 to i32
145  ret i32 %conv3
146}
147
148;
149; Negative tests
150;
151
152; CHECK-LABEL: @neg_multi1
153; CHECK:  %fa = uitofp i8 %a to float
154; CHECK:  %fc = uitofp i8 %c to float
155; CHECK:  %x = fadd float %fa, %fc
156; CHECK:  %y = fptoui float %x to i32
157; CHECK:  %z = fadd float %fc, %d
158; CHECK:  %w = fptoui float %z to i32
159; CHECK:  %r = add i32 %y, %w
160; CHECK:  ret i32 %r
161; The two chains intersect, which means because one fails, no
162; transform can occur.
163define i32 @neg_multi1(i8 %a, i8 %b, i8 %c, float %d) {
164  %fa = uitofp i8 %a to float
165  %fc = uitofp i8 %c to float
166  %x = fadd float %fa, %fc
167  %y = fptoui float %x to i32
168  %z = fadd float %fc, %d
169  %w = fptoui float %z to i32
170  %r = add i32 %y, %w
171  ret i32 %r
172}
173
174; CHECK-LABEL: @neg_muld
175; CHECK:  %fa = uitofp i32 %a to double
176; CHECK:  %fb = uitofp i32 %b to double
177; CHECK:  %mul = fmul double %fa, %fb
178; CHECK:  %r = fptoui double %mul to i64
179; CHECK:  ret i64 %r
180; The i32 * i32 = i64, which has 64 bits, which is greater than the 52 bits
181; that can be exactly represented in a double.
182define i64 @neg_muld(i32 %a, i32 %b) {
183  %fa = uitofp i32 %a to double
184  %fb = uitofp i32 %b to double
185  %mul = fmul double %fa, %fb
186  %r = fptoui double %mul to i64
187  ret i64 %r
188}
189
190; CHECK-LABEL: @neg_mulf
191; CHECK:  %fa = uitofp i16 %a to float
192; CHECK:  %fb = uitofp i16 %b to float
193; CHECK:  %mul = fmul float %fa, %fb
194; CHECK:  %r = fptoui float %mul to i32
195; CHECK:  ret i32 %r
196; The i16 * i16 = i32, which can't be represented in a float, but can in a
197; double. This should fail, as the written code uses floats, not doubles so
198; the original result may be inaccurate.
199define i32 @neg_mulf(i16 %a, i16 %b) {
200  %fa = uitofp i16 %a to float
201  %fb = uitofp i16 %b to float
202  %mul = fmul float %fa, %fb
203  %r = fptoui float %mul to i32
204  ret i32 %r
205}
206
207; CHECK-LABEL: @neg_cmp
208; CHECK:  %1 = uitofp i8 %a to float
209; CHECK:  %2 = uitofp i8 %b to float
210; CHECK:  %3 = fcmp false float %1, %2
211; CHECK:  ret i1 %3
212; "false" doesn't have an icmp equivalent.
213define i1 @neg_cmp(i8 %a, i8 %b) {
214  %1 = uitofp i8 %a to float
215  %2 = uitofp i8 %b to float
216  %3 = fcmp false float %1, %2
217  ret i1 %3
218}
219
220; CHECK-LABEL: @neg_div
221; CHECK:  %1 = uitofp i8 %a to float
222; CHECK:  %2 = fdiv float %1, 1.0
223; CHECK:  %3 = fptoui float %2 to i16
224; CHECK:  ret i16 %3
225; Division isn't a supported operator.
226define i16 @neg_div(i8 %a) {
227  %1 = uitofp i8 %a to float
228  %2 = fdiv float %1, 1.0
229  %3 = fptoui float %2 to i16
230  ret i16 %3
231}
232
233; CHECK-LABEL: @neg_remainder
234; CHECK:  %1 = uitofp i8 %a to float
235; CHECK:  %2 = fadd float %1, 1.2
236; CHECK:  %3 = fptoui float %2 to i16
237; CHECK:  ret i16 %3
238; 1.2 is not an integer.
239define i16 @neg_remainder(i8 %a) {
240  %1 = uitofp i8 %a to float
241  %2 = fadd float %1, 1.25
242  %3 = fptoui float %2 to i16
243  ret i16 %3
244}
245
246; CHECK-LABEL: @neg_toolarge
247; CHECK:  %1 = uitofp i80 %a to fp128
248; CHECK:  %2 = fadd fp128 %1, %1
249; CHECK:  %3 = fptoui fp128 %2 to i80
250; CHECK:  ret i80 %3
251; i80 > i64, which is the largest bitwidth handleable by default.
252define i80 @neg_toolarge(i80 %a) {
253  %1 = uitofp i80 %a to fp128
254  %2 = fadd fp128 %1, %1
255  %3 = fptoui fp128 %2 to i80
256  ret i80 %3
257}
258
259; CHECK-LABEL: @neg_calluser
260; CHECK: sitofp
261; CHECK: fcmp
262; The sequence %1..%3 cannot be converted because %4 uses %2.
263define i32 @neg_calluser(i32 %value) {
264  %1 = sitofp i32 %value to double
265  %2 = fadd double %1, 1.0
266  %3 = fcmp olt double %2, 0.000000e+00
267  %4 = tail call double @g(double %2)
268  %5 = fptosi double %4 to i32
269  %6 = zext i1 %3 to i32
270  %7 = add i32 %6, %5
271  ret i32 %7
272}
273declare double @g(double)
274
275; CHECK-LABEL: @neg_vector
276; CHECK:  %1 = uitofp <4 x i8> %a to <4 x float>
277; CHECK:  %2 = fptoui <4 x float> %1 to <4 x i16>
278; CHECK:  ret <4 x i16> %2
279define <4 x i16> @neg_vector(<4 x i8> %a) {
280  %1 = uitofp <4 x i8> %a to <4 x float>
281  %2 = fptoui <4 x float> %1 to <4 x i16>
282  ret <4 x i16> %2
283}
284