forked from OSchip/llvm-project
137 lines
5.6 KiB
LLVM
137 lines
5.6 KiB
LLVM
; RUN: opt -instcombine -S -o - %s | FileCheck %s
|
|
; Tests that constant folding of min and max operations works as expected.
|
|
|
|
declare float @llvm.minnum.f32(float, float)
|
|
declare float @llvm.maxnum.f32(float, float)
|
|
declare <4 x float> @llvm.minnum.v4f32(<4 x float>, <4 x float>)
|
|
declare <4 x float> @llvm.maxnum.v4f32(<4 x float>, <4 x float>)
|
|
|
|
declare float @llvm.minimum.f32(float, float)
|
|
declare float @llvm.maximum.f32(float, float)
|
|
declare <4 x float> @llvm.minimum.v4f32(<4 x float>, <4 x float>)
|
|
declare <4 x float> @llvm.maximum.v4f32(<4 x float>, <4 x float>)
|
|
|
|
; CHECK: define float @minnum_float() {
|
|
define float @minnum_float() {
|
|
; CHECK-NEXT: ret float 5.000000e+00
|
|
%1 = call float @llvm.minnum.f32(float 5.0, float 42.0)
|
|
ret float %1
|
|
}
|
|
|
|
; Check that minnum constant folds to propagate non-NaN or smaller argument
|
|
; CHECK: define <4 x float> @minnum_float_vec() {
|
|
define <4 x float> @minnum_float_vec() {
|
|
; CHECK-NEXT: ret <4 x float> <float 0x7FF8000000000000, float 5.000000e+00,
|
|
; CHECK-SAME: float 4.200000e+01, float 5.000000e+00>
|
|
%1 = call <4 x float> @llvm.minnum.v4f32(
|
|
<4 x float> <float 0x7FF8000000000000, float 0x7FF8000000000000, float 42., float 42.>,
|
|
<4 x float> <float 0x7FF8000000000000, float 5., float 0x7FF8000000000000, float 5.>
|
|
)
|
|
ret <4 x float> %1
|
|
}
|
|
|
|
; Check that minnum constant folds to propagate one of its argument zeros
|
|
; CHECK: define <4 x float> @minnum_float_zeros_vec() {
|
|
define <4 x float> @minnum_float_zeros_vec() {
|
|
; CHECK-NEXT: ret <4 x float> <float 0.000000e+00, float {{-?}}0.000000e+00,
|
|
; CHECK-SAME: float {{-?}}0.000000e+00, float -0.000000e+00>
|
|
%1 = call <4 x float> @llvm.minnum.v4f32(
|
|
<4 x float> <float 0.0, float -0.0, float 0.0, float -0.0>,
|
|
<4 x float> <float 0.0, float 0.0, float -0.0, float -0.0>
|
|
)
|
|
ret <4 x float> %1
|
|
}
|
|
|
|
; CHECK: define float @maxnum_float() {
|
|
define float @maxnum_float() {
|
|
; CHECK-NEXT: ret float 4.200000e+01
|
|
%1 = call float @llvm.maxnum.f32(float 5.0, float 42.0)
|
|
ret float %1
|
|
}
|
|
|
|
; Check that maxnum constant folds to propagate non-NaN or greater argument
|
|
; CHECK: define <4 x float> @maxnum_float_vec() {
|
|
define <4 x float> @maxnum_float_vec() {
|
|
; CHECK-NEXT: ret <4 x float> <float 0x7FF8000000000000, float 5.000000e+00,
|
|
; CHECK-SAME: float 4.200000e+01, float 4.200000e+01>
|
|
%1 = call <4 x float> @llvm.maxnum.v4f32(
|
|
<4 x float> <float 0x7FF8000000000000, float 0x7FF8000000000000, float 42., float 42.>,
|
|
<4 x float> <float 0x7FF8000000000000, float 5., float 0x7FF8000000000000, float 5.>
|
|
)
|
|
ret <4 x float> %1
|
|
}
|
|
|
|
; Check that maxnum constant folds to propagate one of its argument zeros
|
|
; CHECK: define <4 x float> @maxnum_float_zeros_vec() {
|
|
define <4 x float> @maxnum_float_zeros_vec() {
|
|
; CHECK-NEXT: ret <4 x float> <float 0.000000e+00, float {{-?}}0.000000e+00,
|
|
; CHECK-SAME: float {{-?}}0.000000e+00, float -0.000000e+00>
|
|
%1 = call <4 x float> @llvm.maxnum.v4f32(
|
|
<4 x float> <float 0.0, float -0.0, float 0.0, float -0.0>,
|
|
<4 x float> <float 0.0, float 0.0, float -0.0, float -0.0>
|
|
)
|
|
ret <4 x float> %1
|
|
}
|
|
|
|
; CHECK: define float @minimum_float() {
|
|
define float @minimum_float() {
|
|
; CHECK-NEXT: ret float 5.000000e+00
|
|
%1 = call float @llvm.minimum.f32(float 5.0, float 42.0)
|
|
ret float %1
|
|
}
|
|
|
|
; Check that minimum propagates its NaN or smaller argument
|
|
; CHECK: define <4 x float> @minimum_float_vec() {
|
|
define <4 x float> @minimum_float_vec() {
|
|
; CHECK-NEXT: ret <4 x float> <float 0x7FF8000000000000, float 0x7FF8000000000000,
|
|
; CHECK-SAME: float 0x7FF8000000000000, float 5.000000e+00>
|
|
%1 = call <4 x float> @llvm.minimum.v4f32(
|
|
<4 x float> <float 0x7FF8000000000000, float 0x7FF8000000000000, float 42., float 42.>,
|
|
<4 x float> <float 0x7FF8000000000000, float 5., float 0x7FF8000000000000, float 5.>
|
|
)
|
|
ret <4 x float> %1
|
|
}
|
|
|
|
; Check that minimum treats -0.0 as smaller than 0.0 while constant folding
|
|
; CHECK: define <4 x float> @minimum_float_zeros_vec() {
|
|
define <4 x float> @minimum_float_zeros_vec() {
|
|
; CHECK-NEXT: ret <4 x float> <float 0.000000e+00, float -0.000000e+00,
|
|
; CHECK-SAME: float -0.000000e+00, float -0.000000e+00>
|
|
%1 = call <4 x float> @llvm.minimum.v4f32(
|
|
<4 x float> <float 0.0, float -0.0, float 0.0, float -0.0>,
|
|
<4 x float> <float 0.0, float 0.0, float -0.0, float -0.0>
|
|
)
|
|
ret <4 x float> %1
|
|
}
|
|
|
|
; CHECK: define float @maximum_float() {
|
|
define float @maximum_float() {
|
|
; CHECK-NEXT: ret float 4.200000e+01
|
|
%1 = call float @llvm.maximum.f32(float 5.0, float 42.0)
|
|
ret float %1
|
|
}
|
|
|
|
; Check that maximum propagates its NaN or greater argument
|
|
; CHECK: define <4 x float> @maximum_float_vec() {
|
|
define <4 x float> @maximum_float_vec() {
|
|
; CHECK-NEXT: ret <4 x float> <float 0x7FF8000000000000, float 0x7FF8000000000000,
|
|
; CHECK-SAME: float 0x7FF8000000000000, float 4.200000e+01>
|
|
%1 = call <4 x float> @llvm.maximum.v4f32(
|
|
<4 x float> <float 0x7FF8000000000000, float 0x7FF8000000000000, float 42., float 42.>,
|
|
<4 x float> <float 0x7FF8000000000000, float 5., float 0x7FF8000000000000, float 5.>
|
|
)
|
|
ret <4 x float> %1
|
|
}
|
|
|
|
; Check that maximum treats -0.0 as smaller than 0.0 while constant folding
|
|
; CHECK: define <4 x float> @maximum_float_zeros_vec() {
|
|
define <4 x float> @maximum_float_zeros_vec() {
|
|
; CHECK-NEXT: ret <4 x float> <float 0.000000e+00, float 0.000000e+00,
|
|
; CHECK-SAME: float 0.000000e+00, float -0.000000e+00>
|
|
%1 = call <4 x float> @llvm.maximum.v4f32(
|
|
<4 x float> <float 0.0, float -0.0, float 0.0, float -0.0>,
|
|
<4 x float> <float 0.0, float 0.0, float -0.0, float -0.0>
|
|
)
|
|
ret <4 x float> %1
|
|
}
|