xref: /llvm-project/llvm/test/Transforms/Attributor/nofpclass-log.ll (revision d48d108bc66adb31185ee023e1eb0ccdda2065c1) 
1; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 2
2; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
3
4declare float @llvm.log.f32(float)
5declare float @llvm.log2.f32(float)
6declare float @llvm.log10.f32(float)
7
8declare <2 x float> @llvm.log.v2f32(<2 x float>)
9declare float @llvm.experimental.constrained.log.f32(float, metadata, metadata)
10declare float @llvm.experimental.constrained.log2.f32(float, metadata, metadata)
11declare float @llvm.experimental.constrained.log10.f32(float, metadata, metadata)
12
13define float @ret_log(float %arg) #0 {
14; CHECK-LABEL: define float @ret_log
15; CHECK-SAME: (float [[ARG:%.*]]) #[[ATTR2:[0-9]+]] {
16; CHECK-NEXT:    [[CALL:%.*]] = call float @llvm.log.f32(float [[ARG]]) #[[ATTR10:[0-9]+]]
17; CHECK-NEXT:    ret float [[CALL]]
18;
19  %call = call float @llvm.log.f32(float %arg)
20  ret float %call
21}
22
23define float @ret_log_noinf(float nofpclass(inf) %arg) #0 {
24; CHECK-LABEL: define nofpclass(pinf) float @ret_log_noinf
25; CHECK-SAME: (float nofpclass(inf) [[ARG:%.*]]) #[[ATTR2]] {
26; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(pinf) float @llvm.log.f32(float nofpclass(inf) [[ARG]]) #[[ATTR10]]
27; CHECK-NEXT:    ret float [[CALL]]
28;
29  %call = call float @llvm.log.f32(float %arg)
30  ret float %call
31}
32
33define float @ret_log_noneg(float nofpclass(ninf nsub nnorm) %arg) #0 {
34; CHECK-LABEL: define float @ret_log_noneg
35; CHECK-SAME: (float nofpclass(ninf nsub nnorm) [[ARG:%.*]]) #[[ATTR2]] {
36; CHECK-NEXT:    [[CALL:%.*]] = call float @llvm.log.f32(float nofpclass(ninf nsub nnorm) [[ARG]]) #[[ATTR10]]
37; CHECK-NEXT:    ret float [[CALL]]
38;
39  %call = call float @llvm.log.f32(float %arg)
40  ret float %call
41}
42
43define float @ret_log_noneg_nonan(float nofpclass(ninf nsub nnorm nan) %arg) #0 {
44; CHECK-LABEL: define nofpclass(nan) float @ret_log_noneg_nonan
45; CHECK-SAME: (float nofpclass(nan ninf nsub nnorm) [[ARG:%.*]]) #[[ATTR2]] {
46; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(nan) float @llvm.log.f32(float nofpclass(nan ninf nsub nnorm) [[ARG]]) #[[ATTR10]]
47; CHECK-NEXT:    ret float [[CALL]]
48;
49  %call = call float @llvm.log.f32(float %arg)
50  ret float %call
51}
52
53define float @ret_log_noinf_noneg(float nofpclass(inf nsub nnorm) %arg) #0 {
54; CHECK-LABEL: define nofpclass(pinf) float @ret_log_noinf_noneg
55; CHECK-SAME: (float nofpclass(inf nsub nnorm) [[ARG:%.*]]) #[[ATTR2]] {
56; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(pinf) float @llvm.log.f32(float nofpclass(inf nsub nnorm) [[ARG]]) #[[ATTR10]]
57; CHECK-NEXT:    ret float [[CALL]]
58;
59  %call = call float @llvm.log.f32(float %arg)
60  ret float %call
61}
62
63define float @ret_log_noinf_noneg_nonan(float nofpclass(inf nsub nnorm nan) %arg) #0 {
64; CHECK-LABEL: define nofpclass(nan pinf) float @ret_log_noinf_noneg_nonan
65; CHECK-SAME: (float nofpclass(nan inf nsub nnorm) [[ARG:%.*]]) #[[ATTR2]] {
66; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(nan pinf) float @llvm.log.f32(float nofpclass(nan inf nsub nnorm) [[ARG]]) #[[ATTR10]]
67; CHECK-NEXT:    ret float [[CALL]]
68;
69  %call = call float @llvm.log.f32(float %arg)
70  ret float %call
71}
72
73define float @ret_log_nopinf(float nofpclass(pinf) %arg) #0 {
74; CHECK-LABEL: define nofpclass(pinf) float @ret_log_nopinf
75; CHECK-SAME: (float nofpclass(pinf) [[ARG:%.*]]) #[[ATTR2]] {
76; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(pinf) float @llvm.log.f32(float nofpclass(pinf) [[ARG]]) #[[ATTR10]]
77; CHECK-NEXT:    ret float [[CALL]]
78;
79  %call = call float @llvm.log.f32(float %arg)
80  ret float %call
81}
82
83define float @ret_log_noninf(float nofpclass(ninf) %arg) #0 {
84; CHECK-LABEL: define float @ret_log_noninf
85; CHECK-SAME: (float nofpclass(ninf) [[ARG:%.*]]) #[[ATTR2]] {
86; CHECK-NEXT:    [[CALL:%.*]] = call float @llvm.log.f32(float nofpclass(ninf) [[ARG]]) #[[ATTR10]]
87; CHECK-NEXT:    ret float [[CALL]]
88;
89  %call = call float @llvm.log.f32(float %arg)
90  ret float %call
91}
92
93define float @ret_log_nonan(float nofpclass(nan) %arg) #0 {
94; CHECK-LABEL: define float @ret_log_nonan
95; CHECK-SAME: (float nofpclass(nan) [[ARG:%.*]]) #[[ATTR2]] {
96; CHECK-NEXT:    [[CALL:%.*]] = call float @llvm.log.f32(float nofpclass(nan) [[ARG]]) #[[ATTR10]]
97; CHECK-NEXT:    ret float [[CALL]]
98;
99  %call = call float @llvm.log.f32(float %arg)
100  ret float %call
101}
102
103define float @ret_log_nonan_noinf(float nofpclass(nan inf) %arg) #0 {
104; CHECK-LABEL: define nofpclass(pinf) float @ret_log_nonan_noinf
105; CHECK-SAME: (float nofpclass(nan inf) [[ARG:%.*]]) #[[ATTR2]] {
106; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(pinf) float @llvm.log.f32(float nofpclass(nan inf) [[ARG]]) #[[ATTR10]]
107; CHECK-NEXT:    ret float [[CALL]]
108;
109  %call = call float @llvm.log.f32(float %arg)
110  ret float %call
111}
112
113define float @ret_log_nonan_noinf_nozero(float nofpclass(nan inf zero) %arg) #0 {
114; CHECK-LABEL: define nofpclass(inf) float @ret_log_nonan_noinf_nozero
115; CHECK-SAME: (float nofpclass(nan inf zero) [[ARG:%.*]]) #[[ATTR2]] {
116; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(inf) float @llvm.log.f32(float nofpclass(nan inf zero) [[ARG]]) #[[ATTR10]]
117; CHECK-NEXT:    ret float [[CALL]]
118;
119  %call = call float @llvm.log.f32(float %arg)
120  ret float %call
121}
122
123define float @ret_log_noinf_nozero(float nofpclass(inf zero) %arg) #0 {
124; CHECK-LABEL: define nofpclass(inf) float @ret_log_noinf_nozero
125; CHECK-SAME: (float nofpclass(inf zero) [[ARG:%.*]]) #[[ATTR2]] {
126; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(inf) float @llvm.log.f32(float nofpclass(inf zero) [[ARG]]) #[[ATTR10]]
127; CHECK-NEXT:    ret float [[CALL]]
128;
129  %call = call float @llvm.log.f32(float %arg)
130  ret float %call
131}
132
133define float @ret_log_noinf_nonegzero(float nofpclass(inf nzero) %arg) #0 {
134; CHECK-LABEL: define nofpclass(pinf) float @ret_log_noinf_nonegzero
135; CHECK-SAME: (float nofpclass(inf nzero) [[ARG:%.*]]) #[[ATTR2]] {
136; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(pinf) float @llvm.log.f32(float nofpclass(inf nzero) [[ARG]]) #[[ATTR10]]
137; CHECK-NEXT:    ret float [[CALL]]
138;
139  %call = call float @llvm.log.f32(float %arg)
140  ret float %call
141}
142
143define float @ret_log_positive_source(i32 %arg) #0 {
144; CHECK-LABEL: define nofpclass(nan pinf) float @ret_log_positive_source
145; CHECK-SAME: (i32 [[ARG:%.*]]) #[[ATTR2]] {
146; CHECK-NEXT:    [[UITOFP:%.*]] = uitofp i32 [[ARG]] to float
147; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(nan pinf) float @llvm.log.f32(float [[UITOFP]]) #[[ATTR10]]
148; CHECK-NEXT:    ret float [[CALL]]
149;
150  %uitofp = uitofp i32 %arg to float
151  %call = call float @llvm.log.f32(float %uitofp)
152  ret float %call
153}
154
155; Could produce a nan because we don't know if the multiply is negative.
156define float @ret_log_unknown_sign(float nofpclass(nan) %arg, float nofpclass(nan) %arg1) #0 {
157; CHECK-LABEL: define float @ret_log_unknown_sign
158; CHECK-SAME: (float nofpclass(nan) [[ARG:%.*]], float nofpclass(nan) [[ARG1:%.*]]) #[[ATTR2]] {
159; CHECK-NEXT:    [[UNKNOWN_SIGN_NOT_NAN:%.*]] = fmul nnan float [[ARG]], [[ARG1]]
160; CHECK-NEXT:    [[CALL:%.*]] = call float @llvm.log.f32(float [[UNKNOWN_SIGN_NOT_NAN]]) #[[ATTR10]]
161; CHECK-NEXT:    ret float [[CALL]]
162;
163  %unknown.sign.not.nan = fmul nnan float %arg, %arg1
164  %call = call float @llvm.log.f32(float %unknown.sign.not.nan)
165  ret float %call
166}
167
168define float @ret_log_daz_noinf_nozero(float nofpclass(inf zero) %arg) #1 {
169; CHECK-LABEL: define nofpclass(pinf) float @ret_log_daz_noinf_nozero
170; CHECK-SAME: (float nofpclass(inf zero) [[ARG:%.*]]) #[[ATTR3:[0-9]+]] {
171; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(pinf) float @llvm.log.f32(float nofpclass(inf zero) [[ARG]]) #[[ATTR10]]
172; CHECK-NEXT:    ret float [[CALL]]
173;
174  %call = call float @llvm.log.f32(float %arg)
175  ret float %call
176}
177
178define <2 x float> @ret_log_daz_noinf_nozero_v2f32(<2 x float> nofpclass(inf zero) %arg) #1 {
179; CHECK-LABEL: define nofpclass(pinf) <2 x float> @ret_log_daz_noinf_nozero_v2f32
180; CHECK-SAME: (<2 x float> nofpclass(inf zero) [[ARG:%.*]]) #[[ATTR3]] {
181; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(pinf) <2 x float> @llvm.log.v2f32(<2 x float> nofpclass(inf zero) [[ARG]]) #[[ATTR10]]
182; CHECK-NEXT:    ret <2 x float> [[CALL]]
183;
184  %call = call <2 x float> @llvm.log.v2f32(<2 x float> %arg)
185  ret <2 x float> %call
186}
187
188define float @ret_log_daz_noinf_nonegzero(float nofpclass(inf nzero) %arg) #1 {
189; CHECK-LABEL: define nofpclass(pinf) float @ret_log_daz_noinf_nonegzero
190; CHECK-SAME: (float nofpclass(inf nzero) [[ARG:%.*]]) #[[ATTR3]] {
191; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(pinf) float @llvm.log.f32(float nofpclass(inf nzero) [[ARG]]) #[[ATTR10]]
192; CHECK-NEXT:    ret float [[CALL]]
193;
194  %call = call float @llvm.log.f32(float %arg)
195  ret float %call
196}
197
198define float @ret_log_dapz_noinf_nozero(float nofpclass(inf zero) %arg) #2 {
199; CHECK-LABEL: define nofpclass(pinf) float @ret_log_dapz_noinf_nozero
200; CHECK-SAME: (float nofpclass(inf zero) [[ARG:%.*]]) #[[ATTR4:[0-9]+]] {
201; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(pinf) float @llvm.log.f32(float nofpclass(inf zero) [[ARG]]) #[[ATTR10]]
202; CHECK-NEXT:    ret float [[CALL]]
203;
204  %call = call float @llvm.log.f32(float %arg)
205  ret float %call
206}
207
208define float @ret_log_dapz_noinf_nonegzero(float nofpclass(inf nzero) %arg) #2 {
209; CHECK-LABEL: define nofpclass(pinf) float @ret_log_dapz_noinf_nonegzero
210; CHECK-SAME: (float nofpclass(inf nzero) [[ARG:%.*]]) #[[ATTR4]] {
211; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(pinf) float @llvm.log.f32(float nofpclass(inf nzero) [[ARG]]) #[[ATTR10]]
212; CHECK-NEXT:    ret float [[CALL]]
213;
214  %call = call float @llvm.log.f32(float %arg)
215  ret float %call
216}
217
218define float @ret_log_dynamic_noinf_nozero(float nofpclass(inf zero) %arg) #3 {
219; CHECK-LABEL: define nofpclass(pinf) float @ret_log_dynamic_noinf_nozero
220; CHECK-SAME: (float nofpclass(inf zero) [[ARG:%.*]]) #[[ATTR5:[0-9]+]] {
221; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(pinf) float @llvm.log.f32(float nofpclass(inf zero) [[ARG]]) #[[ATTR10]]
222; CHECK-NEXT:    ret float [[CALL]]
223;
224  %call = call float @llvm.log.f32(float %arg)
225  ret float %call
226}
227
228define float @ret_log_dynamic_noinf_nonegzero(float nofpclass(inf nzero) %arg) #3 {
229; CHECK-LABEL: define nofpclass(pinf) float @ret_log_dynamic_noinf_nonegzero
230; CHECK-SAME: (float nofpclass(inf nzero) [[ARG:%.*]]) #[[ATTR5]] {
231; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(pinf) float @llvm.log.f32(float nofpclass(inf nzero) [[ARG]]) #[[ATTR10]]
232; CHECK-NEXT:    ret float [[CALL]]
233;
234  %call = call float @llvm.log.f32(float %arg)
235  ret float %call
236}
237
238define float @ret_log_ftz_noinf_nonegzero(float nofpclass(inf nzero) %arg) #4 {
239; CHECK-LABEL: define nofpclass(pinf) float @ret_log_ftz_noinf_nonegzero
240; CHECK-SAME: (float nofpclass(inf nzero) [[ARG:%.*]]) #[[ATTR6:[0-9]+]] {
241; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(pinf) float @llvm.log.f32(float nofpclass(inf nzero) [[ARG]]) #[[ATTR10]]
242; CHECK-NEXT:    ret float [[CALL]]
243;
244  %call = call float @llvm.log.f32(float %arg)
245  ret float %call
246}
247
248define float @ret_log_ftpz_noinf_nonegzero(float nofpclass(inf nzero) %arg) #5 {
249; CHECK-LABEL: define nofpclass(pinf) float @ret_log_ftpz_noinf_nonegzero
250; CHECK-SAME: (float nofpclass(inf nzero) [[ARG:%.*]]) #[[ATTR7:[0-9]+]] {
251; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(pinf) float @llvm.log.f32(float nofpclass(inf nzero) [[ARG]]) #[[ATTR10]]
252; CHECK-NEXT:    ret float [[CALL]]
253;
254  %call = call float @llvm.log.f32(float %arg)
255  ret float %call
256}
257
258define float @ret_log_ftz_dynamic_noinf_nonegzero(float nofpclass(inf nzero) %arg) #6 {
259; CHECK-LABEL: define nofpclass(pinf) float @ret_log_ftz_dynamic_noinf_nonegzero
260; CHECK-SAME: (float nofpclass(inf nzero) [[ARG:%.*]]) #[[ATTR8:[0-9]+]] {
261; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(pinf) float @llvm.log.f32(float nofpclass(inf nzero) [[ARG]]) #[[ATTR10]]
262; CHECK-NEXT:    ret float [[CALL]]
263;
264  %call = call float @llvm.log.f32(float %arg)
265  ret float %call
266}
267
268define float @constrained_log(float %arg) strictfp {
269; CHECK-LABEL: define float @constrained_log
270; CHECK-SAME: (float [[ARG:%.*]]) #[[ATTR9:[0-9]+]] {
271; CHECK-NEXT:    [[VAL:%.*]] = call float @llvm.experimental.constrained.log.f32(float [[ARG]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR11:[0-9]+]]
272; CHECK-NEXT:    ret float [[VAL]]
273;
274  %val = call float @llvm.experimental.constrained.log.f32(float %arg, metadata !"round.dynamic", metadata !"fpexcept.strict")
275  ret float %val
276}
277
278define float @constrained_log_nonan(float nofpclass(nan) %arg) strictfp {
279; CHECK-LABEL: define float @constrained_log_nonan
280; CHECK-SAME: (float nofpclass(nan) [[ARG:%.*]]) #[[ATTR9]] {
281; CHECK-NEXT:    [[VAL:%.*]] = call float @llvm.experimental.constrained.log.f32(float nofpclass(nan) [[ARG]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR11]]
282; CHECK-NEXT:    ret float [[VAL]]
283;
284  %val = call float @llvm.experimental.constrained.log.f32(float %arg, metadata !"round.dynamic", metadata !"fpexcept.strict")
285  ret float %val
286}
287
288define float @constrained_log_nopinf(float nofpclass(pinf) %arg) strictfp {
289; CHECK-LABEL: define nofpclass(pinf) float @constrained_log_nopinf
290; CHECK-SAME: (float nofpclass(pinf) [[ARG:%.*]]) #[[ATTR9]] {
291; CHECK-NEXT:    [[VAL:%.*]] = call nofpclass(pinf) float @llvm.experimental.constrained.log.f32(float nofpclass(pinf) [[ARG]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR11]]
292; CHECK-NEXT:    ret float [[VAL]]
293;
294  %val = call float @llvm.experimental.constrained.log.f32(float %arg, metadata !"round.dynamic", metadata !"fpexcept.strict")
295  ret float %val
296}
297
298define float @constrained_log_nonegzero(float nofpclass(nzero) %arg) strictfp {
299; CHECK-LABEL: define float @constrained_log_nonegzero
300; CHECK-SAME: (float nofpclass(nzero) [[ARG:%.*]]) #[[ATTR9]] {
301; CHECK-NEXT:    [[VAL:%.*]] = call float @llvm.experimental.constrained.log.f32(float nofpclass(nzero) [[ARG]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR11]]
302; CHECK-NEXT:    ret float [[VAL]]
303;
304  %val = call float @llvm.experimental.constrained.log.f32(float %arg, metadata !"round.dynamic", metadata !"fpexcept.strict")
305  ret float %val
306}
307
308define float @constrained_log_nozero(float nofpclass(zero) %arg) strictfp {
309; CHECK-LABEL: define nofpclass(ninf) float @constrained_log_nozero
310; CHECK-SAME: (float nofpclass(zero) [[ARG:%.*]]) #[[ATTR9]] {
311; CHECK-NEXT:    [[VAL:%.*]] = call nofpclass(ninf) float @llvm.experimental.constrained.log.f32(float nofpclass(zero) [[ARG]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR11]]
312; CHECK-NEXT:    ret float [[VAL]]
313;
314  %val = call float @llvm.experimental.constrained.log.f32(float %arg, metadata !"round.dynamic", metadata !"fpexcept.strict")
315  ret float %val
316}
317
318define float @ret_log2_noinf_noneg(float nofpclass(inf nsub nnorm) %arg) #0 {
319; CHECK-LABEL: define nofpclass(pinf) float @ret_log2_noinf_noneg
320; CHECK-SAME: (float nofpclass(inf nsub nnorm) [[ARG:%.*]]) #[[ATTR2]] {
321; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(pinf) float @llvm.log2.f32(float nofpclass(inf nsub nnorm) [[ARG]]) #[[ATTR10]]
322; CHECK-NEXT:    ret float [[CALL]]
323;
324  %call = call float @llvm.log2.f32(float %arg)
325  ret float %call
326}
327
328define float @ret_log2_noinf_noneg_nonan(float nofpclass(inf nsub nnorm nan) %arg) #0 {
329; CHECK-LABEL: define nofpclass(nan pinf) float @ret_log2_noinf_noneg_nonan
330; CHECK-SAME: (float nofpclass(nan inf nsub nnorm) [[ARG:%.*]]) #[[ATTR2]] {
331; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(nan pinf) float @llvm.log2.f32(float nofpclass(nan inf nsub nnorm) [[ARG]]) #[[ATTR10]]
332; CHECK-NEXT:    ret float [[CALL]]
333;
334  %call = call float @llvm.log2.f32(float %arg)
335  ret float %call
336}
337
338define float @ret_log2_noinf_noneg_noqnan(float nofpclass(inf nsub nnorm qnan) %arg) #0 {
339; CHECK-LABEL: define nofpclass(pinf) float @ret_log2_noinf_noneg_noqnan
340; CHECK-SAME: (float nofpclass(qnan inf nsub nnorm) [[ARG:%.*]]) #[[ATTR2]] {
341; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(pinf) float @llvm.log2.f32(float nofpclass(qnan inf nsub nnorm) [[ARG]]) #[[ATTR10]]
342; CHECK-NEXT:    ret float [[CALL]]
343;
344  %call = call float @llvm.log2.f32(float %arg)
345  ret float %call
346}
347
348define float @ret_log2_noinf_noneg_nosnan(float nofpclass(inf nsub nnorm snan) %arg) #0 {
349; CHECK-LABEL: define nofpclass(pinf) float @ret_log2_noinf_noneg_nosnan
350; CHECK-SAME: (float nofpclass(snan inf nsub nnorm) [[ARG:%.*]]) #[[ATTR2]] {
351; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(pinf) float @llvm.log2.f32(float nofpclass(snan inf nsub nnorm) [[ARG]]) #[[ATTR10]]
352; CHECK-NEXT:    ret float [[CALL]]
353;
354  %call = call float @llvm.log2.f32(float %arg)
355  ret float %call
356}
357
358define float @ret_log10_noinf_noneg(float nofpclass(inf nsub nnorm) %arg) #0 {
359; CHECK-LABEL: define nofpclass(pinf) float @ret_log10_noinf_noneg
360; CHECK-SAME: (float nofpclass(inf nsub nnorm) [[ARG:%.*]]) #[[ATTR2]] {
361; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(pinf) float @llvm.log10.f32(float nofpclass(inf nsub nnorm) [[ARG]]) #[[ATTR10]]
362; CHECK-NEXT:    ret float [[CALL]]
363;
364  %call = call float @llvm.log10.f32(float %arg)
365  ret float %call
366}
367
368define float @ret_constrained_log2_noinf_noneg(float nofpclass(inf nsub nnorm) %arg) strictfp {
369; CHECK-LABEL: define nofpclass(pinf) float @ret_constrained_log2_noinf_noneg
370; CHECK-SAME: (float nofpclass(inf nsub nnorm) [[ARG:%.*]]) #[[ATTR9]] {
371; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(pinf) float @llvm.experimental.constrained.log2.f32(float nofpclass(inf nsub nnorm) [[ARG]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR11]]
372; CHECK-NEXT:    ret float [[CALL]]
373;
374  %call = call float @llvm.experimental.constrained.log2.f32(float %arg, metadata !"round.dynamic", metadata !"fpexcept.strict")
375  ret float %call
376}
377
378define float @ret_constrained_log10_noinf_noneg(float nofpclass(inf nsub nnorm) %arg) strictfp {
379; CHECK-LABEL: define nofpclass(pinf) float @ret_constrained_log10_noinf_noneg
380; CHECK-SAME: (float nofpclass(inf nsub nnorm) [[ARG:%.*]]) #[[ATTR9]] {
381; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(pinf) float @llvm.experimental.constrained.log10.f32(float nofpclass(inf nsub nnorm) [[ARG]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR11]]
382; CHECK-NEXT:    ret float [[CALL]]
383;
384  %call = call float @llvm.experimental.constrained.log10.f32(float %arg, metadata !"round.dynamic", metadata !"fpexcept.strict")
385  ret float %call
386}
387
388attributes #0 = { "denormal-fp-math"="ieee,ieee" }
389attributes #1 = { "denormal-fp-math"="ieee,preserve-sign" }
390attributes #2 = { "denormal-fp-math"="ieee,positive-zero" }
391attributes #3 = { "denormal-fp-math"="ieee,dynamic" }
392attributes #4 = { "denormal-fp-math"="preserve-sign,ieee" }
393attributes #5 = { "denormal-fp-math"="positive-zero,ieee" }
394attributes #6 = { "denormal-fp-math"="dynamic,ieee" }
395
396;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
397; TUNIT: {{.*}}
398