Lines Matching full:float
4 declare float @llvm.minnum.f32(float, float)
5 declare float @llvm.maxnum.f32(float, float)
6 declare float @llvm.minimum.f32(float, float)
7 declare float @llvm.maximum.f32(float, float)
8 declare <2 x float> @llvm.minnum.v2f32(<2 x float>, <2 x float>)
9 declare <2 x float> @llvm.maxnum.v2f32(<2 x float>, <2 x float>)
10 declare <2 x float> @llvm.minimum.v2f32(<2 x float>, <2 x float>)
11 declare <2 x float> @llvm.maximum.v2f32(<2 x float>, <2 x float>)
22 define float @test_minnum_const_nan(float %x) {
24 ; CHECK-NEXT: ret float [[X:%.*]]
26 %r = call float @llvm.minnum.f32(float %x, float 0x7fff000000000000)
27 ret float %r
30 define float @test_maxnum_const_nan(float %x) {
32 ; CHECK-NEXT: ret float [[X:%.*]]
34 %r = call float @llvm.maxnum.f32(float %x, float 0x7fff000000000000)
35 ret float %r
38 define float @test_maximum_const_nan(float %x) {
40 ; CHECK-NEXT: ret float 0x7FFF000000000000
42 %r = call float @llvm.maximum.f32(float %x, float 0x7fff000000000000)
43 ret float %r
46 define float @test_minimum_const_nan(float %x) {
48 ; CHECK-NEXT: ret float 0x7FFF000000000000
50 %r = call float @llvm.minimum.f32(float %x, float 0x7fff000000000000)
51 ret float %r
54 define float @test_minnum_const_inf(float %x) {
56 ; CHECK-NEXT: [[R:%.*]] = call float @llvm.minnum.f32(float [[X:%.*]], float 0x7FF0000000000000)
57 ; CHECK-NEXT: ret float [[R]]
59 %r = call float @llvm.minnum.f32(float %x, float 0x7ff0000000000000)
60 ret float %r
63 define float @test_maxnum_const_inf(float %x) {
65 ; CHECK-NEXT: ret float 0x7FF0000000000000
67 %r = call float @llvm.maxnum.f32(float %x, float 0x7ff0000000000000)
68 ret float %r
71 define float @test_maximum_const_inf(float %x) {
73 ; CHECK-NEXT: [[R:%.*]] = call float @llvm.maximum.f32(float [[X:%.*]], float 0x7FF0000000000000)
74 ; CHECK-NEXT: ret float [[R]]
76 %r = call float @llvm.maximum.f32(float %x, float 0x7ff0000000000000)
77 ret float %r
80 define float @test_minimum_const_inf(float %x) {
82 ; CHECK-NEXT: ret float [[X:%.*]]
84 %r = call float @llvm.minimum.f32(float %x, float 0x7ff0000000000000)
85 ret float %r
88 define float @test_minnum_const_neg_inf(float %x) {
90 ; CHECK-NEXT: ret float 0xFFF0000000000000
92 %r = call float @llvm.minnum.f32(float %x, float 0xfff0000000000000)
93 ret float %r
96 define float @test_maxnum_const_neg_inf(float %x) {
98 ; CHECK-NEXT: [[R:%.*]] = call float @llvm.maxnum.f32(float [[X:%.*]], float 0xFFF0000000000000)
99 ; CHECK-NEXT: ret float [[R]]
101 %r = call float @llvm.maxnum.f32(float %x, float 0xfff0000000000000)
102 ret float %r
105 define float @test_maximum_const_neg_inf(float %x) {
107 ; CHECK-NEXT: ret float [[X:%.*]]
109 %r = call float @llvm.maximum.f32(float %x, float 0xfff0000000000000)
110 ret float %r
113 define float @test_minimum_const_neg_inf(float %x) {
115 ; CHECK-NEXT: [[R:%.*]] = call float @llvm.minimum.f32(float [[X:%.*]], float 0xFFF0000000000000)
116 ; CHECK-NEXT: ret float [[R]]
118 %r = call float @llvm.minimum.f32(float %x, float 0xfff0000000000000)
119 ret float %r
122 define float @test_minnum_const_inf_nnan(float %x) {
124 ; CHECK-NEXT: ret float [[X:%.*]]
126 %r = call nnan float @llvm.minnum.f32(float %x, float 0x7ff0000000000000)
127 ret float %r
130 define float @test_maxnum_const_inf_nnan(float %x) {
132 ; CHECK-NEXT: ret float 0x7FF0000000000000
134 %r = call nnan float @llvm.maxnum.f32(float %x, float 0x7ff0000000000000)
135 ret float %r
138 define float @test_maximum_const_inf_nnan(float %x) {
140 ; CHECK-NEXT: ret float 0x7FF0000000000000
142 %r = call nnan float @llvm.maximum.f32(float %x, float 0x7ff0000000000000)
143 ret float %r
146 define float @test_minimum_const_inf_nnan(float %x) {
148 ; CHECK-NEXT: ret float [[X:%.*]]
150 %r = call nnan float @llvm.minimum.f32(float %x, float 0x7ff0000000000000)
151 ret float %r
154 define float @test_minnum_const_inf_nnan_comm(float %x) {
156 ; CHECK-NEXT: ret float [[X:%.*]]
158 %r = call nnan float @llvm.minnum.f32(float 0x7ff0000000000000, float %x)
159 ret float %r
162 define float @test_maxnum_const_inf_nnan_comm(float %x) {
164 ; CHECK-NEXT: ret float 0x7FF0000000000000
166 %r = call nnan float @llvm.maxnum.f32(float 0x7ff0000000000000, float %x)
167 ret float %r
170 define float @test_maximum_const_inf_nnan_comm(float %x) {
172 ; CHECK-NEXT: ret float 0x7FF0000000000000
174 %r = call nnan float @llvm.maximum.f32(float 0x7ff0000000000000, float %x)
175 ret float %r
178 define float @test_minimum_const_inf_nnan_comm(float %x) {
180 ; CHECK-NEXT: ret float [[X:%.*]]
182 %r = call nnan float @llvm.minimum.f32(float 0x7ff0000000000000, float %x)
183 ret float %r
186 define <2 x float> @test_minnum_const_inf_nnan_comm_vec(<2 x float> %x) {
188 ; CHECK-NEXT: ret <2 x float> [[X:%.*]]
190 …%r = call nnan <2 x float> @llvm.minnum.v2f32(<2 x float> <float 0x7ff0000000000000, float 0x7ff00…
191 ret <2 x float> %r
194 define <2 x float> @test_maxnum_const_inf_nnan_comm_vec(<2 x float> %x) {
196 ; CHECK-NEXT: ret <2 x float> <float 0x7FF0000000000000, float 0x7FF0000000000000>
198 …%r = call nnan <2 x float> @llvm.maxnum.v2f32(<2 x float> <float 0x7ff0000000000000, float 0x7ff00…
199 ret <2 x float> %r
202 define <2 x float> @test_maximum_const_inf_nnan_comm_vec(<2 x float> %x) {
204 ; CHECK-NEXT: ret <2 x float> <float 0x7FF0000000000000, float 0x7FF0000000000000>
206 …%r = call nnan <2 x float> @llvm.maximum.v2f32(<2 x float> <float 0x7ff0000000000000, float 0x7ff0…
207 ret <2 x float> %r
210 define <2 x float> @test_minimum_const_inf_nnan_comm_vec(<2 x float> %x) {
212 ; CHECK-NEXT: ret <2 x float> [[X:%.*]]
214 …%r = call nnan <2 x float> @llvm.minimum.v2f32(<2 x float> <float 0x7ff0000000000000, float 0x7ff0…
215 ret <2 x float> %r
218 define float @test_minnum_const_neg_inf_nnan(float %x) {
220 ; CHECK-NEXT: ret float 0xFFF0000000000000
222 %r = call nnan float @llvm.minnum.f32(float %x, float 0xfff0000000000000)
223 ret float %r
226 define float @test_maxnum_const_neg_inf_nnan(float %x) {
228 ; CHECK-NEXT: ret float [[X:%.*]]
230 %r = call nnan float @llvm.maxnum.f32(float %x, float 0xfff0000000000000)
231 ret float %r
234 define float @test_maximum_const_neg_inf_nnan(float %x) {
236 ; CHECK-NEXT: ret float [[X:%.*]]
238 %r = call nnan float @llvm.maximum.f32(float %x, float 0xfff0000000000000)
239 ret float %r
242 define float @test_minimum_const_neg_inf_nnan(float %x) {
244 ; CHECK-NEXT: ret float 0xFFF0000000000000
246 %r = call nnan float @llvm.minimum.f32(float %x, float 0xfff0000000000000)
247 ret float %r
250 define float @test_minnum_const_max(float %x) {
252 ; CHECK-NEXT: [[R:%.*]] = call float @llvm.minnum.f32(float [[X:%.*]], float 0x47EFFFFFE0000000)
253 ; CHECK-NEXT: ret float [[R]]
255 %r = call float @llvm.minnum.f32(float %x, float 0x47efffffe0000000)
256 ret float %r
259 define float @test_maxnum_const_max(float %x) {
261 ; CHECK-NEXT: [[R:%.*]] = call float @llvm.maxnum.f32(float [[X:%.*]], float 0x47EFFFFFE0000000)
262 ; CHECK-NEXT: ret float [[R]]
264 %r = call float @llvm.maxnum.f32(float %x, float 0x47efffffe0000000)
265 ret float %r
268 define float @test_maximum_const_max(float %x) {
270 ; CHECK-NEXT: [[R:%.*]] = call float @llvm.maximum.f32(float [[X:%.*]], float 0x47EFFFFFE0000000)
271 ; CHECK-NEXT: ret float [[R]]
273 %r = call float @llvm.maximum.f32(float %x, float 0x47efffffe0000000)
274 ret float %r
277 define float @test_minimum_const_max(float %x) {
279 ; CHECK-NEXT: [[R:%.*]] = call float @llvm.minimum.f32(float [[X:%.*]], float 0x47EFFFFFE0000000)
280 ; CHECK-NEXT: ret float [[R]]
282 %r = call float @llvm.minimum.f32(float %x, float 0x47efffffe0000000)
283 ret float %r
286 define float @test_minnum_const_neg_max(float %x) {
288 ; CHECK-NEXT: [[R:%.*]] = call float @llvm.minnum.f32(float [[X:%.*]], float 0xC7EFFFFFE0000000)
289 ; CHECK-NEXT: ret float [[R]]
291 %r = call float @llvm.minnum.f32(float %x, float 0xc7efffffe0000000)
292 ret float %r
295 define float @test_maxnum_const_neg_max(float %x) {
297 ; CHECK-NEXT: [[R:%.*]] = call float @llvm.maxnum.f32(float [[X:%.*]], float 0xC7EFFFFFE0000000)
298 ; CHECK-NEXT: ret float [[R]]
300 %r = call float @llvm.maxnum.f32(float %x, float 0xc7efffffe0000000)
301 ret float %r
304 define float @test_maximum_const_neg_max(float %x) {
306 ; CHECK-NEXT: [[R:%.*]] = call float @llvm.maximum.f32(float [[X:%.*]], float 0xC7EFFFFFE0000000)
307 ; CHECK-NEXT: ret float [[R]]
309 %r = call float @llvm.maximum.f32(float %x, float 0xc7efffffe0000000)
310 ret float %r
313 define float @test_minimum_const_neg_max(float %x) {
315 ; CHECK-NEXT: [[R:%.*]] = call float @llvm.minimum.f32(float [[X:%.*]], float 0xC7EFFFFFE0000000)
316 ; CHECK-NEXT: ret float [[R]]
318 %r = call float @llvm.minimum.f32(float %x, float 0xc7efffffe0000000)
319 ret float %r
322 define float @test_minnum_const_max_ninf(float %x) {
324 ; CHECK-NEXT: [[R:%.*]] = call ninf float @llvm.minnum.f32(float [[X:%.*]], float 0x47EFFFFFE000…
325 ; CHECK-NEXT: ret float [[R]]
327 %r = call ninf float @llvm.minnum.f32(float %x, float 0x47efffffe0000000)
328 ret float %r
331 define float @test_maxnum_const_max_ninf(float %x) {
333 ; CHECK-NEXT: ret float 0x47EFFFFFE0000000
335 %r = call ninf float @llvm.maxnum.f32(float %x, float 0x47efffffe0000000)
336 ret float %r
339 define float @test_maximum_const_max_ninf(float %x) {
341 ; CHECK-NEXT: [[R:%.*]] = call ninf float @llvm.maximum.f32(float [[X:%.*]], float 0x47EFFFFFE00…
342 ; CHECK-NEXT: ret float [[R]]
344 %r = call ninf float @llvm.maximum.f32(float %x, float 0x47efffffe0000000)
345 ret float %r
348 define float @test_minimum_const_max_ninf(float %x) {
350 ; CHECK-NEXT: ret float [[X:%.*]]
352 %r = call ninf float @llvm.minimum.f32(float %x, float 0x47efffffe0000000)
353 ret float %r
356 define float @test_minnum_const_neg_max_ninf(float %x) {
358 ; CHECK-NEXT: ret float 0xC7EFFFFFE0000000
360 %r = call ninf float @llvm.minnum.f32(float %x, float 0xc7efffffe0000000)
361 ret float %r
364 define float @test_maxnum_const_neg_max_ninf(float %x) {
366 ; CHECK-NEXT: [[R:%.*]] = call ninf float @llvm.maxnum.f32(float [[X:%.*]], float 0xC7EFFFFFE000…
367 ; CHECK-NEXT: ret float [[R]]
369 %r = call ninf float @llvm.maxnum.f32(float %x, float 0xc7efffffe0000000)
370 ret float %r
373 define float @test_maximum_const_neg_max_ninf(float %x) {
375 ; CHECK-NEXT: ret float [[X:%.*]]
377 %r = call ninf float @llvm.maximum.f32(float %x, float 0xc7efffffe0000000)
378 ret float %r
381 define float @test_minimum_const_neg_max_ninf(float %x) {
383 ; CHECK-NEXT: [[R:%.*]] = call ninf float @llvm.minimum.f32(float [[X:%.*]], float 0xC7EFFFFFE00…
384 ; CHECK-NEXT: ret float [[R]]
386 %r = call ninf float @llvm.minimum.f32(float %x, float 0xc7efffffe0000000)
387 ret float %r
390 define float @test_minnum_const_max_nnan_ninf(float %x) {
392 ; CHECK-NEXT: ret float [[X:%.*]]
394 %r = call nnan ninf float @llvm.minnum.f32(float %x, float 0x47efffffe0000000)
395 ret float %r
398 define float @test_maxnum_const_max_nnan_ninf(float %x) {
400 ; CHECK-NEXT: ret float 0x47EFFFFFE0000000
402 %r = call nnan ninf float @llvm.maxnum.f32(float %x, float 0x47efffffe0000000)
403 ret float %r
406 define float @test_maximum_const_max_nnan_ninf(float %x) {
408 ; CHECK-NEXT: ret float 0x47EFFFFFE0000000
410 %r = call nnan ninf float @llvm.maximum.f32(float %x, float 0x47efffffe0000000)
411 ret float %r
414 define float @test_minimum_const_max_nnan_ninf(float %x) {
416 ; CHECK-NEXT: ret float [[X:%.*]]
418 %r = call nnan ninf float @llvm.minimum.f32(float %x, float 0x47efffffe0000000)
419 ret float %r
422 define float @test_minnum_const_neg_max_nnan_ninf(float %x) {
424 ; CHECK-NEXT: ret float 0xC7EFFFFFE0000000
426 %r = call nnan ninf float @llvm.minnum.f32(float %x, float 0xc7efffffe0000000)
427 ret float %r
430 define float @test_maxnum_const_neg_max_nnan_ninf(float %x) {
432 ; CHECK-NEXT: ret float [[X:%.*]]
434 %r = call nnan ninf float @llvm.maxnum.f32(float %x, float 0xc7efffffe0000000)
435 ret float %r
438 define float @test_maximum_const_neg_max_nnan_ninf(float %x) {
440 ; CHECK-NEXT: ret float [[X:%.*]]
442 %r = call nnan ninf float @llvm.maximum.f32(float %x, float 0xc7efffffe0000000)
443 ret float %r
446 define float @test_minimum_const_neg_max_nnan_ninf(float %x) {
448 ; CHECK-NEXT: ret float 0xC7EFFFFFE0000000
450 %r = call nnan ninf float @llvm.minimum.f32(float %x, float 0xc7efffffe0000000)
451 ret float %r
521 define float @maxnum_undef_op1(float %x) {
523 ; CHECK-NEXT: ret float [[X:%.*]]
525 %val = call float @llvm.maxnum.f32(float %x, float undef)
526 ret float %val
529 define float @maxnum_poison_op1(float %x) {
531 ; CHECK-NEXT: ret float [[X:%.*]]
533 %val = call float @llvm.maxnum.f32(float %x, float poison)
534 ret float %val
537 define float @maxnum_undef_op0(float %x) {
539 ; CHECK-NEXT: ret float [[X:%.*]]
541 %val = call float @llvm.maxnum.f32(float undef, float %x)
542 ret float %val
545 define float @maxnum_poison_op0(float %x) {
547 ; CHECK-NEXT: ret float [[X:%.*]]
549 %val = call float @llvm.maxnum.f32(float poison, float %x)
550 ret float %val
553 define float @minnum_undef_op1(float %x) {
555 ; CHECK-NEXT: ret float [[X:%.*]]
557 %val = call float @llvm.minnum.f32(float %x, float undef)
558 ret float %val
561 define float @minnum_poison_op1(float %x) {
563 ; CHECK-NEXT: ret float [[X:%.*]]
565 %val = call float @llvm.minnum.f32(float %x, float poison)
566 ret float %val
569 define float @minnum_undef_op0(float %x) {
571 ; CHECK-NEXT: ret float [[X:%.*]]
573 %val = call float @llvm.minnum.f32(float undef, float %x)
574 ret float %val
577 define float @minnum_poison_op0(float %x) {
579 ; CHECK-NEXT: ret float [[X:%.*]]
581 %val = call float @llvm.minnum.f32(float poison, float %x)
582 ret float %val
585 define float @minnum_undef_undef(float %x) {
587 ; CHECK-NEXT: ret float undef
589 %val = call float @llvm.minnum.f32(float undef, float undef)
590 ret float %val
593 define float @minnum_poison_undef(float %x) {
595 ; CHECK-NEXT: ret float undef
597 %val = call float @llvm.minnum.f32(float poison, float undef)
598 ret float %val
601 define float @minnum_undef_poison(float %x) {
603 ; CHECK-NEXT: ret float poison
605 %val = call float @llvm.minnum.f32(float undef, float poison)
606 ret float %val
609 define float @maxnum_undef_undef(float %x) {
611 ; CHECK-NEXT: ret float undef
613 %val = call float @llvm.maxnum.f32(float undef, float undef)
614 ret float %val
617 define float @maxnum_poison_undef(float %x) {
619 ; CHECK-NEXT: ret float undef
621 %val = call float @llvm.maxnum.f32(float poison, float undef)
622 ret float %val
625 define float @maxnum_undef_poison(float %x) {
627 ; CHECK-NEXT: ret float poison
629 %val = call float @llvm.maxnum.f32(float undef, float poison)
630 ret float %val
633 define float @minnum_same_args(float %x) {
635 ; CHECK-NEXT: ret float [[X:%.*]]
637 %y = call float @llvm.minnum.f32(float %x, float %x)
638 ret float %y
641 define float @maxnum_same_args(float %x) {
643 ; CHECK-NEXT: ret float [[X:%.*]]
645 %y = call float @llvm.maxnum.f32(float %x, float %x)
646 ret float %y
649 define float @minnum_x_minnum_x_y(float %x, float %y) {
651 ; CHECK-NEXT: [[A:%.*]] = call float @llvm.minnum.f32(float [[X:%.*]], float [[Y:%.*]])
652 ; CHECK-NEXT: ret float [[A]]
654 %a = call float @llvm.minnum.f32(float %x, float %y)
655 %b = call float @llvm.minnum.f32(float %x, float %a)
656 ret float %b
659 define float @minnum_y_minnum_x_y(float %x, float %y) {
661 ; CHECK-NEXT: [[A:%.*]] = call float @llvm.minnum.f32(float [[X:%.*]], float [[Y:%.*]])
662 ; CHECK-NEXT: ret float [[A]]
664 %a = call float @llvm.minnum.f32(float %x, float %y)
665 %b = call float @llvm.minnum.f32(float %y, float %a)
666 ret float %b
669 define float @minnum_x_y_minnum_x(float %x, float %y) {
671 ; CHECK-NEXT: [[A:%.*]] = call float @llvm.minnum.f32(float [[X:%.*]], float [[Y:%.*]])
672 ; CHECK-NEXT: ret float [[A]]
674 %a = call float @llvm.minnum.f32(float %x, float %y)
675 %b = call float @llvm.minnum.f32(float %a, float %x)
676 ret float %b
679 define float @minnum_x_y_minnum_y(float %x, float %y) {
681 ; CHECK-NEXT: [[A:%.*]] = call float @llvm.minnum.f32(float [[X:%.*]], float [[Y:%.*]])
682 ; CHECK-NEXT: ret float [[A]]
684 %a = call float @llvm.minnum.f32(float %x, float %y)
685 %b = call float @llvm.minnum.f32(float %a, float %y)
686 ret float %b
691 define float @minnum_z_minnum_x_y(float %x, float %y, float %z) {
693 ; CHECK-NEXT: [[A:%.*]] = call float @llvm.minnum.f32(float [[X:%.*]], float [[Y:%.*]])
694 ; CHECK-NEXT: [[B:%.*]] = call float @llvm.minnum.f32(float [[Z:%.*]], float [[A]])
695 ; CHECK-NEXT: ret float [[B]]
697 %a = call float @llvm.minnum.f32(float %x, float %y)
698 %b = call float @llvm.minnum.f32(float %z, float %a)
699 ret float %b
704 define float @minnum_x_y_minnum_z(float %x, float %y, float %z) {
706 ; CHECK-NEXT: [[A:%.*]] = call float @llvm.minnum.f32(float [[X:%.*]], float [[Y:%.*]])
707 ; CHECK-NEXT: [[B:%.*]] = call float @llvm.minnum.f32(float [[A]], float [[Z:%.*]])
708 ; CHECK-NEXT: ret float [[B]]
710 %a = call float @llvm.minnum.f32(float %x, float %y)
711 %b = call float @llvm.minnum.f32(float %a, float %z)
712 ret float %b
717 define float @minnum_neginf(float %x) {
719 ; CHECK-NEXT: ret float 0xFFF0000000000000
721 %val = call float @llvm.minnum.f32(float %x, float 0xFFF0000000000000)
722 ret float %val
735 define float @minnum_inf(float %x) {
737 ; CHECK-NEXT: [[VAL:%.*]] = call float @llvm.minnum.f32(float 0x7FF0000000000000, float [[X:%.*]…
738 ; CHECK-NEXT: ret float [[VAL]]
740 %val = call float @llvm.minnum.f32(float 0x7FF0000000000000, float %x)
741 ret float %val
743 define float @maxnum_x_maxnum_x_y(float %x, float %y) {
745 ; CHECK-NEXT: [[A:%.*]] = call float @llvm.maxnum.f32(float [[X:%.*]], float [[Y:%.*]])
746 ; CHECK-NEXT: ret float [[A]]
748 %a = call float @llvm.maxnum.f32(float %x, float %y)
749 %b = call float @llvm.maxnum.f32(float %x, float %a)
750 ret float %b
753 define float @maxnum_y_maxnum_x_y(float %x, float %y) {
755 ; CHECK-NEXT: [[A:%.*]] = call float @llvm.maxnum.f32(float [[X:%.*]], float [[Y:%.*]])
756 ; CHECK-NEXT: ret float [[A]]
758 %a = call float @llvm.maxnum.f32(float %x, float %y)
759 %b = call float @llvm.maxnum.f32(float %y, float %a)
760 ret float %b
763 define float @maxnum_x_y_maxnum_x(float %x, float %y) {
765 ; CHECK-NEXT: [[A:%.*]] = call float @llvm.maxnum.f32(float [[X:%.*]], float [[Y:%.*]])
766 ; CHECK-NEXT: ret float [[A]]
768 %a = call float @llvm.maxnum.f32(float %x, float %y)
769 %b = call float @llvm.maxnum.f32(float %a, float %x)
770 ret float %b
773 define float @maxnum_x_y_maxnum_y(float %x, float %y) {
775 ; CHECK-NEXT: [[A:%.*]] = call float @llvm.maxnum.f32(float [[X:%.*]], float [[Y:%.*]])
776 ; CHECK-NEXT: ret float [[A]]
778 %a = call float @llvm.maxnum.f32(float %x, float %y)
779 %b = call float @llvm.maxnum.f32(float %a, float %y)
780 ret float %b
785 define float @maxnum_z_maxnum_x_y(float %x, float %y, float %z) {
787 ; CHECK-NEXT: [[A:%.*]] = call float @llvm.maxnum.f32(float [[X:%.*]], float [[Y:%.*]])
788 ; CHECK-NEXT: [[B:%.*]] = call float @llvm.maxnum.f32(float [[Z:%.*]], float [[A]])
789 ; CHECK-NEXT: ret float [[B]]
791 %a = call float @llvm.maxnum.f32(float %x, float %y)
792 %b = call float @llvm.maxnum.f32(float %z, float %a)
793 ret float %b
798 define float @maxnum_x_y_maxnum_z(float %x, float %y, float %z) {
800 ; CHECK-NEXT: [[A:%.*]] = call float @llvm.maxnum.f32(float [[X:%.*]], float [[Y:%.*]])
801 ; CHECK-NEXT: [[B:%.*]] = call float @llvm.maxnum.f32(float [[A]], float [[Z:%.*]])
802 ; CHECK-NEXT: ret float [[B]]
804 %a = call float @llvm.maxnum.f32(float %x, float %y)
805 %b = call float @llvm.maxnum.f32(float %a, float %z)
806 ret float %b
819 define float @maxnum_inf_commute(float %x) {
821 ; CHECK-NEXT: ret float 0x7FF0000000000000
823 %val = call float @llvm.maxnum.f32(float 0x7FF0000000000000, float %x)
824 ret float %val
829 define float @maxnum_neginf(float %x) {
831 ; CHECK-NEXT: [[VAL:%.*]] = call float @llvm.maxnum.f32(float 0xFFF0000000000000, float [[X:%.*]…
832 ; CHECK-NEXT: ret float [[VAL]]
834 %val = call float @llvm.maxnum.f32(float 0xFFF0000000000000, float %x)
835 ret float %val
921 define float @maximum_undef_op1(float %x) {
923 ; CHECK-NEXT: ret float [[X:%.*]]
925 %val = call float @llvm.maximum.f32(float %x, float undef)
926 ret float %val
929 define float @maximum_poison_op1(float %x) {
931 ; CHECK-NEXT: ret float [[X:%.*]]
933 %val = call float @llvm.maximum.f32(float %x, float poison)
934 ret float %val
937 define float @maximum_undef_op0(float %x) {
939 ; CHECK-NEXT: ret float [[X:%.*]]
941 %val = call float @llvm.maximum.f32(float undef, float %x)
942 ret float %val
945 define float @maximum_poison_op0(float %x) {
947 ; CHECK-NEXT: ret float [[X:%.*]]
949 %val = call float @llvm.maximum.f32(float poison, float %x)
950 ret float %val
953 define float @minimum_undef_op1(float %x) {
955 ; CHECK-NEXT: ret float [[X:%.*]]
957 %val = call float @llvm.minimum.f32(float %x, float undef)
958 ret float %val
961 define float @minimum_poison_op1(float %x) {
963 ; CHECK-NEXT: ret float [[X:%.*]]
965 %val = call float @llvm.minimum.f32(float %x, float poison)
966 ret float %val
969 define float @minimum_undef_op0(float %x) {
971 ; CHECK-NEXT: ret float [[X:%.*]]
973 %val = call float @llvm.minimum.f32(float undef, float %x)
974 ret float %val
977 define float @minimum_poison_op0(float %x) {
979 ; CHECK-NEXT: ret float [[X:%.*]]
981 %val = call float @llvm.minimum.f32(float poison, float %x)
982 ret float %val
985 define float @minimum_undef_undef(float %x) {
987 ; CHECK-NEXT: ret float undef
989 %val = call float @llvm.minimum.f32(float undef, float undef)
990 ret float %val
993 define float @maximum_undef_undef(float %x) {
995 ; CHECK-NEXT: ret float undef
997 %val = call float @llvm.maximum.f32(float undef, float undef)
998 ret float %val
1001 define float @minimum_same_args(float %x) {
1003 ; CHECK-NEXT: ret float [[X:%.*]]
1005 %y = call float @llvm.minimum.f32(float %x, float %x)
1006 ret float %y
1009 define float @maximum_same_args(float %x) {
1011 ; CHECK-NEXT: ret float [[X:%.*]]
1013 %y = call float @llvm.maximum.f32(float %x, float %x)
1014 ret float %y
1017 define float @minimum_x_minimum_x_y(float %x, float %y) {
1019 ; CHECK-NEXT: [[A:%.*]] = call float @llvm.minimum.f32(float [[X:%.*]], float [[Y:%.*]])
1020 ; CHECK-NEXT: ret float [[A]]
1022 %a = call float @llvm.minimum.f32(float %x, float %y)
1023 %b = call float @llvm.minimum.f32(float %x, float %a)
1024 ret float %b
1027 define float @minimum_y_minimum_x_y(float %x, float %y) {
1029 ; CHECK-NEXT: [[A:%.*]] = call float @llvm.minimum.f32(float [[X:%.*]], float [[Y:%.*]])
1030 ; CHECK-NEXT: ret float [[A]]
1032 %a = call float @llvm.minimum.f32(float %x, float %y)
1033 %b = call float @llvm.minimum.f32(float %y, float %a)
1034 ret float %b
1037 define float @minimum_x_y_minimum_x(float %x, float %y) {
1039 ; CHECK-NEXT: [[A:%.*]] = call float @llvm.minimum.f32(float [[X:%.*]], float [[Y:%.*]])
1040 ; CHECK-NEXT: ret float [[A]]
1042 %a = call float @llvm.minimum.f32(float %x, float %y)
1043 %b = call float @llvm.minimum.f32(float %a, float %x)
1044 ret float %b
1047 define float @minimum_x_y_minimum_y(float %x, float %y) {
1049 ; CHECK-NEXT: [[A:%.*]] = call float @llvm.minimum.f32(float [[X:%.*]], float [[Y:%.*]])
1050 ; CHECK-NEXT: ret float [[A]]
1052 %a = call float @llvm.minimum.f32(float %x, float %y)
1053 %b = call float @llvm.minimum.f32(float %a, float %y)
1054 ret float %b
1059 define float @minimum_z_minimum_x_y(float %x, float %y, float %z) {
1061 ; CHECK-NEXT: [[A:%.*]] = call float @llvm.minimum.f32(float [[X:%.*]], float [[Y:%.*]])
1062 ; CHECK-NEXT: [[B:%.*]] = call float @llvm.minimum.f32(float [[Z:%.*]], float [[A]])
1063 ; CHECK-NEXT: ret float [[B]]
1065 %a = call float @llvm.minimum.f32(float %x, float %y)
1066 %b = call float @llvm.minimum.f32(float %z, float %a)
1067 ret float %b
1072 define float @minimum_x_y_minimum_z(float %x, float %y, float %z) {
1074 ; CHECK-NEXT: [[A:%.*]] = call float @llvm.minimum.f32(float [[X:%.*]], float [[Y:%.*]])
1075 ; CHECK-NEXT: [[B:%.*]] = call float @llvm.minimum.f32(float [[A]], float [[Z:%.*]])
1076 ; CHECK-NEXT: ret float [[B]]
1078 %a = call float @llvm.minimum.f32(float %x, float %y)
1079 %b = call float @llvm.minimum.f32(float %a, float %z)
1080 ret float %b
1083 define float @maximum_x_maximum_x_y(float %x, float %y) {
1085 ; CHECK-NEXT: [[A:%.*]] = call float @llvm.maximum.f32(float [[X:%.*]], float [[Y:%.*]])
1086 ; CHECK-NEXT: ret float [[A]]
1088 %a = call float @llvm.maximum.f32(float %x, float %y)
1089 %b = call float @llvm.maximum.f32(float %x, float %a)
1090 ret float %b
1093 define float @maximum_y_maximum_x_y(float %x, float %y) {
1095 ; CHECK-NEXT: [[A:%.*]] = call float @llvm.maximum.f32(float [[X:%.*]], float [[Y:%.*]])
1096 ; CHECK-NEXT: ret float [[A]]
1098 %a = call float @llvm.maximum.f32(float %x, float %y)
1099 %b = call float @llvm.maximum.f32(float %y, float %a)
1100 ret float %b
1103 define float @maximum_x_y_maximum_x(float %x, float %y) {
1105 ; CHECK-NEXT: [[A:%.*]] = call float @llvm.maximum.f32(float [[X:%.*]], float [[Y:%.*]])
1106 ; CHECK-NEXT: ret float [[A]]
1108 %a = call float @llvm.maximum.f32(float %x, float %y)
1109 %b = call float @llvm.maximum.f32(float %a, float %x)
1110 ret float %b
1113 define float @maximum_x_y_maximum_y(float %x, float %y) {
1115 ; CHECK-NEXT: [[A:%.*]] = call float @llvm.maximum.f32(float [[X:%.*]], float [[Y:%.*]])
1116 ; CHECK-NEXT: ret float [[A]]
1118 %a = call float @llvm.maximum.f32(float %x, float %y)
1119 %b = call float @llvm.maximum.f32(float %a, float %y)
1120 ret float %b
1125 define float @maximum_z_maximum_x_y(float %x, float %y, float %z) {
1127 ; CHECK-NEXT: [[A:%.*]] = call float @llvm.maximum.f32(float [[X:%.*]], float [[Y:%.*]])
1128 ; CHECK-NEXT: [[B:%.*]] = call float @llvm.maximum.f32(float [[Z:%.*]], float [[A]])
1129 ; CHECK-NEXT: ret float [[B]]
1131 %a = call float @llvm.maximum.f32(float %x, float %y)
1132 %b = call float @llvm.maximum.f32(float %z, float %a)
1133 ret float %b
1138 define float @maximum_x_y_maximum_z(float %x, float %y, float %z) {
1140 ; CHECK-NEXT: [[A:%.*]] = call float @llvm.maximum.f32(float [[X:%.*]], float [[Y:%.*]])
1141 ; CHECK-NEXT: [[B:%.*]] = call float @llvm.maximum.f32(float [[A]], float [[Z:%.*]])
1142 ; CHECK-NEXT: ret float [[B]]
1144 %a = call float @llvm.maximum.f32(float %x, float %y)
1145 %b = call float @llvm.maximum.f32(float %a, float %z)
1146 ret float %b
1151 define float @minimum_neginf(float %x) {
1153 ; CHECK-NEXT: [[VAL:%.*]] = call float @llvm.minimum.f32(float [[X:%.*]], float 0xFFF00000000000…
1154 ; CHECK-NEXT: ret float [[VAL]]
1156 %val = call float @llvm.minimum.f32(float %x, float 0xFFF0000000000000)
1157 ret float %val
1173 define float @minimum_inf(float %x) {
1175 ; CHECK-NEXT: ret float [[X:%.*]]
1177 %val = call float @llvm.minimum.f32(float 0x7FF0000000000000, float %x)
1178 ret float %val
1194 define float @maximum_inf_commute(float %x) {
1196 ; CHECK-NEXT: [[VAL:%.*]] = call float @llvm.maximum.f32(float 0x7FF0000000000000, float [[X:%.*…
1197 ; CHECK-NEXT: ret float [[VAL]]
1199 %val = call float @llvm.maximum.f32(float 0x7FF0000000000000, float %x)
1200 ret float %val