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@+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@+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@+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@+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@+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@+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@+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@+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@+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@+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@+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@+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@+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@+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@+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@+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@+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@+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@+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@+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@+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@+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@+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@+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@+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@+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@+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@+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@+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@+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@+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@+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@+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@+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 _______________________________________________ cfe-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
