shylie/llvm-project
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
llvm-project/llvm/test/Transforms/HipStdPar/math-fixup.ll
Alex Voicu 6bcff9eb13
[HIPSTDPAR] Add handling for math builtins (#140158) 
When compiling in `--hipstdpar` mode, the builtins corresponding to the
standard library might end up in code that is expected to execute on the
accelerator (e.g. by using the `std::` prefixed functions from
`<cmath>`). We do not have uniform handling for this in AMDGPU, and the
errors that obtain are quite arcane. Furthermore, the user-space changes
required to work around this tend to be rather intrusive.

This patch adds an additional `--hipstdpar` specific pass which forwards
to the run time component of HIPSTDPAR the intrinsics / libcalls which
result from the use of the math builtins, and which are not properly
handled. In the long run we will want to stop relying on this and handle
things in the compiler, but it is going to be a rather lengthy journey,
which makes this medium term escape hatch necessary.

The paired change in the run time component is here
<https://github.com/ROCm/rocThrust/pull/551>.
2025-07-28 22:29:31 +01:00

549 lines
17 KiB
LLVM
Raw Permalink Blame History

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 5
; RUN: opt -S -passes=hipstdpar-math-fixup %s | FileCheck %s
define void @test_acos(double %dbl, float %flt) {
; CHECK-LABEL: define void @test_acos(
; CHECK-SAME: double [[DBL:%.*]], float [[FLT:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*:]]
; CHECK-NEXT: [[TMP0:%.*]] = call double @__hipstdpar_acos_f64(double [[DBL]])
; CHECK-NEXT: [[TMP1:%.*]] = call float @__hipstdpar_acos_f32(float [[FLT]])
; CHECK-NEXT: ret void
;
entry:
%0 = call double @llvm.acos.f64(double %dbl)
%1 = call float @llvm.acos.f32(float %flt)
ret void
}
define void @test_acosh(double %dbl, float %flt) {
; CHECK-LABEL: define void @test_acosh(
; CHECK-SAME: double [[DBL:%.*]], float [[FLT:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*:]]
; CHECK-NEXT: [[TMP0:%.*]] = call double @__hipstdpar_acosh_f64(double [[DBL]])
; CHECK-NEXT: [[TMP1:%.*]] = call float @__hipstdpar_acosh_f32(float [[FLT]])
; CHECK-NEXT: ret void
;
entry:
%0 = call double @acosh(double %dbl)
%1 = call float @acoshf(float %flt)
ret void
}
define void @test_asin(double %dbl, float %flt) {
; CHECK-LABEL: define void @test_asin(
; CHECK-SAME: double [[DBL:%.*]], float [[FLT:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*:]]
; CHECK-NEXT: [[TMP0:%.*]] = call double @__hipstdpar_asin_f64(double [[DBL]])
; CHECK-NEXT: [[TMP1:%.*]] = call float @__hipstdpar_asin_f32(float [[FLT]])
; CHECK-NEXT: ret void
;
entry:
%0 = call double @llvm.asin.f64(double %dbl)
%1 = call float @llvm.asin.f32(float %flt)
ret void
}
define void @test_asinh(double %dbl, float %flt) {
; CHECK-LABEL: define void @test_asinh(
; CHECK-SAME: double [[DBL:%.*]], float [[FLT:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*:]]
; CHECK-NEXT: [[TMP0:%.*]] = call double @__hipstdpar_asinh_f64(double [[DBL]])
; CHECK-NEXT: [[TMP1:%.*]] = call float @__hipstdpar_asinh_f32(float [[FLT]])
; CHECK-NEXT: ret void
;
entry:
%0 = call double @asinh(double %dbl)
%1 = call float @asinhf(float %flt)
ret void
}
define void @test_atan(double %dbl, float %flt) {
; CHECK-LABEL: define void @test_atan(
; CHECK-SAME: double [[DBL:%.*]], float [[FLT:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*:]]
; CHECK-NEXT: [[TMP0:%.*]] = call double @__hipstdpar_atan_f64(double [[DBL]])
; CHECK-NEXT: [[TMP1:%.*]] = call float @__hipstdpar_atan_f32(float [[FLT]])
; CHECK-NEXT: ret void
;
entry:
%0 = call double @llvm.atan.f64(double %dbl)
%1 = call float @llvm.atan.f32(float %flt)
ret void
}
define void @test_atanh(double %dbl, float %flt) {
; CHECK-LABEL: define void @test_atanh(
; CHECK-SAME: double [[DBL:%.*]], float [[FLT:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*:]]
; CHECK-NEXT: [[TMP0:%.*]] = call double @__hipstdpar_atanh_f64(double [[DBL]])
; CHECK-NEXT: [[TMP1:%.*]] = call float @__hipstdpar_atanh_f32(float [[FLT]])
; CHECK-NEXT: ret void
;
entry:
%0 = call double @atanh(double %dbl)
%1 = call float @atanhf(float %flt)
ret void
}
define void @test_atan2(double %dbl, float %flt) {
; CHECK-LABEL: define void @test_atan2(
; CHECK-SAME: double [[DBL:%.*]], float [[FLT:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*:]]
; CHECK-NEXT: [[TMP0:%.*]] = call double @__hipstdpar_atan2_f64(double [[DBL]], double [[DBL]])
; CHECK-NEXT: [[TMP1:%.*]] = call float @__hipstdpar_atan2_f32(float [[FLT]], float [[FLT]])
; CHECK-NEXT: ret void
;
entry:
%0 = call double @llvm.atan2.f64(double %dbl, double %dbl)
%1 = call float @llvm.atan2.f32(float %flt, float %flt)
ret void
}
define void @test_cbrt(double %dbl, float %flt) {
; CHECK-LABEL: define void @test_cbrt(
; CHECK-SAME: double [[DBL:%.*]], float [[FLT:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*:]]
; CHECK-NEXT: [[TMP0:%.*]] = call double @__hipstdpar_cbrt_f64(double [[DBL]])
; CHECK-NEXT: [[TMP1:%.*]] = call float @__hipstdpar_cbrt_f32(float [[FLT]])
; CHECK-NEXT: ret void
;
entry:
%0 = call double @cbrt(double %dbl)
%1 = call float @cbrtf(float %flt)
ret void
}
define void @test_cos(double %dbl) {
; CHECK-LABEL: define void @test_cos(
; CHECK-SAME: double [[DBL:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*:]]
; CHECK-NEXT: [[TMP0:%.*]] = call double @__hipstdpar_cos_f64(double [[DBL]])
; CHECK-NEXT: ret void
;
entry:
%0 = call double @llvm.cos.f64(double %dbl)
ret void
}
define void @test_cosh(double %dbl, float %flt) {
; CHECK-LABEL: define void @test_cosh(
; CHECK-SAME: double [[DBL:%.*]], float [[FLT:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*:]]
; CHECK-NEXT: [[TMP0:%.*]] = call double @__hipstdpar_cosh_f64(double [[DBL]])
; CHECK-NEXT: [[TMP1:%.*]] = call float @__hipstdpar_cosh_f32(float [[FLT]])
; CHECK-NEXT: ret void
;
entry:
%0 = call double @llvm.cosh.f64(double %dbl)
%1 = call float @llvm.cosh.f32(float %flt)
ret void
}
define void @test_erf(double %dbl, float %flt) {
; CHECK-LABEL: define void @test_erf(
; CHECK-SAME: double [[DBL:%.*]], float [[FLT:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*:]]
; CHECK-NEXT: [[TMP0:%.*]] = call double @__hipstdpar_erf_f64(double [[DBL]])
; CHECK-NEXT: [[TMP1:%.*]] = call float @__hipstdpar_erf_f32(float [[FLT]])
; CHECK-NEXT: ret void
;
entry:
%0 = call double @erf(double %dbl)
%1 = call float @erff(float %flt)
ret void
}
define void @test_erfc(double %dbl, float %flt) {
; CHECK-LABEL: define void @test_erfc(
; CHECK-SAME: double [[DBL:%.*]], float [[FLT:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*:]]
; CHECK-NEXT: [[TMP0:%.*]] = call double @__hipstdpar_erfc_f64(double [[DBL]])
; CHECK-NEXT: [[TMP1:%.*]] = call float @__hipstdpar_erfc_f32(float [[FLT]])
; CHECK-NEXT: ret void
;
entry:
%0 = call double @erfc(double %dbl)
%1 = call float @erfcf(float %flt)
ret void
}
define void @test_exp(double %dbl) {
; CHECK-LABEL: define void @test_exp(
; CHECK-SAME: double [[DBL:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*:]]
; CHECK-NEXT: [[TMP0:%.*]] = call double @__hipstdpar_exp_f64(double [[DBL]])
; CHECK-NEXT: ret void
;
entry:
%0 = call double @llvm.exp.f64(double %dbl)
ret void
}
define void @test_exp2(double %dbl) {
; CHECK-LABEL: define void @test_exp2(
; CHECK-SAME: double [[DBL:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*:]]
; CHECK-NEXT: [[TMP0:%.*]] = call double @__hipstdpar_exp2_f64(double [[DBL]])
; CHECK-NEXT: ret void
;
entry:
%0 = call double @llvm.exp2.f64(double %dbl)
ret void
}
define void @test_expm1(double %dbl, float %flt) {
; CHECK-LABEL: define void @test_expm1(
; CHECK-SAME: double [[DBL:%.*]], float [[FLT:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*:]]
; CHECK-NEXT: [[TMP0:%.*]] = call double @__hipstdpar_expm1_f64(double [[DBL]])
; CHECK-NEXT: [[TMP1:%.*]] = call float @__hipstdpar_expm1_f32(float [[FLT]])
; CHECK-NEXT: ret void
;
entry:
%0 = call double @expm1(double %dbl)
%1 = call float @expm1f(float %flt)
ret void
}
define void @test_fdim(double %dbl, float %flt) {
; CHECK-LABEL: define void @test_fdim(
; CHECK-SAME: double [[DBL:%.*]], float [[FLT:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*:]]
; CHECK-NEXT: [[TMP0:%.*]] = call double @__hipstdpar_fdim_f64(double [[DBL]], double [[DBL]])
; CHECK-NEXT: [[TMP1:%.*]] = call float @__hipstdpar_fdim_f32(float [[FLT]], float [[FLT]])
; CHECK-NEXT: ret void
;
entry:
%0 = call double @fdim(double %dbl, double %dbl)
%1 = call float @fdimf(float %flt, float %flt)
ret void
}
define void @test_hypot(double %dbl, float %flt) {
; CHECK-LABEL: define void @test_hypot(
; CHECK-SAME: double [[DBL:%.*]], float [[FLT:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*:]]
; CHECK-NEXT: [[TMP0:%.*]] = call double @__hipstdpar_hypot_f64(double [[DBL]], double [[DBL]])
; CHECK-NEXT: [[TMP1:%.*]] = call float @__hipstdpar_hypot_f32(float [[FLT]], float [[FLT]])
; CHECK-NEXT: ret void
;
entry:
%0 = call double @hypot(double %dbl, double %dbl)
%1 = call float @hypotf(float %flt, float %flt)
ret void
}
define void @test_lgamma(double %dbl, float %flt) {
; CHECK-LABEL: define void @test_lgamma(
; CHECK-SAME: double [[DBL:%.*]], float [[FLT:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*:]]
; CHECK-NEXT: [[TMP0:%.*]] = call double @__hipstdpar_lgamma_f64(double [[DBL]])
; CHECK-NEXT: [[TMP1:%.*]] = call float @__hipstdpar_lgamma_f32(float [[FLT]])
; CHECK-NEXT: ret void
;
entry:
%0 = call double @lgamma(double %dbl)
%1 = call float @lgammaf(float %flt)
ret void
}
define void @test_log(double %dbl) {
; CHECK-LABEL: define void @test_log(
; CHECK-SAME: double [[DBL:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*:]]
; CHECK-NEXT: [[TMP0:%.*]] = call double @__hipstdpar_log_f64(double [[DBL]])
; CHECK-NEXT: ret void
;
entry:
%0 = call double @llvm.log.f64(double %dbl)
ret void
}
define void @test_log10(double %dbl) {
; CHECK-LABEL: define void @test_log10(
; CHECK-SAME: double [[DBL:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*:]]
; CHECK-NEXT: [[TMP0:%.*]] = call double @__hipstdpar_log10_f64(double [[DBL]])
; CHECK-NEXT: ret void
;
entry:
%0 = call double @llvm.log10.f64(double %dbl)
ret void
}
define void @test_log2(double %dbl) {
; CHECK-LABEL: define void @test_log2(
; CHECK-SAME: double [[DBL:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*:]]
; CHECK-NEXT: [[TMP0:%.*]] = call double @__hipstdpar_log2_f64(double [[DBL]])
; CHECK-NEXT: ret void
;
entry:
%0 = call double @llvm.log2.f64(double %dbl)
ret void
}
define void @test_log1p(double %dbl, float %flt) {
; CHECK-LABEL: define void @test_log1p(
; CHECK-SAME: double [[DBL:%.*]], float [[FLT:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*:]]
; CHECK-NEXT: [[TMP0:%.*]] = call double @__hipstdpar_log1p_f64(double [[DBL]])
; CHECK-NEXT: [[TMP1:%.*]] = call float @__hipstdpar_log1p_f32(float [[FLT]])
; CHECK-NEXT: ret void
;
entry:
%0 = call double @log1p(double %dbl)
%1 = call float @log1pf(float %flt)
ret void
}
define void @test_modf(double %dbl, float %flt, ptr %pdbl, ptr %pflt) {
; CHECK-LABEL: define void @test_modf(
; CHECK-SAME: double [[DBL:%.*]], float [[FLT:%.*]], ptr [[PDBL:%.*]], ptr [[PFLT:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*:]]
; CHECK-NEXT: [[TMP0:%.*]] = tail call { double, double } @__hipstdpar_modf_f64(double [[DBL]])
; CHECK-NEXT: [[TMP1:%.*]] = extractvalue { double, double } [[TMP0]], 0
; CHECK-NEXT: [[TMP2:%.*]] = extractvalue { double, double } [[TMP0]], 1
; CHECK-NEXT: store double [[TMP2]], ptr [[PDBL]], align 8
; CHECK-NEXT: [[TMP3:%.*]] = tail call { float, float } @__hipstdpar_modf_f32(float [[FLT]])
; CHECK-NEXT: [[TMP4:%.*]] = extractvalue { float, float } [[TMP3]], 0
; CHECK-NEXT: [[TMP5:%.*]] = extractvalue { float, float } [[TMP3]], 1
; CHECK-NEXT: store float [[TMP5]], ptr [[PFLT]], align 4
; CHECK-NEXT: ret void
;
entry:
%0 = tail call { double, double } @llvm.modf.f64(double %dbl)
%1 = extractvalue { double, double } %0, 0
%2 = extractvalue { double, double } %0, 1
store double %2, ptr %pdbl, align 8
%3 = tail call { float, float } @llvm.modf.f32(float %flt)
%4 = extractvalue { float, float } %3, 0
%5 = extractvalue { float, float } %3, 1
store float %5, ptr %pflt, align 4
ret void
}
define void @test_pow(double %dbl) {
; CHECK-LABEL: define void @test_pow(
; CHECK-SAME: double [[DBL:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*:]]
; CHECK-NEXT: [[TMP0:%.*]] = call double @__hipstdpar_pow_f64(double [[DBL]], double [[DBL]])
; CHECK-NEXT: ret void
;
entry:
%0 = call double @llvm.pow.f64(double %dbl, double %dbl)
ret void
}
define void @test_remainder(double %dbl, float %flt) {
; CHECK-LABEL: define void @test_remainder(
; CHECK-SAME: double [[DBL:%.*]], float [[FLT:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*:]]
; CHECK-NEXT: [[TMP0:%.*]] = call double @__hipstdpar_remainder_f64(double [[DBL]], double [[DBL]])
; CHECK-NEXT: [[TMP1:%.*]] = call float @__hipstdpar_remainder_f32(float [[FLT]], float [[FLT]])
; CHECK-NEXT: ret void
;
entry:
%0 = call double @remainder(double %dbl, double %dbl)
%1 = call float @remainderf(float %flt, float %flt)
ret void
}
define void @test_remquo(double %dbl, float %flt, ptr %p) {
; CHECK-LABEL: define void @test_remquo(
; CHECK-SAME: double [[DBL:%.*]], float [[FLT:%.*]], ptr [[P:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*:]]
; CHECK-NEXT: [[TMP0:%.*]] = call double @__hipstdpar_remquo_f64(double [[DBL]], double [[DBL]], ptr [[P]])
; CHECK-NEXT: [[TMP1:%.*]] = call float @__hipstdpar_remquo_f32(float [[FLT]], float [[FLT]], ptr [[P]])
; CHECK-NEXT: ret void
;
entry:
%0 = call double @remquo(double %dbl, double %dbl, ptr %p)
%1 = call float @remquof(float %flt, float %flt, ptr %p)
ret void
}
define void @test_sin(double %dbl) {
; CHECK-LABEL: define void @test_sin(
; CHECK-SAME: double [[DBL:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*:]]
; CHECK-NEXT: [[TMP0:%.*]] = call double @__hipstdpar_sin_f64(double [[DBL]])
; CHECK-NEXT: ret void
;
entry:
%0 = call double @llvm.sin.f64(double %dbl)
ret void
}
define void @test_sinh(double %dbl, float %flt) {
; CHECK-LABEL: define void @test_sinh(
; CHECK-SAME: double [[DBL:%.*]], float [[FLT:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*:]]
; CHECK-NEXT: [[TMP0:%.*]] = call double @__hipstdpar_sinh_f64(double [[DBL]])
; CHECK-NEXT: [[TMP1:%.*]] = call float @__hipstdpar_sinh_f32(float [[FLT]])
; CHECK-NEXT: ret void
;
entry:
%0 = call double @llvm.sinh.f64(double %dbl)
%1 = call float @llvm.sinh.f32(float %flt)
ret void
}
define void @test_tan(double %dbl, float %flt) {
; CHECK-LABEL: define void @test_tan(
; CHECK-SAME: double [[DBL:%.*]], float [[FLT:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*:]]
; CHECK-NEXT: [[TMP0:%.*]] = call double @__hipstdpar_tan_f64(double [[DBL]])
; CHECK-NEXT: [[TMP1:%.*]] = call float @__hipstdpar_tan_f32(float [[FLT]])
; CHECK-NEXT: ret void
;
entry:
%0 = call double @llvm.tan.f64(double %dbl)
%1 = call float @llvm.tan.f32(float %flt)
ret void
}
define void @test_tanh(double %dbl, float %flt) {
; CHECK-LABEL: define void @test_tanh(
; CHECK-SAME: double [[DBL:%.*]], float [[FLT:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*:]]
; CHECK-NEXT: [[TMP0:%.*]] = call double @__hipstdpar_tanh_f64(double [[DBL]])
; CHECK-NEXT: [[TMP1:%.*]] = call float @__hipstdpar_tanh_f32(float [[FLT]])
; CHECK-NEXT: ret void
;
entry:
%0 = call double @llvm.tanh.f64(double %dbl)
%1 = call float @llvm.tanh.f32(float %flt)
ret void
}
define void @test_tgamma(double %dbl, float %flt) {
; CHECK-LABEL: define void @test_tgamma(
; CHECK-SAME: double [[DBL:%.*]], float [[FLT:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*:]]
; CHECK-NEXT: [[TMP0:%.*]] = call double @__hipstdpar_tgamma_f64(double [[DBL]])
; CHECK-NEXT: [[TMP1:%.*]] = call float @__hipstdpar_tgamma_f32(float [[FLT]])
; CHECK-NEXT: ret void
;
entry:
%0 = call double @tgamma(double %dbl)
%1 = call float @tgammaf(float %flt)
ret void
}
@globdbl = global double 4.200000e+01
@globflt = global float 4.200000e+01
define void @global_args() {
; CHECK-LABEL: define void @global_args() {
; CHECK-NEXT: [[ENTRY:.*:]]
; CHECK-NEXT: [[DBL:%.*]] = load double, ptr @globdbl, align 8
; CHECK-NEXT: [[FLT:%.*]] = load float, ptr @globflt, align 4
; CHECK-NEXT: [[TMP0:%.*]] = call double @__hipstdpar_remquo_f64(double [[DBL]], double [[DBL]], ptr @globdbl)
; CHECK-NEXT: [[TMP1:%.*]] = call float @__hipstdpar_remquo_f32(float [[FLT]], float [[FLT]], ptr @globflt)
; CHECK-NEXT: ret void
;
entry:
%dbl = load double, ptr @globdbl
%flt = load float, ptr @globflt
%1 = call double @remquo(double %dbl, double %dbl, ptr @globdbl)
%2 = call float @remquof(float %flt, float %flt, ptr @globflt)
ret void
}
declare hidden double @remainder(double, double)
declare hidden float @remainderf(float, float)
declare hidden double @remquo(double, double, ptr)
declare hidden float @remquof(float, float, ptr)
declare hidden double @fdim(double, double)
declare hidden float @fdimf(float, float)
declare double @llvm.exp.f64(double)
declare float @llvm.exp.f32(float)
declare double @llvm.exp2.f64(double)
declare float @llvm.exp2.f32(float)
declare hidden double @expm1(double)
declare hidden float @expm1f(float)
declare double @llvm.log.f64(double)
declare double @llvm.log10.f64(double)
declare double @llvm.log2.f64(double)
declare hidden double @log1p(double)
declare hidden float @log1pf(float)
declare { float, float } @llvm.modf.f32(float)
declare { double, double } @llvm.modf.f64(double)
declare double @llvm.pow.f64(double, double)
declare hidden double @cbrt(double)
declare hidden float @cbrtf(float)
declare hidden double @hypot(double, double)
declare hidden float @hypotf(float, float)
declare double @llvm.sin.f64(double)
declare double @llvm.cos.f64(double)
declare double @llvm.tan.f64(double)
declare double @llvm.asin.f64(double)
declare double @llvm.acos.f64(double)
declare double @llvm.atan.f64(double)
declare double @llvm.atan2.f64(double, double)
declare double @llvm.sinh.f64(double)
declare double @llvm.cosh.f64(double)
declare double @llvm.tanh.f64(double)
declare hidden double @asinh(double)
declare hidden float @asinhf(float)
declare hidden double @acosh(double)
declare hidden float @acoshf(float)
declare hidden double @atanh(double)
declare hidden float @atanhf(float)
declare hidden double @erf(double)
declare hidden float @erff(float)
declare hidden double @erfc(double)
declare hidden float @erfcf(float)
declare hidden double @tgamma(double)
declare hidden float @tgammaf(float)
declare hidden double @lgamma(double)
declare hidden float @lgammaf(float)
Reference in New Issue View Git Blame Copy Permalink