@cpp-linter/clang-tidy-darwin-arm64 20.1.8 → 21.1.8

package/lib/clang/21/include/hlsl/hlsl_compat_overloads.h

@@ -0,0 +1,427 @@
+//===--- hlsl_compat_overloads.h - Extra HLSL overloads for intrinsics ----===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _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,
+// unsigned integer and floating point. Keeping this ordering consistent will
+// help keep this file manageable as it grows.
+
+#define _DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(fn)                                 \
+  constexpr float fn(double V) { return fn((float)V); }                        \
+  constexpr float2 fn(double2 V) { return fn((float2)V); }                     \
+  constexpr float3 fn(double3 V) { return fn((float3)V); }                     \
+  constexpr float4 fn(double4 V) { return fn((float4)V); }
+
+#define _DXC_COMPAT_BINARY_DOUBLE_OVERLOADS(fn)                                \
+  constexpr float fn(double V1, double V2) {                                   \
+    return fn((float)V1, (float)V2);                                           \
+  }                                                                            \
+  constexpr float2 fn(double2 V1, double2 V2) {                                \
+    return fn((float2)V1, (float2)V2);                                         \
+  }                                                                            \
+  constexpr float3 fn(double3 V1, double3 V2) {                                \
+    return fn((float3)V1, (float3)V2);                                         \
+  }                                                                            \
+  constexpr float4 fn(double4 V1, double4 V2) {                                \
+    return fn((float4)V1, (float4)V2);                                         \
+  }
+
+#define _DXC_COMPAT_TERNARY_DOUBLE_OVERLOADS(fn)                               \
+  constexpr float fn(double V1, double V2, double V3) {                        \
+    return fn((float)V1, (float)V2, (float)V3);                                \
+  }                                                                            \
+  constexpr float2 fn(double2 V1, double2 V2, double2 V3) {                    \
+    return fn((float2)V1, (float2)V2, (float2)V3);                             \
+  }                                                                            \
+  constexpr float3 fn(double3 V1, double3 V2, double3 V3) {                    \
+    return fn((float3)V1, (float3)V2, (float3)V3);                             \
+  }                                                                            \
+  constexpr float4 fn(double4 V1, double4 V2, double4 V3) {                    \
+    return fn((float4)V1, (float4)V2, (float4)V3);                             \
+  }
+
+#define _DXC_COMPAT_UNARY_INTEGER_OVERLOADS(fn)                                \
+  constexpr float fn(int V) { return fn((float)V); }                           \
+  constexpr float2 fn(int2 V) { return fn((float2)V); }                        \
+  constexpr float3 fn(int3 V) { return fn((float3)V); }                        \
+  constexpr float4 fn(int4 V) { return fn((float4)V); }                        \
+  constexpr float fn(uint V) { return fn((float)V); }                          \
+  constexpr float2 fn(uint2 V) { return fn((float2)V); }                       \
+  constexpr float3 fn(uint3 V) { return fn((float3)V); }                       \
+  constexpr float4 fn(uint4 V) { return fn((float4)V); }                       \
+  constexpr float fn(int64_t V) { return fn((float)V); }                       \
+  constexpr float2 fn(int64_t2 V) { return fn((float2)V); }                    \
+  constexpr float3 fn(int64_t3 V) { return fn((float3)V); }                    \
+  constexpr float4 fn(int64_t4 V) { return fn((float4)V); }                    \
+  constexpr float fn(uint64_t V) { return fn((float)V); }                      \
+  constexpr float2 fn(uint64_t2 V) { return fn((float2)V); }                   \
+  constexpr float3 fn(uint64_t3 V) { return fn((float3)V); }                   \
+  constexpr float4 fn(uint64_t4 V) { return fn((float4)V); }
+
+#define _DXC_COMPAT_BINARY_INTEGER_OVERLOADS(fn)                               \
+  constexpr float fn(int V1, int V2) { return fn((float)V1, (float)V2); }      \
+  constexpr float2 fn(int2 V1, int2 V2) { return fn((float2)V1, (float2)V2); } \
+  constexpr float3 fn(int3 V1, int3 V2) { return fn((float3)V1, (float3)V2); } \
+  constexpr float4 fn(int4 V1, int4 V2) { return fn((float4)V1, (float4)V2); } \
+  constexpr float fn(uint V1, uint V2) { return fn((float)V1, (float)V2); }    \
+  constexpr float2 fn(uint2 V1, uint2 V2) {                                    \
+    return fn((float2)V1, (float2)V2);                                         \
+  }                                                                            \
+  constexpr float3 fn(uint3 V1, uint3 V2) {                                    \
+    return fn((float3)V1, (float3)V2);                                         \
+  }                                                                            \
+  constexpr float4 fn(uint4 V1, uint4 V2) {                                    \
+    return fn((float4)V1, (float4)V2);                                         \
+  }                                                                            \
+  constexpr float fn(int64_t V1, int64_t V2) {                                 \
+    return fn((float)V1, (float)V2);                                           \
+  }                                                                            \
+  constexpr float2 fn(int64_t2 V1, int64_t2 V2) {                              \
+    return fn((float2)V1, (float2)V2);                                         \
+  }                                                                            \
+  constexpr float3 fn(int64_t3 V1, int64_t3 V2) {                              \
+    return fn((float3)V1, (float3)V2);                                         \
+  }                                                                            \
+  constexpr float4 fn(int64_t4 V1, int64_t4 V2) {                              \
+    return fn((float4)V1, (float4)V2);                                         \
+  }                                                                            \
+  constexpr float fn(uint64_t V1, uint64_t V2) {                               \
+    return fn((float)V1, (float)V2);                                           \
+  }                                                                            \
+  constexpr float2 fn(uint64_t2 V1, uint64_t2 V2) {                            \
+    return fn((float2)V1, (float2)V2);                                         \
+  }                                                                            \
+  constexpr float3 fn(uint64_t3 V1, uint64_t3 V2) {                            \
+    return fn((float3)V1, (float3)V2);                                         \
+  }                                                                            \
+  constexpr float4 fn(uint64_t4 V1, uint64_t4 V2) {                            \
+    return fn((float4)V1, (float4)V2);                                         \
+  }
+
+#define _DXC_COMPAT_TERNARY_INTEGER_OVERLOADS(fn)                              \
+  constexpr float fn(int V1, int V2, int V3) {                                 \
+    return fn((float)V1, (float)V2, (float)V3);                                \
+  }                                                                            \
+  constexpr float2 fn(int2 V1, int2 V2, int2 V3) {                             \
+    return fn((float2)V1, (float2)V2, (float2)V3);                             \
+  }                                                                            \
+  constexpr float3 fn(int3 V1, int3 V2, int3 V3) {                             \
+    return fn((float3)V1, (float3)V2, (float3)V3);                             \
+  }                                                                            \
+  constexpr float4 fn(int4 V1, int4 V2, int4 V3) {                             \
+    return fn((float4)V1, (float4)V2, (float4)V3);                             \
+  }                                                                            \
+  constexpr float fn(uint V1, uint V2, uint V3) {                              \
+    return fn((float)V1, (float)V2, (float)V3);                                \
+  }                                                                            \
+  constexpr float2 fn(uint2 V1, uint2 V2, uint2 V3) {                          \
+    return fn((float2)V1, (float2)V2, (float2)V3);                             \
+  }                                                                            \
+  constexpr float3 fn(uint3 V1, uint3 V2, uint3 V3) {                          \
+    return fn((float3)V1, (float3)V2, (float3)V3);                             \
+  }                                                                            \
+  constexpr float4 fn(uint4 V1, uint4 V2, uint4 V3) {                          \
+    return fn((float4)V1, (float4)V2, (float4)V3);                             \
+  }                                                                            \
+  constexpr float fn(int64_t V1, int64_t V2, int64_t V3) {                     \
+    return fn((float)V1, (float)V2, (float)V3);                                \
+  }                                                                            \
+  constexpr float2 fn(int64_t2 V1, int64_t2 V2, int64_t2 V3) {                 \
+    return fn((float2)V1, (float2)V2, (float2)V3);                             \
+  }                                                                            \
+  constexpr float3 fn(int64_t3 V1, int64_t3 V2, int64_t3 V3) {                 \
+    return fn((float3)V1, (float3)V2, (float3)V3);                             \
+  }                                                                            \
+  constexpr float4 fn(int64_t4 V1, int64_t4 V2, int64_t4 V3) {                 \
+    return fn((float4)V1, (float4)V2, (float4)V3);                             \
+  }                                                                            \
+  constexpr float fn(uint64_t V1, uint64_t V2, uint64_t V3) {                  \
+    return fn((float)V1, (float)V2, (float)V3);                                \
+  }                                                                            \
+  constexpr float2 fn(uint64_t2 V1, uint64_t2 V2, uint64_t2 V3) {              \
+    return fn((float2)V1, (float2)V2, (float2)V3);                             \
+  }                                                                            \
+  constexpr float3 fn(uint64_t3 V1, uint64_t3 V2, uint64_t3 V3) {              \
+    return fn((float3)V1, (float3)V2, (float3)V3);                             \
+  }                                                                            \
+  constexpr float4 fn(uint64_t4 V1, uint64_t4 V2, uint64_t4 V3) {              \
+    return fn((float4)V1, (float4)V2, (float4)V3);                             \
+  }
+
+//===----------------------------------------------------------------------===//
+// acos builtins overloads
+//===----------------------------------------------------------------------===//
+
+_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(acos)
+_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(acos)
+
+//===----------------------------------------------------------------------===//
+// asin builtins overloads
+//===----------------------------------------------------------------------===//
+
+_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(asin)
+_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(asin)
+
+//===----------------------------------------------------------------------===//
+// atan builtins overloads
+//===----------------------------------------------------------------------===//
+
+_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(atan)
+_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(atan)
+
+//===----------------------------------------------------------------------===//
+// atan2 builtins overloads
+//===----------------------------------------------------------------------===//
+
+_DXC_COMPAT_BINARY_DOUBLE_OVERLOADS(atan2)
+_DXC_COMPAT_BINARY_INTEGER_OVERLOADS(atan2)
+
+//===----------------------------------------------------------------------===//
+// ceil builtins overloads
+//===----------------------------------------------------------------------===//
+
+_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(ceil)
+_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(ceil)
+
+//===----------------------------------------------------------------------===//
+// clamp builtins overloads
+//===----------------------------------------------------------------------===//
+
+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) {
+  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) {
+  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) {
+  return clamp(p0, (vector<T, N>)p1, (vector<T, N>)p2);
+}
+
+//===----------------------------------------------------------------------===//
+// cos builtins overloads
+//===----------------------------------------------------------------------===//
+
+_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(cos)
+_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(cos)
+
+//===----------------------------------------------------------------------===//
+// cosh builtins overloads
+//===----------------------------------------------------------------------===//
+
+_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(cosh)
+_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(cosh)
+
+//===----------------------------------------------------------------------===//
+// degrees builtins overloads
+//===----------------------------------------------------------------------===//
+
+_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(degrees)
+_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(degrees)
+
+//===----------------------------------------------------------------------===//
+// exp builtins overloads
+//===----------------------------------------------------------------------===//
+
+_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(exp)
+_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(exp)
+
+//===----------------------------------------------------------------------===//
+// exp2 builtins overloads
+//===----------------------------------------------------------------------===//
+
+_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(exp2)
+_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(exp2)
+
+//===----------------------------------------------------------------------===//
+// floor builtins overloads
+//===----------------------------------------------------------------------===//
+
+_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(floor)
+_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(floor)
+
+//===----------------------------------------------------------------------===//
+// frac builtins overloads
+//===----------------------------------------------------------------------===//
+
+_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(frac)
+_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(frac)
+
+//===----------------------------------------------------------------------===//
+// isinf builtins overloads
+//===----------------------------------------------------------------------===//
+
+constexpr bool isinf(double V) { return isinf((float)V); }
+constexpr bool2 isinf(double2 V) { return isinf((float2)V); }
+constexpr bool3 isinf(double3 V) { return isinf((float3)V); }
+constexpr bool4 isinf(double4 V) { return isinf((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) {
+  return lerp(x, y, (vector<T, N>)s);
+}
+
+_DXC_COMPAT_TERNARY_DOUBLE_OVERLOADS(lerp)
+_DXC_COMPAT_TERNARY_INTEGER_OVERLOADS(lerp)
+
+//===----------------------------------------------------------------------===//
+// log builtins overloads
+//===----------------------------------------------------------------------===//
+
+_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(log)
+_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(log)
+
+//===----------------------------------------------------------------------===//
+// log10 builtins overloads
+//===----------------------------------------------------------------------===//
+
+_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(log10)
+_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(log10)
+
+//===----------------------------------------------------------------------===//
+// log2 builtins overloads
+//===----------------------------------------------------------------------===//
+
+_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(log2)
+_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(log2)
+
+//===----------------------------------------------------------------------===//
+// max builtins overloads
+//===----------------------------------------------------------------------===//
+
+template <typename T, uint N>
+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) {
+  return max((vector<T, N>)p0, p1);
+}
+
+//===----------------------------------------------------------------------===//
+// min builtins overloads
+//===----------------------------------------------------------------------===//
+
+template <typename T, uint N>
+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) {
+  return min((vector<T, N>)p0, p1);
+}
+
+//===----------------------------------------------------------------------===//
+// normalize builtins overloads
+//===----------------------------------------------------------------------===//
+
+_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(normalize)
+_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(normalize)
+
+//===----------------------------------------------------------------------===//
+// pow builtins overloads
+//===----------------------------------------------------------------------===//
+
+_DXC_COMPAT_BINARY_DOUBLE_OVERLOADS(pow)
+_DXC_COMPAT_BINARY_INTEGER_OVERLOADS(pow)
+
+//===----------------------------------------------------------------------===//
+// rsqrt builtins overloads
+//===----------------------------------------------------------------------===//
+
+_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(rsqrt)
+_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(rsqrt)
+
+//===----------------------------------------------------------------------===//
+// round builtins overloads
+//===----------------------------------------------------------------------===//
+
+_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(round)
+_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(round)
+
+//===----------------------------------------------------------------------===//
+// sin builtins overloads
+//===----------------------------------------------------------------------===//
+
+_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(sin)
+_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(sin)
+
+//===----------------------------------------------------------------------===//
+// sinh builtins overloads
+//===----------------------------------------------------------------------===//
+
+_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(sinh)
+_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(sinh)
+
+//===----------------------------------------------------------------------===//
+// sqrt builtins overloads
+//===----------------------------------------------------------------------===//
+
+_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(sqrt)
+_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(sqrt)
+
+//===----------------------------------------------------------------------===//
+// step builtins overloads
+//===----------------------------------------------------------------------===//
+
+_DXC_COMPAT_BINARY_DOUBLE_OVERLOADS(step)
+_DXC_COMPAT_BINARY_INTEGER_OVERLOADS(step)
+
+//===----------------------------------------------------------------------===//
+// tan builtins overloads
+//===----------------------------------------------------------------------===//
+
+_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(tan)
+_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(tan)
+
+//===----------------------------------------------------------------------===//
+// tanh builtins overloads
+//===----------------------------------------------------------------------===//
+
+_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(tanh)
+_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(tanh)
+
+//===----------------------------------------------------------------------===//
+// trunc builtins overloads
+//===----------------------------------------------------------------------===//
+
+_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(trunc)
+_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(trunc)
+
+//===----------------------------------------------------------------------===//
+// radians builtins overloads
+//===----------------------------------------------------------------------===//
+
+_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(radians)
+_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(radians)
+
+} // namespace hlsl
+#endif // _HLSL_COMPAT_OVERLOADS_H_

package/lib/clang/21/include/hlsl/hlsl_detail.h

@@ -0,0 +1,54 @@
+//===----- hlsl_detail.h - HLSL definitions for intrinsics ----------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _HLSL_HLSL_DETAILS_H_
+#define _HLSL_HLSL_DETAILS_H_
+
+namespace hlsl {
+
+namespace __detail {
+
+template <typename T, typename U> struct is_same {
+  static const bool value = false;
+};
+
+template <typename T> struct is_same<T, T> {
+  static const bool value = true;
+};
+
+template <bool B, typename T> struct enable_if {};
+
+template <typename T> struct enable_if<true, T> {
+  using Type = T;
+};
+
+template <bool B, class T = void>
+using enable_if_t = typename enable_if<B, T>::Type;
+
+template <typename U, typename T, int N>
+constexpr enable_if_t<sizeof(U) == sizeof(T), vector<U, N>>
+bit_cast(vector<T, N> V) {
+  return __builtin_bit_cast(vector<U, N>, V);
+}
+
+template <typename U, typename T>
+constexpr enable_if_t<sizeof(U) == sizeof(T), U> bit_cast(T F) {
+  return __builtin_bit_cast(U, F);
+}
+
+template <typename T> struct is_arithmetic {
+  static const bool Value = __is_arithmetic(T);
+};
+
+template <typename T, int N>
+using HLSL_FIXED_VECTOR =
+    vector<__detail::enable_if_t<(N > 1 && N <= 4), T>, N>;
+
+} // namespace __detail
+} // namespace hlsl
+#endif //_HLSL_HLSL_DETAILS_H_

package/lib/clang/21/include/hlsl/hlsl_intrinsic_helpers.h

@@ -0,0 +1,144 @@
+//===----- hlsl_intrinsic_helpers.h - HLSL helpers intrinsics -------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _HLSL_HLSL_INTRINSIC_HELPERS_H_
+#define _HLSL_HLSL_INTRINSIC_HELPERS_H_
+
+namespace hlsl {
+namespace __detail {
+
+constexpr vector<uint, 4> d3d_color_to_ubyte4_impl(vector<float, 4> 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
+  // The DXC implementation refers to a comment on the following stackoverflow
+  // discussion to justify the scaling factor: "Built-in rounding, necessary
+  // because of truncation. 0.001953 * 256 = 0.5"
+  // https://stackoverflow.com/questions/52103720/why-does-d3dcolortoubyte4-multiplies-components-by-255-001953f
+  return V.zyxw * 255.001953f;
+}
+
+template <typename T> constexpr T length_impl(T X) { return abs(X); }
+
+template <typename T, int N>
+constexpr enable_if_t<is_same<float, T>::value || is_same<half, T>::value, T>
+length_vec_impl(vector<T, N> X) {
+#if (__has_builtin(__builtin_spirv_length))
+  return __builtin_spirv_length(X);
+#else
+  return sqrt(dot(X, X));
+#endif
+}
+
+template <typename T>
+constexpr vector<T, 4> dst_impl(vector<T, 4> Src0, vector<T, 4> Src1) {
+  return {1, Src0[1] * Src1[1], Src0[2], Src1[3]};
+}
+
+template <typename T> constexpr T distance_impl(T X, T Y) {
+  return length_impl(X - Y);
+}
+
+template <typename T, int N>
+constexpr enable_if_t<is_same<float, T>::value || is_same<half, T>::value, T>
+distance_vec_impl(vector<T, N> X, vector<T, N> Y) {
+  return length_vec_impl(X - Y);
+}
+
+constexpr float dot2add_impl(half2 a, half2 b, float c) {
+#if (__has_builtin(__builtin_dx_dot2add))
+  return __builtin_dx_dot2add(a, b, c);
+#else
+  return dot(a, b) + c;
+#endif
+}
+
+template <typename T> constexpr T reflect_impl(T I, T N) {
+  return I - 2 * N * I * N;
+}
+
+template <typename T, int L>
+constexpr vector<T, L> reflect_vec_impl(vector<T, L> I, vector<T, L> N) {
+#if (__has_builtin(__builtin_spirv_reflect))
+  return __builtin_spirv_reflect(I, N);
+#else
+  return I - 2 * N * dot(I, N);
+#endif
+}
+
+template <typename T> constexpr T fmod_impl(T X, T Y) {
+#if !defined(__DIRECTX__)
+  return __builtin_elementwise_fmod(X, Y);
+#else
+  T div = X / Y;
+  bool ge = div >= 0;
+  T frc = frac(abs(div));
+  return select<T>(ge, frc, -frc) * Y;
+#endif
+}
+
+template <typename T, int N>
+constexpr vector<T, N> fmod_vec_impl(vector<T, N> X, vector<T, N> Y) {
+#if !defined(__DIRECTX__)
+  return __builtin_elementwise_fmod(X, Y);
+#else
+  vector<T, N> div = X / Y;
+  vector<bool, N> ge = div >= 0;
+  vector<T, N> frc = frac(abs(div));
+  return select<T>(ge, frc, -frc) * Y;
+#endif
+}
+
+template <typename T> constexpr T smoothstep_impl(T Min, T Max, T X) {
+#if (__has_builtin(__builtin_spirv_smoothstep))
+  return __builtin_spirv_smoothstep(Min, Max, X);
+#else
+  T S = saturate((X - Min) / (Max - Min));
+  return (3 - 2 * S) * S * S;
+#endif
+}
+
+template <typename T, int N>
+constexpr vector<T, N> smoothstep_vec_impl(vector<T, N> Min, vector<T, N> Max,
+                                           vector<T, N> X) {
+#if (__has_builtin(__builtin_spirv_smoothstep))
+  return __builtin_spirv_smoothstep(Min, Max, X);
+#else
+  vector<T, N> S = saturate((X - Min) / (Max - Min));
+  return (3 - 2 * S) * S * S;
+#endif
+}
+
+template <typename T> constexpr vector<T, 4> lit_impl(T NDotL, T NDotH, T M) {
+  bool DiffuseCond = NDotL < 0;
+  T Diffuse = select<T>(DiffuseCond, 0, NDotL);
+  vector<T, 4> Result = {1, Diffuse, 0, 1};
+  // clang-format off
+  bool SpecularCond = or(DiffuseCond, (NDotH < 0));
+  // clang-format on
+  T SpecularExp = exp(log(NDotH) * M);
+  Result[2] = select<T>(SpecularCond, 0, SpecularExp);
+  return Result;
+}
+
+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;
+}
+
+} // namespace __detail
+} // namespace hlsl
+
+#endif // _HLSL_HLSL_INTRINSIC_HELPERS_H_