[clang] [HLSL] Add macro for float->bool double overloads (PR #233024)
via cfe-commits
cfe-commits at lists.llvm.org
Fri Oct 16 23:06:12 PDT 2026
llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-backend-x86
Author: Dan Brown (danbrown-amd)
<details>
<summary>Changes</summary>
New macro captures the pattern for isfinite(), isinf(), and isnan(). Expected warnings now include template arguments, consistent with other intrinsics' double overload deprecation warnings.
Assisted-by: Claude Sonnet 4
---
Patch is 38.67 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/233024.diff
4 Files Affected:
- (modified) clang/lib/Headers/hlsl/hlsl_compat_overloads.h (+18-114)
- (modified) clang/test/CodeGenHLSL/builtins/isfinite_mat-overloads.hlsl (+15-15)
- (modified) clang/test/CodeGenHLSL/builtins/isinf_mat-overloads.hlsl (+15-15)
- (modified) clang/test/CodeGenHLSL/builtins/isnan_mat-overloads.hlsl (+15-15)
``````````diff
diff --git a/clang/lib/Headers/hlsl/hlsl_compat_overloads.h b/clang/lib/Headers/hlsl/hlsl_compat_overloads.h
index 15af384ec15076..b674a63b5aa7df 100644
--- a/clang/lib/Headers/hlsl/hlsl_compat_overloads.h
+++ b/clang/lib/Headers/hlsl/hlsl_compat_overloads.h
@@ -271,6 +271,21 @@ namespace hlsl {
return fn((matrix<float, R, C>)V1, (matrix<float, R, C>)V2); \
}
+#define _DXC_COMPAT_FLOAT_TO_BOOL_OVERLOADS(fn) \
+_DXC_DEPRECATED_64BIT_FN(fn) \
+constexpr bool fn(double V) { return fn((float)V); } \
+_DXC_DEPRECATED_64BIT_FN(fn) \
+constexpr bool2 fn(double2 V) { return fn((float2)V); } \
+_DXC_DEPRECATED_64BIT_FN(fn) \
+constexpr bool3 fn(double3 V) { return fn((float3)V); } \
+_DXC_DEPRECATED_64BIT_FN(fn) \
+constexpr bool4 fn(double4 V) { return fn((float4)V); } \
+template <uint R, uint C> \
+ _DXC_DEPRECATED_64BIT_FN(fn) \
+ constexpr matrix<bool, R, C> fn(matrix<double, R, C> V) { \
+ return fn((matrix<float, R, C>)V); \
+ }
+
//===----------------------------------------------------------------------===//
// acos builtins overloads
//===----------------------------------------------------------------------===//
@@ -386,130 +401,19 @@ _DXC_COMPAT_UNARY_INTEGER_OVERLOADS(frac)
// isfinite builtins overloads
//===----------------------------------------------------------------------===//
-_DXC_DEPRECATED_64BIT_FN(isfinite)
-constexpr bool isfinite(double V) { return isfinite((float)V); }
-_DXC_DEPRECATED_64BIT_FN(isfinite)
-constexpr bool2 isfinite(double2 V) { return isfinite((float2)V); }
-_DXC_DEPRECATED_64BIT_FN(isfinite)
-constexpr bool3 isfinite(double3 V) { return isfinite((float3)V); }
-_DXC_DEPRECATED_64BIT_FN(isfinite)
-constexpr bool4 isfinite(double4 V) { return isfinite((float4)V); }
-_DXC_DEPRECATED_64BIT_FN(isfinite)
-constexpr bool1x2 isfinite(double1x2 V) { return isfinite((float1x2)V); }
-_DXC_DEPRECATED_64BIT_FN(isfinite)
-constexpr bool1x3 isfinite(double1x3 V) { return isfinite((float1x3)V); }
-_DXC_DEPRECATED_64BIT_FN(isfinite)
-constexpr bool1x4 isfinite(double1x4 V) { return isfinite((float1x4)V); }
-_DXC_DEPRECATED_64BIT_FN(isfinite)
-constexpr bool2x1 isfinite(double2x1 V) { return isfinite((float2x1)V); }
-_DXC_DEPRECATED_64BIT_FN(isfinite)
-constexpr bool2x2 isfinite(double2x2 V) { return isfinite((float2x2)V); }
-_DXC_DEPRECATED_64BIT_FN(isfinite)
-constexpr bool2x3 isfinite(double2x3 V) { return isfinite((float2x3)V); }
-_DXC_DEPRECATED_64BIT_FN(isfinite)
-constexpr bool2x4 isfinite(double2x4 V) { return isfinite((float2x4)V); }
-_DXC_DEPRECATED_64BIT_FN(isfinite)
-constexpr bool3x1 isfinite(double3x1 V) { return isfinite((float3x1)V); }
-_DXC_DEPRECATED_64BIT_FN(isfinite)
-constexpr bool3x2 isfinite(double3x2 V) { return isfinite((float3x2)V); }
-_DXC_DEPRECATED_64BIT_FN(isfinite)
-constexpr bool3x3 isfinite(double3x3 V) { return isfinite((float3x3)V); }
-_DXC_DEPRECATED_64BIT_FN(isfinite)
-constexpr bool3x4 isfinite(double3x4 V) { return isfinite((float3x4)V); }
-_DXC_DEPRECATED_64BIT_FN(isfinite)
-constexpr bool4x1 isfinite(double4x1 V) { return isfinite((float4x1)V); }
-_DXC_DEPRECATED_64BIT_FN(isfinite)
-constexpr bool4x2 isfinite(double4x2 V) { return isfinite((float4x2)V); }
-_DXC_DEPRECATED_64BIT_FN(isfinite)
-constexpr bool4x3 isfinite(double4x3 V) { return isfinite((float4x3)V); }
-_DXC_DEPRECATED_64BIT_FN(isfinite)
-constexpr bool4x4 isfinite(double4x4 V) { return isfinite((float4x4)V); }
+_DXC_COMPAT_FLOAT_TO_BOOL_OVERLOADS(isfinite)
//===----------------------------------------------------------------------===//
// isinf builtins overloads
//===----------------------------------------------------------------------===//
-_DXC_DEPRECATED_64BIT_FN(isinf)
-constexpr bool isinf(double V) { return isinf((float)V); }
-_DXC_DEPRECATED_64BIT_FN(isinf)
-constexpr bool2 isinf(double2 V) { return isinf((float2)V); }
-_DXC_DEPRECATED_64BIT_FN(isinf)
-constexpr bool3 isinf(double3 V) { return isinf((float3)V); }
-_DXC_DEPRECATED_64BIT_FN(isinf)
-constexpr bool4 isinf(double4 V) { return isinf((float4)V); }
-_DXC_DEPRECATED_64BIT_FN(isinf)
-constexpr bool1x2 isinf(double1x2 V) { return isinf((float1x2)V); }
-_DXC_DEPRECATED_64BIT_FN(isinf)
-constexpr bool1x3 isinf(double1x3 V) { return isinf((float1x3)V); }
-_DXC_DEPRECATED_64BIT_FN(isinf)
-constexpr bool1x4 isinf(double1x4 V) { return isinf((float1x4)V); }
-_DXC_DEPRECATED_64BIT_FN(isinf)
-constexpr bool2x1 isinf(double2x1 V) { return isinf((float2x1)V); }
-_DXC_DEPRECATED_64BIT_FN(isinf)
-constexpr bool2x2 isinf(double2x2 V) { return isinf((float2x2)V); }
-_DXC_DEPRECATED_64BIT_FN(isinf)
-constexpr bool2x3 isinf(double2x3 V) { return isinf((float2x3)V); }
-_DXC_DEPRECATED_64BIT_FN(isinf)
-constexpr bool2x4 isinf(double2x4 V) { return isinf((float2x4)V); }
-_DXC_DEPRECATED_64BIT_FN(isinf)
-constexpr bool3x1 isinf(double3x1 V) { return isinf((float3x1)V); }
-_DXC_DEPRECATED_64BIT_FN(isinf)
-constexpr bool3x2 isinf(double3x2 V) { return isinf((float3x2)V); }
-_DXC_DEPRECATED_64BIT_FN(isinf)
-constexpr bool3x3 isinf(double3x3 V) { return isinf((float3x3)V); }
-_DXC_DEPRECATED_64BIT_FN(isinf)
-constexpr bool3x4 isinf(double3x4 V) { return isinf((float3x4)V); }
-_DXC_DEPRECATED_64BIT_FN(isinf)
-constexpr bool4x1 isinf(double4x1 V) { return isinf((float4x1)V); }
-_DXC_DEPRECATED_64BIT_FN(isinf)
-constexpr bool4x2 isinf(double4x2 V) { return isinf((float4x2)V); }
-_DXC_DEPRECATED_64BIT_FN(isinf)
-constexpr bool4x3 isinf(double4x3 V) { return isinf((float4x3)V); }
-_DXC_DEPRECATED_64BIT_FN(isinf)
-constexpr bool4x4 isinf(double4x4 V) { return isinf((float4x4)V); }
+_DXC_COMPAT_FLOAT_TO_BOOL_OVERLOADS(isinf)
//===----------------------------------------------------------------------===//
// isnan builtins overloads
//===----------------------------------------------------------------------===//
-_DXC_DEPRECATED_64BIT_FN(isnan)
-constexpr bool isnan(double V) { return isnan((float)V); }
-_DXC_DEPRECATED_64BIT_FN(isnan)
-constexpr bool2 isnan(double2 V) { return isnan((float2)V); }
-_DXC_DEPRECATED_64BIT_FN(isnan)
-constexpr bool3 isnan(double3 V) { return isnan((float3)V); }
-_DXC_DEPRECATED_64BIT_FN(isnan)
-constexpr bool4 isnan(double4 V) { return isnan((float4)V); }
-_DXC_DEPRECATED_64BIT_FN(isnan)
-constexpr bool1x2 isnan(double1x2 V) { return isnan((float1x2)V); }
-_DXC_DEPRECATED_64BIT_FN(isnan)
-constexpr bool1x3 isnan(double1x3 V) { return isnan((float1x3)V); }
-_DXC_DEPRECATED_64BIT_FN(isnan)
-constexpr bool1x4 isnan(double1x4 V) { return isnan((float1x4)V); }
-_DXC_DEPRECATED_64BIT_FN(isnan)
-constexpr bool2x1 isnan(double2x1 V) { return isnan((float2x1)V); }
-_DXC_DEPRECATED_64BIT_FN(isnan)
-constexpr bool2x2 isnan(double2x2 V) { return isnan((float2x2)V); }
-_DXC_DEPRECATED_64BIT_FN(isnan)
-constexpr bool2x3 isnan(double2x3 V) { return isnan((float2x3)V); }
-_DXC_DEPRECATED_64BIT_FN(isnan)
-constexpr bool2x4 isnan(double2x4 V) { return isnan((float2x4)V); }
-_DXC_DEPRECATED_64BIT_FN(isnan)
-constexpr bool3x1 isnan(double3x1 V) { return isnan((float3x1)V); }
-_DXC_DEPRECATED_64BIT_FN(isnan)
-constexpr bool3x2 isnan(double3x2 V) { return isnan((float3x2)V); }
-_DXC_DEPRECATED_64BIT_FN(isnan)
-constexpr bool3x3 isnan(double3x3 V) { return isnan((float3x3)V); }
-_DXC_DEPRECATED_64BIT_FN(isnan)
-constexpr bool3x4 isnan(double3x4 V) { return isnan((float3x4)V); }
-_DXC_DEPRECATED_64BIT_FN(isnan)
-constexpr bool4x1 isnan(double4x1 V) { return isnan((float4x1)V); }
-_DXC_DEPRECATED_64BIT_FN(isnan)
-constexpr bool4x2 isnan(double4x2 V) { return isnan((float4x2)V); }
-_DXC_DEPRECATED_64BIT_FN(isnan)
-constexpr bool4x3 isnan(double4x3 V) { return isnan((float4x3)V); }
-_DXC_DEPRECATED_64BIT_FN(isnan)
-constexpr bool4x4 isnan(double4x4 V) { return isnan((float4x4)V); }
+_DXC_COMPAT_FLOAT_TO_BOOL_OVERLOADS(isnan)
//===----------------------------------------------------------------------===//
// lerp builtins overloads
diff --git a/clang/test/CodeGenHLSL/builtins/isfinite_mat-overloads.hlsl b/clang/test/CodeGenHLSL/builtins/isfinite_mat-overloads.hlsl
index da7dbf9e4b5d6d..299facd20a277a 100644
--- a/clang/test/CodeGenHLSL/builtins/isfinite_mat-overloads.hlsl
+++ b/clang/test/CodeGenHLSL/builtins/isfinite_mat-overloads.hlsl
@@ -13,103 +13,103 @@
// CHECK: [[CONV:%.*]] = fptrunc {{.*}} <2 x double> %{{.*}} to <2 x float>
// CHECK: [[RET:%.*]] = call <2 x i1> @llvm.[[TARGET]].isfinite.v2f32(<2 x float> [[CONV]])
// CHECK: ret <2 x i1> [[RET]]
-// expected-warning at +1 {{'isfinite' is deprecated: In 202x 64 bit API lowering for isfinite is deprecated. Explicitly cast parameters to 32 or 16 bit types.}}
+// expected-warning at +1 {{'isfinite<1U, 2U>' is deprecated: In 202x 64 bit API lowering for isfinite is deprecated. Explicitly cast parameters to 32 or 16 bit types.}}
bool1x2 test_isfinite_double1x2(double1x2 p0) { return isfinite(p0); }
// CHECK-LABEL: define {{.*}} <3 x i1> @_{{.*}}test_isfinite_double1x3{{.*}}(
// CHECK: [[CONV:%.*]] = fptrunc {{.*}} <3 x double> %{{.*}} to <3 x float>
// CHECK: [[RET:%.*]] = call <3 x i1> @llvm.[[TARGET]].isfinite.v3f32(<3 x float> [[CONV]])
// CHECK: ret <3 x i1> [[RET]]
-// expected-warning at +1 {{'isfinite' is deprecated: In 202x 64 bit API lowering for isfinite is deprecated. Explicitly cast parameters to 32 or 16 bit types.}}
+// expected-warning at +1 {{'isfinite<1U, 3U>' is deprecated: In 202x 64 bit API lowering for isfinite is deprecated. Explicitly cast parameters to 32 or 16 bit types.}}
bool1x3 test_isfinite_double1x3(double1x3 p0) { return isfinite(p0); }
// CHECK-LABEL: define {{.*}} <4 x i1> @_{{.*}}test_isfinite_double1x4{{.*}}(
// CHECK: [[CONV:%.*]] = fptrunc {{.*}} <4 x double> %{{.*}} to <4 x float>
// CHECK: [[RET:%.*]] = call <4 x i1> @llvm.[[TARGET]].isfinite.v4f32(<4 x float> [[CONV]])
// CHECK: ret <4 x i1> [[RET]]
-// expected-warning at +1 {{'isfinite' is deprecated: In 202x 64 bit API lowering for isfinite is deprecated. Explicitly cast parameters to 32 or 16 bit types.}}
+// expected-warning at +1 {{'isfinite<1U, 4U>' is deprecated: In 202x 64 bit API lowering for isfinite is deprecated. Explicitly cast parameters to 32 or 16 bit types.}}
bool1x4 test_isfinite_double1x4(double1x4 p0) { return isfinite(p0); }
// CHECK-LABEL: define {{.*}} <2 x i1> @_{{.*}}test_isfinite_double2x1{{.*}}(
// CHECK: [[CONV:%.*]] = fptrunc {{.*}} <2 x double> %{{.*}} to <2 x float>
// CHECK: [[RET:%.*]] = call <2 x i1> @llvm.[[TARGET]].isfinite.v2f32(<2 x float> [[CONV]])
// CHECK: ret <2 x i1> [[RET]]
-// expected-warning at +1 {{'isfinite' is deprecated: In 202x 64 bit API lowering for isfinite is deprecated. Explicitly cast parameters to 32 or 16 bit types.}}
+// expected-warning at +1 {{'isfinite<2U, 1U>' is deprecated: In 202x 64 bit API lowering for isfinite is deprecated. Explicitly cast parameters to 32 or 16 bit types.}}
bool2x1 test_isfinite_double2x1(double2x1 p0) { return isfinite(p0); }
// CHECK-LABEL: define {{.*}} <4 x i1> @_{{.*}}test_isfinite_double2x2{{.*}}(
// CHECK: [[CONV:%.*]] = fptrunc {{.*}} <4 x double> %{{.*}} to <4 x float>
// CHECK: [[RET:%.*]] = call <4 x i1> @llvm.[[TARGET]].isfinite.v4f32(<4 x float> [[CONV]])
// CHECK: ret <4 x i1> [[RET]]
-// expected-warning at +1 {{'isfinite' is deprecated: In 202x 64 bit API lowering for isfinite is deprecated. Explicitly cast parameters to 32 or 16 bit types.}}
+// expected-warning at +1 {{'isfinite<2U, 2U>' is deprecated: In 202x 64 bit API lowering for isfinite is deprecated. Explicitly cast parameters to 32 or 16 bit types.}}
bool2x2 test_isfinite_double2x2(double2x2 p0) { return isfinite(p0); }
// CHECK-LABEL: define {{.*}} <6 x i1> @_{{.*}}test_isfinite_double2x3{{.*}}(
// CHECK: [[CONV:%.*]] = fptrunc {{.*}} <6 x double> %{{.*}} to <6 x float>
// CHECK: [[RET:%.*]] = call <6 x i1> @llvm.[[TARGET]].isfinite.v6f32(<6 x float> [[CONV]])
// CHECK: ret <6 x i1> [[RET]]
-// expected-warning at +1 {{'isfinite' is deprecated: In 202x 64 bit API lowering for isfinite is deprecated. Explicitly cast parameters to 32 or 16 bit types.}}
+// expected-warning at +1 {{'isfinite<2U, 3U>' is deprecated: In 202x 64 bit API lowering for isfinite is deprecated. Explicitly cast parameters to 32 or 16 bit types.}}
bool2x3 test_isfinite_double2x3(double2x3 p0) { return isfinite(p0); }
// CHECK-LABEL: define {{.*}} <8 x i1> @_{{.*}}test_isfinite_double2x4{{.*}}(
// CHECK: [[CONV:%.*]] = fptrunc {{.*}} <8 x double> %{{.*}} to <8 x float>
// CHECK: [[RET:%.*]] = call <8 x i1> @llvm.[[TARGET]].isfinite.v8f32(<8 x float> [[CONV]])
// CHECK: ret <8 x i1> [[RET]]
-// expected-warning at +1 {{'isfinite' is deprecated: In 202x 64 bit API lowering for isfinite is deprecated. Explicitly cast parameters to 32 or 16 bit types.}}
+// expected-warning at +1 {{'isfinite<2U, 4U>' is deprecated: In 202x 64 bit API lowering for isfinite is deprecated. Explicitly cast parameters to 32 or 16 bit types.}}
bool2x4 test_isfinite_double2x4(double2x4 p0) { return isfinite(p0); }
// CHECK-LABEL: define {{.*}} <3 x i1> @_{{.*}}test_isfinite_double3x1{{.*}}(
// CHECK: [[CONV:%.*]] = fptrunc {{.*}} <3 x double> %{{.*}} to <3 x float>
// CHECK: [[RET:%.*]] = call <3 x i1> @llvm.[[TARGET]].isfinite.v3f32(<3 x float> [[CONV]])
// CHECK: ret <3 x i1> [[RET]]
-// expected-warning at +1 {{'isfinite' is deprecated: In 202x 64 bit API lowering for isfinite is deprecated. Explicitly cast parameters to 32 or 16 bit types.}}
+// expected-warning at +1 {{'isfinite<3U, 1U>' is deprecated: In 202x 64 bit API lowering for isfinite is deprecated. Explicitly cast parameters to 32 or 16 bit types.}}
bool3x1 test_isfinite_double3x1(double3x1 p0) { return isfinite(p0); }
// CHECK-LABEL: define {{.*}} <6 x i1> @_{{.*}}test_isfinite_double3x2{{.*}}(
// CHECK: [[CONV:%.*]] = fptrunc {{.*}} <6 x double> %{{.*}} to <6 x float>
// CHECK: [[RET:%.*]] = call <6 x i1> @llvm.[[TARGET]].isfinite.v6f32(<6 x float> [[CONV]])
// CHECK: ret <6 x i1> [[RET]]
-// expected-warning at +1 {{'isfinite' is deprecated: In 202x 64 bit API lowering for isfinite is deprecated. Explicitly cast parameters to 32 or 16 bit types.}}
+// expected-warning at +1 {{'isfinite<3U, 2U>' is deprecated: In 202x 64 bit API lowering for isfinite is deprecated. Explicitly cast parameters to 32 or 16 bit types.}}
bool3x2 test_isfinite_double3x2(double3x2 p0) { return isfinite(p0); }
// CHECK-LABEL: define {{.*}} <9 x i1> @_{{.*}}test_isfinite_double3x3{{.*}}(
// CHECK: [[CONV:%.*]] = fptrunc {{.*}} <9 x double> %{{.*}} to <9 x float>
// CHECK: [[RET:%.*]] = call <9 x i1> @llvm.[[TARGET]].isfinite.v9f32(<9 x float> [[CONV]])
// CHECK: ret <9 x i1> [[RET]]
-// expected-warning at +1 {{'isfinite' is deprecated: In 202x 64 bit API lowering for isfinite is deprecated. Explicitly cast parameters to 32 or 16 bit types.}}
+// expected-warning at +1 {{'isfinite<3U, 3U>' is deprecated: In 202x 64 bit API lowering for isfinite is deprecated. Explicitly cast parameters to 32 or 16 bit types.}}
bool3x3 test_isfinite_double3x3(double3x3 p0) { return isfinite(p0); }
// CHECK-LABEL: define {{.*}} <12 x i1> @_{{.*}}test_isfinite_double3x4{{.*}}(
// CHECK: [[CONV:%.*]] = fptrunc {{.*}} <12 x double> %{{.*}} to <12 x float>
// CHECK: [[RET:%.*]] = call <12 x i1> @llvm.[[TARGET]].isfinite.v12f32(<12 x float> [[CONV]])
// CHECK: ret <12 x i1> [[RET]]
-// expected-warning at +1 {{'isfinite' is deprecated: In 202x 64 bit API lowering for isfinite is deprecated. Explicitly cast parameters to 32 or 16 bit types.}}
+// expected-warning at +1 {{'isfinite<3U, 4U>' is deprecated: In 202x 64 bit API lowering for isfinite is deprecated. Explicitly cast parameters to 32 or 16 bit types.}}
bool3x4 test_isfinite_double3x4(double3x4 p0) { return isfinite(p0); }
// CHECK-LABEL: define {{.*}} <4 x i1> @_{{.*}}test_isfinite_double4x1{{.*}}(
// CHECK: [[CONV:%.*]] = fptrunc {{.*}} <4 x double> %{{.*}} to <4 x float>
// CHECK: [[RET:%.*]] = call <4 x i1> @llvm.[[TARGET]].isfinite.v4f32(<4 x float> [[CONV]])
// CHECK: ret <4 x i1> [[RET]]
-// expected-warning at +1 {{'isfinite' is deprecated: In 202x 64 bit API lowering for isfinite is deprecated. Explicitly cast parameters to 32 or 16 bit types.}}
+// expected-warning at +1 {{'isfinite<4U, 1U>' is deprecated: In 202x 64 bit API lowering for isfinite is deprecated. Explicitly cast parameters to 32 or 16 bit types.}}
bool4x1 test_isfinite_double4x1(double4x1 p0) { return isfinite(p0); }
// CHECK-LABEL: define {{.*}} <8 x i1> @_{{.*}}test_isfinite_double4x2{{.*}}(
// CHECK: [[CONV:%.*]] = fptrunc {{.*}} <8 x double> %{{.*}} to <8 x float>
// CHECK: [[RET:%.*]] = call <8 x i1> @llvm.[[TARGET]].isfinite.v8f32(<8 x float> [[CONV]])
// CHECK: ret <8 x i1> [[RET]]
-// expected-warning at +1 {{'isfinite' is deprecated: In 202x 64 bit API lowering for isfinite is deprecated. Explicitly cast parameters to 32 or 16 bit types.}}
+// expected-warning at +1 {{'isfinite<4U, 2U>' is deprecated: In 202x 64 bit API lowering for isfinite is deprecated. Explicitly cast parameters to 32 or 16 bit types.}}
bool4x2 test_isfinite_double4x2(double4x2 p0) { return isfinite(p0); }
// CHECK-LABEL: define {{.*}} <12 x i1> @_{{.*}}test_isfinite_double4x3{{.*}}(
// CHECK: [[CONV:%.*]] = fptrunc {{.*}} <12 x double> %{{.*}} to <12 x float>
// CHECK: [[RET:%.*]] = call <12 x i1> @llvm.[[TARGET]].isfinite.v12f32(<12 x float> [[CONV]])
// CHECK: ret <12 x i1> [[RET]]
-// expected-warning at +1 {{'isfinite' is deprecated: In 202x 64 bit API lowering for isfinite is deprecated. Explicitly cast parameters to 32 or 16 bit types.}}
+// expected-warning at +1 {{'isfinite<4U, 3U>' is deprecated: In 202x 64 bit API lowering for isfinite is deprecated. Explicitly cast parameters to 32 or 16 bit types.}}
bool4x3 test_isfinite_double4x3(double4x3 p0) { return isfinite(p0); }
// CHECK-LABEL: define {{.*}} <16 x i1> @_{{.*}}test_isfinite_double4x4{{.*}}(
// CHECK: [[CONV:%.*]] = fptrunc {{.*}} <16 x double> %{{.*}} to <16 x float>
// CHECK: [[RET:%.*]] = call <16 x i1> @llvm.[[TARGET]].isfinite.v16f32(<16 x float> [[CONV]])
// CHECK: ret <16 x i1> [[RET]]
-// expected-warning at +1 {{'isfinite' is deprecated: In 202x 64 bit API lowering for isfinite is deprecated. Explicitly cast parameters to 32 or 16 bit types.}}
+// expected-warning at +1 {{'isfinite<4U, 4U>' is deprecated: In 202x 64 bit API lowering for isfinite is deprecated. Explicitly cast parameters to 32 or 16 bit types.}}
bool4x4 test_isfinite_double4x4(double4x4 p0) { return isfinite(p0); }
diff --git a/clang/test/CodeGenHLSL/builtins/isinf_mat-overloads.hlsl b/clang/test/CodeGenHLSL/builtins/isinf_mat-overloads.hlsl
index 01ddfe785911cb..562ac62b7e17fd 100644
--- a/clang/test/CodeGenHLSL/builtins/isinf_mat-overloads.hlsl
+++ b/clang/test/CodeGenHLSL/builtins/isinf_mat-overloads.hlsl
@@ -13,103 +13,103 @@
// CHECK: [[CONV:%.*]] = fptrunc {{.*}} <2 x double> %{{.*}} to <2 x float>
// CHECK: [[RET:%.*]] = call <2 x i1> @llvm.[[TARGET]].isinf.v2f32(<2 x float> [[CONV]])
// CHECK: ret <2 x i1> [[RET]]
-// expected-warning at +1 {{'isinf' is deprecated: In 202x 64 bit API lowering for isinf is deprecated. Explicitly cast parameters to 32 or 16 bit types.}}
+// expected-warning at +1 {{'isinf<1U, 2U>' is deprecated: In 202x 64 bit API lowering for isinf is deprecated. Explicitly cast parameters to 32 or 16 bit types.}}
bool1x2 test_isinf_double1x2(double1x2 p0) { return isinf(p0); }
// CHECK-LABEL: define {{.*}} <3 x i1> @_{{.*}}test_isinf_double1x3{{.*}}(
// CHECK: [[CONV:%.*]] = fptrunc {{.*}} <3 x double> %{{.*}} to <3 x float>
// CHECK: [[RET:%.*]] = call <3 x i1> @llvm.[[TARGET]].isinf.v3f32(<3 x float> [[CONV]])
// CHECK: ret <3 x i1> [[RET]]
-// expected-warning at +1 {{'isinf' is deprecated: In 202x 64 bit API lowering for isinf is deprecated. Explicitly cast parameters to 32 or 16 bit types.}}
+// expected-warning at +1 {{'isinf<1U, 3U>' is deprecated: In 202x 64 bit API lowering for isinf is d...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/233024
More information about the cfe-commits
mailing list