[llvm] b3660e4 - AMDGPU: Regenerate test checks (#141984)
via llvm-commits
llvm-commits at lists.llvm.org
Thu May 29 12:54:49 PDT 2025
Author: Matt Arsenault
Date: 2025-05-29T21:54:45+02:00
New Revision: b3660e4aa2e4269079eb3d8d702d9f8543583c08
URL: https://github.com/llvm/llvm-project/commit/b3660e4aa2e4269079eb3d8d702d9f8543583c08
DIFF: https://github.com/llvm/llvm-project/commit/b3660e4aa2e4269079eb3d8d702d9f8543583c08.diff
LOG: AMDGPU: Regenerate test checks (#141984)
Update to new update_test_checks output
Added:
Modified:
llvm/test/CodeGen/AMDGPU/fract-match.ll
Removed:
################################################################################
diff --git a/llvm/test/CodeGen/AMDGPU/fract-match.ll b/llvm/test/CodeGen/AMDGPU/fract-match.ll
index d957ba93e4fb3..4307b79bf2c3b 100644
--- a/llvm/test/CodeGen/AMDGPU/fract-match.ll
+++ b/llvm/test/CodeGen/AMDGPU/fract-match.ll
@@ -1,4 +1,4 @@
-; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py UTC_ARGS: --version 2
+; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py UTC_ARGS: --version 5
; Test with buggy fract, shouldn't match
; RUN: opt -S -mtriple=amdgcn-amd-amdpal -mcpu=tahiti -amdgpu-codegenprepare %s | FileCheck -check-prefixes=IR,GFX6-IR %s
@@ -24,9 +24,9 @@
; floor. We can fold in the nan check into the instruction, but the
; inf check must remain.
define float @safe_math_fract_f32(float %x, ptr addrspace(1) writeonly captures(none) %ip) {
-; GFX6-IR-LABEL: define float @safe_math_fract_f32
-; GFX6-IR-SAME: (float [[X:%.*]], ptr addrspace(1) writeonly captures(none) [[IP:%.*]]) #[[ATTR0:[0-9]+]] {
-; GFX6-IR-NEXT: entry:
+; GFX6-IR-LABEL: define float @safe_math_fract_f32(
+; GFX6-IR-SAME: float [[X:%.*]], ptr addrspace(1) writeonly captures(none) [[IP:%.*]]) #[[ATTR0:[0-9]+]] {
+; GFX6-IR-NEXT: [[ENTRY:.*:]]
; GFX6-IR-NEXT: [[FLOOR:%.*]] = tail call float @llvm.floor.f32(float [[X]])
; GFX6-IR-NEXT: [[SUB:%.*]] = fsub float [[X]], [[FLOOR]]
; GFX6-IR-NEXT: [[MIN:%.*]] = tail call float @llvm.minnum.f32(float [[SUB]], float 0x3FEFFFFFE0000000)
@@ -38,9 +38,9 @@ define float @safe_math_fract_f32(float %x, ptr addrspace(1) writeonly captures(
; GFX6-IR-NEXT: store float [[FLOOR]], ptr addrspace(1) [[IP]], align 4
; GFX6-IR-NEXT: ret float [[COND6]]
;
-; IR-FRACT-LABEL: define float @safe_math_fract_f32
-; IR-FRACT-SAME: (float [[X:%.*]], ptr addrspace(1) writeonly captures(none) [[IP:%.*]]) #[[ATTR0:[0-9]+]] {
-; IR-FRACT-NEXT: entry:
+; IR-FRACT-LABEL: define float @safe_math_fract_f32(
+; IR-FRACT-SAME: float [[X:%.*]], ptr addrspace(1) writeonly captures(none) [[IP:%.*]]) #[[ATTR0:[0-9]+]] {
+; IR-FRACT-NEXT: [[ENTRY:.*:]]
; IR-FRACT-NEXT: [[FLOOR:%.*]] = tail call float @llvm.floor.f32(float [[X]])
; IR-FRACT-NEXT: [[COND:%.*]] = call float @llvm.amdgcn.fract.f32(float [[X]])
; IR-FRACT-NEXT: [[FABS:%.*]] = tail call float @llvm.fabs.f32(float [[X]])
@@ -135,9 +135,9 @@ entry:
}
define float @safe_math_fract_f32_noinf_check(float %x, ptr addrspace(1) writeonly captures(none) %ip) {
-; GFX6-IR-LABEL: define float @safe_math_fract_f32_noinf_check
-; GFX6-IR-SAME: (float [[X:%.*]], ptr addrspace(1) writeonly captures(none) [[IP:%.*]]) #[[ATTR0]] {
-; GFX6-IR-NEXT: entry:
+; GFX6-IR-LABEL: define float @safe_math_fract_f32_noinf_check(
+; GFX6-IR-SAME: float [[X:%.*]], ptr addrspace(1) writeonly captures(none) [[IP:%.*]]) #[[ATTR0]] {
+; GFX6-IR-NEXT: [[ENTRY:.*:]]
; GFX6-IR-NEXT: [[FLOOR:%.*]] = tail call float @llvm.floor.f32(float [[X]])
; GFX6-IR-NEXT: [[SUB:%.*]] = fsub float [[X]], [[FLOOR]]
; GFX6-IR-NEXT: [[MIN:%.*]] = tail call float @llvm.minnum.f32(float [[SUB]], float 0x3FEFFFFFE0000000)
@@ -146,9 +146,9 @@ define float @safe_math_fract_f32_noinf_check(float %x, ptr addrspace(1) writeon
; GFX6-IR-NEXT: store float [[FLOOR]], ptr addrspace(1) [[IP]], align 4
; GFX6-IR-NEXT: ret float [[COND]]
;
-; IR-FRACT-LABEL: define float @safe_math_fract_f32_noinf_check
-; IR-FRACT-SAME: (float [[X:%.*]], ptr addrspace(1) writeonly captures(none) [[IP:%.*]]) #[[ATTR0]] {
-; IR-FRACT-NEXT: entry:
+; IR-FRACT-LABEL: define float @safe_math_fract_f32_noinf_check(
+; IR-FRACT-SAME: float [[X:%.*]], ptr addrspace(1) writeonly captures(none) [[IP:%.*]]) #[[ATTR0]] {
+; IR-FRACT-NEXT: [[ENTRY:.*:]]
; IR-FRACT-NEXT: [[FLOOR:%.*]] = tail call float @llvm.floor.f32(float [[X]])
; IR-FRACT-NEXT: [[COND:%.*]] = call float @llvm.amdgcn.fract.f32(float [[X]])
; IR-FRACT-NEXT: store float [[FLOOR]], ptr addrspace(1) [[IP]], align 4
@@ -223,9 +223,9 @@ entry:
; Cannot match fract without a nan check or no-nans.
define float @no_nan_check_math_fract_f32(float %x, ptr addrspace(1) writeonly captures(none) %ip) {
-; IR-LABEL: define float @no_nan_check_math_fract_f32
-; IR-SAME: (float [[X:%.*]], ptr addrspace(1) writeonly captures(none) [[IP:%.*]]) #[[ATTR0:[0-9]+]] {
-; IR-NEXT: entry:
+; IR-LABEL: define float @no_nan_check_math_fract_f32(
+; IR-SAME: float [[X:%.*]], ptr addrspace(1) writeonly captures(none) [[IP:%.*]]) #[[ATTR0:[0-9]+]] {
+; IR-NEXT: [[ENTRY:.*:]]
; IR-NEXT: [[FLOOR:%.*]] = tail call float @llvm.floor.f32(float [[X]])
; IR-NEXT: [[SUB:%.*]] = fsub float [[X]], [[FLOOR]]
; IR-NEXT: [[MIN:%.*]] = tail call float @llvm.minnum.f32(float [[SUB]], float 0x3FEFFFFFE0000000)
@@ -322,17 +322,17 @@ entry:
}
define float @basic_fract_f32_nonans(float nofpclass(nan) %x) {
-; GFX6-IR-LABEL: define float @basic_fract_f32_nonans
-; GFX6-IR-SAME: (float nofpclass(nan) [[X:%.*]]) #[[ATTR0]] {
-; GFX6-IR-NEXT: entry:
+; GFX6-IR-LABEL: define float @basic_fract_f32_nonans(
+; GFX6-IR-SAME: float nofpclass(nan) [[X:%.*]]) #[[ATTR0]] {
+; GFX6-IR-NEXT: [[ENTRY:.*:]]
; GFX6-IR-NEXT: [[FLOOR:%.*]] = tail call float @llvm.floor.f32(float [[X]])
; GFX6-IR-NEXT: [[SUB:%.*]] = fsub float [[X]], [[FLOOR]]
; GFX6-IR-NEXT: [[MIN:%.*]] = tail call float @llvm.minnum.f32(float [[SUB]], float 0x3FEFFFFFE0000000)
; GFX6-IR-NEXT: ret float [[MIN]]
;
-; IR-FRACT-LABEL: define float @basic_fract_f32_nonans
-; IR-FRACT-SAME: (float nofpclass(nan) [[X:%.*]]) #[[ATTR0]] {
-; IR-FRACT-NEXT: entry:
+; IR-FRACT-LABEL: define float @basic_fract_f32_nonans(
+; IR-FRACT-SAME: float nofpclass(nan) [[X:%.*]]) #[[ATTR0]] {
+; IR-FRACT-NEXT: [[ENTRY:.*:]]
; IR-FRACT-NEXT: [[MIN:%.*]] = call nnan float @llvm.amdgcn.fract.f32(float [[X]])
; IR-FRACT-NEXT: ret float [[MIN]]
;
@@ -379,9 +379,9 @@ entry:
}
define float @basic_fract_f32_flags_minnum(float %x) {
-; IR-LABEL: define float @basic_fract_f32_flags_minnum
-; IR-SAME: (float [[X:%.*]]) #[[ATTR0]] {
-; IR-NEXT: entry:
+; IR-LABEL: define float @basic_fract_f32_flags_minnum(
+; IR-SAME: float [[X:%.*]]) #[[ATTR0]] {
+; IR-NEXT: [[ENTRY:.*:]]
; IR-NEXT: [[FLOOR:%.*]] = tail call float @llvm.floor.f32(float [[X]])
; IR-NEXT: [[SUB:%.*]] = fsub float [[X]], [[FLOOR]]
; IR-NEXT: [[MIN:%.*]] = tail call nsz float @llvm.minnum.f32(float [[SUB]], float 0x3FEFFFFFE0000000)
@@ -440,17 +440,17 @@ entry:
}
define float @basic_fract_f32_flags_fsub(float nofpclass(nan) %x) {
-; GFX6-IR-LABEL: define float @basic_fract_f32_flags_fsub
-; GFX6-IR-SAME: (float nofpclass(nan) [[X:%.*]]) #[[ATTR0]] {
-; GFX6-IR-NEXT: entry:
+; GFX6-IR-LABEL: define float @basic_fract_f32_flags_fsub(
+; GFX6-IR-SAME: float nofpclass(nan) [[X:%.*]]) #[[ATTR0]] {
+; GFX6-IR-NEXT: [[ENTRY:.*:]]
; GFX6-IR-NEXT: [[FLOOR:%.*]] = tail call float @llvm.floor.f32(float [[X]])
; GFX6-IR-NEXT: [[SUB:%.*]] = fsub nsz float [[X]], [[FLOOR]]
; GFX6-IR-NEXT: [[MIN:%.*]] = tail call float @llvm.minnum.f32(float [[SUB]], float 0x3FEFFFFFE0000000)
; GFX6-IR-NEXT: ret float [[MIN]]
;
-; IR-FRACT-LABEL: define float @basic_fract_f32_flags_fsub
-; IR-FRACT-SAME: (float nofpclass(nan) [[X:%.*]]) #[[ATTR0]] {
-; IR-FRACT-NEXT: entry:
+; IR-FRACT-LABEL: define float @basic_fract_f32_flags_fsub(
+; IR-FRACT-SAME: float nofpclass(nan) [[X:%.*]]) #[[ATTR0]] {
+; IR-FRACT-NEXT: [[ENTRY:.*:]]
; IR-FRACT-NEXT: [[MIN:%.*]] = call nnan float @llvm.amdgcn.fract.f32(float [[X]])
; IR-FRACT-NEXT: ret float [[MIN]]
;
@@ -497,17 +497,17 @@ entry:
}
define <2 x float> @basic_fract_v2f32_nonans(<2 x float> nofpclass(nan) %x) {
-; GFX6-IR-LABEL: define <2 x float> @basic_fract_v2f32_nonans
-; GFX6-IR-SAME: (<2 x float> nofpclass(nan) [[X:%.*]]) #[[ATTR0]] {
-; GFX6-IR-NEXT: entry:
+; GFX6-IR-LABEL: define <2 x float> @basic_fract_v2f32_nonans(
+; GFX6-IR-SAME: <2 x float> nofpclass(nan) [[X:%.*]]) #[[ATTR0]] {
+; GFX6-IR-NEXT: [[ENTRY:.*:]]
; GFX6-IR-NEXT: [[FLOOR:%.*]] = tail call <2 x float> @llvm.floor.v2f32(<2 x float> [[X]])
; GFX6-IR-NEXT: [[SUB:%.*]] = fsub <2 x float> [[X]], [[FLOOR]]
; GFX6-IR-NEXT: [[MIN:%.*]] = tail call <2 x float> @llvm.minnum.v2f32(<2 x float> [[SUB]], <2 x float> splat (float 0x3FEFFFFFE0000000))
; GFX6-IR-NEXT: ret <2 x float> [[MIN]]
;
-; IR-FRACT-LABEL: define <2 x float> @basic_fract_v2f32_nonans
-; IR-FRACT-SAME: (<2 x float> nofpclass(nan) [[X:%.*]]) #[[ATTR0]] {
-; IR-FRACT-NEXT: entry:
+; IR-FRACT-LABEL: define <2 x float> @basic_fract_v2f32_nonans(
+; IR-FRACT-SAME: <2 x float> nofpclass(nan) [[X:%.*]]) #[[ATTR0]] {
+; IR-FRACT-NEXT: [[ENTRY:.*:]]
; IR-FRACT-NEXT: [[TMP0:%.*]] = extractelement <2 x float> [[X]], i64 0
; IR-FRACT-NEXT: [[TMP1:%.*]] = extractelement <2 x float> [[X]], i64 1
; IR-FRACT-NEXT: [[TMP2:%.*]] = call nnan float @llvm.amdgcn.fract.f32(float [[TMP0]])
@@ -566,18 +566,18 @@ entry:
}
define float @basic_fract_f32_multi_use_fsub_nonans(float nofpclass(nan) %x, ptr addrspace(1) %ptr) {
-; GFX6-IR-LABEL: define float @basic_fract_f32_multi_use_fsub_nonans
-; GFX6-IR-SAME: (float nofpclass(nan) [[X:%.*]], ptr addrspace(1) [[PTR:%.*]]) #[[ATTR0]] {
-; GFX6-IR-NEXT: entry:
+; GFX6-IR-LABEL: define float @basic_fract_f32_multi_use_fsub_nonans(
+; GFX6-IR-SAME: float nofpclass(nan) [[X:%.*]], ptr addrspace(1) [[PTR:%.*]]) #[[ATTR0]] {
+; GFX6-IR-NEXT: [[ENTRY:.*:]]
; GFX6-IR-NEXT: [[FLOOR:%.*]] = tail call float @llvm.floor.f32(float [[X]])
; GFX6-IR-NEXT: [[SUB:%.*]] = fsub float [[X]], [[FLOOR]]
; GFX6-IR-NEXT: [[MIN:%.*]] = tail call float @llvm.minnum.f32(float [[SUB]], float 0x3FEFFFFFE0000000)
; GFX6-IR-NEXT: store float [[SUB]], ptr addrspace(1) [[PTR]], align 4
; GFX6-IR-NEXT: ret float [[MIN]]
;
-; IR-FRACT-LABEL: define float @basic_fract_f32_multi_use_fsub_nonans
-; IR-FRACT-SAME: (float nofpclass(nan) [[X:%.*]], ptr addrspace(1) [[PTR:%.*]]) #[[ATTR0]] {
-; IR-FRACT-NEXT: entry:
+; IR-FRACT-LABEL: define float @basic_fract_f32_multi_use_fsub_nonans(
+; IR-FRACT-SAME: float nofpclass(nan) [[X:%.*]], ptr addrspace(1) [[PTR:%.*]]) #[[ATTR0]] {
+; IR-FRACT-NEXT: [[ENTRY:.*:]]
; IR-FRACT-NEXT: [[FLOOR:%.*]] = tail call float @llvm.floor.f32(float [[X]])
; IR-FRACT-NEXT: [[SUB:%.*]] = fsub float [[X]], [[FLOOR]]
; IR-FRACT-NEXT: [[MIN:%.*]] = call nnan float @llvm.amdgcn.fract.f32(float [[X]])
@@ -654,17 +654,17 @@ entry:
}
define float @nnan_minnum_fract_f32(float %x) {
-; GFX6-IR-LABEL: define float @nnan_minnum_fract_f32
-; GFX6-IR-SAME: (float [[X:%.*]]) #[[ATTR0]] {
-; GFX6-IR-NEXT: entry:
+; GFX6-IR-LABEL: define float @nnan_minnum_fract_f32(
+; GFX6-IR-SAME: float [[X:%.*]]) #[[ATTR0]] {
+; GFX6-IR-NEXT: [[ENTRY:.*:]]
; GFX6-IR-NEXT: [[FLOOR:%.*]] = tail call float @llvm.floor.f32(float [[X]])
; GFX6-IR-NEXT: [[SUB:%.*]] = fsub float [[X]], [[FLOOR]]
; GFX6-IR-NEXT: [[MIN:%.*]] = tail call nnan float @llvm.minnum.f32(float [[SUB]], float 0x3FEFFFFFE0000000)
; GFX6-IR-NEXT: ret float [[MIN]]
;
-; IR-FRACT-LABEL: define float @nnan_minnum_fract_f32
-; IR-FRACT-SAME: (float [[X:%.*]]) #[[ATTR0]] {
-; IR-FRACT-NEXT: entry:
+; IR-FRACT-LABEL: define float @nnan_minnum_fract_f32(
+; IR-FRACT-SAME: float [[X:%.*]]) #[[ATTR0]] {
+; IR-FRACT-NEXT: [[ENTRY:.*:]]
; IR-FRACT-NEXT: [[MIN:%.*]] = call nnan float @llvm.amdgcn.fract.f32(float [[X]])
; IR-FRACT-NEXT: ret float [[MIN]]
;
@@ -713,9 +713,9 @@ entry:
; TODO: Could match if we checked isKnownNeverNaN on the minnum src
; instead of the pattern input source.
define float @nnan_fsub_fract_f32(float %x) {
-; IR-LABEL: define float @nnan_fsub_fract_f32
-; IR-SAME: (float [[X:%.*]]) #[[ATTR0]] {
-; IR-NEXT: entry:
+; IR-LABEL: define float @nnan_fsub_fract_f32(
+; IR-SAME: float [[X:%.*]]) #[[ATTR0]] {
+; IR-NEXT: [[ENTRY:.*:]]
; IR-NEXT: [[FLOOR:%.*]] = tail call float @llvm.floor.f32(float [[X]])
; IR-NEXT: [[SUB:%.*]] = fsub nnan float [[X]], [[FLOOR]]
; IR-NEXT: [[MIN:%.*]] = tail call float @llvm.minnum.f32(float [[SUB]], float 0x3FEFFFFFE0000000)
@@ -774,9 +774,9 @@ entry:
}
define float @nnan_floor_fract_f32(float %x) {
-; IR-LABEL: define float @nnan_floor_fract_f32
-; IR-SAME: (float [[X:%.*]]) #[[ATTR0]] {
-; IR-NEXT: entry:
+; IR-LABEL: define float @nnan_floor_fract_f32(
+; IR-SAME: float [[X:%.*]]) #[[ATTR0]] {
+; IR-NEXT: [[ENTRY:.*:]]
; IR-NEXT: [[FLOOR:%.*]] = tail call nnan float @llvm.floor.f32(float [[X]])
; IR-NEXT: [[SUB:%.*]] = fsub float [[X]], [[FLOOR]]
; IR-NEXT: [[MIN:%.*]] = tail call float @llvm.minnum.f32(float [[SUB]], float 0x3FEFFFFFE0000000)
@@ -835,17 +835,17 @@ entry:
}
define float @nnan_src_fract_f32(float nofpclass(nan) %x) {
-; GFX6-IR-LABEL: define float @nnan_src_fract_f32
-; GFX6-IR-SAME: (float nofpclass(nan) [[X:%.*]]) #[[ATTR0]] {
-; GFX6-IR-NEXT: entry:
+; GFX6-IR-LABEL: define float @nnan_src_fract_f32(
+; GFX6-IR-SAME: float nofpclass(nan) [[X:%.*]]) #[[ATTR0]] {
+; GFX6-IR-NEXT: [[ENTRY:.*:]]
; GFX6-IR-NEXT: [[FLOOR:%.*]] = tail call float @llvm.floor.f32(float [[X]])
; GFX6-IR-NEXT: [[SUB:%.*]] = fsub float [[X]], [[FLOOR]]
; GFX6-IR-NEXT: [[MIN:%.*]] = tail call float @llvm.minnum.f32(float [[SUB]], float 0x3FEFFFFFE0000000)
; GFX6-IR-NEXT: ret float [[MIN]]
;
-; IR-FRACT-LABEL: define float @nnan_src_fract_f32
-; IR-FRACT-SAME: (float nofpclass(nan) [[X:%.*]]) #[[ATTR0]] {
-; IR-FRACT-NEXT: entry:
+; IR-FRACT-LABEL: define float @nnan_src_fract_f32(
+; IR-FRACT-SAME: float nofpclass(nan) [[X:%.*]]) #[[ATTR0]] {
+; IR-FRACT-NEXT: [[ENTRY:.*:]]
; IR-FRACT-NEXT: [[MIN:%.*]] = call nnan float @llvm.amdgcn.fract.f32(float [[X]])
; IR-FRACT-NEXT: ret float [[MIN]]
;
@@ -893,9 +893,9 @@ entry:
; Negative test
define float @not_fract_f32_wrong_const(float nofpclass(nan) %x) {
-; IR-LABEL: define float @not_fract_f32_wrong_const
-; IR-SAME: (float nofpclass(nan) [[X:%.*]]) #[[ATTR0]] {
-; IR-NEXT: entry:
+; IR-LABEL: define float @not_fract_f32_wrong_const(
+; IR-SAME: float nofpclass(nan) [[X:%.*]]) #[[ATTR0]] {
+; IR-NEXT: [[ENTRY:.*:]]
; IR-NEXT: [[FLOOR:%.*]] = tail call float @llvm.floor.f32(float [[X]])
; IR-NEXT: [[SUB:%.*]] = fsub float [[X]], [[FLOOR]]
; IR-NEXT: [[MIN:%.*]] = tail call float @llvm.minnum.f32(float [[SUB]], float 0x3FEFFFFFC0000000)
@@ -955,9 +955,9 @@ entry:
; Negative test
define float @not_fract_f32_swapped_fsub(float nofpclass(nan) %x) {
-; IR-LABEL: define float @not_fract_f32_swapped_fsub
-; IR-SAME: (float nofpclass(nan) [[X:%.*]]) #[[ATTR0]] {
-; IR-NEXT: entry:
+; IR-LABEL: define float @not_fract_f32_swapped_fsub(
+; IR-SAME: float nofpclass(nan) [[X:%.*]]) #[[ATTR0]] {
+; IR-NEXT: [[ENTRY:.*:]]
; IR-NEXT: [[FLOOR:%.*]] = tail call float @llvm.floor.f32(float [[X]])
; IR-NEXT: [[SUB:%.*]] = fsub float [[FLOOR]], [[X]]
; IR-NEXT: [[MIN:%.*]] = tail call float @llvm.minnum.f32(float [[SUB]], float 0x3FEFFFFFE0000000)
@@ -1017,9 +1017,9 @@ entry:
; Negative test
define float @not_fract_f32_not_floor(float nofpclass(nan) %x) {
-; IR-LABEL: define float @not_fract_f32_not_floor
-; IR-SAME: (float nofpclass(nan) [[X:%.*]]) #[[ATTR0]] {
-; IR-NEXT: entry:
+; IR-LABEL: define float @not_fract_f32_not_floor(
+; IR-SAME: float nofpclass(nan) [[X:%.*]]) #[[ATTR0]] {
+; IR-NEXT: [[ENTRY:.*:]]
; IR-NEXT: [[FLOOR:%.*]] = tail call float @llvm.trunc.f32(float [[X]])
; IR-NEXT: [[SUB:%.*]] = fsub float [[X]], [[FLOOR]]
; IR-NEXT: [[MIN:%.*]] = tail call float @llvm.minnum.f32(float [[SUB]], float 0x3FEFFFFFE0000000)
@@ -1079,9 +1079,9 @@ entry:
; Negative test
define float @not_fract_f32_
diff erent_floor(float %x, float %y) {
-; IR-LABEL: define float @not_fract_f32_
diff erent_floor
-; IR-SAME: (float [[X:%.*]], float [[Y:%.*]]) #[[ATTR0]] {
-; IR-NEXT: entry:
+; IR-LABEL: define float @not_fract_f32_
diff erent_floor(
+; IR-SAME: float [[X:%.*]], float [[Y:%.*]]) #[[ATTR0]] {
+; IR-NEXT: [[ENTRY:.*:]]
; IR-NEXT: [[FLOOR:%.*]] = tail call float @llvm.floor.f32(float [[Y]])
; IR-NEXT: [[SUB:%.*]] = fsub float [[X]], [[FLOOR]]
; IR-NEXT: [[MIN:%.*]] = tail call float @llvm.minnum.f32(float [[SUB]], float 0x3FEFFFFFE0000000)
@@ -1141,9 +1141,9 @@ entry:
; Negative test
define float @not_fract_f32_maxnum(float nofpclass(nan) %x) {
-; IR-LABEL: define float @not_fract_f32_maxnum
-; IR-SAME: (float nofpclass(nan) [[X:%.*]]) #[[ATTR0]] {
-; IR-NEXT: entry:
+; IR-LABEL: define float @not_fract_f32_maxnum(
+; IR-SAME: float nofpclass(nan) [[X:%.*]]) #[[ATTR0]] {
+; IR-NEXT: [[ENTRY:.*:]]
; IR-NEXT: [[FLOOR:%.*]] = tail call float @llvm.floor.f32(float [[X]])
; IR-NEXT: [[SUB:%.*]] = fsub float [[X]], [[FLOOR]]
; IR-NEXT: [[MIN:%.*]] = tail call float @llvm.maxnum.f32(float [[SUB]], float 0x3FEFFFFFE0000000)
@@ -1202,9 +1202,9 @@ entry:
}
define float @fcmp_uno_check_is_nan_f32(float %x) {
-; IR-LABEL: define float @fcmp_uno_check_is_nan_f32
-; IR-SAME: (float [[X:%.*]]) #[[ATTR0]] {
-; IR-NEXT: entry:
+; IR-LABEL: define float @fcmp_uno_check_is_nan_f32(
+; IR-SAME: float [[X:%.*]]) #[[ATTR0]] {
+; IR-NEXT: [[ENTRY:.*:]]
; IR-NEXT: [[FLOOR:%.*]] = tail call float @llvm.floor.f32(float [[X]])
; IR-NEXT: [[SUB:%.*]] = fsub float [[X]], [[FLOOR]]
; IR-NEXT: [[MIN:%.*]] = tail call float @llvm.minnum.f32(float [[SUB]], float 0x3FEFFFFFE0000000)
@@ -1236,9 +1236,9 @@ entry:
; No inf check
define float @select_nan_fract_f32(float %x) {
-; GFX6-IR-LABEL: define float @select_nan_fract_f32
-; GFX6-IR-SAME: (float [[X:%.*]]) #[[ATTR0]] {
-; GFX6-IR-NEXT: entry:
+; GFX6-IR-LABEL: define float @select_nan_fract_f32(
+; GFX6-IR-SAME: float [[X:%.*]]) #[[ATTR0]] {
+; GFX6-IR-NEXT: [[ENTRY:.*:]]
; GFX6-IR-NEXT: [[FLOOR:%.*]] = tail call float @llvm.floor.f32(float [[X]])
; GFX6-IR-NEXT: [[SUB:%.*]] = fsub float [[X]], [[FLOOR]]
; GFX6-IR-NEXT: [[MIN:%.*]] = tail call float @llvm.minnum.f32(float [[SUB]], float 0x3FEFFFFFE0000000)
@@ -1246,9 +1246,9 @@ define float @select_nan_fract_f32(float %x) {
; GFX6-IR-NEXT: [[COND:%.*]] = select i1 [[UNO]], float [[X]], float [[MIN]]
; GFX6-IR-NEXT: ret float [[COND]]
;
-; IR-FRACT-LABEL: define float @select_nan_fract_f32
-; IR-FRACT-SAME: (float [[X:%.*]]) #[[ATTR0]] {
-; IR-FRACT-NEXT: entry:
+; IR-FRACT-LABEL: define float @select_nan_fract_f32(
+; IR-FRACT-SAME: float [[X:%.*]]) #[[ATTR0]] {
+; IR-FRACT-NEXT: [[ENTRY:.*:]]
; IR-FRACT-NEXT: [[COND:%.*]] = call float @llvm.amdgcn.fract.f32(float [[X]])
; IR-FRACT-NEXT: ret float [[COND]]
;
@@ -1299,9 +1299,9 @@ entry:
}
define float @commuted_select_nan_fract_f32(float %x) {
-; GFX6-IR-LABEL: define float @commuted_select_nan_fract_f32
-; GFX6-IR-SAME: (float [[X:%.*]]) #[[ATTR0]] {
-; GFX6-IR-NEXT: entry:
+; GFX6-IR-LABEL: define float @commuted_select_nan_fract_f32(
+; GFX6-IR-SAME: float [[X:%.*]]) #[[ATTR0]] {
+; GFX6-IR-NEXT: [[ENTRY:.*:]]
; GFX6-IR-NEXT: [[FLOOR:%.*]] = tail call float @llvm.floor.f32(float [[X]])
; GFX6-IR-NEXT: [[SUB:%.*]] = fsub float [[X]], [[FLOOR]]
; GFX6-IR-NEXT: [[MIN:%.*]] = tail call float @llvm.minnum.f32(float [[SUB]], float 0x3FEFFFFFE0000000)
@@ -1309,9 +1309,9 @@ define float @commuted_select_nan_fract_f32(float %x) {
; GFX6-IR-NEXT: [[COND:%.*]] = select i1 [[UNO]], float [[MIN]], float [[X]]
; GFX6-IR-NEXT: ret float [[COND]]
;
-; IR-FRACT-LABEL: define float @commuted_select_nan_fract_f32
-; IR-FRACT-SAME: (float [[X:%.*]]) #[[ATTR0]] {
-; IR-FRACT-NEXT: entry:
+; IR-FRACT-LABEL: define float @commuted_select_nan_fract_f32(
+; IR-FRACT-SAME: float [[X:%.*]]) #[[ATTR0]] {
+; IR-FRACT-NEXT: [[ENTRY:.*:]]
; IR-FRACT-NEXT: [[COND:%.*]] = call float @llvm.amdgcn.fract.f32(float [[X]])
; IR-FRACT-NEXT: ret float [[COND]]
;
@@ -1362,9 +1362,9 @@ entry:
}
define float @wrong_commuted_nan_select_f32(float %x) {
-; IR-LABEL: define float @wrong_commuted_nan_select_f32
-; IR-SAME: (float [[X:%.*]]) #[[ATTR0]] {
-; IR-NEXT: entry:
+; IR-LABEL: define float @wrong_commuted_nan_select_f32(
+; IR-SAME: float [[X:%.*]]) #[[ATTR0]] {
+; IR-NEXT: [[ENTRY:.*:]]
; IR-NEXT: [[FLOOR:%.*]] = tail call float @llvm.floor.f32(float [[X]])
; IR-NEXT: [[SUB:%.*]] = fsub float [[X]], [[FLOOR]]
; IR-NEXT: [[MIN:%.*]] = tail call float @llvm.minnum.f32(float [[SUB]], float 0x3FEFFFFFE0000000)
@@ -1440,25 +1440,25 @@ entry:
}
define half @basic_fract_f16_nonan(half nofpclass(nan) %x) {
-; GFX6-IR-LABEL: define half @basic_fract_f16_nonan
-; GFX6-IR-SAME: (half nofpclass(nan) [[X:%.*]]) #[[ATTR0]] {
-; GFX6-IR-NEXT: entry:
+; GFX6-IR-LABEL: define half @basic_fract_f16_nonan(
+; GFX6-IR-SAME: half nofpclass(nan) [[X:%.*]]) #[[ATTR0]] {
+; GFX6-IR-NEXT: [[ENTRY:.*:]]
; GFX6-IR-NEXT: [[FLOOR:%.*]] = tail call half @llvm.floor.f16(half [[X]])
; GFX6-IR-NEXT: [[SUB:%.*]] = fsub half [[X]], [[FLOOR]]
; GFX6-IR-NEXT: [[MIN:%.*]] = tail call half @llvm.minnum.f16(half [[SUB]], half 0xH3BFF)
; GFX6-IR-NEXT: ret half [[MIN]]
;
-; GFX7-IR-LABEL: define half @basic_fract_f16_nonan
-; GFX7-IR-SAME: (half nofpclass(nan) [[X:%.*]]) #[[ATTR0]] {
-; GFX7-IR-NEXT: entry:
+; GFX7-IR-LABEL: define half @basic_fract_f16_nonan(
+; GFX7-IR-SAME: half nofpclass(nan) [[X:%.*]]) #[[ATTR0]] {
+; GFX7-IR-NEXT: [[ENTRY:.*:]]
; GFX7-IR-NEXT: [[FLOOR:%.*]] = tail call half @llvm.floor.f16(half [[X]])
; GFX7-IR-NEXT: [[SUB:%.*]] = fsub half [[X]], [[FLOOR]]
; GFX7-IR-NEXT: [[MIN:%.*]] = tail call half @llvm.minnum.f16(half [[SUB]], half 0xH3BFF)
; GFX7-IR-NEXT: ret half [[MIN]]
;
-; IR-LEGALF16-LABEL: define half @basic_fract_f16_nonan
-; IR-LEGALF16-SAME: (half nofpclass(nan) [[X:%.*]]) #[[ATTR0]] {
-; IR-LEGALF16-NEXT: entry:
+; IR-LEGALF16-LABEL: define half @basic_fract_f16_nonan(
+; IR-LEGALF16-SAME: half nofpclass(nan) [[X:%.*]]) #[[ATTR0]] {
+; IR-LEGALF16-NEXT: [[ENTRY:.*:]]
; IR-LEGALF16-NEXT: [[MIN:%.*]] = call nnan half @llvm.amdgcn.fract.f16(half [[X]])
; IR-LEGALF16-NEXT: ret half [[MIN]]
;
@@ -1527,25 +1527,25 @@ entry:
}
define <2 x half> @basic_fract_v2f16_nonan(<2 x half> nofpclass(nan) %x) {
-; GFX6-IR-LABEL: define <2 x half> @basic_fract_v2f16_nonan
-; GFX6-IR-SAME: (<2 x half> nofpclass(nan) [[X:%.*]]) #[[ATTR0]] {
-; GFX6-IR-NEXT: entry:
+; GFX6-IR-LABEL: define <2 x half> @basic_fract_v2f16_nonan(
+; GFX6-IR-SAME: <2 x half> nofpclass(nan) [[X:%.*]]) #[[ATTR0]] {
+; GFX6-IR-NEXT: [[ENTRY:.*:]]
; GFX6-IR-NEXT: [[FLOOR:%.*]] = tail call <2 x half> @llvm.floor.v2f16(<2 x half> [[X]])
; GFX6-IR-NEXT: [[SUB:%.*]] = fsub <2 x half> [[X]], [[FLOOR]]
; GFX6-IR-NEXT: [[MIN:%.*]] = tail call <2 x half> @llvm.minnum.v2f16(<2 x half> [[SUB]], <2 x half> splat (half 0xH3BFF))
; GFX6-IR-NEXT: ret <2 x half> [[MIN]]
;
-; GFX7-IR-LABEL: define <2 x half> @basic_fract_v2f16_nonan
-; GFX7-IR-SAME: (<2 x half> nofpclass(nan) [[X:%.*]]) #[[ATTR0]] {
-; GFX7-IR-NEXT: entry:
+; GFX7-IR-LABEL: define <2 x half> @basic_fract_v2f16_nonan(
+; GFX7-IR-SAME: <2 x half> nofpclass(nan) [[X:%.*]]) #[[ATTR0]] {
+; GFX7-IR-NEXT: [[ENTRY:.*:]]
; GFX7-IR-NEXT: [[FLOOR:%.*]] = tail call <2 x half> @llvm.floor.v2f16(<2 x half> [[X]])
; GFX7-IR-NEXT: [[SUB:%.*]] = fsub <2 x half> [[X]], [[FLOOR]]
; GFX7-IR-NEXT: [[MIN:%.*]] = tail call <2 x half> @llvm.minnum.v2f16(<2 x half> [[SUB]], <2 x half> splat (half 0xH3BFF))
; GFX7-IR-NEXT: ret <2 x half> [[MIN]]
;
-; IR-LEGALF16-LABEL: define <2 x half> @basic_fract_v2f16_nonan
-; IR-LEGALF16-SAME: (<2 x half> nofpclass(nan) [[X:%.*]]) #[[ATTR0]] {
-; IR-LEGALF16-NEXT: entry:
+; IR-LEGALF16-LABEL: define <2 x half> @basic_fract_v2f16_nonan(
+; IR-LEGALF16-SAME: <2 x half> nofpclass(nan) [[X:%.*]]) #[[ATTR0]] {
+; IR-LEGALF16-NEXT: [[ENTRY:.*:]]
; IR-LEGALF16-NEXT: [[TMP0:%.*]] = extractelement <2 x half> [[X]], i64 0
; IR-LEGALF16-NEXT: [[TMP1:%.*]] = extractelement <2 x half> [[X]], i64 1
; IR-LEGALF16-NEXT: [[TMP2:%.*]] = call nnan half @llvm.amdgcn.fract.f16(half [[TMP0]])
@@ -1645,17 +1645,17 @@ entry:
}
define double @basic_fract_f64_nanans(double nofpclass(nan) %x) {
-; GFX6-IR-LABEL: define double @basic_fract_f64_nanans
-; GFX6-IR-SAME: (double nofpclass(nan) [[X:%.*]]) #[[ATTR0]] {
-; GFX6-IR-NEXT: entry:
+; GFX6-IR-LABEL: define double @basic_fract_f64_nanans(
+; GFX6-IR-SAME: double nofpclass(nan) [[X:%.*]]) #[[ATTR0]] {
+; GFX6-IR-NEXT: [[ENTRY:.*:]]
; GFX6-IR-NEXT: [[FLOOR:%.*]] = tail call double @llvm.floor.f64(double [[X]])
; GFX6-IR-NEXT: [[SUB:%.*]] = fsub double [[X]], [[FLOOR]]
; GFX6-IR-NEXT: [[MIN:%.*]] = tail call double @llvm.minnum.f64(double [[SUB]], double 0x3FEFFFFFFFFFFFFF)
; GFX6-IR-NEXT: ret double [[MIN]]
;
-; IR-FRACT-LABEL: define double @basic_fract_f64_nanans
-; IR-FRACT-SAME: (double nofpclass(nan) [[X:%.*]]) #[[ATTR0]] {
-; IR-FRACT-NEXT: entry:
+; IR-FRACT-LABEL: define double @basic_fract_f64_nanans(
+; IR-FRACT-SAME: double nofpclass(nan) [[X:%.*]]) #[[ATTR0]] {
+; IR-FRACT-NEXT: [[ENTRY:.*:]]
; IR-FRACT-NEXT: [[MIN:%.*]] = call nnan double @llvm.amdgcn.fract.f64(double [[X]])
; IR-FRACT-NEXT: ret double [[MIN]]
;
@@ -1711,9 +1711,9 @@ entry:
}
define half @safe_math_fract_f16_noinf_check(half %x, ptr addrspace(1) writeonly captures(none) %ip) {
-; GFX6-IR-LABEL: define half @safe_math_fract_f16_noinf_check
-; GFX6-IR-SAME: (half [[X:%.*]], ptr addrspace(1) writeonly captures(none) [[IP:%.*]]) #[[ATTR0]] {
-; GFX6-IR-NEXT: entry:
+; GFX6-IR-LABEL: define half @safe_math_fract_f16_noinf_check(
+; GFX6-IR-SAME: half [[X:%.*]], ptr addrspace(1) writeonly captures(none) [[IP:%.*]]) #[[ATTR0]] {
+; GFX6-IR-NEXT: [[ENTRY:.*:]]
; GFX6-IR-NEXT: [[FLOOR:%.*]] = tail call half @llvm.floor.f16(half [[X]])
; GFX6-IR-NEXT: [[SUB:%.*]] = fsub half [[X]], [[FLOOR]]
; GFX6-IR-NEXT: [[MIN:%.*]] = tail call half @llvm.minnum.f16(half [[SUB]], half 0xH3BFF)
@@ -1722,9 +1722,9 @@ define half @safe_math_fract_f16_noinf_check(half %x, ptr addrspace(1) writeonly
; GFX6-IR-NEXT: store half [[FLOOR]], ptr addrspace(1) [[IP]], align 4
; GFX6-IR-NEXT: ret half [[COND]]
;
-; GFX7-IR-LABEL: define half @safe_math_fract_f16_noinf_check
-; GFX7-IR-SAME: (half [[X:%.*]], ptr addrspace(1) writeonly captures(none) [[IP:%.*]]) #[[ATTR0]] {
-; GFX7-IR-NEXT: entry:
+; GFX7-IR-LABEL: define half @safe_math_fract_f16_noinf_check(
+; GFX7-IR-SAME: half [[X:%.*]], ptr addrspace(1) writeonly captures(none) [[IP:%.*]]) #[[ATTR0]] {
+; GFX7-IR-NEXT: [[ENTRY:.*:]]
; GFX7-IR-NEXT: [[FLOOR:%.*]] = tail call half @llvm.floor.f16(half [[X]])
; GFX7-IR-NEXT: [[SUB:%.*]] = fsub half [[X]], [[FLOOR]]
; GFX7-IR-NEXT: [[MIN:%.*]] = tail call half @llvm.minnum.f16(half [[SUB]], half 0xH3BFF)
@@ -1733,9 +1733,9 @@ define half @safe_math_fract_f16_noinf_check(half %x, ptr addrspace(1) writeonly
; GFX7-IR-NEXT: store half [[FLOOR]], ptr addrspace(1) [[IP]], align 4
; GFX7-IR-NEXT: ret half [[COND]]
;
-; IR-LEGALF16-LABEL: define half @safe_math_fract_f16_noinf_check
-; IR-LEGALF16-SAME: (half [[X:%.*]], ptr addrspace(1) writeonly captures(none) [[IP:%.*]]) #[[ATTR0]] {
-; IR-LEGALF16-NEXT: entry:
+; IR-LEGALF16-LABEL: define half @safe_math_fract_f16_noinf_check(
+; IR-LEGALF16-SAME: half [[X:%.*]], ptr addrspace(1) writeonly captures(none) [[IP:%.*]]) #[[ATTR0]] {
+; IR-LEGALF16-NEXT: [[ENTRY:.*:]]
; IR-LEGALF16-NEXT: [[FLOOR:%.*]] = tail call half @llvm.floor.f16(half [[X]])
; IR-LEGALF16-NEXT: [[COND:%.*]] = call half @llvm.amdgcn.fract.f16(half [[X]])
; IR-LEGALF16-NEXT: store half [[FLOOR]], ptr addrspace(1) [[IP]], align 4
@@ -1838,9 +1838,9 @@ entry:
}
define double @safe_math_fract_f64_noinf_check(double %x, ptr addrspace(1) writeonly captures(none) %ip) {
-; GFX6-IR-LABEL: define double @safe_math_fract_f64_noinf_check
-; GFX6-IR-SAME: (double [[X:%.*]], ptr addrspace(1) writeonly captures(none) [[IP:%.*]]) #[[ATTR0]] {
-; GFX6-IR-NEXT: entry:
+; GFX6-IR-LABEL: define double @safe_math_fract_f64_noinf_check(
+; GFX6-IR-SAME: double [[X:%.*]], ptr addrspace(1) writeonly captures(none) [[IP:%.*]]) #[[ATTR0]] {
+; GFX6-IR-NEXT: [[ENTRY:.*:]]
; GFX6-IR-NEXT: [[FLOOR:%.*]] = tail call double @llvm.floor.f64(double [[X]])
; GFX6-IR-NEXT: [[SUB:%.*]] = fsub double [[X]], [[FLOOR]]
; GFX6-IR-NEXT: [[MIN:%.*]] = tail call double @llvm.minnum.f64(double [[SUB]], double 0x3FEFFFFFFFFFFFFF)
@@ -1849,9 +1849,9 @@ define double @safe_math_fract_f64_noinf_check(double %x, ptr addrspace(1) write
; GFX6-IR-NEXT: store double [[FLOOR]], ptr addrspace(1) [[IP]], align 4
; GFX6-IR-NEXT: ret double [[COND]]
;
-; IR-FRACT-LABEL: define double @safe_math_fract_f64_noinf_check
-; IR-FRACT-SAME: (double [[X:%.*]], ptr addrspace(1) writeonly captures(none) [[IP:%.*]]) #[[ATTR0]] {
-; IR-FRACT-NEXT: entry:
+; IR-FRACT-LABEL: define double @safe_math_fract_f64_noinf_check(
+; IR-FRACT-SAME: double [[X:%.*]], ptr addrspace(1) writeonly captures(none) [[IP:%.*]]) #[[ATTR0]] {
+; IR-FRACT-NEXT: [[ENTRY:.*:]]
; IR-FRACT-NEXT: [[FLOOR:%.*]] = tail call double @llvm.floor.f64(double [[X]])
; IR-FRACT-NEXT: [[COND:%.*]] = call double @llvm.amdgcn.fract.f64(double [[X]])
; IR-FRACT-NEXT: store double [[FLOOR]], ptr addrspace(1) [[IP]], align 4
@@ -1935,9 +1935,9 @@ entry:
}
define float @select_nan_fract_f32_flags_select(float %x) {
-; GFX6-IR-LABEL: define float @select_nan_fract_f32_flags_select
-; GFX6-IR-SAME: (float [[X:%.*]]) #[[ATTR0]] {
-; GFX6-IR-NEXT: entry:
+; GFX6-IR-LABEL: define float @select_nan_fract_f32_flags_select(
+; GFX6-IR-SAME: float [[X:%.*]]) #[[ATTR0]] {
+; GFX6-IR-NEXT: [[ENTRY:.*:]]
; GFX6-IR-NEXT: [[FLOOR:%.*]] = tail call float @llvm.floor.f32(float [[X]])
; GFX6-IR-NEXT: [[SUB:%.*]] = fsub float [[X]], [[FLOOR]]
; GFX6-IR-NEXT: [[MIN:%.*]] = tail call float @llvm.minnum.f32(float [[SUB]], float 0x3FEFFFFFE0000000)
@@ -1945,9 +1945,9 @@ define float @select_nan_fract_f32_flags_select(float %x) {
; GFX6-IR-NEXT: [[COND:%.*]] = select nsz i1 [[UNO]], float [[X]], float [[MIN]]
; GFX6-IR-NEXT: ret float [[COND]]
;
-; IR-FRACT-LABEL: define float @select_nan_fract_f32_flags_select
-; IR-FRACT-SAME: (float [[X:%.*]]) #[[ATTR0]] {
-; IR-FRACT-NEXT: entry:
+; IR-FRACT-LABEL: define float @select_nan_fract_f32_flags_select(
+; IR-FRACT-SAME: float [[X:%.*]]) #[[ATTR0]] {
+; IR-FRACT-NEXT: [[ENTRY:.*:]]
; IR-FRACT-NEXT: [[COND:%.*]] = call nsz float @llvm.amdgcn.fract.f32(float [[X]])
; IR-FRACT-NEXT: ret float [[COND]]
;
@@ -1998,9 +1998,9 @@ entry:
}
define float @select_nan_fract_f32_flags_minnum(float %x) {
-; GFX6-IR-LABEL: define float @select_nan_fract_f32_flags_minnum
-; GFX6-IR-SAME: (float [[X:%.*]]) #[[ATTR0]] {
-; GFX6-IR-NEXT: entry:
+; GFX6-IR-LABEL: define float @select_nan_fract_f32_flags_minnum(
+; GFX6-IR-SAME: float [[X:%.*]]) #[[ATTR0]] {
+; GFX6-IR-NEXT: [[ENTRY:.*:]]
; GFX6-IR-NEXT: [[FLOOR:%.*]] = tail call float @llvm.floor.f32(float [[X]])
; GFX6-IR-NEXT: [[SUB:%.*]] = fsub float [[X]], [[FLOOR]]
; GFX6-IR-NEXT: [[MIN:%.*]] = tail call nsz float @llvm.minnum.f32(float [[SUB]], float 0x3FEFFFFFE0000000)
@@ -2008,9 +2008,9 @@ define float @select_nan_fract_f32_flags_minnum(float %x) {
; GFX6-IR-NEXT: [[COND:%.*]] = select i1 [[UNO]], float [[X]], float [[MIN]]
; GFX6-IR-NEXT: ret float [[COND]]
;
-; IR-FRACT-LABEL: define float @select_nan_fract_f32_flags_minnum
-; IR-FRACT-SAME: (float [[X:%.*]]) #[[ATTR0]] {
-; IR-FRACT-NEXT: entry:
+; IR-FRACT-LABEL: define float @select_nan_fract_f32_flags_minnum(
+; IR-FRACT-SAME: float [[X:%.*]]) #[[ATTR0]] {
+; IR-FRACT-NEXT: [[ENTRY:.*:]]
; IR-FRACT-NEXT: [[COND:%.*]] = call float @llvm.amdgcn.fract.f32(float [[X]])
; IR-FRACT-NEXT: ret float [[COND]]
;
@@ -2061,9 +2061,9 @@ entry:
}
define <2 x float> @safe_math_fract_v2f32(<2 x float> %x, ptr addrspace(1) writeonly captures(none) %ip) {
-; GFX6-IR-LABEL: define <2 x float> @safe_math_fract_v2f32
-; GFX6-IR-SAME: (<2 x float> [[X:%.*]], ptr addrspace(1) writeonly captures(none) [[IP:%.*]]) #[[ATTR0]] {
-; GFX6-IR-NEXT: entry:
+; GFX6-IR-LABEL: define <2 x float> @safe_math_fract_v2f32(
+; GFX6-IR-SAME: <2 x float> [[X:%.*]], ptr addrspace(1) writeonly captures(none) [[IP:%.*]]) #[[ATTR0]] {
+; GFX6-IR-NEXT: [[ENTRY:.*:]]
; GFX6-IR-NEXT: [[FLOOR:%.*]] = tail call <2 x float> @llvm.floor.v2f32(<2 x float> [[X]])
; GFX6-IR-NEXT: [[SUB:%.*]] = fsub <2 x float> [[X]], [[FLOOR]]
; GFX6-IR-NEXT: [[MIN:%.*]] = tail call <2 x float> @llvm.minnum.v2f32(<2 x float> [[SUB]], <2 x float> splat (float 0x3FEFFFFFE0000000))
@@ -2075,9 +2075,9 @@ define <2 x float> @safe_math_fract_v2f32(<2 x float> %x, ptr addrspace(1) write
; GFX6-IR-NEXT: store <2 x float> [[FLOOR]], ptr addrspace(1) [[IP]], align 4
; GFX6-IR-NEXT: ret <2 x float> [[COND6]]
;
-; IR-FRACT-LABEL: define <2 x float> @safe_math_fract_v2f32
-; IR-FRACT-SAME: (<2 x float> [[X:%.*]], ptr addrspace(1) writeonly captures(none) [[IP:%.*]]) #[[ATTR0]] {
-; IR-FRACT-NEXT: entry:
+; IR-FRACT-LABEL: define <2 x float> @safe_math_fract_v2f32(
+; IR-FRACT-SAME: <2 x float> [[X:%.*]], ptr addrspace(1) writeonly captures(none) [[IP:%.*]]) #[[ATTR0]] {
+; IR-FRACT-NEXT: [[ENTRY:.*:]]
; IR-FRACT-NEXT: [[FLOOR:%.*]] = tail call <2 x float> @llvm.floor.v2f32(<2 x float> [[X]])
; IR-FRACT-NEXT: [[TMP0:%.*]] = extractelement <2 x float> [[X]], i64 0
; IR-FRACT-NEXT: [[TMP1:%.*]] = extractelement <2 x float> [[X]], i64 1
@@ -2201,9 +2201,9 @@ entry:
}
define double @safe_math_fract_f64(double %x, ptr addrspace(1) writeonly captures(none) %ip) {
-; GFX6-IR-LABEL: define double @safe_math_fract_f64
-; GFX6-IR-SAME: (double [[X:%.*]], ptr addrspace(1) writeonly captures(none) [[IP:%.*]]) #[[ATTR0]] {
-; GFX6-IR-NEXT: entry:
+; GFX6-IR-LABEL: define double @safe_math_fract_f64(
+; GFX6-IR-SAME: double [[X:%.*]], ptr addrspace(1) writeonly captures(none) [[IP:%.*]]) #[[ATTR0]] {
+; GFX6-IR-NEXT: [[ENTRY:.*:]]
; GFX6-IR-NEXT: [[FLOOR:%.*]] = tail call double @llvm.floor.f64(double [[X]])
; GFX6-IR-NEXT: [[SUB:%.*]] = fsub double [[X]], [[FLOOR]]
; GFX6-IR-NEXT: [[MIN:%.*]] = tail call double @llvm.minnum.f64(double [[SUB]], double 0x3FEFFFFFFFFFFFFF)
@@ -2215,9 +2215,9 @@ define double @safe_math_fract_f64(double %x, ptr addrspace(1) writeonly capture
; GFX6-IR-NEXT: store double [[FLOOR]], ptr addrspace(1) [[IP]], align 4
; GFX6-IR-NEXT: ret double [[COND6]]
;
-; IR-FRACT-LABEL: define double @safe_math_fract_f64
-; IR-FRACT-SAME: (double [[X:%.*]], ptr addrspace(1) writeonly captures(none) [[IP:%.*]]) #[[ATTR0]] {
-; IR-FRACT-NEXT: entry:
+; IR-FRACT-LABEL: define double @safe_math_fract_f64(
+; IR-FRACT-SAME: double [[X:%.*]], ptr addrspace(1) writeonly captures(none) [[IP:%.*]]) #[[ATTR0]] {
+; IR-FRACT-NEXT: [[ENTRY:.*:]]
; IR-FRACT-NEXT: [[FLOOR:%.*]] = tail call double @llvm.floor.f64(double [[X]])
; IR-FRACT-NEXT: [[COND:%.*]] = call double @llvm.amdgcn.fract.f64(double [[X]])
; IR-FRACT-NEXT: [[FABS:%.*]] = tail call double @llvm.fabs.f64(double [[X]])
@@ -2328,9 +2328,9 @@ entry:
}
define half @safe_math_fract_f16(half %x, ptr addrspace(1) writeonly captures(none) %ip) {
-; GFX6-IR-LABEL: define half @safe_math_fract_f16
-; GFX6-IR-SAME: (half [[X:%.*]], ptr addrspace(1) writeonly captures(none) [[IP:%.*]]) #[[ATTR0]] {
-; GFX6-IR-NEXT: entry:
+; GFX6-IR-LABEL: define half @safe_math_fract_f16(
+; GFX6-IR-SAME: half [[X:%.*]], ptr addrspace(1) writeonly captures(none) [[IP:%.*]]) #[[ATTR0]] {
+; GFX6-IR-NEXT: [[ENTRY:.*:]]
; GFX6-IR-NEXT: [[FLOOR:%.*]] = tail call half @llvm.floor.f16(half [[X]])
; GFX6-IR-NEXT: [[SUB:%.*]] = fsub half [[X]], [[FLOOR]]
; GFX6-IR-NEXT: [[MIN:%.*]] = tail call half @llvm.minnum.f16(half [[SUB]], half 0xH3BFF)
@@ -2342,9 +2342,9 @@ define half @safe_math_fract_f16(half %x, ptr addrspace(1) writeonly captures(no
; GFX6-IR-NEXT: store half [[FLOOR]], ptr addrspace(1) [[IP]], align 4
; GFX6-IR-NEXT: ret half [[COND6]]
;
-; GFX7-IR-LABEL: define half @safe_math_fract_f16
-; GFX7-IR-SAME: (half [[X:%.*]], ptr addrspace(1) writeonly captures(none) [[IP:%.*]]) #[[ATTR0]] {
-; GFX7-IR-NEXT: entry:
+; GFX7-IR-LABEL: define half @safe_math_fract_f16(
+; GFX7-IR-SAME: half [[X:%.*]], ptr addrspace(1) writeonly captures(none) [[IP:%.*]]) #[[ATTR0]] {
+; GFX7-IR-NEXT: [[ENTRY:.*:]]
; GFX7-IR-NEXT: [[FLOOR:%.*]] = tail call half @llvm.floor.f16(half [[X]])
; GFX7-IR-NEXT: [[SUB:%.*]] = fsub half [[X]], [[FLOOR]]
; GFX7-IR-NEXT: [[MIN:%.*]] = tail call half @llvm.minnum.f16(half [[SUB]], half 0xH3BFF)
@@ -2356,9 +2356,9 @@ define half @safe_math_fract_f16(half %x, ptr addrspace(1) writeonly captures(no
; GFX7-IR-NEXT: store half [[FLOOR]], ptr addrspace(1) [[IP]], align 4
; GFX7-IR-NEXT: ret half [[COND6]]
;
-; IR-LEGALF16-LABEL: define half @safe_math_fract_f16
-; IR-LEGALF16-SAME: (half [[X:%.*]], ptr addrspace(1) writeonly captures(none) [[IP:%.*]]) #[[ATTR0]] {
-; IR-LEGALF16-NEXT: entry:
+; IR-LEGALF16-LABEL: define half @safe_math_fract_f16(
+; IR-LEGALF16-SAME: half [[X:%.*]], ptr addrspace(1) writeonly captures(none) [[IP:%.*]]) #[[ATTR0]] {
+; IR-LEGALF16-NEXT: [[ENTRY:.*:]]
; IR-LEGALF16-NEXT: [[FLOOR:%.*]] = tail call half @llvm.floor.f16(half [[X]])
; IR-LEGALF16-NEXT: [[COND:%.*]] = call half @llvm.amdgcn.fract.f16(half [[X]])
; IR-LEGALF16-NEXT: [[FABS:%.*]] = tail call half @llvm.fabs.f16(half [[X]])
@@ -2490,9 +2490,9 @@ entry:
}
define <2 x half> @safe_math_fract_v2f16(<2 x half> %x, ptr addrspace(1) writeonly captures(none) %ip) {
-; GFX6-IR-LABEL: define <2 x half> @safe_math_fract_v2f16
-; GFX6-IR-SAME: (<2 x half> [[X:%.*]], ptr addrspace(1) writeonly captures(none) [[IP:%.*]]) #[[ATTR0]] {
-; GFX6-IR-NEXT: entry:
+; GFX6-IR-LABEL: define <2 x half> @safe_math_fract_v2f16(
+; GFX6-IR-SAME: <2 x half> [[X:%.*]], ptr addrspace(1) writeonly captures(none) [[IP:%.*]]) #[[ATTR0]] {
+; GFX6-IR-NEXT: [[ENTRY:.*:]]
; GFX6-IR-NEXT: [[FLOOR:%.*]] = tail call <2 x half> @llvm.floor.v2f16(<2 x half> [[X]])
; GFX6-IR-NEXT: [[SUB:%.*]] = fsub <2 x half> [[X]], [[FLOOR]]
; GFX6-IR-NEXT: [[MIN:%.*]] = tail call <2 x half> @llvm.minnum.v2f16(<2 x half> [[SUB]], <2 x half> splat (half 0xH3BFF))
@@ -2504,9 +2504,9 @@ define <2 x half> @safe_math_fract_v2f16(<2 x half> %x, ptr addrspace(1) writeon
; GFX6-IR-NEXT: store <2 x half> [[FLOOR]], ptr addrspace(1) [[IP]], align 4
; GFX6-IR-NEXT: ret <2 x half> [[COND6]]
;
-; GFX7-IR-LABEL: define <2 x half> @safe_math_fract_v2f16
-; GFX7-IR-SAME: (<2 x half> [[X:%.*]], ptr addrspace(1) writeonly captures(none) [[IP:%.*]]) #[[ATTR0]] {
-; GFX7-IR-NEXT: entry:
+; GFX7-IR-LABEL: define <2 x half> @safe_math_fract_v2f16(
+; GFX7-IR-SAME: <2 x half> [[X:%.*]], ptr addrspace(1) writeonly captures(none) [[IP:%.*]]) #[[ATTR0]] {
+; GFX7-IR-NEXT: [[ENTRY:.*:]]
; GFX7-IR-NEXT: [[FLOOR:%.*]] = tail call <2 x half> @llvm.floor.v2f16(<2 x half> [[X]])
; GFX7-IR-NEXT: [[SUB:%.*]] = fsub <2 x half> [[X]], [[FLOOR]]
; GFX7-IR-NEXT: [[MIN:%.*]] = tail call <2 x half> @llvm.minnum.v2f16(<2 x half> [[SUB]], <2 x half> splat (half 0xH3BFF))
@@ -2518,9 +2518,9 @@ define <2 x half> @safe_math_fract_v2f16(<2 x half> %x, ptr addrspace(1) writeon
; GFX7-IR-NEXT: store <2 x half> [[FLOOR]], ptr addrspace(1) [[IP]], align 4
; GFX7-IR-NEXT: ret <2 x half> [[COND6]]
;
-; IR-LEGALF16-LABEL: define <2 x half> @safe_math_fract_v2f16
-; IR-LEGALF16-SAME: (<2 x half> [[X:%.*]], ptr addrspace(1) writeonly captures(none) [[IP:%.*]]) #[[ATTR0]] {
-; IR-LEGALF16-NEXT: entry:
+; IR-LEGALF16-LABEL: define <2 x half> @safe_math_fract_v2f16(
+; IR-LEGALF16-SAME: <2 x half> [[X:%.*]], ptr addrspace(1) writeonly captures(none) [[IP:%.*]]) #[[ATTR0]] {
+; IR-LEGALF16-NEXT: [[ENTRY:.*:]]
; IR-LEGALF16-NEXT: [[FLOOR:%.*]] = tail call <2 x half> @llvm.floor.v2f16(<2 x half> [[X]])
; IR-LEGALF16-NEXT: [[TMP0:%.*]] = extractelement <2 x half> [[X]], i64 0
; IR-LEGALF16-NEXT: [[TMP1:%.*]] = extractelement <2 x half> [[X]], i64 1
@@ -2721,9 +2721,9 @@ entry:
}
define <2 x double> @safe_math_fract_v2f64(<2 x double> %x, ptr addrspace(1) writeonly captures(none) %ip) {
-; GFX6-IR-LABEL: define <2 x double> @safe_math_fract_v2f64
-; GFX6-IR-SAME: (<2 x double> [[X:%.*]], ptr addrspace(1) writeonly captures(none) [[IP:%.*]]) #[[ATTR0]] {
-; GFX6-IR-NEXT: entry:
+; GFX6-IR-LABEL: define <2 x double> @safe_math_fract_v2f64(
+; GFX6-IR-SAME: <2 x double> [[X:%.*]], ptr addrspace(1) writeonly captures(none) [[IP:%.*]]) #[[ATTR0]] {
+; GFX6-IR-NEXT: [[ENTRY:.*:]]
; GFX6-IR-NEXT: [[FLOOR:%.*]] = tail call <2 x double> @llvm.floor.v2f64(<2 x double> [[X]])
; GFX6-IR-NEXT: [[SUB:%.*]] = fsub <2 x double> [[X]], [[FLOOR]]
; GFX6-IR-NEXT: [[MIN:%.*]] = tail call <2 x double> @llvm.minnum.v2f64(<2 x double> [[SUB]], <2 x double> splat (double 0x3FEFFFFFFFFFFFFF))
@@ -2735,9 +2735,9 @@ define <2 x double> @safe_math_fract_v2f64(<2 x double> %x, ptr addrspace(1) wri
; GFX6-IR-NEXT: store <2 x double> [[FLOOR]], ptr addrspace(1) [[IP]], align 4
; GFX6-IR-NEXT: ret <2 x double> [[COND6]]
;
-; IR-FRACT-LABEL: define <2 x double> @safe_math_fract_v2f64
-; IR-FRACT-SAME: (<2 x double> [[X:%.*]], ptr addrspace(1) writeonly captures(none) [[IP:%.*]]) #[[ATTR0]] {
-; IR-FRACT-NEXT: entry:
+; IR-FRACT-LABEL: define <2 x double> @safe_math_fract_v2f64(
+; IR-FRACT-SAME: <2 x double> [[X:%.*]], ptr addrspace(1) writeonly captures(none) [[IP:%.*]]) #[[ATTR0]] {
+; IR-FRACT-NEXT: [[ENTRY:.*:]]
; IR-FRACT-NEXT: [[FLOOR:%.*]] = tail call <2 x double> @llvm.floor.v2f64(<2 x double> [[X]])
; IR-FRACT-NEXT: [[TMP0:%.*]] = extractelement <2 x double> [[X]], i64 0
; IR-FRACT-NEXT: [[TMP1:%.*]] = extractelement <2 x double> [[X]], i64 1
More information about the llvm-commits
mailing list