brintos / llvm-project-archived public Read only

1//===--- hlsl_alias_intrinsics.h - HLSL alias definitions for intrinsics --===//2//3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.4// See https://llvm.org/LICENSE.txt for license information.5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception6//7//===----------------------------------------------------------------------===//8 9#ifndef _HLSL_HLSL_ALIAS_INTRINSICS_H_10#define _HLSL_HLSL_ALIAS_INTRINSICS_H_11 12namespace hlsl {13 14// Note: Functions in this file are sorted alphabetically, then grouped by base15// element type, and the element types are sorted by size, then singed integer,16// unsigned integer and floating point. Keeping this ordering consistent will17// help keep this file manageable as it grows.18 19#define _HLSL_BUILTIN_ALIAS(builtin)                                           \20  __attribute__((clang_builtin_alias(builtin)))21#define _HLSL_AVAILABILITY(platform, version)                                  \22  __attribute__((availability(platform, introduced = version)))23#define _HLSL_AVAILABILITY_STAGE(platform, version, stage)                     \24  __attribute__((                                                              \25      availability(platform, introduced = version, environment = stage)))26 27#ifdef __HLSL_ENABLE_16_BIT28#define _HLSL_16BIT_AVAILABILITY(platform, version)                            \29  __attribute__((availability(platform, introduced = version)))30#define _HLSL_16BIT_AVAILABILITY_STAGE(platform, version, stage)               \31  __attribute__((                                                              \32      availability(platform, introduced = version, environment = stage)))33#else34#define _HLSL_16BIT_AVAILABILITY(environment, version)35#define _HLSL_16BIT_AVAILABILITY_STAGE(environment, version, stage)36#endif37 38//===----------------------------------------------------------------------===//39// abs builtins40//===----------------------------------------------------------------------===//41 42/// \fn T abs(T Val)43/// \brief Returns the absolute value of the input value, \a Val.44/// \param Val The input value.45 46#ifdef __HLSL_ENABLE_16_BIT47_HLSL_AVAILABILITY(shadermodel, 6.2)48_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)49int16_t abs(int16_t);50_HLSL_AVAILABILITY(shadermodel, 6.2)51_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)52int16_t2 abs(int16_t2);53_HLSL_AVAILABILITY(shadermodel, 6.2)54_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)55int16_t3 abs(int16_t3);56_HLSL_AVAILABILITY(shadermodel, 6.2)57_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)58int16_t4 abs(int16_t4);59 60_HLSL_AVAILABILITY(shadermodel, 6.2)61constexpr uint16_t abs(uint16_t V) { return V; }62_HLSL_AVAILABILITY(shadermodel, 6.2)63constexpr uint16_t2 abs(uint16_t2 V) { return V; }64_HLSL_AVAILABILITY(shadermodel, 6.2)65constexpr uint16_t3 abs(uint16_t3 V) { return V; }66_HLSL_AVAILABILITY(shadermodel, 6.2)67constexpr uint16_t4 abs(uint16_t4 V) { return V; }68#endif69 70_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)71_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)72half abs(half);73_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)74_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)75half2 abs(half2);76_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)77_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)78half3 abs(half3);79_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)80_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)81half4 abs(half4);82 83_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)84int abs(int);85_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)86int2 abs(int2);87_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)88int3 abs(int3);89_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)90int4 abs(int4);91 92constexpr uint abs(uint V) { return V; }93constexpr uint2 abs(uint2 V) { return V; }94constexpr uint3 abs(uint3 V) { return V; }95constexpr uint4 abs(uint4 V) { return V; }96 97_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)98float abs(float);99_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)100float2 abs(float2);101_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)102float3 abs(float3);103_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)104float4 abs(float4);105 106_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)107int64_t abs(int64_t);108_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)109int64_t2 abs(int64_t2);110_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)111int64_t3 abs(int64_t3);112_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)113int64_t4 abs(int64_t4);114 115constexpr uint64_t abs(uint64_t V) { return V; }116constexpr uint64_t2 abs(uint64_t2 V) { return V; }117constexpr uint64_t3 abs(uint64_t3 V) { return V; }118constexpr uint64_t4 abs(uint64_t4 V) { return V; }119 120_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)121double abs(double);122_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)123double2 abs(double2);124_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)125double3 abs(double3);126_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)127double4 abs(double4);128 129//===----------------------------------------------------------------------===//130// acos builtins131//===----------------------------------------------------------------------===//132 133/// \fn T acos(T Val)134/// \brief Returns the arccosine of the input value, \a Val.135/// \param Val The input value.136 137_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)138_HLSL_BUILTIN_ALIAS(__builtin_elementwise_acos)139half acos(half);140_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)141_HLSL_BUILTIN_ALIAS(__builtin_elementwise_acos)142half2 acos(half2);143_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)144_HLSL_BUILTIN_ALIAS(__builtin_elementwise_acos)145half3 acos(half3);146_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)147_HLSL_BUILTIN_ALIAS(__builtin_elementwise_acos)148half4 acos(half4);149 150_HLSL_BUILTIN_ALIAS(__builtin_elementwise_acos)151float acos(float);152_HLSL_BUILTIN_ALIAS(__builtin_elementwise_acos)153float2 acos(float2);154_HLSL_BUILTIN_ALIAS(__builtin_elementwise_acos)155float3 acos(float3);156_HLSL_BUILTIN_ALIAS(__builtin_elementwise_acos)157float4 acos(float4);158 159//===----------------------------------------------------------------------===//160// AddUint64 builtins161//===----------------------------------------------------------------------===//162 163/// \fn T AddUint64(T a, T b)164/// \brief Implements unsigned 64-bit integer addition using pairs of unsigned165/// 32-bit integers.166/// \param x [in] The first unsigned 32-bit integer pair(s)167/// \param y [in] The second unsigned 32-bit integer pair(s)168///169/// This function takes one or two pairs (low, high) of unsigned 32-bit integer170/// values and returns pairs (low, high) of unsigned 32-bit integer171/// values representing the result of unsigned 64-bit integer addition.172 173_HLSL_AVAILABILITY(shadermodel, 6.0)174_HLSL_BUILTIN_ALIAS(__builtin_hlsl_adduint64)175uint32_t2 AddUint64(uint32_t2, uint32_t2);176_HLSL_AVAILABILITY(shadermodel, 6.0)177_HLSL_BUILTIN_ALIAS(__builtin_hlsl_adduint64)178uint32_t4 AddUint64(uint32_t4, uint32_t4);179 180//===----------------------------------------------------------------------===//181// all builtins182//===----------------------------------------------------------------------===//183 184/// \fn bool all(T x)185/// \brief Returns True if all components of the \a x parameter are non-zero;186/// otherwise, false. \param x The input value.187 188#ifdef __HLSL_ENABLE_16_BIT189_HLSL_AVAILABILITY(shadermodel, 6.2)190_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)191bool all(int16_t);192_HLSL_AVAILABILITY(shadermodel, 6.2)193_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)194bool all(int16_t2);195_HLSL_AVAILABILITY(shadermodel, 6.2)196_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)197bool all(int16_t3);198_HLSL_AVAILABILITY(shadermodel, 6.2)199_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)200bool all(int16_t4);201_HLSL_AVAILABILITY(shadermodel, 6.2)202_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)203bool all(uint16_t);204_HLSL_AVAILABILITY(shadermodel, 6.2)205_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)206bool all(uint16_t2);207_HLSL_AVAILABILITY(shadermodel, 6.2)208_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)209bool all(uint16_t3);210_HLSL_AVAILABILITY(shadermodel, 6.2)211_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)212bool all(uint16_t4);213#endif214 215_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)216_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)217bool all(half);218_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)219_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)220bool all(half2);221_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)222_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)223bool all(half3);224_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)225_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)226bool all(half4);227 228_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)229bool all(bool);230_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)231bool all(bool2);232_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)233bool all(bool3);234_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)235bool all(bool4);236_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)237 238_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)239bool all(int);240_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)241bool all(int2);242_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)243bool all(int3);244_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)245bool all(int4);246 247_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)248bool all(uint);249_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)250bool all(uint2);251_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)252bool all(uint3);253_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)254bool all(uint4);255 256_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)257bool all(float);258_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)259bool all(float2);260_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)261bool all(float3);262_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)263bool all(float4);264 265_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)266bool all(int64_t);267_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)268bool all(int64_t2);269_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)270bool all(int64_t3);271_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)272bool all(int64_t4);273 274_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)275bool all(uint64_t);276_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)277bool all(uint64_t2);278_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)279bool all(uint64_t3);280_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)281bool all(uint64_t4);282 283_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)284bool all(double);285_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)286bool all(double2);287_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)288bool all(double3);289_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)290bool all(double4);291 292//===----------------------------------------------------------------------===//293// and builtins294//===----------------------------------------------------------------------===//295 296/// \fn bool and(bool x, bool y)297/// \brief Logically ands two boolean vectors elementwise and produces a bool298/// vector output.299 300// TODO: Clean up clang-format marker once we've resolved301//       https://github.com/llvm/llvm-project/issues/127851302//303// clang-format off304_HLSL_BUILTIN_ALIAS(__builtin_hlsl_and)305bool and(bool x, bool y);306_HLSL_BUILTIN_ALIAS(__builtin_hlsl_and)307bool2 and(bool2 x, bool2 y);308_HLSL_BUILTIN_ALIAS(__builtin_hlsl_and)309bool3 and(bool3 x, bool3 y);310_HLSL_BUILTIN_ALIAS(__builtin_hlsl_and)311bool4 and(bool4 x, bool4 y);312// clang-format on313 314//===----------------------------------------------------------------------===//315// any builtins316//===----------------------------------------------------------------------===//317 318/// \fn bool any(T x)319/// \brief Returns True if any components of the \a x parameter are non-zero;320/// otherwise, false. \param x The input value.321 322#ifdef __HLSL_ENABLE_16_BIT323_HLSL_AVAILABILITY(shadermodel, 6.2)324_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)325bool any(int16_t);326_HLSL_AVAILABILITY(shadermodel, 6.2)327_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)328bool any(int16_t2);329_HLSL_AVAILABILITY(shadermodel, 6.2)330_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)331bool any(int16_t3);332_HLSL_AVAILABILITY(shadermodel, 6.2)333_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)334bool any(int16_t4);335_HLSL_AVAILABILITY(shadermodel, 6.2)336_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)337bool any(uint16_t);338_HLSL_AVAILABILITY(shadermodel, 6.2)339_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)340bool any(uint16_t2);341_HLSL_AVAILABILITY(shadermodel, 6.2)342_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)343bool any(uint16_t3);344_HLSL_AVAILABILITY(shadermodel, 6.2)345_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)346bool any(uint16_t4);347#endif348 349_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)350_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)351bool any(half);352_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)353_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)354bool any(half2);355_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)356_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)357bool any(half3);358_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)359_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)360bool any(half4);361 362_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)363bool any(bool);364_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)365bool any(bool2);366_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)367bool any(bool3);368_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)369bool any(bool4);370_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)371 372_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)373bool any(int);374_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)375bool any(int2);376_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)377bool any(int3);378_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)379bool any(int4);380 381_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)382bool any(uint);383_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)384bool any(uint2);385_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)386bool any(uint3);387_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)388bool any(uint4);389 390_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)391bool any(float);392_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)393bool any(float2);394_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)395bool any(float3);396_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)397bool any(float4);398 399_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)400bool any(int64_t);401_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)402bool any(int64_t2);403_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)404bool any(int64_t3);405_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)406bool any(int64_t4);407 408_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)409bool any(uint64_t);410_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)411bool any(uint64_t2);412_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)413bool any(uint64_t3);414_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)415bool any(uint64_t4);416 417_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)418bool any(double);419_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)420bool any(double2);421_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)422bool any(double3);423_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)424bool any(double4);425 426//===----------------------------------------------------------------------===//427// asdouble builtins428//===----------------------------------------------------------------------===//429 430/// \fn double asdouble(uint LowBits, uint HighBits)431/// \brief Reinterprets a cast value (two 32-bit values) into a double.432/// \param LowBits The low 32-bit pattern of the input value.433/// \param HighBits The high 32-bit pattern of the input value.434 435_HLSL_BUILTIN_ALIAS(__builtin_hlsl_asdouble)436double asdouble(uint, uint);437_HLSL_BUILTIN_ALIAS(__builtin_hlsl_asdouble)438double2 asdouble(uint2, uint2);439_HLSL_BUILTIN_ALIAS(__builtin_hlsl_asdouble)440double3 asdouble(uint3, uint3);441_HLSL_BUILTIN_ALIAS(__builtin_hlsl_asdouble)442double4 asdouble(uint4, uint4);443 444//===----------------------------------------------------------------------===//445// asin builtins446//===----------------------------------------------------------------------===//447 448/// \fn T asin(T Val)449/// \brief Returns the arcsine of the input value, \a Val.450/// \param Val The input value.451 452_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)453_HLSL_BUILTIN_ALIAS(__builtin_elementwise_asin)454half asin(half);455_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)456_HLSL_BUILTIN_ALIAS(__builtin_elementwise_asin)457half2 asin(half2);458_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)459_HLSL_BUILTIN_ALIAS(__builtin_elementwise_asin)460half3 asin(half3);461_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)462_HLSL_BUILTIN_ALIAS(__builtin_elementwise_asin)463half4 asin(half4);464 465_HLSL_BUILTIN_ALIAS(__builtin_elementwise_asin)466float asin(float);467_HLSL_BUILTIN_ALIAS(__builtin_elementwise_asin)468float2 asin(float2);469_HLSL_BUILTIN_ALIAS(__builtin_elementwise_asin)470float3 asin(float3);471_HLSL_BUILTIN_ALIAS(__builtin_elementwise_asin)472float4 asin(float4);473 474//===----------------------------------------------------------------------===//475// atan builtins476//===----------------------------------------------------------------------===//477 478/// \fn T atan(T Val)479/// \brief Returns the arctangent of the input value, \a Val.480/// \param Val The input value.481 482_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)483_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan)484half atan(half);485_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)486_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan)487half2 atan(half2);488_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)489_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan)490half3 atan(half3);491_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)492_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan)493half4 atan(half4);494 495_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan)496float atan(float);497_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan)498float2 atan(float2);499_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan)500float3 atan(float3);501_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan)502float4 atan(float4);503 504//===----------------------------------------------------------------------===//505// atan2 builtins506//===----------------------------------------------------------------------===//507 508/// \fn T atan2(T y, T x)509/// \brief Returns the arctangent of y/x, using the signs of the arguments to510/// determine the correct quadrant.511/// \param y The y-coordinate.512/// \param x The x-coordinate.513 514_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)515_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)516half atan2(half y, half x);517_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)518_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)519half2 atan2(half2 y, half2 x);520_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)521_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)522half3 atan2(half3 y, half3 x);523_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)524_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)525half4 atan2(half4 y, half4 x);526 527_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)528float atan2(float y, float x);529_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)530float2 atan2(float2 y, float2 x);531_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)532float3 atan2(float3 y, float3 x);533_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)534float4 atan2(float4 y, float4 x);535 536//===----------------------------------------------------------------------===//537// ceil builtins538//===----------------------------------------------------------------------===//539 540/// \fn T ceil(T Val)541/// \brief Returns the smallest integer value that is greater than or equal to542/// the input value, \a Val.543/// \param Val The input value.544 545_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)546_HLSL_BUILTIN_ALIAS(__builtin_elementwise_ceil)547half ceil(half);548_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)549_HLSL_BUILTIN_ALIAS(__builtin_elementwise_ceil)550half2 ceil(half2);551_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)552_HLSL_BUILTIN_ALIAS(__builtin_elementwise_ceil)553half3 ceil(half3);554_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)555_HLSL_BUILTIN_ALIAS(__builtin_elementwise_ceil)556half4 ceil(half4);557 558_HLSL_BUILTIN_ALIAS(__builtin_elementwise_ceil)559float ceil(float);560_HLSL_BUILTIN_ALIAS(__builtin_elementwise_ceil)561float2 ceil(float2);562_HLSL_BUILTIN_ALIAS(__builtin_elementwise_ceil)563float3 ceil(float3);564_HLSL_BUILTIN_ALIAS(__builtin_elementwise_ceil)565float4 ceil(float4);566 567//===----------------------------------------------------------------------===//568// clamp builtins569//===----------------------------------------------------------------------===//570 571/// \fn T clamp(T X, T Min, T Max)572/// \brief Clamps the specified value \a X to the specified573/// minimum ( \a Min) and maximum ( \a Max) range.574/// \param X A value to clamp.575/// \param Min The specified minimum range.576/// \param Max The specified maximum range.577///578/// Returns The clamped value for the \a X parameter.579/// For values of -INF or INF, clamp will behave as expected.580/// However for values of NaN, the results are undefined.581 582_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)583_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)584half clamp(half, half, half);585_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)586_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)587half2 clamp(half2, half2, half2);588_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)589_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)590half3 clamp(half3, half3, half3);591_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)592_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)593half4 clamp(half4, half4, half4);594 595#ifdef __HLSL_ENABLE_16_BIT596_HLSL_AVAILABILITY(shadermodel, 6.2)597_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)598int16_t clamp(int16_t, int16_t, int16_t);599_HLSL_AVAILABILITY(shadermodel, 6.2)600_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)601int16_t2 clamp(int16_t2, int16_t2, int16_t2);602_HLSL_AVAILABILITY(shadermodel, 6.2)603_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)604int16_t3 clamp(int16_t3, int16_t3, int16_t3);605_HLSL_AVAILABILITY(shadermodel, 6.2)606_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)607int16_t4 clamp(int16_t4, int16_t4, int16_t4);608 609_HLSL_AVAILABILITY(shadermodel, 6.2)610_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)611uint16_t clamp(uint16_t, uint16_t, uint16_t);612_HLSL_AVAILABILITY(shadermodel, 6.2)613_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)614uint16_t2 clamp(uint16_t2, uint16_t2, uint16_t2);615_HLSL_AVAILABILITY(shadermodel, 6.2)616_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)617uint16_t3 clamp(uint16_t3, uint16_t3, uint16_t3);618_HLSL_AVAILABILITY(shadermodel, 6.2)619_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)620uint16_t4 clamp(uint16_t4, uint16_t4, uint16_t4);621#endif622 623_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)624int clamp(int, int, int);625_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)626int2 clamp(int2, int2, int2);627_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)628int3 clamp(int3, int3, int3);629_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)630int4 clamp(int4, int4, int4);631 632_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)633uint clamp(uint, uint, uint);634_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)635uint2 clamp(uint2, uint2, uint2);636_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)637uint3 clamp(uint3, uint3, uint3);638_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)639uint4 clamp(uint4, uint4, uint4);640 641_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)642int64_t clamp(int64_t, int64_t, int64_t);643_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)644int64_t2 clamp(int64_t2, int64_t2, int64_t2);645_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)646int64_t3 clamp(int64_t3, int64_t3, int64_t3);647_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)648int64_t4 clamp(int64_t4, int64_t4, int64_t4);649 650_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)651uint64_t clamp(uint64_t, uint64_t, uint64_t);652_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)653uint64_t2 clamp(uint64_t2, uint64_t2, uint64_t2);654_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)655uint64_t3 clamp(uint64_t3, uint64_t3, uint64_t3);656_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)657uint64_t4 clamp(uint64_t4, uint64_t4, uint64_t4);658 659_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)660float clamp(float, float, float);661_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)662float2 clamp(float2, float2, float2);663_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)664float3 clamp(float3, float3, float3);665_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)666float4 clamp(float4, float4, float4);667 668_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)669double clamp(double, double, double);670_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)671double2 clamp(double2, double2, double2);672_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)673double3 clamp(double3, double3, double3);674_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)675double4 clamp(double4, double4, double4);676 677//===----------------------------------------------------------------------===//678// clip builtins679//===----------------------------------------------------------------------===//680 681/// \fn void clip(T Val)682/// \brief Discards the current pixel if the specified value is less than zero.683/// \param Val The input value.684 685_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clip)686void clip(float);687_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clip)688void clip(float2);689_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clip)690void clip(float3);691_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clip)692void clip(float4);693 694//===----------------------------------------------------------------------===//695// cos builtins696//===----------------------------------------------------------------------===//697 698/// \fn T cos(T Val)699/// \brief Returns the cosine of the input value, \a Val.700/// \param Val The input value.701 702_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)703_HLSL_BUILTIN_ALIAS(__builtin_elementwise_cos)704half cos(half);705_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)706_HLSL_BUILTIN_ALIAS(__builtin_elementwise_cos)707half2 cos(half2);708_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)709_HLSL_BUILTIN_ALIAS(__builtin_elementwise_cos)710half3 cos(half3);711_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)712_HLSL_BUILTIN_ALIAS(__builtin_elementwise_cos)713half4 cos(half4);714 715_HLSL_BUILTIN_ALIAS(__builtin_elementwise_cos)716float cos(float);717_HLSL_BUILTIN_ALIAS(__builtin_elementwise_cos)718float2 cos(float2);719_HLSL_BUILTIN_ALIAS(__builtin_elementwise_cos)720float3 cos(float3);721_HLSL_BUILTIN_ALIAS(__builtin_elementwise_cos)722float4 cos(float4);723 724//===----------------------------------------------------------------------===//725// cosh builtins726//===----------------------------------------------------------------------===//727 728/// \fn T cosh(T Val)729/// \brief Returns the hyperbolic cosine of the input value, \a Val.730/// \param Val The input value.731 732_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)733_HLSL_BUILTIN_ALIAS(__builtin_elementwise_cosh)734half cosh(half);735_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)736_HLSL_BUILTIN_ALIAS(__builtin_elementwise_cosh)737half2 cosh(half2);738_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)739_HLSL_BUILTIN_ALIAS(__builtin_elementwise_cosh)740half3 cosh(half3);741_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)742_HLSL_BUILTIN_ALIAS(__builtin_elementwise_cosh)743half4 cosh(half4);744 745_HLSL_BUILTIN_ALIAS(__builtin_elementwise_cosh)746float cosh(float);747_HLSL_BUILTIN_ALIAS(__builtin_elementwise_cosh)748float2 cosh(float2);749_HLSL_BUILTIN_ALIAS(__builtin_elementwise_cosh)750float3 cosh(float3);751_HLSL_BUILTIN_ALIAS(__builtin_elementwise_cosh)752float4 cosh(float4);753 754//===----------------------------------------------------------------------===//755// count bits builtins756//===----------------------------------------------------------------------===//757 758/// \fn T countbits(T Val)759/// \brief Return the number of bits (per component) set in the input integer.760/// \param Val The input value.761 762#ifdef __HLSL_ENABLE_16_BIT763_HLSL_AVAILABILITY(shadermodel, 6.2)764const inline uint countbits(int16_t x) {765  return __builtin_elementwise_popcount(x);766}767_HLSL_AVAILABILITY(shadermodel, 6.2)768const inline uint2 countbits(int16_t2 x) {769  return __builtin_elementwise_popcount(x);770}771_HLSL_AVAILABILITY(shadermodel, 6.2)772const inline uint3 countbits(int16_t3 x) {773  return __builtin_elementwise_popcount(x);774}775_HLSL_AVAILABILITY(shadermodel, 6.2)776const inline uint4 countbits(int16_t4 x) {777  return __builtin_elementwise_popcount(x);778}779_HLSL_AVAILABILITY(shadermodel, 6.2)780const inline uint countbits(uint16_t x) {781  return __builtin_elementwise_popcount(x);782}783_HLSL_AVAILABILITY(shadermodel, 6.2)784const inline uint2 countbits(uint16_t2 x) {785  return __builtin_elementwise_popcount(x);786}787_HLSL_AVAILABILITY(shadermodel, 6.2)788const inline uint3 countbits(uint16_t3 x) {789  return __builtin_elementwise_popcount(x);790}791_HLSL_AVAILABILITY(shadermodel, 6.2)792const inline uint4 countbits(uint16_t4 x) {793  return __builtin_elementwise_popcount(x);794}795#endif796 797const inline uint countbits(int x) { return __builtin_elementwise_popcount(x); }798const inline uint2 countbits(int2 x) {799  return __builtin_elementwise_popcount(x);800}801const inline uint3 countbits(int3 x) {802  return __builtin_elementwise_popcount(x);803}804const inline uint4 countbits(int4 x) {805  return __builtin_elementwise_popcount(x);806}807 808const inline uint countbits(uint x) {809  return __builtin_elementwise_popcount(x);810}811const inline uint2 countbits(uint2 x) {812  return __builtin_elementwise_popcount(x);813}814const inline uint3 countbits(uint3 x) {815  return __builtin_elementwise_popcount(x);816}817const inline uint4 countbits(uint4 x) {818  return __builtin_elementwise_popcount(x);819}820 821const inline uint countbits(int64_t x) {822  return __builtin_elementwise_popcount(x);823}824const inline uint2 countbits(int64_t2 x) {825  return __builtin_elementwise_popcount(x);826}827const inline uint3 countbits(int64_t3 x) {828  return __builtin_elementwise_popcount(x);829}830const inline uint4 countbits(int64_t4 x) {831  return __builtin_elementwise_popcount(x);832}833 834const inline uint countbits(uint64_t x) {835  return __builtin_elementwise_popcount(x);836}837const inline uint2 countbits(uint64_t2 x) {838  return __builtin_elementwise_popcount(x);839}840const inline uint3 countbits(uint64_t3 x) {841  return __builtin_elementwise_popcount(x);842}843const inline uint4 countbits(uint64_t4 x) {844  return __builtin_elementwise_popcount(x);845}846 847//===----------------------------------------------------------------------===//848// degrees builtins849//===----------------------------------------------------------------------===//850 851/// \fn T degrees(T x)852/// \brief Converts the specified value from radians to degrees.853/// \param x The specified input value.854 855_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)856_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_degrees)857half degrees(half);858_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)859_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_degrees)860half2 degrees(half2);861_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)862_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_degrees)863half3 degrees(half3);864_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)865_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_degrees)866half4 degrees(half4);867 868_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_degrees)869float degrees(float);870_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_degrees)871float2 degrees(float2);872_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_degrees)873float3 degrees(float3);874_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_degrees)875float4 degrees(float4);876 877//===----------------------------------------------------------------------===//878// dot product builtins879//===----------------------------------------------------------------------===//880 881/// \fn K dot(T X, T Y)882/// \brief Return the dot product (a scalar value) of \a X and \a Y.883/// \param X The X input value.884/// \param Y The Y input value.885 886_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)887_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)888half dot(half, half);889_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)890_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)891half dot(half2, half2);892_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)893_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)894half dot(half3, half3);895_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)896_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)897half dot(half4, half4);898 899#ifdef __HLSL_ENABLE_16_BIT900_HLSL_AVAILABILITY(shadermodel, 6.2)901_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)902int16_t dot(int16_t, int16_t);903_HLSL_AVAILABILITY(shadermodel, 6.2)904_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)905int16_t dot(int16_t2, int16_t2);906_HLSL_AVAILABILITY(shadermodel, 6.2)907_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)908int16_t dot(int16_t3, int16_t3);909_HLSL_AVAILABILITY(shadermodel, 6.2)910_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)911int16_t dot(int16_t4, int16_t4);912 913_HLSL_AVAILABILITY(shadermodel, 6.2)914_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)915uint16_t dot(uint16_t, uint16_t);916_HLSL_AVAILABILITY(shadermodel, 6.2)917_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)918uint16_t dot(uint16_t2, uint16_t2);919_HLSL_AVAILABILITY(shadermodel, 6.2)920_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)921uint16_t dot(uint16_t3, uint16_t3);922_HLSL_AVAILABILITY(shadermodel, 6.2)923_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)924uint16_t dot(uint16_t4, uint16_t4);925#endif926 927_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)928float dot(float, float);929_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)930float dot(float2, float2);931_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)932float dot(float3, float3);933_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)934float dot(float4, float4);935 936_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)937double dot(double, double);938 939_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)940int dot(int, int);941_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)942int dot(int2, int2);943_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)944int dot(int3, int3);945_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)946int dot(int4, int4);947 948_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)949uint dot(uint, uint);950_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)951uint dot(uint2, uint2);952_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)953uint dot(uint3, uint3);954_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)955uint dot(uint4, uint4);956 957_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)958int64_t dot(int64_t, int64_t);959_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)960int64_t dot(int64_t2, int64_t2);961_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)962int64_t dot(int64_t3, int64_t3);963_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)964int64_t dot(int64_t4, int64_t4);965 966_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)967uint64_t dot(uint64_t, uint64_t);968_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)969uint64_t dot(uint64_t2, uint64_t2);970_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)971uint64_t dot(uint64_t3, uint64_t3);972_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)973uint64_t dot(uint64_t4, uint64_t4);974 975//===----------------------------------------------------------------------===//976// dot4add builtins977//===----------------------------------------------------------------------===//978 979/// \fn int dot4add_i8packed(uint A, uint B, int C)980 981_HLSL_AVAILABILITY(shadermodel, 6.4)982_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot4add_i8packed)983int dot4add_i8packed(uint, uint, int);984 985/// \fn uint dot4add_u8packed(uint A, uint B, uint C)986 987_HLSL_AVAILABILITY(shadermodel, 6.4)988_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot4add_u8packed)989uint dot4add_u8packed(uint, uint, uint);990 991//===----------------------------------------------------------------------===//992// exp builtins993//===----------------------------------------------------------------------===//994 995/// \fn T exp(T x)996/// \brief Returns the base-e exponential, or \a e**x, of the specified value.997/// \param x The specified input value.998///999/// The return value is the base-e exponential of the \a x parameter.1000 1001_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1002_HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp)1003half exp(half);1004_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1005_HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp)1006half2 exp(half2);1007_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1008_HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp)1009half3 exp(half3);1010_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1011_HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp)1012half4 exp(half4);1013 1014_HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp)1015float exp(float);1016_HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp)1017float2 exp(float2);1018_HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp)1019float3 exp(float3);1020_HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp)1021float4 exp(float4);1022 1023//===----------------------------------------------------------------------===//1024// exp2 builtins1025//===----------------------------------------------------------------------===//1026 1027/// \fn T exp2(T x)1028/// \brief Returns the base 2 exponential, or \a 2**x, of the specified value.1029/// \param x The specified input value.1030///1031/// The base 2 exponential of the \a x parameter.1032 1033_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1034_HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp2)1035half exp2(half);1036_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1037_HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp2)1038half2 exp2(half2);1039_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1040_HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp2)1041half3 exp2(half3);1042_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1043_HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp2)1044half4 exp2(half4);1045 1046_HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp2)1047float exp2(float);1048_HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp2)1049float2 exp2(float2);1050_HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp2)1051float3 exp2(float3);1052_HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp2)1053float4 exp2(float4);1054 1055//===----------------------------------------------------------------------===//1056// f16tof32 builtins1057//===----------------------------------------------------------------------===//1058 1059/// \fn float f16tof32(uint x)1060/// \brief Returns the half value stored in the low 16 bits of the uint arg1061/// converted to a float.1062/// \param x The uint containing two half values.1063///1064/// The float value of the half value found in the low 16 bits of the \a xi1065/// parameter.1066 1067_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_f16tof32)1068float f16tof32(uint);1069_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_f16tof32)1070float2 f16tof32(uint2);1071_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_f16tof32)1072float3 f16tof32(uint3);1073_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_f16tof32)1074float4 f16tof32(uint4);1075 1076//===----------------------------------------------------------------------===//1077// firstbitlow builtins1078//===----------------------------------------------------------------------===//1079 1080/// \fn T firstbitlow(T Val)1081/// \brief Returns the location of the first set bit starting from the lowest1082/// order bit and working upward, per component.1083/// \param Val the input value.1084 1085#ifdef __HLSL_ENABLE_16_BIT1086_HLSL_AVAILABILITY(shadermodel, 6.2)1087_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)1088uint firstbitlow(int16_t);1089_HLSL_AVAILABILITY(shadermodel, 6.2)1090_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)1091uint2 firstbitlow(int16_t2);1092_HLSL_AVAILABILITY(shadermodel, 6.2)1093_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)1094uint3 firstbitlow(int16_t3);1095_HLSL_AVAILABILITY(shadermodel, 6.2)1096_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)1097uint4 firstbitlow(int16_t4);1098_HLSL_AVAILABILITY(shadermodel, 6.2)1099_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)1100uint firstbitlow(uint16_t);1101_HLSL_AVAILABILITY(shadermodel, 6.2)1102_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)1103uint2 firstbitlow(uint16_t2);1104_HLSL_AVAILABILITY(shadermodel, 6.2)1105_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)1106uint3 firstbitlow(uint16_t3);1107_HLSL_AVAILABILITY(shadermodel, 6.2)1108_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)1109uint4 firstbitlow(uint16_t4);1110#endif1111 1112_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)1113uint firstbitlow(int);1114_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)1115uint2 firstbitlow(int2);1116_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)1117uint3 firstbitlow(int3);1118_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)1119uint4 firstbitlow(int4);1120 1121_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)1122uint firstbitlow(uint);1123_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)1124uint2 firstbitlow(uint2);1125_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)1126uint3 firstbitlow(uint3);1127_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)1128uint4 firstbitlow(uint4);1129 1130_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)1131uint firstbitlow(int64_t);1132_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)1133uint2 firstbitlow(int64_t2);1134_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)1135uint3 firstbitlow(int64_t3);1136_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)1137uint4 firstbitlow(int64_t4);1138 1139_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)1140uint firstbitlow(uint64_t);1141_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)1142uint2 firstbitlow(uint64_t2);1143_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)1144uint3 firstbitlow(uint64_t3);1145_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)1146uint4 firstbitlow(uint64_t4);1147 1148//===----------------------------------------------------------------------===//1149// floor builtins1150//===----------------------------------------------------------------------===//1151 1152/// \fn T floor(T Val)1153/// \brief Returns the largest integer that is less than or equal to the input1154/// value, \a Val.1155/// \param Val The input value.1156 1157_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1158_HLSL_BUILTIN_ALIAS(__builtin_elementwise_floor)1159half floor(half);1160_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1161_HLSL_BUILTIN_ALIAS(__builtin_elementwise_floor)1162half2 floor(half2);1163_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1164_HLSL_BUILTIN_ALIAS(__builtin_elementwise_floor)1165half3 floor(half3);1166_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1167_HLSL_BUILTIN_ALIAS(__builtin_elementwise_floor)1168half4 floor(half4);1169 1170_HLSL_BUILTIN_ALIAS(__builtin_elementwise_floor)1171float floor(float);1172_HLSL_BUILTIN_ALIAS(__builtin_elementwise_floor)1173float2 floor(float2);1174_HLSL_BUILTIN_ALIAS(__builtin_elementwise_floor)1175float3 floor(float3);1176_HLSL_BUILTIN_ALIAS(__builtin_elementwise_floor)1177float4 floor(float4);1178 1179//===----------------------------------------------------------------------===//1180// frac builtins1181//===----------------------------------------------------------------------===//1182 1183/// \fn T frac(T x)1184/// \brief Returns the fractional (or decimal) part of x. \a x parameter.1185/// \param x The specified input value.1186///1187/// If \a the return value is greater than or equal to 0 and less than 1.1188 1189_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1190_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_frac)1191half frac(half);1192_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1193_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_frac)1194half2 frac(half2);1195_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1196_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_frac)1197half3 frac(half3);1198_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1199_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_frac)1200half4 frac(half4);1201 1202_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_frac)1203float frac(float);1204_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_frac)1205float2 frac(float2);1206_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_frac)1207float3 frac(float3);1208_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_frac)1209float4 frac(float4);1210 1211//===----------------------------------------------------------------------===//1212// isinf builtins1213//===----------------------------------------------------------------------===//1214 1215/// \fn T isinf(T x)1216/// \brief Determines if the specified value \a x  is infinite.1217/// \param x The specified input value.1218///1219/// Returns a value of the same size as the input, with a value set1220/// to True if the x parameter is +INF or -INF. Otherwise, False.1221 1222_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1223_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_isinf)1224bool isinf(half);1225_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1226_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_isinf)1227bool2 isinf(half2);1228_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1229_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_isinf)1230bool3 isinf(half3);1231_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1232_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_isinf)1233bool4 isinf(half4);1234 1235_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_isinf)1236bool isinf(float);1237_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_isinf)1238bool2 isinf(float2);1239_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_isinf)1240bool3 isinf(float3);1241_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_isinf)1242bool4 isinf(float4);1243 1244//===----------------------------------------------------------------------===//1245// isnan builtins1246//===----------------------------------------------------------------------===//1247 1248/// \fn T isnan(T x)1249/// \brief Determines if the specified value \a x  is Not a Number.1250/// \param x The specified input value.1251///1252/// Returns a value of the same size as the input, with a value set1253/// to True if the x parameter is NaN or QNaN. Otherwise, False.1254 1255_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1256_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_isnan)1257bool isnan(half);1258_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1259_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_isnan)1260bool2 isnan(half2);1261_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1262_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_isnan)1263bool3 isnan(half3);1264_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1265_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_isnan)1266bool4 isnan(half4);1267 1268_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_isnan)1269bool isnan(float);1270_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_isnan)1271bool2 isnan(float2);1272_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_isnan)1273bool3 isnan(float3);1274_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_isnan)1275bool4 isnan(float4);1276 1277//===----------------------------------------------------------------------===//1278// lerp builtins1279//===----------------------------------------------------------------------===//1280 1281/// \fn T lerp(T x, T y, T s)1282/// \brief Returns the linear interpolation of x to y by s.1283/// \param x [in] The first-floating point value.1284/// \param y [in] The second-floating point value.1285/// \param s [in] A value that linearly interpolates between the x parameter and1286/// the y parameter.1287///1288/// Linear interpolation is based on the following formula: x*(1-s) + y*s which1289/// can equivalently be written as x + s(y-x).1290 1291_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1292_HLSL_BUILTIN_ALIAS(__builtin_hlsl_lerp)1293half lerp(half, half, half);1294_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1295_HLSL_BUILTIN_ALIAS(__builtin_hlsl_lerp)1296half2 lerp(half2, half2, half2);1297_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1298_HLSL_BUILTIN_ALIAS(__builtin_hlsl_lerp)1299half3 lerp(half3, half3, half3);1300_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1301_HLSL_BUILTIN_ALIAS(__builtin_hlsl_lerp)1302half4 lerp(half4, half4, half4);1303 1304_HLSL_BUILTIN_ALIAS(__builtin_hlsl_lerp)1305float lerp(float, float, float);1306_HLSL_BUILTIN_ALIAS(__builtin_hlsl_lerp)1307float2 lerp(float2, float2, float2);1308_HLSL_BUILTIN_ALIAS(__builtin_hlsl_lerp)1309float3 lerp(float3, float3, float3);1310_HLSL_BUILTIN_ALIAS(__builtin_hlsl_lerp)1311float4 lerp(float4, float4, float4);1312 1313//===----------------------------------------------------------------------===//1314// log builtins1315//===----------------------------------------------------------------------===//1316 1317/// \fn T log(T Val)1318/// \brief The base-e logarithm of the input value, \a Val parameter.1319/// \param Val The input value.1320///1321/// If \a Val is negative, this result is undefined. If \a Val is 0, this1322/// function returns negative infinity.1323 1324_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1325_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log)1326half log(half);1327_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1328_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log)1329half2 log(half2);1330_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1331_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log)1332half3 log(half3);1333_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1334_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log)1335half4 log(half4);1336 1337_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log)1338float log(float);1339_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log)1340float2 log(float2);1341_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log)1342float3 log(float3);1343_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log)1344float4 log(float4);1345 1346//===----------------------------------------------------------------------===//1347// log10 builtins1348//===----------------------------------------------------------------------===//1349 1350/// \fn T log10(T Val)1351/// \brief The base-10 logarithm of the input value, \a Val parameter.1352/// \param Val The input value.1353///1354/// If \a Val is negative, this result is undefined. If \a Val is 0, this1355/// function returns negative infinity.1356 1357_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1358_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log10)1359half log10(half);1360_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1361_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log10)1362half2 log10(half2);1363_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1364_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log10)1365half3 log10(half3);1366_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1367_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log10)1368half4 log10(half4);1369 1370_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log10)1371float log10(float);1372_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log10)1373float2 log10(float2);1374_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log10)1375float3 log10(float3);1376_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log10)1377float4 log10(float4);1378 1379//===----------------------------------------------------------------------===//1380// log2 builtins1381//===----------------------------------------------------------------------===//1382 1383/// \fn T log2(T Val)1384/// \brief The base-2 logarithm of the input value, \a Val parameter.1385/// \param Val The input value.1386///1387/// If \a Val is negative, this result is undefined. If \a Val is 0, this1388/// function returns negative infinity.1389 1390_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1391_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log2)1392half log2(half);1393_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1394_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log2)1395half2 log2(half2);1396_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1397_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log2)1398half3 log2(half3);1399_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1400_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log2)1401half4 log2(half4);1402 1403_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log2)1404float log2(float);1405_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log2)1406float2 log2(float2);1407_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log2)1408float3 log2(float3);1409_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log2)1410float4 log2(float4);1411 1412//===----------------------------------------------------------------------===//1413// mad builtins1414//===----------------------------------------------------------------------===//1415 1416/// \fn T mad(T M, T A, T B)1417/// \brief The result of \a M * \a A + \a B.1418/// \param M The multiplication value.1419/// \param A The first addition value.1420/// \param B The second addition value.1421 1422_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1423_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)1424half mad(half, half, half);1425_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1426_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)1427half2 mad(half2, half2, half2);1428_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1429_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)1430half3 mad(half3, half3, half3);1431_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1432_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)1433half4 mad(half4, half4, half4);1434 1435#ifdef __HLSL_ENABLE_16_BIT1436_HLSL_AVAILABILITY(shadermodel, 6.2)1437_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)1438int16_t mad(int16_t, int16_t, int16_t);1439_HLSL_AVAILABILITY(shadermodel, 6.2)1440_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)1441int16_t2 mad(int16_t2, int16_t2, int16_t2);1442_HLSL_AVAILABILITY(shadermodel, 6.2)1443_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)1444int16_t3 mad(int16_t3, int16_t3, int16_t3);1445_HLSL_AVAILABILITY(shadermodel, 6.2)1446_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)1447int16_t4 mad(int16_t4, int16_t4, int16_t4);1448 1449_HLSL_AVAILABILITY(shadermodel, 6.2)1450_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)1451uint16_t mad(uint16_t, uint16_t, uint16_t);1452_HLSL_AVAILABILITY(shadermodel, 6.2)1453_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)1454uint16_t2 mad(uint16_t2, uint16_t2, uint16_t2);1455_HLSL_AVAILABILITY(shadermodel, 6.2)1456_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)1457uint16_t3 mad(uint16_t3, uint16_t3, uint16_t3);1458_HLSL_AVAILABILITY(shadermodel, 6.2)1459_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)1460uint16_t4 mad(uint16_t4, uint16_t4, uint16_t4);1461#endif1462 1463_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)1464int mad(int, int, int);1465_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)1466int2 mad(int2, int2, int2);1467_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)1468int3 mad(int3, int3, int3);1469_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)1470int4 mad(int4, int4, int4);1471 1472_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)1473uint mad(uint, uint, uint);1474_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)1475uint2 mad(uint2, uint2, uint2);1476_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)1477uint3 mad(uint3, uint3, uint3);1478_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)1479uint4 mad(uint4, uint4, uint4);1480 1481_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)1482int64_t mad(int64_t, int64_t, int64_t);1483_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)1484int64_t2 mad(int64_t2, int64_t2, int64_t2);1485_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)1486int64_t3 mad(int64_t3, int64_t3, int64_t3);1487_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)1488int64_t4 mad(int64_t4, int64_t4, int64_t4);1489 1490_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)1491uint64_t mad(uint64_t, uint64_t, uint64_t);1492_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)1493uint64_t2 mad(uint64_t2, uint64_t2, uint64_t2);1494_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)1495uint64_t3 mad(uint64_t3, uint64_t3, uint64_t3);1496_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)1497uint64_t4 mad(uint64_t4, uint64_t4, uint64_t4);1498 1499_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)1500float mad(float, float, float);1501_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)1502float2 mad(float2, float2, float2);1503_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)1504float3 mad(float3, float3, float3);1505_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)1506float4 mad(float4, float4, float4);1507 1508_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)1509double mad(double, double, double);1510_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)1511double2 mad(double2, double2, double2);1512_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)1513double3 mad(double3, double3, double3);1514_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)1515double4 mad(double4, double4, double4);1516 1517//===----------------------------------------------------------------------===//1518// max builtins1519//===----------------------------------------------------------------------===//1520 1521/// \fn T max(T X, T Y)1522/// \brief Return the greater of \a X and \a Y.1523/// \param X The X input value.1524/// \param Y The Y input value.1525 1526_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1527_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)1528half max(half, half);1529_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1530_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)1531half2 max(half2, half2);1532_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1533_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)1534half3 max(half3, half3);1535_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1536_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)1537half4 max(half4, half4);1538 1539#ifdef __HLSL_ENABLE_16_BIT1540_HLSL_AVAILABILITY(shadermodel, 6.2)1541_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)1542int16_t max(int16_t, int16_t);1543_HLSL_AVAILABILITY(shadermodel, 6.2)1544_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)1545int16_t2 max(int16_t2, int16_t2);1546_HLSL_AVAILABILITY(shadermodel, 6.2)1547_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)1548int16_t3 max(int16_t3, int16_t3);1549_HLSL_AVAILABILITY(shadermodel, 6.2)1550_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)1551int16_t4 max(int16_t4, int16_t4);1552 1553_HLSL_AVAILABILITY(shadermodel, 6.2)1554_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)1555uint16_t max(uint16_t, uint16_t);1556_HLSL_AVAILABILITY(shadermodel, 6.2)1557_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)1558uint16_t2 max(uint16_t2, uint16_t2);1559_HLSL_AVAILABILITY(shadermodel, 6.2)1560_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)1561uint16_t3 max(uint16_t3, uint16_t3);1562_HLSL_AVAILABILITY(shadermodel, 6.2)1563_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)1564uint16_t4 max(uint16_t4, uint16_t4);1565#endif1566 1567_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)1568int max(int, int);1569_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)1570int2 max(int2, int2);1571_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)1572int3 max(int3, int3);1573_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)1574int4 max(int4, int4);1575 1576_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)1577uint max(uint, uint);1578_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)1579uint2 max(uint2, uint2);1580_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)1581uint3 max(uint3, uint3);1582_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)1583uint4 max(uint4, uint4);1584 1585_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)1586int64_t max(int64_t, int64_t);1587_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)1588int64_t2 max(int64_t2, int64_t2);1589_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)1590int64_t3 max(int64_t3, int64_t3);1591_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)1592int64_t4 max(int64_t4, int64_t4);1593 1594_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)1595uint64_t max(uint64_t, uint64_t);1596_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)1597uint64_t2 max(uint64_t2, uint64_t2);1598_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)1599uint64_t3 max(uint64_t3, uint64_t3);1600_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)1601uint64_t4 max(uint64_t4, uint64_t4);1602 1603_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)1604float max(float, float);1605_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)1606float2 max(float2, float2);1607_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)1608float3 max(float3, float3);1609_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)1610float4 max(float4, float4);1611 1612_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)1613double max(double, double);1614_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)1615double2 max(double2, double2);1616_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)1617double3 max(double3, double3);1618_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)1619double4 max(double4, double4);1620 1621//===----------------------------------------------------------------------===//1622// min builtins1623//===----------------------------------------------------------------------===//1624 1625/// \fn T min(T X, T Y)1626/// \brief Return the lesser of \a X and \a Y.1627/// \param X The X input value.1628/// \param Y The Y input value.1629 1630_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1631_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)1632half min(half, half);1633_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1634_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)1635half2 min(half2, half2);1636_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1637_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)1638half3 min(half3, half3);1639_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1640_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)1641half4 min(half4, half4);1642 1643#ifdef __HLSL_ENABLE_16_BIT1644_HLSL_AVAILABILITY(shadermodel, 6.2)1645_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)1646int16_t min(int16_t, int16_t);1647_HLSL_AVAILABILITY(shadermodel, 6.2)1648_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)1649int16_t2 min(int16_t2, int16_t2);1650_HLSL_AVAILABILITY(shadermodel, 6.2)1651_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)1652int16_t3 min(int16_t3, int16_t3);1653_HLSL_AVAILABILITY(shadermodel, 6.2)1654_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)1655int16_t4 min(int16_t4, int16_t4);1656 1657_HLSL_AVAILABILITY(shadermodel, 6.2)1658_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)1659uint16_t min(uint16_t, uint16_t);1660_HLSL_AVAILABILITY(shadermodel, 6.2)1661_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)1662uint16_t2 min(uint16_t2, uint16_t2);1663_HLSL_AVAILABILITY(shadermodel, 6.2)1664_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)1665uint16_t3 min(uint16_t3, uint16_t3);1666_HLSL_AVAILABILITY(shadermodel, 6.2)1667_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)1668uint16_t4 min(uint16_t4, uint16_t4);1669#endif1670 1671_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)1672int min(int, int);1673_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)1674int2 min(int2, int2);1675_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)1676int3 min(int3, int3);1677_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)1678int4 min(int4, int4);1679 1680_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)1681uint min(uint, uint);1682_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)1683uint2 min(uint2, uint2);1684_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)1685uint3 min(uint3, uint3);1686_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)1687uint4 min(uint4, uint4);1688 1689_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)1690float min(float, float);1691_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)1692float2 min(float2, float2);1693_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)1694float3 min(float3, float3);1695_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)1696float4 min(float4, float4);1697 1698_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)1699int64_t min(int64_t, int64_t);1700_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)1701int64_t2 min(int64_t2, int64_t2);1702_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)1703int64_t3 min(int64_t3, int64_t3);1704_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)1705int64_t4 min(int64_t4, int64_t4);1706 1707_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)1708uint64_t min(uint64_t, uint64_t);1709_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)1710uint64_t2 min(uint64_t2, uint64_t2);1711_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)1712uint64_t3 min(uint64_t3, uint64_t3);1713_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)1714uint64_t4 min(uint64_t4, uint64_t4);1715 1716_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)1717double min(double, double);1718_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)1719double2 min(double2, double2);1720_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)1721double3 min(double3, double3);1722_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)1723double4 min(double4, double4);1724 1725//===----------------------------------------------------------------------===//1726// normalize builtins1727//===----------------------------------------------------------------------===//1728 1729/// \fn T normalize(T x)1730/// \brief Returns the normalized unit vector of the specified floating-point1731/// vector. \param x [in] The vector of floats.1732///1733/// Normalize is based on the following formula: x / length(x).1734 1735_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1736_HLSL_BUILTIN_ALIAS(__builtin_hlsl_normalize)1737half normalize(half);1738_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1739_HLSL_BUILTIN_ALIAS(__builtin_hlsl_normalize)1740half2 normalize(half2);1741_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1742_HLSL_BUILTIN_ALIAS(__builtin_hlsl_normalize)1743half3 normalize(half3);1744_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1745_HLSL_BUILTIN_ALIAS(__builtin_hlsl_normalize)1746half4 normalize(half4);1747 1748_HLSL_BUILTIN_ALIAS(__builtin_hlsl_normalize)1749float normalize(float);1750_HLSL_BUILTIN_ALIAS(__builtin_hlsl_normalize)1751float2 normalize(float2);1752_HLSL_BUILTIN_ALIAS(__builtin_hlsl_normalize)1753float3 normalize(float3);1754_HLSL_BUILTIN_ALIAS(__builtin_hlsl_normalize)1755float4 normalize(float4);1756 1757//===----------------------------------------------------------------------===//1758// or builtins1759//===----------------------------------------------------------------------===//1760 1761/// \fn bool or(bool x, bool y)1762/// \brief Logically ors two boolean vectors elementwise and produces a bool1763/// vector output.1764 1765// TODO: Clean up clang-format marker once we've resolved1766//       https://github.com/llvm/llvm-project/issues/1278511767//1768// clang-format off1769_HLSL_BUILTIN_ALIAS(__builtin_hlsl_or)1770bool or(bool, bool);1771_HLSL_BUILTIN_ALIAS(__builtin_hlsl_or)1772bool2 or(bool2, bool2);1773_HLSL_BUILTIN_ALIAS(__builtin_hlsl_or)1774bool3 or(bool3, bool3);1775_HLSL_BUILTIN_ALIAS(__builtin_hlsl_or)1776bool4 or(bool4, bool4);1777// clang-format on1778 1779//===----------------------------------------------------------------------===//1780// pow builtins1781//===----------------------------------------------------------------------===//1782 1783/// \fn T pow(T Val, T Pow)1784/// \brief Return the value \a Val, raised to the power \a Pow.1785/// \param Val The input value.1786/// \param Pow The specified power.1787 1788_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1789_HLSL_BUILTIN_ALIAS(__builtin_elementwise_pow)1790half pow(half, half);1791_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1792_HLSL_BUILTIN_ALIAS(__builtin_elementwise_pow)1793half2 pow(half2, half2);1794_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1795_HLSL_BUILTIN_ALIAS(__builtin_elementwise_pow)1796half3 pow(half3, half3);1797_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1798_HLSL_BUILTIN_ALIAS(__builtin_elementwise_pow)1799half4 pow(half4, half4);1800 1801_HLSL_BUILTIN_ALIAS(__builtin_elementwise_pow)1802float pow(float, float);1803_HLSL_BUILTIN_ALIAS(__builtin_elementwise_pow)1804float2 pow(float2, float2);1805_HLSL_BUILTIN_ALIAS(__builtin_elementwise_pow)1806float3 pow(float3, float3);1807_HLSL_BUILTIN_ALIAS(__builtin_elementwise_pow)1808float4 pow(float4, float4);1809 1810//===----------------------------------------------------------------------===//1811// reversebits builtins1812//===----------------------------------------------------------------------===//1813 1814/// \fn T reversebits(T Val)1815/// \brief Return the value \a Val with the bit order reversed.1816/// \param Val The input value.1817 1818#ifdef __HLSL_ENABLE_16_BIT1819_HLSL_AVAILABILITY(shadermodel, 6.2)1820_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)1821uint16_t reversebits(uint16_t);1822_HLSL_AVAILABILITY(shadermodel, 6.2)1823_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)1824uint16_t2 reversebits(uint16_t2);1825_HLSL_AVAILABILITY(shadermodel, 6.2)1826_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)1827uint16_t3 reversebits(uint16_t3);1828_HLSL_AVAILABILITY(shadermodel, 6.2)1829_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)1830uint16_t4 reversebits(uint16_t4);1831#endif1832 1833_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)1834uint reversebits(uint);1835_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)1836uint2 reversebits(uint2);1837_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)1838uint3 reversebits(uint3);1839_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)1840uint4 reversebits(uint4);1841 1842_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)1843uint64_t reversebits(uint64_t);1844_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)1845uint64_t2 reversebits(uint64_t2);1846_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)1847uint64_t3 reversebits(uint64_t3);1848_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)1849uint64_t4 reversebits(uint64_t4);1850 1851//===----------------------------------------------------------------------===//1852// cross builtins1853//===----------------------------------------------------------------------===//1854 1855/// \fn T cross(T x, T y)1856/// \brief Returns the cross product of two floating-point, 3D vectors.1857/// \param x [in] The first floating-point, 3D vector.1858/// \param y [in] The second floating-point, 3D vector.1859///1860/// Result is the cross product of x and y, i.e., the resulting1861/// components are, in order :1862/// x[1] * y[2] - y[1] * x[2]1863/// x[2] * y[0] - y[2] * x[0]1864/// x[0] * y[1] - y[0] * x[1]1865 1866_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1867_HLSL_BUILTIN_ALIAS(__builtin_hlsl_crossf16)1868half3 cross(half3, half3);1869 1870_HLSL_BUILTIN_ALIAS(__builtin_hlsl_crossf32)1871float3 cross(float3, float3);1872 1873//===----------------------------------------------------------------------===//1874// rcp builtins1875//===----------------------------------------------------------------------===//1876 1877/// \fn T rcp(T x)1878/// \brief Calculates a fast, approximate, per-component reciprocal ie 1 / \a x.1879/// \param x The specified input value.1880///1881/// The return value is the reciprocal of the \a x parameter.1882 1883_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1884_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rcp)1885half rcp(half);1886_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1887_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rcp)1888half2 rcp(half2);1889_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1890_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rcp)1891half3 rcp(half3);1892_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1893_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rcp)1894half4 rcp(half4);1895 1896_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rcp)1897float rcp(float);1898_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rcp)1899float2 rcp(float2);1900_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rcp)1901float3 rcp(float3);1902_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rcp)1903float4 rcp(float4);1904 1905_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rcp)1906double rcp(double);1907_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rcp)1908double2 rcp(double2);1909_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rcp)1910double3 rcp(double3);1911_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rcp)1912double4 rcp(double4);1913 1914//===----------------------------------------------------------------------===//1915// rsqrt builtins1916//===----------------------------------------------------------------------===//1917 1918/// \fn T rsqrt(T x)1919/// \brief Returns the reciprocal of the square root of the specified value.1920/// ie 1 / sqrt( \a x).1921/// \param x The specified input value.1922///1923/// This function uses the following formula: 1 / sqrt(x).1924 1925_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1926_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rsqrt)1927half rsqrt(half);1928_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1929_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rsqrt)1930half2 rsqrt(half2);1931_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1932_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rsqrt)1933half3 rsqrt(half3);1934_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1935_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rsqrt)1936half4 rsqrt(half4);1937 1938_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rsqrt)1939float rsqrt(float);1940_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rsqrt)1941float2 rsqrt(float2);1942_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rsqrt)1943float3 rsqrt(float3);1944_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rsqrt)1945float4 rsqrt(float4);1946 1947//===----------------------------------------------------------------------===//1948// round builtins1949//===----------------------------------------------------------------------===//1950 1951/// \fn T round(T x)1952/// \brief Rounds the specified value \a x to the nearest integer.1953/// \param x The specified input value.1954///1955/// The return value is the \a x parameter, rounded to the nearest integer1956/// within a floating-point type. Halfway cases are1957/// rounded to the nearest even value.1958 1959_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1960_HLSL_BUILTIN_ALIAS(__builtin_elementwise_roundeven)1961half round(half);1962_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1963_HLSL_BUILTIN_ALIAS(__builtin_elementwise_roundeven)1964half2 round(half2);1965_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1966_HLSL_BUILTIN_ALIAS(__builtin_elementwise_roundeven)1967half3 round(half3);1968_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1969_HLSL_BUILTIN_ALIAS(__builtin_elementwise_roundeven)1970half4 round(half4);1971 1972_HLSL_BUILTIN_ALIAS(__builtin_elementwise_roundeven)1973float round(float);1974_HLSL_BUILTIN_ALIAS(__builtin_elementwise_roundeven)1975float2 round(float2);1976_HLSL_BUILTIN_ALIAS(__builtin_elementwise_roundeven)1977float3 round(float3);1978_HLSL_BUILTIN_ALIAS(__builtin_elementwise_roundeven)1979float4 round(float4);1980 1981//===----------------------------------------------------------------------===//1982// saturate builtins1983//===----------------------------------------------------------------------===//1984 1985/// \fn T saturate(T Val)1986/// \brief Returns input value, \a Val, clamped within the range of 0.0f1987/// to 1.0f. \param Val The input value.1988 1989_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1990_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_saturate)1991half saturate(half);1992_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1993_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_saturate)1994half2 saturate(half2);1995_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1996_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_saturate)1997half3 saturate(half3);1998_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)1999_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_saturate)2000half4 saturate(half4);2001 2002_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_saturate)2003float saturate(float);2004_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_saturate)2005float2 saturate(float2);2006_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_saturate)2007float3 saturate(float3);2008_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_saturate)2009float4 saturate(float4);2010 2011_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_saturate)2012double saturate(double);2013_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_saturate)2014double2 saturate(double2);2015_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_saturate)2016double3 saturate(double3);2017_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_saturate)2018double4 saturate(double4);2019 2020//===----------------------------------------------------------------------===//2021// select builtins2022//===----------------------------------------------------------------------===//2023 2024/// \fn T select(bool Cond, T TrueVal, T FalseVal)2025/// \brief ternary operator.2026/// \param Cond The Condition input value.2027/// \param TrueVal The Value returned if Cond is true.2028/// \param FalseVal The Value returned if Cond is false.2029 2030template <typename T>2031_HLSL_BUILTIN_ALIAS(__builtin_hlsl_select)2032T select(bool, T, T);2033 2034/// \fn vector<T,Sz> select(vector<bool,Sz> Conds, vector<T,Sz> TrueVals,2035///                         vector<T,Sz> FalseVals)2036/// \brief ternary operator for vectors. All vectors must be the same size.2037/// \param Conds The Condition input values.2038/// \param TrueVals The vector values are chosen from when conditions are true.2039/// \param FalseVals The vector values are chosen from when conditions are2040/// false.2041 2042template <typename T>2043_HLSL_BUILTIN_ALIAS(__builtin_hlsl_select)2044vector<T, 2> select(vector<bool, 2>, vector<T, 2>, vector<T, 2>);2045 2046template <typename T>2047_HLSL_BUILTIN_ALIAS(__builtin_hlsl_select)2048vector<T, 3> select(vector<bool, 3>, vector<T, 3>, vector<T, 3>);2049 2050template <typename T>2051_HLSL_BUILTIN_ALIAS(__builtin_hlsl_select)2052vector<T, 4> select(vector<bool, 4>, vector<T, 4>, vector<T, 4>);2053 2054/// \fn vector<T,Sz> select(vector<bool,Sz> Conds, T TrueVal,2055///                         vector<T,Sz> FalseVals)2056/// \brief ternary operator for vectors. All vectors must be the same size.2057/// \param Conds The Condition input values.2058/// \param TrueVal The scalar value to splat from when conditions are true.2059/// \param FalseVals The vector values are chosen from when conditions are2060/// false.2061 2062template <typename T>2063_HLSL_BUILTIN_ALIAS(__builtin_hlsl_select)2064vector<T, 2> select(vector<bool, 2>, T, vector<T, 2>);2065 2066template <typename T>2067_HLSL_BUILTIN_ALIAS(__builtin_hlsl_select)2068vector<T, 3> select(vector<bool, 3>, T, vector<T, 3>);2069 2070template <typename T>2071_HLSL_BUILTIN_ALIAS(__builtin_hlsl_select)2072vector<T, 4> select(vector<bool, 4>, T, vector<T, 4>);2073 2074/// \fn vector<T,Sz> select(vector<bool,Sz> Conds, vector<T,Sz> TrueVals,2075///                         T FalseVal)2076/// \brief ternary operator for vectors. All vectors must be the same size.2077/// \param Conds The Condition input values.2078/// \param TrueVals The vector values are chosen from when conditions are true.2079/// \param FalseVal The scalar value to splat from when conditions are false.2080 2081template <typename T>2082_HLSL_BUILTIN_ALIAS(__builtin_hlsl_select)2083vector<T, 2> select(vector<bool, 2>, vector<T, 2>, T);2084 2085template <typename T>2086_HLSL_BUILTIN_ALIAS(__builtin_hlsl_select)2087vector<T, 3> select(vector<bool, 3>, vector<T, 3>, T);2088 2089template <typename T>2090_HLSL_BUILTIN_ALIAS(__builtin_hlsl_select)2091vector<T, 4> select(vector<bool, 4>, vector<T, 4>, T);2092 2093/// \fn vector<T,Sz> select(vector<bool,Sz> Conds, vector<T,Sz> TrueVals,2094///                         T FalseVal)2095/// \brief ternary operator for vectors. All vectors must be the same size.2096/// \param Conds The Condition input values.2097/// \param TrueVal The scalar value to splat from when conditions are true.2098/// \param FalseVal The scalar value to splat from when conditions are false.2099 2100template <typename T>2101_HLSL_BUILTIN_ALIAS(__builtin_hlsl_select)2102__detail::enable_if_t<__detail::is_arithmetic<T>::Value, vector<T, 2>> select(2103    vector<bool, 2>, T, T);2104 2105template <typename T>2106_HLSL_BUILTIN_ALIAS(__builtin_hlsl_select)2107__detail::enable_if_t<__detail::is_arithmetic<T>::Value, vector<T, 3>> select(2108    vector<bool, 3>, T, T);2109 2110template <typename T>2111_HLSL_BUILTIN_ALIAS(__builtin_hlsl_select)2112__detail::enable_if_t<__detail::is_arithmetic<T>::Value, vector<T, 4>> select(2113    vector<bool, 4>, T, T);2114 2115//===----------------------------------------------------------------------===//2116// sin builtins2117//===----------------------------------------------------------------------===//2118 2119/// \fn T sin(T Val)2120/// \brief Returns the sine of the input value, \a Val.2121/// \param Val The input value.2122 2123_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)2124_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sin)2125half sin(half);2126_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)2127_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sin)2128half2 sin(half2);2129_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)2130_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sin)2131half3 sin(half3);2132_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)2133_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sin)2134half4 sin(half4);2135 2136_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sin)2137float sin(float);2138_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sin)2139float2 sin(float2);2140_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sin)2141float3 sin(float3);2142_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sin)2143float4 sin(float4);2144 2145//===----------------------------------------------------------------------===//2146// sinh builtins2147//===----------------------------------------------------------------------===//2148 2149/// \fn T sinh(T Val)2150/// \brief Returns the hyperbolic sine of the input value, \a Val.2151/// \param Val The input value.2152 2153_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)2154_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sinh)2155half sinh(half);2156_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)2157_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sinh)2158half2 sinh(half2);2159_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)2160_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sinh)2161half3 sinh(half3);2162_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)2163_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sinh)2164half4 sinh(half4);2165 2166_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sinh)2167float sinh(float);2168_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sinh)2169float2 sinh(float2);2170_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sinh)2171float3 sinh(float3);2172_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sinh)2173float4 sinh(float4);2174 2175//===----------------------------------------------------------------------===//2176// sqrt builtins2177//===----------------------------------------------------------------------===//2178 2179/// \fn T sqrt(T Val)2180/// \brief Returns the square root of the input value, \a Val.2181/// \param Val The input value.2182 2183_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)2184_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sqrt)2185half sqrt(half);2186_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)2187_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sqrt)2188half2 sqrt(half2);2189_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)2190_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sqrt)2191half3 sqrt(half3);2192_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)2193_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sqrt)2194half4 sqrt(half4);2195 2196_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sqrt)2197float sqrt(float);2198_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sqrt)2199float2 sqrt(float2);2200_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sqrt)2201float3 sqrt(float3);2202_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sqrt)2203float4 sqrt(float4);2204 2205//===----------------------------------------------------------------------===//2206// step builtins2207//===----------------------------------------------------------------------===//2208 2209/// \fn T step(T y, T x)2210/// \brief Returns 1 if the x parameter is greater than or equal to the y2211/// parameter; otherwise, 0. vector. \param y [in] The first floating-point2212/// value to compare. \param x [in] The second floating-point value to compare.2213///2214/// Step is based on the following formula: (x >= y) ? 1 : 02215 2216_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)2217_HLSL_BUILTIN_ALIAS(__builtin_hlsl_step)2218half step(half, half);2219_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)2220_HLSL_BUILTIN_ALIAS(__builtin_hlsl_step)2221half2 step(half2, half2);2222_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)2223_HLSL_BUILTIN_ALIAS(__builtin_hlsl_step)2224half3 step(half3, half3);2225_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)2226_HLSL_BUILTIN_ALIAS(__builtin_hlsl_step)2227half4 step(half4, half4);2228 2229_HLSL_BUILTIN_ALIAS(__builtin_hlsl_step)2230float step(float, float);2231_HLSL_BUILTIN_ALIAS(__builtin_hlsl_step)2232float2 step(float2, float2);2233_HLSL_BUILTIN_ALIAS(__builtin_hlsl_step)2234float3 step(float3, float3);2235_HLSL_BUILTIN_ALIAS(__builtin_hlsl_step)2236float4 step(float4, float4);2237 2238//===----------------------------------------------------------------------===//2239// tan builtins2240//===----------------------------------------------------------------------===//2241 2242/// \fn T tan(T Val)2243/// \brief Returns the tangent of the input value, \a Val.2244/// \param Val The input value.2245 2246_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)2247_HLSL_BUILTIN_ALIAS(__builtin_elementwise_tan)2248half tan(half);2249_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)2250_HLSL_BUILTIN_ALIAS(__builtin_elementwise_tan)2251half2 tan(half2);2252_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)2253_HLSL_BUILTIN_ALIAS(__builtin_elementwise_tan)2254half3 tan(half3);2255_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)2256_HLSL_BUILTIN_ALIAS(__builtin_elementwise_tan)2257half4 tan(half4);2258 2259_HLSL_BUILTIN_ALIAS(__builtin_elementwise_tan)2260float tan(float);2261_HLSL_BUILTIN_ALIAS(__builtin_elementwise_tan)2262float2 tan(float2);2263_HLSL_BUILTIN_ALIAS(__builtin_elementwise_tan)2264float3 tan(float3);2265_HLSL_BUILTIN_ALIAS(__builtin_elementwise_tan)2266float4 tan(float4);2267 2268//===----------------------------------------------------------------------===//2269// tanh builtins2270//===----------------------------------------------------------------------===//2271 2272/// \fn T tanh(T Val)2273/// \brief Returns the hyperbolic tangent of the input value, \a Val.2274/// \param Val The input value.2275 2276_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)2277_HLSL_BUILTIN_ALIAS(__builtin_elementwise_tanh)2278half tanh(half);2279_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)2280_HLSL_BUILTIN_ALIAS(__builtin_elementwise_tanh)2281half2 tanh(half2);2282_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)2283_HLSL_BUILTIN_ALIAS(__builtin_elementwise_tanh)2284half3 tanh(half3);2285_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)2286_HLSL_BUILTIN_ALIAS(__builtin_elementwise_tanh)2287half4 tanh(half4);2288 2289_HLSL_BUILTIN_ALIAS(__builtin_elementwise_tanh)2290float tanh(float);2291_HLSL_BUILTIN_ALIAS(__builtin_elementwise_tanh)2292float2 tanh(float2);2293_HLSL_BUILTIN_ALIAS(__builtin_elementwise_tanh)2294float3 tanh(float3);2295_HLSL_BUILTIN_ALIAS(__builtin_elementwise_tanh)2296float4 tanh(float4);2297 2298//===----------------------------------------------------------------------===//2299// trunc builtins2300//===----------------------------------------------------------------------===//2301 2302/// \fn T trunc(T Val)2303/// \brief Returns the truncated integer value of the input value, \a Val.2304/// \param Val The input value.2305 2306_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)2307_HLSL_BUILTIN_ALIAS(__builtin_elementwise_trunc)2308half trunc(half);2309_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)2310_HLSL_BUILTIN_ALIAS(__builtin_elementwise_trunc)2311half2 trunc(half2);2312_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)2313_HLSL_BUILTIN_ALIAS(__builtin_elementwise_trunc)2314half3 trunc(half3);2315_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)2316_HLSL_BUILTIN_ALIAS(__builtin_elementwise_trunc)2317half4 trunc(half4);2318 2319_HLSL_BUILTIN_ALIAS(__builtin_elementwise_trunc)2320float trunc(float);2321_HLSL_BUILTIN_ALIAS(__builtin_elementwise_trunc)2322float2 trunc(float2);2323_HLSL_BUILTIN_ALIAS(__builtin_elementwise_trunc)2324float3 trunc(float3);2325_HLSL_BUILTIN_ALIAS(__builtin_elementwise_trunc)2326float4 trunc(float4);2327 2328//===----------------------------------------------------------------------===//2329// Wave* builtins2330//===----------------------------------------------------------------------===//2331 2332/// \brief Returns true if the expression is true in all active lanes in the2333/// current wave.2334///2335/// \param Val The boolean expression to evaluate.2336/// \return True if the expression is true in all lanes.2337_HLSL_AVAILABILITY(shadermodel, 6.0)2338_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_all_true)2339__attribute__((convergent)) bool WaveActiveAllTrue(bool Val);2340 2341/// \brief Returns true if the expression is true in any active lane in the2342/// current wave.2343///2344/// \param Val The boolean expression to evaluate.2345/// \return True if the expression is true in any lane.2346_HLSL_AVAILABILITY(shadermodel, 6.0)2347_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_any_true)2348__attribute__((convergent)) bool WaveActiveAnyTrue(bool Val);2349 2350/// \brief Counts the number of boolean variables which evaluate to true across2351/// all active lanes in the current wave.2352///2353/// \param Val The input boolean value.2354/// \return The number of lanes for which the boolean variable evaluates to2355/// true, across all active lanes in the current wave.2356_HLSL_AVAILABILITY(shadermodel, 6.0)2357_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_count_bits)2358__attribute__((convergent)) uint WaveActiveCountBits(bool Val);2359 2360/// \brief Returns the index of the current lane within the current wave.2361_HLSL_AVAILABILITY(shadermodel, 6.0)2362_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_get_lane_index)2363__attribute__((convergent)) uint WaveGetLaneIndex();2364 2365_HLSL_AVAILABILITY(shadermodel, 6.0)2366_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_is_first_lane)2367__attribute__((convergent)) bool WaveIsFirstLane();2368 2369_HLSL_AVAILABILITY(shadermodel, 6.0)2370_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_get_lane_count)2371__attribute__((convergent)) uint WaveGetLaneCount();2372 2373//===----------------------------------------------------------------------===//2374// WaveReadLaneAt builtins2375//===----------------------------------------------------------------------===//2376 2377// \brief Returns the value of the expression for the given lane index within2378// the specified wave.2379 2380_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)2381__attribute__((convergent)) bool WaveReadLaneAt(bool, uint32_t);2382_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)2383__attribute__((convergent)) bool2 WaveReadLaneAt(bool2, uint32_t);2384_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)2385__attribute__((convergent)) bool3 WaveReadLaneAt(bool3, uint32_t);2386_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)2387__attribute__((convergent)) bool4 WaveReadLaneAt(bool4, uint32_t);2388 2389#ifdef __HLSL_ENABLE_16_BIT2390_HLSL_AVAILABILITY(shadermodel, 6.0)2391_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)2392__attribute__((convergent)) int16_t WaveReadLaneAt(int16_t, uint32_t);2393_HLSL_AVAILABILITY(shadermodel, 6.0)2394_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)2395__attribute__((convergent)) int16_t2 WaveReadLaneAt(int16_t2, uint32_t);2396_HLSL_AVAILABILITY(shadermodel, 6.0)2397_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)2398__attribute__((convergent)) int16_t3 WaveReadLaneAt(int16_t3, uint32_t);2399_HLSL_AVAILABILITY(shadermodel, 6.0)2400_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)2401__attribute__((convergent)) int16_t4 WaveReadLaneAt(int16_t4, uint32_t);2402 2403_HLSL_AVAILABILITY(shadermodel, 6.0)2404_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)2405__attribute__((convergent)) uint16_t WaveReadLaneAt(uint16_t, uint32_t);2406_HLSL_AVAILABILITY(shadermodel, 6.0)2407_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)2408__attribute__((convergent)) uint16_t2 WaveReadLaneAt(uint16_t2, uint32_t);2409_HLSL_AVAILABILITY(shadermodel, 6.0)2410_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)2411__attribute__((convergent)) uint16_t3 WaveReadLaneAt(uint16_t3, uint32_t);2412_HLSL_AVAILABILITY(shadermodel, 6.0)2413_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)2414__attribute__((convergent)) uint16_t4 WaveReadLaneAt(uint16_t4, uint32_t);2415#endif2416 2417_HLSL_16BIT_AVAILABILITY(shadermodel, 6.0)2418_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)2419__attribute__((convergent)) half WaveReadLaneAt(half, uint32_t);2420_HLSL_16BIT_AVAILABILITY(shadermodel, 6.0)2421_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)2422__attribute__((convergent)) half2 WaveReadLaneAt(half2, uint32_t);2423_HLSL_16BIT_AVAILABILITY(shadermodel, 6.0)2424_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)2425__attribute__((convergent)) half3 WaveReadLaneAt(half3, uint32_t);2426_HLSL_16BIT_AVAILABILITY(shadermodel, 6.0)2427_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)2428__attribute__((convergent)) half4 WaveReadLaneAt(half4, uint32_t);2429 2430_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)2431__attribute__((convergent)) int WaveReadLaneAt(int, uint32_t);2432_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)2433__attribute__((convergent)) int2 WaveReadLaneAt(int2, uint32_t);2434_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)2435__attribute__((convergent)) int3 WaveReadLaneAt(int3, uint32_t);2436_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)2437__attribute__((convergent)) int4 WaveReadLaneAt(int4, uint32_t);2438 2439_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)2440__attribute__((convergent)) uint WaveReadLaneAt(uint, uint32_t);2441_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)2442__attribute__((convergent)) uint2 WaveReadLaneAt(uint2, uint32_t);2443_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)2444__attribute__((convergent)) uint3 WaveReadLaneAt(uint3, uint32_t);2445_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)2446__attribute__((convergent)) uint4 WaveReadLaneAt(uint4, uint32_t);2447 2448_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)2449__attribute__((convergent)) float WaveReadLaneAt(float, uint32_t);2450_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)2451__attribute__((convergent)) float2 WaveReadLaneAt(float2, uint32_t);2452_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)2453__attribute__((convergent)) float3 WaveReadLaneAt(float3, uint32_t);2454_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)2455__attribute__((convergent)) float4 WaveReadLaneAt(float4, uint32_t);2456 2457_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)2458__attribute__((convergent)) int64_t WaveReadLaneAt(int64_t, uint32_t);2459_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)2460__attribute__((convergent)) int64_t2 WaveReadLaneAt(int64_t2, uint32_t);2461_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)2462__attribute__((convergent)) int64_t3 WaveReadLaneAt(int64_t3, uint32_t);2463_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)2464__attribute__((convergent)) int64_t4 WaveReadLaneAt(int64_t4, uint32_t);2465 2466_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)2467__attribute__((convergent)) uint64_t WaveReadLaneAt(uint64_t, uint32_t);2468_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)2469__attribute__((convergent)) uint64_t2 WaveReadLaneAt(uint64_t2, uint32_t);2470_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)2471__attribute__((convergent)) uint64_t3 WaveReadLaneAt(uint64_t3, uint32_t);2472_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)2473__attribute__((convergent)) uint64_t4 WaveReadLaneAt(uint64_t4, uint32_t);2474 2475_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)2476__attribute__((convergent)) double WaveReadLaneAt(double, uint32_t);2477_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)2478__attribute__((convergent)) double2 WaveReadLaneAt(double2, uint32_t);2479_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)2480__attribute__((convergent)) double3 WaveReadLaneAt(double3, uint32_t);2481_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)2482__attribute__((convergent)) double4 WaveReadLaneAt(double4, uint32_t);2483 2484//===----------------------------------------------------------------------===//2485// WaveActiveMax builtins2486//===----------------------------------------------------------------------===//2487 2488_HLSL_16BIT_AVAILABILITY(shadermodel, 6.0)2489_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)2490__attribute__((convergent)) half WaveActiveMax(half);2491_HLSL_16BIT_AVAILABILITY(shadermodel, 6.0)2492_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)2493__attribute__((convergent)) half2 WaveActiveMax(half2);2494_HLSL_16BIT_AVAILABILITY(shadermodel, 6.0)2495_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)2496__attribute__((convergent)) half3 WaveActiveMax(half3);2497_HLSL_16BIT_AVAILABILITY(shadermodel, 6.0)2498_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)2499__attribute__((convergent)) half4 WaveActiveMax(half4);2500 2501#ifdef __HLSL_ENABLE_16_BIT2502_HLSL_AVAILABILITY(shadermodel, 6.0)2503_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)2504__attribute__((convergent)) int16_t WaveActiveMax(int16_t);2505_HLSL_AVAILABILITY(shadermodel, 6.0)2506_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)2507__attribute__((convergent)) int16_t2 WaveActiveMax(int16_t2);2508_HLSL_AVAILABILITY(shadermodel, 6.0)2509_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)2510__attribute__((convergent)) int16_t3 WaveActiveMax(int16_t3);2511_HLSL_AVAILABILITY(shadermodel, 6.0)2512_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)2513__attribute__((convergent)) int16_t4 WaveActiveMax(int16_t4);2514 2515_HLSL_AVAILABILITY(shadermodel, 6.0)2516_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)2517__attribute__((convergent)) uint16_t WaveActiveMax(uint16_t);2518_HLSL_AVAILABILITY(shadermodel, 6.0)2519_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)2520__attribute__((convergent)) uint16_t2 WaveActiveMax(uint16_t2);2521_HLSL_AVAILABILITY(shadermodel, 6.0)2522_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)2523__attribute__((convergent)) uint16_t3 WaveActiveMax(uint16_t3);2524_HLSL_AVAILABILITY(shadermodel, 6.0)2525_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)2526__attribute__((convergent)) uint16_t4 WaveActiveMax(uint16_t4);2527#endif2528 2529_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)2530__attribute__((convergent)) int WaveActiveMax(int);2531_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)2532__attribute__((convergent)) int2 WaveActiveMax(int2);2533_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)2534__attribute__((convergent)) int3 WaveActiveMax(int3);2535_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)2536__attribute__((convergent)) int4 WaveActiveMax(int4);2537 2538_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)2539__attribute__((convergent)) uint WaveActiveMax(uint);2540_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)2541__attribute__((convergent)) uint2 WaveActiveMax(uint2);2542_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)2543__attribute__((convergent)) uint3 WaveActiveMax(uint3);2544_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)2545__attribute__((convergent)) uint4 WaveActiveMax(uint4);2546 2547_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)2548__attribute__((convergent)) int64_t WaveActiveMax(int64_t);2549_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)2550__attribute__((convergent)) int64_t2 WaveActiveMax(int64_t2);2551_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)2552__attribute__((convergent)) int64_t3 WaveActiveMax(int64_t3);2553_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)2554__attribute__((convergent)) int64_t4 WaveActiveMax(int64_t4);2555 2556_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)2557__attribute__((convergent)) uint64_t WaveActiveMax(uint64_t);2558_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)2559__attribute__((convergent)) uint64_t2 WaveActiveMax(uint64_t2);2560_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)2561__attribute__((convergent)) uint64_t3 WaveActiveMax(uint64_t3);2562_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)2563__attribute__((convergent)) uint64_t4 WaveActiveMax(uint64_t4);2564 2565_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)2566__attribute__((convergent)) float WaveActiveMax(float);2567_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)2568__attribute__((convergent)) float2 WaveActiveMax(float2);2569_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)2570__attribute__((convergent)) float3 WaveActiveMax(float3);2571_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)2572__attribute__((convergent)) float4 WaveActiveMax(float4);2573 2574_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)2575__attribute__((convergent)) double WaveActiveMax(double);2576_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)2577__attribute__((convergent)) double2 WaveActiveMax(double2);2578_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)2579__attribute__((convergent)) double3 WaveActiveMax(double3);2580_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max)2581__attribute__((convergent)) double4 WaveActiveMax(double4);2582 2583//===----------------------------------------------------------------------===//2584// WaveActiveMin builtins2585//===----------------------------------------------------------------------===//2586 2587_HLSL_16BIT_AVAILABILITY(shadermodel, 6.0)2588_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_min)2589__attribute__((convergent)) half WaveActiveMin(half);2590_HLSL_16BIT_AVAILABILITY(shadermodel, 6.0)2591_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_min)2592__attribute__((convergent)) half2 WaveActiveMin(half2);2593_HLSL_16BIT_AVAILABILITY(shadermodel, 6.0)2594_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_min)2595__attribute__((convergent)) half3 WaveActiveMin(half3);2596_HLSL_16BIT_AVAILABILITY(shadermodel, 6.0)2597_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_min)2598__attribute__((convergent)) half4 WaveActiveMin(half4);2599 2600#ifdef __HLSL_ENABLE_16_BIT2601_HLSL_AVAILABILITY(shadermodel, 6.0)2602_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_min)2603__attribute__((convergent)) int16_t WaveActiveMin(int16_t);2604_HLSL_AVAILABILITY(shadermodel, 6.0)2605_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_min)2606__attribute__((convergent)) int16_t2 WaveActiveMin(int16_t2);2607_HLSL_AVAILABILITY(shadermodel, 6.0)2608_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_min)2609__attribute__((convergent)) int16_t3 WaveActiveMin(int16_t3);2610_HLSL_AVAILABILITY(shadermodel, 6.0)2611_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_min)2612__attribute__((convergent)) int16_t4 WaveActiveMin(int16_t4);2613 2614_HLSL_AVAILABILITY(shadermodel, 6.0)2615_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_min)2616__attribute__((convergent)) uint16_t WaveActiveMin(uint16_t);2617_HLSL_AVAILABILITY(shadermodel, 6.0)2618_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_min)2619__attribute__((convergent)) uint16_t2 WaveActiveMin(uint16_t2);2620_HLSL_AVAILABILITY(shadermodel, 6.0)2621_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_min)2622__attribute__((convergent)) uint16_t3 WaveActiveMin(uint16_t3);2623_HLSL_AVAILABILITY(shadermodel, 6.0)2624_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_min)2625__attribute__((convergent)) uint16_t4 WaveActiveMin(uint16_t4);2626#endif2627 2628_HLSL_AVAILABILITY(shadermodel, 6.0)2629_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_min)2630__attribute__((convergent)) int WaveActiveMin(int);2631_HLSL_AVAILABILITY(shadermodel, 6.0)2632_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_min)2633__attribute__((convergent)) int2 WaveActiveMin(int2);2634_HLSL_AVAILABILITY(shadermodel, 6.0)2635_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_min)2636__attribute__((convergent)) int3 WaveActiveMin(int3);2637_HLSL_AVAILABILITY(shadermodel, 6.0)2638_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_min)2639__attribute__((convergent)) int4 WaveActiveMin(int4);2640 2641_HLSL_AVAILABILITY(shadermodel, 6.0)2642_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_min)2643__attribute__((convergent)) uint WaveActiveMin(uint);2644_HLSL_AVAILABILITY(shadermodel, 6.0)2645_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_min)2646__attribute__((convergent)) uint2 WaveActiveMin(uint2);2647_HLSL_AVAILABILITY(shadermodel, 6.0)2648_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_min)2649__attribute__((convergent)) uint3 WaveActiveMin(uint3);2650_HLSL_AVAILABILITY(shadermodel, 6.0)2651_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_min)2652__attribute__((convergent)) uint4 WaveActiveMin(uint4);2653 2654_HLSL_AVAILABILITY(shadermodel, 6.0)2655_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_min)2656__attribute__((convergent)) int64_t WaveActiveMin(int64_t);2657_HLSL_AVAILABILITY(shadermodel, 6.0)2658_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_min)2659__attribute__((convergent)) int64_t2 WaveActiveMin(int64_t2);2660_HLSL_AVAILABILITY(shadermodel, 6.0)2661_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_min)2662__attribute__((convergent)) int64_t3 WaveActiveMin(int64_t3);2663_HLSL_AVAILABILITY(shadermodel, 6.0)2664_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_min)2665__attribute__((convergent)) int64_t4 WaveActiveMin(int64_t4);2666 2667_HLSL_AVAILABILITY(shadermodel, 6.0)2668_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_min)2669__attribute__((convergent)) uint64_t WaveActiveMin(uint64_t);2670_HLSL_AVAILABILITY(shadermodel, 6.0)2671_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_min)2672__attribute__((convergent)) uint64_t2 WaveActiveMin(uint64_t2);2673_HLSL_AVAILABILITY(shadermodel, 6.0)2674_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_min)2675__attribute__((convergent)) uint64_t3 WaveActiveMin(uint64_t3);2676_HLSL_AVAILABILITY(shadermodel, 6.0)2677_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_min)2678__attribute__((convergent)) uint64_t4 WaveActiveMin(uint64_t4);2679 2680_HLSL_AVAILABILITY(shadermodel, 6.0)2681_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_min)2682__attribute__((convergent)) float WaveActiveMin(float);2683_HLSL_AVAILABILITY(shadermodel, 6.0)2684_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_min)2685__attribute__((convergent)) float2 WaveActiveMin(float2);2686_HLSL_AVAILABILITY(shadermodel, 6.0)2687_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_min)2688__attribute__((convergent)) float3 WaveActiveMin(float3);2689_HLSL_AVAILABILITY(shadermodel, 6.0)2690_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_min)2691__attribute__((convergent)) float4 WaveActiveMin(float4);2692 2693_HLSL_AVAILABILITY(shadermodel, 6.0)2694_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_min)2695__attribute__((convergent)) double WaveActiveMin(double);2696_HLSL_AVAILABILITY(shadermodel, 6.0)2697_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_min)2698__attribute__((convergent)) double2 WaveActiveMin(double2);2699_HLSL_AVAILABILITY(shadermodel, 6.0)2700_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_min)2701__attribute__((convergent)) double3 WaveActiveMin(double3);2702_HLSL_AVAILABILITY(shadermodel, 6.0)2703_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_min)2704__attribute__((convergent)) double4 WaveActiveMin(double4);2705 2706//===----------------------------------------------------------------------===//2707// WaveActiveSum builtins2708//===----------------------------------------------------------------------===//2709 2710_HLSL_16BIT_AVAILABILITY(shadermodel, 6.0)2711_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)2712__attribute__((convergent)) half WaveActiveSum(half);2713_HLSL_16BIT_AVAILABILITY(shadermodel, 6.0)2714_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)2715__attribute__((convergent)) half2 WaveActiveSum(half2);2716_HLSL_16BIT_AVAILABILITY(shadermodel, 6.0)2717_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)2718__attribute__((convergent)) half3 WaveActiveSum(half3);2719_HLSL_16BIT_AVAILABILITY(shadermodel, 6.0)2720_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)2721__attribute__((convergent)) half4 WaveActiveSum(half4);2722 2723#ifdef __HLSL_ENABLE_16_BIT2724_HLSL_AVAILABILITY(shadermodel, 6.0)2725_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)2726__attribute__((convergent)) int16_t WaveActiveSum(int16_t);2727_HLSL_AVAILABILITY(shadermodel, 6.0)2728_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)2729__attribute__((convergent)) int16_t2 WaveActiveSum(int16_t2);2730_HLSL_AVAILABILITY(shadermodel, 6.0)2731_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)2732__attribute__((convergent)) int16_t3 WaveActiveSum(int16_t3);2733_HLSL_AVAILABILITY(shadermodel, 6.0)2734_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)2735__attribute__((convergent)) int16_t4 WaveActiveSum(int16_t4);2736 2737_HLSL_AVAILABILITY(shadermodel, 6.0)2738_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)2739__attribute__((convergent)) uint16_t WaveActiveSum(uint16_t);2740_HLSL_AVAILABILITY(shadermodel, 6.0)2741_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)2742__attribute__((convergent)) uint16_t2 WaveActiveSum(uint16_t2);2743_HLSL_AVAILABILITY(shadermodel, 6.0)2744_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)2745__attribute__((convergent)) uint16_t3 WaveActiveSum(uint16_t3);2746_HLSL_AVAILABILITY(shadermodel, 6.0)2747_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)2748__attribute__((convergent)) uint16_t4 WaveActiveSum(uint16_t4);2749#endif2750 2751_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)2752__attribute__((convergent)) int WaveActiveSum(int);2753_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)2754__attribute__((convergent)) int2 WaveActiveSum(int2);2755_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)2756__attribute__((convergent)) int3 WaveActiveSum(int3);2757_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)2758__attribute__((convergent)) int4 WaveActiveSum(int4);2759 2760_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)2761__attribute__((convergent)) uint WaveActiveSum(uint);2762_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)2763__attribute__((convergent)) uint2 WaveActiveSum(uint2);2764_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)2765__attribute__((convergent)) uint3 WaveActiveSum(uint3);2766_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)2767__attribute__((convergent)) uint4 WaveActiveSum(uint4);2768 2769_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)2770__attribute__((convergent)) int64_t WaveActiveSum(int64_t);2771_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)2772__attribute__((convergent)) int64_t2 WaveActiveSum(int64_t2);2773_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)2774__attribute__((convergent)) int64_t3 WaveActiveSum(int64_t3);2775_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)2776__attribute__((convergent)) int64_t4 WaveActiveSum(int64_t4);2777 2778_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)2779__attribute__((convergent)) uint64_t WaveActiveSum(uint64_t);2780_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)2781__attribute__((convergent)) uint64_t2 WaveActiveSum(uint64_t2);2782_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)2783__attribute__((convergent)) uint64_t3 WaveActiveSum(uint64_t3);2784_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)2785__attribute__((convergent)) uint64_t4 WaveActiveSum(uint64_t4);2786 2787_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)2788__attribute__((convergent)) float WaveActiveSum(float);2789_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)2790__attribute__((convergent)) float2 WaveActiveSum(float2);2791_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)2792__attribute__((convergent)) float3 WaveActiveSum(float3);2793_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)2794__attribute__((convergent)) float4 WaveActiveSum(float4);2795 2796_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)2797__attribute__((convergent)) double WaveActiveSum(double);2798_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)2799__attribute__((convergent)) double2 WaveActiveSum(double2);2800_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)2801__attribute__((convergent)) double3 WaveActiveSum(double3);2802_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)2803__attribute__((convergent)) double4 WaveActiveSum(double4);2804 2805//===----------------------------------------------------------------------===//2806// sign builtins2807//===----------------------------------------------------------------------===//2808 2809/// \fn T sign(T Val)2810/// \brief Returns -1 if \a Val is less than zero; 0 if \a Val equals zero; and2811/// 1 if \a Val is greater than zero. \param Val The input value.2812 2813#ifdef __HLSL_ENABLE_16_BIT2814_HLSL_AVAILABILITY(shadermodel, 6.2)2815_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)2816int sign(int16_t);2817_HLSL_AVAILABILITY(shadermodel, 6.2)2818_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)2819int2 sign(int16_t2);2820_HLSL_AVAILABILITY(shadermodel, 6.2)2821_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)2822int3 sign(int16_t3);2823_HLSL_AVAILABILITY(shadermodel, 6.2)2824_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)2825int4 sign(int16_t4);2826 2827_HLSL_AVAILABILITY(shadermodel, 6.2)2828_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)2829int sign(uint16_t);2830_HLSL_AVAILABILITY(shadermodel, 6.2)2831_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)2832int2 sign(uint16_t2);2833_HLSL_AVAILABILITY(shadermodel, 6.2)2834_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)2835int3 sign(uint16_t3);2836_HLSL_AVAILABILITY(shadermodel, 6.2)2837_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)2838int4 sign(uint16_t4);2839#endif2840 2841_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)2842_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)2843int sign(half);2844_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)2845_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)2846int2 sign(half2);2847_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)2848_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)2849int3 sign(half3);2850_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)2851_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)2852int4 sign(half4);2853 2854_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)2855int sign(int);2856_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)2857int2 sign(int2);2858_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)2859int3 sign(int3);2860_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)2861int4 sign(int4);2862 2863_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)2864int sign(uint);2865_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)2866int2 sign(uint2);2867_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)2868int3 sign(uint3);2869_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)2870int4 sign(uint4);2871 2872_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)2873int sign(float);2874_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)2875int2 sign(float2);2876_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)2877int3 sign(float3);2878_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)2879int4 sign(float4);2880 2881_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)2882int sign(int64_t);2883_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)2884int2 sign(int64_t2);2885_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)2886int3 sign(int64_t3);2887_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)2888int4 sign(int64_t4);2889 2890_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)2891int sign(uint64_t);2892_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)2893int2 sign(uint64_t2);2894_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)2895int3 sign(uint64_t3);2896_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)2897int4 sign(uint64_t4);2898 2899_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)2900int sign(double);2901_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)2902int2 sign(double2);2903_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)2904int3 sign(double3);2905_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)2906int4 sign(double4);2907 2908//===----------------------------------------------------------------------===//2909// radians builtins2910//===----------------------------------------------------------------------===//2911 2912/// \fn T radians(T Val)2913/// \brief Converts the specified value from degrees to radians.2914 2915_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)2916_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_radians)2917half radians(half);2918_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)2919_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_radians)2920half2 radians(half2);2921_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)2922_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_radians)2923half3 radians(half3);2924_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)2925_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_radians)2926half4 radians(half4);2927 2928_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_radians)2929float radians(float);2930_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_radians)2931float2 radians(float2);2932_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_radians)2933float3 radians(float3);2934_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_radians)2935float4 radians(float4);2936 2937//===----------------------------------------------------------------------===//2938// GroupMemoryBarrierWithGroupSync builtins2939//===----------------------------------------------------------------------===//2940 2941/// \fn void GroupMemoryBarrierWithGroupSync(void)2942/// \brief Blocks execution of all threads in a group until all group shared2943/// accesses have been completed and all threads in the group have reached this2944/// call.2945 2946_HLSL_BUILTIN_ALIAS(__builtin_hlsl_group_memory_barrier_with_group_sync)2947__attribute__((convergent)) void GroupMemoryBarrierWithGroupSync(void);2948 2949//===----------------------------------------------------------------------===//2950// ddx_coarse builtin2951//===----------------------------------------------------------------------===//2952 2953/// \fn T ddx_coarse(T value)2954/// \brief Computes a low precision partial derivative with respect to the2955/// screen-space x-coordinate.2956/// \param value The input value.2957///2958/// The return value is a floating point scalar or vector containing the low2959/// prevision partial derivative of the input value.2960 2961_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)2962_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddx_coarse)2963half ddx_coarse(half);2964_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)2965_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddx_coarse)2966half2 ddx_coarse(half2);2967_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)2968_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddx_coarse)2969half3 ddx_coarse(half3);2970_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)2971_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddx_coarse)2972half4 ddx_coarse(half4);2973 2974_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddx_coarse)2975float ddx_coarse(float);2976_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddx_coarse)2977float2 ddx_coarse(float2);2978_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddx_coarse)2979float3 ddx_coarse(float3);2980_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddx_coarse)2981float4 ddx_coarse(float4);2982 2983//===----------------------------------------------------------------------===//2984// ddy_coarse builtin2985//===----------------------------------------------------------------------===//2986 2987/// \fn T ddy_coarse(T value)2988/// \brief Computes a low precision partial derivative with respect to the2989/// screen-space y-coordinate.2990/// \param value The input value.2991///2992/// The return value is a floating point scalar or vector containing the low2993/// prevision partial derivative of the input value.2994 2995_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)2996_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddy_coarse)2997half ddy_coarse(half);2998_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)2999_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddy_coarse)3000half2 ddy_coarse(half2);3001_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)3002_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddy_coarse)3003half3 ddy_coarse(half3);3004_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)3005_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddy_coarse)3006half4 ddy_coarse(half4);3007 3008_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddy_coarse)3009float ddy_coarse(float);3010_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddy_coarse)3011float2 ddy_coarse(float2);3012_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddy_coarse)3013float3 ddy_coarse(float3);3014_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_ddy_coarse)3015float4 ddy_coarse(float4);3016 3017} // namespace hlsl3018#endif //_HLSL_HLSL_ALIAS_INTRINSICS_H_3019