Mercurial > hg > CbC > CbC_llvm

comparison llvm/test/Feature/fp-intrinsics.ll @ 150:1d019706d866

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
LLVM10
author anatofuz
date Thu, 13 Feb 2020 15:10:13 +0900
parents
children
comparison
equal deleted inserted replaced
147:c2174574ed3a 150:1d019706d866
1 ; RUN: opt -O3 -S < %s | FileCheck %s
2
3 ; Test to verify that constants aren't folded when the rounding mode is unknown.
4 ; CHECK-LABEL: @f1
5 ; CHECK: call double @llvm.experimental.constrained.fdiv.f64
6 define double @f1() #0 {
7 entry:
8 %div = call double @llvm.experimental.constrained.fdiv.f64(
9 double 1.000000e+00,
10 double 1.000000e+01,
11 metadata !"round.dynamic",
12 metadata !"fpexcept.strict") #0
13 ret double %div
14 }
15
16 ; Verify that 'a - 0' isn't simplified to 'a' when the rounding mode is unknown.
17 ;
18 ; double f2(double a) {
19 ; // Because the result of '0 - 0' is negative zero if rounding mode is
20 ; // downward, this shouldn't be simplified.
21 ; return a - 0.0;
22 ; }
23 ;
24 ; CHECK-LABEL: @f2
25 ; CHECK: call double @llvm.experimental.constrained.fsub.f64
26 define double @f2(double %a) #0 {
27 entry:
28 %div = call double @llvm.experimental.constrained.fsub.f64(
29 double %a, double 0.000000e+00,
30 metadata !"round.dynamic",
31 metadata !"fpexcept.strict") #0
32 ret double %div
33 }
34
35 ; Verify that '-((-a)*b)' isn't simplified to 'a*b' when the rounding mode is
36 ; unknown.
37 ;
38 ; double f3(double a, double b) {
39 ; // Because the intermediate value involved in this calculation may require
40 ; // rounding, this shouldn't be simplified.
41 ; return -((-a)*b);
42 ; }
43 ;
44 ; CHECK-LABEL: @f3
45 ; CHECK: call double @llvm.experimental.constrained.fsub.f64
46 ; CHECK: call double @llvm.experimental.constrained.fmul.f64
47 ; CHECK: call double @llvm.experimental.constrained.fsub.f64
48 define double @f3(double %a, double %b) #0 {
49 entry:
50 %sub = call double @llvm.experimental.constrained.fsub.f64(
51 double -0.000000e+00, double %a,
52 metadata !"round.dynamic",
53 metadata !"fpexcept.strict") #0
54 %mul = call double @llvm.experimental.constrained.fmul.f64(
55 double %sub, double %b,
56 metadata !"round.dynamic",
57 metadata !"fpexcept.strict") #0
58 %ret = call double @llvm.experimental.constrained.fsub.f64(
59 double -0.000000e+00,
60 double %mul,
61 metadata !"round.dynamic",
62 metadata !"fpexcept.strict") #0
63 ret double %ret
64 }
65
66 ; Verify that FP operations are not performed speculatively when FP exceptions
67 ; are not being ignored.
68 ;
69 ; double f4(int n, double a) {
70 ; // Because a + 1 may overflow, this should not be simplified.
71 ; if (n > 0)
72 ; return a + 1.0;
73 ; return a;
74 ; }
75 ;
76 ;
77 ; CHECK-LABEL: @f4
78 ; CHECK-NOT: select
79 ; CHECK: br i1 %cmp
80 define double @f4(i32 %n, double %a) #0 {
81 entry:
82 %cmp = icmp sgt i32 %n, 0
83 br i1 %cmp, label %if.then, label %if.end
84
85 if.then:
86 %add = call double @llvm.experimental.constrained.fadd.f64(
87 double 1.000000e+00, double %a,
88 metadata !"round.dynamic",
89 metadata !"fpexcept.strict") #0
90 br label %if.end
91
92 if.end:
93 %a.0 = phi double [%add, %if.then], [ %a, %entry ]
94 ret double %a.0
95 }
96
97 ; Verify that sqrt(42.0) isn't simplified when the rounding mode is unknown.
98 ; CHECK-LABEL: f5
99 ; CHECK: call double @llvm.experimental.constrained.sqrt
100 define double @f5() #0 {
101 entry:
102 %result = call double @llvm.experimental.constrained.sqrt.f64(double 42.0,
103 metadata !"round.dynamic",
104 metadata !"fpexcept.strict") #0
105 ret double %result
106 }
107
108 ; Verify that pow(42.1, 3.0) isn't simplified when the rounding mode is unknown.
109 ; CHECK-LABEL: f6
110 ; CHECK: call double @llvm.experimental.constrained.pow
111 define double @f6() #0 {
112 entry:
113 %result = call double @llvm.experimental.constrained.pow.f64(double 42.1,
114 double 3.0,
115 metadata !"round.dynamic",
116 metadata !"fpexcept.strict") #0
117 ret double %result
118 }
119
120 ; Verify that powi(42.1, 3) isn't simplified when the rounding mode is unknown.
121 ; CHECK-LABEL: f7
122 ; CHECK: call double @llvm.experimental.constrained.powi
123 define double @f7() #0 {
124 entry:
125 %result = call double @llvm.experimental.constrained.powi.f64(double 42.1,
126 i32 3,
127 metadata !"round.dynamic",
128 metadata !"fpexcept.strict") #0
129 ret double %result
130 }
131
132 ; Verify that sin(42.0) isn't simplified when the rounding mode is unknown.
133 ; CHECK-LABEL: f8
134 ; CHECK: call double @llvm.experimental.constrained.sin
135 define double @f8() #0 {
136 entry:
137 %result = call double @llvm.experimental.constrained.sin.f64(double 42.0,
138 metadata !"round.dynamic",
139 metadata !"fpexcept.strict") #0
140 ret double %result
141 }
142
143 ; Verify that cos(42.0) isn't simplified when the rounding mode is unknown.
144 ; CHECK-LABEL: f9
145 ; CHECK: call double @llvm.experimental.constrained.cos
146 define double @f9() #0 {
147 entry:
148 %result = call double @llvm.experimental.constrained.cos.f64(double 42.0,
149 metadata !"round.dynamic",
150 metadata !"fpexcept.strict") #0
151 ret double %result
152 }
153
154 ; Verify that exp(42.0) isn't simplified when the rounding mode is unknown.
155 ; CHECK-LABEL: f10
156 ; CHECK: call double @llvm.experimental.constrained.exp
157 define double @f10() #0 {
158 entry:
159 %result = call double @llvm.experimental.constrained.exp.f64(double 42.0,
160 metadata !"round.dynamic",
161 metadata !"fpexcept.strict") #0
162 ret double %result
163 }
164
165 ; Verify that exp2(42.1) isn't simplified when the rounding mode is unknown.
166 ; CHECK-LABEL: f11
167 ; CHECK: call double @llvm.experimental.constrained.exp2
168 define double @f11() #0 {
169 entry:
170 %result = call double @llvm.experimental.constrained.exp2.f64(double 42.1,
171 metadata !"round.dynamic",
172 metadata !"fpexcept.strict") #0
173 ret double %result
174 }
175
176 ; Verify that log(42.0) isn't simplified when the rounding mode is unknown.
177 ; CHECK-LABEL: f12
178 ; CHECK: call double @llvm.experimental.constrained.log
179 define double @f12() #0 {
180 entry:
181 %result = call double @llvm.experimental.constrained.log.f64(double 42.0,
182 metadata !"round.dynamic",
183 metadata !"fpexcept.strict") #0
184 ret double %result
185 }
186
187 ; Verify that log10(42.0) isn't simplified when the rounding mode is unknown.
188 ; CHECK-LABEL: f13
189 ; CHECK: call double @llvm.experimental.constrained.log10
190 define double @f13() #0 {
191 entry:
192 %result = call double @llvm.experimental.constrained.log10.f64(double 42.0,
193 metadata !"round.dynamic",
194 metadata !"fpexcept.strict") #0
195 ret double %result
196 }
197
198 ; Verify that log2(42.0) isn't simplified when the rounding mode is unknown.
199 ; CHECK-LABEL: f14
200 ; CHECK: call double @llvm.experimental.constrained.log2
201 define double @f14() #0 {
202 entry:
203 %result = call double @llvm.experimental.constrained.log2.f64(double 42.0,
204 metadata !"round.dynamic",
205 metadata !"fpexcept.strict") #0
206 ret double %result
207 }
208
209 ; Verify that rint(42.1) isn't simplified when the rounding mode is unknown.
210 ; CHECK-LABEL: f15
211 ; CHECK: call double @llvm.experimental.constrained.rint
212 define double @f15() #0 {
213 entry:
214 %result = call double @llvm.experimental.constrained.rint.f64(double 42.1,
215 metadata !"round.dynamic",
216 metadata !"fpexcept.strict") #0
217 ret double %result
218 }
219
220 ; Verify that nearbyint(42.1) isn't simplified when the rounding mode is
221 ; unknown.
222 ; CHECK-LABEL: f16
223 ; CHECK: call double @llvm.experimental.constrained.nearbyint
224 define double @f16() #0 {
225 entry:
226 %result = call double @llvm.experimental.constrained.nearbyint.f64(
227 double 42.1,
228 metadata !"round.dynamic",
229 metadata !"fpexcept.strict") #0
230 ret double %result
231 }
232
233 ; Verify that fma(42.1) isn't simplified when the rounding mode is
234 ; unknown.
235 ; CHECK-LABEL: f17
236 ; CHECK: call double @llvm.experimental.constrained.fma
237 define double @f17() #0 {
238 entry:
239 %result = call double @llvm.experimental.constrained.fma.f64(double 42.1, double 42.1, double 42.1,
240 metadata !"round.dynamic",
241 metadata !"fpexcept.strict") #0
242 ret double %result
243 }
244
245 ; Verify that fptoui(42.1) isn't simplified when the rounding mode is
246 ; unknown.
247 ; CHECK-LABEL: f18
248 ; CHECK: call zeroext i32 @llvm.experimental.constrained.fptoui
249 define zeroext i32 @f18() #0 {
250 entry:
251 %result = call zeroext i32 @llvm.experimental.constrained.fptoui.i32.f64(
252 double 42.1,
253 metadata !"fpexcept.strict") #0
254 ret i32 %result
255 }
256
257 ; Verify that fptosi(42.1) isn't simplified when the rounding mode is
258 ; unknown.
259 ; CHECK-LABEL: f19
260 ; CHECK: call i32 @llvm.experimental.constrained.fptosi
261 define i32 @f19() #0 {
262 entry:
263 %result = call i32 @llvm.experimental.constrained.fptosi.i32.f64(double 42.1,
264 metadata !"fpexcept.strict") #0
265 ret i32 %result
266 }
267
268 ; Verify that fptrunc(42.1) isn't simplified when the rounding mode is
269 ; unknown.
270 ; CHECK-LABEL: f20
271 ; CHECK: call float @llvm.experimental.constrained.fptrunc
272 define float @f20() #0 {
273 entry:
274 %result = call float @llvm.experimental.constrained.fptrunc.f32.f64(
275 double 42.1,
276 metadata !"round.dynamic",
277 metadata !"fpexcept.strict") #0
278 ret float %result
279 }
280
281 ; Verify that fpext(42.1) isn't simplified when the rounding mode is
282 ; unknown.
283 ; CHECK-LABEL: f21
284 ; CHECK: call double @llvm.experimental.constrained.fpext
285 define double @f21() #0 {
286 entry:
287 %result = call double @llvm.experimental.constrained.fpext.f64.f32(float 42.0,
288 metadata !"fpexcept.strict") #0
289 ret double %result
290 }
291
292 ; Verify that lrint(42.1) isn't simplified when the rounding mode is unknown.
293 ; CHECK-LABEL: f22
294 ; CHECK: call i32 @llvm.experimental.constrained.lrint
295 define i32 @f22() #0 {
296 entry:
297 %result = call i32 @llvm.experimental.constrained.lrint.i32.f64(double 42.1,
298 metadata !"round.dynamic",
299 metadata !"fpexcept.strict") #0
300 ret i32 %result
301 }
302
303 ; Verify that lrintf(42.0) isn't simplified when the rounding mode is unknown.
304 ; CHECK-LABEL: f23
305 ; CHECK: call i32 @llvm.experimental.constrained.lrint
306 define i32 @f23() #0 {
307 entry:
308 %result = call i32 @llvm.experimental.constrained.lrint.i32.f32(float 42.0,
309 metadata !"round.dynamic",
310 metadata !"fpexcept.strict") #0
311 ret i32 %result
312 }
313
314 ; Verify that llrint(42.1) isn't simplified when the rounding mode is unknown.
315 ; CHECK-LABEL: f24
316 ; CHECK: call i64 @llvm.experimental.constrained.llrint
317 define i64 @f24() #0 {
318 entry:
319 %result = call i64 @llvm.experimental.constrained.llrint.i64.f64(double 42.1,
320 metadata !"round.dynamic",
321 metadata !"fpexcept.strict") #0
322 ret i64 %result
323 }
324
325 ; Verify that llrint(42.0) isn't simplified when the rounding mode is unknown.
326 ; CHECK-LABEL: f25
327 ; CHECK: call i64 @llvm.experimental.constrained.llrint
328 define i64 @f25() #0 {
329 entry:
330 %result = call i64 @llvm.experimental.constrained.llrint.i64.f32(float 42.0,
331 metadata !"round.dynamic",
332 metadata !"fpexcept.strict") #0
333 ret i64 %result
334 }
335
336 ; Verify that lround(42.1) isn't simplified when the rounding mode is unknown.
337 ; CHECK-LABEL: f26
338 ; CHECK: call i32 @llvm.experimental.constrained.lround
339 define i32 @f26() #0 {
340 entry:
341 %result = call i32 @llvm.experimental.constrained.lround.i32.f64(double 42.1,
342 metadata !"fpexcept.strict") #0
343 ret i32 %result
344 }
345
346 ; Verify that lround(42.0) isn't simplified when the rounding mode is unknown.
347 ; CHECK-LABEL: f27
348 ; CHECK: call i32 @llvm.experimental.constrained.lround
349 define i32 @f27() #0 {
350 entry:
351 %result = call i32 @llvm.experimental.constrained.lround.i32.f32(float 42.0,
352 metadata !"fpexcept.strict") #0
353 ret i32 %result
354 }
355
356 ; Verify that llround(42.1) isn't simplified when the rounding mode is unknown.
357 ; CHECK-LABEL: f28
358 ; CHECK: call i64 @llvm.experimental.constrained.llround
359 define i64 @f28() #0 {
360 entry:
361 %result = call i64 @llvm.experimental.constrained.llround.i64.f64(double 42.1,
362 metadata !"fpexcept.strict") #0
363 ret i64 %result
364 }
365
366 ; Verify that llround(42.0) isn't simplified when the rounding mode is unknown.
367 ; CHECK-LABEL: f29
368 ; CHECK: call i64 @llvm.experimental.constrained.llround
369 define i64 @f29() #0 {
370 entry:
371 %result = call i64 @llvm.experimental.constrained.llround.i64.f32(float 42.0,
372 metadata !"fpexcept.strict") #0
373 ret i64 %result
374 }
375
376 ; Verify that sitofp(42) isn't simplified when the rounding mode is unknown.
377 ; CHECK-LABEL: @f30
378 ; CHECK: call double @llvm.experimental.constrained.sitofp
379 define double @f30() #0 {
380 entry:
381 %result = call double @llvm.experimental.constrained.sitofp.f64.i32(i32 42,
382 metadata !"round.dynamic",
383 metadata !"fpexcept.strict") #0
384 ret double %result
385 }
386
387 ; Verify that uitofp(42) isn't simplified when the rounding mode is unknown.
388 ; CHECK-LABEL: @f31
389 ; CHECK: call double @llvm.experimental.constrained.uitofp
390 define double @f31() #0 {
391 entry:
392 %result = call double @llvm.experimental.constrained.uitofp.f64.i32(i32 42,
393 metadata !"round.dynamic",
394 metadata !"fpexcept.strict") #0
395 ret double %result
396 }
397
398 attributes #0 = { strictfp }
399
400 @llvm.fp.env = thread_local global i8 zeroinitializer, section "llvm.metadata"
401 declare double @llvm.experimental.constrained.fdiv.f64(double, double, metadata, metadata)
402 declare double @llvm.experimental.constrained.fmul.f64(double, double, metadata, metadata)
403 declare double @llvm.experimental.constrained.fadd.f64(double, double, metadata, metadata)
404 declare double @llvm.experimental.constrained.fsub.f64(double, double, metadata, metadata)
405 declare double @llvm.experimental.constrained.sqrt.f64(double, metadata, metadata)
406 declare double @llvm.experimental.constrained.pow.f64(double, double, metadata, metadata)
407 declare double @llvm.experimental.constrained.powi.f64(double, i32, metadata, metadata)
408 declare double @llvm.experimental.constrained.sin.f64(double, metadata, metadata)
409 declare double @llvm.experimental.constrained.cos.f64(double, metadata, metadata)
410 declare double @llvm.experimental.constrained.exp.f64(double, metadata, metadata)
411 declare double @llvm.experimental.constrained.exp2.f64(double, metadata, metadata)
412 declare double @llvm.experimental.constrained.log.f64(double, metadata, metadata)
413 declare double @llvm.experimental.constrained.log10.f64(double, metadata, metadata)
414 declare double @llvm.experimental.constrained.log2.f64(double, metadata, metadata)
415 declare double @llvm.experimental.constrained.rint.f64(double, metadata, metadata)
416 declare double @llvm.experimental.constrained.nearbyint.f64(double, metadata, metadata)
417 declare double @llvm.experimental.constrained.fma.f64(double, double, double, metadata, metadata)
418 declare i32 @llvm.experimental.constrained.fptosi.i32.f64(double, metadata)
419 declare i32 @llvm.experimental.constrained.fptoui.i32.f64(double, metadata)
420 declare float @llvm.experimental.constrained.fptrunc.f32.f64(double, metadata, metadata)
421 declare double @llvm.experimental.constrained.fpext.f64.f32(float, metadata)
422 declare i32 @llvm.experimental.constrained.lrint.i32.f64(double, metadata, metadata)
423 declare i32 @llvm.experimental.constrained.lrint.i32.f32(float, metadata, metadata)
424 declare i64 @llvm.experimental.constrained.llrint.i64.f64(double, metadata, metadata)
425 declare i64 @llvm.experimental.constrained.llrint.i64.f32(float, metadata, metadata)
426 declare i32 @llvm.experimental.constrained.lround.i32.f64(double, metadata)
427 declare i32 @llvm.experimental.constrained.lround.i32.f32(float, metadata)
428 declare i64 @llvm.experimental.constrained.llround.i64.f64(double, metadata)
429 declare i64 @llvm.experimental.constrained.llround.i64.f32(float, metadata)
430 declare double @llvm.experimental.constrained.sitofp.f64.i32(i32, metadata, metadata)
431 declare double @llvm.experimental.constrained.uitofp.f64.i32(i32, metadata, metadata)