@cpp-linter/clang-tidy-win32-x64 21.1.0 → 22.1.8

package/lib/clang/{21 → 22}/include/hlsl/hlsl_compat_overloads.h

@@ -7,153 +7,225 @@
 //===----------------------------------------------------------------------===//
 
 #ifndef _HLSL_COMPAT_OVERLOADS_H_
-#define _HLSl_COMPAT_OVERLOADS_H_
+#define _HLSL_COMPAT_OVERLOADS_H_
 
 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,18 +343,32 @@ _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); }
 
+//===----------------------------------------------------------------------===//
+// isnan builtins overloads
+//===----------------------------------------------------------------------===//
+
+constexpr bool isnan(double V) { return isnan((float)V); }
+constexpr bool2 isnan(double2 V) { return isnan((float2)V); }
+constexpr bool3 isnan(double3 V) { return isnan((float3)V); }
+constexpr bool4 isnan(double4 V) { return isnan((float4)V); }
+
 //===----------------------------------------------------------------------===//
 // lerp builtins overloads
 //===----------------------------------------------------------------------===//
 
 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 +401,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 +419,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(min)
+constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>> min(
+    vector<T, N> p0, T p1) {
   return min(p0, (vector<T, N>)p1);
 }
 
 template <typename T, uint N>
-constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>>
-min(T p0, vector<T, N> p1) {
+_DXC_DEPRECATED_VEC_SCALAR_FN(min)
+constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>> min(
+    T p0, vector<T, N> p1) {
   return min((vector<T, N>)p0, p1);
 }
 

package/lib/clang/{21 → 22}/include/hlsl/hlsl_intrinsic_helpers.h

@@ -12,7 +12,7 @@
 namespace hlsl {
 namespace __detail {
 
-constexpr vector<uint, 4> d3d_color_to_ubyte4_impl(vector<float, 4> V) {
+constexpr int4 d3d_color_to_ubyte4_impl(float4 V) {
   // Use the same scaling factor used by FXC, and DXC for DXIL
   // (i.e., 255.001953)
   // https://github.com/microsoft/DirectXShaderCompiler/blob/070d0d5a2beacef9eeb51037a9b04665716fd6f3/lib/HLSL/HLOperationLower.cpp#L666C1-L697C2
@@ -71,6 +71,16 @@ constexpr vector<T, L> reflect_vec_impl(vector<T, L> I, vector<T, L> N) {
 #endif
 }
 
+template <typename T, typename U> constexpr T refract_impl(T I, T N, U Eta) {
+#if (__has_builtin(__builtin_spirv_refract))
+  return __builtin_spirv_refract(I, N, Eta);
+#endif
+  T Mul = dot(N, I);
+  T K = 1 - Eta * Eta * (1 - Mul * Mul);
+  T Result = (Eta * I - (Eta * Mul + sqrt(K)) * N);
+  return select<T>(K < 0, static_cast<T>(0), Result);
+}
+
 template <typename T> constexpr T fmod_impl(T X, T Y) {
 #if !defined(__DIRECTX__)
   return __builtin_elementwise_fmod(X, Y);
@@ -127,17 +137,53 @@ template <typename T> constexpr vector<T, 4> lit_impl(T NDotL, T NDotH, T M) {
 }
 
 template <typename T> constexpr T faceforward_impl(T N, T I, T Ng) {
-#if (__has_builtin(__builtin_spirv_faceforward))
-  return __builtin_spirv_faceforward(N, I, Ng);
-#else
   return select(dot(I, Ng) < 0, N, -N);
-#endif
 }
 
 template <typename T> constexpr T ldexp_impl(T X, T Exp) {
   return exp2(Exp) * X;
 }
 
+template <typename K, typename T, int BitWidth>
+constexpr K firstbithigh_impl(T X) {
+  K FBH = __builtin_hlsl_elementwise_firstbithigh(X);
+#if defined(__DIRECTX__)
+  // The firstbithigh DXIL ops count bits from the wrong side, so we need to
+  // invert it for DirectX.
+  K Inversion = (BitWidth - 1) - FBH;
+  FBH = select(FBH == -1, FBH, Inversion);
+#endif
+  return FBH;
+}
+
+template <typename T> constexpr T ddx_impl(T input) {
+#if (__has_builtin(__builtin_spirv_ddx))
+  return __builtin_spirv_ddx(input);
+#else
+  return __builtin_hlsl_elementwise_ddx_coarse(input);
+#endif
+}
+
+template <typename T> constexpr T ddy_impl(T input) {
+#if (__has_builtin(__builtin_spirv_ddy))
+  return __builtin_spirv_ddy(input);
+#else
+  return __builtin_hlsl_elementwise_ddy_coarse(input);
+#endif
+}
+
+template <typename T> constexpr T fwidth_impl(T input) {
+#if (__has_builtin(__builtin_spirv_fwidth))
+  return __builtin_spirv_fwidth(input);
+#else
+  T derivCoarseX = ddx_coarse(input);
+  derivCoarseX = abs(derivCoarseX);
+  T derivCoarseY = ddy_coarse(input);
+  derivCoarseY = abs(derivCoarseY);
+  return derivCoarseX + derivCoarseY;
+#endif
+}
+
 } // namespace __detail
 } // namespace hlsl