TheRock/compiler/amd-llvm/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-fpext.ll

; 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(inf norm sub zero) half @returns_nan_f16()
declare nofpclass(qnan inf norm sub zero) half @returns_snan_f16()
declare nofpclass(nan ninf norm sub zero) half @returns_pinf_f16()
declare nofpclass(nan pinf norm sub zero) half @returns_ninf_f16()
declare nofpclass(nan norm sub zero) half @returns_inf_f16()
declare nofpclass(norm sub zero) half @returns_inf_or_nan_f16()

declare nofpclass(inf nan norm psub zero) half @returns_nsub_f16()
declare nofpclass(inf nan norm nsub zero) half @returns_psub_f16()
declare nofpclass(inf nan norm zero) half @returns_sub_f16()

declare nofpclass(nan pinf pnorm psub pzero) half @returns_negative_f16()
declare nofpclass(pinf pnorm psub pzero) half @returns_negative_or_nan_f16()

declare nofpclass(nan ninf nnorm nsub nzero) half @returns_positive_f16()
declare nofpclass(ninf nnorm nsub nzero) half @returns_positive_or_nan_f16()

declare nofpclass(nan inf norm sub) half @returns_zero_f16()
declare nofpclass(nan inf norm sub pzero) half @returns_nzero_f16()
declare nofpclass(nan inf norm sub nzero) half @returns_pzero_f16()
declare nofpclass(inf norm sub) half @returns_zero_or_nan_f16()


define nofpclass(inf norm sub zero qnan) float @ret_only_snan__fpext(half %x) {
; CHECK-LABEL: define nofpclass(qnan inf zero sub norm) float @ret_only_snan__fpext(
; CHECK-SAME: half [[X:%.*]]) {
; CHECK-NEXT:    [[RESULT:%.*]] = fpext ninf half [[X]] to float
; CHECK-NEXT:    ret float [[RESULT]]
;
  %result = fpext half %x to float
  ret float %result
}

define nofpclass(inf norm sub zero snan) float @ret_only_qnan__fpext(half %x) {
; CHECK-LABEL: define nofpclass(snan inf zero sub norm) float @ret_only_qnan__fpext(
; CHECK-SAME: half [[X:%.*]]) {
; CHECK-NEXT:    ret float +qnan
;
  %result = fpext half %x to float
  ret float %result
}

define nofpclass(inf norm sub zero) float @ret_only_nan__fpext(half %x) {
; CHECK-LABEL: define nofpclass(inf zero sub norm) float @ret_only_nan__fpext(
; CHECK-SAME: half [[X:%.*]]) {
; CHECK-NEXT:    ret float +qnan
;
  %result = fpext half %x to float
  ret float %result
}

define nofpclass(nan norm sub zero) float @ret_only_inf__fpext(half %x) {
; CHECK-LABEL: define nofpclass(nan zero sub norm) float @ret_only_inf__fpext(
; CHECK-SAME: half [[X:%.*]]) {
; CHECK-NEXT:    [[RESULT:%.*]] = fpext nnan half [[X]] to float
; CHECK-NEXT:    ret float [[RESULT]]
;
  %result = fpext half %x to float
  ret float %result
}

define nofpclass(nan pinf norm sub zero) float @ret_only_ninf__fpext(half %x) {
; CHECK-LABEL: define nofpclass(nan pinf zero sub norm) float @ret_only_ninf__fpext(
; CHECK-SAME: half [[X:%.*]]) {
; CHECK-NEXT:    ret float -inf
;
  %result = fpext half %x to float
  ret float %result
}

define nofpclass(nan ninf norm sub zero) float @ret_only_pinf__fpext(half %x) {
; CHECK-LABEL: define nofpclass(nan ninf zero sub norm) float @ret_only_pinf__fpext(
; CHECK-SAME: half [[X:%.*]]) {
; CHECK-NEXT:    ret float +inf
;
  %result = fpext half %x to float
  ret float %result
}

define nofpclass(inf nan norm sub) float @ret_only_zero__fpext(half %x) {
; CHECK-LABEL: define nofpclass(nan inf sub norm) float @ret_only_zero__fpext(
; CHECK-SAME: half [[X:%.*]]) {
; CHECK-NEXT:    [[RESULT:%.*]] = fpext nnan ninf half [[X]] to float
; CHECK-NEXT:    ret float [[RESULT]]
;
  %result = fpext half %x to float
  ret float %result
}

define nofpclass(inf nan norm sub nzero) float @ret_only_pzero__fpext(half %x) {
; CHECK-LABEL: define nofpclass(nan inf nzero sub norm) float @ret_only_pzero__fpext(
; CHECK-SAME: half [[X:%.*]]) {
; CHECK-NEXT:    ret float 0.000000e+00
;
  %result = fpext half %x to float
  ret float %result
}

define nofpclass(inf nan norm sub pzero) float @ret_only_nzero__fpext(half %x) {
; CHECK-LABEL: define nofpclass(nan inf pzero sub norm) float @ret_only_nzero__fpext(
; CHECK-SAME: half [[X:%.*]]) {
; CHECK-NEXT:    ret float -0.000000e+00
;
  %result = fpext half %x to float
  ret float %result
}

; Fold out select
define nofpclass(nan) float @ret_no_nan__fpext__select_nan_or_unknown(i1 %cond, half %unknown) {
; CHECK-LABEL: define nofpclass(nan) float @ret_no_nan__fpext__select_nan_or_unknown(
; CHECK-SAME: i1 [[COND:%.*]], half [[UNKNOWN:%.*]]) {
; CHECK-NEXT:    [[NAN:%.*]] = call half @returns_nan_f16()
; CHECK-NEXT:    [[RESULT:%.*]] = fpext nnan half [[UNKNOWN]] to float
; CHECK-NEXT:    ret float [[RESULT]]
;
  %nan = call half @returns_nan_f16()
  %select = select i1 %cond, half %nan, half %unknown
  %result = fpext half %select to float
  ret float %result
}

; Fold out select
define nofpclass(pinf) float @ret_no_pinf__fpext__select_pinf_or_unknown(i1 %cond, half %unknown) {
; CHECK-LABEL: define nofpclass(pinf) float @ret_no_pinf__fpext__select_pinf_or_unknown(
; CHECK-SAME: i1 [[COND:%.*]], half [[UNKNOWN:%.*]]) {
; CHECK-NEXT:    [[PINF:%.*]] = call half @returns_pinf_f16()
; CHECK-NEXT:    [[RESULT:%.*]] = fpext half [[UNKNOWN]] to float
; CHECK-NEXT:    ret float [[RESULT]]
;
  %pinf = call half @returns_pinf_f16()
  %select = select i1 %cond, half %pinf, half %unknown
  %result = fpext half %select to float
  ret float %result
}

; Fold out select
define nofpclass(ninf) float @ret_no_ninf__fpext__select_ninf_or_unknown(i1 %cond, half %unknown) {
; CHECK-LABEL: define nofpclass(ninf) float @ret_no_ninf__fpext__select_ninf_or_unknown(
; CHECK-SAME: i1 [[COND:%.*]], half [[UNKNOWN:%.*]]) {
; CHECK-NEXT:    [[NINF:%.*]] = call half @returns_ninf_f16()
; CHECK-NEXT:    [[RESULT:%.*]] = fpext half [[UNKNOWN]] to float
; CHECK-NEXT:    ret float [[RESULT]]
;
  %ninf = call half @returns_ninf_f16()
  %select = select i1 %cond, half %ninf, half %unknown
  %result = fpext half %select to float
  ret float %result
}

; Fold out select
define nofpclass(inf) float @ret_no_inf__fpext__select_inf_or_unknown(i1 %cond, half %unknown) {
; CHECK-LABEL: define nofpclass(inf) float @ret_no_inf__fpext__select_inf_or_unknown(
; CHECK-SAME: i1 [[COND:%.*]], half [[UNKNOWN:%.*]]) {
; CHECK-NEXT:    [[INF:%.*]] = call half @returns_inf_f16()
; CHECK-NEXT:    [[RESULT:%.*]] = fpext ninf half [[UNKNOWN]] to float
; CHECK-NEXT:    ret float [[RESULT]]
;
  %inf = call half @returns_inf_f16()
  %select = select i1 %cond, half %inf, half %unknown
  %result = fpext half %select to float
  ret float %result
}

; Fold out select
define nofpclass(nan inf) float @ret_no_inf_no_nan__fpext__select_inf_or_nan_or_unknown(i1 %cond, half %unknown) {
; CHECK-LABEL: define nofpclass(nan inf) float @ret_no_inf_no_nan__fpext__select_inf_or_nan_or_unknown(
; CHECK-SAME: i1 [[COND:%.*]], half [[UNKNOWN:%.*]]) {
; CHECK-NEXT:    [[INF_OR_NAN:%.*]] = call half @returns_inf_or_nan_f16()
; CHECK-NEXT:    [[RESULT:%.*]] = fpext nnan ninf half [[UNKNOWN]] to float
; CHECK-NEXT:    ret float [[RESULT]]
;
  %inf.or.nan = call half @returns_inf_or_nan_f16()
  %select = select i1 %cond, half %inf.or.nan, half %unknown
  %result = fpext half %select to float
  ret float %result
}

; Do not delete select, no subnormal result does not imply no
; subnormal source.
define nofpclass(nsub) float @ret_no_nsub__fpext__select_nsub_or_unknown(i1 %cond, half %unknown) {
; CHECK-LABEL: define nofpclass(nsub) float @ret_no_nsub__fpext__select_nsub_or_unknown(
; CHECK-SAME: i1 [[COND:%.*]], half [[UNKNOWN:%.*]]) {
; CHECK-NEXT:    [[NSUB:%.*]] = call half @returns_nsub_f16()
; CHECK-NEXT:    [[SELECT:%.*]] = select i1 [[COND]], half [[NSUB]], half [[UNKNOWN]]
; CHECK-NEXT:    [[RESULT:%.*]] = fpext half [[SELECT]] to float
; CHECK-NEXT:    ret float [[RESULT]]
;
  %nsub = call half @returns_nsub_f16()
  %select = select i1 %cond, half %nsub, half %unknown
  %result = fpext half %select to float
  ret float %result
}

; Do not delete select, no subnormal result does not imply no
; subnormal source.
define nofpclass(psub) float @ret_no_psub__fpext__select_psub_or_unknown(i1 %cond, half %unknown) {
; CHECK-LABEL: define nofpclass(psub) float @ret_no_psub__fpext__select_psub_or_unknown(
; CHECK-SAME: i1 [[COND:%.*]], half [[UNKNOWN:%.*]]) {
; CHECK-NEXT:    [[PSUB:%.*]] = call half @returns_psub_f16()
; CHECK-NEXT:    [[SELECT:%.*]] = select i1 [[COND]], half [[PSUB]], half [[UNKNOWN]]
; CHECK-NEXT:    [[RESULT:%.*]] = fpext half [[SELECT]] to float
; CHECK-NEXT:    ret float [[RESULT]]
;
  %psub = call half @returns_psub_f16()
  %select = select i1 %cond, half %psub, half %unknown
  %result = fpext half %select to float
  ret float %result
}

; Do not delete select, no subnormal result does not imply no
; subnormal source.
define nofpclass(sub) float @ret_no_sub__fpext__select_sub_or_unknown(i1 %cond, half %unknown) {
; CHECK-LABEL: define nofpclass(sub) float @ret_no_sub__fpext__select_sub_or_unknown(
; CHECK-SAME: i1 [[COND:%.*]], half [[UNKNOWN:%.*]]) {
; CHECK-NEXT:    [[SUB:%.*]] = call half @returns_sub_f16()
; CHECK-NEXT:    [[SELECT:%.*]] = select i1 [[COND]], half [[SUB]], half [[UNKNOWN]]
; CHECK-NEXT:    [[RESULT:%.*]] = fpext half [[SELECT]] to float
; CHECK-NEXT:    ret float [[RESULT]]
;
  %sub = call half @returns_sub_f16()
  %select = select i1 %cond, half %sub, half %unknown
  %result = fpext half %select to float
  ret float %result
}

; Remove select
define nofpclass(pinf pnorm psub pzero) float @ret_no_positive__fpext__select_positive_or_unknown(i1 %cond, half %unknown) {
; CHECK-LABEL: define nofpclass(pinf pzero psub pnorm) float @ret_no_positive__fpext__select_positive_or_unknown(
; CHECK-SAME: i1 [[COND:%.*]], half [[UNKNOWN:%.*]]) {
; CHECK-NEXT:    [[POSITIVE:%.*]] = call half @returns_positive_f16()
; CHECK-NEXT:    [[RESULT:%.*]] = fpext half [[UNKNOWN]] to float
; CHECK-NEXT:    ret float [[RESULT]]
;
  %positive = call half @returns_positive_f16()
  %select = select i1 %cond, half %positive, half %unknown
  %result = fpext half %select to float
  ret float %result
}

; No remove select
define nofpclass(pinf pnorm psub pzero) float @ret_no_positive__fpext__select_positive_nan_or_unknown(i1 %cond, half %unknown) {
; CHECK-LABEL: define nofpclass(pinf pzero psub pnorm) float @ret_no_positive__fpext__select_positive_nan_or_unknown(
; CHECK-SAME: i1 [[COND:%.*]], half [[UNKNOWN:%.*]]) {
; CHECK-NEXT:    [[POSITIVE_OR_NAN:%.*]] = call half @returns_positive_or_nan_f16()
; CHECK-NEXT:    [[SELECT:%.*]] = select i1 [[COND]], half [[POSITIVE_OR_NAN]], half [[UNKNOWN]]
; CHECK-NEXT:    [[RESULT:%.*]] = fpext half [[SELECT]] to float
; CHECK-NEXT:    ret float [[RESULT]]
;
  %positive.or.nan = call half @returns_positive_or_nan_f16()
  %select = select i1 %cond, half %positive.or.nan, half %unknown
  %result = fpext half %select to float
  ret float %result
}

; Remove select
define nofpclass(nan pinf pnorm psub pzero) float @ret_no_positive_no_nan__fpext__select_positive_nan_or_unknown(i1 %cond, half %unknown) {
; CHECK-LABEL: define nofpclass(nan pinf pzero psub pnorm) float @ret_no_positive_no_nan__fpext__select_positive_nan_or_unknown(
; CHECK-SAME: i1 [[COND:%.*]], half [[UNKNOWN:%.*]]) {
; CHECK-NEXT:    [[POSITIVE_OR_NAN:%.*]] = call half @returns_positive_or_nan_f16()
; CHECK-NEXT:    [[RESULT:%.*]] = fpext nnan half [[UNKNOWN]] to float
; CHECK-NEXT:    ret float [[RESULT]]
;
  %positive.or.nan = call half @returns_positive_or_nan_f16()
  %select = select i1 %cond, half %positive.or.nan, half %unknown
  %result = fpext half %select to float
  ret float %result
}

; Remove select
define nofpclass(ninf nnorm nsub nzero) float @ret_no_negative__fpext__select_negative_or_unknown(i1 %cond, half %unknown) {
; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @ret_no_negative__fpext__select_negative_or_unknown(
; CHECK-SAME: i1 [[COND:%.*]], half [[UNKNOWN:%.*]]) {
; CHECK-NEXT:    [[NEGATIVE:%.*]] = call half @returns_negative_f16()
; CHECK-NEXT:    [[RESULT:%.*]] = fpext half [[UNKNOWN]] to float
; CHECK-NEXT:    ret float [[RESULT]]
;
  %negative = call half @returns_negative_f16()
  %select = select i1 %cond, half %negative, half %unknown
  %result = fpext half %select to float
  ret float %result
}

; No remove select
define nofpclass(ninf nnorm nsub nzero) float @ret_no_negative__fpext__select_negative_nan_or_unknown(i1 %cond, half %unknown) {
; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @ret_no_negative__fpext__select_negative_nan_or_unknown(
; CHECK-SAME: i1 [[COND:%.*]], half [[UNKNOWN:%.*]]) {
; CHECK-NEXT:    [[NEGATIVE_OR_NAN:%.*]] = call half @returns_negative_or_nan_f16()
; CHECK-NEXT:    [[SELECT:%.*]] = select i1 [[COND]], half [[NEGATIVE_OR_NAN]], half [[UNKNOWN]]
; CHECK-NEXT:    [[RESULT:%.*]] = fpext half [[SELECT]] to float
; CHECK-NEXT:    ret float [[RESULT]]
;
  %negative.or.nan = call half @returns_negative_or_nan_f16()
  %select = select i1 %cond, half %negative.or.nan, half %unknown
  %result = fpext half %select to float
  ret float %result
}

; Remove select
define nofpclass(nan ninf nnorm nsub nzero) float @ret_no_negative_no_nan__fpext__select_negative_nan_or_unknown(i1 %cond, half %unknown) {
; CHECK-LABEL: define nofpclass(nan ninf nzero nsub nnorm) float @ret_no_negative_no_nan__fpext__select_negative_nan_or_unknown(
; CHECK-SAME: i1 [[COND:%.*]], half [[UNKNOWN:%.*]]) {
; CHECK-NEXT:    [[NEGATIVE_OR_NAN:%.*]] = call half @returns_negative_or_nan_f16()
; CHECK-NEXT:    [[RESULT:%.*]] = fpext nnan half [[UNKNOWN]] to float
; CHECK-NEXT:    ret float [[RESULT]]
;
  %negative.or.nan = call half @returns_negative_or_nan_f16()
  %select = select i1 %cond, half %negative.or.nan, half %unknown
  %result = fpext half %select to float
  ret float %result
}

define nofpclass(snan) float @ret_no_snan__fpext__always_zero() {
; CHECK-LABEL: define nofpclass(snan) float @ret_no_snan__fpext__always_zero() {
; CHECK-NEXT:    [[ZERO:%.*]] = call half @returns_zero_f16()
; CHECK-NEXT:    [[RESULT:%.*]] = fpext nnan ninf half [[ZERO]] to float
; CHECK-NEXT:    ret float [[RESULT]]
;
  %zero = call half @returns_zero_f16()
  %result = fpext half %zero to float
  ret float %result
}

define nofpclass(snan) float @ret_no_snan__fpext__always_zero_or_nan() {
; CHECK-LABEL: define nofpclass(snan) float @ret_no_snan__fpext__always_zero_or_nan() {
; CHECK-NEXT:    [[ZERO_OR_NAN:%.*]] = call half @returns_zero_or_nan_f16()
; CHECK-NEXT:    [[RESULT:%.*]] = fpext ninf half [[ZERO_OR_NAN]] to float
; CHECK-NEXT:    ret float [[RESULT]]
;
  %zero.or.nan = call half @returns_zero_or_nan_f16()
  %result = fpext half %zero.or.nan to float
  ret float %result
}

define nofpclass(snan) float @ret_no_snan__fpext__always_inf() {
; CHECK-LABEL: define nofpclass(snan) float @ret_no_snan__fpext__always_inf() {
; CHECK-NEXT:    [[INF:%.*]] = call half @returns_inf_f16()
; CHECK-NEXT:    [[RESULT:%.*]] = fpext nnan half [[INF]] to float
; CHECK-NEXT:    ret float [[RESULT]]
;
  %inf = call half @returns_inf_f16()
  %result = fpext half %inf to float
  ret float %result
}

define nofpclass(snan) float @ret_no_snan__fpext__always_inf_or_nan() {
; CHECK-LABEL: define nofpclass(snan) float @ret_no_snan__fpext__always_inf_or_nan() {
; CHECK-NEXT:    [[INF_OR_NAN:%.*]] = call half @returns_inf_or_nan_f16()
; CHECK-NEXT:    [[RESULT:%.*]] = fpext half [[INF_OR_NAN]] to float
; CHECK-NEXT:    ret float [[RESULT]]
;
  %inf.or.nan = call half @returns_inf_or_nan_f16()
  %result = fpext half %inf.or.nan to float
  ret float %result
}

define nofpclass(inf nan norm zero) float @ret_only_sub__fpext(half %x) {
; CHECK-LABEL: define nofpclass(nan inf zero norm) float @ret_only_sub__fpext(
; CHECK-SAME: half [[X:%.*]]) {
; CHECK-NEXT:    ret float poison
;
  %result = fpext half %x to float
  ret float %result
}

define nofpclass(inf nan norm zero nsub) float @ret_only_psub__fpext(half %x) {
; CHECK-LABEL: define nofpclass(nan inf zero nsub norm) float @ret_only_psub__fpext(
; CHECK-SAME: half [[X:%.*]]) {
; CHECK-NEXT:    ret float poison
;
  %result = fpext half %x to float
  ret float %result
}

define nofpclass(inf nan norm zero psub) float @ret_only_nsub__fpext(half %x) {
; CHECK-LABEL: define nofpclass(nan inf zero psub norm) float @ret_only_nsub__fpext(
; CHECK-SAME: half [[X:%.*]]) {
; CHECK-NEXT:    ret float poison
;
  %result = fpext half %x to float
  ret float %result
}

define nofpclass(inf nan norm) float @ret_only_sub_zero__fpext(half %x) {
; CHECK-LABEL: define nofpclass(nan inf norm) float @ret_only_sub_zero__fpext(
; CHECK-SAME: half [[X:%.*]]) {
; CHECK-NEXT:    [[RESULT:%.*]] = fpext nnan ninf half [[X]] to float
; CHECK-NEXT:    ret float [[RESULT]]
;
  %result = fpext half %x to float
  ret float %result
}

define nofpclass(inf nan norm nzero nsub) float @ret_only_psub_pzero__fpext(half %x) {
; CHECK-LABEL: define nofpclass(nan inf nzero nsub norm) float @ret_only_psub_pzero__fpext(
; CHECK-SAME: half [[X:%.*]]) {
; CHECK-NEXT:    ret float 0.000000e+00
;
  %result = fpext half %x to float
  ret float %result
}

define nofpclass(inf nan norm pzero psub) float @ret_only_nsub_nzero__fpext(half %x) {
; CHECK-LABEL: define nofpclass(nan inf pzero psub norm) float @ret_only_nsub_nzero__fpext(
; CHECK-SAME: half [[X:%.*]]) {
; CHECK-NEXT:    ret float -0.000000e+00
;
  %result = fpext half %x to float
  ret float %result
}

; -> +inf
define nofpclass(ninf) float @ret_no_ninf__fpext__inf() {
; CHECK-LABEL: define nofpclass(ninf) float @ret_no_ninf__fpext__inf() {
; CHECK-NEXT:    [[INF:%.*]] = call half @returns_inf_f16()
; CHECK-NEXT:    ret float +inf
;
  %inf = call half @returns_inf_f16()
  %result = fpext half %inf to float
  ret float %result
}

; -> -inf
define nofpclass(pinf) float @ret_no_pinf__fpext__inf() {
; CHECK-LABEL: define nofpclass(pinf) float @ret_no_pinf__fpext__inf() {
; CHECK-NEXT:    [[INF:%.*]] = call half @returns_inf_f16()
; CHECK-NEXT:    ret float -inf
;
  %inf = call half @returns_inf_f16()
  %result = fpext half %inf to float
  ret float %result
}

define nofpclass(nzero) float @ret_no_nzero__fpext__select_nzero_or_unknown(i1 %cond, half %unknown) {
; CHECK-LABEL: define nofpclass(nzero) float @ret_no_nzero__fpext__select_nzero_or_unknown(
; CHECK-SAME: i1 [[COND:%.*]], half [[UNKNOWN:%.*]]) {
; CHECK-NEXT:    [[NZERO:%.*]] = call half @returns_nzero_f16()
; CHECK-NEXT:    [[RESULT:%.*]] = fpext half [[UNKNOWN]] to float
; CHECK-NEXT:    ret float [[RESULT]]
;
  %nzero = call half @returns_nzero_f16()
  %select = select i1 %cond, half %nzero, half %unknown
  %result = fpext half %select to float
  ret float %result
}

define nofpclass(pzero) float @ret_no_pzero__fpext__select_pzero_or_unknown(i1 %cond, half %unknown) {
; CHECK-LABEL: define nofpclass(pzero) float @ret_no_pzero__fpext__select_pzero_or_unknown(
; CHECK-SAME: i1 [[COND:%.*]], half [[UNKNOWN:%.*]]) {
; CHECK-NEXT:    [[PZERO:%.*]] = call half @returns_pzero_f16()
; CHECK-NEXT:    [[RESULT:%.*]] = fpext half [[UNKNOWN]] to float
; CHECK-NEXT:    ret float [[RESULT]]
;
  %pzero = call half @returns_pzero_f16()
  %select = select i1 %cond, half %pzero, half %unknown
  %result = fpext half %select to float
  ret float %result
}

define nofpclass(zero) float @ret_no_zero__fpext__select_zero_or_unknown(i1 %cond, half %unknown) {
; CHECK-LABEL: define nofpclass(zero) float @ret_no_zero__fpext__select_zero_or_unknown(
; CHECK-SAME: i1 [[COND:%.*]], half [[UNKNOWN:%.*]]) {
; CHECK-NEXT:    [[ZERO:%.*]] = call half @returns_zero_f16()
; CHECK-NEXT:    [[RESULT:%.*]] = fpext half [[UNKNOWN]] to float
; CHECK-NEXT:    ret float [[RESULT]]
;
  %zero = call half @returns_zero_f16()
  %select = select i1 %cond, half %zero, half %unknown
  %result = fpext half %select to float
  ret float %result
}

define nofpclass(snan) float @qnan_result_demands_snan_src(i1 %cond, half %unknown) {
; CHECK-LABEL: define nofpclass(snan) float @qnan_result_demands_snan_src(
; CHECK-SAME: i1 [[COND:%.*]], half [[UNKNOWN:%.*]]) {
; CHECK-NEXT:    [[SNAN:%.*]] = call half @returns_snan_f16()
; CHECK-NEXT:    [[SELECT:%.*]] = select i1 [[COND]], half [[SNAN]], half [[UNKNOWN]]
; CHECK-NEXT:    [[RESULT:%.*]] = fpext half [[SELECT]] to float
; CHECK-NEXT:    ret float [[RESULT]]
;
  %snan = call half @returns_snan_f16()
  %select = select i1 %cond, half %snan, half %unknown
  %result = fpext half %select to float
  ret float %result
}