Skip to content

[HLSL] Add deprecation warnings to compatability overloads #159208

New issue

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

Sign up for GitHub

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

Already on GitHub? Sign in to your account

Jump to bottom
Merged
merged 2 commits into from
Sep 19, 2025
Merged

[HLSL] Add deprecation warnings to compatability overloads #159208

merged 2 commits into from
Sep 19, 2025

Conversation

spall
Copy link
Contributor

@spall spall commented Sep 16, 2025

Add deprecation warnings to compatability overloads and add tests to show the warnings.
Closes #133452

@llvmbot llvmbot added clang Clang issues not falling into any other category backend:X86 clang:headers Headers provided by Clang, e.g. for intrinsics HLSL HLSL Language Support labels Sep 16, 2025
@llvmbot
Copy link
Member

llvmbot commented Sep 16, 2025 •
edited
Loading

@llvm/pr-subscribers-clang

@llvm/pr-subscribers-backend-x86

Author: Sarah Spall (spall)

Changes

Add deprecation warnings to compatability overloads and add tests to show the warnings.
Closes #133452

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

5 Files Affected:

  • (modified) clang/lib/Headers/hlsl/hlsl_compat_overloads.h (+101-17)
  • (added) clang/test/SemaHLSL/BuiltIns/binary-compat-overload-warnings.hlsl (+46)
  • (added) clang/test/SemaHLSL/BuiltIns/ternary-compat-overload-warnings.hlsl (+44)
  • (added) clang/test/SemaHLSL/BuiltIns/unary-compat-overload-warnings.hlsl (+67)
  • (added) clang/test/SemaHLSL/BuiltIns/vec-scalar-compat-overload-warnings.hlsl (+41)
diff --git a/clang/lib/Headers/hlsl/hlsl_compat_overloads.h b/clang/lib/Headers/hlsl/hlsl_compat_overloads.h
index 4874206d349c0..72a7bed21f3c9 100644
--- a/clang/lib/Headers/hlsl/hlsl_compat_overloads.h
+++ b/clang/lib/Headers/hlsl/hlsl_compat_overloads.h
@@ -12,148 +12,220 @@
 namespace hlsl {
 
 // Note: Functions in this file are sorted alphabetically, then grouped by base
-// element type, and the element types are sorted by size, then singed integer,
+// element type, and the element types are sorted by size, then signed integer,
 // unsigned integer and floating point. Keeping this ordering consistent will
 // help keep this file manageable as it grows.
 
+#define _DXC_DEPRECATED_64BIT_FN(fn)                                           \
+  [[deprecated("In 202x 64 bit API lowering for " #fn " is deprecated. "       \
+               "Explicitly cast parameters to 32 or 16 bit types.")]]
+
+#define _DXC_DEPRECATED_INT_FN(fn)                                             \
+  [[deprecated("In 202x int lowering for " #fn " is deprecated. "              \
+               "Explicitly cast parameters to float types.")]]
+
+#define _DXC_DEPRECATED_VEC_SCALAR_FN(fn)                                      \
+  [[deprecated("In 202x mismatched vector/scalar lowering for " #fn " is "     \
+               "deprecated. Explicitly cast parameters.")]]
+
 #define _DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(fn)                                 \
+  _DXC_DEPRECATED_64BIT_FN(fn)                                                 \
   constexpr float fn(double V) { return fn((float)V); }                        \
+  _DXC_DEPRECATED_64BIT_FN(fn)                                                 \
   constexpr float2 fn(double2 V) { return fn((float2)V); }                     \
+  _DXC_DEPRECATED_64BIT_FN(fn)                                                 \
   constexpr float3 fn(double3 V) { return fn((float3)V); }                     \
+  _DXC_DEPRECATED_64BIT_FN(fn)                                                 \
   constexpr float4 fn(double4 V) { return fn((float4)V); }
 
 #define _DXC_COMPAT_BINARY_DOUBLE_OVERLOADS(fn)                                \
+  _DXC_DEPRECATED_64BIT_FN(fn)                                                 \
   constexpr float fn(double V1, double V2) {                                   \
     return fn((float)V1, (float)V2);                                           \
   }                                                                            \
+  _DXC_DEPRECATED_64BIT_FN(fn)                                                 \
   constexpr float2 fn(double2 V1, double2 V2) {                                \
     return fn((float2)V1, (float2)V2);                                         \
   }                                                                            \
+  _DXC_DEPRECATED_64BIT_FN(fn)                                                 \
   constexpr float3 fn(double3 V1, double3 V2) {                                \
     return fn((float3)V1, (float3)V2);                                         \
   }                                                                            \
+  _DXC_DEPRECATED_64BIT_FN(fn)                                                 \
   constexpr float4 fn(double4 V1, double4 V2) {                                \
     return fn((float4)V1, (float4)V2);                                         \
   }
 
 #define _DXC_COMPAT_TERNARY_DOUBLE_OVERLOADS(fn)                               \
+  _DXC_DEPRECATED_64BIT_FN(fn)                                                 \
   constexpr float fn(double V1, double V2, double V3) {                        \
     return fn((float)V1, (float)V2, (float)V3);                                \
   }                                                                            \
+  _DXC_DEPRECATED_64BIT_FN(fn)                                                 \
   constexpr float2 fn(double2 V1, double2 V2, double2 V3) {                    \
     return fn((float2)V1, (float2)V2, (float2)V3);                             \
   }                                                                            \
+  _DXC_DEPRECATED_64BIT_FN(fn)                                                 \
   constexpr float3 fn(double3 V1, double3 V2, double3 V3) {                    \
     return fn((float3)V1, (float3)V2, (float3)V3);                             \
   }                                                                            \
+  _DXC_DEPRECATED_64BIT_FN(fn)                                                 \
   constexpr float4 fn(double4 V1, double4 V2, double4 V3) {                    \
     return fn((float4)V1, (float4)V2, (float4)V3);                             \
   }
 
 #define _DXC_COMPAT_UNARY_INTEGER_OVERLOADS(fn)                                \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float fn(int V) { return fn((float)V); }                           \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float2 fn(int2 V) { return fn((float2)V); }                        \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float3 fn(int3 V) { return fn((float3)V); }                        \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float4 fn(int4 V) { return fn((float4)V); }                        \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float fn(uint V) { return fn((float)V); }                          \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float2 fn(uint2 V) { return fn((float2)V); }                       \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float3 fn(uint3 V) { return fn((float3)V); }                       \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float4 fn(uint4 V) { return fn((float4)V); }                       \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float fn(int64_t V) { return fn((float)V); }                       \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float2 fn(int64_t2 V) { return fn((float2)V); }                    \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float3 fn(int64_t3 V) { return fn((float3)V); }                    \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float4 fn(int64_t4 V) { return fn((float4)V); }                    \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float fn(uint64_t V) { return fn((float)V); }                      \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float2 fn(uint64_t2 V) { return fn((float2)V); }                   \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float3 fn(uint64_t3 V) { return fn((float3)V); }                   \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float4 fn(uint64_t4 V) { return fn((float4)V); }
 
 #define _DXC_COMPAT_BINARY_INTEGER_OVERLOADS(fn)                               \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float fn(int V1, int V2) { return fn((float)V1, (float)V2); }      \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float2 fn(int2 V1, int2 V2) { return fn((float2)V1, (float2)V2); } \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float3 fn(int3 V1, int3 V2) { return fn((float3)V1, (float3)V2); } \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float4 fn(int4 V1, int4 V2) { return fn((float4)V1, (float4)V2); } \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float fn(uint V1, uint V2) { return fn((float)V1, (float)V2); }    \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float2 fn(uint2 V1, uint2 V2) {                                    \
     return fn((float2)V1, (float2)V2);                                         \
   }                                                                            \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float3 fn(uint3 V1, uint3 V2) {                                    \
     return fn((float3)V1, (float3)V2);                                         \
   }                                                                            \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float4 fn(uint4 V1, uint4 V2) {                                    \
     return fn((float4)V1, (float4)V2);                                         \
   }                                                                            \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float fn(int64_t V1, int64_t V2) {                                 \
     return fn((float)V1, (float)V2);                                           \
   }                                                                            \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float2 fn(int64_t2 V1, int64_t2 V2) {                              \
     return fn((float2)V1, (float2)V2);                                         \
   }                                                                            \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float3 fn(int64_t3 V1, int64_t3 V2) {                              \
     return fn((float3)V1, (float3)V2);                                         \
   }                                                                            \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float4 fn(int64_t4 V1, int64_t4 V2) {                              \
     return fn((float4)V1, (float4)V2);                                         \
   }                                                                            \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float fn(uint64_t V1, uint64_t V2) {                               \
     return fn((float)V1, (float)V2);                                           \
   }                                                                            \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float2 fn(uint64_t2 V1, uint64_t2 V2) {                            \
     return fn((float2)V1, (float2)V2);                                         \
   }                                                                            \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float3 fn(uint64_t3 V1, uint64_t3 V2) {                            \
     return fn((float3)V1, (float3)V2);                                         \
   }                                                                            \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float4 fn(uint64_t4 V1, uint64_t4 V2) {                            \
     return fn((float4)V1, (float4)V2);                                         \
   }
 
 #define _DXC_COMPAT_TERNARY_INTEGER_OVERLOADS(fn)                              \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float fn(int V1, int V2, int V3) {                                 \
     return fn((float)V1, (float)V2, (float)V3);                                \
   }                                                                            \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float2 fn(int2 V1, int2 V2, int2 V3) {                             \
     return fn((float2)V1, (float2)V2, (float2)V3);                             \
   }                                                                            \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float3 fn(int3 V1, int3 V2, int3 V3) {                             \
     return fn((float3)V1, (float3)V2, (float3)V3);                             \
   }                                                                            \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float4 fn(int4 V1, int4 V2, int4 V3) {                             \
     return fn((float4)V1, (float4)V2, (float4)V3);                             \
   }                                                                            \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float fn(uint V1, uint V2, uint V3) {                              \
     return fn((float)V1, (float)V2, (float)V3);                                \
   }                                                                            \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float2 fn(uint2 V1, uint2 V2, uint2 V3) {                          \
     return fn((float2)V1, (float2)V2, (float2)V3);                             \
   }                                                                            \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float3 fn(uint3 V1, uint3 V2, uint3 V3) {                          \
     return fn((float3)V1, (float3)V2, (float3)V3);                             \
   }                                                                            \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float4 fn(uint4 V1, uint4 V2, uint4 V3) {                          \
     return fn((float4)V1, (float4)V2, (float4)V3);                             \
   }                                                                            \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float fn(int64_t V1, int64_t V2, int64_t V3) {                     \
     return fn((float)V1, (float)V2, (float)V3);                                \
   }                                                                            \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float2 fn(int64_t2 V1, int64_t2 V2, int64_t2 V3) {                 \
     return fn((float2)V1, (float2)V2, (float2)V3);                             \
   }                                                                            \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float3 fn(int64_t3 V1, int64_t3 V2, int64_t3 V3) {                 \
     return fn((float3)V1, (float3)V2, (float3)V3);                             \
   }                                                                            \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float4 fn(int64_t4 V1, int64_t4 V2, int64_t4 V3) {                 \
     return fn((float4)V1, (float4)V2, (float4)V3);                             \
   }                                                                            \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float fn(uint64_t V1, uint64_t V2, uint64_t V3) {                  \
     return fn((float)V1, (float)V2, (float)V3);                                \
   }                                                                            \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float2 fn(uint64_t2 V1, uint64_t2 V2, uint64_t2 V3) {              \
     return fn((float2)V1, (float2)V2, (float2)V3);                             \
   }                                                                            \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float3 fn(uint64_t3 V1, uint64_t3 V2, uint64_t3 V3) {              \
     return fn((float3)V1, (float3)V2, (float3)V3);                             \
   }                                                                            \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float4 fn(uint64_t4 V1, uint64_t4 V2, uint64_t4 V3) {              \
     return fn((float4)V1, (float4)V2, (float4)V3);                             \
   }
@@ -198,20 +270,23 @@ _DXC_COMPAT_UNARY_INTEGER_OVERLOADS(ceil)
 //===----------------------------------------------------------------------===//
 
 template <typename T, uint N>
-constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>>
-clamp(vector<T, N> p0, vector<T, N> p1, T p2) {
+_DXC_DEPRECATED_VEC_SCALAR_FN(clamp)
+constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>> clamp(
+    vector<T, N> p0, vector<T, N> p1, T p2) {
   return clamp(p0, p1, (vector<T, N>)p2);
 }
 
 template <typename T, uint N>
-constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>>
-clamp(vector<T, N> p0, T p1, vector<T, N> p2) {
+_DXC_DEPRECATED_VEC_SCALAR_FN(clamp)
+constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>> clamp(
+    vector<T, N> p0, T p1, vector<T, N> p2) {
   return clamp(p0, (vector<T, N>)p1, p2);
 }
 
 template <typename T, uint N>
-constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>>
-clamp(vector<T, N> p0, T p1, T p2) {
+_DXC_DEPRECATED_VEC_SCALAR_FN(clamp)
+constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>> clamp(
+    vector<T, N> p0, T p1, T p2) {
   return clamp(p0, (vector<T, N>)p1, (vector<T, N>)p2);
 }
 
@@ -268,9 +343,13 @@ _DXC_COMPAT_UNARY_INTEGER_OVERLOADS(frac)
 // isinf builtins overloads
 //===----------------------------------------------------------------------===//
 
+_DXC_DEPRECATED_64BIT_FN(fn)
 constexpr bool isinf(double V) { return isinf((float)V); }
+_DXC_DEPRECATED_64BIT_FN(fn)
 constexpr bool2 isinf(double2 V) { return isinf((float2)V); }
+_DXC_DEPRECATED_64BIT_FN(fn)
 constexpr bool3 isinf(double3 V) { return isinf((float3)V); }
+_DXC_DEPRECATED_64BIT_FN(fn)
 constexpr bool4 isinf(double4 V) { return isinf((float4)V); }
 
 //===----------------------------------------------------------------------===//
@@ -278,8 +357,9 @@ constexpr bool4 isinf(double4 V) { return isinf((float4)V); }
 //===----------------------------------------------------------------------===//
 
 template <typename T, uint N>
-constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>>
-lerp(vector<T, N> x, vector<T, N> y, T s) {
+_DXC_DEPRECATED_VEC_SCALAR_FN(lerp)
+constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>> lerp(
+    vector<T, N> x, vector<T, N> y, T s) {
   return lerp(x, y, (vector<T, N>)s);
 }
 
@@ -312,14 +392,16 @@ _DXC_COMPAT_UNARY_INTEGER_OVERLOADS(log2)
 //===----------------------------------------------------------------------===//
 
 template <typename T, uint N>
-constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>>
-max(vector<T, N> p0, T p1) {
+_DXC_DEPRECATED_VEC_SCALAR_FN(max)
+constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>> max(
+    vector<T, N> p0, T p1) {
   return max(p0, (vector<T, N>)p1);
 }
 
 template <typename T, uint N>
-constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>>
-max(T p0, vector<T, N> p1) {
+_DXC_DEPRECATED_VEC_SCALAR_FN(max)
+constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>> max(
+    T p0, vector<T, N> p1) {
   return max((vector<T, N>)p0, p1);
 }
 
@@ -328,14 +410,16 @@ max(T p0, vector<T, N> p1) {
 //===----------------------------------------------------------------------===//
 
 template <typename T, uint N>
-constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>>
-min(vector<T, N> p0, T p1) {
+_DXC_DEPRECATED_VEC_SCALAR_FN(...
[truncated]

@llvmbot
Copy link
Member

llvmbot commented Sep 16, 2025

@llvm/pr-subscribers-hlsl

Author: Sarah Spall (spall)

Changes

Add deprecation warnings to compatability overloads and add tests to show the warnings.
Closes #133452

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

5 Files Affected:

  • (modified) clang/lib/Headers/hlsl/hlsl_compat_overloads.h (+101-17)
  • (added) clang/test/SemaHLSL/BuiltIns/binary-compat-overload-warnings.hlsl (+46)
  • (added) clang/test/SemaHLSL/BuiltIns/ternary-compat-overload-warnings.hlsl (+44)
  • (added) clang/test/SemaHLSL/BuiltIns/unary-compat-overload-warnings.hlsl (+67)
  • (added) clang/test/SemaHLSL/BuiltIns/vec-scalar-compat-overload-warnings.hlsl (+41)
diff --git a/clang/lib/Headers/hlsl/hlsl_compat_overloads.h b/clang/lib/Headers/hlsl/hlsl_compat_overloads.h
index 4874206d349c0..72a7bed21f3c9 100644
--- a/clang/lib/Headers/hlsl/hlsl_compat_overloads.h
+++ b/clang/lib/Headers/hlsl/hlsl_compat_overloads.h
@@ -12,148 +12,220 @@
 namespace hlsl {
 
 // Note: Functions in this file are sorted alphabetically, then grouped by base
-// element type, and the element types are sorted by size, then singed integer,
+// element type, and the element types are sorted by size, then signed integer,
 // unsigned integer and floating point. Keeping this ordering consistent will
 // help keep this file manageable as it grows.
 
+#define _DXC_DEPRECATED_64BIT_FN(fn)                                           \
+  [[deprecated("In 202x 64 bit API lowering for " #fn " is deprecated. "       \
+               "Explicitly cast parameters to 32 or 16 bit types.")]]
+
+#define _DXC_DEPRECATED_INT_FN(fn)                                             \
+  [[deprecated("In 202x int lowering for " #fn " is deprecated. "              \
+               "Explicitly cast parameters to float types.")]]
+
+#define _DXC_DEPRECATED_VEC_SCALAR_FN(fn)                                      \
+  [[deprecated("In 202x mismatched vector/scalar lowering for " #fn " is "     \
+               "deprecated. Explicitly cast parameters.")]]
+
 #define _DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(fn)                                 \
+  _DXC_DEPRECATED_64BIT_FN(fn)                                                 \
   constexpr float fn(double V) { return fn((float)V); }                        \
+  _DXC_DEPRECATED_64BIT_FN(fn)                                                 \
   constexpr float2 fn(double2 V) { return fn((float2)V); }                     \
+  _DXC_DEPRECATED_64BIT_FN(fn)                                                 \
   constexpr float3 fn(double3 V) { return fn((float3)V); }                     \
+  _DXC_DEPRECATED_64BIT_FN(fn)                                                 \
   constexpr float4 fn(double4 V) { return fn((float4)V); }
 
 #define _DXC_COMPAT_BINARY_DOUBLE_OVERLOADS(fn)                                \
+  _DXC_DEPRECATED_64BIT_FN(fn)                                                 \
   constexpr float fn(double V1, double V2) {                                   \
     return fn((float)V1, (float)V2);                                           \
   }                                                                            \
+  _DXC_DEPRECATED_64BIT_FN(fn)                                                 \
   constexpr float2 fn(double2 V1, double2 V2) {                                \
     return fn((float2)V1, (float2)V2);                                         \
   }                                                                            \
+  _DXC_DEPRECATED_64BIT_FN(fn)                                                 \
   constexpr float3 fn(double3 V1, double3 V2) {                                \
     return fn((float3)V1, (float3)V2);                                         \
   }                                                                            \
+  _DXC_DEPRECATED_64BIT_FN(fn)                                                 \
   constexpr float4 fn(double4 V1, double4 V2) {                                \
     return fn((float4)V1, (float4)V2);                                         \
   }
 
 #define _DXC_COMPAT_TERNARY_DOUBLE_OVERLOADS(fn)                               \
+  _DXC_DEPRECATED_64BIT_FN(fn)                                                 \
   constexpr float fn(double V1, double V2, double V3) {                        \
     return fn((float)V1, (float)V2, (float)V3);                                \
   }                                                                            \
+  _DXC_DEPRECATED_64BIT_FN(fn)                                                 \
   constexpr float2 fn(double2 V1, double2 V2, double2 V3) {                    \
     return fn((float2)V1, (float2)V2, (float2)V3);                             \
   }                                                                            \
+  _DXC_DEPRECATED_64BIT_FN(fn)                                                 \
   constexpr float3 fn(double3 V1, double3 V2, double3 V3) {                    \
     return fn((float3)V1, (float3)V2, (float3)V3);                             \
   }                                                                            \
+  _DXC_DEPRECATED_64BIT_FN(fn)                                                 \
   constexpr float4 fn(double4 V1, double4 V2, double4 V3) {                    \
     return fn((float4)V1, (float4)V2, (float4)V3);                             \
   }
 
 #define _DXC_COMPAT_UNARY_INTEGER_OVERLOADS(fn)                                \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float fn(int V) { return fn((float)V); }                           \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float2 fn(int2 V) { return fn((float2)V); }                        \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float3 fn(int3 V) { return fn((float3)V); }                        \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float4 fn(int4 V) { return fn((float4)V); }                        \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float fn(uint V) { return fn((float)V); }                          \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float2 fn(uint2 V) { return fn((float2)V); }                       \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float3 fn(uint3 V) { return fn((float3)V); }                       \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float4 fn(uint4 V) { return fn((float4)V); }                       \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float fn(int64_t V) { return fn((float)V); }                       \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float2 fn(int64_t2 V) { return fn((float2)V); }                    \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float3 fn(int64_t3 V) { return fn((float3)V); }                    \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float4 fn(int64_t4 V) { return fn((float4)V); }                    \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float fn(uint64_t V) { return fn((float)V); }                      \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float2 fn(uint64_t2 V) { return fn((float2)V); }                   \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float3 fn(uint64_t3 V) { return fn((float3)V); }                   \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float4 fn(uint64_t4 V) { return fn((float4)V); }
 
 #define _DXC_COMPAT_BINARY_INTEGER_OVERLOADS(fn)                               \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float fn(int V1, int V2) { return fn((float)V1, (float)V2); }      \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float2 fn(int2 V1, int2 V2) { return fn((float2)V1, (float2)V2); } \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float3 fn(int3 V1, int3 V2) { return fn((float3)V1, (float3)V2); } \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float4 fn(int4 V1, int4 V2) { return fn((float4)V1, (float4)V2); } \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float fn(uint V1, uint V2) { return fn((float)V1, (float)V2); }    \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float2 fn(uint2 V1, uint2 V2) {                                    \
     return fn((float2)V1, (float2)V2);                                         \
   }                                                                            \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float3 fn(uint3 V1, uint3 V2) {                                    \
     return fn((float3)V1, (float3)V2);                                         \
   }                                                                            \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float4 fn(uint4 V1, uint4 V2) {                                    \
     return fn((float4)V1, (float4)V2);                                         \
   }                                                                            \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float fn(int64_t V1, int64_t V2) {                                 \
     return fn((float)V1, (float)V2);                                           \
   }                                                                            \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float2 fn(int64_t2 V1, int64_t2 V2) {                              \
     return fn((float2)V1, (float2)V2);                                         \
   }                                                                            \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float3 fn(int64_t3 V1, int64_t3 V2) {                              \
     return fn((float3)V1, (float3)V2);                                         \
   }                                                                            \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float4 fn(int64_t4 V1, int64_t4 V2) {                              \
     return fn((float4)V1, (float4)V2);                                         \
   }                                                                            \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float fn(uint64_t V1, uint64_t V2) {                               \
     return fn((float)V1, (float)V2);                                           \
   }                                                                            \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float2 fn(uint64_t2 V1, uint64_t2 V2) {                            \
     return fn((float2)V1, (float2)V2);                                         \
   }                                                                            \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float3 fn(uint64_t3 V1, uint64_t3 V2) {                            \
     return fn((float3)V1, (float3)V2);                                         \
   }                                                                            \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float4 fn(uint64_t4 V1, uint64_t4 V2) {                            \
     return fn((float4)V1, (float4)V2);                                         \
   }
 
 #define _DXC_COMPAT_TERNARY_INTEGER_OVERLOADS(fn)                              \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float fn(int V1, int V2, int V3) {                                 \
     return fn((float)V1, (float)V2, (float)V3);                                \
   }                                                                            \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float2 fn(int2 V1, int2 V2, int2 V3) {                             \
     return fn((float2)V1, (float2)V2, (float2)V3);                             \
   }                                                                            \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float3 fn(int3 V1, int3 V2, int3 V3) {                             \
     return fn((float3)V1, (float3)V2, (float3)V3);                             \
   }                                                                            \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float4 fn(int4 V1, int4 V2, int4 V3) {                             \
     return fn((float4)V1, (float4)V2, (float4)V3);                             \
   }                                                                            \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float fn(uint V1, uint V2, uint V3) {                              \
     return fn((float)V1, (float)V2, (float)V3);                                \
   }                                                                            \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float2 fn(uint2 V1, uint2 V2, uint2 V3) {                          \
     return fn((float2)V1, (float2)V2, (float2)V3);                             \
   }                                                                            \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float3 fn(uint3 V1, uint3 V2, uint3 V3) {                          \
     return fn((float3)V1, (float3)V2, (float3)V3);                             \
   }                                                                            \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float4 fn(uint4 V1, uint4 V2, uint4 V3) {                          \
     return fn((float4)V1, (float4)V2, (float4)V3);                             \
   }                                                                            \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float fn(int64_t V1, int64_t V2, int64_t V3) {                     \
     return fn((float)V1, (float)V2, (float)V3);                                \
   }                                                                            \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float2 fn(int64_t2 V1, int64_t2 V2, int64_t2 V3) {                 \
     return fn((float2)V1, (float2)V2, (float2)V3);                             \
   }                                                                            \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float3 fn(int64_t3 V1, int64_t3 V2, int64_t3 V3) {                 \
     return fn((float3)V1, (float3)V2, (float3)V3);                             \
   }                                                                            \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float4 fn(int64_t4 V1, int64_t4 V2, int64_t4 V3) {                 \
     return fn((float4)V1, (float4)V2, (float4)V3);                             \
   }                                                                            \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float fn(uint64_t V1, uint64_t V2, uint64_t V3) {                  \
     return fn((float)V1, (float)V2, (float)V3);                                \
   }                                                                            \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float2 fn(uint64_t2 V1, uint64_t2 V2, uint64_t2 V3) {              \
     return fn((float2)V1, (float2)V2, (float2)V3);                             \
   }                                                                            \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float3 fn(uint64_t3 V1, uint64_t3 V2, uint64_t3 V3) {              \
     return fn((float3)V1, (float3)V2, (float3)V3);                             \
   }                                                                            \
+  _DXC_DEPRECATED_INT_FN(fn)                                                   \
   constexpr float4 fn(uint64_t4 V1, uint64_t4 V2, uint64_t4 V3) {              \
     return fn((float4)V1, (float4)V2, (float4)V3);                             \
   }
@@ -198,20 +270,23 @@ _DXC_COMPAT_UNARY_INTEGER_OVERLOADS(ceil)
 //===----------------------------------------------------------------------===//
 
 template <typename T, uint N>
-constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>>
-clamp(vector<T, N> p0, vector<T, N> p1, T p2) {
+_DXC_DEPRECATED_VEC_SCALAR_FN(clamp)
+constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>> clamp(
+    vector<T, N> p0, vector<T, N> p1, T p2) {
   return clamp(p0, p1, (vector<T, N>)p2);
 }
 
 template <typename T, uint N>
-constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>>
-clamp(vector<T, N> p0, T p1, vector<T, N> p2) {
+_DXC_DEPRECATED_VEC_SCALAR_FN(clamp)
+constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>> clamp(
+    vector<T, N> p0, T p1, vector<T, N> p2) {
   return clamp(p0, (vector<T, N>)p1, p2);
 }
 
 template <typename T, uint N>
-constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>>
-clamp(vector<T, N> p0, T p1, T p2) {
+_DXC_DEPRECATED_VEC_SCALAR_FN(clamp)
+constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>> clamp(
+    vector<T, N> p0, T p1, T p2) {
   return clamp(p0, (vector<T, N>)p1, (vector<T, N>)p2);
 }
 
@@ -268,9 +343,13 @@ _DXC_COMPAT_UNARY_INTEGER_OVERLOADS(frac)
 // isinf builtins overloads
 //===----------------------------------------------------------------------===//
 
+_DXC_DEPRECATED_64BIT_FN(fn)
 constexpr bool isinf(double V) { return isinf((float)V); }
+_DXC_DEPRECATED_64BIT_FN(fn)
 constexpr bool2 isinf(double2 V) { return isinf((float2)V); }
+_DXC_DEPRECATED_64BIT_FN(fn)
 constexpr bool3 isinf(double3 V) { return isinf((float3)V); }
+_DXC_DEPRECATED_64BIT_FN(fn)
 constexpr bool4 isinf(double4 V) { return isinf((float4)V); }
 
 //===----------------------------------------------------------------------===//
@@ -278,8 +357,9 @@ constexpr bool4 isinf(double4 V) { return isinf((float4)V); }
 //===----------------------------------------------------------------------===//
 
 template <typename T, uint N>
-constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>>
-lerp(vector<T, N> x, vector<T, N> y, T s) {
+_DXC_DEPRECATED_VEC_SCALAR_FN(lerp)
+constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>> lerp(
+    vector<T, N> x, vector<T, N> y, T s) {
   return lerp(x, y, (vector<T, N>)s);
 }
 
@@ -312,14 +392,16 @@ _DXC_COMPAT_UNARY_INTEGER_OVERLOADS(log2)
 //===----------------------------------------------------------------------===//
 
 template <typename T, uint N>
-constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>>
-max(vector<T, N> p0, T p1) {
+_DXC_DEPRECATED_VEC_SCALAR_FN(max)
+constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>> max(
+    vector<T, N> p0, T p1) {
   return max(p0, (vector<T, N>)p1);
 }
 
 template <typename T, uint N>
-constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>>
-max(T p0, vector<T, N> p1) {
+_DXC_DEPRECATED_VEC_SCALAR_FN(max)
+constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>> max(
+    T p0, vector<T, N> p1) {
   return max((vector<T, N>)p0, p1);
 }
 
@@ -328,14 +410,16 @@ max(T p0, vector<T, N> p1) {
 //===----------------------------------------------------------------------===//
 
 template <typename T, uint N>
-constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>>
-min(vector<T, N> p0, T p1) {
+_DXC_DEPRECATED_VEC_SCALAR_FN(...
[truncated]

inbelic
inbelic approved these changes Sep 17, 2025
View reviewed changes
clang/test/SemaHLSL/BuiltIns/binary-compat-overload-warnings.hlsl Outdated
@@ -0,0 +1,46 @@
// RUN: %clang_dxc -T cs_6_0 -HV 202x -DFUNC=atan2 %s 2>&1 | FileCheck %s -DFUNC=atan2
Copy link
Contributor

@inbelic inbelic Sep 17, 2025 •
edited
Loading

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

nit: I think all the other tests in this directory are invoked through cc1. We should probably match this here.

edit: this might be why the test runners are failing? The dxc driver might not be built yet

@spall spall merged commit 4c7ebf8 into llvm:main Sep 19, 2025
9 checks passed
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Reviewers

@llvm-beanz llvm-beanz llvm-beanz approved these changes

@inbelic inbelic inbelic approved these changes

Assignees

No one assigned

Labels

backend:X86 clang:headers Headers provided by Clang, e.g. for intrinsics clang Clang issues not falling into any other category HLSL HLSL Language Support

Projects

None yet

Milestone

No milestone

Development

Successfully merging this pull request may close these issues.

[HLSL] Add deprecated warnings to overloads defined in hlsl_compat_overloads.h

4 participants

@spall @llvmbot @llvm-beanz @inbelic