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
881 lines
31 KiB
LLVM
881 lines
31 KiB
LLVM
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 5
|
|
; RUN: opt < %s -passes=instsimplify -march=nvptx64 --mcpu=sm_86 --mattr=+ptx72 -S | FileCheck %s
|
|
|
|
; Check constant-folding for NVVM divide intrinsics with different rounding modes
|
|
|
|
;###############################################################
|
|
;# Div(1.25, 2.0) #
|
|
;###############################################################
|
|
; Tests division of two normal numbers (1.25 by 2.0) where the result
|
|
; is exactly representable. All rounding modes should produce the same result.
|
|
|
|
define double @test_1_25_div_2_rm_d() {
|
|
; CHECK-LABEL: define double @test_1_25_div_2_rm_d() {
|
|
; CHECK-NEXT: ret double 6.250000e-01
|
|
;
|
|
%res = call double @llvm.nvvm.div.rm.d(double 1.25, double 2.0)
|
|
ret double %res
|
|
}
|
|
|
|
define double @test_1_25_div_2_rn_d() {
|
|
; CHECK-LABEL: define double @test_1_25_div_2_rn_d() {
|
|
; CHECK-NEXT: ret double 6.250000e-01
|
|
;
|
|
%res = call double @llvm.nvvm.div.rn.d(double 1.25, double 2.0)
|
|
ret double %res
|
|
}
|
|
|
|
define double @test_1_25_div_2_rp_d() {
|
|
; CHECK-LABEL: define double @test_1_25_div_2_rp_d() {
|
|
; CHECK-NEXT: ret double 6.250000e-01
|
|
;
|
|
%res = call double @llvm.nvvm.div.rp.d(double 1.25, double 2.0)
|
|
ret double %res
|
|
}
|
|
|
|
define double @test_1_25_div_2_rz_d() {
|
|
; CHECK-LABEL: define double @test_1_25_div_2_rz_d() {
|
|
; CHECK-NEXT: ret double 6.250000e-01
|
|
;
|
|
%res = call double @llvm.nvvm.div.rz.d(double 1.25, double 2.0)
|
|
ret double %res
|
|
}
|
|
|
|
define float @test_1_25_div_2_rm_f() {
|
|
; CHECK-LABEL: define float @test_1_25_div_2_rm_f() {
|
|
; CHECK-NEXT: ret float 6.250000e-01
|
|
;
|
|
%res = call float @llvm.nvvm.div.rm.f(float 1.25, float 2.0)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_1_25_div_2_rn_f() {
|
|
; CHECK-LABEL: define float @test_1_25_div_2_rn_f() {
|
|
; CHECK-NEXT: ret float 6.250000e-01
|
|
;
|
|
%res = call float @llvm.nvvm.div.rn.f(float 1.25, float 2.0)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_1_25_div_2_rp_f() {
|
|
; CHECK-LABEL: define float @test_1_25_div_2_rp_f() {
|
|
; CHECK-NEXT: ret float 6.250000e-01
|
|
;
|
|
%res = call float @llvm.nvvm.div.rp.f(float 1.25, float 2.0)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_1_25_div_2_rz_f() {
|
|
; CHECK-LABEL: define float @test_1_25_div_2_rz_f() {
|
|
; CHECK-NEXT: ret float 6.250000e-01
|
|
;
|
|
%res = call float @llvm.nvvm.div.rz.f(float 1.25, float 2.0)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_1_25_div_2_rm_ftz_f() {
|
|
; CHECK-LABEL: define float @test_1_25_div_2_rm_ftz_f() {
|
|
; CHECK-NEXT: ret float 6.250000e-01
|
|
;
|
|
%res = call float @llvm.nvvm.div.rm.ftz.f(float 1.25, float 2.0)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_1_25_div_2_rn_ftz_f() {
|
|
; CHECK-LABEL: define float @test_1_25_div_2_rn_ftz_f() {
|
|
; CHECK-NEXT: ret float 6.250000e-01
|
|
;
|
|
%res = call float @llvm.nvvm.div.rn.ftz.f(float 1.25, float 2.0)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_1_25_div_2_rp_ftz_f() {
|
|
; CHECK-LABEL: define float @test_1_25_div_2_rp_ftz_f() {
|
|
; CHECK-NEXT: ret float 6.250000e-01
|
|
;
|
|
%res = call float @llvm.nvvm.div.rp.ftz.f(float 1.25, float 2.0)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_1_25_div_2_rz_ftz_f() {
|
|
; CHECK-LABEL: define float @test_1_25_div_2_rz_ftz_f() {
|
|
; CHECK-NEXT: ret float 6.250000e-01
|
|
;
|
|
%res = call float @llvm.nvvm.div.rz.ftz.f(float 1.25, float 2.0)
|
|
ret float %res
|
|
}
|
|
|
|
;###############################################################
|
|
;# Div(Subnormal, 1.0) #
|
|
;###############################################################
|
|
; Tests division of a subnormal number by 1.0 to verify FTZ behavior.
|
|
; For float, we use 2^-149 (smallest subnormal).
|
|
; For double, we use 2^-1074 (smallest subnormal).
|
|
; Without FTZ, the result should be the subnormal number.
|
|
; With FTZ, the result should be 0.0.
|
|
|
|
define double @test_subnorm_div_1_rm_d() {
|
|
; CHECK-LABEL: define double @test_subnorm_div_1_rm_d() {
|
|
; CHECK-NEXT: ret double 4.940660e-324
|
|
;
|
|
%res = call double @llvm.nvvm.div.rm.d(double 0x0000000000000001, double 1.0)
|
|
ret double %res
|
|
}
|
|
|
|
define double @test_subnorm_div_1_rn_d() {
|
|
; CHECK-LABEL: define double @test_subnorm_div_1_rn_d() {
|
|
; CHECK-NEXT: ret double 4.940660e-324
|
|
;
|
|
%res = call double @llvm.nvvm.div.rn.d(double 0x0000000000000001, double 1.0)
|
|
ret double %res
|
|
}
|
|
|
|
define double @test_subnorm_div_1_rp_d() {
|
|
; CHECK-LABEL: define double @test_subnorm_div_1_rp_d() {
|
|
; CHECK-NEXT: ret double 4.940660e-324
|
|
;
|
|
%res = call double @llvm.nvvm.div.rp.d(double 0x0000000000000001, double 1.0)
|
|
ret double %res
|
|
}
|
|
|
|
define double @test_subnorm_div_1_rz_d() {
|
|
; CHECK-LABEL: define double @test_subnorm_div_1_rz_d() {
|
|
; CHECK-NEXT: ret double 4.940660e-324
|
|
;
|
|
%res = call double @llvm.nvvm.div.rz.d(double 0x0000000000000001, double 1.0)
|
|
ret double %res
|
|
}
|
|
|
|
define float @test_subnorm_div_1_rm_f() {
|
|
; CHECK-LABEL: define float @test_subnorm_div_1_rm_f() {
|
|
; CHECK-NEXT: ret float 1.401300e-45
|
|
;
|
|
%res = call float @llvm.nvvm.div.rm.f(float 0x36A0000000000000, float 1.0)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_subnorm_div_1_rn_f() {
|
|
; CHECK-LABEL: define float @test_subnorm_div_1_rn_f() {
|
|
; CHECK-NEXT: ret float 1.401300e-45
|
|
;
|
|
%res = call float @llvm.nvvm.div.rn.f(float 0x36A0000000000000, float 1.0)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_subnorm_div_1_rp_f() {
|
|
; CHECK-LABEL: define float @test_subnorm_div_1_rp_f() {
|
|
; CHECK-NEXT: ret float 1.401300e-45
|
|
;
|
|
%res = call float @llvm.nvvm.div.rp.f(float 0x36A0000000000000, float 1.0)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_subnorm_div_1_rz_f() {
|
|
; CHECK-LABEL: define float @test_subnorm_div_1_rz_f() {
|
|
; CHECK-NEXT: ret float 1.401300e-45
|
|
;
|
|
%res = call float @llvm.nvvm.div.rz.f(float 0x36A0000000000000, float 1.0)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_subnorm_div_1_rm_ftz_f() {
|
|
; CHECK-LABEL: define float @test_subnorm_div_1_rm_ftz_f() {
|
|
; CHECK-NEXT: ret float 0.000000e+00
|
|
;
|
|
%res = call float @llvm.nvvm.div.rm.ftz.f(float 0x36A0000000000000, float 1.0)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_subnorm_div_1_rn_ftz_f() {
|
|
; CHECK-LABEL: define float @test_subnorm_div_1_rn_ftz_f() {
|
|
; CHECK-NEXT: ret float 0.000000e+00
|
|
;
|
|
%res = call float @llvm.nvvm.div.rn.ftz.f(float 0x36A0000000000000, float 1.0)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_subnorm_div_1_rp_ftz_f() {
|
|
; CHECK-LABEL: define float @test_subnorm_div_1_rp_ftz_f() {
|
|
; CHECK-NEXT: ret float 0.000000e+00
|
|
;
|
|
%res = call float @llvm.nvvm.div.rp.ftz.f(float 0x36A0000000000000, float 1.0)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_subnorm_div_1_rz_ftz_f() {
|
|
; CHECK-LABEL: define float @test_subnorm_div_1_rz_ftz_f() {
|
|
; CHECK-NEXT: ret float 0.000000e+00
|
|
;
|
|
%res = call float @llvm.nvvm.div.rz.ftz.f(float 0x36A0000000000000, float 1.0)
|
|
ret float %res
|
|
}
|
|
|
|
;###############################################################
|
|
;# Div(Normal, Normal) -> Subnormal #
|
|
;###############################################################
|
|
; Tests division of two normal numbers that produces a subnormal result.
|
|
; We divide the smallest normal float (2^-126 or 2^-1022 for doubles) by 2 to get 2^-127 (or 2^-1023),
|
|
; which is subnormal. This tests the transition from normal to subnormal numbers.
|
|
|
|
define double @test_normal_div_normal_to_subnorm_rm_d() {
|
|
; CHECK-LABEL: define double @test_normal_div_normal_to_subnorm_rm_d() {
|
|
; CHECK-NEXT: ret double f0x0008000000000000
|
|
;
|
|
%res = call double @llvm.nvvm.div.rm.d(double 0x10000000000000, double 2.0)
|
|
ret double %res
|
|
}
|
|
|
|
define double @test_normal_div_normal_to_subnorm_rn_d() {
|
|
; CHECK-LABEL: define double @test_normal_div_normal_to_subnorm_rn_d() {
|
|
; CHECK-NEXT: ret double f0x0008000000000000
|
|
;
|
|
%res = call double @llvm.nvvm.div.rn.d(double 0x10000000000000, double 2.0)
|
|
ret double %res
|
|
}
|
|
|
|
define double @test_normal_div_normal_to_subnorm_rp_d() {
|
|
; CHECK-LABEL: define double @test_normal_div_normal_to_subnorm_rp_d() {
|
|
; CHECK-NEXT: ret double f0x0008000000000000
|
|
;
|
|
%res = call double @llvm.nvvm.div.rp.d(double 0x10000000000000, double 2.0)
|
|
ret double %res
|
|
}
|
|
|
|
define double @test_normal_div_normal_to_subnorm_rz_d() {
|
|
; CHECK-LABEL: define double @test_normal_div_normal_to_subnorm_rz_d() {
|
|
; CHECK-NEXT: ret double f0x0008000000000000
|
|
;
|
|
%res = call double @llvm.nvvm.div.rz.d(double 0x10000000000000, double 2.0)
|
|
ret double %res
|
|
}
|
|
|
|
define float @test_normal_div_normal_to_subnorm_rm_f() {
|
|
; CHECK-LABEL: define float @test_normal_div_normal_to_subnorm_rm_f() {
|
|
; CHECK-NEXT: ret float f0x00400000
|
|
;
|
|
%res = call float @llvm.nvvm.div.rm.f(float 0x3810000000000000, float 2.0)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_normal_div_normal_to_subnorm_rn_f() {
|
|
; CHECK-LABEL: define float @test_normal_div_normal_to_subnorm_rn_f() {
|
|
; CHECK-NEXT: ret float f0x00400000
|
|
;
|
|
%res = call float @llvm.nvvm.div.rn.f(float 0x3810000000000000, float 2.0)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_normal_div_normal_to_subnorm_rp_f() {
|
|
; CHECK-LABEL: define float @test_normal_div_normal_to_subnorm_rp_f() {
|
|
; CHECK-NEXT: ret float f0x00400000
|
|
;
|
|
%res = call float @llvm.nvvm.div.rp.f(float 0x3810000000000000, float 2.0)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_normal_div_normal_to_subnorm_rz_f() {
|
|
; CHECK-LABEL: define float @test_normal_div_normal_to_subnorm_rz_f() {
|
|
; CHECK-NEXT: ret float f0x00400000
|
|
;
|
|
%res = call float @llvm.nvvm.div.rz.f(float 0x3810000000000000, float 2.0)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_normal_div_normal_to_subnorm_rm_ftz_f() {
|
|
; CHECK-LABEL: define float @test_normal_div_normal_to_subnorm_rm_ftz_f() {
|
|
; CHECK-NEXT: ret float 0.000000e+00
|
|
;
|
|
%res = call float @llvm.nvvm.div.rm.ftz.f(float 0x3810000000000000, float 2.0)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_normal_div_normal_to_subnorm_rn_ftz_f() {
|
|
; CHECK-LABEL: define float @test_normal_div_normal_to_subnorm_rn_ftz_f() {
|
|
; CHECK-NEXT: ret float 0.000000e+00
|
|
;
|
|
%res = call float @llvm.nvvm.div.rn.ftz.f(float 0x3810000000000000, float 2.0)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_normal_div_normal_to_subnorm_rp_ftz_f() {
|
|
; CHECK-LABEL: define float @test_normal_div_normal_to_subnorm_rp_ftz_f() {
|
|
; CHECK-NEXT: ret float 0.000000e+00
|
|
;
|
|
%res = call float @llvm.nvvm.div.rp.ftz.f(float 0x3810000000000000, float 2.0)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_normal_div_normal_to_subnorm_rz_ftz_f() {
|
|
; CHECK-LABEL: define float @test_normal_div_normal_to_subnorm_rz_ftz_f() {
|
|
; CHECK-NEXT: ret float 0.000000e+00
|
|
;
|
|
%res = call float @llvm.nvvm.div.rz.ftz.f(float 0x3810000000000000, float 2.0)
|
|
ret float %res
|
|
}
|
|
|
|
;###############################################################
|
|
;# Div( 4/3 + epsilon , 4/3 - epsilon) #
|
|
;###############################################################
|
|
; Tests division of numbers just above and just below 4/3.
|
|
; The result falls between 1.0 and 1.0 + 2^-23
|
|
; - RZ, RM round to 1.0 (rounding towards zero/down)
|
|
; - RN, RP rounds to 1.0 + 2^-23 (rounding towards nearest/up)
|
|
|
|
define float @test_div_just_above_1_rm_f() {
|
|
; CHECK-LABEL: define float @test_div_just_above_1_rm_f() {
|
|
; CHECK-NEXT: ret float 1.000000e+00
|
|
;
|
|
%res = call float @llvm.nvvm.div.rm.f(float 0x3FF5555560000000, float 0x3FF5555540000000)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_div_just_above_1_rn_f() {
|
|
; CHECK-LABEL: define float @test_div_just_above_1_rn_f() {
|
|
; CHECK-NEXT: ret float f0x3F800001
|
|
;
|
|
%res = call float @llvm.nvvm.div.rn.f(float 0x3FF5555560000000, float 0x3FF5555540000000)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_div_just_above_1_rp_f() {
|
|
; CHECK-LABEL: define float @test_div_just_above_1_rp_f() {
|
|
; CHECK-NEXT: ret float f0x3F800001
|
|
;
|
|
%res = call float @llvm.nvvm.div.rp.f(float 0x3FF5555560000000, float 0x3FF5555540000000)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_div_just_above_1_rz_f() {
|
|
; CHECK-LABEL: define float @test_div_just_above_1_rz_f() {
|
|
; CHECK-NEXT: ret float 1.000000e+00
|
|
;
|
|
%res = call float @llvm.nvvm.div.rz.f(float 0x3FF5555560000000, float 0x3FF5555540000000)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_div_just_above_1_rm_ftz_f() {
|
|
; CHECK-LABEL: define float @test_div_just_above_1_rm_ftz_f() {
|
|
; CHECK-NEXT: ret float 1.000000e+00
|
|
;
|
|
%res = call float @llvm.nvvm.div.rm.ftz.f(float 0x3FF5555560000000, float 0x3FF5555540000000)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_div_just_above_1_rn_ftz_f() {
|
|
; CHECK-LABEL: define float @test_div_just_above_1_rn_ftz_f() {
|
|
; CHECK-NEXT: ret float f0x3F800001
|
|
;
|
|
%res = call float @llvm.nvvm.div.rn.ftz.f(float 0x3FF5555560000000, float 0x3FF5555540000000)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_div_just_above_1_rp_ftz_f() {
|
|
; CHECK-LABEL: define float @test_div_just_above_1_rp_ftz_f() {
|
|
; CHECK-NEXT: ret float f0x3F800001
|
|
;
|
|
%res = call float @llvm.nvvm.div.rp.ftz.f(float 0x3FF5555560000000, float 0x3FF5555540000000)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_div_just_above_1_rz_ftz_f() {
|
|
; CHECK-LABEL: define float @test_div_just_above_1_rz_ftz_f() {
|
|
; CHECK-NEXT: ret float 1.000000e+00
|
|
;
|
|
%res = call float @llvm.nvvm.div.rz.ftz.f(float 0x3FF5555560000000, float 0x3FF5555540000000)
|
|
ret float %res
|
|
}
|
|
|
|
;###############################################################
|
|
;# Div(4/3 + epsilon / 4/3 - epsilon) #
|
|
;###############################################################
|
|
; Tests division of numbers just above and just below 4/3.
|
|
; The result falls between 1.0 and 1.0 + 2^-52
|
|
; - RZ, RM round to 1.0 (rounding towards zero/down)
|
|
; - RN, RP rounds to 1.0 + 2^-23 (rounding towards nearest/up)
|
|
|
|
define double @test_div_just_above_1_rm_d() {
|
|
; CHECK-LABEL: define double @test_div_just_above_1_rm_d() {
|
|
; CHECK-NEXT: ret double 1.000000e+00
|
|
;
|
|
%res = call double @llvm.nvvm.div.rm.d(double 0x3FF5555555555555, double 0x3FF5555555555554)
|
|
ret double %res
|
|
}
|
|
|
|
define double @test_div_just_above_1_rn_d() {
|
|
; CHECK-LABEL: define double @test_div_just_above_1_rn_d() {
|
|
; CHECK-NEXT: ret double f0x3FF0000000000001
|
|
;
|
|
%res = call double @llvm.nvvm.div.rn.d(double 0x3FF5555555555555, double 0x3FF5555555555554)
|
|
ret double %res
|
|
}
|
|
|
|
define double @test_div_just_above_1_rp_d() {
|
|
; CHECK-LABEL: define double @test_div_just_above_1_rp_d() {
|
|
; CHECK-NEXT: ret double f0x3FF0000000000001
|
|
;
|
|
%res = call double @llvm.nvvm.div.rp.d(double 0x3FF5555555555555, double 0x3FF5555555555554)
|
|
ret double %res
|
|
}
|
|
|
|
define double @test_div_just_above_1_rz_d() {
|
|
; CHECK-LABEL: define double @test_div_just_above_1_rz_d() {
|
|
; CHECK-NEXT: ret double 1.000000e+00
|
|
;
|
|
%res = call double @llvm.nvvm.div.rz.d(double 0x3FF5555555555555, double 0x3FF5555555555554)
|
|
ret double %res
|
|
}
|
|
|
|
;###############################################################
|
|
;# Div( -(4/3 + epsilon), 4/3 - epsilon ) #
|
|
;###############################################################
|
|
; Tests division of numbers just below -4/3 and just below 4/3.
|
|
; The result falls between -1.0 and -1.0 - 2^-52
|
|
; - RZ, RP round to -1.0 (rounding towards zero/up)
|
|
; - RN, RM rounds to -1.0 - 2^-52 (rounding towards nearest/down)
|
|
|
|
define float @test_div_just_below_negative_1_rm_f() {
|
|
; CHECK-LABEL: define float @test_div_just_below_negative_1_rm_f() {
|
|
; CHECK-NEXT: ret float f0xBF800001
|
|
;
|
|
%res = call float @llvm.nvvm.div.rm.f(float 0xBFF5555560000000, float 0x3FF5555540000000)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_div_just_below_negative_1_rn_f() {
|
|
; CHECK-LABEL: define float @test_div_just_below_negative_1_rn_f() {
|
|
; CHECK-NEXT: ret float f0xBF800001
|
|
;
|
|
%res = call float @llvm.nvvm.div.rn.f(float 0xBFF5555560000000, float 0x3FF5555540000000)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_div_just_below_negative_1_rp_f() {
|
|
; CHECK-LABEL: define float @test_div_just_below_negative_1_rp_f() {
|
|
; CHECK-NEXT: ret float -1.000000e+00
|
|
;
|
|
%res = call float @llvm.nvvm.div.rp.f(float 0xBFF5555560000000, float 0x3FF5555540000000)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_div_just_below_negative_1_rz_f() {
|
|
; CHECK-LABEL: define float @test_div_just_below_negative_1_rz_f() {
|
|
; CHECK-NEXT: ret float -1.000000e+00
|
|
;
|
|
%res = call float @llvm.nvvm.div.rz.f(float 0xBFF5555560000000, float 0x3FF5555540000000)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_div_just_below_negative_1_rm_ftz_f() {
|
|
; CHECK-LABEL: define float @test_div_just_below_negative_1_rm_ftz_f() {
|
|
; CHECK-NEXT: ret float f0xBF800001
|
|
;
|
|
%res = call float @llvm.nvvm.div.rm.ftz.f(float 0xBFF5555560000000, float 0x3FF5555540000000)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_div_just_below_negative_1_rn_ftz_f() {
|
|
; CHECK-LABEL: define float @test_div_just_below_negative_1_rn_ftz_f() {
|
|
; CHECK-NEXT: ret float f0xBF800001
|
|
;
|
|
%res = call float @llvm.nvvm.div.rn.ftz.f(float 0xBFF5555560000000, float 0x3FF5555540000000)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_div_just_below_negative_1_rp_ftz_f() {
|
|
; CHECK-LABEL: define float @test_div_just_below_negative_1_rp_ftz_f() {
|
|
; CHECK-NEXT: ret float -1.000000e+00
|
|
;
|
|
%res = call float @llvm.nvvm.div.rp.ftz.f(float 0xBFF5555560000000, float 0x3FF5555540000000)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_div_just_below_negative_1_rz_ftz_f() {
|
|
; CHECK-LABEL: define float @test_div_just_below_negative_1_rz_ftz_f() {
|
|
; CHECK-NEXT: ret float -1.000000e+00
|
|
;
|
|
%res = call float @llvm.nvvm.div.rz.ftz.f(float 0xBFF5555560000000, float 0x3FF5555540000000)
|
|
ret float %res
|
|
}
|
|
|
|
;###############################################################
|
|
;# Div( -(4/3 + epsilon), 4/3 - epsilon ) #
|
|
;###############################################################
|
|
; Tests division of numbers just below -4/3 and just below 4/3.
|
|
; The result falls between -1.0 and -1.0 - 2^-52
|
|
; - RZ, RP round to -1.0 (rounding towards zero/up)
|
|
; - RN, RM rounds to -1.0 - 2^-52 (rounding towards nearest/down)
|
|
|
|
define double @test_div_just_below_negative_1_rm_d() {
|
|
; CHECK-LABEL: define double @test_div_just_below_negative_1_rm_d() {
|
|
; CHECK-NEXT: ret double f0xBFF0000000000001
|
|
;
|
|
%res = call double @llvm.nvvm.div.rm.d(double 0xBFF5555555555555, double 0x3FF5555555555554)
|
|
ret double %res
|
|
}
|
|
|
|
define double @test_div_just_below_negative_1_rn_d() {
|
|
; CHECK-LABEL: define double @test_div_just_below_negative_1_rn_d() {
|
|
; CHECK-NEXT: ret double f0xBFF0000000000001
|
|
;
|
|
%res = call double @llvm.nvvm.div.rn.d(double 0xBFF5555555555555, double 0x3FF5555555555554)
|
|
ret double %res
|
|
}
|
|
|
|
define double @test_div_just_below_negative_1_rp_d() {
|
|
; CHECK-LABEL: define double @test_div_just_below_negative_1_rp_d() {
|
|
; CHECK-NEXT: ret double -1.000000e+00
|
|
;
|
|
%res = call double @llvm.nvvm.div.rp.d(double 0xBFF5555555555555, double 0x3FF5555555555554)
|
|
ret double %res
|
|
}
|
|
|
|
define double @test_div_just_below_negative_1_rz_d() {
|
|
; CHECK-LABEL: define double @test_div_just_below_negative_1_rz_d() {
|
|
; CHECK-NEXT: ret double -1.000000e+00
|
|
;
|
|
%res = call double @llvm.nvvm.div.rz.d(double 0xBFF5555555555555, double 0x3FF5555555555554)
|
|
ret double %res
|
|
}
|
|
|
|
;###############################################################
|
|
;# Div(~4/3 , ~4/3 + epsilon) #
|
|
;###############################################################
|
|
; Tests division of ~4/3 by a value just over 4/3
|
|
; The exact result falls between 1.0 - 2^23 ( = 0x3FEFFFFFC0000000)
|
|
; and 1.0 - (2^23 + 2^24) ( = 0x3FEFFFFFA0000000).
|
|
; - RN, RZ, RM round to 1.0 - 2^-23 - 2^-24 (rounding towards nearest/zero/down)
|
|
; - RP rounds to 1.0 - 2^-23 (rounding up)
|
|
|
|
define float @test_div_just_below_1_rm_f() {
|
|
; CHECK-LABEL: define float @test_div_just_below_1_rm_f() {
|
|
; CHECK-NEXT: ret float f0x3F7FFFFD
|
|
;
|
|
%res = call float @llvm.nvvm.div.rm.f(float 0x3FF5555540000000, float 0x3FF5555580000000)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_div_just_below_1_rn_f() {
|
|
; CHECK-LABEL: define float @test_div_just_below_1_rn_f() {
|
|
; CHECK-NEXT: ret float f0x3F7FFFFD
|
|
;
|
|
%res = call float @llvm.nvvm.div.rn.f(float 0x3FF5555540000000, float 0x3FF5555580000000)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_div_just_below_1_rp_f() {
|
|
; CHECK-LABEL: define float @test_div_just_below_1_rp_f() {
|
|
; CHECK-NEXT: ret float f0x3F7FFFFE
|
|
;
|
|
%res = call float @llvm.nvvm.div.rp.f(float 0x3FF5555540000000, float 0x3FF5555580000000)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_div_just_below_1_rz_f() {
|
|
; CHECK-LABEL: define float @test_div_just_below_1_rz_f() {
|
|
; CHECK-NEXT: ret float f0x3F7FFFFD
|
|
;
|
|
%res = call float @llvm.nvvm.div.rz.f(float 0x3FF5555540000000, float 0x3FF5555580000000)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_div_just_below_1_rm_ftz_f() {
|
|
; CHECK-LABEL: define float @test_div_just_below_1_rm_ftz_f() {
|
|
; CHECK-NEXT: ret float f0x3F7FFFFD
|
|
;
|
|
%res = call float @llvm.nvvm.div.rm.ftz.f(float 0x3FF5555540000000, float 0x3FF5555580000000)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_div_just_below_1_rn_ftz_f() {
|
|
; CHECK-LABEL: define float @test_div_just_below_1_rn_ftz_f() {
|
|
; CHECK-NEXT: ret float f0x3F7FFFFD
|
|
;
|
|
%res = call float @llvm.nvvm.div.rn.ftz.f(float 0x3FF5555540000000, float 0x3FF5555580000000)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_div_just_below_1_rp_ftz_f() {
|
|
; CHECK-LABEL: define float @test_div_just_below_1_rp_ftz_f() {
|
|
; CHECK-NEXT: ret float f0x3F7FFFFE
|
|
;
|
|
%res = call float @llvm.nvvm.div.rp.ftz.f(float 0x3FF5555540000000, float 0x3FF5555580000000)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_div_just_below_1_rz_ftz_f() {
|
|
; CHECK-LABEL: define float @test_div_just_below_1_rz_ftz_f() {
|
|
; CHECK-NEXT: ret float f0x3F7FFFFD
|
|
;
|
|
%res = call float @llvm.nvvm.div.rz.ftz.f(float 0x3FF5555540000000, float 0x3FF5555580000000)
|
|
ret float %res
|
|
}
|
|
|
|
;###############################################################
|
|
;# Div(~4/3 , ~4/3 + epsilon) #
|
|
;###############################################################
|
|
; Tests division of ~4/3 by a value just over 4/3
|
|
; The exact result falls between 1.0 - 2^-51 - 2^-52 ( = 0x3FEFFFFFFFFFFFFA)
|
|
; and 1.0 - 2^-51 - 2^-53 ( = 0x3FEFFFFFFFFFFFFB).
|
|
; - RN, RZ, RM round to 1.0 - 2^-51 - 2^-52 (rounding towards nearest/zero/down)
|
|
; - RP rounds to 1.0 - 2^-51 - 2^-53 (rounding up)
|
|
|
|
define double @test_div_just_below_1_rm_d() {
|
|
; CHECK-LABEL: define double @test_div_just_below_1_rm_d() {
|
|
; CHECK-NEXT: ret double f0x3FEFFFFFFFFFFFFA
|
|
;
|
|
%res = call double @llvm.nvvm.div.rm.d(double 0x3FF5555555555554, double 0x3FF5555555555558)
|
|
ret double %res
|
|
}
|
|
|
|
define double @test_div_just_below_1_rn_d() {
|
|
; CHECK-LABEL: define double @test_div_just_below_1_rn_d() {
|
|
; CHECK-NEXT: ret double f0x3FEFFFFFFFFFFFFA
|
|
;
|
|
%res = call double @llvm.nvvm.div.rn.d(double 0x3FF5555555555554, double 0x3FF5555555555558)
|
|
ret double %res
|
|
}
|
|
|
|
define double @test_div_just_below_1_rp_d() {
|
|
; CHECK-LABEL: define double @test_div_just_below_1_rp_d() {
|
|
; CHECK-NEXT: ret double f0x3FEFFFFFFFFFFFFB
|
|
;
|
|
%res = call double @llvm.nvvm.div.rp.d(double 0x3FF5555555555554, double 0x3FF5555555555558)
|
|
ret double %res
|
|
}
|
|
|
|
define double @test_div_just_below_1_rz_d() {
|
|
; CHECK-LABEL: define double @test_div_just_below_1_rz_d() {
|
|
; CHECK-NEXT: ret double f0x3FEFFFFFFFFFFFFA
|
|
;
|
|
%res = call double @llvm.nvvm.div.rz.d(double 0x3FF5555555555554, double 0x3FF5555555555558)
|
|
ret double %res
|
|
}
|
|
|
|
;###############################################################
|
|
;# Div(-4/3, ~4/3 + epsilon) #
|
|
;###############################################################
|
|
; Tests division of ~4/3 by a value just over 4/3
|
|
; The exact result falls between 1.0 - 2^23 ( = 0x3FEFFFFFC0000000)
|
|
; and 1.0 - (2^23 + 2^24) ( = 0x3FEFFFFFA0000000).
|
|
; - RN, RZ, RP round to -1.0 + 2^-23 + + 2^-24 (rounding towards nearest/zero/up)
|
|
; - RM rounds to -1.0 + 2^-23 (rounding up)
|
|
|
|
define float @test_div_just_above_negative_1_rm_f() {
|
|
; CHECK-LABEL: define float @test_div_just_above_negative_1_rm_f() {
|
|
; CHECK-NEXT: ret float f0xBF7FFFFE
|
|
;
|
|
%res = call float @llvm.nvvm.div.rm.f(float 0xBFF5555540000000, float 0x3FF5555580000000)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_div_just_above_negative_1_rn_f() {
|
|
; CHECK-LABEL: define float @test_div_just_above_negative_1_rn_f() {
|
|
; CHECK-NEXT: ret float f0xBF7FFFFD
|
|
;
|
|
%res = call float @llvm.nvvm.div.rn.f(float 0xBFF5555540000000, float 0x3FF5555580000000)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_div_just_above_negative_1_rp_f() {
|
|
; CHECK-LABEL: define float @test_div_just_above_negative_1_rp_f() {
|
|
; CHECK-NEXT: ret float f0xBF7FFFFD
|
|
;
|
|
%res = call float @llvm.nvvm.div.rp.f(float 0xBFF5555540000000, float 0x3FF5555580000000)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_div_just_above_negative_1_rz_f() {
|
|
; CHECK-LABEL: define float @test_div_just_above_negative_1_rz_f() {
|
|
; CHECK-NEXT: ret float f0xBF7FFFFD
|
|
;
|
|
%res = call float @llvm.nvvm.div.rz.f(float 0xBFF5555540000000, float 0x3FF5555580000000)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_div_just_above_negative_1_rm_ftz_f() {
|
|
; CHECK-LABEL: define float @test_div_just_above_negative_1_rm_ftz_f() {
|
|
; CHECK-NEXT: ret float f0xBF7FFFFE
|
|
;
|
|
%res = call float @llvm.nvvm.div.rm.ftz.f(float 0xBFF5555540000000, float 0x3FF5555580000000)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_div_just_above_negative_1_rn_ftz_f() {
|
|
; CHECK-LABEL: define float @test_div_just_above_negative_1_rn_ftz_f() {
|
|
; CHECK-NEXT: ret float f0xBF7FFFFD
|
|
;
|
|
%res = call float @llvm.nvvm.div.rn.ftz.f(float 0xBFF5555540000000, float 0x3FF5555580000000)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_div_just_above_negative_1_rp_ftz_f() {
|
|
; CHECK-LABEL: define float @test_div_just_above_negative_1_rp_ftz_f() {
|
|
; CHECK-NEXT: ret float f0xBF7FFFFD
|
|
;
|
|
%res = call float @llvm.nvvm.div.rp.ftz.f(float 0xBFF5555540000000, float 0x3FF5555580000000)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_div_just_above_negative_1_rz_ftz_f() {
|
|
; CHECK-LABEL: define float @test_div_just_above_negative_1_rz_ftz_f() {
|
|
; CHECK-NEXT: ret float f0xBF7FFFFD
|
|
;
|
|
%res = call float @llvm.nvvm.div.rz.ftz.f(float 0xBFF5555540000000, float 0x3FF5555580000000)
|
|
ret float %res
|
|
}
|
|
|
|
;###############################################################
|
|
;# Div(~4/3 , ~4/3 + epsilon) #
|
|
;###############################################################
|
|
; Tests division of ~4/3 by a value just over 4/3
|
|
; The exact result falls between -1.0 + 2^-51 + 2^-52 ( = 0x3FEFFFFFFFFFFFFA)
|
|
; and -1.0 + 2^-51 + 2^-53 ( = 0x3FEFFFFFFFFFFFFB).
|
|
; - RN, RZ, RP round to -1.0 + 2^-51 + 2^-52 (rounding towards nearest/zero/up)
|
|
; - RM rounds to -1.0 + 2^-51 + 2^-53 (rounding down)
|
|
|
|
define double @test_div_just_above_negative_1_rm_d() {
|
|
; CHECK-LABEL: define double @test_div_just_above_negative_1_rm_d() {
|
|
; CHECK-NEXT: ret double f0xBFEFFFFFFFFFFFFB
|
|
;
|
|
%res = call double @llvm.nvvm.div.rm.d(double 0xBFF5555555555554, double 0x3FF5555555555558)
|
|
ret double %res
|
|
}
|
|
|
|
define double @test_div_just_above_negative_1_rn_d() {
|
|
; CHECK-LABEL: define double @test_div_just_above_negative_1_rn_d() {
|
|
; CHECK-NEXT: ret double f0xBFEFFFFFFFFFFFFA
|
|
;
|
|
%res = call double @llvm.nvvm.div.rn.d(double 0xBFF5555555555554, double 0x3FF5555555555558)
|
|
ret double %res
|
|
}
|
|
|
|
define double @test_div_just_above_negative_1_rp_d() {
|
|
; CHECK-LABEL: define double @test_div_just_above_negative_1_rp_d() {
|
|
; CHECK-NEXT: ret double f0xBFEFFFFFFFFFFFFA
|
|
;
|
|
%res = call double @llvm.nvvm.div.rp.d(double 0xBFF5555555555554, double 0x3FF5555555555558)
|
|
ret double %res
|
|
}
|
|
|
|
define double @test_div_just_above_negative_1_rz_d() {
|
|
; CHECK-LABEL: define double @test_div_just_above_negative_1_rz_d() {
|
|
; CHECK-NEXT: ret double f0xBFEFFFFFFFFFFFFA
|
|
;
|
|
%res = call double @llvm.nvvm.div.rz.d(double 0xBFF5555555555554, double 0x3FF5555555555558)
|
|
ret double %res
|
|
}
|
|
|
|
;###############################################################
|
|
;# Div(NaN, NaN) #
|
|
;###############################################################
|
|
; Tests division of NaN by NaN to verify that constant folding is not performed
|
|
; when the result would be NaN.
|
|
|
|
define float @test_nan_div_nan_rm_f() {
|
|
; CHECK-LABEL: define float @test_nan_div_nan_rm_f() {
|
|
; CHECK-NEXT: [[RES:%.*]] = call float @llvm.nvvm.div.rm.f(float +nan(0x3FFFF8), float +nan(0x3FFFF8))
|
|
; CHECK-NEXT: ret float [[RES]]
|
|
;
|
|
%res = call float @llvm.nvvm.div.rm.f(float 0x7FFFFFFF00000000, float 0x7FFFFFFF00000000)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_nan_div_nan_rn_f() {
|
|
; CHECK-LABEL: define float @test_nan_div_nan_rn_f() {
|
|
; CHECK-NEXT: [[RES:%.*]] = call float @llvm.nvvm.div.rn.f(float +nan(0x3FFFF8), float +nan(0x3FFFF8))
|
|
; CHECK-NEXT: ret float [[RES]]
|
|
;
|
|
%res = call float @llvm.nvvm.div.rn.f(float 0x7FFFFFFF00000000, float 0x7FFFFFFF00000000)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_nan_div_nan_rp_f() {
|
|
; CHECK-LABEL: define float @test_nan_div_nan_rp_f() {
|
|
; CHECK-NEXT: [[RES:%.*]] = call float @llvm.nvvm.div.rp.f(float +nan(0x3FFFF8), float +nan(0x3FFFF8))
|
|
; CHECK-NEXT: ret float [[RES]]
|
|
;
|
|
%res = call float @llvm.nvvm.div.rp.f(float 0x7FFFFFFF00000000, float 0x7FFFFFFF00000000)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_nan_div_nan_rz_f() {
|
|
; CHECK-LABEL: define float @test_nan_div_nan_rz_f() {
|
|
; CHECK-NEXT: [[RES:%.*]] = call float @llvm.nvvm.div.rz.f(float +nan(0x3FFFF8), float +nan(0x3FFFF8))
|
|
; CHECK-NEXT: ret float [[RES]]
|
|
;
|
|
%res = call float @llvm.nvvm.div.rz.f(float 0x7FFFFFFF00000000, float 0x7FFFFFFF00000000)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_nan_div_nan_rm_ftz_f() {
|
|
; CHECK-LABEL: define float @test_nan_div_nan_rm_ftz_f() {
|
|
; CHECK-NEXT: [[RES:%.*]] = call float @llvm.nvvm.div.rm.ftz.f(float +nan(0x3FFFF8), float +nan(0x3FFFF8))
|
|
; CHECK-NEXT: ret float [[RES]]
|
|
;
|
|
%res = call float @llvm.nvvm.div.rm.ftz.f(float 0x7FFFFFFF00000000, float 0x7FFFFFFF00000000)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_nan_div_nan_rn_ftz_f() {
|
|
; CHECK-LABEL: define float @test_nan_div_nan_rn_ftz_f() {
|
|
; CHECK-NEXT: [[RES:%.*]] = call float @llvm.nvvm.div.rn.ftz.f(float +nan(0x3FFFF8), float +nan(0x3FFFF8))
|
|
; CHECK-NEXT: ret float [[RES]]
|
|
;
|
|
%res = call float @llvm.nvvm.div.rn.ftz.f(float 0x7FFFFFFF00000000, float 0x7FFFFFFF00000000)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_nan_div_nan_rp_ftz_f() {
|
|
; CHECK-LABEL: define float @test_nan_div_nan_rp_ftz_f() {
|
|
; CHECK-NEXT: [[RES:%.*]] = call float @llvm.nvvm.div.rp.ftz.f(float +nan(0x3FFFF8), float +nan(0x3FFFF8))
|
|
; CHECK-NEXT: ret float [[RES]]
|
|
;
|
|
%res = call float @llvm.nvvm.div.rp.ftz.f(float 0x7FFFFFFF00000000, float 0x7FFFFFFF00000000)
|
|
ret float %res
|
|
}
|
|
|
|
define float @test_nan_div_nan_rz_ftz_f() {
|
|
; CHECK-LABEL: define float @test_nan_div_nan_rz_ftz_f() {
|
|
; CHECK-NEXT: [[RES:%.*]] = call float @llvm.nvvm.div.rz.ftz.f(float +nan(0x3FFFF8), float +nan(0x3FFFF8))
|
|
; CHECK-NEXT: ret float [[RES]]
|
|
;
|
|
%res = call float @llvm.nvvm.div.rz.ftz.f(float 0x7FFFFFFF00000000, float 0x7FFFFFFF00000000)
|
|
ret float %res
|
|
}
|
|
|
|
define double @test_nan_div_nan_rm_d() {
|
|
; CHECK-LABEL: define double @test_nan_div_nan_rm_d() {
|
|
; CHECK-NEXT: [[RES:%.*]] = call double @llvm.nvvm.div.rm.d(double +nan(0x7FFFFFFFFFFFF), double +nan(0x7FFFFFFFFFFFF))
|
|
; CHECK-NEXT: ret double [[RES]]
|
|
;
|
|
%res = call double @llvm.nvvm.div.rm.d(double 0x7FFFFFFFFFFFFFFF, double 0x7FFFFFFFFFFFFFFF)
|
|
ret double %res
|
|
}
|
|
|
|
define double @test_nan_div_nan_rn_d() {
|
|
; CHECK-LABEL: define double @test_nan_div_nan_rn_d() {
|
|
; CHECK-NEXT: [[RES:%.*]] = call double @llvm.nvvm.div.rn.d(double +nan(0x7FFFFFFFFFFFF), double +nan(0x7FFFFFFFFFFFF))
|
|
; CHECK-NEXT: ret double [[RES]]
|
|
;
|
|
%res = call double @llvm.nvvm.div.rn.d(double 0x7FFFFFFFFFFFFFFF, double 0x7FFFFFFFFFFFFFFF)
|
|
ret double %res
|
|
}
|
|
|
|
define double @test_nan_div_nan_rp_d() {
|
|
; CHECK-LABEL: define double @test_nan_div_nan_rp_d() {
|
|
; CHECK-NEXT: [[RES:%.*]] = call double @llvm.nvvm.div.rp.d(double +nan(0x7FFFFFFFFFFFF), double +nan(0x7FFFFFFFFFFFF))
|
|
; CHECK-NEXT: ret double [[RES]]
|
|
;
|
|
%res = call double @llvm.nvvm.div.rp.d(double 0x7FFFFFFFFFFFFFFF, double 0x7FFFFFFFFFFFFFFF)
|
|
ret double %res
|
|
}
|
|
|
|
define double @test_nan_div_nan_rz_d() {
|
|
; CHECK-LABEL: define double @test_nan_div_nan_rz_d() {
|
|
; CHECK-NEXT: [[RES:%.*]] = call double @llvm.nvvm.div.rz.d(double +nan(0x7FFFFFFFFFFFF), double +nan(0x7FFFFFFFFFFFF))
|
|
; CHECK-NEXT: ret double [[RES]]
|
|
;
|
|
%res = call double @llvm.nvvm.div.rz.d(double 0x7FFFFFFFFFFFFFFF, double 0x7FFFFFFFFFFFFFFF)
|
|
ret double %res
|
|
}
|