derek.holloway
7502bf64a4
CodeQL / Analyze (actions) (push) Canceled after 0s
CodeQL / Analyze (python) (push) Canceled after 0s
pre-commit / pre-commit (push) Canceled after 0s
Multi-Arch CI / setup (push) Canceled after 0s
Publish build_manylinux_x86_64 images / publish_build_manylinux_x86_64 (push) Canceled after 0s
Setup (Multi-Arch) / setup (push) Canceled after 0s
Multi-Arch CI / Linux::${{ fromJSON(needs.setup.outputs.linux_build_config || '{}').build_variant_label || 'skip' }} (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Publish no_rocm_image_ubi10 image / publish_no_rocm_image_ubi10 (push) Canceled after 0s
Multi-Arch CI / Windows::${{ fromJSON(needs.setup.outputs.windows_build_config || '{}').build_variant_label || 'skip' }} (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Multi-Arch CI / Manifest Diff (push) Canceled after 0s
TheRock Manifest Diff Report / Generate Manifest Diff Report (push) Canceled after 0s
Multi-Arch CI / CI Summary (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04 (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04_ocl_rt images / publish_no_rocm_image_ubuntu24_04_ocl_rt (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_rocgdb (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04_rocgdb images / publish_no_rocm_image_ubuntu24_04_rocgdb (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_ocl_rt (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Unit Tests / Unit Tests :: ubuntu-24.04 (push) Canceled after 0s
Unit Tests / Unit Tests :: windows-2022 (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_media (push) Canceled after 0s
Unit Tests / Unit Tests Summary (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_openmpi (push) Canceled after 0s
1238 lines
51 KiB
LLVM
1238 lines
51 KiB
LLVM
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 6
|
|
; RUN: opt -S -passes=instcombine < %s | FileCheck %s
|
|
|
|
declare nofpclass(nan inf sub norm) half @returns_zero()
|
|
declare nofpclass(nan inf nzero sub norm) half @returns_pzero()
|
|
declare nofpclass(nan inf pzero sub norm) half @returns_nzero()
|
|
declare nofpclass(inf sub norm) half @returns_zero_or_nan()
|
|
declare nofpclass(inf nzero sub norm) half @returns_pzero_or_nan()
|
|
declare nofpclass(inf pzero sub norm) half @returns_nzero_or_nan()
|
|
|
|
declare nofpclass(nan zero sub norm) half @returns_inf()
|
|
declare nofpclass(nan ninf zero sub norm) half @returns_pinf()
|
|
declare nofpclass(nan pinf zero sub norm) half @returns_ninf()
|
|
declare nofpclass(zero sub norm) half @returns_inf_or_nan()
|
|
|
|
declare nofpclass(ninf nzero nsub nnorm) half @returns_positive_or_nan()
|
|
declare nofpclass(pinf pzero psub pnorm) half @returns_negative_or_nan()
|
|
|
|
declare nofpclass(nan ninf nzero nsub nnorm) half @returns_positive()
|
|
declare nofpclass(nan pinf pzero psub pnorm) half @returns_negative()
|
|
|
|
declare nofpclass(inf zero sub norm) half @returns_nan()
|
|
declare nofpclass(qnan inf zero sub norm) half @returns_snan()
|
|
|
|
declare nofpclass(nan inf zero sub) half @returns_norm()
|
|
declare nofpclass(nan inf zero sub pnorm) half @returns_nnorm()
|
|
declare nofpclass(nan inf zero sub nnorm) half @returns_pnorm()
|
|
|
|
declare nofpclass(nan inf zero norm) half @returns_sub()
|
|
declare nofpclass(nan inf zero psub norm) half @returns_nsub()
|
|
declare nofpclass(nan inf zero nsub norm) half @returns_psub()
|
|
|
|
declare void @use(half)
|
|
|
|
define nofpclass(inf zero sub norm) half @ret_only_nan(half %x, half %y) {
|
|
; CHECK-LABEL: define nofpclass(inf zero sub norm) half @ret_only_nan(
|
|
; CHECK-SAME: half [[X:%.*]], half [[Y:%.*]]) {
|
|
; CHECK-NEXT: ret half +qnan
|
|
;
|
|
%add = fsub half %x, %y
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(snan inf zero sub norm) half @ret_only_qnan(half %x, half %y) {
|
|
; CHECK-LABEL: define nofpclass(snan inf zero sub norm) half @ret_only_qnan(
|
|
; CHECK-SAME: half [[X:%.*]], half [[Y:%.*]]) {
|
|
; CHECK-NEXT: ret half +qnan
|
|
;
|
|
%add = fsub half %x, %y
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(qnan inf zero sub norm) half @ret_only_snan(half %x, half %y) {
|
|
; CHECK-LABEL: define nofpclass(qnan inf zero sub norm) half @ret_only_snan(
|
|
; CHECK-SAME: half [[X:%.*]], half [[Y:%.*]]) {
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub half [[X]], [[Y]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%add = fsub half %x, %y
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(nan inf sub norm) half @ret_only_zero(half %x, half %y) {
|
|
; CHECK-LABEL: define nofpclass(nan inf sub norm) half @ret_only_zero(
|
|
; CHECK-SAME: half [[X:%.*]], half [[Y:%.*]]) {
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub nnan ninf half [[X]], [[Y]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%add = fsub half %x, %y
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(nan inf nzero sub norm) half @ret_only_pzero(half %x, half %y) {
|
|
; CHECK-LABEL: define nofpclass(nan inf nzero sub norm) half @ret_only_pzero(
|
|
; CHECK-SAME: half [[X:%.*]], half [[Y:%.*]]) {
|
|
; CHECK-NEXT: ret half 0.000000e+00
|
|
;
|
|
%add = fsub half %x, %y
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(nan inf pzero sub norm) half @ret_only_nzero(half %x, half %y) {
|
|
; CHECK-LABEL: define nofpclass(nan inf pzero sub norm) half @ret_only_nzero(
|
|
; CHECK-SAME: half [[X:%.*]], half [[Y:%.*]]) {
|
|
; CHECK-NEXT: ret half -0.000000e+00
|
|
;
|
|
%add = fsub half %x, %y
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(nan zero sub norm) half @ret_only_inf(half %x, half %y) {
|
|
; CHECK-LABEL: define nofpclass(nan zero sub norm) half @ret_only_inf(
|
|
; CHECK-SAME: half [[X:%.*]], half [[Y:%.*]]) {
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub nnan half [[X]], [[Y]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%add = fsub half %x, %y
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(nan ninf zero sub norm) half @ret_only_pinf(half %x, half %y) {
|
|
; CHECK-LABEL: define nofpclass(nan ninf zero sub norm) half @ret_only_pinf(
|
|
; CHECK-SAME: half [[X:%.*]], half [[Y:%.*]]) {
|
|
; CHECK-NEXT: ret half +inf
|
|
;
|
|
%add = fsub half %x, %y
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(nan pinf zero sub norm) half @ret_only_ninf(half %x, half %y) {
|
|
; CHECK-LABEL: define nofpclass(nan pinf zero sub norm) half @ret_only_ninf(
|
|
; CHECK-SAME: half [[X:%.*]], half [[Y:%.*]]) {
|
|
; CHECK-NEXT: ret half -inf
|
|
;
|
|
%add = fsub half %x, %y
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(pinf) half @ret_nofpclass_pinf__fsub_select_unknown_or_pinf__unknown(i1 %cond, half %x, half %y) {
|
|
; CHECK-LABEL: define nofpclass(pinf) half @ret_nofpclass_pinf__fsub_select_unknown_or_pinf__unknown(
|
|
; CHECK-SAME: i1 [[COND:%.*]], half [[X:%.*]], half [[Y:%.*]]) {
|
|
; CHECK-NEXT: [[X_OR_PINF:%.*]] = select i1 [[COND]], half [[X]], half +inf
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub half [[X_OR_PINF]], [[Y]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%x.or.pinf = select i1 %cond, half %x, half 0xH7C00
|
|
%add = fsub half %x.or.pinf, %y
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(pinf) half @ret_nofpclass_pinf__fsub_unknown__select_unknown_or_pinf(i1 %cond, half %x, half %y) {
|
|
; CHECK-LABEL: define nofpclass(pinf) half @ret_nofpclass_pinf__fsub_unknown__select_unknown_or_pinf(
|
|
; CHECK-SAME: i1 [[COND:%.*]], half [[X:%.*]], half [[Y:%.*]]) {
|
|
; CHECK-NEXT: [[Y_OR_PINF:%.*]] = select i1 [[COND]], half [[Y]], half +inf
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub half [[X]], [[Y_OR_PINF]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%y.or.pinf = select i1 %cond, half %y, half 0xH7C00
|
|
%add = fsub half %x, %y.or.pinf
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(inf) half @ret_nofpclass_inf__fsub_select_unknown_or_inf__unknown(i1 %cond, half %x, half %y) {
|
|
; CHECK-LABEL: define nofpclass(inf) half @ret_nofpclass_inf__fsub_select_unknown_or_inf__unknown(
|
|
; CHECK-SAME: i1 [[COND:%.*]], half [[X:%.*]], half [[Y:%.*]]) {
|
|
; CHECK-NEXT: [[INF:%.*]] = call half @returns_inf()
|
|
; CHECK-NEXT: [[X_OR_INF:%.*]] = select i1 [[COND]], half [[X]], half [[INF]]
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub half [[X_OR_INF]], [[Y]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%inf = call half @returns_inf()
|
|
%x.or.inf = select i1 %cond, half %x, half %inf
|
|
%add = fsub half %x.or.inf, %y
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(inf) half @ret_nofpclass_inf__fsub_unknown__select_unknown_or_inf(i1 %cond, half %x, half %y) {
|
|
; CHECK-LABEL: define nofpclass(inf) half @ret_nofpclass_inf__fsub_unknown__select_unknown_or_inf(
|
|
; CHECK-SAME: i1 [[COND:%.*]], half [[X:%.*]], half [[Y:%.*]]) {
|
|
; CHECK-NEXT: [[INF:%.*]] = call half @returns_inf()
|
|
; CHECK-NEXT: [[Y_OR_INF:%.*]] = select i1 [[COND]], half [[Y]], half [[INF]]
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub half [[X]], [[Y_OR_INF]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%inf = call half @returns_inf()
|
|
%y.or.inf = select i1 %cond, half %y, half %inf
|
|
%add = fsub half %x, %y.or.inf
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(pinf) half @ret_nofpclass_pinf__fsub_select_unknown_or_pinf(i1 %cond, half %x, half %y) {
|
|
; CHECK-LABEL: define nofpclass(pinf) half @ret_nofpclass_pinf__fsub_select_unknown_or_pinf(
|
|
; CHECK-SAME: i1 [[COND:%.*]], half [[X:%.*]], half [[Y:%.*]]) {
|
|
; CHECK-NEXT: [[TMP1:%.*]] = fsub half [[X]], [[Y]]
|
|
; CHECK-NEXT: [[ADD:%.*]] = select i1 [[COND]], half [[TMP1]], half +qnan
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%x.or.pinf = select i1 %cond, half %x, half 0xH7C00
|
|
%y.or.pinf = select i1 %cond, half %y, half 0xH7C00
|
|
%add = fsub half %x.or.pinf, %y.or.pinf
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(ninf) half @ret_nofpclass_ninf__fsub_select_unknown_or_ninf(i1 %cond, half %x, half %y) {
|
|
; CHECK-LABEL: define nofpclass(ninf) half @ret_nofpclass_ninf__fsub_select_unknown_or_ninf(
|
|
; CHECK-SAME: i1 [[COND:%.*]], half [[X:%.*]], half [[Y:%.*]]) {
|
|
; CHECK-NEXT: [[TMP1:%.*]] = fsub half [[X]], [[Y]]
|
|
; CHECK-NEXT: [[ADD:%.*]] = select i1 [[COND]], half [[TMP1]], half +qnan
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%x.or.ninf = select i1 %cond, half %x, half 0xHFC00
|
|
%y.or.ninf = select i1 %cond, half %y, half 0xHFC00
|
|
%add = fsub half %x.or.ninf, %y.or.ninf
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(inf) half @ret_nofpclass_inf__fsub_select_unknown_or_inf(i1 %cond, half %x, half %y) {
|
|
; CHECK-LABEL: define nofpclass(inf) half @ret_nofpclass_inf__fsub_select_unknown_or_inf(
|
|
; CHECK-SAME: i1 [[COND:%.*]], half [[X:%.*]], half [[Y:%.*]]) {
|
|
; CHECK-NEXT: [[INF0:%.*]] = call half @returns_inf()
|
|
; CHECK-NEXT: [[INF1:%.*]] = call half @returns_inf()
|
|
; CHECK-NEXT: [[X_OR_INF:%.*]] = select i1 [[COND]], half [[X]], half [[INF0]]
|
|
; CHECK-NEXT: [[Y_OR_INF:%.*]] = select i1 [[COND]], half [[Y]], half [[INF1]]
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub half [[X_OR_INF]], [[Y_OR_INF]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%inf0 = call half @returns_inf()
|
|
%inf1 = call half @returns_inf()
|
|
%x.or.inf = select i1 %cond, half %x, half %inf0
|
|
%y.or.inf = select i1 %cond, half %y, half %inf1
|
|
%add = fsub half %x.or.inf, %y.or.inf
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(nan inf) half @ret_nofpclass_inf_nan__fsub_select_unknown_or_inf(i1 %cond, half %x, half %y) {
|
|
; CHECK-LABEL: define nofpclass(nan inf) half @ret_nofpclass_inf_nan__fsub_select_unknown_or_inf(
|
|
; CHECK-SAME: i1 [[COND:%.*]], half [[X:%.*]], half [[Y:%.*]]) {
|
|
; CHECK-NEXT: [[INF0:%.*]] = call half @returns_inf()
|
|
; CHECK-NEXT: [[INF1:%.*]] = call half @returns_inf()
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub nnan ninf half [[X]], [[Y]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%inf0 = call half @returns_inf()
|
|
%inf1 = call half @returns_inf()
|
|
%x.or.inf = select i1 %cond, half %x, half %inf0
|
|
%y.or.inf = select i1 %cond, half %y, half %inf1
|
|
%add = fsub half %x.or.inf, %y.or.inf
|
|
ret half %add
|
|
}
|
|
|
|
; Cannot prune the select, the result could be nan depending on %x
|
|
define nofpclass(inf sub norm) half @nan_result_demands_inf_input_lhs(i1 %cond, half nofpclass(zero) %x, half nofpclass(zero inf nan) %y) {
|
|
; CHECK-LABEL: define nofpclass(inf sub norm) half @nan_result_demands_inf_input_lhs(
|
|
; CHECK-SAME: i1 [[COND:%.*]], half nofpclass(zero) [[X:%.*]], half nofpclass(nan inf zero) [[Y:%.*]]) {
|
|
; CHECK-NEXT: [[PINF:%.*]] = call half @returns_pinf()
|
|
; CHECK-NEXT: [[X_OR_INF:%.*]] = select i1 [[COND]], half [[X]], half +inf
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub half [[X_OR_INF]], [[Y]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%pinf = call half @returns_pinf()
|
|
%x.or.inf = select i1 %cond, half %x, half %pinf
|
|
%add = fsub half %x.or.inf, %y
|
|
ret half %add
|
|
}
|
|
|
|
; Cannot prune the select, the result could be nan depending on %y
|
|
define nofpclass(inf sub norm) half @nan_result_demands_inf_input_rhs(i1 %cond, half nofpclass(zero) %x, half %y) {
|
|
; CHECK-LABEL: define nofpclass(inf sub norm) half @nan_result_demands_inf_input_rhs(
|
|
; CHECK-SAME: i1 [[COND:%.*]], half nofpclass(zero) [[X:%.*]], half [[Y:%.*]]) {
|
|
; CHECK-NEXT: [[PINF:%.*]] = call half @returns_pinf()
|
|
; CHECK-NEXT: [[Y_OR_INF:%.*]] = select i1 [[COND]], half [[Y]], half +inf
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub half [[X]], [[Y_OR_INF]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%pinf = call half @returns_pinf()
|
|
%y.or.inf = select i1 %cond, half %y, half %pinf
|
|
%add = fsub half %x, %y.or.inf
|
|
ret half %add
|
|
}
|
|
|
|
; Cannot prune the select
|
|
define nofpclass(nan sub norm zero) half @inf_result_demands_inf_input_lhs(i1 %cond, half nofpclass(zero) %x, half nofpclass(zero) %y) {
|
|
; CHECK-LABEL: define nofpclass(nan zero sub norm) half @inf_result_demands_inf_input_lhs(
|
|
; CHECK-SAME: i1 [[COND:%.*]], half nofpclass(zero) [[X:%.*]], half nofpclass(zero) [[Y:%.*]]) {
|
|
; CHECK-NEXT: [[INF:%.*]] = call half @returns_inf()
|
|
; CHECK-NEXT: [[X_OR_INF:%.*]] = select i1 [[COND]], half [[X]], half [[INF]]
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub nnan half [[X_OR_INF]], [[Y]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%inf = call half @returns_inf()
|
|
%x.or.inf = select i1 %cond, half %x, half %inf
|
|
%add = fsub half %x.or.inf, %y
|
|
ret half %add
|
|
}
|
|
|
|
; Cannot prune the select
|
|
define nofpclass(nan sub norm zero) half @inf_result_demands_inf_input_rhs(i1 %cond, half nofpclass(zero) %x, half nofpclass(zero) %y) {
|
|
; CHECK-LABEL: define nofpclass(nan zero sub norm) half @inf_result_demands_inf_input_rhs(
|
|
; CHECK-SAME: i1 [[COND:%.*]], half nofpclass(zero) [[X:%.*]], half nofpclass(zero) [[Y:%.*]]) {
|
|
; CHECK-NEXT: [[INF:%.*]] = call half @returns_inf()
|
|
; CHECK-NEXT: [[Y_OR_INF:%.*]] = select i1 [[COND]], half [[Y]], half [[INF]]
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub nnan half [[X]], [[Y_OR_INF]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%inf = call half @returns_inf()
|
|
%y.or.inf = select i1 %cond, half %y, half %inf
|
|
%add = fsub half %x, %y.or.inf
|
|
ret half %add
|
|
}
|
|
|
|
; Cannot prune the select
|
|
define nofpclass(nan sub norm zero) half @inf_result_demands_pinf_input_lhs(i1 %cond, half nofpclass(zero) %x, half nofpclass(zero) %y) {
|
|
; CHECK-LABEL: define nofpclass(nan zero sub norm) half @inf_result_demands_pinf_input_lhs(
|
|
; CHECK-SAME: i1 [[COND:%.*]], half nofpclass(zero) [[X:%.*]], half nofpclass(zero) [[Y:%.*]]) {
|
|
; CHECK-NEXT: [[PINF:%.*]] = call half @returns_pinf()
|
|
; CHECK-NEXT: [[X_OR_INF:%.*]] = select i1 [[COND]], half [[X]], half +inf
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub nnan half [[X_OR_INF]], [[Y]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%pinf = call half @returns_pinf()
|
|
%x.or.inf = select i1 %cond, half %x, half %pinf
|
|
%add = fsub half %x.or.inf, %y
|
|
ret half %add
|
|
}
|
|
|
|
; Cannot prune the select
|
|
define nofpclass(nan sub norm zero) half @inf_result_demands_pinf_input_rhs(i1 %cond, half nofpclass(zero) %x, half nofpclass(zero) %y) {
|
|
; CHECK-LABEL: define nofpclass(nan zero sub norm) half @inf_result_demands_pinf_input_rhs(
|
|
; CHECK-SAME: i1 [[COND:%.*]], half nofpclass(zero) [[X:%.*]], half nofpclass(zero) [[Y:%.*]]) {
|
|
; CHECK-NEXT: [[PINF:%.*]] = call half @returns_pinf()
|
|
; CHECK-NEXT: [[Y_OR_INF:%.*]] = select i1 [[COND]], half [[Y]], half +inf
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub nnan half [[X]], [[Y_OR_INF]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%pinf = call half @returns_pinf()
|
|
%y.or.inf = select i1 %cond, half %y, half %pinf
|
|
%add = fsub half %x, %y.or.inf
|
|
ret half %add
|
|
}
|
|
|
|
; Cannot prune the select
|
|
define nofpclass(nan sub norm zero) half @inf_result_demands_ninf_input_lhs(i1 %cond, half nofpclass(zero) %x, half nofpclass(zero) %y) {
|
|
; CHECK-LABEL: define nofpclass(nan zero sub norm) half @inf_result_demands_ninf_input_lhs(
|
|
; CHECK-SAME: i1 [[COND:%.*]], half nofpclass(zero) [[X:%.*]], half nofpclass(zero) [[Y:%.*]]) {
|
|
; CHECK-NEXT: [[NINF:%.*]] = call half @returns_ninf()
|
|
; CHECK-NEXT: [[X_OR_INF:%.*]] = select i1 [[COND]], half [[X]], half -inf
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub nnan half [[X_OR_INF]], [[Y]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%ninf = call half @returns_ninf()
|
|
%x.or.inf = select i1 %cond, half %x, half %ninf
|
|
%add = fsub half %x.or.inf, %y
|
|
ret half %add
|
|
}
|
|
|
|
; Cannot prune the select
|
|
define nofpclass(nan sub norm zero) half @inf_result_demands_ninf_input_rhs(i1 %cond, half nofpclass(zero) %x, half nofpclass(zero) %y) {
|
|
; CHECK-LABEL: define nofpclass(nan zero sub norm) half @inf_result_demands_ninf_input_rhs(
|
|
; CHECK-SAME: i1 [[COND:%.*]], half nofpclass(zero) [[X:%.*]], half nofpclass(zero) [[Y:%.*]]) {
|
|
; CHECK-NEXT: [[NINF:%.*]] = call half @returns_ninf()
|
|
; CHECK-NEXT: [[Y_OR_INF:%.*]] = select i1 [[COND]], half [[Y]], half -inf
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub nnan half [[X]], [[Y_OR_INF]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%ninf = call half @returns_ninf()
|
|
%y.or.inf = select i1 %cond, half %y, half %ninf
|
|
%add = fsub half %x, %y.or.inf
|
|
ret half %add
|
|
}
|
|
|
|
; Cannot add nnan flag from not-nan inputs, the result could still be
|
|
; nan
|
|
define nofpclass(snan) half @no_nans_inputs(half nofpclass(nan) %x, half nofpclass(nan) %y) {
|
|
; CHECK-LABEL: define nofpclass(snan) half @no_nans_inputs(
|
|
; CHECK-SAME: half nofpclass(nan) [[X:%.*]], half nofpclass(nan) [[Y:%.*]]) {
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub half [[X]], [[Y]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%add = fsub half %x, %y
|
|
ret half %add
|
|
}
|
|
|
|
; Can add nnan flag if inputs and output known not-nan.
|
|
define nofpclass(nan) half @no_nans_input_and_output(half nofpclass(nan) %x, half nofpclass(nan) %y) {
|
|
; CHECK-LABEL: define nofpclass(nan) half @no_nans_input_and_output(
|
|
; CHECK-SAME: half nofpclass(nan) [[X:%.*]], half nofpclass(nan) [[Y:%.*]]) {
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub nnan half [[X]], [[Y]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%add = fsub half %x, %y
|
|
ret half %add
|
|
}
|
|
|
|
; Cannot add ninf flag from not-inf inputs, the result could still be
|
|
; inf
|
|
define nofpclass(snan) half @no_infs_inputs(half nofpclass(inf) %x, half nofpclass(inf) %y) {
|
|
; CHECK-LABEL: define nofpclass(snan) half @no_infs_inputs(
|
|
; CHECK-SAME: half nofpclass(inf) [[X:%.*]], half nofpclass(inf) [[Y:%.*]]) {
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub half [[X]], [[Y]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%add = fsub half %x, %y
|
|
ret half %add
|
|
}
|
|
|
|
; Can infer ninf flag
|
|
define nofpclass(inf) half @no_infs_inputs_and_outputs(half nofpclass(inf) %x, half nofpclass(inf) %y) {
|
|
; CHECK-LABEL: define nofpclass(inf) half @no_infs_inputs_and_outputs(
|
|
; CHECK-SAME: half nofpclass(inf) [[X:%.*]], half nofpclass(inf) [[Y:%.*]]) {
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub ninf half [[X]], [[Y]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%add = fsub half %x, %y
|
|
ret half %add
|
|
}
|
|
|
|
; Can infer nnan flag, not ninf flag.
|
|
define nofpclass(snan) half @no_nans_infs_inputs(half nofpclass(nan inf) %x, half nofpclass(nan inf) %y) {
|
|
; CHECK-LABEL: define nofpclass(snan) half @no_nans_infs_inputs(
|
|
; CHECK-SAME: half nofpclass(nan inf) [[X:%.*]], half nofpclass(nan inf) [[Y:%.*]]) {
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub nnan half [[X]], [[Y]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%add = fsub half %x, %y
|
|
ret half %add
|
|
}
|
|
|
|
; Can infer nnan, ninf
|
|
define nofpclass(inf) half @no_nans_infs_inputs__noinfs_output(half nofpclass(nan inf) %x, half nofpclass(nan inf) %y) {
|
|
; CHECK-LABEL: define nofpclass(inf) half @no_nans_infs_inputs__noinfs_output(
|
|
; CHECK-SAME: half nofpclass(nan inf) [[X:%.*]], half nofpclass(nan inf) [[Y:%.*]]) {
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub nnan ninf half [[X]], [[Y]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%add = fsub half %x, %y
|
|
ret half %add
|
|
}
|
|
|
|
; Can only infer nnan, not ninf
|
|
define nofpclass(nan) half @no_nans_infs_inputs__nonans_output(half nofpclass(nan inf) %x, half nofpclass(nan inf) %y) {
|
|
; CHECK-LABEL: define nofpclass(nan) half @no_nans_infs_inputs__nonans_output(
|
|
; CHECK-SAME: half nofpclass(nan inf) [[X:%.*]], half nofpclass(nan inf) [[Y:%.*]]) {
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub nnan half [[X]], [[Y]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%add = fsub half %x, %y
|
|
ret half %add
|
|
}
|
|
|
|
; Can infer nnan flag
|
|
define nofpclass(nzero) half @inferred_nan_output__noinfs_only_lhs(half nofpclass(nan inf) %x, half nofpclass(nan) %y) {
|
|
; CHECK-LABEL: define nofpclass(nzero) half @inferred_nan_output__noinfs_only_lhs(
|
|
; CHECK-SAME: half nofpclass(nan inf) [[X:%.*]], half nofpclass(nan) [[Y:%.*]]) {
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub nnan half [[X]], [[Y]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%add = fsub half %x, %y
|
|
ret half %add
|
|
}
|
|
|
|
; Can infer nnan flag
|
|
define nofpclass(nzero) half @inferred_nan_output__noinfs_only_rhs(half nofpclass(nan) %x, half nofpclass(nan inf) %y) {
|
|
; CHECK-LABEL: define nofpclass(nzero) half @inferred_nan_output__noinfs_only_rhs(
|
|
; CHECK-SAME: half nofpclass(nan) [[X:%.*]], half nofpclass(nan inf) [[Y:%.*]]) {
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub nnan half [[X]], [[Y]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%add = fsub half %x, %y
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(nzero) half @inferred_nan_output__fsub__nnan__no_ninf_no_nan(half nofpclass(nan) %x, half nofpclass(nan ninf) %y) {
|
|
; CHECK-LABEL: define nofpclass(nzero) half @inferred_nan_output__fsub__nnan__no_ninf_no_nan(
|
|
; CHECK-SAME: half nofpclass(nan) [[X:%.*]], half nofpclass(nan ninf) [[Y:%.*]]) {
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub half [[X]], [[Y]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%add = fsub half %x, %y
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(nzero) half @inferred_nan_output__fsub__no_ninf_no_nan__no_nan(half nofpclass(nan ninf) %x, half nofpclass(nan) %y) {
|
|
; CHECK-LABEL: define nofpclass(nzero) half @inferred_nan_output__fsub__no_ninf_no_nan__no_nan(
|
|
; CHECK-SAME: half nofpclass(nan ninf) [[X:%.*]], half nofpclass(nan) [[Y:%.*]]) {
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub half [[X]], [[Y]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%add = fsub half %x, %y
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(nzero) half @inferred_nan_output__fsub__no_nan__no_pinf_no_nan(half nofpclass(nan) %x, half nofpclass(nan pinf) %y) {
|
|
; CHECK-LABEL: define nofpclass(nzero) half @inferred_nan_output__fsub__no_nan__no_pinf_no_nan(
|
|
; CHECK-SAME: half nofpclass(nan) [[X:%.*]], half nofpclass(nan pinf) [[Y:%.*]]) {
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub half [[X]], [[Y]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%add = fsub half %x, %y
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(nzero) half @inferred_nan_output__fsub__no_pinf_no_nan__no_nan(half nofpclass(nan pinf) %x, half nofpclass(nan) %y) {
|
|
; CHECK-LABEL: define nofpclass(nzero) half @inferred_nan_output__fsub__no_pinf_no_nan__no_nan(
|
|
; CHECK-SAME: half nofpclass(nan pinf) [[X:%.*]], half nofpclass(nan) [[Y:%.*]]) {
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub half [[X]], [[Y]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%add = fsub half %x, %y
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(nzero) half @inferred_nan_output__fsub__no_pinf_no_nan__no_pinf_no_nan(half nofpclass(nan pinf) %x, half nofpclass(nan pinf) %y) {
|
|
; CHECK-LABEL: define nofpclass(nzero) half @inferred_nan_output__fsub__no_pinf_no_nan__no_pinf_no_nan(
|
|
; CHECK-SAME: half nofpclass(nan pinf) [[X:%.*]], half nofpclass(nan pinf) [[Y:%.*]]) {
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub half [[X]], [[Y]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%add = fsub half %x, %y
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(nzero) half @inferred_nan_output__fsub__no_ninf_no_nan__no_ninf_no_nan(half nofpclass(nan ninf) %x, half nofpclass(nan ninf) %y) {
|
|
; CHECK-LABEL: define nofpclass(nzero) half @inferred_nan_output__fsub__no_ninf_no_nan__no_ninf_no_nan(
|
|
; CHECK-SAME: half nofpclass(nan ninf) [[X:%.*]], half nofpclass(nan ninf) [[Y:%.*]]) {
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub half [[X]], [[Y]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%add = fsub half %x, %y
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(nan) half @ret_nonan_fabs_fsub_known_positive_or_nan_sources() {
|
|
; CHECK-LABEL: define nofpclass(nan) half @ret_nonan_fabs_fsub_known_positive_or_nan_sources() {
|
|
; CHECK-NEXT: [[POSITIVE_OR_NAN0:%.*]] = call half @returns_positive_or_nan()
|
|
; CHECK-NEXT: [[POSITIVE_OR_NAN1:%.*]] = call half @returns_positive_or_nan()
|
|
; CHECK-NEXT: [[KNOWN_POSITIVE_ADD:%.*]] = fsub nnan half [[POSITIVE_OR_NAN0]], [[POSITIVE_OR_NAN1]]
|
|
; CHECK-NEXT: [[FABS:%.*]] = call half @llvm.fabs.f16(half [[KNOWN_POSITIVE_ADD]])
|
|
; CHECK-NEXT: ret half [[FABS]]
|
|
;
|
|
%positive.or.nan0 = call half @returns_positive_or_nan()
|
|
%positive.or.nan1 = call half @returns_positive_or_nan()
|
|
%known.positive.add = fsub half %positive.or.nan0, %positive.or.nan1
|
|
%fabs = call half @llvm.fabs.f16(half %known.positive.add)
|
|
ret half %fabs
|
|
}
|
|
|
|
; Should be able to eliminate the fabs
|
|
define nofpclass(nan) half @ret_nonan_fabs_fsub_known_positive_sources() {
|
|
; CHECK-LABEL: define nofpclass(nan) half @ret_nonan_fabs_fsub_known_positive_sources() {
|
|
; CHECK-NEXT: [[POSITIVE0:%.*]] = call half @returns_positive()
|
|
; CHECK-NEXT: [[POSITIVE1:%.*]] = call half @returns_positive()
|
|
; CHECK-NEXT: ret half 0.000000e+00
|
|
;
|
|
%positive0 = call half @returns_positive()
|
|
%positive1 = call half @returns_positive()
|
|
%known.positive.add = fsub half %positive1, %positive1
|
|
%fabs = call half @llvm.fabs.f16(half %known.positive.add)
|
|
ret half %fabs
|
|
}
|
|
|
|
define nofpclass(snan) half @unknown__fsub__inf(half %unknown) {
|
|
; CHECK-LABEL: define nofpclass(snan) half @unknown__fsub__inf(
|
|
; CHECK-SAME: half [[UNKNOWN:%.*]]) {
|
|
; CHECK-NEXT: [[INF:%.*]] = call half @returns_inf()
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub half [[UNKNOWN]], [[INF]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%inf = call half @returns_inf()
|
|
%add = fsub half %unknown, %inf
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(snan) half @inf__fsub__unknown(half %unknown) {
|
|
; CHECK-LABEL: define nofpclass(snan) half @inf__fsub__unknown(
|
|
; CHECK-SAME: half [[UNKNOWN:%.*]]) {
|
|
; CHECK-NEXT: [[INF:%.*]] = call half @returns_inf()
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub half [[INF]], [[UNKNOWN]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%inf = call half @returns_inf()
|
|
%add = fsub half %inf, %unknown
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(snan) half @unknown__fsub__inf_or_nan(half %unknown) {
|
|
; CHECK-LABEL: define nofpclass(snan) half @unknown__fsub__inf_or_nan(
|
|
; CHECK-SAME: half [[UNKNOWN:%.*]]) {
|
|
; CHECK-NEXT: [[INF_OR_NAN:%.*]] = call half @returns_inf_or_nan()
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub half [[UNKNOWN]], [[INF_OR_NAN]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%inf.or.nan = call half @returns_inf_or_nan()
|
|
%add = fsub half %unknown, %inf.or.nan
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(snan) half @inf_or_nan__fsub__unknown(half %unknown) {
|
|
; CHECK-LABEL: define nofpclass(snan) half @inf_or_nan__fsub__unknown(
|
|
; CHECK-SAME: half [[UNKNOWN:%.*]]) {
|
|
; CHECK-NEXT: [[INF_OR_NAN:%.*]] = call half @returns_inf_or_nan()
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub half [[INF_OR_NAN]], [[UNKNOWN]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%inf.or.nan = call half @returns_inf_or_nan()
|
|
%add = fsub half %inf.or.nan, %unknown
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(nan) half @ret_nonan__unknown__fsub__inf(half %unknown) {
|
|
; CHECK-LABEL: define nofpclass(nan) half @ret_nonan__unknown__fsub__inf(
|
|
; CHECK-SAME: half [[UNKNOWN:%.*]]) {
|
|
; CHECK-NEXT: [[INF:%.*]] = call half @returns_inf()
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub nnan half [[UNKNOWN]], [[INF]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%inf = call half @returns_inf()
|
|
%add = fsub half %unknown, %inf
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(nan) half @ret_nonan__inf__fsub__unknown(half %unknown) {
|
|
; CHECK-LABEL: define nofpclass(nan) half @ret_nonan__inf__fsub__unknown(
|
|
; CHECK-SAME: half [[UNKNOWN:%.*]]) {
|
|
; CHECK-NEXT: [[INF:%.*]] = call half @returns_inf()
|
|
; CHECK-NEXT: ret half [[INF]]
|
|
;
|
|
%inf = call half @returns_inf()
|
|
%add = fsub half %inf, %unknown
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(nan) half @ret_nonan__unknown__fsub__inf_or_nan(half %unknown) {
|
|
; CHECK-LABEL: define nofpclass(nan) half @ret_nonan__unknown__fsub__inf_or_nan(
|
|
; CHECK-SAME: half [[UNKNOWN:%.*]]) {
|
|
; CHECK-NEXT: [[INF_OR_NAN:%.*]] = call half @returns_inf_or_nan()
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub nnan half [[UNKNOWN]], [[INF_OR_NAN]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%inf.or.nan = call half @returns_inf_or_nan()
|
|
%add = fsub half %unknown, %inf.or.nan
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(nan) half @ret_nonan__inf_or_nan__fsub__unknown(half %unknown) {
|
|
; CHECK-LABEL: define nofpclass(nan) half @ret_nonan__inf_or_nan__fsub__unknown(
|
|
; CHECK-SAME: half [[UNKNOWN:%.*]]) {
|
|
; CHECK-NEXT: [[INF_OR_NAN:%.*]] = call half @returns_inf_or_nan()
|
|
; CHECK-NEXT: ret half [[INF_OR_NAN]]
|
|
;
|
|
%inf.or.nan = call half @returns_inf_or_nan()
|
|
%add = fsub half %inf.or.nan, %unknown
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(snan) half @unknown__fsub__zero(half %unknown) {
|
|
; CHECK-LABEL: define nofpclass(snan) half @unknown__fsub__zero(
|
|
; CHECK-SAME: half [[UNKNOWN:%.*]]) {
|
|
; CHECK-NEXT: [[ZERO:%.*]] = call half @returns_zero()
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub half [[UNKNOWN]], [[ZERO]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%zero = call half @returns_zero()
|
|
%add = fsub half %unknown, %zero
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(snan) half @zero__fsub__unknown(half %unknown) {
|
|
; CHECK-LABEL: define nofpclass(snan) half @zero__fsub__unknown(
|
|
; CHECK-SAME: half [[UNKNOWN:%.*]]) {
|
|
; CHECK-NEXT: [[ZERO:%.*]] = call half @returns_zero()
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub half [[ZERO]], [[UNKNOWN]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%zero = call half @returns_zero()
|
|
%add = fsub half %zero, %unknown
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(nan) half @ret_nonan__unknown__fsub__zero(half %unknown) {
|
|
; CHECK-LABEL: define nofpclass(nan) half @ret_nonan__unknown__fsub__zero(
|
|
; CHECK-SAME: half [[UNKNOWN:%.*]]) {
|
|
; CHECK-NEXT: [[ZERO:%.*]] = call half @returns_zero()
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub nnan half [[UNKNOWN]], [[ZERO]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%zero = call half @returns_zero()
|
|
%add = fsub half %unknown, %zero
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(nan) half @ret_nonan__zero__fsub__unknown(half %unknown) {
|
|
; CHECK-LABEL: define nofpclass(nan) half @ret_nonan__zero__fsub__unknown(
|
|
; CHECK-SAME: half [[UNKNOWN:%.*]]) {
|
|
; CHECK-NEXT: [[ZERO:%.*]] = call half @returns_zero()
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub nnan half [[ZERO]], [[UNKNOWN]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%zero = call half @returns_zero()
|
|
%add = fsub half %zero, %unknown
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(snan) half @unknown__fsub__pzero(half %unknown) {
|
|
; CHECK-LABEL: define nofpclass(snan) half @unknown__fsub__pzero(
|
|
; CHECK-SAME: half [[UNKNOWN:%.*]]) {
|
|
; CHECK-NEXT: [[PZERO:%.*]] = call half @returns_pzero()
|
|
; CHECK-NEXT: ret half [[UNKNOWN]]
|
|
;
|
|
%pzero = call half @returns_pzero()
|
|
%add = fsub half %unknown, %pzero
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(snan) half @pzero__fsub__unknown(half %unknown) {
|
|
; CHECK-LABEL: define nofpclass(snan) half @pzero__fsub__unknown(
|
|
; CHECK-SAME: half [[UNKNOWN:%.*]]) {
|
|
; CHECK-NEXT: [[PZERO:%.*]] = call half @returns_pzero()
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub half 0.000000e+00, [[UNKNOWN]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%pzero = call half @returns_pzero()
|
|
%add = fsub half %pzero, %unknown
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(nan) half @ret_nonan__unknown__fsub__pzero(half %unknown) {
|
|
; CHECK-LABEL: define nofpclass(nan) half @ret_nonan__unknown__fsub__pzero(
|
|
; CHECK-SAME: half [[UNKNOWN:%.*]]) {
|
|
; CHECK-NEXT: [[PZERO:%.*]] = call half @returns_pzero()
|
|
; CHECK-NEXT: ret half [[UNKNOWN]]
|
|
;
|
|
%pzero = call half @returns_pzero()
|
|
%add = fsub half %unknown, %pzero
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(nan) half @ret_nonan__pzero__fsub__unknown(half %unknown) {
|
|
; CHECK-LABEL: define nofpclass(nan) half @ret_nonan__pzero__fsub__unknown(
|
|
; CHECK-SAME: half [[UNKNOWN:%.*]]) {
|
|
; CHECK-NEXT: [[PZERO:%.*]] = call half @returns_pzero()
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub nnan half 0.000000e+00, [[UNKNOWN]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%pzero = call half @returns_pzero()
|
|
%add = fsub half %pzero, %unknown
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(snan) half @unknown__fsub__nzero(half %unknown) {
|
|
; CHECK-LABEL: define nofpclass(snan) half @unknown__fsub__nzero(
|
|
; CHECK-SAME: half [[UNKNOWN:%.*]]) {
|
|
; CHECK-NEXT: [[NZERO:%.*]] = call half @returns_nzero()
|
|
; CHECK-NEXT: [[ADD:%.*]] = fadd half [[UNKNOWN]], 0.000000e+00
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%nzero = call half @returns_nzero()
|
|
%add = fsub half %unknown, %nzero
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(snan) half @nzero__fsub__unknown(half %unknown) {
|
|
; CHECK-LABEL: define nofpclass(snan) half @nzero__fsub__unknown(
|
|
; CHECK-SAME: half [[UNKNOWN:%.*]]) {
|
|
; CHECK-NEXT: [[NZERO:%.*]] = call half @returns_nzero()
|
|
; CHECK-NEXT: [[ADD:%.*]] = fneg half [[UNKNOWN]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%nzero = call half @returns_nzero()
|
|
%add = fsub half %nzero, %unknown
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(snan) half @unknown__fsub__nzero_or_nan(half %unknown) {
|
|
; CHECK-LABEL: define nofpclass(snan) half @unknown__fsub__nzero_or_nan(
|
|
; CHECK-SAME: half [[UNKNOWN:%.*]]) {
|
|
; CHECK-NEXT: [[NZERO_OR_NAN:%.*]] = call half @returns_nzero_or_nan()
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub half [[UNKNOWN]], [[NZERO_OR_NAN]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%nzero.or.nan = call half @returns_nzero_or_nan()
|
|
%add = fsub half %unknown, %nzero.or.nan
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(snan) half @nzero_or_nan__fsub__unknown(half %unknown) {
|
|
; CHECK-LABEL: define nofpclass(snan) half @nzero_or_nan__fsub__unknown(
|
|
; CHECK-SAME: half [[UNKNOWN:%.*]]) {
|
|
; CHECK-NEXT: [[NZERO_OR_NAN:%.*]] = call half @returns_nzero_or_nan()
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub half [[NZERO_OR_NAN]], [[UNKNOWN]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%nzero.or.nan = call half @returns_nzero_or_nan()
|
|
%add = fsub half %nzero.or.nan, %unknown
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(nan) half @ret_nonan__unknown__fsub__nzero(half %unknown) {
|
|
; CHECK-LABEL: define nofpclass(nan) half @ret_nonan__unknown__fsub__nzero(
|
|
; CHECK-SAME: half [[UNKNOWN:%.*]]) {
|
|
; CHECK-NEXT: [[NZERO:%.*]] = call half @returns_nzero()
|
|
; CHECK-NEXT: [[ADD:%.*]] = fadd nnan half [[UNKNOWN]], 0.000000e+00
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%nzero = call half @returns_nzero()
|
|
%add = fsub half %unknown, %nzero
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(nan) half @ret_nonan__nzero__fsub__unknown(half %unknown) {
|
|
; CHECK-LABEL: define nofpclass(nan) half @ret_nonan__nzero__fsub__unknown(
|
|
; CHECK-SAME: half [[UNKNOWN:%.*]]) {
|
|
; CHECK-NEXT: [[NZERO:%.*]] = call half @returns_nzero()
|
|
; CHECK-NEXT: [[ADD:%.*]] = fneg half [[UNKNOWN]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%nzero = call half @returns_nzero()
|
|
%add = fsub half %nzero, %unknown
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(snan) half @not_nzero__fsub__zero(half nofpclass(nzero) %not.nzero) {
|
|
; CHECK-LABEL: define nofpclass(snan) half @not_nzero__fsub__zero(
|
|
; CHECK-SAME: half nofpclass(nzero) [[NOT_NZERO:%.*]]) {
|
|
; CHECK-NEXT: [[ZERO:%.*]] = call half @returns_zero()
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub half [[NOT_NZERO]], [[ZERO]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%zero = call half @returns_zero()
|
|
%add = fsub half %not.nzero, %zero
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(snan) half @zero__fsub__not_nzero(half nofpclass(nzero) %not.nzero) {
|
|
; CHECK-LABEL: define nofpclass(snan) half @zero__fsub__not_nzero(
|
|
; CHECK-SAME: half nofpclass(nzero) [[NOT_NZERO:%.*]]) {
|
|
; CHECK-NEXT: [[ZERO:%.*]] = call half @returns_zero()
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub half [[ZERO]], [[NOT_NZERO]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%zero = call half @returns_zero()
|
|
%add = fsub half %zero, %not.nzero
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(snan) half @not_nzero__fsub__pzero(half nofpclass(nzero) %not.nzero) {
|
|
; CHECK-LABEL: define nofpclass(snan) half @not_nzero__fsub__pzero(
|
|
; CHECK-SAME: half nofpclass(nzero) [[NOT_NZERO:%.*]]) {
|
|
; CHECK-NEXT: [[PZERO:%.*]] = call half @returns_pzero()
|
|
; CHECK-NEXT: ret half [[NOT_NZERO]]
|
|
;
|
|
%pzero = call half @returns_pzero()
|
|
%add = fsub half %not.nzero, %pzero
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(snan) half @pzero__fsub__not_nzero(half nofpclass(nzero) %not.nzero) {
|
|
; CHECK-LABEL: define nofpclass(snan) half @pzero__fsub__not_nzero(
|
|
; CHECK-SAME: half nofpclass(nzero) [[NOT_NZERO:%.*]]) {
|
|
; CHECK-NEXT: [[PZERO:%.*]] = call half @returns_pzero()
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub half 0.000000e+00, [[NOT_NZERO]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%pzero = call half @returns_pzero()
|
|
%add = fsub half %pzero, %not.nzero
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(snan) half @not_nzero__fsub__zero_or_nan(half nofpclass(nzero) %not.nzero) {
|
|
; CHECK-LABEL: define nofpclass(snan) half @not_nzero__fsub__zero_or_nan(
|
|
; CHECK-SAME: half nofpclass(nzero) [[NOT_NZERO:%.*]]) {
|
|
; CHECK-NEXT: [[ZERO_OR_NAN:%.*]] = call half @returns_zero_or_nan()
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub half [[NOT_NZERO]], [[ZERO_OR_NAN]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%zero.or.nan = call half @returns_zero_or_nan()
|
|
%add = fsub half %not.nzero, %zero.or.nan
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(snan) half @zero_or_nan__fsub__not_nzero(half nofpclass(nzero) %not.nzero) {
|
|
; CHECK-LABEL: define nofpclass(snan) half @zero_or_nan__fsub__not_nzero(
|
|
; CHECK-SAME: half nofpclass(nzero) [[NOT_NZERO:%.*]]) {
|
|
; CHECK-NEXT: [[ZERO_OR_NAN:%.*]] = call half @returns_zero_or_nan()
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub half [[ZERO_OR_NAN]], [[NOT_NZERO]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%zero.or.nan = call half @returns_zero_or_nan()
|
|
%add = fsub half %zero.or.nan, %not.nzero
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(snan) half @not_nzero__fsub__pzero_or_nan(half nofpclass(nzero) %not.nzero) {
|
|
; CHECK-LABEL: define nofpclass(snan) half @not_nzero__fsub__pzero_or_nan(
|
|
; CHECK-SAME: half nofpclass(nzero) [[NOT_NZERO:%.*]]) {
|
|
; CHECK-NEXT: [[PZERO_OR_NAN:%.*]] = call half @returns_pzero_or_nan()
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub half [[NOT_NZERO]], [[PZERO_OR_NAN]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%pzero.or.nan = call half @returns_pzero_or_nan()
|
|
%add = fsub half %not.nzero, %pzero.or.nan
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(snan) half @pzero_or_nan__fsub__not_nzero(half nofpclass(nzero) %not.nzero) {
|
|
; CHECK-LABEL: define nofpclass(snan) half @pzero_or_nan__fsub__not_nzero(
|
|
; CHECK-SAME: half nofpclass(nzero) [[NOT_NZERO:%.*]]) {
|
|
; CHECK-NEXT: [[PZERO_OR_NAN:%.*]] = call half @returns_pzero_or_nan()
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub half [[PZERO_OR_NAN]], [[NOT_NZERO]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%pzero.or.nan = call half @returns_pzero_or_nan()
|
|
%add = fsub half %pzero.or.nan, %not.nzero
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(snan) half @unknown__fsub_nsz__pzero(half %unknown) {
|
|
; CHECK-LABEL: define nofpclass(snan) half @unknown__fsub_nsz__pzero(
|
|
; CHECK-SAME: half [[UNKNOWN:%.*]]) {
|
|
; CHECK-NEXT: [[PZERO:%.*]] = call half @returns_pzero()
|
|
; CHECK-NEXT: ret half [[UNKNOWN]]
|
|
;
|
|
%pzero = call half @returns_pzero()
|
|
%add = fsub nsz half %unknown, %pzero
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(snan) half @pzero__fsub_nsz__unknown(half %unknown) {
|
|
; CHECK-LABEL: define nofpclass(snan) half @pzero__fsub_nsz__unknown(
|
|
; CHECK-SAME: half [[UNKNOWN:%.*]]) {
|
|
; CHECK-NEXT: [[PZERO:%.*]] = call half @returns_pzero()
|
|
; CHECK-NEXT: [[ADD:%.*]] = fneg nsz half [[UNKNOWN]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%pzero = call half @returns_pzero()
|
|
%add = fsub nsz half %pzero, %unknown
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(snan) half @unknown__fsub_nsz__pzero_or_nan(half %unknown) {
|
|
; CHECK-LABEL: define nofpclass(snan) half @unknown__fsub_nsz__pzero_or_nan(
|
|
; CHECK-SAME: half [[UNKNOWN:%.*]]) {
|
|
; CHECK-NEXT: [[PZERO_OR_NAN:%.*]] = call half @returns_pzero()
|
|
; CHECK-NEXT: ret half [[UNKNOWN]]
|
|
;
|
|
%pzero.or.nan = call half @returns_pzero()
|
|
%add = fsub nsz half %unknown, %pzero.or.nan
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(snan) half @pzero_or_nan__fsub_nsz__unknown(half %unknown) {
|
|
; CHECK-LABEL: define nofpclass(snan) half @pzero_or_nan__fsub_nsz__unknown(
|
|
; CHECK-SAME: half [[UNKNOWN:%.*]]) {
|
|
; CHECK-NEXT: [[PZERO_OR_NAN:%.*]] = call half @returns_pzero_or_nan()
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub nsz half [[PZERO_OR_NAN]], [[UNKNOWN]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%pzero.or.nan = call half @returns_pzero_or_nan()
|
|
%add = fsub nsz half %pzero.or.nan, %unknown
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(snan) half @unknown__fsub_nsz__zero(half %unknown) {
|
|
; CHECK-LABEL: define nofpclass(snan) half @unknown__fsub_nsz__zero(
|
|
; CHECK-SAME: half [[UNKNOWN:%.*]]) {
|
|
; CHECK-NEXT: [[ZERO:%.*]] = call half @returns_zero()
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub nsz half [[UNKNOWN]], [[ZERO]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%zero = call half @returns_zero()
|
|
%add = fsub nsz half %unknown, %zero
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(snan) half @zero__fsub_nsz__unknown(half %unknown) {
|
|
; CHECK-LABEL: define nofpclass(snan) half @zero__fsub_nsz__unknown(
|
|
; CHECK-SAME: half [[UNKNOWN:%.*]]) {
|
|
; CHECK-NEXT: [[ZERO:%.*]] = call half @returns_zero()
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub nsz half [[ZERO]], [[UNKNOWN]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%zero = call half @returns_zero()
|
|
%add = fsub nsz half %zero, %unknown
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(snan) half @unknown__fsub_nsz__zero_or_nan(half %unknown) {
|
|
; CHECK-LABEL: define nofpclass(snan) half @unknown__fsub_nsz__zero_or_nan(
|
|
; CHECK-SAME: half [[UNKNOWN:%.*]]) {
|
|
; CHECK-NEXT: [[ZERO_OR_NAN:%.*]] = call half @returns_zero()
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub nsz half [[UNKNOWN]], [[ZERO_OR_NAN]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%zero.or.nan = call half @returns_zero()
|
|
%add = fsub nsz half %unknown, %zero.or.nan
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(snan) half @zero_or_nan__fsub_nsz__unknown(half %unknown) {
|
|
; CHECK-LABEL: define nofpclass(snan) half @zero_or_nan__fsub_nsz__unknown(
|
|
; CHECK-SAME: half [[UNKNOWN:%.*]]) {
|
|
; CHECK-NEXT: [[ZERO_OR_NAN:%.*]] = call half @returns_zero_or_nan()
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub nsz half [[ZERO_OR_NAN]], [[UNKNOWN]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%zero.or.nan = call half @returns_zero_or_nan()
|
|
%add = fsub nsz half %zero.or.nan, %unknown
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(inf) half @nan_result_demands_nan_input_lhs(i1 %cond, half %unknown, half nofpclass(inf nan zero sub) %normal) {
|
|
; CHECK-LABEL: define nofpclass(inf) half @nan_result_demands_nan_input_lhs(
|
|
; CHECK-SAME: i1 [[COND:%.*]], half [[UNKNOWN:%.*]], half nofpclass(nan inf zero sub) [[NORMAL:%.*]]) {
|
|
; CHECK-NEXT: [[NAN:%.*]] = call half @returns_nan()
|
|
; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND]], half [[NAN]], half [[UNKNOWN]]
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub half [[SELECT]], [[NORMAL]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%nan = call half @returns_nan()
|
|
%select = select i1 %cond, half %nan, half %unknown
|
|
%add = fsub half %select, %normal
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(inf) half @nan_result_demands_nan_input_rhs(i1 %cond, half %unknown, half nofpclass(inf nan zero sub) %normal) {
|
|
; CHECK-LABEL: define nofpclass(inf) half @nan_result_demands_nan_input_rhs(
|
|
; CHECK-SAME: i1 [[COND:%.*]], half [[UNKNOWN:%.*]], half nofpclass(nan inf zero sub) [[NORMAL:%.*]]) {
|
|
; CHECK-NEXT: [[NAN:%.*]] = call half @returns_nan()
|
|
; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND]], half [[NAN]], half [[UNKNOWN]]
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub half [[NORMAL]], [[SELECT]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%nan = call half @returns_nan()
|
|
%select = select i1 %cond, half %nan, half %unknown
|
|
%add = fsub half %normal, %select
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(snan) half @not_nzero__fsub__pzero__daz(half nofpclass(nzero) %not.nzero) #0 {
|
|
; CHECK-LABEL: define nofpclass(snan) half @not_nzero__fsub__pzero__daz(
|
|
; CHECK-SAME: half nofpclass(nzero) [[NOT_NZERO:%.*]]) #[[ATTR0:[0-9]+]] {
|
|
; CHECK-NEXT: [[PZERO:%.*]] = call half @returns_pzero()
|
|
; CHECK-NEXT: ret half [[NOT_NZERO]]
|
|
;
|
|
%pzero = call half @returns_pzero()
|
|
%add = fsub half %not.nzero, %pzero
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(snan) half @pzero__fsub__not_nzero__daz(half nofpclass(nzero) %not.nzero) #0 {
|
|
; CHECK-LABEL: define nofpclass(snan) half @pzero__fsub__not_nzero__daz(
|
|
; CHECK-SAME: half nofpclass(nzero) [[NOT_NZERO:%.*]]) #[[ATTR0]] {
|
|
; CHECK-NEXT: [[PZERO:%.*]] = call half @returns_pzero()
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub half 0.000000e+00, [[NOT_NZERO]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%pzero = call half @returns_pzero()
|
|
%add = fsub half %pzero, %not.nzero
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(snan) half @not_nzero__fsub__pzero__dynamic(half nofpclass(nzero) %not.nzero) #1 {
|
|
; CHECK-LABEL: define nofpclass(snan) half @not_nzero__fsub__pzero__dynamic(
|
|
; CHECK-SAME: half nofpclass(nzero) [[NOT_NZERO:%.*]]) #[[ATTR1:[0-9]+]] {
|
|
; CHECK-NEXT: [[PZERO:%.*]] = call half @returns_pzero()
|
|
; CHECK-NEXT: ret half [[NOT_NZERO]]
|
|
;
|
|
%pzero = call half @returns_pzero()
|
|
%add = fsub half %not.nzero, %pzero
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(snan) half @pzero__fsub__not_nzero__dynamic(half nofpclass(nzero) %not.nzero) #1 {
|
|
; CHECK-LABEL: define nofpclass(snan) half @pzero__fsub__not_nzero__dynamic(
|
|
; CHECK-SAME: half nofpclass(nzero) [[NOT_NZERO:%.*]]) #[[ATTR1]] {
|
|
; CHECK-NEXT: [[PZERO:%.*]] = call half @returns_pzero()
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub half 0.000000e+00, [[NOT_NZERO]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%pzero = call half @returns_pzero()
|
|
%add = fsub half %pzero, %not.nzero
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(snan) half @not_nzero_nsub__fsub__pzero__daz(half nofpclass(nzero nsub) %not.nzero.nsub) #0 {
|
|
; CHECK-LABEL: define nofpclass(snan) half @not_nzero_nsub__fsub__pzero__daz(
|
|
; CHECK-SAME: half nofpclass(nzero nsub) [[NOT_NZERO_NSUB:%.*]]) #[[ATTR0]] {
|
|
; CHECK-NEXT: [[PZERO:%.*]] = call half @returns_pzero()
|
|
; CHECK-NEXT: ret half [[NOT_NZERO_NSUB]]
|
|
;
|
|
%pzero = call half @returns_pzero()
|
|
%add = fsub half %not.nzero.nsub, %pzero
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(snan) half @pzero__fsub__not_nzero_nsub__daz(half nofpclass(nzero nsub) %not.nzero.nsub) #0 {
|
|
; CHECK-LABEL: define nofpclass(snan) half @pzero__fsub__not_nzero_nsub__daz(
|
|
; CHECK-SAME: half nofpclass(nzero nsub) [[NOT_NZERO_NSUB:%.*]]) #[[ATTR0]] {
|
|
; CHECK-NEXT: [[PZERO:%.*]] = call half @returns_pzero()
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub half 0.000000e+00, [[NOT_NZERO_NSUB]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%pzero = call half @returns_pzero()
|
|
%add = fsub half %pzero, %not.nzero.nsub
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(snan) half @not_nzero_nsub__fsub__pzero__dynamic(half nofpclass(nzero nsub) %not.nzero.nsub) #1 {
|
|
; CHECK-LABEL: define nofpclass(snan) half @not_nzero_nsub__fsub__pzero__dynamic(
|
|
; CHECK-SAME: half nofpclass(nzero nsub) [[NOT_NZERO_NSUB:%.*]]) #[[ATTR1]] {
|
|
; CHECK-NEXT: [[PZERO:%.*]] = call half @returns_pzero()
|
|
; CHECK-NEXT: ret half [[NOT_NZERO_NSUB]]
|
|
;
|
|
%pzero = call half @returns_pzero()
|
|
%add = fsub half %not.nzero.nsub, %pzero
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(snan) half @pzero__fsub__not_nzero_nsub__dynamic(half nofpclass(nzero nsub) %not.nzero.nsub) #1 {
|
|
; CHECK-LABEL: define nofpclass(snan) half @pzero__fsub__not_nzero_nsub__dynamic(
|
|
; CHECK-SAME: half nofpclass(nzero nsub) [[NOT_NZERO_NSUB:%.*]]) #[[ATTR1]] {
|
|
; CHECK-NEXT: [[PZERO:%.*]] = call half @returns_pzero()
|
|
; CHECK-NEXT: [[ADD:%.*]] = fsub half 0.000000e+00, [[NOT_NZERO_NSUB]]
|
|
; CHECK-NEXT: ret half [[ADD]]
|
|
;
|
|
%pzero = call half @returns_pzero()
|
|
%add = fsub half %pzero, %not.nzero.nsub
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(nan) half @ret_nonan__fsub_self__nonan(i1 %cond, half noundef %unknown) {
|
|
; CHECK-LABEL: define nofpclass(nan) half @ret_nonan__fsub_self__nonan(
|
|
; CHECK-SAME: i1 [[COND:%.*]], half noundef [[UNKNOWN:%.*]]) {
|
|
; CHECK-NEXT: [[NAN:%.*]] = call noundef half @returns_nan()
|
|
; CHECK-NEXT: ret half 0.000000e+00
|
|
;
|
|
%nan = call noundef half @returns_nan()
|
|
%select = select i1 %cond, half %nan, half %unknown
|
|
%add = fsub half %select, %select
|
|
ret half %add
|
|
}
|
|
|
|
define nofpclass(nan) half @ret_nonan_fneg_fabs_fsub_known_negative_or_nan_sources() {
|
|
; CHECK-LABEL: define nofpclass(nan) half @ret_nonan_fneg_fabs_fsub_known_negative_or_nan_sources() {
|
|
; CHECK-NEXT: [[NEGATIVE_OR_NAN0:%.*]] = call half @returns_negative_or_nan()
|
|
; CHECK-NEXT: [[NEGATIVE_OR_NAN1:%.*]] = call half @returns_negative_or_nan()
|
|
; CHECK-NEXT: [[KNOWN_NEGATIVE_SUB:%.*]] = fsub nnan half [[NEGATIVE_OR_NAN0]], [[NEGATIVE_OR_NAN1]]
|
|
; CHECK-NEXT: [[FABS:%.*]] = call half @llvm.fabs.f16(half [[KNOWN_NEGATIVE_SUB]])
|
|
; CHECK-NEXT: [[NEG_FABS:%.*]] = fneg half [[FABS]]
|
|
; CHECK-NEXT: ret half [[NEG_FABS]]
|
|
;
|
|
%negative.or.nan0 = call half @returns_negative_or_nan()
|
|
%negative.or.nan1 = call half @returns_negative_or_nan()
|
|
%known.negative.sub = fsub half %negative.or.nan0, %negative.or.nan1
|
|
%fabs = call half @llvm.fabs.f16(half %known.negative.sub)
|
|
%neg.fabs = fneg half %fabs
|
|
ret half %neg.fabs
|
|
}
|
|
|
|
define nofpclass(nan) half @ret_nonan_fneg_fabs_fsub_known_negative_sources() {
|
|
; CHECK-LABEL: define nofpclass(nan) half @ret_nonan_fneg_fabs_fsub_known_negative_sources() {
|
|
; CHECK-NEXT: [[NEGATIVE0:%.*]] = call half @returns_negative()
|
|
; CHECK-NEXT: [[NEGATIVE1:%.*]] = call half @returns_negative()
|
|
; CHECK-NEXT: [[KNOWN_NEGATIVE_OP:%.*]] = fsub nnan half [[NEGATIVE0]], [[NEGATIVE1]]
|
|
; CHECK-NEXT: [[FABS:%.*]] = call half @llvm.fabs.f16(half [[KNOWN_NEGATIVE_OP]])
|
|
; CHECK-NEXT: [[NEG_FABS:%.*]] = fneg half [[FABS]]
|
|
; CHECK-NEXT: ret half [[NEG_FABS]]
|
|
;
|
|
%negative0 = call half @returns_negative()
|
|
%negative1 = call half @returns_negative()
|
|
%known.negative.op = fsub half %negative0, %negative1
|
|
%fabs = call half @llvm.fabs.f16(half %known.negative.op)
|
|
%neg.fabs = fneg half %fabs
|
|
ret half %neg.fabs
|
|
}
|
|
|
|
define nofpclass(snan) half @ret_no_snan__known_positive_or_nan__fsub__known_negative_or_nan() {
|
|
; CHECK-LABEL: define nofpclass(snan) half @ret_no_snan__known_positive_or_nan__fsub__known_negative_or_nan() {
|
|
; CHECK-NEXT: [[POSITIVE_OR_NAN:%.*]] = call half @returns_positive_or_nan()
|
|
; CHECK-NEXT: [[NEGATIVE_OR_NAN:%.*]] = call half @returns_negative_or_nan()
|
|
; CHECK-NEXT: [[RESULT:%.*]] = fsub half [[POSITIVE_OR_NAN]], [[NEGATIVE_OR_NAN]]
|
|
; CHECK-NEXT: ret half [[RESULT]]
|
|
;
|
|
%positive.or.nan = call half @returns_positive_or_nan()
|
|
%negative.or.nan = call half @returns_negative_or_nan()
|
|
%result = fsub half %positive.or.nan, %negative.or.nan
|
|
ret half %result
|
|
}
|
|
|
|
define nofpclass(snan) half @ret_no_snan__known_negative_or_nan__fsub__known_positive_or_nan() {
|
|
; CHECK-LABEL: define nofpclass(snan) half @ret_no_snan__known_negative_or_nan__fsub__known_positive_or_nan() {
|
|
; CHECK-NEXT: [[NEGATIVE_OR_NAN:%.*]] = call half @returns_negative_or_nan()
|
|
; CHECK-NEXT: [[POSITIVE_OR_NAN:%.*]] = call half @returns_positive_or_nan()
|
|
; CHECK-NEXT: [[RESULT:%.*]] = fsub half [[NEGATIVE_OR_NAN]], [[POSITIVE_OR_NAN]]
|
|
; CHECK-NEXT: ret half [[RESULT]]
|
|
;
|
|
%negative.or.nan = call half @returns_negative_or_nan()
|
|
%positive.or.nan = call half @returns_positive_or_nan()
|
|
%result = fsub half %negative.or.nan, %positive.or.nan
|
|
ret half %result
|
|
}
|
|
|
|
define nofpclass(snan) half @ret_no_snan__known_positive__fsub__known_negative() {
|
|
; CHECK-LABEL: define nofpclass(snan) half @ret_no_snan__known_positive__fsub__known_negative() {
|
|
; CHECK-NEXT: [[POSITIVE:%.*]] = call half @returns_positive_or_nan()
|
|
; CHECK-NEXT: [[NEGATIVE:%.*]] = call half @returns_negative_or_nan()
|
|
; CHECK-NEXT: [[RESULT:%.*]] = fsub half [[POSITIVE]], [[NEGATIVE]]
|
|
; CHECK-NEXT: ret half [[RESULT]]
|
|
;
|
|
%positive = call half @returns_positive_or_nan()
|
|
%negative = call half @returns_negative_or_nan()
|
|
%result = fsub half %positive, %negative
|
|
ret half %result
|
|
}
|
|
|
|
define nofpclass(snan) half @ret_no_snan__known_negative__fsub__known_positive() {
|
|
; CHECK-LABEL: define nofpclass(snan) half @ret_no_snan__known_negative__fsub__known_positive() {
|
|
; CHECK-NEXT: [[NEGATIVE:%.*]] = call half @returns_negative_or_nan()
|
|
; CHECK-NEXT: [[POSITIVE:%.*]] = call half @returns_positive_or_nan()
|
|
; CHECK-NEXT: [[RESULT:%.*]] = fsub half [[NEGATIVE]], [[POSITIVE]]
|
|
; CHECK-NEXT: ret half [[RESULT]]
|
|
;
|
|
%negative = call half @returns_negative_or_nan()
|
|
%positive = call half @returns_positive_or_nan()
|
|
%result = fsub half %negative, %positive
|
|
ret half %result
|
|
}
|
|
|
|
define nofpclass(snan) half @qnan_result_demands_snan_lhs(i1 %cond, half %unknown0, half %unknown1) {
|
|
; CHECK-LABEL: define nofpclass(snan) half @qnan_result_demands_snan_lhs(
|
|
; CHECK-SAME: i1 [[COND:%.*]], half [[UNKNOWN0:%.*]], half [[UNKNOWN1:%.*]]) {
|
|
; CHECK-NEXT: [[SNAN:%.*]] = call half @returns_snan()
|
|
; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND]], half [[SNAN]], half [[UNKNOWN0]]
|
|
; CHECK-NEXT: [[RESULT:%.*]] = fsub half [[SELECT]], [[UNKNOWN1]]
|
|
; CHECK-NEXT: ret half [[RESULT]]
|
|
;
|
|
%snan = call half @returns_snan()
|
|
%select = select i1 %cond, half %snan, half %unknown0
|
|
%result = fsub half %select, %unknown1
|
|
ret half %result
|
|
}
|
|
|
|
define nofpclass(snan) half @qnan_result_demands_snan_rhs(i1 %cond, half %unknown0, half %unknown1) {
|
|
; CHECK-LABEL: define nofpclass(snan) half @qnan_result_demands_snan_rhs(
|
|
; CHECK-SAME: i1 [[COND:%.*]], half [[UNKNOWN0:%.*]], half [[UNKNOWN1:%.*]]) {
|
|
; CHECK-NEXT: [[SNAN:%.*]] = call half @returns_snan()
|
|
; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND]], half [[SNAN]], half [[UNKNOWN0]]
|
|
; CHECK-NEXT: [[RESULT:%.*]] = fsub half [[UNKNOWN1]], [[SELECT]]
|
|
; CHECK-NEXT: ret half [[RESULT]]
|
|
;
|
|
%snan = call half @returns_snan()
|
|
%select = select i1 %cond, half %snan, half %unknown0
|
|
%result = fsub half %unknown1, %select
|
|
ret half %result
|
|
}
|
|
|
|
attributes #0 = { denormal_fpenv(preservesign) }
|
|
attributes #1 = { denormal_fpenv(dynamic) }
|