This is an archive of the discontinued LLVM Phabricator instance.

Differential D53875

[InstCombine] Add preliminary tests for nested min/max combines. NFC
ClosedPublic

Authored by volkan on Oct 30 2018, 10:39 AM.

Details

Reviewers
spatel
Commits
rG5a672b22e8a4: [InstCombine] Add preliminary tests for nested min/max combines. NFC
rL345616: [InstCombine] Add preliminary tests for nested min/max combines. NFC
Summary

As requested in D53774.

Diff Detail

Repository
rL LLVM

Event Timeline

volkan created this revision.Oct 30 2018, 10:39 AM
spatel accepted this revision.Oct 30 2018, 10:46 AM

Thanks - LGTM. Feel free to add baseline tests as you see fit without pre-commit review.

This revision is now accepted and ready to land.Oct 30 2018, 10:46 AM
Closed by commit rL345616: [InstCombine] Add preliminary tests for nested min/max combines. NFC (authored by volkan). · Explain WhyOct 30 2018, 10:53 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
llvm/
trunk/
test/
Transforms/
InstCombine/
60 lines
60 lines
62 lines
62 lines

Diff 171731

llvm/trunk/test/Transforms/InstCombine/maximum.ll

Show First 20 Lines • Show All 139 Lines • ▼ Show 20 Lines
define float @maximum_f32_val_nan(float %x) { define float @maximum_f32_val_nan(float %x) {
; CHECK-LABEL: @maximum_f32_val_nan( ; CHECK-LABEL: @maximum_f32_val_nan(
; CHECK-NEXT: ret float 0x7FF8000000000000 ; CHECK-NEXT: ret float 0x7FF8000000000000
; ;
%y = call float @llvm.maximum.f32(float %x, float 0x7FF8000000000000) %y = call float @llvm.maximum.f32(float %x, float 0x7FF8000000000000)
ret float %y ret float %y
} }
define float @maximum_f32_1_maximum_val_p0(float %x) {
; CHECK-LABEL: @maximum_f32_1_maximum_val_p0(
; CHECK-NEXT: [[Y:%.*]] = call float @llvm.maximum.f32(float %x, float 0.000000e+00)
; CHECK-NEXT: [[RES:%.*]] = call float @llvm.maximum.f32(float [[Y]], float 1.000000e+00)
; CHECK-NEXT: ret float [[RES]]
%y = call float @llvm.maximum.f32(float %x, float 0.0)
%z = call float @llvm.maximum.f32(float %y, float 1.0)
ret float %z
}
define float @maximum_f32_1_maximum_p0_val_fast(float %x) {
; CHECK-LABEL: @maximum_f32_1_maximum_p0_val_fast(
; CHECK-NEXT: [[Y:%.*]] = call float @llvm.maximum.f32(float %x, float 0.000000e+00)
; CHECK-NEXT: [[RES:%.*]] = call fast float @llvm.maximum.f32(float [[Y]], float 1.000000e+00)
; CHECK-NEXT: ret float [[RES]]
%y = call float @llvm.maximum.f32(float 0.0, float %x)
%z = call fast float @llvm.maximum.f32(float %y, float 1.0)
ret float %z
}
define float @maximum_f32_1_maximum_p0_val_nnan_ninf(float %x) {
; CHECK-LABEL: @maximum_f32_1_maximum_p0_val_nnan_ninf(
; CHECK-NEXT: [[Y:%.*]] = call float @llvm.maximum.f32(float %x, float 0.000000e+00)
; CHECK-NEXT: [[RES:%.*]] = call nnan ninf float @llvm.maximum.f32(float [[Y]], float 1.000000e+00)
; CHECK-NEXT: ret float [[RES]]
%y = call float @llvm.maximum.f32(float 0.0, float %x)
%z = call nnan ninf float @llvm.maximum.f32(float %y, float 1.0)
ret float %z
}
define float @maximum_f32_p0_maximum_val_n0(float %x) {
; CHECK-LABEL: @maximum_f32_p0_maximum_val_n0(
; CHECK-NEXT: [[Y:%.*]] = call float @llvm.maximum.f32(float %x, float -0.000000e+00)
; CHECK-NEXT: [[RES:%.*]] = call float @llvm.maximum.f32(float [[Y]], float 0.000000e+00)
; CHECK-NEXT: ret float [[RES]]
%y = call float @llvm.maximum.f32(float %x, float -0.0)
%z = call float @llvm.maximum.f32(float %y, float 0.0)
ret float %z
}
define float @maximum_f32_1_maximum_p0_val(float %x) {
; CHECK-LABEL: @maximum_f32_1_maximum_p0_val(
; CHECK-NEXT: [[Y:%.*]] = call float @llvm.maximum.f32(float %x, float 0.000000e+00)
; CHECK-NEXT: [[RES:%.*]] = call float @llvm.maximum.f32(float [[Y]], float 1.000000e+00)
; CHECK-NEXT: ret float [[RES]]
%y = call float @llvm.maximum.f32(float 0.0, float %x)
%z = call float @llvm.maximum.f32(float %y, float 1.0)
ret float %z
}
define <2 x float> @maximum_f32_1_maximum_val_p0_val_v2f32(<2 x float> %x) {
; CHECK-LABEL: @maximum_f32_1_maximum_val_p0_val_v2f32(
; CHECK-NEXT: [[Y:%.*]] = call <2 x float> @llvm.maximum.v2f32(<2 x float> %x, <2 x float> zeroinitializer)
; CHECK-NEXT: [[RES:%.*]] = call <2 x float> @llvm.maximum.v2f32(<2 x float> [[Y]], <2 x float> <float 1.000000e+00, float 1.000000e+00>)
; CHECK-NEXT: ret <2 x float> [[RES]]
%y = call <2 x float> @llvm.maximum.v2f32(<2 x float> %x, <2 x float> zeroinitializer)
%z = call <2 x float> @llvm.maximum.v2f32(<2 x float> %y, <2 x float><float 1.0, float 1.0>)
ret <2 x float> %z
}
define float @maximum4(float %x, float %y, float %z, float %w) { define float @maximum4(float %x, float %y, float %z, float %w) {
; CHECK-LABEL: @maximum4( ; CHECK-LABEL: @maximum4(
; CHECK-NEXT: [[A:%.*]] = call float @llvm.maximum.f32(float [[X:%.*]], float [[Y:%.*]]) ; CHECK-NEXT: [[A:%.*]] = call float @llvm.maximum.f32(float [[X:%.*]], float [[Y:%.*]])
; CHECK-NEXT: [[B:%.*]] = call float @llvm.maximum.f32(float [[Z:%.*]], float [[W:%.*]]) ; CHECK-NEXT: [[B:%.*]] = call float @llvm.maximum.f32(float [[Z:%.*]], float [[W:%.*]])
; CHECK-NEXT: [[C:%.*]] = call float @llvm.maximum.f32(float [[A]], float [[B]]) ; CHECK-NEXT: [[C:%.*]] = call float @llvm.maximum.f32(float [[A]], float [[B]])
; CHECK-NEXT: ret float [[C]] ; CHECK-NEXT: ret float [[C]]
; ;
%a = call float @llvm.maximum.f32(float %x, float %y) %a = call float @llvm.maximum.f32(float %x, float %y)
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/InstCombine/maxnum.ll

Show First 20 Lines • Show All 139 Lines • ▼ Show 20 Lines
define float @maxnum_f32_val_nan(float %x) { define float @maxnum_f32_val_nan(float %x) {
; CHECK-LABEL: @maxnum_f32_val_nan( ; CHECK-LABEL: @maxnum_f32_val_nan(
; CHECK-NEXT: ret float [[X:%.*]] ; CHECK-NEXT: ret float [[X:%.*]]
; ;
%y = call float @llvm.maxnum.f32(float %x, float 0x7FF8000000000000) %y = call float @llvm.maxnum.f32(float %x, float 0x7FF8000000000000)
ret float %y ret float %y
} }
define float @maxnum_f32_1_maxnum_val_p0(float %x) {
; CHECK-LABEL: @maxnum_f32_1_maxnum_val_p0(
; CHECK-NEXT: [[Y:%.*]] = call float @llvm.maxnum.f32(float %x, float 0.000000e+00)
; CHECK-NEXT: [[RES:%.*]] = call float @llvm.maxnum.f32(float [[Y]], float 1.000000e+00)
; CHECK-NEXT: ret float [[RES]]
%y = call float @llvm.maxnum.f32(float %x, float 0.0)
%z = call float @llvm.maxnum.f32(float %y, float 1.0)
ret float %z
}
define float @maxnum_f32_1_maxnum_p0_val_fast(float %x) {
; CHECK-LABEL: @maxnum_f32_1_maxnum_p0_val_fast(
; CHECK-NEXT: [[Y:%.*]] = call float @llvm.maxnum.f32(float %x, float 0.000000e+00)
; CHECK-NEXT: [[RES:%.*]] = call fast float @llvm.maxnum.f32(float [[Y]], float 1.000000e+00)
; CHECK-NEXT: ret float [[RES]]
%y = call float @llvm.maxnum.f32(float 0.0, float %x)
%z = call fast float @llvm.maxnum.f32(float %y, float 1.0)
ret float %z
}
define float @maxnum_f32_1_maxnum_p0_val_nnan_ninf(float %x) {
; CHECK-LABEL: @maxnum_f32_1_maxnum_p0_val_nnan_ninf(
; CHECK-NEXT: [[Y:%.*]] = call float @llvm.maxnum.f32(float %x, float 0.000000e+00)
; CHECK-NEXT: [[RES:%.*]] = call nnan ninf float @llvm.maxnum.f32(float [[Y]], float 1.000000e+00)
; CHECK-NEXT: ret float [[RES]]
%y = call float @llvm.maxnum.f32(float 0.0, float %x)
%z = call nnan ninf float @llvm.maxnum.f32(float %y, float 1.0)
ret float %z
}
define float @maxnum_f32_p0_maxnum_val_n0(float %x) {
; CHECK-LABEL: @maxnum_f32_p0_maxnum_val_n0(
; CHECK-NEXT: [[Y:%.*]] = call float @llvm.maxnum.f32(float %x, float -0.000000e+00)
; CHECK-NEXT: [[RES:%.*]] = call float @llvm.maxnum.f32(float [[Y]], float 0.000000e+00)
; CHECK-NEXT: ret float [[RES]]
%y = call float @llvm.maxnum.f32(float %x, float -0.0)
%z = call float @llvm.maxnum.f32(float %y, float 0.0)
ret float %z
}
define float @maxnum_f32_1_maxnum_p0_val(float %x) {
; CHECK-LABEL: @maxnum_f32_1_maxnum_p0_val(
; CHECK-NEXT: [[Y:%.*]] = call float @llvm.maxnum.f32(float %x, float 0.000000e+00)
; CHECK-NEXT: [[RES:%.*]] = call float @llvm.maxnum.f32(float [[Y]], float 1.000000e+00)
; CHECK-NEXT: ret float [[RES]]
%y = call float @llvm.maxnum.f32(float 0.0, float %x)
%z = call float @llvm.maxnum.f32(float %y, float 1.0)
ret float %z
}
define <2 x float> @maxnum_f32_1_maxnum_val_p0_val_v2f32(<2 x float> %x) {
; CHECK-LABEL: @maxnum_f32_1_maxnum_val_p0_val_v2f32(
; CHECK-NEXT: [[Y:%.*]] = call <2 x float> @llvm.maxnum.v2f32(<2 x float> %x, <2 x float> zeroinitializer)
; CHECK-NEXT: [[RES:%.*]] = call <2 x float> @llvm.maxnum.v2f32(<2 x float> [[Y]], <2 x float> <float 1.000000e+00, float 1.000000e+00>)
; CHECK-NEXT: ret <2 x float> [[RES]]
%y = call <2 x float> @llvm.maxnum.v2f32(<2 x float> %x, <2 x float> zeroinitializer)
%z = call <2 x float> @llvm.maxnum.v2f32(<2 x float> %y, <2 x float><float 1.0, float 1.0>)
ret <2 x float> %z
}
define float @maxnum4(float %x, float %y, float %z, float %w) { define float @maxnum4(float %x, float %y, float %z, float %w) {
; CHECK-LABEL: @maxnum4( ; CHECK-LABEL: @maxnum4(
; CHECK-NEXT: [[A:%.*]] = call float @llvm.maxnum.f32(float [[X:%.*]], float [[Y:%.*]]) ; CHECK-NEXT: [[A:%.*]] = call float @llvm.maxnum.f32(float [[X:%.*]], float [[Y:%.*]])
; CHECK-NEXT: [[B:%.*]] = call float @llvm.maxnum.f32(float [[Z:%.*]], float [[W:%.*]]) ; CHECK-NEXT: [[B:%.*]] = call float @llvm.maxnum.f32(float [[Z:%.*]], float [[W:%.*]])
; CHECK-NEXT: [[C:%.*]] = call float @llvm.maxnum.f32(float [[A]], float [[B]]) ; CHECK-NEXT: [[C:%.*]] = call float @llvm.maxnum.f32(float [[A]], float [[B]])
; CHECK-NEXT: ret float [[C]] ; CHECK-NEXT: ret float [[C]]
; ;
%a = call float @llvm.maxnum.f32(float %x, float %y) %a = call float @llvm.maxnum.f32(float %x, float %y)
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/InstCombine/minimum.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S -instcombine < %s | FileCheck %s ; RUN: opt -S -instcombine < %s | FileCheck %s
declare float @llvm.minimum.f32(float, float) declare float @llvm.minimum.f32(float, float)
declare float @llvm.minimum.v2f32(<2 x float>, <2 x float>) declare <2 x float> @llvm.minimum.v2f32(<2 x float>, <2 x float>)
declare <4 x float> @llvm.minimum.v4f32(<4 x float>, <4 x float>) declare <4 x float> @llvm.minimum.v4f32(<4 x float>, <4 x float>)
declare double @llvm.minimum.f64(double, double) declare double @llvm.minimum.f64(double, double)
declare <2 x double> @llvm.minimum.v2f64(<2 x double>, <2 x double>) declare <2 x double> @llvm.minimum.v2f64(<2 x double>, <2 x double>)
declare float @llvm.maximum.f32(float, float) declare float @llvm.maximum.f32(float, float)
define float @constant_fold_minimum_f32() { define float @constant_fold_minimum_f32() {
▲ Show 20 Lines • Show All 128 Lines • ▼ Show 20 Lines
define float @minimum_f32_val_nan(float %x) { define float @minimum_f32_val_nan(float %x) {
; CHECK-LABEL: @minimum_f32_val_nan( ; CHECK-LABEL: @minimum_f32_val_nan(
; CHECK-NEXT: ret float 0x7FF8000000000000 ; CHECK-NEXT: ret float 0x7FF8000000000000
; ;
%y = call float @llvm.minimum.f32(float %x, float 0x7FF8000000000000) %y = call float @llvm.minimum.f32(float %x, float 0x7FF8000000000000)
ret float %y ret float %y
} }
define float @minimum_f32_1_minimum_val_p0(float %x) {
; CHECK-LABEL: @minimum_f32_1_minimum_val_p0(
; CHECK-NEXT: [[Y:%.*]] = call float @llvm.minimum.f32(float %x, float 0.000000e+00)
; CHECK-NEXT: [[RES:%.*]] = call float @llvm.minimum.f32(float [[Y]], float 1.000000e+00)
; CHECK-NEXT: ret float [[RES]]
%y = call float @llvm.minimum.f32(float %x, float 0.0)
%z = call float @llvm.minimum.f32(float %y, float 1.0)
ret float %z
}
define float @minimum_f32_1_minimum_p0_val_fast(float %x) {
; CHECK-LABEL: @minimum_f32_1_minimum_p0_val_fast(
; CHECK-NEXT: [[Y:%.*]] = call float @llvm.minimum.f32(float %x, float 0.000000e+00)
; CHECK-NEXT: [[RES:%.*]] = call fast float @llvm.minimum.f32(float [[Y]], float 1.000000e+00)
; CHECK-NEXT: ret float [[RES]]
%y = call float @llvm.minimum.f32(float 0.0, float %x)
%z = call fast float @llvm.minimum.f32(float %y, float 1.0)
ret float %z
}
define float @minimum_f32_1_minimum_p0_val_nnan_ninf(float %x) {
; CHECK-LABEL: @minimum_f32_1_minimum_p0_val_nnan_ninf(
; CHECK-NEXT: [[Y:%.*]] = call float @llvm.minimum.f32(float %x, float 0.000000e+00)
; CHECK-NEXT: [[RES:%.*]] = call nnan ninf float @llvm.minimum.f32(float [[Y]], float 1.000000e+00)
; CHECK-NEXT: ret float [[RES]]
%y = call float @llvm.minimum.f32(float 0.0, float %x)
%z = call nnan ninf float @llvm.minimum.f32(float %y, float 1.0)
ret float %z
}
define float @minimum_f32_p0_minimum_val_n0(float %x) {
; CHECK-LABEL: @minimum_f32_p0_minimum_val_n0(
; CHECK-NEXT: [[Y:%.*]] = call float @llvm.minimum.f32(float %x, float -0.000000e+00)
; CHECK-NEXT: [[RES:%.*]] = call float @llvm.minimum.f32(float [[Y]], float 0.000000e+00)
; CHECK-NEXT: ret float [[RES]]
%y = call float @llvm.minimum.f32(float %x, float -0.0)
%z = call float @llvm.minimum.f32(float %y, float 0.0)
ret float %z
}
define float @minimum_f32_1_minimum_p0_val(float %x) {
; CHECK-LABEL: @minimum_f32_1_minimum_p0_val(
; CHECK-NEXT: [[Y:%.*]] = call float @llvm.minimum.f32(float %x, float 0.000000e+00)
; CHECK-NEXT: [[RES:%.*]] = call float @llvm.minimum.f32(float [[Y]], float 1.000000e+00)
; CHECK-NEXT: ret float [[RES]]
%y = call float @llvm.minimum.f32(float 0.0, float %x)
%z = call float @llvm.minimum.f32(float %y, float 1.0)
ret float %z
}
define <2 x float> @minimum_f32_1_minimum_val_p0_val_v2f32(<2 x float> %x) {
; CHECK-LABEL: @minimum_f32_1_minimum_val_p0_val_v2f32(
; CHECK-NEXT: [[Y:%.*]] = call <2 x float> @llvm.minimum.v2f32(<2 x float> %x, <2 x float> zeroinitializer)
; CHECK-NEXT: [[RES:%.*]] = call <2 x float> @llvm.minimum.v2f32(<2 x float> [[Y]], <2 x float> <float 1.000000e+00, float 1.000000e+00>)
; CHECK-NEXT: ret <2 x float> [[RES]]
%y = call <2 x float> @llvm.minimum.v2f32(<2 x float> %x, <2 x float> zeroinitializer)
%z = call <2 x float> @llvm.minimum.v2f32(<2 x float> %y, <2 x float><float 1.0, float 1.0>)
ret <2 x float> %z
}
define float @minimum4(float %x, float %y, float %z, float %w) { define float @minimum4(float %x, float %y, float %z, float %w) {
; CHECK-LABEL: @minimum4( ; CHECK-LABEL: @minimum4(
; CHECK-NEXT: [[A:%.*]] = call float @llvm.minimum.f32(float [[X:%.*]], float [[Y:%.*]]) ; CHECK-NEXT: [[A:%.*]] = call float @llvm.minimum.f32(float [[X:%.*]], float [[Y:%.*]])
; CHECK-NEXT: [[B:%.*]] = call float @llvm.minimum.f32(float [[Z:%.*]], float [[W:%.*]]) ; CHECK-NEXT: [[B:%.*]] = call float @llvm.minimum.f32(float [[Z:%.*]], float [[W:%.*]])
; CHECK-NEXT: [[C:%.*]] = call float @llvm.minimum.f32(float [[A]], float [[B]]) ; CHECK-NEXT: [[C:%.*]] = call float @llvm.minimum.f32(float [[A]], float [[B]])
; CHECK-NEXT: ret float [[C]] ; CHECK-NEXT: ret float [[C]]
; ;
%a = call float @llvm.minimum.f32(float %x, float %y) %a = call float @llvm.minimum.f32(float %x, float %y)
▲ Show 20 Lines • Show All 106 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/InstCombine/minnum.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S -instcombine < %s | FileCheck %s ; RUN: opt -S -instcombine < %s | FileCheck %s
declare float @llvm.minnum.f32(float, float) declare float @llvm.minnum.f32(float, float)
declare float @llvm.minnum.v2f32(<2 x float>, <2 x float>) declare <2 x float> @llvm.minnum.v2f32(<2 x float>, <2 x float>)
declare <4 x float> @llvm.minnum.v4f32(<4 x float>, <4 x float>) declare <4 x float> @llvm.minnum.v4f32(<4 x float>, <4 x float>)
declare double @llvm.minnum.f64(double, double) declare double @llvm.minnum.f64(double, double)
declare <2 x double> @llvm.minnum.v2f64(<2 x double>, <2 x double>) declare <2 x double> @llvm.minnum.v2f64(<2 x double>, <2 x double>)
declare float @llvm.maxnum.f32(float, float) declare float @llvm.maxnum.f32(float, float)
define float @constant_fold_minnum_f32() { define float @constant_fold_minnum_f32() {
▲ Show 20 Lines • Show All 128 Lines • ▼ Show 20 Lines
define float @minnum_f32_val_nan(float %x) { define float @minnum_f32_val_nan(float %x) {
; CHECK-LABEL: @minnum_f32_val_nan( ; CHECK-LABEL: @minnum_f32_val_nan(
; CHECK-NEXT: ret float [[X:%.*]] ; CHECK-NEXT: ret float [[X:%.*]]
; ;
%y = call float @llvm.minnum.f32(float %x, float 0x7FF8000000000000) %y = call float @llvm.minnum.f32(float %x, float 0x7FF8000000000000)
ret float %y ret float %y
} }
define float @minnum_f32_1_minnum_val_p0(float %x) {
; CHECK-LABEL: @minnum_f32_1_minnum_val_p0(
; CHECK-NEXT: [[Y:%.*]] = call float @llvm.minnum.f32(float %x, float 0.000000e+00)
; CHECK-NEXT: [[RES:%.*]] = call float @llvm.minnum.f32(float [[Y]], float 1.000000e+00)
; CHECK-NEXT: ret float [[RES]]
%y = call float @llvm.minnum.f32(float %x, float 0.0)
%z = call float @llvm.minnum.f32(float %y, float 1.0)
ret float %z
}
define float @minnum_f32_1_minnum_p0_val_fast(float %x) {
; CHECK-LABEL: @minnum_f32_1_minnum_p0_val_fast(
; CHECK-NEXT: [[Y:%.*]] = call float @llvm.minnum.f32(float %x, float 0.000000e+00)
; CHECK-NEXT: [[RES:%.*]] = call fast float @llvm.minnum.f32(float [[Y]], float 1.000000e+00)
; CHECK-NEXT: ret float [[RES]]
%y = call float @llvm.minnum.f32(float 0.0, float %x)
%z = call fast float @llvm.minnum.f32(float %y, float 1.0)
ret float %z
}
define float @minnum_f32_1_minnum_p0_val_nnan_ninf(float %x) {
; CHECK-LABEL: @minnum_f32_1_minnum_p0_val_nnan_ninf(
; CHECK-NEXT: [[Y:%.*]] = call float @llvm.minnum.f32(float %x, float 0.000000e+00)
; CHECK-NEXT: [[RES:%.*]] = call nnan ninf float @llvm.minnum.f32(float [[Y]], float 1.000000e+00)
; CHECK-NEXT: ret float [[RES]]
%y = call float @llvm.minnum.f32(float 0.0, float %x)
%z = call nnan ninf float @llvm.minnum.f32(float %y, float 1.0)
ret float %z
}
define float @minnum_f32_p0_minnum_val_n0(float %x) {
; CHECK-LABEL: @minnum_f32_p0_minnum_val_n0(
; CHECK-NEXT: [[Y:%.*]] = call float @llvm.minnum.f32(float %x, float -0.000000e+00)
; CHECK-NEXT: [[RES:%.*]] = call float @llvm.minnum.f32(float [[Y]], float 0.000000e+00)
; CHECK-NEXT: ret float [[RES]]
%y = call float @llvm.minnum.f32(float %x, float -0.0)
%z = call float @llvm.minnum.f32(float %y, float 0.0)
ret float %z
}
define float @minnum_f32_1_minnum_p0_val(float %x) {
; CHECK-LABEL: @minnum_f32_1_minnum_p0_val(
; CHECK-NEXT: [[Y:%.*]] = call float @llvm.minnum.f32(float %x, float 0.000000e+00)
; CHECK-NEXT: [[RES:%.*]] = call float @llvm.minnum.f32(float [[Y]], float 1.000000e+00)
; CHECK-NEXT: ret float [[RES]]
%y = call float @llvm.minnum.f32(float 0.0, float %x)
%z = call float @llvm.minnum.f32(float %y, float 1.0)
ret float %z
}
define <2 x float> @minnum_f32_1_minnum_val_p0_val_v2f32(<2 x float> %x) {
; CHECK-LABEL: @minnum_f32_1_minnum_val_p0_val_v2f32(
; CHECK-NEXT: [[Y:%.*]] = call <2 x float> @llvm.minnum.v2f32(<2 x float> %x, <2 x float> zeroinitializer)
; CHECK-NEXT: [[RES:%.*]] = call <2 x float> @llvm.minnum.v2f32(<2 x float> [[Y]], <2 x float> <float 1.000000e+00, float 1.000000e+00>)
; CHECK-NEXT: ret <2 x float> [[RES]]
%y = call <2 x float> @llvm.minnum.v2f32(<2 x float> %x, <2 x float> zeroinitializer)
%z = call <2 x float> @llvm.minnum.v2f32(<2 x float> %y, <2 x float><float 1.0, float 1.0>)
ret <2 x float> %z
}
define float @minnum4(float %x, float %y, float %z, float %w) { define float @minnum4(float %x, float %y, float %z, float %w) {
; CHECK-LABEL: @minnum4( ; CHECK-LABEL: @minnum4(
; CHECK-NEXT: [[A:%.*]] = call float @llvm.minnum.f32(float [[X:%.*]], float [[Y:%.*]]) ; CHECK-NEXT: [[A:%.*]] = call float @llvm.minnum.f32(float [[X:%.*]], float [[Y:%.*]])
; CHECK-NEXT: [[B:%.*]] = call float @llvm.minnum.f32(float [[Z:%.*]], float [[W:%.*]]) ; CHECK-NEXT: [[B:%.*]] = call float @llvm.minnum.f32(float [[Z:%.*]], float [[W:%.*]])
; CHECK-NEXT: [[C:%.*]] = call float @llvm.minnum.f32(float [[A]], float [[B]]) ; CHECK-NEXT: [[C:%.*]] = call float @llvm.minnum.f32(float [[A]], float [[B]])
; CHECK-NEXT: ret float [[C]] ; CHECK-NEXT: ret float [[C]]
; ;
%a = call float @llvm.minnum.f32(float %x, float %y) %a = call float @llvm.minnum.f32(float %x, float %y)
▲ Show 20 Lines • Show All 107 Lines • Show Last 20 Lines