Skip to content

AMDGPU: Add baseline tests for f64 rsq pattern handling #172052

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom
Open
arsenm wants to merge 1 commit into
base: main
Choose a base branch
from
Open

AMDGPU: Add baseline tests for f64 rsq pattern handling #172052

arsenm wants to merge 1 commit into from
+526 −0

Conversation

@arsenm
Copy link
Contributor

@arsenm arsenm commented Dec 12, 2025

No description provided.

@arsenm arsenm added backend:AMDGPU floating-point Floating-point math labels Dec 12, 2025 — with Graphite App
@arsenm Graphite App
Copy link
Contributor Author

arsenm commented Dec 12, 2025 •
edited
Loading

This stack of pull requests is managed by Graphite. Learn more about stacking.

@arsenm arsenm mentioned this pull request Dec 12, 2025
Open
@llvmbot
Copy link
Member

llvmbot commented Dec 12, 2025

@llvm/pr-subscribers-backend-amdgpu

Author: Matt Arsenault (arsenm)

Changes

Patch is 21.50 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/172052.diff

1 Files Affected:

  • (added) llvm/test/CodeGen/AMDGPU/amdgpu-codegenprepare-fdiv.f64.ll (+526)
diff --git a/llvm/test/CodeGen/AMDGPU/amdgpu-codegenprepare-fdiv.f64.ll b/llvm/test/CodeGen/AMDGPU/amdgpu-codegenprepare-fdiv.f64.ll
new file mode 100644
index 0000000000000..b97cd91f2ab32
--- /dev/null
+++ b/llvm/test/CodeGen/AMDGPU/amdgpu-codegenprepare-fdiv.f64.ll
@@ -0,0 +1,526 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 6
+; RUN: opt -S -mtriple=amdgcn-- -passes=amdgpu-codegenprepare < %s | FileCheck %s
+
+define double @rsq_f64(double %x) {
+; CHECK-LABEL: define double @rsq_f64(
+; CHECK-SAME: double [[X:%.*]]) {
+; CHECK-NEXT:    [[SQRT_X:%.*]] = call contract double @llvm.sqrt.f64(double [[X]])
+; CHECK-NEXT:    [[FDIV:%.*]] = fdiv contract double 1.000000e+00, [[SQRT_X]]
+; CHECK-NEXT:    ret double [[FDIV]]
+;
+  %sqrt.x = call contract double @llvm.sqrt.f64(double %x)
+  %fdiv = fdiv contract double 1.0, %sqrt.x
+  ret double %fdiv
+}
+
+define double @neg_rsq_f64(double %x) {
+; CHECK-LABEL: define double @neg_rsq_f64(
+; CHECK-SAME: double [[X:%.*]]) {
+; CHECK-NEXT:    [[SQRT_X:%.*]] = call contract double @llvm.sqrt.f64(double [[X]])
+; CHECK-NEXT:    [[FDIV:%.*]] = fdiv contract double -1.000000e+00, [[SQRT_X]]
+; CHECK-NEXT:    ret double [[FDIV]]
+;
+  %sqrt.x = call contract double @llvm.sqrt.f64(double %x)
+  %fdiv = fdiv contract double -1.0, %sqrt.x
+  ret double %fdiv
+}
+
+define double @rsq_f64_nnan(double %x) {
+; CHECK-LABEL: define double @rsq_f64_nnan(
+; CHECK-SAME: double [[X:%.*]]) {
+; CHECK-NEXT:    [[SQRT_X:%.*]] = call nnan contract double @llvm.sqrt.f64(double [[X]])
+; CHECK-NEXT:    [[FDIV:%.*]] = fdiv nnan contract double 1.000000e+00, [[SQRT_X]]
+; CHECK-NEXT:    ret double [[FDIV]]
+;
+  %sqrt.x = call contract nnan double @llvm.sqrt.f64(double %x)
+  %fdiv = fdiv contract nnan double 1.0, %sqrt.x
+  ret double %fdiv
+}
+
+define double @neg_rsq_f64_nnan(double %x) {
+; CHECK-LABEL: define double @neg_rsq_f64_nnan(
+; CHECK-SAME: double [[X:%.*]]) {
+; CHECK-NEXT:    [[SQRT_X:%.*]] = call nnan contract double @llvm.sqrt.f64(double [[X]])
+; CHECK-NEXT:    [[FDIV:%.*]] = fdiv nnan contract double -1.000000e+00, [[SQRT_X]]
+; CHECK-NEXT:    ret double [[FDIV]]
+;
+  %sqrt.x = call contract nnan double @llvm.sqrt.f64(double %x)
+  %fdiv = fdiv contract nnan double -1.0, %sqrt.x
+  ret double %fdiv
+}
+
+define double @rsq_f64_ninf(double %x) {
+; CHECK-LABEL: define double @rsq_f64_ninf(
+; CHECK-SAME: double [[X:%.*]]) {
+; CHECK-NEXT:    [[SQRT_X:%.*]] = call ninf contract double @llvm.sqrt.f64(double [[X]])
+; CHECK-NEXT:    [[FDIV:%.*]] = fdiv ninf contract double 1.000000e+00, [[SQRT_X]]
+; CHECK-NEXT:    ret double [[FDIV]]
+;
+  %sqrt.x = call contract ninf double @llvm.sqrt.f64(double %x)
+  %fdiv = fdiv contract ninf double 1.0, %sqrt.x
+  ret double %fdiv
+}
+
+define double @neg_rsq_f64_ninf(double %x) {
+; CHECK-LABEL: define double @neg_rsq_f64_ninf(
+; CHECK-SAME: double [[X:%.*]]) {
+; CHECK-NEXT:    [[SQRT_X:%.*]] = call ninf contract double @llvm.sqrt.f64(double [[X]])
+; CHECK-NEXT:    [[FDIV:%.*]] = fdiv ninf contract double -1.000000e+00, [[SQRT_X]]
+; CHECK-NEXT:    ret double [[FDIV]]
+;
+  %sqrt.x = call contract ninf double @llvm.sqrt.f64(double %x)
+  %fdiv = fdiv contract ninf double -1.0, %sqrt.x
+  ret double %fdiv
+}
+
+define double @rsq_f64_nnan_ninf(double %x) {
+; CHECK-LABEL: define double @rsq_f64_nnan_ninf(
+; CHECK-SAME: double [[X:%.*]]) {
+; CHECK-NEXT:    [[SQRT_X:%.*]] = call nnan ninf contract double @llvm.sqrt.f64(double [[X]])
+; CHECK-NEXT:    [[FDIV:%.*]] = fdiv nnan ninf contract double 1.000000e+00, [[SQRT_X]]
+; CHECK-NEXT:    ret double [[FDIV]]
+;
+  %sqrt.x = call contract nnan ninf double @llvm.sqrt.f64(double %x)
+  %fdiv = fdiv contract nnan ninf double 1.0, %sqrt.x
+  ret double %fdiv
+}
+
+define double @neg_rsq_f64_nnan_ninf(double %x) {
+; CHECK-LABEL: define double @neg_rsq_f64_nnan_ninf(
+; CHECK-SAME: double [[X:%.*]]) {
+; CHECK-NEXT:    [[SQRT_X:%.*]] = call nnan ninf contract double @llvm.sqrt.f64(double [[X]])
+; CHECK-NEXT:    [[FDIV:%.*]] = fdiv nnan ninf contract double -1.000000e+00, [[SQRT_X]]
+; CHECK-NEXT:    ret double [[FDIV]]
+;
+  %sqrt.x = call contract nnan ninf double @llvm.sqrt.f64(double %x)
+  %fdiv = fdiv contract nnan ninf double -1.0, %sqrt.x
+  ret double %fdiv
+}
+
+define double @rsq_f64_sqrt_nnan_ninf(double %x) {
+; CHECK-LABEL: define double @rsq_f64_sqrt_nnan_ninf(
+; CHECK-SAME: double [[X:%.*]]) {
+; CHECK-NEXT:    [[SQRT_X:%.*]] = call nnan ninf contract double @llvm.sqrt.f64(double [[X]])
+; CHECK-NEXT:    [[FDIV:%.*]] = fdiv contract double 1.000000e+00, [[SQRT_X]]
+; CHECK-NEXT:    ret double [[FDIV]]
+;
+  %sqrt.x = call contract nnan ninf double @llvm.sqrt.f64(double %x)
+  %fdiv = fdiv contract double 1.0, %sqrt.x
+  ret double %fdiv
+}
+
+define double @rsq_f64_fdiv_nnan_ninf(double %x) {
+; CHECK-LABEL: define double @rsq_f64_fdiv_nnan_ninf(
+; CHECK-SAME: double [[X:%.*]]) {
+; CHECK-NEXT:    [[SQRT_X:%.*]] = call contract double @llvm.sqrt.f64(double [[X]])
+; CHECK-NEXT:    [[FDIV:%.*]] = fdiv nnan ninf contract double 1.000000e+00, [[SQRT_X]]
+; CHECK-NEXT:    ret double [[FDIV]]
+;
+  %sqrt.x = call contract double @llvm.sqrt.f64(double %x)
+  %fdiv = fdiv contract nnan ninf double 1.0, %sqrt.x
+  ret double %fdiv
+}
+
+define <2 x double> @rsq_v2f64(<2 x double> %x) {
+; CHECK-LABEL: define <2 x double> @rsq_v2f64(
+; CHECK-SAME: <2 x double> [[X:%.*]]) {
+; CHECK-NEXT:    [[SQRT_X:%.*]] = call contract <2 x double> @llvm.sqrt.v2f64(<2 x double> [[X]])
+; CHECK-NEXT:    [[FDIV:%.*]] = fdiv contract <2 x double> splat (double 1.000000e+00), [[SQRT_X]]
+; CHECK-NEXT:    ret <2 x double> [[FDIV]]
+;
+  %sqrt.x = call contract <2 x double> @llvm.sqrt.f64(<2 x double> %x)
+  %fdiv = fdiv contract <2 x double> splat (double 1.0), %sqrt.x
+  ret <2 x double> %fdiv
+}
+
+define <2 x double> @neg_rsq_v2f64(<2 x double> %x) {
+; CHECK-LABEL: define <2 x double> @neg_rsq_v2f64(
+; CHECK-SAME: <2 x double> [[X:%.*]]) {
+; CHECK-NEXT:    [[SQRT_X:%.*]] = call contract <2 x double> @llvm.sqrt.v2f64(<2 x double> [[X]])
+; CHECK-NEXT:    [[FDIV:%.*]] = fdiv contract <2 x double> splat (double 1.000000e+00), [[SQRT_X]]
+; CHECK-NEXT:    ret <2 x double> [[FDIV]]
+;
+  %sqrt.x = call contract <2 x double> @llvm.sqrt.f64(<2 x double> %x)
+  %fdiv = fdiv contract <2 x double> splat (double 1.0), %sqrt.x
+  ret <2 x double> %fdiv
+}
+
+define <2 x double> @mixed_sign_rsq_v2f64(<2 x double> %x) {
+; CHECK-LABEL: define <2 x double> @mixed_sign_rsq_v2f64(
+; CHECK-SAME: <2 x double> [[X:%.*]]) {
+; CHECK-NEXT:    [[SQRT_X:%.*]] = call contract <2 x double> @llvm.sqrt.v2f64(<2 x double> [[X]])
+; CHECK-NEXT:    [[FDIV:%.*]] = fdiv contract <2 x double> <double 1.000000e+00, double -1.000000e+00>, [[SQRT_X]]
+; CHECK-NEXT:    ret <2 x double> [[FDIV]]
+;
+  %sqrt.x = call contract <2 x double> @llvm.sqrt.f64(<2 x double> %x)
+  %fdiv = fdiv contract <2 x double> <double 1.0, double -1.0>, %sqrt.x
+  ret <2 x double> %fdiv
+}
+
+define <2 x double> @rsq_some_elements_v2f64(<2 x double> %x) {
+; CHECK-LABEL: define <2 x double> @rsq_some_elements_v2f64(
+; CHECK-SAME: <2 x double> [[X:%.*]]) {
+; CHECK-NEXT:    [[SQRT_X:%.*]] = call contract <2 x double> @llvm.sqrt.v2f64(<2 x double> [[X]])
+; CHECK-NEXT:    [[FDIV:%.*]] = fdiv contract <2 x double> <double 1.000000e+00, double 2.000000e+00>, [[SQRT_X]]
+; CHECK-NEXT:    ret <2 x double> [[FDIV]]
+;
+  %sqrt.x = call contract <2 x double> @llvm.sqrt.f64(<2 x double> %x)
+  %fdiv = fdiv contract <2 x double> <double 1.0, double 2.0>, %sqrt.x
+  ret <2 x double> %fdiv
+}
+
+; Negative test
+define double @rsq_f64_missing_contract0(double %x) {
+; CHECK-LABEL: define double @rsq_f64_missing_contract0(
+; CHECK-SAME: double [[X:%.*]]) {
+; CHECK-NEXT:    [[SQRT_X:%.*]] = call double @llvm.sqrt.f64(double [[X]])
+; CHECK-NEXT:    [[FDIV:%.*]] = fdiv contract double 1.000000e+00, [[SQRT_X]]
+; CHECK-NEXT:    ret double [[FDIV]]
+;
+  %sqrt.x = call double @llvm.sqrt.f64(double %x)
+  %fdiv = fdiv contract double 1.0, %sqrt.x
+  ret double %fdiv
+}
+
+; Negative test
+define double @rsq_f64_missing_contract1(double %x) {
+; CHECK-LABEL: define double @rsq_f64_missing_contract1(
+; CHECK-SAME: double [[X:%.*]]) {
+; CHECK-NEXT:    [[SQRT_X:%.*]] = call contract double @llvm.sqrt.f64(double [[X]])
+; CHECK-NEXT:    [[FDIV:%.*]] = fdiv double 1.000000e+00, [[SQRT_X]]
+; CHECK-NEXT:    ret double [[FDIV]]
+;
+  %sqrt.x = call contract double @llvm.sqrt.f64(double %x)
+  %fdiv = fdiv double 1.0, %sqrt.x
+  ret double %fdiv
+}
+
+declare double @sqrt(double)
+
+define double @rsq_f64_not_sqrt_intrin(double %x) {
+; CHECK-LABEL: define double @rsq_f64_not_sqrt_intrin(
+; CHECK-SAME: double [[X:%.*]]) {
+; CHECK-NEXT:    [[SQRT_X:%.*]] = call contract double @sqrt(double [[X]])
+; CHECK-NEXT:    [[FDIV:%.*]] = fdiv contract double 1.000000e+00, [[SQRT_X]]
+; CHECK-NEXT:    ret double [[FDIV]]
+;
+  %sqrt.x = call contract double @sqrt(double %x)
+  %fdiv = fdiv contract double 1.0, %sqrt.x
+  ret double %fdiv
+}
+
+define double @rcp_f64(double %x) {
+; CHECK-LABEL: define double @rcp_f64(
+; CHECK-SAME: double [[X:%.*]]) {
+; CHECK-NEXT:    [[FDIV:%.*]] = fdiv arcp contract double 1.000000e+00, [[X]]
+; CHECK-NEXT:    ret double [[FDIV]]
+;
+  %fdiv = fdiv contract arcp double 1.0, %x
+  ret double %fdiv
+}
+
+define double @rcp_afn_f64(double %x) {
+; CHECK-LABEL: define double @rcp_afn_f64(
+; CHECK-SAME: double [[X:%.*]]) {
+; CHECK-NEXT:    [[FDIV:%.*]] = fdiv arcp contract afn double 1.000000e+00, [[X]]
+; CHECK-NEXT:    ret double [[FDIV]]
+;
+  %fdiv = fdiv contract arcp afn double 1.0, %x
+  ret double %fdiv
+}
+
+define double @neg_rcp_f64(double %x) {
+; CHECK-LABEL: define double @neg_rcp_f64(
+; CHECK-SAME: double [[X:%.*]]) {
+; CHECK-NEXT:    [[FDIV:%.*]] = fdiv arcp contract double -1.000000e+00, [[X]]
+; CHECK-NEXT:    ret double [[FDIV]]
+;
+  %fdiv = fdiv contract arcp double -1.0, %x
+  ret double %fdiv
+}
+
+define double @neg_rcp_afn_f64(double %x) {
+; CHECK-LABEL: define double @neg_rcp_afn_f64(
+; CHECK-SAME: double [[X:%.*]]) {
+; CHECK-NEXT:    [[FDIV:%.*]] = fdiv arcp contract afn double -1.000000e+00, [[X]]
+; CHECK-NEXT:    ret double [[FDIV]]
+;
+  %fdiv = fdiv contract arcp afn double -1.0, %x
+  ret double %fdiv
+}
+
+; Make sure this doesn't accidentally go down f32 paths
+define double @v_fdiv_f64_ulp25(double %a, double %b) {
+; CHECK-LABEL: define double @v_fdiv_f64_ulp25(
+; CHECK-SAME: double [[A:%.*]], double [[B:%.*]]) {
+; CHECK-NEXT:    [[FDIV:%.*]] = fdiv double [[A]], [[B]], !fpmath [[META0:![0-9]+]]
+; CHECK-NEXT:    ret double [[FDIV]]
+;
+  %fdiv = fdiv double %a, %b, !fpmath !0
+  ret double %fdiv
+}
+
+; TODO: Handle arcp case
+define double @fdiv_arcp_2_f64(double %x) {
+; CHECK-LABEL: define double @fdiv_arcp_2_f64(
+; CHECK-SAME: double [[X:%.*]]) {
+; CHECK-NEXT:    [[SQRT_X:%.*]] = call arcp contract double @llvm.sqrt.f64(double [[X]])
+; CHECK-NEXT:    [[FDIV:%.*]] = fdiv arcp contract double 2.000000e+00, [[SQRT_X]]
+; CHECK-NEXT:    ret double [[FDIV]]
+;
+  %sqrt.x = call arcp contract double @llvm.sqrt.f64(double %x)
+  %fdiv = fdiv arcp contract double 2.0, %sqrt.x
+  ret double %fdiv
+}
+
+define double @fdiv_arcp_var_f64(double %x, double %y) {
+; CHECK-LABEL: define double @fdiv_arcp_var_f64(
+; CHECK-SAME: double [[X:%.*]], double [[Y:%.*]]) {
+; CHECK-NEXT:    [[SQRT_X:%.*]] = call arcp contract double @llvm.sqrt.f64(double [[X]])
+; CHECK-NEXT:    [[FDIV:%.*]] = fdiv arcp contract double [[Y]], [[SQRT_X]]
+; CHECK-NEXT:    ret double [[FDIV]]
+;
+  %sqrt.x = call arcp contract double @llvm.sqrt.f64(double %x)
+  %fdiv = fdiv arcp contract double %y, %sqrt.x
+  ret double %fdiv
+}
+
+define double @rsq_amdgcn_f64(double %x) {
+; CHECK-LABEL: define double @rsq_amdgcn_f64(
+; CHECK-SAME: double [[X:%.*]]) {
+; CHECK-NEXT:    [[SQRT_X:%.*]] = call contract double @llvm.amdgcn.sqrt.f64(double [[X]])
+; CHECK-NEXT:    [[FDIV:%.*]] = fdiv contract double 1.000000e+00, [[SQRT_X]]
+; CHECK-NEXT:    ret double [[FDIV]]
+;
+  %sqrt.x = call contract double @llvm.amdgcn.sqrt.f64(double %x)
+  %fdiv = fdiv contract double 1.0, %sqrt.x
+  ret double %fdiv
+}
+
+define double @neg_rsq_amdgcn_f64(double %x) {
+; CHECK-LABEL: define double @neg_rsq_amdgcn_f64(
+; CHECK-SAME: double [[X:%.*]]) {
+; CHECK-NEXT:    [[SQRT_X:%.*]] = call contract double @llvm.amdgcn.sqrt.f64(double [[X]])
+; CHECK-NEXT:    [[FDIV:%.*]] = fdiv contract double -1.000000e+00, [[SQRT_X]]
+; CHECK-NEXT:    ret double [[FDIV]]
+;
+  %sqrt.x = call contract double @llvm.amdgcn.sqrt.f64(double %x)
+  %fdiv = fdiv contract double -1.0, %sqrt.x
+  ret double %fdiv
+}
+
+define double @rsq_amdgcn_f64_nnan_ninf(double %x) {
+; CHECK-LABEL: define double @rsq_amdgcn_f64_nnan_ninf(
+; CHECK-SAME: double [[X:%.*]]) {
+; CHECK-NEXT:    [[SQRT_X:%.*]] = call nnan ninf contract double @llvm.amdgcn.sqrt.f64(double [[X]])
+; CHECK-NEXT:    [[FDIV:%.*]] = fdiv nnan ninf contract double 1.000000e+00, [[SQRT_X]]
+; CHECK-NEXT:    ret double [[FDIV]]
+;
+  %sqrt.x = call contract nnan ninf double @llvm.amdgcn.sqrt.f64(double %x)
+  %fdiv = fdiv contract nnan ninf double 1.0, %sqrt.x
+  ret double %fdiv
+}
+
+define double @rsq_f64_input_known_not_zero(double nofpclass(zero) %x) {
+; CHECK-LABEL: define double @rsq_f64_input_known_not_zero(
+; CHECK-SAME: double nofpclass(zero) [[X:%.*]]) {
+; CHECK-NEXT:    [[SQRT_X:%.*]] = call contract double @llvm.sqrt.f64(double [[X]])
+; CHECK-NEXT:    [[FDIV:%.*]] = fdiv contract double 1.000000e+00, [[SQRT_X]]
+; CHECK-NEXT:    ret double [[FDIV]]
+;
+  %sqrt.x = call contract double @llvm.sqrt.f64(double %x)
+  %fdiv = fdiv contract double 1.0, %sqrt.x
+  ret double %fdiv
+}
+
+define double @rsq_f64_input_known_not_pinf(double nofpclass(pinf) %x) {
+; CHECK-LABEL: define double @rsq_f64_input_known_not_pinf(
+; CHECK-SAME: double nofpclass(pinf) [[X:%.*]]) {
+; CHECK-NEXT:    [[SQRT_X:%.*]] = call contract double @llvm.sqrt.f64(double [[X]])
+; CHECK-NEXT:    [[FDIV:%.*]] = fdiv contract double 1.000000e+00, [[SQRT_X]]
+; CHECK-NEXT:    ret double [[FDIV]]
+;
+  %sqrt.x = call contract double @llvm.sqrt.f64(double %x)
+  %fdiv = fdiv contract double 1.0, %sqrt.x
+  ret double %fdiv
+}
+
+define double @rsq_f64_input_known_not_pinf_zero(double nofpclass(pinf zero) %x) {
+; CHECK-LABEL: define double @rsq_f64_input_known_not_pinf_zero(
+; CHECK-SAME: double nofpclass(pinf zero) [[X:%.*]]) {
+; CHECK-NEXT:    [[SQRT_X:%.*]] = call contract double @llvm.sqrt.f64(double [[X]])
+; CHECK-NEXT:    [[FDIV:%.*]] = fdiv contract double 1.000000e+00, [[SQRT_X]]
+; CHECK-NEXT:    ret double [[FDIV]]
+;
+  %sqrt.x = call contract double @llvm.sqrt.f64(double %x)
+  %fdiv = fdiv contract double 1.0, %sqrt.x
+  ret double %fdiv
+}
+
+define double @rsq_f64_input_known_not_pinf_zero_dynamic_fp(double nofpclass(pinf zero) %x) #0 {
+; CHECK-LABEL: define double @rsq_f64_input_known_not_pinf_zero_dynamic_fp(
+; CHECK-SAME: double nofpclass(pinf zero) [[X:%.*]]) #[[ATTR0:[0-9]+]] {
+; CHECK-NEXT:    [[SQRT_X:%.*]] = call contract double @llvm.sqrt.f64(double [[X]])
+; CHECK-NEXT:    [[FDIV:%.*]] = fdiv contract double 1.000000e+00, [[SQRT_X]]
+; CHECK-NEXT:    ret double [[FDIV]]
+;
+  %sqrt.x = call contract double @llvm.sqrt.f64(double %x)
+  %fdiv = fdiv contract double 1.0, %sqrt.x
+  ret double %fdiv
+}
+
+define double @rsq_f64_input_known_not_pinf_zero_daz(double nofpclass(pinf zero) %x) #1 {
+; CHECK-LABEL: define double @rsq_f64_input_known_not_pinf_zero_daz(
+; CHECK-SAME: double nofpclass(pinf zero) [[X:%.*]]) #[[ATTR1:[0-9]+]] {
+; CHECK-NEXT:    [[SQRT_X:%.*]] = call contract double @llvm.sqrt.f64(double [[X]])
+; CHECK-NEXT:    [[FDIV:%.*]] = fdiv contract double 1.000000e+00, [[SQRT_X]]
+; CHECK-NEXT:    ret double [[FDIV]]
+;
+  %sqrt.x = call contract double @llvm.sqrt.f64(double %x)
+  %fdiv = fdiv contract double 1.0, %sqrt.x
+  ret double %fdiv
+}
+
+define double @rsq_f64_input_known_not_pinf_zero_denorm_daz(double nofpclass(pinf zero sub) %x) #1 {
+; CHECK-LABEL: define double @rsq_f64_input_known_not_pinf_zero_denorm_daz(
+; CHECK-SAME: double nofpclass(pinf zero sub) [[X:%.*]]) #[[ATTR1]] {
+; CHECK-NEXT:    [[SQRT_X:%.*]] = call contract double @llvm.sqrt.f64(double [[X]])
+; CHECK-NEXT:    [[FDIV:%.*]] = fdiv contract double 1.000000e+00, [[SQRT_X]]
+; CHECK-NEXT:    ret double [[FDIV]]
+;
+  %sqrt.x = call contract double @llvm.sqrt.f64(double %x)
+  %fdiv = fdiv contract double 1.0, %sqrt.x
+  ret double %fdiv
+}
+
+define double @rsq_f64_dynamic_denormal(double %x) #0 {
+; CHECK-LABEL: define double @rsq_f64_dynamic_denormal(
+; CHECK-SAME: double [[X:%.*]]) #[[ATTR0]] {
+; CHECK-NEXT:    [[SQRT_X:%.*]] = call contract double @llvm.sqrt.f64(double [[X]])
+; CHECK-NEXT:    [[FDIV:%.*]] = fdiv contract double 1.000000e+00, [[SQRT_X]]
+; CHECK-NEXT:    ret double [[FDIV]]
+;
+  %sqrt.x = call contract double @llvm.sqrt.f64(double %x)
+  %fdiv = fdiv contract double 1.0, %sqrt.x
+  ret double %fdiv
+}
+
+define double @rsq_f64_dynamic_denormal_no_pinf(double nofpclass(pinf) %x) #0 {
+; CHECK-LABEL: define double @rsq_f64_dynamic_denormal_no_pinf(
+; CHECK-SAME: double nofpclass(pinf) [[X:%.*]]) #[[ATTR0]] {
+; CHECK-NEXT:    [[SQRT_X:%.*]] = call contract double @llvm.sqrt.f64(double [[X]])
+; CHECK-NEXT:    [[FDIV:%.*]] = fdiv contract double 1.000000e+00, [[SQRT_X]]
+; CHECK-NEXT:    ret double [[FDIV]]
+;
+  %sqrt.x = call contract double @llvm.sqrt.f64(double %x)
+  %fdiv = fdiv contract double 1.0, %sqrt.x
+  ret double %fdiv
+}
+
+define double @rsq_f64_dynamic_denormal_no_zero_no_denorm(double nofpclass(zero sub) %x) #0 {
+; CHECK-LABEL: define double @rsq_f64_dynamic_denormal_no_zero_no_denorm(
+; CHECK-SAME: double nofpclass(zero sub) [[X:%.*]]) #[[ATTR0]] {
+; CHECK-NEXT:    [[SQRT_X:%.*]] = call contract double @llvm.sqrt.f64(double [[X]])
+; CHECK-NEXT:    [[FDIV:%.*]] = fdiv contract double 1.000000e+00, [[SQRT_X]]
+; CHECK-NEXT:    ret double [[FDIV]]
+;
+  %sqrt.x = call contract double @llvm.sqrt.f64(double %x)
+  %fdiv = fdiv contract double 1.0, %sqrt.x
+  ret double %fdiv
+}
+
+define double @rsq_f64_nnan_sqrt(double %x) {
+; CHECK-LABEL: define double @rsq_f64_nnan_sqrt(
+; CHECK-SAME: double [[X:%.*]]) {
+; CHECK-NEXT:    [[SQRT_X:%.*]] = call nnan contract double @llvm.sqrt.f64(double [[X]])
+; CHECK-NEXT:    [[FDIV:%.*]] = fdiv contract double 1.000000e+00, [[SQRT_X]]
+; CHECK-NEXT:    ret double [[FDIV]]
+;
+  %sqrt.x = call contract nnan double @llvm.sqrt.f64(double %x)
+  %fdiv = fdiv contract double 1.0, %sqrt.x
+  ret double %fdiv
+}
+
+define double @rsq_f64_nnan_fdiv(double %x) {
+; CHECK-LABEL: define double @rsq_f64_nnan_fdiv(
+; CHECK-SAME: double [[X:%.*]]) {
+; CHECK-NEXT:    [[SQRT_X:%.*]] = call contract double @llvm.sqrt.f64(double [[X]])
+; CHECK-NEXT:    [[FDIV:%.*]] = fdiv nnan contract double 1.000000e+00, [[SQRT_X]]
+; CHECK-NEXT:    ret double [[FDIV]]
+;
+  %sqrt.x = call contract double @llvm.sqrt.f64(double %x)
+  %fdiv = fdiv contract nnan double 1.0, %sqrt.x
+  ret double %fdiv
+}
+
+define double @rsq_f64_ninf_sqrt(double %x) {
+; CHECK-LABEL: define double @rsq_f64_ninf_sqrt(
+; CHECK-SAME: double [[X:%.*]]) {
+; CHECK-NEXT:    [[SQRT_X:%.*]] = call ninf contract double @llvm.sqrt.f64(double [[X]])
+; CHECK-NEXT:    [[FDIV:%.*]] = fdiv contract double 1.000000e+00, [[SQRT_X]]
+; CHECK-NEXT:    ret double [[FDIV]]
+;
+  %sqrt.x = call contract ninf double @llvm.sqrt.f64(double %x)
+  %fdiv = fdiv contract double 1.0, %sqrt.x
+  ret double %fdiv
+}
+
+define double @rsq_f64_ninf_fdiv(double %x) {
+; CHECK-LABEL: define double @rsq_f64_ninf_fdiv(
+; CHECK-SAME: double [[X:%.*]]) {
+; CHECK-NEXT:    [[SQRT_X:%.*]] = call contract double @llvm.sqrt.f64(double [[X]])
+; CHECK-NEXT:    [[FDIV:%.*]] = fdiv ninf contract double 1.000000e+00, [[SQRT_X]]
+; CHECK-NEXT:    ret double [[FDIV]]
+;
+  %sqrt.x = call contract double @llvm.sqrt.f64(double %x)
+  %fdiv = fdiv contract ninf double 1.0, %sqrt.x
+  ret double %fdiv
+}
+
+define double @rsq_f64_ninf_sqrt_nnan_fdiv(double %x) {
+; CHECK-LABEL: define double @rsq_f64_ninf_sqrt_nnan_fdiv(
+; CHECK-SAME: double [[X:%.*]]) {
+; CHECK-NEXT:    [[SQRT_X:%.*]] = call ninf contract double @llvm.sqrt.f64(double [[X]])
+; CHECK-NEXT:    [[FDIV:%.*]] = fdiv nnan contract double 1.000000e+00, [[SQRT_X]]
+; CHECK-NEXT:    ret double [[FDIV]]...
[truncated]

@arsenm arsenm marked this pull request as ready for review December 12, 2025 17:44
@arsenm arsenm mentioned this pull request Dec 12, 2025
Open
@arsenm arsenm force-pushed the users/arsenm/amdgpu/add-baseline-tests-f64-rsq-codegenprepare branch from 76822a0 to 02e6b0e Compare December 14, 2025 17:04
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Reviewers

@dtcxzyw dtcxzyw Awaiting requested review from dtcxzyw

@jayfoad jayfoad Awaiting requested review from jayfoad

@Pierre-vh Pierre-vh Awaiting requested review from Pierre-vh

@shiltian shiltian Awaiting requested review from shiltian

Assignees

No one assigned

Labels

backend:AMDGPU floating-point Floating-point math

Projects

None yet

Milestone

No milestone

Development

Successfully merging this pull request may close these issues.

3 participants

@arsenm @llvmbot