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
955 lines
38 KiB
LLVM
955 lines
38 KiB
LLVM
; 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
|
|
}
|