@cpp-linter/clang-tidy-linux-arm64 22.1.8 → 23.1.4

package/lib/clang/{22/include/hlsl/hlsl_alias_intrinsics.h → 23/include/hlsl/hlsl_alias_intrinsics_gen.inc}

@@ -1,47 +1,22 @@
-//===--- hlsl_alias_intrinsics.h - HLSL alias 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_ALIAS_INTRINSICS_H_
-#define _HLSL_HLSL_ALIAS_INTRINSICS_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 _HLSL_BUILTIN_ALIAS(builtin)                                           \
-  __attribute__((clang_builtin_alias(builtin)))
-#define _HLSL_AVAILABILITY(platform, version)                                  \
-  __attribute__((availability(platform, introduced = version)))
-#define _HLSL_AVAILABILITY_STAGE(platform, version, stage)                     \
-  __attribute__((                                                              \
-      availability(platform, introduced = version, environment = stage)))
-
-#ifdef __HLSL_ENABLE_16_BIT
-#define _HLSL_16BIT_AVAILABILITY(platform, version)                            \
-  __attribute__((availability(platform, introduced = version)))
-#define _HLSL_16BIT_AVAILABILITY_STAGE(platform, version, stage)               \
-  __attribute__((                                                              \
-      availability(platform, introduced = version, environment = stage)))
-#else
-#define _HLSL_16BIT_AVAILABILITY(environment, version)
-#define _HLSL_16BIT_AVAILABILITY_STAGE(environment, version, stage)
-#endif
-
-//===----------------------------------------------------------------------===//
-// abs builtins
-//===----------------------------------------------------------------------===//
+// This file is auto-generated by clang-tblgen from HLSLIntrinsics.td.
+// Do not edit this file directly.
 
 /// \fn T abs(T Val)
 /// \brief Returns the absolute value of the input value, \a Val.
 /// \param Val The input value.
+// abs overloads
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)
+half abs(half);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)
+half2 abs(half2);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)
+half3 abs(half3);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)
+half4 abs(half4);
 
 #ifdef __HLSL_ENABLE_16_BIT
 _HLSL_AVAILABILITY(shadermodel, 6.2)
@@ -56,30 +31,8 @@ int16_t3 abs(int16_t3);
 _HLSL_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)
 int16_t4 abs(int16_t4);
-
-_HLSL_AVAILABILITY(shadermodel, 6.2)
-constexpr uint16_t abs(uint16_t V) { return V; }
-_HLSL_AVAILABILITY(shadermodel, 6.2)
-constexpr uint16_t2 abs(uint16_t2 V) { return V; }
-_HLSL_AVAILABILITY(shadermodel, 6.2)
-constexpr uint16_t3 abs(uint16_t3 V) { return V; }
-_HLSL_AVAILABILITY(shadermodel, 6.2)
-constexpr uint16_t4 abs(uint16_t4 V) { return V; }
 #endif
 
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)
-half abs(half);
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)
-half2 abs(half2);
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)
-half3 abs(half3);
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)
-half4 abs(half4);
-
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)
 int abs(int);
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)
@@ -89,20 +42,6 @@ int3 abs(int3);
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)
 int4 abs(int4);
 
-constexpr uint abs(uint V) { return V; }
-constexpr uint2 abs(uint2 V) { return V; }
-constexpr uint3 abs(uint3 V) { return V; }
-constexpr uint4 abs(uint4 V) { return V; }
-
-_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)
-float abs(float);
-_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)
-float2 abs(float2);
-_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)
-float3 abs(float3);
-_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)
-float4 abs(float4);
-
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)
 int64_t abs(int64_t);
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)
@@ -112,10 +51,14 @@ int64_t3 abs(int64_t3);
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)
 int64_t4 abs(int64_t4);
 
-constexpr uint64_t abs(uint64_t V) { return V; }
-constexpr uint64_t2 abs(uint64_t2 V) { return V; }
-constexpr uint64_t3 abs(uint64_t3 V) { return V; }
-constexpr uint64_t4 abs(uint64_t4 V) { return V; }
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)
+float abs(float);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)
+float2 abs(float2);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)
+float3 abs(float3);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)
+float4 abs(float4);
 
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)
 double abs(double);
@@ -126,14 +69,10 @@ double3 abs(double3);
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)
 double4 abs(double4);
 
-//===----------------------------------------------------------------------===//
-// acos builtins
-//===----------------------------------------------------------------------===//
-
 /// \fn T acos(T Val)
 /// \brief Returns the arccosine of the input value, \a Val.
 /// \param Val The input value.
-
+// acos overloads
 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_acos)
 half acos(half);
@@ -156,10 +95,6 @@ float3 acos(float3);
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_acos)
 float4 acos(float4);
 
-//===----------------------------------------------------------------------===//
-// AddUint64 builtins
-//===----------------------------------------------------------------------===//
-
 /// \fn T AddUint64(T a, T b)
 /// \brief Implements unsigned 64-bit integer addition using pairs of unsigned
 /// 32-bit integers.
@@ -169,21 +104,31 @@ float4 acos(float4);
 /// This function takes one or two pairs (low, high) of unsigned 32-bit integer
 /// values and returns pairs (low, high) of unsigned 32-bit integer
 /// values representing the result of unsigned 64-bit integer addition.
-
+// AddUint64 overloads
 _HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_adduint64)
-uint32_t2 AddUint64(uint32_t2, uint32_t2);
+uint2 AddUint64(uint2, uint2);
 _HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_adduint64)
-uint32_t4 AddUint64(uint32_t4, uint32_t4);
-
-//===----------------------------------------------------------------------===//
-// all builtins
-//===----------------------------------------------------------------------===//
+uint4 AddUint64(uint4, uint4);
 
 /// \fn bool all(T x)
 /// \brief Returns True if all components of the \a x parameter are non-zero;
-/// otherwise, false. \param x The input value.
+/// otherwise, false.
+/// \param x The input value.
+// all overloads
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
+bool all(half);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
+bool all(half2);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
+bool all(half3);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
+bool all(half4);
 
 #ifdef __HLSL_ENABLE_16_BIT
 _HLSL_AVAILABILITY(shadermodel, 6.2)
@@ -198,6 +143,7 @@ bool all(int16_t3);
 _HLSL_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
 bool all(int16_t4);
+
 _HLSL_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
 bool all(uint16_t);
@@ -212,19 +158,6 @@ _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
 bool all(uint16_t4);
 #endif
 
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
-bool all(half);
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
-bool all(half2);
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
-bool all(half3);
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
-bool all(half4);
-
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
 bool all(bool);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
@@ -233,7 +166,6 @@ _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
 bool all(bool3);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
 bool all(bool4);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
 
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
 bool all(int);
@@ -253,15 +185,6 @@ bool all(uint3);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
 bool all(uint4);
 
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
-bool all(float);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
-bool all(float2);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
-bool all(float3);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
-bool all(float4);
-
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
 bool all(int64_t);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
@@ -280,6 +203,15 @@ bool all(uint64_t3);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
 bool all(uint64_t4);
 
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
+bool all(float);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
+bool all(float2);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
+bool all(float3);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
+bool all(float4);
+
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
 bool all(double);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
@@ -289,67 +221,80 @@ bool all(double3);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
 bool all(double4);
 
-//===----------------------------------------------------------------------===//
-// and builtins
-//===----------------------------------------------------------------------===//
+/// \fn void AllMemoryBarrier(void)
+/// \brief Blocks execution of all threads in a group until all memory
+/// accesses have been completed.
+// AllMemoryBarrier overloads
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all_memory_barrier)
+__attribute__((convergent)) void AllMemoryBarrier();
+
+/// \fn void AllMemoryBarrierWithGroupSync(void)
+/// \brief Blocks execution of all threads in a group until all memory
+/// accesses have been completed and all threads in the group have reached this call.
+// AllMemoryBarrierWithGroupSync overloads
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all_memory_barrier_with_group_sync)
+__attribute__((convergent)) void AllMemoryBarrierWithGroupSync();
 
 /// \fn bool and(bool x, bool y)
 /// \brief Logically ands two boolean vectors or matrices elementwise and
 /// produces a bool vector or matrix output.
-
-// TODO: Clean up clang-format marker once we've resolved
-//       https://github.com/llvm/llvm-project/issues/127851
-//
-// clang-format off
+// and overloads
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_and)
-bool and(bool x, bool y);
+bool and(bool, bool);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_and)
-bool2 and(bool2 x, bool2 y);
+bool2 and(bool2, bool2);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_and)
-bool3 and(bool3 x, bool3 y);
+bool3 and(bool3, bool3);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_and)
-bool4 and(bool4 x, bool4 y);
-
-
+bool4 and(bool4, bool4);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_and)
-bool1x2 and(bool1x2 x, bool1x2 y);
+bool1x2 and(bool1x2, bool1x2);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_and)
-bool1x3 and(bool1x3 x, bool1x3 y);
+bool1x3 and(bool1x3, bool1x3);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_and)
-bool1x4 and(bool1x4 x, bool1x4 y);
+bool1x4 and(bool1x4, bool1x4);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_and)
-bool2x1 and(bool2x1 x, bool2x1 y);
+bool2x1 and(bool2x1, bool2x1);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_and)
-bool2x2 and(bool2x2 x, bool2x2 y);
+bool2x2 and(bool2x2, bool2x2);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_and)
-bool2x3 and(bool2x3 x, bool2x3 y);
+bool2x3 and(bool2x3, bool2x3);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_and)
-bool2x4 and(bool2x4 x, bool2x4 y);
+bool2x4 and(bool2x4, bool2x4);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_and)
-bool3x1 and(bool3x1 x, bool3x1 y);
+bool3x1 and(bool3x1, bool3x1);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_and)
-bool3x2 and(bool3x2 x, bool3x2 y);
+bool3x2 and(bool3x2, bool3x2);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_and)
-bool3x3 and(bool3x3 x, bool3x3 y);
+bool3x3 and(bool3x3, bool3x3);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_and)
-bool3x4 and(bool3x4 x, bool3x4 y);
+bool3x4 and(bool3x4, bool3x4);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_and)
-bool4x1 and(bool4x1 x, bool4x1 y);
+bool4x1 and(bool4x1, bool4x1);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_and)
-bool4x2 and(bool4x2 x, bool4x2 y);
+bool4x2 and(bool4x2, bool4x2);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_and)
-bool4x3 and(bool4x3 x, bool4x3 y);
+bool4x3 and(bool4x3, bool4x3);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_and)
-bool4x4 and(bool4x4 x, bool4x4 y);
-// clang-format on
-
-//===----------------------------------------------------------------------===//
-// any builtins
-//===----------------------------------------------------------------------===//
+bool4x4 and(bool4x4, bool4x4);
 
 /// \fn bool any(T x)
 /// \brief Returns True if any components of the \a x parameter are non-zero;
-/// otherwise, false. \param x The input value.
+/// otherwise, false.
+/// \param x The input value.
+// any overloads
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
+bool any(half);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
+bool any(half2);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
+bool any(half3);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
+bool any(half4);
 
 #ifdef __HLSL_ENABLE_16_BIT
 _HLSL_AVAILABILITY(shadermodel, 6.2)
@@ -364,6 +309,7 @@ bool any(int16_t3);
 _HLSL_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
 bool any(int16_t4);
+
 _HLSL_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
 bool any(uint16_t);
@@ -378,19 +324,6 @@ _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
 bool any(uint16_t4);
 #endif
 
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
-bool any(half);
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
-bool any(half2);
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
-bool any(half3);
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
-bool any(half4);
-
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
 bool any(bool);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
@@ -399,7 +332,6 @@ _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
 bool any(bool3);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
 bool any(bool4);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
 
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
 bool any(int);
@@ -419,15 +351,6 @@ bool any(uint3);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
 bool any(uint4);
 
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
-bool any(float);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
-bool any(float2);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
-bool any(float3);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
-bool any(float4);
-
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
 bool any(int64_t);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
@@ -446,6 +369,15 @@ bool any(uint64_t3);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
 bool any(uint64_t4);
 
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
+bool any(float);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
+bool any(float2);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
+bool any(float3);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
+bool any(float4);
+
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
 bool any(double);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
@@ -455,15 +387,11 @@ bool any(double3);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
 bool any(double4);
 
-//===----------------------------------------------------------------------===//
-// asdouble builtins
-//===----------------------------------------------------------------------===//
-
 /// \fn double asdouble(uint LowBits, uint HighBits)
 /// \brief Reinterprets a cast value (two 32-bit values) into a double.
 /// \param LowBits The low 32-bit pattern of the input value.
 /// \param HighBits The high 32-bit pattern of the input value.
-
+// asdouble overloads
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_asdouble)
 double asdouble(uint, uint);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_asdouble)
@@ -473,14 +401,10 @@ double3 asdouble(uint3, uint3);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_asdouble)
 double4 asdouble(uint4, uint4);
 
-//===----------------------------------------------------------------------===//
-// asin builtins
-//===----------------------------------------------------------------------===//
-
 /// \fn T asin(T Val)
 /// \brief Returns the arcsine of the input value, \a Val.
 /// \param Val The input value.
-
+// asin overloads
 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_asin)
 half asin(half);
@@ -503,14 +427,10 @@ float3 asin(float3);
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_asin)
 float4 asin(float4);
 
-//===----------------------------------------------------------------------===//
-// atan builtins
-//===----------------------------------------------------------------------===//
-
 /// \fn T atan(T Val)
 /// \brief Returns the arctangent of the input value, \a Val.
 /// \param Val The input value.
-
+// atan overloads
 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan)
 half atan(half);
@@ -533,47 +453,114 @@ float3 atan(float3);
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan)
 float4 atan(float4);
 
-//===----------------------------------------------------------------------===//
-// atan2 builtins
-//===----------------------------------------------------------------------===//
-
 /// \fn T atan2(T y, T x)
 /// \brief Returns the arctangent of y/x, using the signs of the arguments to
 /// determine the correct quadrant.
 /// \param y The y-coordinate.
 /// \param x The x-coordinate.
-
+// atan2 overloads
 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)
-half atan2(half y, half x);
+half atan2(half, half);
 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)
-half2 atan2(half2 y, half2 x);
+half2 atan2(half2, half2);
 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)
-half3 atan2(half3 y, half3 x);
+half3 atan2(half3, half3);
 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)
-half4 atan2(half4 y, half4 x);
-
+half4 atan2(half4, half4);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)
+half1x2 atan2(half1x2, half1x2);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)
+half1x3 atan2(half1x3, half1x3);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)
+half1x4 atan2(half1x4, half1x4);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)
+half2x1 atan2(half2x1, half2x1);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)
+half2x2 atan2(half2x2, half2x2);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)
+half2x3 atan2(half2x3, half2x3);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)
+half2x4 atan2(half2x4, half2x4);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)
-float atan2(float y, float x);
+half3x1 atan2(half3x1, half3x1);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)
+half3x2 atan2(half3x2, half3x2);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)
+half3x3 atan2(half3x3, half3x3);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)
+half3x4 atan2(half3x4, half3x4);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)
+half4x1 atan2(half4x1, half4x1);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)
-float2 atan2(float2 y, float2 x);
+half4x2 atan2(half4x2, half4x2);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)
-float3 atan2(float3 y, float3 x);
+half4x3 atan2(half4x3, half4x3);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)
-float4 atan2(float4 y, float4 x);
+half4x4 atan2(half4x4, half4x4);
 
-//===----------------------------------------------------------------------===//
-// ceil builtins
-//===----------------------------------------------------------------------===//
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)
+float atan2(float, float);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)
+float2 atan2(float2, float2);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)
+float3 atan2(float3, float3);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)
+float4 atan2(float4, float4);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)
+float1x2 atan2(float1x2, float1x2);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)
+float1x3 atan2(float1x3, float1x3);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)
+float1x4 atan2(float1x4, float1x4);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)
+float2x1 atan2(float2x1, float2x1);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)
+float2x2 atan2(float2x2, float2x2);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)
+float2x3 atan2(float2x3, float2x3);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)
+float2x4 atan2(float2x4, float2x4);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)
+float3x1 atan2(float3x1, float3x1);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)
+float3x2 atan2(float3x2, float3x2);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)
+float3x3 atan2(float3x3, float3x3);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)
+float3x4 atan2(float3x4, float3x4);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)
+float4x1 atan2(float4x1, float4x1);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)
+float4x2 atan2(float4x2, float4x2);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)
+float4x3 atan2(float4x3, float4x3);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)
+float4x4 atan2(float4x4, float4x4);
 
 /// \fn T ceil(T Val)
 /// \brief Returns the smallest integer value that is greater than or equal to
 /// the input value, \a Val.
 /// \param Val The input value.
-
+// ceil overloads
 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_ceil)
 half ceil(half);
@@ -596,10 +583,6 @@ float3 ceil(float3);
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_ceil)
 float4 ceil(float4);
 
-//===----------------------------------------------------------------------===//
-// clamp builtins
-//===----------------------------------------------------------------------===//
-
 /// \fn T clamp(T X, T Min, T Max)
 /// \brief Clamps the specified value \a X to the specified
 /// minimum ( \a Min) and maximum ( \a Max) range.
@@ -610,7 +593,7 @@ float4 ceil(float4);
 /// Returns The clamped value for the \a X parameter.
 /// For values of -INF or INF, clamp will behave as expected.
 /// However for values of NaN, the results are undefined.
-
+// clamp overloads
 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)
 half clamp(half, half, half);
@@ -706,13 +689,22 @@ double3 clamp(double3, double3, double3);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)
 double4 clamp(double4, double4, double4);
 
-//===----------------------------------------------------------------------===//
-// clip builtins
-//===----------------------------------------------------------------------===//
-
 /// \fn void clip(T Val)
 /// \brief Discards the current pixel if the specified value is less than zero.
 /// \param Val The input value.
+// clip overloads
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clip)
+void clip(half);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clip)
+void clip(half2);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clip)
+void clip(half3);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clip)
+void clip(half4);
 
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clip)
 void clip(float);
@@ -723,14 +715,10 @@ void clip(float3);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clip)
 void clip(float4);
 
-//===----------------------------------------------------------------------===//
-// cos builtins
-//===----------------------------------------------------------------------===//
-
 /// \fn T cos(T Val)
 /// \brief Returns the cosine of the input value, \a Val.
 /// \param Val The input value.
-
+// cos overloads
 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_cos)
 half cos(half);
@@ -753,14 +741,10 @@ float3 cos(float3);
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_cos)
 float4 cos(float4);
 
-//===----------------------------------------------------------------------===//
-// cosh builtins
-//===----------------------------------------------------------------------===//
-
 /// \fn T cosh(T Val)
 /// \brief Returns the hyperbolic cosine of the input value, \a Val.
 /// \param Val The input value.
-
+// cosh overloads
 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_cosh)
 half cosh(half);
@@ -783,111 +767,153 @@ float3 cosh(float3);
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_cosh)
 float4 cosh(float4);
 
-//===----------------------------------------------------------------------===//
-// count bits builtins
-//===----------------------------------------------------------------------===//
-
-/// \fn T countbits(T Val)
-/// \brief Return the number of bits (per component) set in the input integer.
-/// \param Val The input value.
+// cross overloads
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_crossf32)
+float3 cross(float3, float3);
 
-#ifdef __HLSL_ENABLE_16_BIT
-_HLSL_AVAILABILITY(shadermodel, 6.2)
-const inline uint countbits(int16_t x) {
-  return __builtin_elementwise_popcount(x);
-}
-_HLSL_AVAILABILITY(shadermodel, 6.2)
-const inline uint2 countbits(int16_t2 x) {
-  return __builtin_elementwise_popcount(x);
-}
-_HLSL_AVAILABILITY(shadermodel, 6.2)
-const inline uint3 countbits(int16_t3 x) {
-  return __builtin_elementwise_popcount(x);
-}
-_HLSL_AVAILABILITY(shadermodel, 6.2)
-const inline uint4 countbits(int16_t4 x) {
-  return __builtin_elementwise_popcount(x);
-}
-_HLSL_AVAILABILITY(shadermodel, 6.2)
-const inline uint countbits(uint16_t x) {
-  return __builtin_elementwise_popcount(x);
-}
-_HLSL_AVAILABILITY(shadermodel, 6.2)
-const inline uint2 countbits(uint16_t2 x) {
-  return __builtin_elementwise_popcount(x);
-}
-_HLSL_AVAILABILITY(shadermodel, 6.2)
-const inline uint3 countbits(uint16_t3 x) {
-  return __builtin_elementwise_popcount(x);
-}
+/// \fn T cross(T x, T y)
+/// \brief Returns the cross product of two floating-point, 3D vectors.
+/// \param x [in] The first floating-point, 3D vector.
+/// \param y [in] The second floating-point, 3D vector.
+///
+/// Result is the cross product of x and y, i.e., the resulting
+/// components are, in order :
+/// x[1] * y[2] - y[1] * x[2]
+/// x[2] * y[0] - y[2] * x[0]
+/// x[0] * y[1] - y[0] * x[1]
+// cross overloads
 _HLSL_AVAILABILITY(shadermodel, 6.2)
-const inline uint4 countbits(uint16_t4 x) {
-  return __builtin_elementwise_popcount(x);
-}
-#endif
-
-const inline uint countbits(int x) { return __builtin_elementwise_popcount(x); }
-const inline uint2 countbits(int2 x) {
-  return __builtin_elementwise_popcount(x);
-}
-const inline uint3 countbits(int3 x) {
-  return __builtin_elementwise_popcount(x);
-}
-const inline uint4 countbits(int4 x) {
-  return __builtin_elementwise_popcount(x);
-}
-
-const inline uint countbits(uint x) {
-  return __builtin_elementwise_popcount(x);
-}
-const inline uint2 countbits(uint2 x) {
-  return __builtin_elementwise_popcount(x);
-}
-const inline uint3 countbits(uint3 x) {
-  return __builtin_elementwise_popcount(x);
-}
-const inline uint4 countbits(uint4 x) {
-  return __builtin_elementwise_popcount(x);
-}
-
-const inline uint countbits(int64_t x) {
-  return __builtin_elementwise_popcount(x);
-}
-const inline uint2 countbits(int64_t2 x) {
-  return __builtin_elementwise_popcount(x);
-}
-const inline uint3 countbits(int64_t3 x) {
-  return __builtin_elementwise_popcount(x);
-}
-const inline uint4 countbits(int64_t4 x) {
-  return __builtin_elementwise_popcount(x);
-}
-
-const inline uint countbits(uint64_t x) {
-  return __builtin_elementwise_popcount(x);
-}
-const inline uint2 countbits(uint64_t2 x) {
-  return __builtin_elementwise_popcount(x);
-}
-const inline uint3 countbits(uint64_t3 x) {
-  return __builtin_elementwise_popcount(x);
-}
-const inline uint4 countbits(uint64_t4 x) {
-  return __builtin_elementwise_popcount(x);
-}
-
-//===----------------------------------------------------------------------===//
-// degrees builtins
-//===----------------------------------------------------------------------===//
-
-/// \fn T degrees(T x)
-/// \brief Converts the specified value from radians to degrees.
-/// \param x The specified input value.
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_crossf16)
+half3 cross(half3, half3);
 
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_degrees)
-half degrees(half);
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+/// \fn T ddx_coarse(T value)
+/// \brief Computes a low precision partial derivative with respect to the
+/// screen-space x-coordinate.
+/// \param value The input value.
+///
+/// The return value is a floating point scalar or vector containing the low
+/// prevision partial derivative of the input value.
+// ddx_coarse overloads
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddx_coarse)
+half ddx_coarse(half);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddx_coarse)
+half2 ddx_coarse(half2);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddx_coarse)
+half3 ddx_coarse(half3);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddx_coarse)
+half4 ddx_coarse(half4);
+
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddx_coarse)
+float ddx_coarse(float);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddx_coarse)
+float2 ddx_coarse(float2);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddx_coarse)
+float3 ddx_coarse(float3);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddx_coarse)
+float4 ddx_coarse(float4);
+
+/// \fn T ddx_fine(T value)
+/// \brief Computes a high precision partial derivative with respect to the
+/// screen-space x-coordinate.
+/// \param value The input value.
+///
+/// The return value is a floating point scalar or vector containing the high
+/// prevision partial derivative of the input value.
+// ddx_fine overloads
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddx_fine)
+half ddx_fine(half);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddx_fine)
+half2 ddx_fine(half2);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddx_fine)
+half3 ddx_fine(half3);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddx_fine)
+half4 ddx_fine(half4);
+
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddx_fine)
+float ddx_fine(float);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddx_fine)
+float2 ddx_fine(float2);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddx_fine)
+float3 ddx_fine(float3);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddx_fine)
+float4 ddx_fine(float4);
+
+/// \fn T ddy_coarse(T value)
+/// \brief Computes a low precision partial derivative with respect to the
+/// screen-space y-coordinate.
+/// \param value The input value.
+///
+/// The return value is a floating point scalar or vector containing the low
+/// prevision partial derivative of the input value.
+// ddy_coarse overloads
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddy_coarse)
+half ddy_coarse(half);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddy_coarse)
+half2 ddy_coarse(half2);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddy_coarse)
+half3 ddy_coarse(half3);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddy_coarse)
+half4 ddy_coarse(half4);
+
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddy_coarse)
+float ddy_coarse(float);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddy_coarse)
+float2 ddy_coarse(float2);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddy_coarse)
+float3 ddy_coarse(float3);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddy_coarse)
+float4 ddy_coarse(float4);
+
+/// \fn T ddy_fine(T value)
+/// \brief Computes a high precision partial derivative with respect to the
+/// screen-space y-coordinate.
+/// \param value The input value.
+///
+/// The return value is a floating point scalar or vector containing the high
+/// prevision partial derivative of the input value.
+// ddy_fine overloads
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddy_fine)
+half ddy_fine(half);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddy_fine)
+half2 ddy_fine(half2);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddy_fine)
+half3 ddy_fine(half3);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddy_fine)
+half4 ddy_fine(half4);
+
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddy_fine)
+float ddy_fine(float);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddy_fine)
+float2 ddy_fine(float2);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddy_fine)
+float3 ddy_fine(float3);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddy_fine)
+float4 ddy_fine(float4);
+
+/// \fn T degrees(T x)
+/// \brief Converts the specified value from radians to degrees.
+/// \param x The specified input value.
+// degrees overloads
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_degrees)
+half degrees(half);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_degrees)
 half2 degrees(half2);
 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
@@ -906,15 +932,25 @@ float3 degrees(float3);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_degrees)
 float4 degrees(float4);
 
-//===----------------------------------------------------------------------===//
-// dot product builtins
-//===----------------------------------------------------------------------===//
+/// \fn void DeviceMemoryBarrier(void)
+/// \brief Blocks execution of all threads in a group until all device memory
+/// accesses have been completed.
+// DeviceMemoryBarrier overloads
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_device_memory_barrier)
+__attribute__((convergent)) void DeviceMemoryBarrier();
+
+/// \fn void DeviceMemoryBarrierWithGroupSync(void)
+/// \brief Blocks execution of all threads in a group until all device memory
+/// accesses have been completed and all threads in the group have reached this call.
+// DeviceMemoryBarrierWithGroupSync overloads
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_device_memory_barrier_with_group_sync)
+__attribute__((convergent)) void DeviceMemoryBarrierWithGroupSync();
 
 /// \fn K dot(T X, T Y)
 /// \brief Return the dot product (a scalar value) of \a X and \a Y.
 /// \param X The X input value.
 /// \param Y The Y input value.
-
+// dot overloads
 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)
 half dot(half, half);
@@ -956,18 +992,6 @@ _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)
 uint16_t dot(uint16_t4, uint16_t4);
 #endif
 
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)
-float dot(float, float);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)
-float dot(float2, float2);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)
-float dot(float3, float3);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)
-float dot(float4, float4);
-
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)
-double dot(double, double);
-
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)
 int dot(int, int);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)
@@ -1004,32 +1028,41 @@ uint64_t dot(uint64_t3, uint64_t3);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)
 uint64_t dot(uint64_t4, uint64_t4);
 
-//===----------------------------------------------------------------------===//
-// dot4add builtins
-//===----------------------------------------------------------------------===//
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)
+float dot(float, float);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)
+float dot(float2, float2);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)
+float dot(float3, float3);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)
+float dot(float4, float4);
 
 /// \fn int dot4add_i8packed(uint A, uint B, int C)
-
+/// \brief Dot product of two packed 8-bit signed integer vectors, accumulated
+/// with a 32-bit signed integer.
+// dot4add_i8packed overloads
 _HLSL_AVAILABILITY(shadermodel, 6.4)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot4add_i8packed)
 int dot4add_i8packed(uint, uint, int);
 
 /// \fn uint dot4add_u8packed(uint A, uint B, uint C)
-
+/// \brief Dot product of two packed 8-bit unsigned integer vectors, accumulated
+/// with a 32-bit unsigned integer.
+// dot4add_u8packed overloads
 _HLSL_AVAILABILITY(shadermodel, 6.4)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot4add_u8packed)
 uint dot4add_u8packed(uint, uint, uint);
 
-//===----------------------------------------------------------------------===//
-// exp builtins
-//===----------------------------------------------------------------------===//
+// dot overloads
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)
+double dot(double, double);
 
 /// \fn T exp(T x)
 /// \brief Returns the base-e exponential, or \a e**x, of the specified value.
 /// \param x The specified input value.
 ///
 /// The return value is the base-e exponential of the \a x parameter.
-
+// exp overloads
 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp)
 half exp(half);
@@ -1052,16 +1085,12 @@ float3 exp(float3);
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp)
 float4 exp(float4);
 
-//===----------------------------------------------------------------------===//
-// exp2 builtins
-//===----------------------------------------------------------------------===//
-
 /// \fn T exp2(T x)
 /// \brief Returns the base 2 exponential, or \a 2**x, of the specified value.
 /// \param x The specified input value.
 ///
 /// The base 2 exponential of the \a x parameter.
-
+// exp2 overloads
 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp2)
 half exp2(half);
@@ -1084,18 +1113,14 @@ float3 exp2(float3);
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp2)
 float4 exp2(float4);
 
-//===----------------------------------------------------------------------===//
-// f16tof32 builtins
-//===----------------------------------------------------------------------===//
-
 /// \fn float f16tof32(uint x)
 /// \brief Returns the half value stored in the low 16 bits of the uint arg
 /// converted to a float.
 /// \param x The uint containing two half values.
 ///
-/// The float value of the half value found in the low 16 bits of the \a xi
+/// The float value of the half value found in the low 16 bits of the \a x
 /// parameter.
-
+// f16tof32 overloads
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_f16tof32)
 float f16tof32(uint);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_f16tof32)
@@ -1105,15 +1130,28 @@ float3 f16tof32(uint3);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_f16tof32)
 float4 f16tof32(uint4);
 
-//===----------------------------------------------------------------------===//
-// firstbitlow builtins
-//===----------------------------------------------------------------------===//
+/// \fn uint f32tof16(float x)
+/// \brief Returns the float arg value converted to half in the low 16 bits of
+/// the uint return value.
+/// \param x The float to be converted to half.
+///
+/// The return value is a uint containing the converted half value in the low
+/// 16 bits.
+// f32tof16 overloads
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_f32tof16)
+uint f32tof16(float);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_f32tof16)
+uint2 f32tof16(float2);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_f32tof16)
+uint3 f32tof16(float3);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_f32tof16)
+uint4 f32tof16(float4);
 
 /// \fn T firstbitlow(T Val)
 /// \brief Returns the location of the first set bit starting from the lowest
 /// order bit and working upward, per component.
 /// \param Val the input value.
-
+// firstbitlow overloads
 #ifdef __HLSL_ENABLE_16_BIT
 _HLSL_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)
@@ -1127,6 +1165,7 @@ uint3 firstbitlow(int16_t3);
 _HLSL_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)
 uint4 firstbitlow(int16_t4);
+
 _HLSL_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)
 uint firstbitlow(uint16_t);
@@ -1177,15 +1216,11 @@ uint3 firstbitlow(uint64_t3);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)
 uint4 firstbitlow(uint64_t4);
 
-//===----------------------------------------------------------------------===//
-// floor builtins
-//===----------------------------------------------------------------------===//
-
 /// \fn T floor(T Val)
 /// \brief Returns the largest integer that is less than or equal to the input
 /// value, \a Val.
 /// \param Val The input value.
-
+// floor overloads
 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_floor)
 half floor(half);
@@ -1208,16 +1243,57 @@ float3 floor(float3);
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_floor)
 float4 floor(float4);
 
-//===----------------------------------------------------------------------===//
-// frac builtins
-//===----------------------------------------------------------------------===//
+/// \fn double fma(double a, double b, double c)
+/// \brief Returns the double-precision fused multiply-addition of a * b + c.
+/// \param a The first value in the fused multiply-addition.
+/// \param b The second value in the fused multiply-addition.
+/// \param c The third value in the fused multiply-addition.
+// fma overloads
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_fma)
+double fma(double, double, double);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_fma)
+double2 fma(double2, double2, double2);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_fma)
+double3 fma(double3, double3, double3);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_fma)
+double4 fma(double4, double4, double4);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_fma)
+double1x2 fma(double1x2, double1x2, double1x2);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_fma)
+double1x3 fma(double1x3, double1x3, double1x3);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_fma)
+double1x4 fma(double1x4, double1x4, double1x4);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_fma)
+double2x1 fma(double2x1, double2x1, double2x1);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_fma)
+double2x2 fma(double2x2, double2x2, double2x2);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_fma)
+double2x3 fma(double2x3, double2x3, double2x3);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_fma)
+double2x4 fma(double2x4, double2x4, double2x4);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_fma)
+double3x1 fma(double3x1, double3x1, double3x1);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_fma)
+double3x2 fma(double3x2, double3x2, double3x2);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_fma)
+double3x3 fma(double3x3, double3x3, double3x3);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_fma)
+double3x4 fma(double3x4, double3x4, double3x4);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_fma)
+double4x1 fma(double4x1, double4x1, double4x1);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_fma)
+double4x2 fma(double4x2, double4x2, double4x2);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_fma)
+double4x3 fma(double4x3, double4x3, double4x3);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_fma)
+double4x4 fma(double4x4, double4x4, double4x4);
 
 /// \fn T frac(T x)
 /// \brief Returns the fractional (or decimal) part of x. \a x parameter.
 /// \param x The specified input value.
 ///
 /// If \a the return value is greater than or equal to 0 and less than 1.
-
+// frac overloads
 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_frac)
 half frac(half);
@@ -1240,9 +1316,20 @@ float3 frac(float3);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_frac)
 float4 frac(float4);
 
-//===----------------------------------------------------------------------===//
-// isinf builtins
-//===----------------------------------------------------------------------===//
+/// \fn void GroupMemoryBarrier(void)
+/// \brief Blocks execution of all threads in a group until all group shared
+/// accesses have been completed.
+// GroupMemoryBarrier overloads
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_group_memory_barrier)
+__attribute__((convergent)) void GroupMemoryBarrier();
+
+/// \fn void GroupMemoryBarrierWithGroupSync(void)
+/// \brief Blocks execution of all threads in a group until all group shared
+/// accesses have been completed and all threads in the group have reached this
+/// call.
+// GroupMemoryBarrierWithGroupSync overloads
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_group_memory_barrier_with_group_sync)
+__attribute__((convergent)) void GroupMemoryBarrierWithGroupSync();
 
 /// \fn T isinf(T x)
 /// \brief Determines if the specified value \a x  is infinite.
@@ -1250,7 +1337,7 @@ float4 frac(float4);
 ///
 /// Returns a value of the same size as the input, with a value set
 /// to True if the x parameter is +INF or -INF. Otherwise, False.
-
+// isinf overloads
 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_isinf)
 bool isinf(half);
@@ -1273,17 +1360,13 @@ bool3 isinf(float3);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_isinf)
 bool4 isinf(float4);
 
-//===----------------------------------------------------------------------===//
-// isnan builtins
-//===----------------------------------------------------------------------===//
-
 /// \fn T isnan(T x)
 /// \brief Determines if the specified value \a x  is Not a Number.
 /// \param x The specified input value.
 ///
 /// Returns a value of the same size as the input, with a value set
 /// to True if the x parameter is NaN or QNaN. Otherwise, False.
-
+// isnan overloads
 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_isnan)
 bool isnan(half);
@@ -1306,10 +1389,6 @@ bool3 isnan(float3);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_isnan)
 bool4 isnan(float4);
 
-//===----------------------------------------------------------------------===//
-// lerp builtins
-//===----------------------------------------------------------------------===//
-
 /// \fn T lerp(T x, T y, T s)
 /// \brief Returns the linear interpolation of x to y by s.
 /// \param x [in] The first-floating point value.
@@ -1319,7 +1398,7 @@ bool4 isnan(float4);
 ///
 /// Linear interpolation is based on the following formula: x*(1-s) + y*s which
 /// can equivalently be written as x + s(y-x).
-
+// lerp overloads
 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_lerp)
 half lerp(half, half, half);
@@ -1342,17 +1421,13 @@ float3 lerp(float3, float3, float3);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_lerp)
 float4 lerp(float4, float4, float4);
 
-//===----------------------------------------------------------------------===//
-// log builtins
-//===----------------------------------------------------------------------===//
-
 /// \fn T log(T Val)
 /// \brief The base-e logarithm of the input value, \a Val parameter.
 /// \param Val The input value.
 ///
 /// If \a Val is negative, this result is undefined. If \a Val is 0, this
 /// function returns negative infinity.
-
+// log overloads
 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log)
 half log(half);
@@ -1375,50 +1450,13 @@ float3 log(float3);
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log)
 float4 log(float4);
 
-//===----------------------------------------------------------------------===//
-// log10 builtins
-//===----------------------------------------------------------------------===//
-
-/// \fn T log10(T Val)
-/// \brief The base-10 logarithm of the input value, \a Val parameter.
-/// \param Val The input value.
-///
-/// If \a Val is negative, this result is undefined. If \a Val is 0, this
-/// function returns negative infinity.
-
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log10)
-half log10(half);
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log10)
-half2 log10(half2);
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log10)
-half3 log10(half3);
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log10)
-half4 log10(half4);
-
-_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log10)
-float log10(float);
-_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log10)
-float2 log10(float2);
-_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log10)
-float3 log10(float3);
-_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log10)
-float4 log10(float4);
-
-//===----------------------------------------------------------------------===//
-// log2 builtins
-//===----------------------------------------------------------------------===//
-
 /// \fn T log2(T Val)
 /// \brief The base-2 logarithm of the input value, \a Val parameter.
 /// \param Val The input value.
 ///
 /// If \a Val is negative, this result is undefined. If \a Val is 0, this
 /// function returns negative infinity.
-
+// log2 overloads
 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log2)
 half log2(half);
@@ -1441,16 +1479,41 @@ float3 log2(float3);
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log2)
 float4 log2(float4);
 
-//===----------------------------------------------------------------------===//
-// mad builtins
-//===----------------------------------------------------------------------===//
+/// \fn T log10(T Val)
+/// \brief The base-10 logarithm of the input value, \a Val parameter.
+/// \param Val The input value.
+///
+/// If \a Val is negative, this result is undefined. If \a Val is 0, this
+/// function returns negative infinity.
+// log10 overloads
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log10)
+half log10(half);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log10)
+half2 log10(half2);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log10)
+half3 log10(half3);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log10)
+half4 log10(half4);
+
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log10)
+float log10(float);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log10)
+float2 log10(float2);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log10)
+float3 log10(float3);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log10)
+float4 log10(float4);
 
 /// \fn T mad(T M, T A, T B)
 /// \brief The result of \a M * \a A + \a B.
 /// \param M The multiplication value.
 /// \param A The first addition value.
 /// \param B The second addition value.
-
+// mad overloads
 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)
 half mad(half, half, half);
@@ -1546,15 +1609,11 @@ double3 mad(double3, double3, double3);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)
 double4 mad(double4, double4, double4);
 
-//===----------------------------------------------------------------------===//
-// max builtins
-//===----------------------------------------------------------------------===//
-
 /// \fn T max(T X, T Y)
 /// \brief Return the greater of \a X and \a Y.
 /// \param X The X input value.
 /// \param Y The Y input value.
-
+// max overloads
 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
 half max(half, half);
@@ -1650,15 +1709,11 @@ double3 max(double3, double3);
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
 double4 max(double4, double4);
 
-//===----------------------------------------------------------------------===//
-// min builtins
-//===----------------------------------------------------------------------===//
-
 /// \fn T min(T X, T Y)
 /// \brief Return the lesser of \a X and \a Y.
 /// \param X The X input value.
 /// \param Y The Y input value.
-
+// min overloads
 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
 half min(half, half);
@@ -1718,15 +1773,6 @@ uint3 min(uint3, uint3);
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
 uint4 min(uint4, uint4);
 
-_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
-float min(float, float);
-_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
-float2 min(float2, float2);
-_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
-float3 min(float3, float3);
-_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
-float4 min(float4, float4);
-
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
 int64_t min(int64_t, int64_t);
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
@@ -1745,6 +1791,15 @@ uint64_t3 min(uint64_t3, uint64_t3);
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
 uint64_t4 min(uint64_t4, uint64_t4);
 
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
+float min(float, float);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
+float2 min(float2, float2);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
+float3 min(float3, float3);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
+float4 min(float4, float4);
+
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
 double min(double, double);
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
@@ -1754,16 +1809,23 @@ double3 min(double3, double3);
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
 double4 min(double4, double4);
 
-//===----------------------------------------------------------------------===//
-// normalize builtins
-//===----------------------------------------------------------------------===//
+/// \fn uint NonUniformResourceIndex(uint I)
+/// \brief A compiler hint to indicate that a resource index varies across
+/// threads within a wave (i.e., it is non-uniform).
+/// \param I [in] Resource array index
+///
+/// The return value is the \a I parameter.
+// NonUniformResourceIndex overloads
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_resource_nonuniformindex)
+uint NonUniformResourceIndex(uint);
 
 /// \fn T normalize(T x)
 /// \brief Returns the normalized unit vector of the specified floating-point
-/// vector. \param x [in] The vector of floats.
+/// vector.
+/// \param x [in] The vector of floats.
 ///
 /// Normalize is based on the following formula: x / length(x).
-
+// normalize overloads
 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_normalize)
 half normalize(half);
@@ -1786,18 +1848,10 @@ float3 normalize(float3);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_normalize)
 float4 normalize(float4);
 
-//===----------------------------------------------------------------------===//
-// or builtins
-//===----------------------------------------------------------------------===//
-
 /// \fn bool or(bool x, bool y)
 /// \brief Logically ors two boolean vectors or matrices elementwise and
 ///  produces a bool vector or matrix output.
-
-// TODO: Clean up clang-format marker once we've resolved
-//       https://github.com/llvm/llvm-project/issues/127851
-//
-// clang-format off
+// or overloads
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_or)
 bool or(bool, bool);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_or)
@@ -1806,48 +1860,42 @@ _HLSL_BUILTIN_ALIAS(__builtin_hlsl_or)
 bool3 or(bool3, bool3);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_or)
 bool4 or(bool4, bool4);
-
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_or)
-bool1x2 or(bool1x2 x, bool1x2 y);
+bool1x2 or(bool1x2, bool1x2);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_or)
-bool1x3 or(bool1x3 x, bool1x3 y);
+bool1x3 or(bool1x3, bool1x3);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_or)
-bool1x4 or(bool1x4 x, bool1x4 y);
+bool1x4 or(bool1x4, bool1x4);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_or)
-bool2x1 or(bool2x1 x, bool2x1 y);
+bool2x1 or(bool2x1, bool2x1);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_or)
-bool2x2 or(bool2x2 x, bool2x2 y);
+bool2x2 or(bool2x2, bool2x2);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_or)
-bool2x3 or(bool2x3 x, bool2x3 y);
+bool2x3 or(bool2x3, bool2x3);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_or)
-bool2x4 or(bool2x4 x, bool2x4 y);
+bool2x4 or(bool2x4, bool2x4);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_or)
-bool3x1 or(bool3x1 x, bool3x1 y);
+bool3x1 or(bool3x1, bool3x1);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_or)
-bool3x2 or(bool3x2 x, bool3x2 y);
+bool3x2 or(bool3x2, bool3x2);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_or)
-bool3x3 or(bool3x3 x, bool3x3 y);
+bool3x3 or(bool3x3, bool3x3);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_or)
-bool3x4 or(bool3x4 x, bool3x4 y);
+bool3x4 or(bool3x4, bool3x4);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_or)
-bool4x1 or(bool4x1 x, bool4x1 y);
+bool4x1 or(bool4x1, bool4x1);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_or)
-bool4x2 or(bool4x2 x, bool4x2 y);
+bool4x2 or(bool4x2, bool4x2);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_or)
-bool4x3 or(bool4x3 x, bool4x3 y);
+bool4x3 or(bool4x3, bool4x3);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_or)
-bool4x4 or(bool4x4 x, bool4x4 y);
-// clang-format on
-
-//===----------------------------------------------------------------------===//
-// pow builtins
-//===----------------------------------------------------------------------===//
+bool4x4 or(bool4x4, bool4x4);
 
 /// \fn T pow(T Val, T Pow)
 /// \brief Return the value \a Val, raised to the power \a Pow.
 /// \param Val The input value.
 /// \param Pow The specified power.
-
+// pow overloads
 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_pow)
 half pow(half, half);
@@ -1870,79 +1918,331 @@ float3 pow(float3, float3);
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_pow)
 float4 pow(float4, float4);
 
-//===----------------------------------------------------------------------===//
-// reversebits builtins
-//===----------------------------------------------------------------------===//
+/// \brief Returns the value from the lane diagonally opposite from the current lane in the quad.
+/// \param Val The input value.
+// QuadReadAcrossDiagonal overloads
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_diagonal)
+__attribute__((convergent)) half QuadReadAcrossDiagonal(half);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_diagonal)
+__attribute__((convergent)) half2 QuadReadAcrossDiagonal(half2);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_diagonal)
+__attribute__((convergent)) half3 QuadReadAcrossDiagonal(half3);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_diagonal)
+__attribute__((convergent)) half4 QuadReadAcrossDiagonal(half4);
 
-/// \fn T reversebits(T Val)
-/// \brief Return the value \a Val with the bit order reversed.
+#ifdef __HLSL_ENABLE_16_BIT
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_diagonal)
+__attribute__((convergent)) int16_t QuadReadAcrossDiagonal(int16_t);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_diagonal)
+__attribute__((convergent)) int16_t2 QuadReadAcrossDiagonal(int16_t2);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_diagonal)
+__attribute__((convergent)) int16_t3 QuadReadAcrossDiagonal(int16_t3);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_diagonal)
+__attribute__((convergent)) int16_t4 QuadReadAcrossDiagonal(int16_t4);
+
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_diagonal)
+__attribute__((convergent)) uint16_t QuadReadAcrossDiagonal(uint16_t);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_diagonal)
+__attribute__((convergent)) uint16_t2 QuadReadAcrossDiagonal(uint16_t2);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_diagonal)
+__attribute__((convergent)) uint16_t3 QuadReadAcrossDiagonal(uint16_t3);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_diagonal)
+__attribute__((convergent)) uint16_t4 QuadReadAcrossDiagonal(uint16_t4);
+#endif
+
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_diagonal)
+__attribute__((convergent)) int QuadReadAcrossDiagonal(int);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_diagonal)
+__attribute__((convergent)) int2 QuadReadAcrossDiagonal(int2);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_diagonal)
+__attribute__((convergent)) int3 QuadReadAcrossDiagonal(int3);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_diagonal)
+__attribute__((convergent)) int4 QuadReadAcrossDiagonal(int4);
+
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_diagonal)
+__attribute__((convergent)) uint QuadReadAcrossDiagonal(uint);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_diagonal)
+__attribute__((convergent)) uint2 QuadReadAcrossDiagonal(uint2);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_diagonal)
+__attribute__((convergent)) uint3 QuadReadAcrossDiagonal(uint3);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_diagonal)
+__attribute__((convergent)) uint4 QuadReadAcrossDiagonal(uint4);
+
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_diagonal)
+__attribute__((convergent)) int64_t QuadReadAcrossDiagonal(int64_t);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_diagonal)
+__attribute__((convergent)) int64_t2 QuadReadAcrossDiagonal(int64_t2);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_diagonal)
+__attribute__((convergent)) int64_t3 QuadReadAcrossDiagonal(int64_t3);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_diagonal)
+__attribute__((convergent)) int64_t4 QuadReadAcrossDiagonal(int64_t4);
+
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_diagonal)
+__attribute__((convergent)) uint64_t QuadReadAcrossDiagonal(uint64_t);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_diagonal)
+__attribute__((convergent)) uint64_t2 QuadReadAcrossDiagonal(uint64_t2);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_diagonal)
+__attribute__((convergent)) uint64_t3 QuadReadAcrossDiagonal(uint64_t3);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_diagonal)
+__attribute__((convergent)) uint64_t4 QuadReadAcrossDiagonal(uint64_t4);
+
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_diagonal)
+__attribute__((convergent)) float QuadReadAcrossDiagonal(float);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_diagonal)
+__attribute__((convergent)) float2 QuadReadAcrossDiagonal(float2);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_diagonal)
+__attribute__((convergent)) float3 QuadReadAcrossDiagonal(float3);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_diagonal)
+__attribute__((convergent)) float4 QuadReadAcrossDiagonal(float4);
+
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_diagonal)
+__attribute__((convergent)) double QuadReadAcrossDiagonal(double);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_diagonal)
+__attribute__((convergent)) double2 QuadReadAcrossDiagonal(double2);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_diagonal)
+__attribute__((convergent)) double3 QuadReadAcrossDiagonal(double3);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_diagonal)
+__attribute__((convergent)) double4 QuadReadAcrossDiagonal(double4);
+
+/// \brief Reads the value from the lane across the X axis of the quad.
 /// \param Val The input value.
+// QuadReadAcrossX overloads
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_x)
+__attribute__((convergent)) half QuadReadAcrossX(half);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_x)
+__attribute__((convergent)) half2 QuadReadAcrossX(half2);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_x)
+__attribute__((convergent)) half3 QuadReadAcrossX(half3);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_x)
+__attribute__((convergent)) half4 QuadReadAcrossX(half4);
 
 #ifdef __HLSL_ENABLE_16_BIT
 _HLSL_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)
-uint16_t reversebits(uint16_t);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_x)
+__attribute__((convergent)) int16_t QuadReadAcrossX(int16_t);
 _HLSL_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)
-uint16_t2 reversebits(uint16_t2);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_x)
+__attribute__((convergent)) int16_t2 QuadReadAcrossX(int16_t2);
 _HLSL_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)
-uint16_t3 reversebits(uint16_t3);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_x)
+__attribute__((convergent)) int16_t3 QuadReadAcrossX(int16_t3);
 _HLSL_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)
-uint16_t4 reversebits(uint16_t4);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_x)
+__attribute__((convergent)) int16_t4 QuadReadAcrossX(int16_t4);
+
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_x)
+__attribute__((convergent)) uint16_t QuadReadAcrossX(uint16_t);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_x)
+__attribute__((convergent)) uint16_t2 QuadReadAcrossX(uint16_t2);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_x)
+__attribute__((convergent)) uint16_t3 QuadReadAcrossX(uint16_t3);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_x)
+__attribute__((convergent)) uint16_t4 QuadReadAcrossX(uint16_t4);
 #endif
 
-_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)
-uint reversebits(uint);
-_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)
-uint2 reversebits(uint2);
-_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)
-uint3 reversebits(uint3);
-_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)
-uint4 reversebits(uint4);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_x)
+__attribute__((convergent)) int QuadReadAcrossX(int);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_x)
+__attribute__((convergent)) int2 QuadReadAcrossX(int2);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_x)
+__attribute__((convergent)) int3 QuadReadAcrossX(int3);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_x)
+__attribute__((convergent)) int4 QuadReadAcrossX(int4);
+
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_x)
+__attribute__((convergent)) uint QuadReadAcrossX(uint);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_x)
+__attribute__((convergent)) uint2 QuadReadAcrossX(uint2);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_x)
+__attribute__((convergent)) uint3 QuadReadAcrossX(uint3);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_x)
+__attribute__((convergent)) uint4 QuadReadAcrossX(uint4);
+
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_x)
+__attribute__((convergent)) int64_t QuadReadAcrossX(int64_t);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_x)
+__attribute__((convergent)) int64_t2 QuadReadAcrossX(int64_t2);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_x)
+__attribute__((convergent)) int64_t3 QuadReadAcrossX(int64_t3);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_x)
+__attribute__((convergent)) int64_t4 QuadReadAcrossX(int64_t4);
+
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_x)
+__attribute__((convergent)) uint64_t QuadReadAcrossX(uint64_t);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_x)
+__attribute__((convergent)) uint64_t2 QuadReadAcrossX(uint64_t2);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_x)
+__attribute__((convergent)) uint64_t3 QuadReadAcrossX(uint64_t3);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_x)
+__attribute__((convergent)) uint64_t4 QuadReadAcrossX(uint64_t4);
+
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_x)
+__attribute__((convergent)) float QuadReadAcrossX(float);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_x)
+__attribute__((convergent)) float2 QuadReadAcrossX(float2);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_x)
+__attribute__((convergent)) float3 QuadReadAcrossX(float3);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_x)
+__attribute__((convergent)) float4 QuadReadAcrossX(float4);
+
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_x)
+__attribute__((convergent)) double QuadReadAcrossX(double);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_x)
+__attribute__((convergent)) double2 QuadReadAcrossX(double2);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_x)
+__attribute__((convergent)) double3 QuadReadAcrossX(double3);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_x)
+__attribute__((convergent)) double4 QuadReadAcrossX(double4);
+
+/// \brief Reads the value from the lane across the Y axis of the quad.
+/// \param Val The input value.
+// QuadReadAcrossY overloads
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_y)
+__attribute__((convergent)) half QuadReadAcrossY(half);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_y)
+__attribute__((convergent)) half2 QuadReadAcrossY(half2);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_y)
+__attribute__((convergent)) half3 QuadReadAcrossY(half3);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_y)
+__attribute__((convergent)) half4 QuadReadAcrossY(half4);
 
-_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)
-uint64_t reversebits(uint64_t);
-_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)
-uint64_t2 reversebits(uint64_t2);
-_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)
-uint64_t3 reversebits(uint64_t3);
-_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)
-uint64_t4 reversebits(uint64_t4);
+#ifdef __HLSL_ENABLE_16_BIT
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_y)
+__attribute__((convergent)) int16_t QuadReadAcrossY(int16_t);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_y)
+__attribute__((convergent)) int16_t2 QuadReadAcrossY(int16_t2);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_y)
+__attribute__((convergent)) int16_t3 QuadReadAcrossY(int16_t3);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_y)
+__attribute__((convergent)) int16_t4 QuadReadAcrossY(int16_t4);
 
-//===----------------------------------------------------------------------===//
-// cross builtins
-//===----------------------------------------------------------------------===//
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_y)
+__attribute__((convergent)) uint16_t QuadReadAcrossY(uint16_t);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_y)
+__attribute__((convergent)) uint16_t2 QuadReadAcrossY(uint16_t2);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_y)
+__attribute__((convergent)) uint16_t3 QuadReadAcrossY(uint16_t3);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_y)
+__attribute__((convergent)) uint16_t4 QuadReadAcrossY(uint16_t4);
+#endif
 
-/// \fn T cross(T x, T y)
-/// \brief Returns the cross product of two floating-point, 3D vectors.
-/// \param x [in] The first floating-point, 3D vector.
-/// \param y [in] The second floating-point, 3D vector.
-///
-/// Result is the cross product of x and y, i.e., the resulting
-/// components are, in order :
-/// x[1] * y[2] - y[1] * x[2]
-/// x[2] * y[0] - y[2] * x[0]
-/// x[0] * y[1] - y[0] * x[1]
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_y)
+__attribute__((convergent)) int QuadReadAcrossY(int);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_y)
+__attribute__((convergent)) int2 QuadReadAcrossY(int2);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_y)
+__attribute__((convergent)) int3 QuadReadAcrossY(int3);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_y)
+__attribute__((convergent)) int4 QuadReadAcrossY(int4);
+
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_y)
+__attribute__((convergent)) uint QuadReadAcrossY(uint);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_y)
+__attribute__((convergent)) uint2 QuadReadAcrossY(uint2);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_y)
+__attribute__((convergent)) uint3 QuadReadAcrossY(uint3);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_y)
+__attribute__((convergent)) uint4 QuadReadAcrossY(uint4);
+
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_y)
+__attribute__((convergent)) int64_t QuadReadAcrossY(int64_t);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_y)
+__attribute__((convergent)) int64_t2 QuadReadAcrossY(int64_t2);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_y)
+__attribute__((convergent)) int64_t3 QuadReadAcrossY(int64_t3);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_y)
+__attribute__((convergent)) int64_t4 QuadReadAcrossY(int64_t4);
+
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_y)
+__attribute__((convergent)) uint64_t QuadReadAcrossY(uint64_t);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_y)
+__attribute__((convergent)) uint64_t2 QuadReadAcrossY(uint64_t2);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_y)
+__attribute__((convergent)) uint64_t3 QuadReadAcrossY(uint64_t3);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_y)
+__attribute__((convergent)) uint64_t4 QuadReadAcrossY(uint64_t4);
+
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_y)
+__attribute__((convergent)) float QuadReadAcrossY(float);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_y)
+__attribute__((convergent)) float2 QuadReadAcrossY(float2);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_y)
+__attribute__((convergent)) float3 QuadReadAcrossY(float3);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_y)
+__attribute__((convergent)) float4 QuadReadAcrossY(float4);
+
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_y)
+__attribute__((convergent)) double QuadReadAcrossY(double);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_y)
+__attribute__((convergent)) double2 QuadReadAcrossY(double2);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_y)
+__attribute__((convergent)) double3 QuadReadAcrossY(double3);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_quad_read_across_y)
+__attribute__((convergent)) double4 QuadReadAcrossY(double4);
 
+/// \fn T radians(T Val)
+/// \brief Converts the specified value from degrees to radians.
+// radians overloads
 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_crossf16)
-half3 cross(half3, half3);
-
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_crossf32)
-float3 cross(float3, float3);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_radians)
+half radians(half);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_radians)
+half2 radians(half2);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_radians)
+half3 radians(half3);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_radians)
+half4 radians(half4);
 
-//===----------------------------------------------------------------------===//
-// rcp builtins
-//===----------------------------------------------------------------------===//
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_radians)
+float radians(float);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_radians)
+float2 radians(float2);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_radians)
+float3 radians(float3);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_radians)
+float4 radians(float4);
 
 /// \fn T rcp(T x)
 /// \brief Calculates a fast, approximate, per-component reciprocal ie 1 / \a x.
 /// \param x The specified input value.
 ///
 /// The return value is the reciprocal of the \a x parameter.
-
+// rcp overloads
 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rcp)
 half rcp(half);
@@ -1974,42 +2274,73 @@ double3 rcp(double3);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rcp)
 double4 rcp(double4);
 
-//===----------------------------------------------------------------------===//
-// rsqrt builtins
-//===----------------------------------------------------------------------===//
+/// \fn T reversebits(T Val)
+/// \brief Return the value \a Val with the bit order reversed.
+/// \param Val The input value.
+// reversebits overloads
+#ifdef __HLSL_ENABLE_16_BIT
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)
+int16_t reversebits(int16_t);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)
+int16_t2 reversebits(int16_t2);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)
+int16_t3 reversebits(int16_t3);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)
+int16_t4 reversebits(int16_t4);
 
-/// \fn T rsqrt(T x)
-/// \brief Returns the reciprocal of the square root of the specified value.
-/// ie 1 / sqrt( \a x).
-/// \param x The specified input value.
-///
-/// This function uses the following formula: 1 / sqrt(x).
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)
+uint16_t reversebits(uint16_t);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)
+uint16_t2 reversebits(uint16_t2);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)
+uint16_t3 reversebits(uint16_t3);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)
+uint16_t4 reversebits(uint16_t4);
+#endif
 
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rsqrt)
-half rsqrt(half);
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rsqrt)
-half2 rsqrt(half2);
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rsqrt)
-half3 rsqrt(half3);
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rsqrt)
-half4 rsqrt(half4);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)
+int reversebits(int);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)
+int2 reversebits(int2);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)
+int3 reversebits(int3);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)
+int4 reversebits(int4);
 
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rsqrt)
-float rsqrt(float);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rsqrt)
-float2 rsqrt(float2);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rsqrt)
-float3 rsqrt(float3);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rsqrt)
-float4 rsqrt(float4);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)
+uint reversebits(uint);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)
+uint2 reversebits(uint2);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)
+uint3 reversebits(uint3);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)
+uint4 reversebits(uint4);
+
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)
+int64_t reversebits(int64_t);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)
+int64_t2 reversebits(int64_t2);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)
+int64_t3 reversebits(int64_t3);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)
+int64_t4 reversebits(int64_t4);
 
-//===----------------------------------------------------------------------===//
-// round builtins
-//===----------------------------------------------------------------------===//
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)
+uint64_t reversebits(uint64_t);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)
+uint64_t2 reversebits(uint64_t2);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)
+uint64_t3 reversebits(uint64_t3);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)
+uint64_t4 reversebits(uint64_t4);
 
 /// \fn T round(T x)
 /// \brief Rounds the specified value \a x to the nearest integer.
@@ -2018,7 +2349,7 @@ float4 rsqrt(float4);
 /// The return value is the \a x parameter, rounded to the nearest integer
 /// within a floating-point type. Halfway cases are
 /// rounded to the nearest even value.
-
+// round overloads
 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_roundeven)
 half round(half);
@@ -2041,14 +2372,40 @@ float3 round(float3);
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_roundeven)
 float4 round(float4);
 
-//===----------------------------------------------------------------------===//
-// saturate builtins
-//===----------------------------------------------------------------------===//
+/// \fn T rsqrt(T x)
+/// \brief Returns the reciprocal of the square root of the specified value.
+/// ie 1 / sqrt( \a x).
+/// \param x The specified input value.
+///
+/// This function uses the following formula: 1 / sqrt(x).
+// rsqrt overloads
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rsqrt)
+half rsqrt(half);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rsqrt)
+half2 rsqrt(half2);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rsqrt)
+half3 rsqrt(half3);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rsqrt)
+half4 rsqrt(half4);
+
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rsqrt)
+float rsqrt(float);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rsqrt)
+float2 rsqrt(float2);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rsqrt)
+float3 rsqrt(float3);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rsqrt)
+float4 rsqrt(float4);
 
 /// \fn T saturate(T Val)
 /// \brief Returns input value, \a Val, clamped within the range of 0.0f
-/// to 1.0f. \param Val The input value.
-
+/// to 1.0f.
+/// \param Val The input value.
+// saturate overloads
 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_saturate)
 half saturate(half);
@@ -2080,142 +2437,139 @@ double3 saturate(double3);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_saturate)
 double4 saturate(double4);
 
-//===----------------------------------------------------------------------===//
-// select builtins
-//===----------------------------------------------------------------------===//
-
-/// \fn T select(bool Cond, T TrueVal, T FalseVal)
-/// \brief ternary operator.
-/// \param Cond The Condition input value.
-/// \param TrueVal The Value returned if Cond is true.
-/// \param FalseVal The Value returned if Cond is false.
-
-template <typename T>
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_select)
-T select(bool, T, T);
-
-/// \fn vector<T,Sz> select(vector<bool,Sz> Conds, vector<T,Sz> TrueVals,
-///                         vector<T,Sz> FalseVals)
-/// \brief ternary operator for vectors. All vectors must be the same size.
-/// \param Conds The Condition input values.
-/// \param TrueVals The vector values are chosen from when conditions are true.
-/// \param FalseVals The vector values are chosen from when conditions are
-/// false.
-
-template <typename T>
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_select)
-vector<T, 2> select(vector<bool, 2>, vector<T, 2>, vector<T, 2>);
-
-template <typename T>
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_select)
-vector<T, 3> select(vector<bool, 3>, vector<T, 3>, vector<T, 3>);
-
-template <typename T>
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_select)
-vector<T, 4> select(vector<bool, 4>, vector<T, 4>, vector<T, 4>);
-
-/// \fn vector<T,Sz> select(vector<bool,Sz> Conds, T TrueVal,
-///                         vector<T,Sz> FalseVals)
-/// \brief ternary operator for vectors. All vectors must be the same size.
-/// \param Conds The Condition input values.
-/// \param TrueVal The scalar value to splat from when conditions are true.
-/// \param FalseVals The vector values are chosen from when conditions are
-/// false.
-
-template <typename T>
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_select)
-vector<T, 2> select(vector<bool, 2>, T, vector<T, 2>);
-
-template <typename T>
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_select)
-vector<T, 3> select(vector<bool, 3>, T, vector<T, 3>);
-
-template <typename T>
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_select)
-vector<T, 4> select(vector<bool, 4>, T, vector<T, 4>);
-
-/// \fn vector<T,Sz> select(vector<bool,Sz> Conds, vector<T,Sz> TrueVals,
-///                         T FalseVal)
-/// \brief ternary operator for vectors. All vectors must be the same size.
-/// \param Conds The Condition input values.
-/// \param TrueVals The vector values are chosen from when conditions are true.
-/// \param FalseVal The scalar value to splat from when conditions are false.
-
-template <typename T>
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_select)
-vector<T, 2> select(vector<bool, 2>, vector<T, 2>, T);
-
-template <typename T>
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_select)
-vector<T, 3> select(vector<bool, 3>, vector<T, 3>, T);
-
-template <typename T>
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_select)
-vector<T, 4> select(vector<bool, 4>, vector<T, 4>, T);
-
-/// \fn vector<T,Sz> select(vector<bool,Sz> Conds, vector<T,Sz> TrueVals,
-///                         T FalseVal)
-/// \brief ternary operator for vectors. All vectors must be the same size.
-/// \param Conds The Condition input values.
-/// \param TrueVal The scalar value to splat from when conditions are true.
-/// \param FalseVal The scalar value to splat from when conditions are false.
-
-template <typename T>
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_select)
-__detail::enable_if_t<__detail::is_arithmetic<T>::Value, vector<T, 2>> select(
-    vector<bool, 2>, T, T);
-
-template <typename T>
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_select)
-__detail::enable_if_t<__detail::is_arithmetic<T>::Value, vector<T, 3>> select(
-    vector<bool, 3>, T, T);
-
-template <typename T>
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_select)
-__detail::enable_if_t<__detail::is_arithmetic<T>::Value, vector<T, 4>> select(
-    vector<bool, 4>, T, T);
-
-//===----------------------------------------------------------------------===//
-// sin builtins
-//===----------------------------------------------------------------------===//
-
-/// \fn T sin(T Val)
-/// \brief Returns the sine of the input value, \a Val.
+/// \fn T sign(T Val)
+/// \brief Returns -1 if \a Val is less than zero; 0 if \a Val equals zero; and
+/// 1 if \a Val is greater than zero.
 /// \param Val The input value.
-
+// sign overloads
 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sin)
-half sin(half);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
+int sign(half);
 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sin)
-half2 sin(half2);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
+int2 sign(half2);
 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sin)
-half3 sin(half3);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
+int3 sign(half3);
 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sin)
-half4 sin(half4);
-
-_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sin)
-float sin(float);
-_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sin)
-float2 sin(float2);
-_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sin)
-float3 sin(float3);
-_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sin)
-float4 sin(float4);
-
-//===----------------------------------------------------------------------===//
-// sinh builtins
-//===----------------------------------------------------------------------===//
-
-/// \fn T sinh(T Val)
-/// \brief Returns the hyperbolic sine of the input value, \a Val.
-/// \param Val The input value.
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
+int4 sign(half4);
 
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sinh)
-half sinh(half);
+#ifdef __HLSL_ENABLE_16_BIT
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
+int sign(int16_t);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
+int2 sign(int16_t2);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
+int3 sign(int16_t3);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
+int4 sign(int16_t4);
+
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
+int sign(uint16_t);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
+int2 sign(uint16_t2);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
+int3 sign(uint16_t3);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
+int4 sign(uint16_t4);
+#endif
+
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
+int sign(int);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
+int2 sign(int2);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
+int3 sign(int3);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
+int4 sign(int4);
+
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
+int sign(uint);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
+int2 sign(uint2);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
+int3 sign(uint3);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
+int4 sign(uint4);
+
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
+int sign(int64_t);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
+int2 sign(int64_t2);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
+int3 sign(int64_t3);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
+int4 sign(int64_t4);
+
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
+int sign(uint64_t);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
+int2 sign(uint64_t2);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
+int3 sign(uint64_t3);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
+int4 sign(uint64_t4);
+
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
+int sign(float);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
+int2 sign(float2);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
+int3 sign(float3);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
+int4 sign(float4);
+
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
+int sign(double);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
+int2 sign(double2);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
+int3 sign(double3);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
+int4 sign(double4);
+
+/// \fn T sin(T Val)
+/// \brief Returns the sine of the input value, \a Val.
+/// \param Val The input value.
+// sin overloads
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sin)
+half sin(half);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sin)
+half2 sin(half2);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sin)
+half3 sin(half3);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sin)
+half4 sin(half4);
+
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sin)
+float sin(float);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sin)
+float2 sin(float2);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sin)
+float3 sin(float3);
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sin)
+float4 sin(float4);
+
+/// \fn T sinh(T Val)
+/// \brief Returns the hyperbolic sine of the input value, \a Val.
+/// \param Val The input value.
+// sinh overloads
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sinh)
+half sinh(half);
 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_sinh)
 half2 sinh(half2);
@@ -2235,14 +2589,10 @@ float3 sinh(float3);
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_sinh)
 float4 sinh(float4);
 
-//===----------------------------------------------------------------------===//
-// sqrt builtins
-//===----------------------------------------------------------------------===//
-
 /// \fn T sqrt(T Val)
 /// \brief Returns the square root of the input value, \a Val.
 /// \param Val The input value.
-
+// sqrt overloads
 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_sqrt)
 half sqrt(half);
@@ -2265,17 +2615,14 @@ float3 sqrt(float3);
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_sqrt)
 float4 sqrt(float4);
 
-//===----------------------------------------------------------------------===//
-// step builtins
-//===----------------------------------------------------------------------===//
-
 /// \fn T step(T y, T x)
 /// \brief Returns 1 if the x parameter is greater than or equal to the y
-/// parameter; otherwise, 0. vector. \param y [in] The first floating-point
-/// value to compare. \param x [in] The second floating-point value to compare.
+/// parameter; otherwise, 0.
+/// \param y [in] The first floating-point value to compare.
+/// \param x [in] The second floating-point value to compare.
 ///
 /// Step is based on the following formula: (x >= y) ? 1 : 0
-
+// step overloads
 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_step)
 half step(half, half);
@@ -2298,14 +2645,10 @@ float3 step(float3, float3);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_step)
 float4 step(float4, float4);
 
-//===----------------------------------------------------------------------===//
-// tan builtins
-//===----------------------------------------------------------------------===//
-
 /// \fn T tan(T Val)
 /// \brief Returns the tangent of the input value, \a Val.
 /// \param Val The input value.
-
+// tan overloads
 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_tan)
 half tan(half);
@@ -2328,14 +2671,10 @@ float3 tan(float3);
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_tan)
 float4 tan(float4);
 
-//===----------------------------------------------------------------------===//
-// tanh builtins
-//===----------------------------------------------------------------------===//
-
 /// \fn T tanh(T Val)
 /// \brief Returns the hyperbolic tangent of the input value, \a Val.
 /// \param Val The input value.
-
+// tanh overloads
 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_tanh)
 half tanh(half);
@@ -2358,14 +2697,10 @@ float3 tanh(float3);
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_tanh)
 float4 tanh(float4);
 
-//===----------------------------------------------------------------------===//
-// trunc builtins
-//===----------------------------------------------------------------------===//
-
 /// \fn T trunc(T Val)
 /// \brief Returns the truncated integer value of the input value, \a Val.
 /// \param Val The input value.
-
+// trunc overloads
 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_trunc)
 half trunc(half);
@@ -2388,314 +2723,417 @@ float3 trunc(float3);
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_trunc)
 float4 trunc(float4);
 
-//===----------------------------------------------------------------------===//
-// Wave* builtins
-//===----------------------------------------------------------------------===//
+/// \brief Evaluates a value for all active invocations in the group. The
+/// result is true if Value is equal for all active invocations in the
+/// group. Otherwise, the result is false.
+/// \param Value The value to compare with
+/// \return True if all values across all lanes are equal, false otherwise
+// WaveActiveAllEqual overloads
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_all_equal)
+__attribute__((convergent)) bool WaveActiveAllEqual(half);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_all_equal)
+__attribute__((convergent)) bool2 WaveActiveAllEqual(half2);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_all_equal)
+__attribute__((convergent)) bool3 WaveActiveAllEqual(half3);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_all_equal)
+__attribute__((convergent)) bool4 WaveActiveAllEqual(half4);
+
+#ifdef __HLSL_ENABLE_16_BIT
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_all_equal)
+__attribute__((convergent)) bool WaveActiveAllEqual(int16_t);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_all_equal)
+__attribute__((convergent)) bool2 WaveActiveAllEqual(int16_t2);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_all_equal)
+__attribute__((convergent)) bool3 WaveActiveAllEqual(int16_t3);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_all_equal)
+__attribute__((convergent)) bool4 WaveActiveAllEqual(int16_t4);
+
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_all_equal)
+__attribute__((convergent)) bool WaveActiveAllEqual(uint16_t);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_all_equal)
+__attribute__((convergent)) bool2 WaveActiveAllEqual(uint16_t2);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_all_equal)
+__attribute__((convergent)) bool3 WaveActiveAllEqual(uint16_t3);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_all_equal)
+__attribute__((convergent)) bool4 WaveActiveAllEqual(uint16_t4);
+#endif
+
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_all_equal)
+__attribute__((convergent)) bool WaveActiveAllEqual(int);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_all_equal)
+__attribute__((convergent)) bool2 WaveActiveAllEqual(int2);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_all_equal)
+__attribute__((convergent)) bool3 WaveActiveAllEqual(int3);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_all_equal)
+__attribute__((convergent)) bool4 WaveActiveAllEqual(int4);
+
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_all_equal)
+__attribute__((convergent)) bool WaveActiveAllEqual(uint);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_all_equal)
+__attribute__((convergent)) bool2 WaveActiveAllEqual(uint2);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_all_equal)
+__attribute__((convergent)) bool3 WaveActiveAllEqual(uint3);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_all_equal)
+__attribute__((convergent)) bool4 WaveActiveAllEqual(uint4);
+
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_all_equal)
+__attribute__((convergent)) bool WaveActiveAllEqual(int64_t);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_all_equal)
+__attribute__((convergent)) bool2 WaveActiveAllEqual(int64_t2);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_all_equal)
+__attribute__((convergent)) bool3 WaveActiveAllEqual(int64_t3);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_all_equal)
+__attribute__((convergent)) bool4 WaveActiveAllEqual(int64_t4);
+
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_all_equal)
+__attribute__((convergent)) bool WaveActiveAllEqual(uint64_t);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_all_equal)
+__attribute__((convergent)) bool2 WaveActiveAllEqual(uint64_t2);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_all_equal)
+__attribute__((convergent)) bool3 WaveActiveAllEqual(uint64_t3);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_all_equal)
+__attribute__((convergent)) bool4 WaveActiveAllEqual(uint64_t4);
+
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_all_equal)
+__attribute__((convergent)) bool WaveActiveAllEqual(float);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_all_equal)
+__attribute__((convergent)) bool2 WaveActiveAllEqual(float2);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_all_equal)
+__attribute__((convergent)) bool3 WaveActiveAllEqual(float3);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_all_equal)
+__attribute__((convergent)) bool4 WaveActiveAllEqual(float4);
+
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_all_equal)
+__attribute__((convergent)) bool WaveActiveAllEqual(double);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_all_equal)
+__attribute__((convergent)) bool2 WaveActiveAllEqual(double2);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_all_equal)
+__attribute__((convergent)) bool3 WaveActiveAllEqual(double3);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_all_equal)
+__attribute__((convergent)) bool4 WaveActiveAllEqual(double4);
 
 /// \brief Returns true if the expression is true in all active lanes in the
 /// current wave.
-///
 /// \param Val The boolean expression to evaluate.
 /// \return True if the expression is true in all lanes.
+// WaveActiveAllTrue overloads
 _HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_all_true)
-__attribute__((convergent)) bool WaveActiveAllTrue(bool Val);
+__attribute__((convergent)) bool WaveActiveAllTrue(bool);
 
 /// \brief Returns true if the expression is true in any active lane in the
 /// current wave.
-///
 /// \param Val The boolean expression to evaluate.
 /// \return True if the expression is true in any lane.
+// WaveActiveAnyTrue overloads
 _HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_any_true)
-__attribute__((convergent)) bool WaveActiveAnyTrue(bool Val);
+__attribute__((convergent)) bool WaveActiveAnyTrue(bool);
 
 /// \brief Returns a uint4 containing a bitmask of the evaluation of the
 /// boolean expression for all active lanes in the current wave.
 /// The least-significant bit corresponds to the lane with index zero.
 /// The bits corresponding to inactive lanes will be zero. The bits that
 /// are greater than or equal to WaveGetLaneCount will be zero.
-///
 /// \param Val The boolean expression to evaluate.
 /// \return uint4 bitmask
+// WaveActiveBallot overloads
 _HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_ballot)
-__attribute__((convergent)) uint4 WaveActiveBallot(bool Val);
+__attribute__((convergent)) uint4 WaveActiveBallot(bool);
 
-/// \brief Counts the number of boolean variables which evaluate to true across
-/// all active lanes in the current wave.
-///
-/// \param Val The input boolean value.
-/// \return The number of lanes for which the boolean variable evaluates to
-/// true, across all active lanes in the current wave.
+// WaveActiveBitAnd overloads
 _HLSL_AVAILABILITY(shadermodel, 6.0)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_count_bits)
-__attribute__((convergent)) uint WaveActiveCountBits(bool Val);
-
-/// \brief Returns the index of the current lane within the current wave.
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_bit_and)
+__attribute__((convergent)) uint WaveActiveBitAnd(uint);
 _HLSL_AVAILABILITY(shadermodel, 6.0)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_get_lane_index)
-__attribute__((convergent)) uint WaveGetLaneIndex();
-
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_bit_and)
+__attribute__((convergent)) uint2 WaveActiveBitAnd(uint2);
 _HLSL_AVAILABILITY(shadermodel, 6.0)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_is_first_lane)
-__attribute__((convergent)) bool WaveIsFirstLane();
-
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_bit_and)
+__attribute__((convergent)) uint3 WaveActiveBitAnd(uint3);
 _HLSL_AVAILABILITY(shadermodel, 6.0)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_get_lane_count)
-__attribute__((convergent)) uint WaveGetLaneCount();
-
-//===----------------------------------------------------------------------===//
-// WaveReadLaneAt builtins
-//===----------------------------------------------------------------------===//
-
-// \brief Returns the value of the expression for the given lane index within
-// the specified wave.
-
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
-__attribute__((convergent)) bool WaveReadLaneAt(bool, uint32_t);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
-__attribute__((convergent)) bool2 WaveReadLaneAt(bool2, uint32_t);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
-__attribute__((convergent)) bool3 WaveReadLaneAt(bool3, uint32_t);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
-__attribute__((convergent)) bool4 WaveReadLaneAt(bool4, uint32_t);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_bit_and)
+__attribute__((convergent)) uint4 WaveActiveBitAnd(uint4);
 
-#ifdef __HLSL_ENABLE_16_BIT
 _HLSL_AVAILABILITY(shadermodel, 6.0)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
-__attribute__((convergent)) int16_t WaveReadLaneAt(int16_t, uint32_t);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_bit_and)
+__attribute__((convergent)) uint64_t WaveActiveBitAnd(uint64_t);
 _HLSL_AVAILABILITY(shadermodel, 6.0)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
-__attribute__((convergent)) int16_t2 WaveReadLaneAt(int16_t2, uint32_t);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_bit_and)
+__attribute__((convergent)) uint64_t2 WaveActiveBitAnd(uint64_t2);
 _HLSL_AVAILABILITY(shadermodel, 6.0)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
-__attribute__((convergent)) int16_t3 WaveReadLaneAt(int16_t3, uint32_t);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_bit_and)
+__attribute__((convergent)) uint64_t3 WaveActiveBitAnd(uint64_t3);
 _HLSL_AVAILABILITY(shadermodel, 6.0)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
-__attribute__((convergent)) int16_t4 WaveReadLaneAt(int16_t4, uint32_t);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_bit_and)
+__attribute__((convergent)) uint64_t4 WaveActiveBitAnd(uint64_t4);
 
+/// \brief Returns the bitwise OR of all the values of <expr> across all active
+/// non-helper lanes in the current wave, and replicates it back to
+/// all active non-helper lanes.
+// WaveActiveBitOr overloads
 _HLSL_AVAILABILITY(shadermodel, 6.0)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
-__attribute__((convergent)) uint16_t WaveReadLaneAt(uint16_t, uint32_t);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_bit_or)
+__attribute__((convergent)) uint WaveActiveBitOr(uint);
 _HLSL_AVAILABILITY(shadermodel, 6.0)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
-__attribute__((convergent)) uint16_t2 WaveReadLaneAt(uint16_t2, uint32_t);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_bit_or)
+__attribute__((convergent)) uint2 WaveActiveBitOr(uint2);
 _HLSL_AVAILABILITY(shadermodel, 6.0)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
-__attribute__((convergent)) uint16_t3 WaveReadLaneAt(uint16_t3, uint32_t);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_bit_or)
+__attribute__((convergent)) uint3 WaveActiveBitOr(uint3);
 _HLSL_AVAILABILITY(shadermodel, 6.0)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
-__attribute__((convergent)) uint16_t4 WaveReadLaneAt(uint16_t4, uint32_t);
-#endif
-
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.0)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
-__attribute__((convergent)) half WaveReadLaneAt(half, uint32_t);
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.0)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
-__attribute__((convergent)) half2 WaveReadLaneAt(half2, uint32_t);
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.0)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
-__attribute__((convergent)) half3 WaveReadLaneAt(half3, uint32_t);
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.0)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
-__attribute__((convergent)) half4 WaveReadLaneAt(half4, uint32_t);
-
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
-__attribute__((convergent)) int WaveReadLaneAt(int, uint32_t);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
-__attribute__((convergent)) int2 WaveReadLaneAt(int2, uint32_t);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
-__attribute__((convergent)) int3 WaveReadLaneAt(int3, uint32_t);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
-__attribute__((convergent)) int4 WaveReadLaneAt(int4, uint32_t);
-
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
-__attribute__((convergent)) uint WaveReadLaneAt(uint, uint32_t);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
-__attribute__((convergent)) uint2 WaveReadLaneAt(uint2, uint32_t);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
-__attribute__((convergent)) uint3 WaveReadLaneAt(uint3, uint32_t);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
-__attribute__((convergent)) uint4 WaveReadLaneAt(uint4, uint32_t);
-
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
-__attribute__((convergent)) float WaveReadLaneAt(float, uint32_t);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
-__attribute__((convergent)) float2 WaveReadLaneAt(float2, uint32_t);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
-__attribute__((convergent)) float3 WaveReadLaneAt(float3, uint32_t);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
-__attribute__((convergent)) float4 WaveReadLaneAt(float4, uint32_t);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_bit_or)
+__attribute__((convergent)) uint4 WaveActiveBitOr(uint4);
 
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
-__attribute__((convergent)) int64_t WaveReadLaneAt(int64_t, uint32_t);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
-__attribute__((convergent)) int64_t2 WaveReadLaneAt(int64_t2, uint32_t);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
-__attribute__((convergent)) int64_t3 WaveReadLaneAt(int64_t3, uint32_t);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
-__attribute__((convergent)) int64_t4 WaveReadLaneAt(int64_t4, uint32_t);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_bit_or)
+__attribute__((convergent)) uint64_t WaveActiveBitOr(uint64_t);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_bit_or)
+__attribute__((convergent)) uint64_t2 WaveActiveBitOr(uint64_t2);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_bit_or)
+__attribute__((convergent)) uint64_t3 WaveActiveBitOr(uint64_t3);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_bit_or)
+__attribute__((convergent)) uint64_t4 WaveActiveBitOr(uint64_t4);
 
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
-__attribute__((convergent)) uint64_t WaveReadLaneAt(uint64_t, uint32_t);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
-__attribute__((convergent)) uint64_t2 WaveReadLaneAt(uint64_t2, uint32_t);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
-__attribute__((convergent)) uint64_t3 WaveReadLaneAt(uint64_t3, uint32_t);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
-__attribute__((convergent)) uint64_t4 WaveReadLaneAt(uint64_t4, uint32_t);
+// WaveActiveBitXor overloads
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_bit_xor)
+__attribute__((convergent)) uint WaveActiveBitXor(uint);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_bit_xor)
+__attribute__((convergent)) uint2 WaveActiveBitXor(uint2);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_bit_xor)
+__attribute__((convergent)) uint3 WaveActiveBitXor(uint3);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_bit_xor)
+__attribute__((convergent)) uint4 WaveActiveBitXor(uint4);
 
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
-__attribute__((convergent)) double WaveReadLaneAt(double, uint32_t);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
-__attribute__((convergent)) double2 WaveReadLaneAt(double2, uint32_t);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
-__attribute__((convergent)) double3 WaveReadLaneAt(double3, uint32_t);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
-__attribute__((convergent)) double4 WaveReadLaneAt(double4, uint32_t);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_bit_xor)
+__attribute__((convergent)) uint64_t WaveActiveBitXor(uint64_t);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_bit_xor)
+__attribute__((convergent)) uint64_t2 WaveActiveBitXor(uint64_t2);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_bit_xor)
+__attribute__((convergent)) uint64_t3 WaveActiveBitXor(uint64_t3);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_bit_xor)
+__attribute__((convergent)) uint64_t4 WaveActiveBitXor(uint64_t4);
 
-//===----------------------------------------------------------------------===//
-// WaveActiveMax builtins
-//===----------------------------------------------------------------------===//
+/// \brief Counts the number of boolean variables which evaluate to true across
+/// all active lanes in the current wave.
+/// \param Val The input boolean value.
+/// \return The number of lanes for which the boolean variable evaluates to
+/// true, across all active lanes in the current wave.
+// WaveActiveCountBits overloads
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_count_bits)
+__attribute__((convergent)) uint WaveActiveCountBits(bool);
 
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.0)
+/// \brief Returns the maximum value across all active lanes in the wave.
+/// \param Val The input value.
+// WaveActiveMax overloads
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)
 __attribute__((convergent)) half WaveActiveMax(half);
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.0)
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)
 __attribute__((convergent)) half2 WaveActiveMax(half2);
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.0)
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)
 __attribute__((convergent)) half3 WaveActiveMax(half3);
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.0)
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)
 __attribute__((convergent)) half4 WaveActiveMax(half4);
 
 #ifdef __HLSL_ENABLE_16_BIT
-_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)
 __attribute__((convergent)) int16_t WaveActiveMax(int16_t);
-_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)
 __attribute__((convergent)) int16_t2 WaveActiveMax(int16_t2);
-_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)
 __attribute__((convergent)) int16_t3 WaveActiveMax(int16_t3);
-_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)
 __attribute__((convergent)) int16_t4 WaveActiveMax(int16_t4);
 
-_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)
 __attribute__((convergent)) uint16_t WaveActiveMax(uint16_t);
-_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)
 __attribute__((convergent)) uint16_t2 WaveActiveMax(uint16_t2);
-_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)
 __attribute__((convergent)) uint16_t3 WaveActiveMax(uint16_t3);
-_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)
 __attribute__((convergent)) uint16_t4 WaveActiveMax(uint16_t4);
 #endif
 
+_HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)
 __attribute__((convergent)) int WaveActiveMax(int);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)
 __attribute__((convergent)) int2 WaveActiveMax(int2);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)
 __attribute__((convergent)) int3 WaveActiveMax(int3);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)
 __attribute__((convergent)) int4 WaveActiveMax(int4);
 
+_HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)
 __attribute__((convergent)) uint WaveActiveMax(uint);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)
 __attribute__((convergent)) uint2 WaveActiveMax(uint2);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)
 __attribute__((convergent)) uint3 WaveActiveMax(uint3);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)
 __attribute__((convergent)) uint4 WaveActiveMax(uint4);
 
+_HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)
 __attribute__((convergent)) int64_t WaveActiveMax(int64_t);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)
 __attribute__((convergent)) int64_t2 WaveActiveMax(int64_t2);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)
 __attribute__((convergent)) int64_t3 WaveActiveMax(int64_t3);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)
 __attribute__((convergent)) int64_t4 WaveActiveMax(int64_t4);
 
+_HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)
 __attribute__((convergent)) uint64_t WaveActiveMax(uint64_t);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)
 __attribute__((convergent)) uint64_t2 WaveActiveMax(uint64_t2);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)
 __attribute__((convergent)) uint64_t3 WaveActiveMax(uint64_t3);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)
 __attribute__((convergent)) uint64_t4 WaveActiveMax(uint64_t4);
 
+_HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)
 __attribute__((convergent)) float WaveActiveMax(float);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)
 __attribute__((convergent)) float2 WaveActiveMax(float2);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)
 __attribute__((convergent)) float3 WaveActiveMax(float3);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)
 __attribute__((convergent)) float4 WaveActiveMax(float4);
 
+_HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)
 __attribute__((convergent)) double WaveActiveMax(double);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)
 __attribute__((convergent)) double2 WaveActiveMax(double2);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)
 __attribute__((convergent)) double3 WaveActiveMax(double3);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)
 __attribute__((convergent)) double4 WaveActiveMax(double4);
 
-//===----------------------------------------------------------------------===//
-// WaveActiveMin builtins
-//===----------------------------------------------------------------------===//
-
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.0)
+/// \brief Returns the minimum value across all active lanes in the wave.
+/// \param Val The input value.
+// WaveActiveMin overloads
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_min)
 __attribute__((convergent)) half WaveActiveMin(half);
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.0)
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_min)
 __attribute__((convergent)) half2 WaveActiveMin(half2);
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.0)
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_min)
 __attribute__((convergent)) half3 WaveActiveMin(half3);
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.0)
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_min)
 __attribute__((convergent)) half4 WaveActiveMin(half4);
 
 #ifdef __HLSL_ENABLE_16_BIT
-_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_min)
 __attribute__((convergent)) int16_t WaveActiveMin(int16_t);
-_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_min)
 __attribute__((convergent)) int16_t2 WaveActiveMin(int16_t2);
-_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_min)
 __attribute__((convergent)) int16_t3 WaveActiveMin(int16_t3);
-_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_min)
 __attribute__((convergent)) int16_t4 WaveActiveMin(int16_t4);
 
-_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_min)
 __attribute__((convergent)) uint16_t WaveActiveMin(uint16_t);
-_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_min)
 __attribute__((convergent)) uint16_t2 WaveActiveMin(uint16_t2);
-_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_min)
 __attribute__((convergent)) uint16_t3 WaveActiveMin(uint16_t3);
-_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_min)
 __attribute__((convergent)) uint16_t4 WaveActiveMin(uint16_t4);
 #endif
@@ -2778,384 +3216,654 @@ _HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_min)
 __attribute__((convergent)) double4 WaveActiveMin(double4);
 
-//===----------------------------------------------------------------------===//
-// WaveActiveSum builtins
-//===----------------------------------------------------------------------===//
+/// \brief Returns the product of values across all active lanes in the wave.
+/// \param Val The input value.
+// WaveActiveProduct overloads
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_product)
+__attribute__((convergent)) half WaveActiveProduct(half);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_product)
+__attribute__((convergent)) half2 WaveActiveProduct(half2);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_product)
+__attribute__((convergent)) half3 WaveActiveProduct(half3);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_product)
+__attribute__((convergent)) half4 WaveActiveProduct(half4);
+
+#ifdef __HLSL_ENABLE_16_BIT
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_product)
+__attribute__((convergent)) int16_t WaveActiveProduct(int16_t);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_product)
+__attribute__((convergent)) int16_t2 WaveActiveProduct(int16_t2);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_product)
+__attribute__((convergent)) int16_t3 WaveActiveProduct(int16_t3);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_product)
+__attribute__((convergent)) int16_t4 WaveActiveProduct(int16_t4);
+
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_product)
+__attribute__((convergent)) uint16_t WaveActiveProduct(uint16_t);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_product)
+__attribute__((convergent)) uint16_t2 WaveActiveProduct(uint16_t2);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_product)
+__attribute__((convergent)) uint16_t3 WaveActiveProduct(uint16_t3);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_product)
+__attribute__((convergent)) uint16_t4 WaveActiveProduct(uint16_t4);
+#endif
+
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_product)
+__attribute__((convergent)) int WaveActiveProduct(int);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_product)
+__attribute__((convergent)) int2 WaveActiveProduct(int2);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_product)
+__attribute__((convergent)) int3 WaveActiveProduct(int3);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_product)
+__attribute__((convergent)) int4 WaveActiveProduct(int4);
+
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_product)
+__attribute__((convergent)) uint WaveActiveProduct(uint);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_product)
+__attribute__((convergent)) uint2 WaveActiveProduct(uint2);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_product)
+__attribute__((convergent)) uint3 WaveActiveProduct(uint3);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_product)
+__attribute__((convergent)) uint4 WaveActiveProduct(uint4);
+
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_product)
+__attribute__((convergent)) int64_t WaveActiveProduct(int64_t);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_product)
+__attribute__((convergent)) int64_t2 WaveActiveProduct(int64_t2);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_product)
+__attribute__((convergent)) int64_t3 WaveActiveProduct(int64_t3);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_product)
+__attribute__((convergent)) int64_t4 WaveActiveProduct(int64_t4);
+
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_product)
+__attribute__((convergent)) uint64_t WaveActiveProduct(uint64_t);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_product)
+__attribute__((convergent)) uint64_t2 WaveActiveProduct(uint64_t2);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_product)
+__attribute__((convergent)) uint64_t3 WaveActiveProduct(uint64_t3);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_product)
+__attribute__((convergent)) uint64_t4 WaveActiveProduct(uint64_t4);
+
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_product)
+__attribute__((convergent)) float WaveActiveProduct(float);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_product)
+__attribute__((convergent)) float2 WaveActiveProduct(float2);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_product)
+__attribute__((convergent)) float3 WaveActiveProduct(float3);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_product)
+__attribute__((convergent)) float4 WaveActiveProduct(float4);
+
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_product)
+__attribute__((convergent)) double WaveActiveProduct(double);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_product)
+__attribute__((convergent)) double2 WaveActiveProduct(double2);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_product)
+__attribute__((convergent)) double3 WaveActiveProduct(double3);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_product)
+__attribute__((convergent)) double4 WaveActiveProduct(double4);
 
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.0)
+/// \brief Returns the sum of values across all active lanes in the wave.
+/// \param Val The input value.
+// WaveActiveSum overloads
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
 __attribute__((convergent)) half WaveActiveSum(half);
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.0)
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
 __attribute__((convergent)) half2 WaveActiveSum(half2);
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.0)
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
 __attribute__((convergent)) half3 WaveActiveSum(half3);
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.0)
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
 __attribute__((convergent)) half4 WaveActiveSum(half4);
 
 #ifdef __HLSL_ENABLE_16_BIT
-_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
 __attribute__((convergent)) int16_t WaveActiveSum(int16_t);
-_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
 __attribute__((convergent)) int16_t2 WaveActiveSum(int16_t2);
-_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
 __attribute__((convergent)) int16_t3 WaveActiveSum(int16_t3);
-_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
 __attribute__((convergent)) int16_t4 WaveActiveSum(int16_t4);
 
-_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
 __attribute__((convergent)) uint16_t WaveActiveSum(uint16_t);
-_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
 __attribute__((convergent)) uint16_t2 WaveActiveSum(uint16_t2);
-_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
 __attribute__((convergent)) uint16_t3 WaveActiveSum(uint16_t3);
-_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
 __attribute__((convergent)) uint16_t4 WaveActiveSum(uint16_t4);
 #endif
 
+_HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
 __attribute__((convergent)) int WaveActiveSum(int);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
 __attribute__((convergent)) int2 WaveActiveSum(int2);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
 __attribute__((convergent)) int3 WaveActiveSum(int3);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
 __attribute__((convergent)) int4 WaveActiveSum(int4);
 
+_HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
 __attribute__((convergent)) uint WaveActiveSum(uint);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
 __attribute__((convergent)) uint2 WaveActiveSum(uint2);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
 __attribute__((convergent)) uint3 WaveActiveSum(uint3);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
 __attribute__((convergent)) uint4 WaveActiveSum(uint4);
 
+_HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
 __attribute__((convergent)) int64_t WaveActiveSum(int64_t);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
 __attribute__((convergent)) int64_t2 WaveActiveSum(int64_t2);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
 __attribute__((convergent)) int64_t3 WaveActiveSum(int64_t3);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
 __attribute__((convergent)) int64_t4 WaveActiveSum(int64_t4);
 
+_HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
 __attribute__((convergent)) uint64_t WaveActiveSum(uint64_t);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
 __attribute__((convergent)) uint64_t2 WaveActiveSum(uint64_t2);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
 __attribute__((convergent)) uint64_t3 WaveActiveSum(uint64_t3);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
 __attribute__((convergent)) uint64_t4 WaveActiveSum(uint64_t4);
 
+_HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
 __attribute__((convergent)) float WaveActiveSum(float);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
 __attribute__((convergent)) float2 WaveActiveSum(float2);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
 __attribute__((convergent)) float3 WaveActiveSum(float3);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
 __attribute__((convergent)) float4 WaveActiveSum(float4);
 
+_HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
 __attribute__((convergent)) double WaveActiveSum(double);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
 __attribute__((convergent)) double2 WaveActiveSum(double2);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
 __attribute__((convergent)) double3 WaveActiveSum(double3);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
 __attribute__((convergent)) double4 WaveActiveSum(double4);
 
-//===----------------------------------------------------------------------===//
-// sign builtins
-//===----------------------------------------------------------------------===//
+/// \brief Returns the number of lanes in the current wave.
+// WaveGetLaneCount overloads
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_get_lane_count)
+__attribute__((convergent)) uint WaveGetLaneCount();
 
-/// \fn T sign(T Val)
-/// \brief Returns -1 if \a Val is less than zero; 0 if \a Val equals zero; and
-/// 1 if \a Val is greater than zero. \param Val The input value.
+/// \brief Returns the index of the current lane within the current wave.
+// WaveGetLaneIndex overloads
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_get_lane_index)
+__attribute__((convergent)) uint WaveGetLaneIndex();
+
+/// \brief Returns true if the current lane is the first active lane in the wave.
+// WaveIsFirstLane overloads
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_is_first_lane)
+__attribute__((convergent)) bool WaveIsFirstLane();
+
+/// \brief Returns the count of bits of Expr set to 1 on prior lanes.
+/// \param Expr The boolean expression to evaluate.
+/// \return the count of bits set to 1 on prior lanes.
+// WavePrefixCountBits overloads
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_count_bits)
+__attribute__((convergent)) uint WavePrefixCountBits(bool);
+
+/// \brief Returns the product of values across lanes with smaller indices in the wave.
+/// \param Val The input value.
+// WavePrefixProduct overloads
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_product)
+__attribute__((convergent)) half WavePrefixProduct(half);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_product)
+__attribute__((convergent)) half2 WavePrefixProduct(half2);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_product)
+__attribute__((convergent)) half3 WavePrefixProduct(half3);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_product)
+__attribute__((convergent)) half4 WavePrefixProduct(half4);
 
 #ifdef __HLSL_ENABLE_16_BIT
 _HLSL_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
-int sign(int16_t);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_product)
+__attribute__((convergent)) int16_t WavePrefixProduct(int16_t);
 _HLSL_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
-int2 sign(int16_t2);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_product)
+__attribute__((convergent)) int16_t2 WavePrefixProduct(int16_t2);
 _HLSL_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
-int3 sign(int16_t3);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_product)
+__attribute__((convergent)) int16_t3 WavePrefixProduct(int16_t3);
 _HLSL_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
-int4 sign(int16_t4);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_product)
+__attribute__((convergent)) int16_t4 WavePrefixProduct(int16_t4);
 
 _HLSL_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
-int sign(uint16_t);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_product)
+__attribute__((convergent)) uint16_t WavePrefixProduct(uint16_t);
 _HLSL_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
-int2 sign(uint16_t2);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_product)
+__attribute__((convergent)) uint16_t2 WavePrefixProduct(uint16_t2);
 _HLSL_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
-int3 sign(uint16_t3);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_product)
+__attribute__((convergent)) uint16_t3 WavePrefixProduct(uint16_t3);
 _HLSL_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
-int4 sign(uint16_t4);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_product)
+__attribute__((convergent)) uint16_t4 WavePrefixProduct(uint16_t4);
 #endif
 
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
-int sign(half);
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
-int2 sign(half2);
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
-int3 sign(half3);
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
-int4 sign(half4);
-
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
-int sign(int);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
-int2 sign(int2);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
-int3 sign(int3);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
-int4 sign(int4);
-
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
-int sign(uint);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
-int2 sign(uint2);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
-int3 sign(uint3);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
-int4 sign(uint4);
-
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
-int sign(float);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
-int2 sign(float2);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
-int3 sign(float3);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
-int4 sign(float4);
-
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
-int sign(int64_t);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
-int2 sign(int64_t2);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
-int3 sign(int64_t3);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
-int4 sign(int64_t4);
-
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
-int sign(uint64_t);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
-int2 sign(uint64_t2);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
-int3 sign(uint64_t3);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
-int4 sign(uint64_t4);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_product)
+__attribute__((convergent)) int WavePrefixProduct(int);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_product)
+__attribute__((convergent)) int2 WavePrefixProduct(int2);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_product)
+__attribute__((convergent)) int3 WavePrefixProduct(int3);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_product)
+__attribute__((convergent)) int4 WavePrefixProduct(int4);
 
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
-int sign(double);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
-int2 sign(double2);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
-int3 sign(double3);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
-int4 sign(double4);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_product)
+__attribute__((convergent)) uint WavePrefixProduct(uint);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_product)
+__attribute__((convergent)) uint2 WavePrefixProduct(uint2);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_product)
+__attribute__((convergent)) uint3 WavePrefixProduct(uint3);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_product)
+__attribute__((convergent)) uint4 WavePrefixProduct(uint4);
 
-//===----------------------------------------------------------------------===//
-// radians builtins
-//===----------------------------------------------------------------------===//
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_product)
+__attribute__((convergent)) int64_t WavePrefixProduct(int64_t);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_product)
+__attribute__((convergent)) int64_t2 WavePrefixProduct(int64_t2);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_product)
+__attribute__((convergent)) int64_t3 WavePrefixProduct(int64_t3);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_product)
+__attribute__((convergent)) int64_t4 WavePrefixProduct(int64_t4);
 
-/// \fn T radians(T Val)
-/// \brief Converts the specified value from degrees to radians.
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_product)
+__attribute__((convergent)) uint64_t WavePrefixProduct(uint64_t);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_product)
+__attribute__((convergent)) uint64_t2 WavePrefixProduct(uint64_t2);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_product)
+__attribute__((convergent)) uint64_t3 WavePrefixProduct(uint64_t3);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_product)
+__attribute__((convergent)) uint64_t4 WavePrefixProduct(uint64_t4);
 
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_radians)
-half radians(half);
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_radians)
-half2 radians(half2);
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_radians)
-half3 radians(half3);
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_radians)
-half4 radians(half4);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_product)
+__attribute__((convergent)) float WavePrefixProduct(float);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_product)
+__attribute__((convergent)) float2 WavePrefixProduct(float2);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_product)
+__attribute__((convergent)) float3 WavePrefixProduct(float3);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_product)
+__attribute__((convergent)) float4 WavePrefixProduct(float4);
 
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_radians)
-float radians(float);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_radians)
-float2 radians(float2);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_radians)
-float3 radians(float3);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_radians)
-float4 radians(float4);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_product)
+__attribute__((convergent)) double WavePrefixProduct(double);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_product)
+__attribute__((convergent)) double2 WavePrefixProduct(double2);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_product)
+__attribute__((convergent)) double3 WavePrefixProduct(double3);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_product)
+__attribute__((convergent)) double4 WavePrefixProduct(double4);
 
-//===----------------------------------------------------------------------===//
-// GroupMemoryBarrierWithGroupSync builtins
-//===----------------------------------------------------------------------===//
+/// \brief Returns the sum of values across lanes with smaller indices in the wave.
+/// \param Val The input value.
+// WavePrefixSum overloads
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_sum)
+__attribute__((convergent)) half WavePrefixSum(half);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_sum)
+__attribute__((convergent)) half2 WavePrefixSum(half2);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_sum)
+__attribute__((convergent)) half3 WavePrefixSum(half3);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_sum)
+__attribute__((convergent)) half4 WavePrefixSum(half4);
 
-/// \fn void GroupMemoryBarrierWithGroupSync(void)
-/// \brief Blocks execution of all threads in a group until all group shared
-/// accesses have been completed and all threads in the group have reached this
-/// call.
+#ifdef __HLSL_ENABLE_16_BIT
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_sum)
+__attribute__((convergent)) int16_t WavePrefixSum(int16_t);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_sum)
+__attribute__((convergent)) int16_t2 WavePrefixSum(int16_t2);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_sum)
+__attribute__((convergent)) int16_t3 WavePrefixSum(int16_t3);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_sum)
+__attribute__((convergent)) int16_t4 WavePrefixSum(int16_t4);
 
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_group_memory_barrier_with_group_sync)
-__attribute__((convergent)) void GroupMemoryBarrierWithGroupSync(void);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_sum)
+__attribute__((convergent)) uint16_t WavePrefixSum(uint16_t);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_sum)
+__attribute__((convergent)) uint16_t2 WavePrefixSum(uint16_t2);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_sum)
+__attribute__((convergent)) uint16_t3 WavePrefixSum(uint16_t3);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_sum)
+__attribute__((convergent)) uint16_t4 WavePrefixSum(uint16_t4);
+#endif
 
-//===----------------------------------------------------------------------===//
-// ddx_coarse builtin
-//===----------------------------------------------------------------------===//
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_sum)
+__attribute__((convergent)) int WavePrefixSum(int);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_sum)
+__attribute__((convergent)) int2 WavePrefixSum(int2);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_sum)
+__attribute__((convergent)) int3 WavePrefixSum(int3);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_sum)
+__attribute__((convergent)) int4 WavePrefixSum(int4);
 
-/// \fn T ddx_coarse(T value)
-/// \brief Computes a low precision partial derivative with respect to the
-/// screen-space x-coordinate.
-/// \param value The input value.
-///
-/// The return value is a floating point scalar or vector containing the low
-/// prevision partial derivative of the input value.
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_sum)
+__attribute__((convergent)) uint WavePrefixSum(uint);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_sum)
+__attribute__((convergent)) uint2 WavePrefixSum(uint2);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_sum)
+__attribute__((convergent)) uint3 WavePrefixSum(uint3);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_sum)
+__attribute__((convergent)) uint4 WavePrefixSum(uint4);
 
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddx_coarse)
-half ddx_coarse(half);
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddx_coarse)
-half2 ddx_coarse(half2);
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddx_coarse)
-half3 ddx_coarse(half3);
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddx_coarse)
-half4 ddx_coarse(half4);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_sum)
+__attribute__((convergent)) int64_t WavePrefixSum(int64_t);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_sum)
+__attribute__((convergent)) int64_t2 WavePrefixSum(int64_t2);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_sum)
+__attribute__((convergent)) int64_t3 WavePrefixSum(int64_t3);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_sum)
+__attribute__((convergent)) int64_t4 WavePrefixSum(int64_t4);
 
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddx_coarse)
-float ddx_coarse(float);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddx_coarse)
-float2 ddx_coarse(float2);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddx_coarse)
-float3 ddx_coarse(float3);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddx_coarse)
-float4 ddx_coarse(float4);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_sum)
+__attribute__((convergent)) uint64_t WavePrefixSum(uint64_t);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_sum)
+__attribute__((convergent)) uint64_t2 WavePrefixSum(uint64_t2);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_sum)
+__attribute__((convergent)) uint64_t3 WavePrefixSum(uint64_t3);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_sum)
+__attribute__((convergent)) uint64_t4 WavePrefixSum(uint64_t4);
 
-//===----------------------------------------------------------------------===//
-// ddy_coarse builtin
-//===----------------------------------------------------------------------===//
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_sum)
+__attribute__((convergent)) float WavePrefixSum(float);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_sum)
+__attribute__((convergent)) float2 WavePrefixSum(float2);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_sum)
+__attribute__((convergent)) float3 WavePrefixSum(float3);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_sum)
+__attribute__((convergent)) float4 WavePrefixSum(float4);
 
-/// \fn T ddy_coarse(T value)
-/// \brief Computes a low precision partial derivative with respect to the
-/// screen-space y-coordinate.
-/// \param value The input value.
-///
-/// The return value is a floating point scalar or vector containing the low
-/// prevision partial derivative of the input value.
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_sum)
+__attribute__((convergent)) double WavePrefixSum(double);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_sum)
+__attribute__((convergent)) double2 WavePrefixSum(double2);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_sum)
+__attribute__((convergent)) double3 WavePrefixSum(double3);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_prefix_sum)
+__attribute__((convergent)) double4 WavePrefixSum(double4);
 
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddy_coarse)
-half ddy_coarse(half);
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddy_coarse)
-half2 ddy_coarse(half2);
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddy_coarse)
-half3 ddy_coarse(half3);
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddy_coarse)
-half4 ddy_coarse(half4);
+/// \brief Returns the value of the expression for the given lane index within
+/// the specified wave.
+/// \param Val The value to read.
+/// \param Index The lane index.
+// WaveReadLaneAt overloads
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
+__attribute__((convergent)) half WaveReadLaneAt(half, uint);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
+__attribute__((convergent)) half2 WaveReadLaneAt(half2, uint);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
+__attribute__((convergent)) half3 WaveReadLaneAt(half3, uint);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
+__attribute__((convergent)) half4 WaveReadLaneAt(half4, uint);
 
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddy_coarse)
-float ddy_coarse(float);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddy_coarse)
-float2 ddy_coarse(float2);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddy_coarse)
-float3 ddy_coarse(float3);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddy_coarse)
-float4 ddy_coarse(float4);
+#ifdef __HLSL_ENABLE_16_BIT
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
+__attribute__((convergent)) int16_t WaveReadLaneAt(int16_t, uint);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
+__attribute__((convergent)) int16_t2 WaveReadLaneAt(int16_t2, uint);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
+__attribute__((convergent)) int16_t3 WaveReadLaneAt(int16_t3, uint);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
+__attribute__((convergent)) int16_t4 WaveReadLaneAt(int16_t4, uint);
 
-//===----------------------------------------------------------------------===//
-// ddx_fine builtin
-//===----------------------------------------------------------------------===//
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
+__attribute__((convergent)) uint16_t WaveReadLaneAt(uint16_t, uint);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
+__attribute__((convergent)) uint16_t2 WaveReadLaneAt(uint16_t2, uint);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
+__attribute__((convergent)) uint16_t3 WaveReadLaneAt(uint16_t3, uint);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
+__attribute__((convergent)) uint16_t4 WaveReadLaneAt(uint16_t4, uint);
+#endif
 
-/// \fn T ddx_fine(T value)
-/// \brief Computes a high precision partial derivative with respect to the
-/// screen-space x-coordinate.
-/// \param value The input value.
-///
-/// The return value is a floating point scalar or vector containing the high
-/// prevision partial derivative of the input value.
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
+__attribute__((convergent)) bool WaveReadLaneAt(bool, uint);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
+__attribute__((convergent)) bool2 WaveReadLaneAt(bool2, uint);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
+__attribute__((convergent)) bool3 WaveReadLaneAt(bool3, uint);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
+__attribute__((convergent)) bool4 WaveReadLaneAt(bool4, uint);
 
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddx_fine)
-half ddx_fine(half);
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddx_fine)
-half2 ddx_fine(half2);
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddx_fine)
-half3 ddx_fine(half3);
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddx_fine)
-half4 ddx_fine(half4);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
+__attribute__((convergent)) int WaveReadLaneAt(int, uint);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
+__attribute__((convergent)) int2 WaveReadLaneAt(int2, uint);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
+__attribute__((convergent)) int3 WaveReadLaneAt(int3, uint);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
+__attribute__((convergent)) int4 WaveReadLaneAt(int4, uint);
 
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddx_fine)
-float ddx_fine(float);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddx_fine)
-float2 ddx_fine(float2);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddx_fine)
-float3 ddx_fine(float3);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddx_fine)
-float4 ddx_fine(float4);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
+__attribute__((convergent)) uint WaveReadLaneAt(uint, uint);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
+__attribute__((convergent)) uint2 WaveReadLaneAt(uint2, uint);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
+__attribute__((convergent)) uint3 WaveReadLaneAt(uint3, uint);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
+__attribute__((convergent)) uint4 WaveReadLaneAt(uint4, uint);
 
-//===----------------------------------------------------------------------===//
-// ddy_fine builtin
-//===----------------------------------------------------------------------===//
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
+__attribute__((convergent)) int64_t WaveReadLaneAt(int64_t, uint);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
+__attribute__((convergent)) int64_t2 WaveReadLaneAt(int64_t2, uint);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
+__attribute__((convergent)) int64_t3 WaveReadLaneAt(int64_t3, uint);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
+__attribute__((convergent)) int64_t4 WaveReadLaneAt(int64_t4, uint);
 
-/// \fn T ddy_fine(T value)
-/// \brief Computes a high precision partial derivative with respect to the
-/// screen-space y-coordinate.
-/// \param value The input value.
-///
-/// The return value is a floating point scalar or vector containing the high
-/// prevision partial derivative of the input value.
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
+__attribute__((convergent)) uint64_t WaveReadLaneAt(uint64_t, uint);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
+__attribute__((convergent)) uint64_t2 WaveReadLaneAt(uint64_t2, uint);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
+__attribute__((convergent)) uint64_t3 WaveReadLaneAt(uint64_t3, uint);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
+__attribute__((convergent)) uint64_t4 WaveReadLaneAt(uint64_t4, uint);
 
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddy_fine)
-half ddy_fine(half);
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddy_fine)
-half2 ddy_fine(half2);
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddy_fine)
-half3 ddy_fine(half3);
-_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddy_fine)
-half4 ddy_fine(half4);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
+__attribute__((convergent)) float WaveReadLaneAt(float, uint);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
+__attribute__((convergent)) float2 WaveReadLaneAt(float2, uint);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
+__attribute__((convergent)) float3 WaveReadLaneAt(float3, uint);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
+__attribute__((convergent)) float4 WaveReadLaneAt(float4, uint);
 
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddy_fine)
-float ddy_fine(float);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddy_fine)
-float2 ddy_fine(float2);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddy_fine)
-float3 ddy_fine(float3);
-_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddy_fine)
-float4 ddy_fine(float4);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
+__attribute__((convergent)) double WaveReadLaneAt(double, uint);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
+__attribute__((convergent)) double2 WaveReadLaneAt(double2, uint);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
+__attribute__((convergent)) double3 WaveReadLaneAt(double3, uint);
+_HLSL_AVAILABILITY(shadermodel, 6.0)
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
+__attribute__((convergent)) double4 WaveReadLaneAt(double4, uint);
 
-} // namespace hlsl
-#endif //_HLSL_HLSL_ALIAS_INTRINSICS_H_