; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 6
; RUN: opt -S -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal < %s | FileCheck %s

; Test that multiply by a constant with a sufficiently large exponent
; proves the result is not subnormal.

define float @ret_fmul_f32(float %arg0, float %arg1) {
; CHECK-LABEL: define float @ret_fmul_f32(
; CHECK-SAME: float [[ARG0:%.*]], float [[ARG1:%.*]]) #[[ATTR0:[0-9]+]] {
; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG0]], [[ARG1]]
; CHECK-NEXT:    ret float [[FMUL]]
;
  %fmul = fmul float %arg0, %arg1
  ret float %fmul
}

define float @ret_fmul_square_f32(float noundef %arg) {
; CHECK-LABEL: define noundef nofpclass(ninf nzero nsub nnorm) float @ret_fmul_square_f32(
; CHECK-SAME: float noundef [[ARG:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG]], [[ARG]]
; CHECK-NEXT:    ret float [[FMUL]]
;
  %fmul = fmul float %arg, %arg
  ret float %fmul
}

define float @ret_fmul_square_f32_maybe_undef(float %arg) {
; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @ret_fmul_square_f32_maybe_undef(
; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG]], [[ARG]]
; CHECK-NEXT:    ret float [[FMUL]]
;
  %fmul = fmul float %arg, %arg
  ret float %fmul
}

define float @ret_mul_exponent_f32_22(float %arg0) {
; CHECK-LABEL: define float @ret_mul_exponent_f32_22(
; CHECK-SAME: float [[ARG0:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[CALL:%.*]] = fmul float [[ARG0]], f0x4A800000
; CHECK-NEXT:    ret float [[CALL]]
;
  %call = fmul float %arg0, 0x4150000000000000
  ret float %call
}

define float @ret_fmul_square_f32_src_no_nan(float noundef nofpclass(nan) %arg) {
; CHECK-LABEL: define noundef nofpclass(nan ninf nzero nsub nnorm) float @ret_fmul_square_f32_src_no_nan(
; CHECK-SAME: float noundef nofpclass(nan) [[ARG:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG]], [[ARG]]
; CHECK-NEXT:    ret float [[FMUL]]
;
  %fmul = fmul float %arg, %arg
  ret float %fmul
}

define float @ret_fmul_square_f32_src_no_snan(float noundef nofpclass(snan) %arg) {
; CHECK-LABEL: define noundef nofpclass(snan ninf nzero nsub nnorm) float @ret_fmul_square_f32_src_no_snan(
; CHECK-SAME: float noundef nofpclass(snan) [[ARG:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG]], [[ARG]]
; CHECK-NEXT:    ret float [[FMUL]]
;
  %fmul = fmul float %arg, %arg
  ret float %fmul
}

define float @ret_fmul_square_f32_src_no_qnan(float noundef nofpclass(qnan) %arg) {
; CHECK-LABEL: define noundef nofpclass(ninf nzero nsub nnorm) float @ret_fmul_square_f32_src_no_qnan(
; CHECK-SAME: float noundef nofpclass(qnan) [[ARG:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG]], [[ARG]]
; CHECK-NEXT:    ret float [[FMUL]]
;
  %fmul = fmul float %arg, %arg
  ret float %fmul
}

define float @ret_mul_exponent_f32_23(float %arg0) {
; CHECK-LABEL: define nofpclass(sub) float @ret_mul_exponent_f32_23(
; CHECK-SAME: float [[ARG0:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[CALL:%.*]] = fmul float [[ARG0]], f0x4B000000
; CHECK-NEXT:    ret float [[CALL]]
;
  %call = fmul float %arg0, 0x4160000000000000
  ret float %call
}

define float @ret_mul_exponent_f32_24(float %arg0) {
; CHECK-LABEL: define nofpclass(sub) float @ret_mul_exponent_f32_24(
; CHECK-SAME: float [[ARG0:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[CALL:%.*]] = fmul float [[ARG0]], f0x4B800000
; CHECK-NEXT:    ret float [[CALL]]
;
  %call = fmul float %arg0, 0x4170000000000000
  ret float %call
}

define float @ret_mul_exponent_f32_23_nnan(float nofpclass(nan) %arg0) {
; CHECK-LABEL: define nofpclass(nan sub) float @ret_mul_exponent_f32_23_nnan(
; CHECK-SAME: float nofpclass(nan) [[ARG0:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[CALL:%.*]] = fmul float [[ARG0]], f0x4B000000
; CHECK-NEXT:    ret float [[CALL]]
;
  %call = fmul float %arg0, 0x4160000000000000
  ret float %call
}

define double @ret_mul_exponent_f64_24(double %arg0) {
; CHECK-LABEL: define double @ret_mul_exponent_f64_24(
; CHECK-SAME: double [[ARG0:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[CALL:%.*]] = fmul double [[ARG0]], f0x4170000000000000
; CHECK-NEXT:    ret double [[CALL]]
;
  %call = fmul double %arg0, 0x4170000000000000
  ret double %call
}

define double @ret_mul_exponent_f64_51(double %arg0) {
; CHECK-LABEL: define double @ret_mul_exponent_f64_51(
; CHECK-SAME: double [[ARG0:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[CALL:%.*]] = fmul double [[ARG0]], f0x4320000000000000
; CHECK-NEXT:    ret double [[CALL]]
;
  %call = fmul double %arg0, 0x4320000000000000
  ret double %call
}

define double @ret_mul_exponent_f64_52(double %arg0) {
; CHECK-LABEL: define nofpclass(sub) double @ret_mul_exponent_f64_52(
; CHECK-SAME: double [[ARG0:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[CALL:%.*]] = fmul double [[ARG0]], f0x4330000000000000
; CHECK-NEXT:    ret double [[CALL]]
;
  %call = fmul double %arg0, 0x4330000000000000
  ret double %call
}

define double @ret_mul_exponent_f64_53(double %arg0) {
; CHECK-LABEL: define nofpclass(sub) double @ret_mul_exponent_f64_53(
; CHECK-SAME: double [[ARG0:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[CALL:%.*]] = fmul double [[ARG0]], f0x4340000000000000
; CHECK-NEXT:    ret double [[CALL]]
;
  %call = fmul double %arg0, 0x4340000000000000
  ret double %call
}

define half @ret_mul_exponent_f16_8(half %arg0) {
; CHECK-LABEL: define half @ret_mul_exponent_f16_8(
; CHECK-SAME: half [[ARG0:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[CALL:%.*]] = fmul half [[ARG0]], 2.560000e+02
; CHECK-NEXT:    ret half [[CALL]]
;
  %call = fmul half %arg0, 0xH5C00
  ret half %call
}

define half @ret_mul_exponent_f16_9(half %arg0) {
; CHECK-LABEL: define half @ret_mul_exponent_f16_9(
; CHECK-SAME: half [[ARG0:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[CALL:%.*]] = fmul half [[ARG0]], 5.120000e+02
; CHECK-NEXT:    ret half [[CALL]]
;
  %call = fmul half %arg0, 0xH6000
  ret half %call
}

define half @ret_mul_exponent_f16_10(half %arg0) {
; CHECK-LABEL: define nofpclass(sub) half @ret_mul_exponent_f16_10(
; CHECK-SAME: half [[ARG0:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[CALL:%.*]] = fmul half [[ARG0]], 1.024000e+03
; CHECK-NEXT:    ret half [[CALL]]
;
  %call = fmul half %arg0, 0xH6400
  ret half %call
}

define bfloat @ret_mul_exponent_bf16_6(bfloat %arg0) {
; CHECK-LABEL: define bfloat @ret_mul_exponent_bf16_6(
; CHECK-SAME: bfloat [[ARG0:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[CALL:%.*]] = fmul bfloat [[ARG0]], 6.400000e+01
; CHECK-NEXT:    ret bfloat [[CALL]]
;
  %call = fmul bfloat %arg0, 0xR4280
  ret bfloat %call
}

define bfloat @ret_mul_exponent_bf16_7(bfloat %arg0) {
; CHECK-LABEL: define nofpclass(sub) bfloat @ret_mul_exponent_bf16_7(
; CHECK-SAME: bfloat [[ARG0:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[CALL:%.*]] = fmul bfloat [[ARG0]], 1.280000e+02
; CHECK-NEXT:    ret bfloat [[CALL]]
;
  %call = fmul bfloat %arg0, 0xR4300
  ret bfloat %call
}

define bfloat @ret_mul_exponent_bf16_8(bfloat %arg0) {
; CHECK-LABEL: define nofpclass(sub) bfloat @ret_mul_exponent_bf16_8(
; CHECK-SAME: bfloat [[ARG0:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[CALL:%.*]] = fmul bfloat [[ARG0]], 2.560000e+02
; CHECK-NEXT:    ret bfloat [[CALL]]
;
  %call = fmul bfloat %arg0, 0xR4380
  ret bfloat %call
}

define float @ret_mul_exponent_f32_neg22(float %arg0) {
; CHECK-LABEL: define float @ret_mul_exponent_f32_neg22(
; CHECK-SAME: float [[ARG0:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[CALL:%.*]] = fmul float [[ARG0]], f0x34800000
; CHECK-NEXT:    ret float [[CALL]]
;
  %call = fmul float %arg0, 0x3E90000000000000
  ret float %call
}

define float @ret_mul_exponent_f32_neg23(float %arg0) {
; CHECK-LABEL: define float @ret_mul_exponent_f32_neg23(
; CHECK-SAME: float [[ARG0:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[CALL:%.*]] = fmul float [[ARG0]], f0x34000000
; CHECK-NEXT:    ret float [[CALL]]
;
  %call = fmul float %arg0, 0x3E80000000000000
  ret float %call
}

define float @ret_mul_exponent_f32_neg24(float %arg0) {
; CHECK-LABEL: define float @ret_mul_exponent_f32_neg24(
; CHECK-SAME: float [[ARG0:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[CALL:%.*]] = fmul float [[ARG0]], f0x33800000
; CHECK-NEXT:    ret float [[CALL]]
;
  %call = fmul float %arg0, 0x3E70000000000000
  ret float %call
}

define float @ret_mul_exponent_f32_neg126(float %arg0) {
; CHECK-LABEL: define float @ret_mul_exponent_f32_neg126(
; CHECK-SAME: float [[ARG0:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[CALL:%.*]] = fmul float [[ARG0]], f0x00800000
; CHECK-NEXT:    ret float [[CALL]]
;
  %call = fmul float %arg0, 0x3810000000000000
  ret float %call
}

define float @ret_mul_exponent_f32_neg127(float %arg0) {
; CHECK-LABEL: define float @ret_mul_exponent_f32_neg127(
; CHECK-SAME: float [[ARG0:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[CALL:%.*]] = fmul float [[ARG0]], f0x00400000
; CHECK-NEXT:    ret float [[CALL]]
;
  %call = fmul float %arg0, 0x3800000000000000
  ret float %call
}

define <2 x float> @ret_mul_exponent_v2f32_splat_23(<2 x float> %arg0) {
; CHECK-LABEL: define nofpclass(sub) <2 x float> @ret_mul_exponent_v2f32_splat_23(
; CHECK-SAME: <2 x float> [[ARG0:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[CALL:%.*]] = fmul <2 x float> [[ARG0]], splat (float f0x4B000000)
; CHECK-NEXT:    ret <2 x float> [[CALL]]
;
  %call = fmul <2 x float> %arg0, splat (float 0x4160000000000000)
  ret <2 x float> %call
}

define <2 x float> @ret_mul_exponent_v2f32_splat_poison_23(<2 x float> %arg0) {
; CHECK-LABEL: define <2 x float> @ret_mul_exponent_v2f32_splat_poison_23(
; CHECK-SAME: <2 x float> [[ARG0:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[CALL:%.*]] = fmul <2 x float> [[ARG0]], <float f0x4B000000, float poison>
; CHECK-NEXT:    ret <2 x float> [[CALL]]
;
  %call = fmul <2 x float> %arg0, <float 0x4160000000000000, float poison>
  ret <2 x float> %call
}

; TODO: Should be able to prove nofpclass(sub)
define <2 x float> @ret_mul_exponent_v2f32_nonsplat(<2 x float> %arg0) {
; CHECK-LABEL: define <2 x float> @ret_mul_exponent_v2f32_nonsplat(
; CHECK-SAME: <2 x float> [[ARG0:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[CALL:%.*]] = fmul <2 x float> [[ARG0]], <float f0x4B000000, float f0x4B800000>
; CHECK-NEXT:    ret <2 x float> [[CALL]]
;
  %call = fmul <2 x float> %arg0, <float 0x4160000000000000, float 0x4170000000000000>
  ret <2 x float> %call
}

; Cannot prove this is not-subnormal
define <2 x float> @ret_mul_partially_foldable_exponent_v2f32(<2 x float> %arg0) {
; CHECK-LABEL: define <2 x float> @ret_mul_partially_foldable_exponent_v2f32(
; CHECK-SAME: <2 x float> [[ARG0:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[CALL:%.*]] = fmul <2 x float> [[ARG0]], <float f0x4B000000, float f0x4A800000>
; CHECK-NEXT:    ret <2 x float> [[CALL]]
;
  %call = fmul <2 x float> %arg0, <float 0x4160000000000000, float 0x4150000000000000>
  ret <2 x float> %call
}

define float @ret_mul_f32_0(float %arg0) {
; CHECK-LABEL: define nofpclass(inf sub norm) float @ret_mul_f32_0(
; CHECK-SAME: float [[ARG0:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[CALL:%.*]] = fmul float [[ARG0]], 0.000000e+00
; CHECK-NEXT:    ret float [[CALL]]
;
  %call = fmul float %arg0, 0.0
  ret float %call
}

define float @ret_mul_f32_inf(float %arg0) {
; CHECK-LABEL: define nofpclass(zero sub norm) float @ret_mul_f32_inf(
; CHECK-SAME: float [[ARG0:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[CALL:%.*]] = fmul float [[ARG0]], +inf
; CHECK-NEXT:    ret float [[CALL]]
;
  %call = fmul float %arg0, 0x7FF0000000000000
  ret float %call
}

define float @ret_mul_f32_nan(float %arg0) {
; CHECK-LABEL: define nofpclass(inf zero sub norm) float @ret_mul_f32_nan(
; CHECK-SAME: float [[ARG0:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[CALL:%.*]] = fmul float [[ARG0]], +qnan
; CHECK-NEXT:    ret float [[CALL]]
;
  %call = fmul float %arg0, 0x7FF8000000000000
  ret float %call
}

define float @ret_fmul_f32_known_zero_or_nan_lhs(float nofpclass(inf norm sub) %arg0, float %arg1) {
; CHECK-LABEL: define nofpclass(inf sub norm) float @ret_fmul_f32_known_zero_or_nan_lhs(
; CHECK-SAME: float nofpclass(inf sub norm) [[ARG0:%.*]], float [[ARG1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG0]], [[ARG1]]
; CHECK-NEXT:    ret float [[FMUL]]
;
  %fmul = fmul float %arg0, %arg1
  ret float %fmul
}

define float @ret_fmul_f32_known_zero_or_nan_rhs(float %arg0, float nofpclass(inf norm sub) %arg1) {
; CHECK-LABEL: define nofpclass(inf sub norm) float @ret_fmul_f32_known_zero_or_nan_rhs(
; CHECK-SAME: float [[ARG0:%.*]], float nofpclass(inf sub norm) [[ARG1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG0]], [[ARG1]]
; CHECK-NEXT:    ret float [[FMUL]]
;
  %fmul = fmul float %arg0, %arg1
  ret float %fmul
}

define float @ret_fmul_f32_known_zero_lhs(float nofpclass(nan inf norm sub) %arg0, float %arg1) {
; CHECK-LABEL: define nofpclass(inf sub norm) float @ret_fmul_f32_known_zero_lhs(
; CHECK-SAME: float nofpclass(nan inf sub norm) [[ARG0:%.*]], float [[ARG1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG0]], [[ARG1]]
; CHECK-NEXT:    ret float [[FMUL]]
;
  %fmul = fmul float %arg0, %arg1
  ret float %fmul
}

define float @ret_fmul_f32_known_zero_rhs(float %arg0, float nofpclass(nan inf norm sub) %arg1) {
; CHECK-LABEL: define nofpclass(inf sub norm) float @ret_fmul_f32_known_zero_rhs(
; CHECK-SAME: float [[ARG0:%.*]], float nofpclass(nan inf sub norm) [[ARG1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG0]], [[ARG1]]
; CHECK-NEXT:    ret float [[FMUL]]
;
  %fmul = fmul float %arg0, %arg1
  ret float %fmul
}

define float @ret_fmul_f32_known_pzero_or_nan_lhs(float nofpclass(inf norm sub nzero) %arg0, float %arg1) {
; CHECK-LABEL: define nofpclass(inf sub norm) float @ret_fmul_f32_known_pzero_or_nan_lhs(
; CHECK-SAME: float nofpclass(inf nzero sub norm) [[ARG0:%.*]], float [[ARG1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG0]], [[ARG1]]
; CHECK-NEXT:    ret float [[FMUL]]
;
  %fmul = fmul float %arg0, %arg1
  ret float %fmul
}

define float @ret_fmul_f32_known_pzero_or_nan_rhs(float %arg0, float nofpclass(inf norm sub nzero) %arg1) {
; CHECK-LABEL: define nofpclass(inf sub norm) float @ret_fmul_f32_known_pzero_or_nan_rhs(
; CHECK-SAME: float [[ARG0:%.*]], float nofpclass(inf nzero sub norm) [[ARG1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG0]], [[ARG1]]
; CHECK-NEXT:    ret float [[FMUL]]
;
  %fmul = fmul float %arg0, %arg1
  ret float %fmul
}

define float @ret_fmul_f32_known_pzero_lhs(float nofpclass(nan inf norm sub nzero) %arg0, float %arg1) {
; CHECK-LABEL: define nofpclass(inf sub norm) float @ret_fmul_f32_known_pzero_lhs(
; CHECK-SAME: float nofpclass(nan inf nzero sub norm) [[ARG0:%.*]], float [[ARG1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG0]], [[ARG1]]
; CHECK-NEXT:    ret float [[FMUL]]
;
  %fmul = fmul float %arg0, %arg1
  ret float %fmul
}

define float @ret_fmul_f32_known_pzero_rhs(float %arg0, float nofpclass(nan inf norm sub nzero) %arg1) {
; CHECK-LABEL: define nofpclass(inf sub norm) float @ret_fmul_f32_known_pzero_rhs(
; CHECK-SAME: float [[ARG0:%.*]], float nofpclass(nan inf nzero sub norm) [[ARG1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG0]], [[ARG1]]
; CHECK-NEXT:    ret float [[FMUL]]
;
  %fmul = fmul float %arg0, %arg1
  ret float %fmul
}

define float @ret_fmul_f32_known_nzero_or_nan_lhs(float nofpclass(inf norm sub pzero) %arg0, float %arg1) {
; CHECK-LABEL: define nofpclass(inf sub norm) float @ret_fmul_f32_known_nzero_or_nan_lhs(
; CHECK-SAME: float nofpclass(inf pzero sub norm) [[ARG0:%.*]], float [[ARG1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG0]], [[ARG1]]
; CHECK-NEXT:    ret float [[FMUL]]
;
  %fmul = fmul float %arg0, %arg1
  ret float %fmul
}

define float @ret_fmul_f32_known_nzero_or_nan_rhs(float %arg0, float nofpclass(inf norm sub pzero) %arg1) {
; CHECK-LABEL: define nofpclass(inf sub norm) float @ret_fmul_f32_known_nzero_or_nan_rhs(
; CHECK-SAME: float [[ARG0:%.*]], float nofpclass(inf pzero sub norm) [[ARG1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG0]], [[ARG1]]
; CHECK-NEXT:    ret float [[FMUL]]
;
  %fmul = fmul float %arg0, %arg1
  ret float %fmul
}

define float @ret_fmul_f32_known_nzero_lhs(float nofpclass(nan inf norm sub pzero) %arg0, float %arg1) {
; CHECK-LABEL: define nofpclass(inf sub norm) float @ret_fmul_f32_known_nzero_lhs(
; CHECK-SAME: float nofpclass(nan inf pzero sub norm) [[ARG0:%.*]], float [[ARG1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG0]], [[ARG1]]
; CHECK-NEXT:    ret float [[FMUL]]
;
  %fmul = fmul float %arg0, %arg1
  ret float %fmul
}

define float @ret_fmul_f32_known_nzero_rhs(float %arg0, float nofpclass(nan inf norm sub pzero) %arg1) {
; CHECK-LABEL: define nofpclass(inf sub norm) float @ret_fmul_f32_known_nzero_rhs(
; CHECK-SAME: float [[ARG0:%.*]], float nofpclass(nan inf pzero sub norm) [[ARG1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG0]], [[ARG1]]
; CHECK-NEXT:    ret float [[FMUL]]
;
  %fmul = fmul float %arg0, %arg1
  ret float %fmul
}

define float @ret_fmul_f32_known_inf_or_nan_lhs(float nofpclass(zero norm sub) %arg0, float %arg1) {
; CHECK-LABEL: define nofpclass(zero sub norm) float @ret_fmul_f32_known_inf_or_nan_lhs(
; CHECK-SAME: float nofpclass(zero sub norm) [[ARG0:%.*]], float [[ARG1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG0]], [[ARG1]]
; CHECK-NEXT:    ret float [[FMUL]]
;
  %fmul = fmul float %arg0, %arg1
  ret float %fmul
}

define float @ret_fmul_f32_known_inf_or_nan_rhs(float %arg0, float nofpclass(zero norm sub) %arg1) {
; CHECK-LABEL: define nofpclass(zero sub norm) float @ret_fmul_f32_known_inf_or_nan_rhs(
; CHECK-SAME: float [[ARG0:%.*]], float nofpclass(zero sub norm) [[ARG1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG0]], [[ARG1]]
; CHECK-NEXT:    ret float [[FMUL]]
;
  %fmul = fmul float %arg0, %arg1
  ret float %fmul
}

define float @ret_fmul_f32_known_inf_lhs(float nofpclass(nan zero norm sub) %arg0, float %arg1) {
; CHECK-LABEL: define nofpclass(zero sub norm) float @ret_fmul_f32_known_inf_lhs(
; CHECK-SAME: float nofpclass(nan zero sub norm) [[ARG0:%.*]], float [[ARG1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG0]], [[ARG1]]
; CHECK-NEXT:    ret float [[FMUL]]
;
  %fmul = fmul float %arg0, %arg1
  ret float %fmul
}

define float @ret_fmul_f32_known_inf_rhs(float %arg0, float nofpclass(nan zero norm sub) %arg1) {
; CHECK-LABEL: define nofpclass(zero sub norm) float @ret_fmul_f32_known_inf_rhs(
; CHECK-SAME: float [[ARG0:%.*]], float nofpclass(nan zero sub norm) [[ARG1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG0]], [[ARG1]]
; CHECK-NEXT:    ret float [[FMUL]]
;
  %fmul = fmul float %arg0, %arg1
  ret float %fmul
}

define float @ret_fmul_f32_known_pinf_or_nan_lhs(float nofpclass(ninf zero norm sub) %arg0, float %arg1) {
; CHECK-LABEL: define nofpclass(zero sub norm) float @ret_fmul_f32_known_pinf_or_nan_lhs(
; CHECK-SAME: float nofpclass(ninf zero sub norm) [[ARG0:%.*]], float [[ARG1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG0]], [[ARG1]]
; CHECK-NEXT:    ret float [[FMUL]]
;
  %fmul = fmul float %arg0, %arg1
  ret float %fmul
}

define float @ret_fmul_f32_known_pinf_or_nan_rhs(float %arg0, float nofpclass(ninf zero norm sub) %arg1) {
; CHECK-LABEL: define nofpclass(zero sub norm) float @ret_fmul_f32_known_pinf_or_nan_rhs(
; CHECK-SAME: float [[ARG0:%.*]], float nofpclass(ninf zero sub norm) [[ARG1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG0]], [[ARG1]]
; CHECK-NEXT:    ret float [[FMUL]]
;
  %fmul = fmul float %arg0, %arg1
  ret float %fmul
}

define float @ret_fmul_f32_known_ninf_or_nan_lhs(float nofpclass(pinf zero norm sub) %arg0, float %arg1) {
; CHECK-LABEL: define nofpclass(zero sub norm) float @ret_fmul_f32_known_ninf_or_nan_lhs(
; CHECK-SAME: float nofpclass(pinf zero sub norm) [[ARG0:%.*]], float [[ARG1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG0]], [[ARG1]]
; CHECK-NEXT:    ret float [[FMUL]]
;
  %fmul = fmul float %arg0, %arg1
  ret float %fmul
}

define float @ret_fmul_f32_known_ninf_or_nan_rhs(float %arg0, float nofpclass(pinf zero norm sub) %arg1) {
; CHECK-LABEL: define nofpclass(zero sub norm) float @ret_fmul_f32_known_ninf_or_nan_rhs(
; CHECK-SAME: float [[ARG0:%.*]], float nofpclass(pinf zero sub norm) [[ARG1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG0]], [[ARG1]]
; CHECK-NEXT:    ret float [[FMUL]]
;
  %fmul = fmul float %arg0, %arg1
  ret float %fmul
}

; -> nan
define float @ret_known_inf_mul_known_zero(float nofpclass(nan norm sub zero) %arg0, float nofpclass(nan inf norm sub) %arg1) {
; CHECK-LABEL: define nofpclass(inf zero sub norm) float @ret_known_inf_mul_known_zero(
; CHECK-SAME: float nofpclass(nan zero sub norm) [[ARG0:%.*]], float nofpclass(nan inf sub norm) [[ARG1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG0]], [[ARG1]]
; CHECK-NEXT:    ret float [[FMUL]]
;
  %fmul = fmul float %arg0, %arg1
  ret float %fmul
}

; -> nan
define float @ret_known_inf_or_nan_mul_known_zero(float nofpclass(norm sub zero) %arg0, float nofpclass(nan inf norm sub) %arg1) {
; CHECK-LABEL: define nofpclass(inf zero sub norm) float @ret_known_inf_or_nan_mul_known_zero(
; CHECK-SAME: float nofpclass(zero sub norm) [[ARG0:%.*]], float nofpclass(nan inf sub norm) [[ARG1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG0]], [[ARG1]]
; CHECK-NEXT:    ret float [[FMUL]]
;
  %fmul = fmul float %arg0, %arg1
  ret float %fmul
}

; -> nan
define float @ret_known_inf_mul_known_zero_or_nan(float nofpclass(nan norm sub zero) %arg0, float nofpclass(inf norm sub) %arg1) {
; CHECK-LABEL: define nofpclass(inf zero sub norm) float @ret_known_inf_mul_known_zero_or_nan(
; CHECK-SAME: float nofpclass(nan zero sub norm) [[ARG0:%.*]], float nofpclass(inf sub norm) [[ARG1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG0]], [[ARG1]]
; CHECK-NEXT:    ret float [[FMUL]]
;
  %fmul = fmul float %arg0, %arg1
  ret float %fmul
}

; -> nan
define float @ret_known_ninf_mul_known_zero(float nofpclass(nan pinf norm sub zero) %arg0, float nofpclass(nan inf norm sub) %arg1) {
; CHECK-LABEL: define nofpclass(inf zero sub norm) float @ret_known_ninf_mul_known_zero(
; CHECK-SAME: float nofpclass(nan pinf zero sub norm) [[ARG0:%.*]], float nofpclass(nan inf sub norm) [[ARG1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG0]], [[ARG1]]
; CHECK-NEXT:    ret float [[FMUL]]
;
  %fmul = fmul float %arg0, %arg1
  ret float %fmul
}

; -> nan
define float @ret_known_pinf_mul_known_zero(float nofpclass(nan ninf norm sub zero) %arg0, float nofpclass(nan inf norm sub) %arg1) {
; CHECK-LABEL: define nofpclass(inf zero sub norm) float @ret_known_pinf_mul_known_zero(
; CHECK-SAME: float nofpclass(nan ninf zero sub norm) [[ARG0:%.*]], float nofpclass(nan inf sub norm) [[ARG1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG0]], [[ARG1]]
; CHECK-NEXT:    ret float [[FMUL]]
;
  %fmul = fmul float %arg0, %arg1
  ret float %fmul
}

; -> nan
define float @ret_known_zero_mul_known_inf(float nofpclass(nan inf norm sub) %arg0, float nofpclass(nan norm sub zero) %arg1) {
; CHECK-LABEL: define nofpclass(inf zero sub norm) float @ret_known_zero_mul_known_inf(
; CHECK-SAME: float nofpclass(nan inf sub norm) [[ARG0:%.*]], float nofpclass(nan zero sub norm) [[ARG1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG0]], [[ARG1]]
; CHECK-NEXT:    ret float [[FMUL]]
;
  %fmul = fmul float %arg0, %arg1
  ret float %fmul
}

; -> nan
define float @ret_known_zero_mul_known_inf_or_nan(float nofpclass(nan inf norm sub) %arg0, float nofpclass(norm sub zero) %arg1) {
; CHECK-LABEL: define nofpclass(inf zero sub norm) float @ret_known_zero_mul_known_inf_or_nan(
; CHECK-SAME: float nofpclass(nan inf sub norm) [[ARG0:%.*]], float nofpclass(zero sub norm) [[ARG1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG0]], [[ARG1]]
; CHECK-NEXT:    ret float [[FMUL]]
;
  %fmul = fmul float %arg0, %arg1
  ret float %fmul
}

; -> nan
define float @ret_known_zero_or_nan_mul_known_inf(float nofpclass(inf norm sub) %arg0, float nofpclass(nan norm sub zero) %arg1) {
; CHECK-LABEL: define nofpclass(inf zero sub norm) float @ret_known_zero_or_nan_mul_known_inf(
; CHECK-SAME: float nofpclass(inf sub norm) [[ARG0:%.*]], float nofpclass(nan zero sub norm) [[ARG1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG0]], [[ARG1]]
; CHECK-NEXT:    ret float [[FMUL]]
;
  %fmul = fmul float %arg0, %arg1
  ret float %fmul
}

; Know nothing
define float @ret_fmul_lhs_known_positive_or_nan(float %lhs, float %rhs) {
; CHECK-LABEL: define float @ret_fmul_lhs_known_positive_or_nan(
; CHECK-SAME: float [[LHS:%.*]], float [[RHS:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[LHS_FABS:%.*]] = call float @llvm.fabs.f32(float [[LHS]]) #[[ATTR2:[0-9]+]]
; CHECK-NEXT:    [[MUL:%.*]] = fmul float [[LHS_FABS]], [[RHS]]
; CHECK-NEXT:    ret float [[MUL]]
;
  %lhs.fabs = call float @llvm.fabs.f32(float %lhs)
  %mul = fmul float %lhs.fabs, %rhs
  ret float %mul
}

; Know nothing
define float @ret_fmul_rhs_known_positive_or_nan(float %lhs, float %rhs) {
; CHECK-LABEL: define float @ret_fmul_rhs_known_positive_or_nan(
; CHECK-SAME: float [[LHS:%.*]], float [[RHS:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[RHS_FABS:%.*]] = call float @llvm.fabs.f32(float [[RHS]]) #[[ATTR2]]
; CHECK-NEXT:    [[MUL:%.*]] = fmul float [[LHS]], [[RHS_FABS]]
; CHECK-NEXT:    ret float [[MUL]]
;
  %rhs.fabs = call float @llvm.fabs.f32(float %rhs)
  %mul = fmul float %lhs, %rhs.fabs
  ret float %mul
}

; Result must be positive or nan
define float @ret_fmul_both_signs_positive_or_nan(float %lhs, float %rhs) {
; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @ret_fmul_both_signs_positive_or_nan(
; CHECK-SAME: float [[LHS:%.*]], float [[RHS:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[LHS_FABS:%.*]] = call float @llvm.fabs.f32(float [[LHS]]) #[[ATTR2]]
; CHECK-NEXT:    [[RHS_FABS:%.*]] = call float @llvm.fabs.f32(float [[RHS]]) #[[ATTR2]]
; CHECK-NEXT:    [[MUL:%.*]] = fmul float [[LHS_FABS]], [[RHS_FABS]]
; CHECK-NEXT:    ret float [[MUL]]
;
  %lhs.fabs = call float @llvm.fabs.f32(float %lhs)
  %rhs.fabs = call float @llvm.fabs.f32(float %rhs)
  %mul = fmul float %lhs.fabs, %rhs.fabs
  ret float %mul
}

; Result must be positive or nan
define float @ret_fmul_both_signs_negative_or_nan(float %lhs, float %rhs) {
; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @ret_fmul_both_signs_negative_or_nan(
; CHECK-SAME: float [[LHS:%.*]], float [[RHS:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[LHS_FABS:%.*]] = call float @llvm.fabs.f32(float [[LHS]]) #[[ATTR2]]
; CHECK-NEXT:    [[RHS_FABS:%.*]] = call float @llvm.fabs.f32(float [[RHS]]) #[[ATTR2]]
; CHECK-NEXT:    [[LHS_NEG_FABS:%.*]] = fneg float [[LHS_FABS]]
; CHECK-NEXT:    [[RHS_NEG_FABS:%.*]] = fneg float [[RHS_FABS]]
; CHECK-NEXT:    [[MUL:%.*]] = fmul float [[LHS_NEG_FABS]], [[RHS_NEG_FABS]]
; CHECK-NEXT:    ret float [[MUL]]
;
  %lhs.fabs = call float @llvm.fabs.f32(float %lhs)
  %rhs.fabs = call float @llvm.fabs.f32(float %rhs)
  %lhs.neg.fabs = fneg float %lhs.fabs
  %rhs.neg.fabs = fneg float %rhs.fabs
  %mul = fmul float %lhs.neg.fabs, %rhs.neg.fabs
  ret float %mul
}

; Result must be negative or nan
define float @ret_fmul_lhs_negative_rhs_positive(float %lhs, float %rhs) {
; CHECK-LABEL: define nofpclass(pinf pzero psub pnorm) float @ret_fmul_lhs_negative_rhs_positive(
; CHECK-SAME: float [[LHS:%.*]], float [[RHS:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[LHS_FABS:%.*]] = call float @llvm.fabs.f32(float [[LHS]]) #[[ATTR2]]
; CHECK-NEXT:    [[RHS_FABS:%.*]] = call float @llvm.fabs.f32(float [[RHS]]) #[[ATTR2]]
; CHECK-NEXT:    [[LHS_NEG_FABS:%.*]] = fneg float [[LHS_FABS]]
; CHECK-NEXT:    [[MUL:%.*]] = fmul float [[LHS_NEG_FABS]], [[RHS_FABS]]
; CHECK-NEXT:    ret float [[MUL]]
;
  %lhs.fabs = call float @llvm.fabs.f32(float %lhs)
  %rhs.fabs = call float @llvm.fabs.f32(float %rhs)
  %lhs.neg.fabs = fneg float %lhs.fabs
  %mul = fmul float %lhs.neg.fabs, %rhs.fabs
  ret float %mul
}

; Result must be negative or nan
define float @ret_fmul_rhs_negative_lhs_positive(float %lhs, float %rhs) {
; CHECK-LABEL: define nofpclass(pinf pzero psub pnorm) float @ret_fmul_rhs_negative_lhs_positive(
; CHECK-SAME: float [[LHS:%.*]], float [[RHS:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[LHS_FABS:%.*]] = call float @llvm.fabs.f32(float [[LHS]]) #[[ATTR2]]
; CHECK-NEXT:    [[RHS_FABS:%.*]] = call float @llvm.fabs.f32(float [[RHS]]) #[[ATTR2]]
; CHECK-NEXT:    [[RHS_NEG_FABS:%.*]] = fneg float [[RHS_FABS]]
; CHECK-NEXT:    [[MUL:%.*]] = fmul float [[LHS_FABS]], [[RHS_NEG_FABS]]
; CHECK-NEXT:    ret float [[MUL]]
;
  %lhs.fabs = call float @llvm.fabs.f32(float %lhs)
  %rhs.fabs = call float @llvm.fabs.f32(float %rhs)
  %rhs.neg.fabs = fneg float %rhs.fabs
  %mul = fmul float %lhs.fabs, %rhs.neg.fabs
  ret float %mul
}

; Could be inf of either sign
define float @ret_known_inf_fmul_known_inf(float nofpclass(norm sub zero nan) %arg0, float nofpclass(norm sub zero nan) %arg1) {
; CHECK-LABEL: define nofpclass(nan zero sub norm) float @ret_known_inf_fmul_known_inf(
; CHECK-SAME: float nofpclass(nan zero sub norm) [[ARG0:%.*]], float nofpclass(nan zero sub norm) [[ARG1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG0]], [[ARG1]]
; CHECK-NEXT:    ret float [[FMUL]]
;
  %fmul = fmul float %arg0, %arg1
  ret float %fmul
}

; Could be inf of either sign, or nan
define float @ret_known_inf_fmul_known_inf_or_nan(float nofpclass(norm sub zero nan) %arg0, float nofpclass(norm sub zero) %arg1) {
; CHECK-LABEL: define nofpclass(zero sub norm) float @ret_known_inf_fmul_known_inf_or_nan(
; CHECK-SAME: float nofpclass(nan zero sub norm) [[ARG0:%.*]], float nofpclass(zero sub norm) [[ARG1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG0]], [[ARG1]]
; CHECK-NEXT:    ret float [[FMUL]]
;
  %fmul = fmul float %arg0, %arg1
  ret float %fmul
}

; Could be inf of either sign, or nan
define float @ret_known_inf_or_nan_fmul_known_inf(float nofpclass(norm sub zero) %arg0, float nofpclass(norm sub zero nan) %arg1) {
; CHECK-LABEL: define nofpclass(zero sub norm) float @ret_known_inf_or_nan_fmul_known_inf(
; CHECK-SAME: float nofpclass(zero sub norm) [[ARG0:%.*]], float nofpclass(nan zero sub norm) [[ARG1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG0]], [[ARG1]]
; CHECK-NEXT:    ret float [[FMUL]]
;
  %fmul = fmul float %arg0, %arg1
  ret float %fmul
}

; Could be zero of either sign
define float @ret_known_zero_fmul_known_zero(float nofpclass(inf norm sub nan) %arg0, float nofpclass(inf norm sub nan) %arg1) {
; CHECK-LABEL: define nofpclass(nan inf sub norm) float @ret_known_zero_fmul_known_zero(
; CHECK-SAME: float nofpclass(nan inf sub norm) [[ARG0:%.*]], float nofpclass(nan inf sub norm) [[ARG1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG0]], [[ARG1]]
; CHECK-NEXT:    ret float [[FMUL]]
;
  %fmul = fmul float %arg0, %arg1
  ret float %fmul
}

; Could be zero of either sign, or nan
define float @ret_known_zero_fmul_known_zero_or_nan(float nofpclass(inf norm sub nan) %arg0, float nofpclass(inf norm sub) %arg1) {
; CHECK-LABEL: define nofpclass(inf sub norm) float @ret_known_zero_fmul_known_zero_or_nan(
; CHECK-SAME: float nofpclass(nan inf sub norm) [[ARG0:%.*]], float nofpclass(inf sub norm) [[ARG1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG0]], [[ARG1]]
; CHECK-NEXT:    ret float [[FMUL]]
;
  %fmul = fmul float %arg0, %arg1
  ret float %fmul
}

; Could be zero of either sign, or nan
define float @ret_known_zero_or_nan_fmul_known_zero(float nofpclass(inf norm sub) %arg0, float nofpclass(inf norm sub nan) %arg1) {
; CHECK-LABEL: define nofpclass(inf sub norm) float @ret_known_zero_or_nan_fmul_known_zero(
; CHECK-SAME: float nofpclass(inf sub norm) [[ARG0:%.*]], float nofpclass(nan inf sub norm) [[ARG1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG0]], [[ARG1]]
; CHECK-NEXT:    ret float [[FMUL]]
;
  %fmul = fmul float %arg0, %arg1
  ret float %fmul
}

define float @ret_known_inf_or_nan_fmul_unknown(float nofpclass(norm sub zero) %arg0, float %arg1) {
; CHECK-LABEL: define nofpclass(zero sub norm) float @ret_known_inf_or_nan_fmul_unknown(
; CHECK-SAME: float nofpclass(zero sub norm) [[ARG0:%.*]], float [[ARG1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG0]], [[ARG1]]
; CHECK-NEXT:    ret float [[FMUL]]
;
  %fmul = fmul float %arg0, %arg1
  ret float %fmul
}

define float @ret_unknown_fmul_known_inf_or_nan(float %arg0, float nofpclass(norm sub zero) %arg1) {
; CHECK-LABEL: define nofpclass(zero sub norm) float @ret_unknown_fmul_known_inf_or_nan(
; CHECK-SAME: float [[ARG0:%.*]], float nofpclass(zero sub norm) [[ARG1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG0]], [[ARG1]]
; CHECK-NEXT:    ret float [[FMUL]]
;
  %fmul = fmul float %arg0, %arg1
  ret float %fmul
}

define float @ret_known_inf_or_nan_fmul_known_inf_or_nan(float nofpclass(norm sub zero) %arg0, float nofpclass(norm sub zero) %arg1) {
; CHECK-LABEL: define nofpclass(zero sub norm) float @ret_known_inf_or_nan_fmul_known_inf_or_nan(
; CHECK-SAME: float nofpclass(zero sub norm) [[ARG0:%.*]], float nofpclass(zero sub norm) [[ARG1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[FMUL:%.*]] = fmul float [[ARG0]], [[ARG1]]
; CHECK-NEXT:    ret float [[FMUL]]
;
  %fmul = fmul float %arg0, %arg1
  ret float %fmul
}

; Cannot introduce overflow, propagate no-infs
define float @ret_fmul__not_inf__half(float nofpclass(inf) %x) {
; CHECK-LABEL: define nofpclass(inf) float @ret_fmul__not_inf__half(
; CHECK-SAME: float nofpclass(inf) [[X:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[MUL:%.*]] = fmul float [[X]], 5.000000e-01
; CHECK-NEXT:    ret float [[MUL]]
;
  %mul = fmul float %x, 0.5
  ret float %mul
}

; Cannot introduce overflow, propagate no-infs
define float @ret_fmul__not_inf__neghalf(float nofpclass(inf) %x) {
; CHECK-LABEL: define nofpclass(inf) float @ret_fmul__not_inf__neghalf(
; CHECK-SAME: float nofpclass(inf) [[X:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[MUL:%.*]] = fmul float [[X]], -5.000000e-01
; CHECK-NEXT:    ret float [[MUL]]
;
  %mul = fmul float %x, -0.5
  ret float %mul
}

define float @ret_fmul__not_pinf__half(float nofpclass(pinf) %x) {
; CHECK-LABEL: define float @ret_fmul__not_pinf__half(
; CHECK-SAME: float nofpclass(pinf) [[X:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[MUL:%.*]] = fmul float [[X]], 5.000000e-01
; CHECK-NEXT:    ret float [[MUL]]
;
  %mul = fmul float %x, 0.5
  ret float %mul
}

define float @ret_fmul__not_ninf__half(float nofpclass(ninf) %x) {
; CHECK-LABEL: define float @ret_fmul__not_ninf__half(
; CHECK-SAME: float nofpclass(ninf) [[X:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[MUL:%.*]] = fmul float [[X]], 5.000000e-01
; CHECK-NEXT:    ret float [[MUL]]
;
  %mul = fmul float %x, 0.5
  ret float %mul
}

; Cannot introduce overflow, propagate no-infs
define float @ret_fmul__not_inf__1(float nofpclass(inf) %x) {
; CHECK-LABEL: define nofpclass(inf) float @ret_fmul__not_inf__1(
; CHECK-SAME: float nofpclass(inf) [[X:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[MUL:%.*]] = fmul float [[X]], 1.000000e+00
; CHECK-NEXT:    ret float [[MUL]]
;
  %mul = fmul float %x, 1.0
  ret float %mul
}

; Cannot introduce overflow, propagate no-infs
define float @ret_fmul__not_inf__neg1(float nofpclass(inf) %x) {
; CHECK-LABEL: define nofpclass(inf) float @ret_fmul__not_inf__neg1(
; CHECK-SAME: float nofpclass(inf) [[X:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[MUL:%.*]] = fmul float [[X]], -1.000000e+00
; CHECK-NEXT:    ret float [[MUL]]
;
  %mul = fmul float %x, -1.0
  ret float %mul
}

define float @ret_fmul__not_inf__2(float nofpclass(inf) %x) {
; CHECK-LABEL: define float @ret_fmul__not_inf__2(
; CHECK-SAME: float nofpclass(inf) [[X:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[MUL:%.*]] = fmul float [[X]], 2.000000e+00
; CHECK-NEXT:    ret float [[MUL]]
;
  %mul = fmul float %x, 2.0
  ret float %mul
}

; Negative test
define float @ret_fmul__not_inf__nextup_1(float nofpclass(inf) %x) {
; CHECK-LABEL: define float @ret_fmul__not_inf__nextup_1(
; CHECK-SAME: float nofpclass(inf) [[X:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[MUL:%.*]] = fmul float [[X]], f0x3F800001
; CHECK-NEXT:    ret float [[MUL]]
;
  %mul = fmul float %x, 0x3ff0000020000000
  ret float %mul
}

; Negative test
define float @ret_fmul__not_inf__1.5(float nofpclass(inf) %x) {
; CHECK-LABEL: define float @ret_fmul__not_inf__1.5(
; CHECK-SAME: float nofpclass(inf) [[X:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[MUL:%.*]] = fmul float [[X]], 1.500000e+00
; CHECK-NEXT:    ret float [[MUL]]
;
  %mul = fmul float %x, 1.5
  ret float %mul
}

; Negative test
define float @ret_fmul__not_inf__neg1.5(float nofpclass(inf) %x) {
; CHECK-LABEL: define float @ret_fmul__not_inf__neg1.5(
; CHECK-SAME: float nofpclass(inf) [[X:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[MUL:%.*]] = fmul float [[X]], -1.500000e+00
; CHECK-NEXT:    ret float [[MUL]]
;
  %mul = fmul float %x, -1.5
  ret float %mul
}

define float @ret_fmul__not_inf__fsub_floor_pat(float nofpclass(inf) %x, float %y) {
; CHECK-LABEL: define nofpclass(inf) float @ret_fmul__not_inf__fsub_floor_pat(
; CHECK-SAME: float nofpclass(inf) [[X:%.*]], float [[Y:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[FLOOR_Y:%.*]] = call float @llvm.floor.f32(float [[Y]]) #[[ATTR2]]
; CHECK-NEXT:    [[Y_SUB_FLOOR_Y:%.*]] = fsub float [[Y]], [[FLOOR_Y]]
; CHECK-NEXT:    [[MUL:%.*]] = fmul float [[X]], [[Y_SUB_FLOOR_Y]]
; CHECK-NEXT:    ret float [[MUL]]
;
  %floor.y = call float @llvm.floor.f32(float %y)
  %y.sub.floor.y = fsub float %y, %floor.y
  %mul = fmul float %x, %y.sub.floor.y
  ret float %mul
}

define float @ret_fmul__not_inf__fsub_floor_pat_commute(float nofpclass(inf) %x, float %y) {
; CHECK-LABEL: define nofpclass(inf) float @ret_fmul__not_inf__fsub_floor_pat_commute(
; CHECK-SAME: float nofpclass(inf) [[X:%.*]], float [[Y:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[FLOOR_Y:%.*]] = call float @llvm.floor.f32(float [[Y]]) #[[ATTR2]]
; CHECK-NEXT:    [[Y_SUB_FLOOR_Y:%.*]] = fsub float [[Y]], [[FLOOR_Y]]
; CHECK-NEXT:    [[MUL:%.*]] = fmul float [[Y_SUB_FLOOR_Y]], [[X]]
; CHECK-NEXT:    ret float [[MUL]]
;
  %floor.y = call float @llvm.floor.f32(float %y)
  %y.sub.floor.y = fsub float %y, %floor.y
  %mul = fmul float %y.sub.floor.y, %x
  ret float %mul
}

define float @ret_fmul__not_inf__fsub_floor_pat_wrong_floor_val(float nofpclass(inf) %x, float %y, float %z) {
; CHECK-LABEL: define float @ret_fmul__not_inf__fsub_floor_pat_wrong_floor_val(
; CHECK-SAME: float nofpclass(inf) [[X:%.*]], float [[Y:%.*]], float [[Z:%.*]]) #[[ATTR0]] {
; CHECK-NEXT:    [[FLOOR_Y:%.*]] = call float @llvm.floor.f32(float [[Z]]) #[[ATTR2]]
; CHECK-NEXT:    [[Y_SUB_FLOOR_Y:%.*]] = fsub float [[Y]], [[FLOOR_Y]]
; CHECK-NEXT:    [[MUL:%.*]] = fmul float [[X]], [[Y_SUB_FLOOR_Y]]
; CHECK-NEXT:    ret float [[MUL]]
;
  %floor.y = call float @llvm.floor.f32(float %z)
  %y.sub.floor.y = fsub float %y, %floor.y
  %mul = fmul float %x, %y.sub.floor.y
  ret float %mul
}