clang 20.0.0git
hlsl_intrinsics.h
Go to the documentation of this file.
1//===----- hlsl_intrinsics.h - HLSL 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-exception
6//
7//===----------------------------------------------------------------------===//
8
9#ifndef _HLSL_HLSL_INTRINSICS_H_
10#define _HLSL_HLSL_INTRINSICS_H_
11
12#include "hlsl_detail.h"
13
14namespace hlsl {
15
16// Note: Functions in this file are sorted alphabetically, then grouped by base
17// element type, and the element types are sorted by size, then singed integer,
18// unsigned integer and floating point. Keeping this ordering consistent will
19// help keep this file manageable as it grows.
20
21#define _HLSL_BUILTIN_ALIAS(builtin) \
22 __attribute__((clang_builtin_alias(builtin)))
23#define _HLSL_AVAILABILITY(platform, version) \
24 __attribute__((availability(platform, introduced = version)))
25#define _HLSL_AVAILABILITY_STAGE(platform, version, stage) \
26 __attribute__(( \
27 availability(platform, introduced = version, environment = stage)))
28
29#ifdef __HLSL_ENABLE_16_BIT
30#define _HLSL_16BIT_AVAILABILITY(platform, version) \
31 __attribute__((availability(platform, introduced = version)))
32#define _HLSL_16BIT_AVAILABILITY_STAGE(platform, version, stage) \
33 __attribute__(( \
34 availability(platform, introduced = version, environment = stage)))
35#else
36#define _HLSL_16BIT_AVAILABILITY(environment, version)
37#define _HLSL_16BIT_AVAILABILITY_STAGE(environment, version, stage)
38#endif
39
40//===----------------------------------------------------------------------===//
41// abs builtins
42//===----------------------------------------------------------------------===//
43
44/// \fn T abs(T Val)
45/// \brief Returns the absolute value of the input value, \a Val.
46/// \param Val The input value.
47
48#ifdef __HLSL_ENABLE_16_BIT
49_HLSL_AVAILABILITY(shadermodel, 6.2)
50_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)
51int16_t abs(int16_t);
52_HLSL_AVAILABILITY(shadermodel, 6.2)
53_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)
54int16_t2 abs(int16_t2);
55_HLSL_AVAILABILITY(shadermodel, 6.2)
56_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)
57int16_t3 abs(int16_t3);
58_HLSL_AVAILABILITY(shadermodel, 6.2)
59_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)
60int16_t4 abs(int16_t4);
61#endif
62
63_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
64_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)
65half abs(half);
66_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
67_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)
69_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
70_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)
72_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
73_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)
75
76_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)
77int abs(int);
78_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)
80_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)
82_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)
84
85_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)
86float abs(float);
87_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)
89_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)
91_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)
93
94_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)
96_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)
98_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)
100_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)
102
103_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)
104double abs(double);
105_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)
107_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)
109_HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs)
111
112//===----------------------------------------------------------------------===//
113// acos builtins
114//===----------------------------------------------------------------------===//
115
116/// \fn T acos(T Val)
117/// \brief Returns the arccosine of the input value, \a Val.
118/// \param Val The input value.
119
120#ifdef __HLSL_ENABLE_16_BIT
121_HLSL_BUILTIN_ALIAS(__builtin_elementwise_acos)
122half acos(half);
123_HLSL_BUILTIN_ALIAS(__builtin_elementwise_acos)
125_HLSL_BUILTIN_ALIAS(__builtin_elementwise_acos)
127_HLSL_BUILTIN_ALIAS(__builtin_elementwise_acos)
129#endif
130
131_HLSL_BUILTIN_ALIAS(__builtin_elementwise_acos)
132float acos(float);
133_HLSL_BUILTIN_ALIAS(__builtin_elementwise_acos)
135_HLSL_BUILTIN_ALIAS(__builtin_elementwise_acos)
137_HLSL_BUILTIN_ALIAS(__builtin_elementwise_acos)
139
140//===----------------------------------------------------------------------===//
141// all builtins
142//===----------------------------------------------------------------------===//
143
144/// \fn bool all(T x)
145/// \brief Returns True if all components of the \a x parameter are non-zero;
146/// otherwise, false. \param x The input value.
147
148#ifdef __HLSL_ENABLE_16_BIT
149_HLSL_AVAILABILITY(shadermodel, 6.2)
150_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
151bool all(int16_t);
152_HLSL_AVAILABILITY(shadermodel, 6.2)
153_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
154bool all(int16_t2);
155_HLSL_AVAILABILITY(shadermodel, 6.2)
156_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
157bool all(int16_t3);
158_HLSL_AVAILABILITY(shadermodel, 6.2)
159_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
160bool all(int16_t4);
161_HLSL_AVAILABILITY(shadermodel, 6.2)
162_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
163bool all(uint16_t);
164_HLSL_AVAILABILITY(shadermodel, 6.2)
165_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
166bool all(uint16_t2);
167_HLSL_AVAILABILITY(shadermodel, 6.2)
168_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
169bool all(uint16_t3);
170_HLSL_AVAILABILITY(shadermodel, 6.2)
171_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
172bool all(uint16_t4);
173#endif
174
175_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
176_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
177bool all(half);
178_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
179_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
180bool all(half2);
181_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
182_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
183bool all(half3);
184_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
185_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
186bool all(half4);
187
188_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
189bool all(bool);
190_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
191bool all(bool2);
192_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
193bool all(bool3);
194_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
195bool all(bool4);
196_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
197
198_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
199bool all(int);
200_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
201bool all(int2);
202_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
203bool all(int3);
204_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
205bool all(int4);
206
207_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
208bool all(uint);
209_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
210bool all(uint2);
211_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
212bool all(uint3);
213_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
214bool all(uint4);
215
216_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
217bool all(float);
218_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
220_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
222_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
224
225_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
227_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
229_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
231_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
233
234_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
236_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
238_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
240_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
242
243_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
244bool all(double);
245_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
247_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
249_HLSL_BUILTIN_ALIAS(__builtin_hlsl_all)
251
252//===----------------------------------------------------------------------===//
253// any builtins
254//===----------------------------------------------------------------------===//
255
256/// \fn bool any(T x)
257/// \brief Returns True if any components of the \a x parameter are non-zero;
258/// otherwise, false. \param x The input value.
259
260#ifdef __HLSL_ENABLE_16_BIT
261_HLSL_AVAILABILITY(shadermodel, 6.2)
262_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
263bool any(int16_t);
264_HLSL_AVAILABILITY(shadermodel, 6.2)
265_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
266bool any(int16_t2);
267_HLSL_AVAILABILITY(shadermodel, 6.2)
268_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
269bool any(int16_t3);
270_HLSL_AVAILABILITY(shadermodel, 6.2)
271_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
272bool any(int16_t4);
273_HLSL_AVAILABILITY(shadermodel, 6.2)
274_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
275bool any(uint16_t);
276_HLSL_AVAILABILITY(shadermodel, 6.2)
277_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
278bool any(uint16_t2);
279_HLSL_AVAILABILITY(shadermodel, 6.2)
280_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
281bool any(uint16_t3);
282_HLSL_AVAILABILITY(shadermodel, 6.2)
283_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
284bool any(uint16_t4);
285#endif
286
287_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
288_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
289bool any(half);
290_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
291_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
292bool any(half2);
293_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
294_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
295bool any(half3);
296_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
297_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
298bool any(half4);
299
300_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
301bool any(bool);
302_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
303bool any(bool2);
304_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
305bool any(bool3);
306_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
307bool any(bool4);
308_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
309
310_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
311bool any(int);
312_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
313bool any(int2);
314_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
315bool any(int3);
316_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
317bool any(int4);
318
319_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
320bool any(uint);
321_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
322bool any(uint2);
323_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
324bool any(uint3);
325_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
326bool any(uint4);
327
328_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
329bool any(float);
330_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
332_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
334_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
336
337_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
339_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
341_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
343_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
345
346_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
348_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
350_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
352_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
354
355_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
356bool any(double);
357_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
359_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
361_HLSL_BUILTIN_ALIAS(__builtin_hlsl_any)
363
364//===----------------------------------------------------------------------===//
365// asdouble builtins
366//===----------------------------------------------------------------------===//
367
368/// \fn double asdouble(uint LowBits, uint HighBits)
369/// \brief Reinterprets a cast value (two 32-bit values) into a double.
370/// \param LowBits The low 32-bit pattern of the input value.
371/// \param HighBits The high 32-bit pattern of the input value.
372
373_HLSL_BUILTIN_ALIAS(__builtin_hlsl_asdouble)
375_HLSL_BUILTIN_ALIAS(__builtin_hlsl_asdouble)
377_HLSL_BUILTIN_ALIAS(__builtin_hlsl_asdouble)
379_HLSL_BUILTIN_ALIAS(__builtin_hlsl_asdouble)
381
382//===----------------------------------------------------------------------===//
383// asfloat builtins
384//===----------------------------------------------------------------------===//
385
386/// \fn float asfloat(T Val)
387/// \brief Interprets the bit pattern of x as float point number.
388/// \param Val The input value.
389
390template <typename T, int N>
391constexpr vector<float, N> asfloat(vector<T, N> V) {
392 return __detail::bit_cast<float, T, N>(V);
393}
394
395template <typename T> constexpr float asfloat(T F) {
396 return __detail::bit_cast<float, T>(F);
397}
398
399//===----------------------------------------------------------------------===//
400// asint builtins
401//===----------------------------------------------------------------------===//
402
403/// \fn int asint(T Val)
404/// \brief Interprets the bit pattern of x as an integer.
405/// \param Val The input value.
406
407template <typename T, int N> constexpr vector<int, N> asint(vector<T, N> V) {
408 return __detail::bit_cast<int, T, N>(V);
409}
410
411template <typename T> constexpr int asint(T F) {
412 return __detail::bit_cast<int, T>(F);
413}
414
415//===----------------------------------------------------------------------===//
416// asin builtins
417//===----------------------------------------------------------------------===//
418
419/// \fn T asin(T Val)
420/// \brief Returns the arcsine of the input value, \a Val.
421/// \param Val The input value.
422
423#ifdef __HLSL_ENABLE_16_BIT
424_HLSL_BUILTIN_ALIAS(__builtin_elementwise_asin)
425half asin(half);
426_HLSL_BUILTIN_ALIAS(__builtin_elementwise_asin)
428_HLSL_BUILTIN_ALIAS(__builtin_elementwise_asin)
430_HLSL_BUILTIN_ALIAS(__builtin_elementwise_asin)
432#endif
433
434_HLSL_BUILTIN_ALIAS(__builtin_elementwise_asin)
435float asin(float);
436_HLSL_BUILTIN_ALIAS(__builtin_elementwise_asin)
438_HLSL_BUILTIN_ALIAS(__builtin_elementwise_asin)
440_HLSL_BUILTIN_ALIAS(__builtin_elementwise_asin)
442
443//===----------------------------------------------------------------------===//
444// asuint builtins
445//===----------------------------------------------------------------------===//
446
447/// \fn uint asuint(T Val)
448/// \brief Interprets the bit pattern of x as an unsigned integer.
449/// \param Val The input value.
450
451template <typename T, int N> constexpr vector<uint, N> asuint(vector<T, N> V) {
452 return __detail::bit_cast<uint, T, N>(V);
453}
454
455template <typename T> constexpr uint asuint(T F) {
456 return __detail::bit_cast<uint, T>(F);
457}
458
459//===----------------------------------------------------------------------===//
460// asuint splitdouble builtins
461//===----------------------------------------------------------------------===//
462
463/// \fn void asuint(double D, out uint lowbits, out int highbits)
464/// \brief Split and interprets the lowbits and highbits of double D into uints.
465/// \param D The input double.
466/// \param lowbits The output lowbits of D.
467/// \param highbits The output highbits of D.
468_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_splitdouble)
469void asuint(double, out uint, out uint);
470_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_splitdouble)
471void asuint(double2, out uint2, out uint2);
472_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_splitdouble)
473void asuint(double3, out uint3, out uint3);
474_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_splitdouble)
475void asuint(double4, out uint4, out uint4);
476
477//===----------------------------------------------------------------------===//
478// atan builtins
479//===----------------------------------------------------------------------===//
480
481/// \fn T atan(T Val)
482/// \brief Returns the arctangent of the input value, \a Val.
483/// \param Val The input value.
484
485#ifdef __HLSL_ENABLE_16_BIT
486_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan)
487half atan(half);
488_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan)
490_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan)
492_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan)
494#endif
495
496_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan)
497float atan(float);
498_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan)
500_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan)
502_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan)
504
505//===----------------------------------------------------------------------===//
506// atan2 builtins
507//===----------------------------------------------------------------------===//
508
509/// \fn T atan2(T y, T x)
510/// \brief Returns the arctangent of y/x, using the signs of the arguments to
511/// determine the correct quadrant.
512/// \param y The y-coordinate.
513/// \param x The x-coordinate.
514
515#ifdef __HLSL_ENABLE_16_BIT
516_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)
517half atan2(half y, half x);
518_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)
519half2 atan2(half2 y, half2 x);
520_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)
521half3 atan2(half3 y, half3 x);
522_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)
523half4 atan2(half4 y, half4 x);
524#endif
525
526_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)
527float atan2(float y, float x);
528_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)
530_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)
532_HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2)
534
535//===----------------------------------------------------------------------===//
536// ceil builtins
537//===----------------------------------------------------------------------===//
538
539/// \fn T ceil(T Val)
540/// \brief Returns the smallest integer value that is greater than or equal to
541/// the input value, \a Val.
542/// \param Val The input value.
543
544_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
545_HLSL_BUILTIN_ALIAS(__builtin_elementwise_ceil)
546half ceil(half);
547_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
548_HLSL_BUILTIN_ALIAS(__builtin_elementwise_ceil)
550_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
551_HLSL_BUILTIN_ALIAS(__builtin_elementwise_ceil)
553_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
554_HLSL_BUILTIN_ALIAS(__builtin_elementwise_ceil)
556
557_HLSL_BUILTIN_ALIAS(__builtin_elementwise_ceil)
558float ceil(float);
559_HLSL_BUILTIN_ALIAS(__builtin_elementwise_ceil)
561_HLSL_BUILTIN_ALIAS(__builtin_elementwise_ceil)
563_HLSL_BUILTIN_ALIAS(__builtin_elementwise_ceil)
565
566//===----------------------------------------------------------------------===//
567// clamp builtins
568//===----------------------------------------------------------------------===//
569
570/// \fn T clamp(T X, T Min, T Max)
571/// \brief Clamps the specified value \a X to the specified
572/// minimum ( \a Min) and maximum ( \a Max) range.
573/// \param X A value to clamp.
574/// \param Min The specified minimum range.
575/// \param Max The specified maximum range.
576///
577/// Returns The clamped value for the \a X parameter.
578/// For values of -INF or INF, clamp will behave as expected.
579/// However for values of NaN, the results are undefined.
580
581_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
582_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)
583half clamp(half, half, half);
584_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
585_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)
587_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
588_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)
590_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
591_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)
593
594#ifdef __HLSL_ENABLE_16_BIT
595_HLSL_AVAILABILITY(shadermodel, 6.2)
596_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)
597int16_t clamp(int16_t, int16_t, int16_t);
598_HLSL_AVAILABILITY(shadermodel, 6.2)
599_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)
600int16_t2 clamp(int16_t2, int16_t2, int16_t2);
601_HLSL_AVAILABILITY(shadermodel, 6.2)
602_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)
603int16_t3 clamp(int16_t3, int16_t3, int16_t3);
604_HLSL_AVAILABILITY(shadermodel, 6.2)
605_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)
606int16_t4 clamp(int16_t4, int16_t4, int16_t4);
607
608_HLSL_AVAILABILITY(shadermodel, 6.2)
609_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)
610uint16_t clamp(uint16_t, uint16_t, uint16_t);
611_HLSL_AVAILABILITY(shadermodel, 6.2)
612_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)
613uint16_t2 clamp(uint16_t2, uint16_t2, uint16_t2);
614_HLSL_AVAILABILITY(shadermodel, 6.2)
615_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)
616uint16_t3 clamp(uint16_t3, uint16_t3, uint16_t3);
617_HLSL_AVAILABILITY(shadermodel, 6.2)
618_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)
619uint16_t4 clamp(uint16_t4, uint16_t4, uint16_t4);
620#endif
621
622_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)
623int clamp(int, int, int);
624_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)
626_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)
628_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)
630
631_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)
633_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)
635_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)
637_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)
639
640_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)
642_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)
644_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)
646_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)
648
649_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)
651_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)
653_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)
655_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)
657
658_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)
659float clamp(float, float, float);
660_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)
662_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)
664_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)
666
667_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)
668double clamp(double, double, double);
669_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)
671_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)
673_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp)
675
676//===----------------------------------------------------------------------===//
677// clip builtins
678//===----------------------------------------------------------------------===//
679
680/// \fn void clip(T Val)
681/// \brief Discards the current pixel if the specified value is less than zero.
682/// \param Val The input value.
683
684_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clip)
685void clip(float);
686_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clip)
688_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clip)
690_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clip)
692
693//===----------------------------------------------------------------------===//
694// cos builtins
695//===----------------------------------------------------------------------===//
696
697/// \fn T cos(T Val)
698/// \brief Returns the cosine of the input value, \a Val.
699/// \param Val The input value.
700
701_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
702_HLSL_BUILTIN_ALIAS(__builtin_elementwise_cos)
703half cos(half);
704_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
705_HLSL_BUILTIN_ALIAS(__builtin_elementwise_cos)
707_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
708_HLSL_BUILTIN_ALIAS(__builtin_elementwise_cos)
710_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
711_HLSL_BUILTIN_ALIAS(__builtin_elementwise_cos)
713
714_HLSL_BUILTIN_ALIAS(__builtin_elementwise_cos)
715float cos(float);
716_HLSL_BUILTIN_ALIAS(__builtin_elementwise_cos)
718_HLSL_BUILTIN_ALIAS(__builtin_elementwise_cos)
720_HLSL_BUILTIN_ALIAS(__builtin_elementwise_cos)
722
723//===----------------------------------------------------------------------===//
724// cosh builtins
725//===----------------------------------------------------------------------===//
726
727/// \fn T cosh(T Val)
728/// \brief Returns the hyperbolic cosine of the input value, \a Val.
729/// \param Val The input value.
730
731#ifdef __HLSL_ENABLE_16_BIT
732_HLSL_BUILTIN_ALIAS(__builtin_elementwise_cosh)
733half cosh(half);
734_HLSL_BUILTIN_ALIAS(__builtin_elementwise_cosh)
736_HLSL_BUILTIN_ALIAS(__builtin_elementwise_cosh)
738_HLSL_BUILTIN_ALIAS(__builtin_elementwise_cosh)
740#endif
741
742_HLSL_BUILTIN_ALIAS(__builtin_elementwise_cosh)
743float cosh(float);
744_HLSL_BUILTIN_ALIAS(__builtin_elementwise_cosh)
746_HLSL_BUILTIN_ALIAS(__builtin_elementwise_cosh)
748_HLSL_BUILTIN_ALIAS(__builtin_elementwise_cosh)
750
751//===----------------------------------------------------------------------===//
752// count bits builtins
753//===----------------------------------------------------------------------===//
754
755/// \fn T countbits(T Val)
756/// \brief Return the number of bits (per component) set in the input integer.
757/// \param Val The input value.
758
759#ifdef __HLSL_ENABLE_16_BIT
760_HLSL_AVAILABILITY(shadermodel, 6.2)
761const inline uint countbits(int16_t x) {
762 return __builtin_elementwise_popcount(x);
763}
764_HLSL_AVAILABILITY(shadermodel, 6.2)
765const inline uint2 countbits(int16_t2 x) {
766 return __builtin_elementwise_popcount(x);
767}
768_HLSL_AVAILABILITY(shadermodel, 6.2)
769const inline uint3 countbits(int16_t3 x) {
770 return __builtin_elementwise_popcount(x);
771}
772_HLSL_AVAILABILITY(shadermodel, 6.2)
773const inline uint4 countbits(int16_t4 x) {
774 return __builtin_elementwise_popcount(x);
775}
776_HLSL_AVAILABILITY(shadermodel, 6.2)
777const inline uint countbits(uint16_t x) {
778 return __builtin_elementwise_popcount(x);
779}
780_HLSL_AVAILABILITY(shadermodel, 6.2)
781const inline uint2 countbits(uint16_t2 x) {
782 return __builtin_elementwise_popcount(x);
783}
784_HLSL_AVAILABILITY(shadermodel, 6.2)
785const inline uint3 countbits(uint16_t3 x) {
786 return __builtin_elementwise_popcount(x);
787}
788_HLSL_AVAILABILITY(shadermodel, 6.2)
789const inline uint4 countbits(uint16_t4 x) {
790 return __builtin_elementwise_popcount(x);
791}
792#endif
793
794const inline uint countbits(int x) { return __builtin_elementwise_popcount(x); }
795const inline uint2 countbits(int2 x) {
796 return __builtin_elementwise_popcount(x);
797}
798const inline uint3 countbits(int3 x) {
799 return __builtin_elementwise_popcount(x);
800}
801const inline uint4 countbits(int4 x) {
802 return __builtin_elementwise_popcount(x);
803}
804
805const inline uint countbits(uint x) {
806 return __builtin_elementwise_popcount(x);
807}
808const inline uint2 countbits(uint2 x) {
809 return __builtin_elementwise_popcount(x);
810}
811const inline uint3 countbits(uint3 x) {
812 return __builtin_elementwise_popcount(x);
813}
814const inline uint4 countbits(uint4 x) {
815 return __builtin_elementwise_popcount(x);
816}
817
818const inline uint countbits(int64_t x) {
819 return __builtin_elementwise_popcount(x);
820}
821const inline uint2 countbits(int64_t2 x) {
822 return __builtin_elementwise_popcount(x);
823}
824const inline uint3 countbits(int64_t3 x) {
825 return __builtin_elementwise_popcount(x);
826}
827const inline uint4 countbits(int64_t4 x) {
828 return __builtin_elementwise_popcount(x);
829}
830
831const inline uint countbits(uint64_t x) {
832 return __builtin_elementwise_popcount(x);
833}
834const inline uint2 countbits(uint64_t2 x) {
835 return __builtin_elementwise_popcount(x);
836}
837const inline uint3 countbits(uint64_t3 x) {
838 return __builtin_elementwise_popcount(x);
839}
840const inline uint4 countbits(uint64_t4 x) {
841 return __builtin_elementwise_popcount(x);
842}
843
844//===----------------------------------------------------------------------===//
845// degrees builtins
846//===----------------------------------------------------------------------===//
847
848/// \fn T degrees(T x)
849/// \brief Converts the specified value from radians to degrees.
850/// \param x The specified input value.
851
852_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
853_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_degrees)
854half degrees(half);
855_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
856_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_degrees)
858_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
859_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_degrees)
861_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
862_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_degrees)
864
865_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_degrees)
866float degrees(float);
867_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_degrees)
869_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_degrees)
871_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_degrees)
873
874//===----------------------------------------------------------------------===//
875// distance builtins
876//===----------------------------------------------------------------------===//
877
878/// \fn K distance(T X, T Y)
879/// \brief Returns a distance scalar between \a X and \a Y.
880/// \param X The X input value.
881/// \param Y The Y input value.
882
883_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
884const inline half distance(half X, half Y) {
885 return __detail::distance_impl(X, Y);
886}
887
888const inline float distance(float X, float Y) {
889 return __detail::distance_impl(X, Y);
890}
891
892template <int N>
893_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
894const inline half distance(vector<half, N> X, vector<half, N> Y) {
896}
897
898template <int N>
899const inline float distance(vector<float, N> X, vector<float, N> Y) {
901}
902
903//===----------------------------------------------------------------------===//
904// dot product builtins
905//===----------------------------------------------------------------------===//
906
907/// \fn K dot(T X, T Y)
908/// \brief Return the dot product (a scalar value) of \a X and \a Y.
909/// \param X The X input value.
910/// \param Y The Y input value.
911
912_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
913_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)
914half dot(half, half);
915_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
916_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)
918_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
919_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)
921_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
922_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)
924
925#ifdef __HLSL_ENABLE_16_BIT
926_HLSL_AVAILABILITY(shadermodel, 6.2)
927_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)
928int16_t dot(int16_t, int16_t);
929_HLSL_AVAILABILITY(shadermodel, 6.2)
930_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)
931int16_t dot(int16_t2, int16_t2);
932_HLSL_AVAILABILITY(shadermodel, 6.2)
933_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)
934int16_t dot(int16_t3, int16_t3);
935_HLSL_AVAILABILITY(shadermodel, 6.2)
936_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)
937int16_t dot(int16_t4, int16_t4);
938
939_HLSL_AVAILABILITY(shadermodel, 6.2)
940_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)
941uint16_t dot(uint16_t, uint16_t);
942_HLSL_AVAILABILITY(shadermodel, 6.2)
943_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)
944uint16_t dot(uint16_t2, uint16_t2);
945_HLSL_AVAILABILITY(shadermodel, 6.2)
946_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)
947uint16_t dot(uint16_t3, uint16_t3);
948_HLSL_AVAILABILITY(shadermodel, 6.2)
949_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)
950uint16_t dot(uint16_t4, uint16_t4);
951#endif
952
953_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)
954float dot(float, float);
955_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)
957_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)
959_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)
961
962_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)
963double dot(double, double);
964
965_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)
966int dot(int, int);
967_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)
969_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)
971_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)
973
974_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)
976_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)
978_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)
980_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)
982
983_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)
985_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)
987_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)
989_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)
991
992_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)
994_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)
996_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)
998_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot)
1000
1001//===----------------------------------------------------------------------===//
1002// dot4add builtins
1003//===----------------------------------------------------------------------===//
1004
1005/// \fn int dot4add_i8packed(uint A, uint B, int C)
1006
1007_HLSL_AVAILABILITY(shadermodel, 6.4)
1008_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot4add_i8packed)
1010
1011/// \fn uint dot4add_u8packed(uint A, uint B, uint C)
1012
1013_HLSL_AVAILABILITY(shadermodel, 6.4)
1014_HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot4add_u8packed)
1016
1017//===----------------------------------------------------------------------===//
1018// exp builtins
1019//===----------------------------------------------------------------------===//
1020
1021/// \fn T exp(T x)
1022/// \brief Returns the base-e exponential, or \a e**x, of the specified value.
1023/// \param x The specified input value.
1024///
1025/// The return value is the base-e exponential of the \a x parameter.
1026
1027_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1028_HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp)
1029half exp(half);
1030_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1031_HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp)
1033_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1034_HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp)
1036_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1037_HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp)
1039
1040_HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp)
1041float exp(float);
1042_HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp)
1044_HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp)
1046_HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp)
1048
1049//===----------------------------------------------------------------------===//
1050// exp2 builtins
1051//===----------------------------------------------------------------------===//
1052
1053/// \fn T exp2(T x)
1054/// \brief Returns the base 2 exponential, or \a 2**x, of the specified value.
1055/// \param x The specified input value.
1056///
1057/// The base 2 exponential of the \a x parameter.
1058
1059_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1060_HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp2)
1061half exp2(half);
1062_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1063_HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp2)
1065_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1066_HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp2)
1068_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1069_HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp2)
1071
1072_HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp2)
1073float exp2(float);
1074_HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp2)
1076_HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp2)
1078_HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp2)
1080
1081//===----------------------------------------------------------------------===//
1082// firstbithigh builtins
1083//===----------------------------------------------------------------------===//
1084
1085/// \fn T firstbithigh(T Val)
1086/// \brief Returns the location of the first set bit starting from the highest
1087/// order bit and working downward, per component.
1088/// \param Val the input value.
1089
1090#ifdef __HLSL_ENABLE_16_BIT
1091_HLSL_AVAILABILITY(shadermodel, 6.2)
1092_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbithigh)
1093uint firstbithigh(int16_t);
1094_HLSL_AVAILABILITY(shadermodel, 6.2)
1095_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbithigh)
1096uint2 firstbithigh(int16_t2);
1097_HLSL_AVAILABILITY(shadermodel, 6.2)
1098_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbithigh)
1099uint3 firstbithigh(int16_t3);
1100_HLSL_AVAILABILITY(shadermodel, 6.2)
1101_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbithigh)
1102uint4 firstbithigh(int16_t4);
1103_HLSL_AVAILABILITY(shadermodel, 6.2)
1104_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbithigh)
1105uint firstbithigh(uint16_t);
1106_HLSL_AVAILABILITY(shadermodel, 6.2)
1107_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbithigh)
1108uint2 firstbithigh(uint16_t2);
1109_HLSL_AVAILABILITY(shadermodel, 6.2)
1110_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbithigh)
1111uint3 firstbithigh(uint16_t3);
1112_HLSL_AVAILABILITY(shadermodel, 6.2)
1113_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbithigh)
1114uint4 firstbithigh(uint16_t4);
1115#endif
1116
1117_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbithigh)
1119_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbithigh)
1121_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbithigh)
1123_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbithigh)
1125
1126_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbithigh)
1128_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbithigh)
1130_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbithigh)
1132_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbithigh)
1134
1135_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbithigh)
1137_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbithigh)
1139_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbithigh)
1141_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbithigh)
1143
1144_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbithigh)
1146_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbithigh)
1148_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbithigh)
1150_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbithigh)
1152
1153//===----------------------------------------------------------------------===//
1154// firstbitlow builtins
1155//===----------------------------------------------------------------------===//
1156
1157/// \fn T firstbitlow(T Val)
1158/// \brief Returns the location of the first set bit starting from the lowest
1159/// order bit and working upward, per component.
1160/// \param Val the input value.
1161
1162#ifdef __HLSL_ENABLE_16_BIT
1163_HLSL_AVAILABILITY(shadermodel, 6.2)
1164_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)
1165uint firstbitlow(int16_t);
1166_HLSL_AVAILABILITY(shadermodel, 6.2)
1167_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)
1168uint2 firstbitlow(int16_t2);
1169_HLSL_AVAILABILITY(shadermodel, 6.2)
1170_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)
1171uint3 firstbitlow(int16_t3);
1172_HLSL_AVAILABILITY(shadermodel, 6.2)
1173_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)
1174uint4 firstbitlow(int16_t4);
1175_HLSL_AVAILABILITY(shadermodel, 6.2)
1176_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)
1177uint firstbitlow(uint16_t);
1178_HLSL_AVAILABILITY(shadermodel, 6.2)
1179_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)
1180uint2 firstbitlow(uint16_t2);
1181_HLSL_AVAILABILITY(shadermodel, 6.2)
1182_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)
1183uint3 firstbitlow(uint16_t3);
1184_HLSL_AVAILABILITY(shadermodel, 6.2)
1185_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)
1186uint4 firstbitlow(uint16_t4);
1187#endif
1188
1189_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)
1191_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)
1193_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)
1195_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)
1197
1198_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)
1200_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)
1202_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)
1204_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)
1206
1207_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)
1209_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)
1211_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)
1213_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)
1215
1216_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)
1218_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)
1220_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)
1222_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow)
1224
1225//===----------------------------------------------------------------------===//
1226// floor builtins
1227//===----------------------------------------------------------------------===//
1228
1229/// \fn T floor(T Val)
1230/// \brief Returns the largest integer that is less than or equal to the input
1231/// value, \a Val.
1232/// \param Val The input value.
1233
1234_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1235_HLSL_BUILTIN_ALIAS(__builtin_elementwise_floor)
1236half floor(half);
1237_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1238_HLSL_BUILTIN_ALIAS(__builtin_elementwise_floor)
1240_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1241_HLSL_BUILTIN_ALIAS(__builtin_elementwise_floor)
1243_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1244_HLSL_BUILTIN_ALIAS(__builtin_elementwise_floor)
1246
1247_HLSL_BUILTIN_ALIAS(__builtin_elementwise_floor)
1248float floor(float);
1249_HLSL_BUILTIN_ALIAS(__builtin_elementwise_floor)
1251_HLSL_BUILTIN_ALIAS(__builtin_elementwise_floor)
1253_HLSL_BUILTIN_ALIAS(__builtin_elementwise_floor)
1255
1256//===----------------------------------------------------------------------===//
1257// fmod builtins
1258//===----------------------------------------------------------------------===//
1259
1260/// \fn T fmod(T x, T y)
1261/// \brief Returns the linear interpolation of x to y.
1262/// \param x [in] The dividend.
1263/// \param y [in] The divisor.
1264///
1265/// Return the floating-point remainder of the x parameter divided by the y
1266/// parameter.
1267
1268_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1269_HLSL_BUILTIN_ALIAS(__builtin_elementwise_fmod)
1270half fmod(half, half);
1271_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1272_HLSL_BUILTIN_ALIAS(__builtin_elementwise_fmod)
1274_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1275_HLSL_BUILTIN_ALIAS(__builtin_elementwise_fmod)
1277_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1278_HLSL_BUILTIN_ALIAS(__builtin_elementwise_fmod)
1280
1281_HLSL_BUILTIN_ALIAS(__builtin_elementwise_fmod)
1282float fmod(float, float);
1283_HLSL_BUILTIN_ALIAS(__builtin_elementwise_fmod)
1285_HLSL_BUILTIN_ALIAS(__builtin_elementwise_fmod)
1287_HLSL_BUILTIN_ALIAS(__builtin_elementwise_fmod)
1289
1290//===----------------------------------------------------------------------===//
1291// frac builtins
1292//===----------------------------------------------------------------------===//
1293
1294/// \fn T frac(T x)
1295/// \brief Returns the fractional (or decimal) part of x. \a x parameter.
1296/// \param x The specified input value.
1297///
1298/// If \a the return value is greater than or equal to 0 and less than 1.
1299
1300_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1301_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_frac)
1302half frac(half);
1303_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1304_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_frac)
1306_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1307_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_frac)
1309_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1310_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_frac)
1312
1313_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_frac)
1314float frac(float);
1315_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_frac)
1317_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_frac)
1319_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_frac)
1321
1322//===----------------------------------------------------------------------===//
1323// isinf builtins
1324//===----------------------------------------------------------------------===//
1325
1326/// \fn T isinf(T x)
1327/// \brief Determines if the specified value \a x is infinite.
1328/// \param x The specified input value.
1329///
1330/// Returns a value of the same size as the input, with a value set
1331/// to True if the x parameter is +INF or -INF. Otherwise, False.
1332
1333_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1334_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_isinf)
1335bool isinf(half);
1336_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1337_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_isinf)
1339_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1340_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_isinf)
1342_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1343_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_isinf)
1345
1346_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_isinf)
1347bool isinf(float);
1348_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_isinf)
1350_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_isinf)
1352_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_isinf)
1354
1355//===----------------------------------------------------------------------===//
1356// lerp builtins
1357//===----------------------------------------------------------------------===//
1358
1359/// \fn T lerp(T x, T y, T s)
1360/// \brief Returns the linear interpolation of x to y by s.
1361/// \param x [in] The first-floating point value.
1362/// \param y [in] The second-floating point value.
1363/// \param s [in] A value that linearly interpolates between the x parameter and
1364/// the y parameter.
1365///
1366/// Linear interpolation is based on the following formula: x*(1-s) + y*s which
1367/// can equivalently be written as x + s(y-x).
1368
1369_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1370_HLSL_BUILTIN_ALIAS(__builtin_hlsl_lerp)
1371half lerp(half, half, half);
1372_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1373_HLSL_BUILTIN_ALIAS(__builtin_hlsl_lerp)
1375_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1376_HLSL_BUILTIN_ALIAS(__builtin_hlsl_lerp)
1378_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1379_HLSL_BUILTIN_ALIAS(__builtin_hlsl_lerp)
1381
1382_HLSL_BUILTIN_ALIAS(__builtin_hlsl_lerp)
1383float lerp(float, float, float);
1384_HLSL_BUILTIN_ALIAS(__builtin_hlsl_lerp)
1386_HLSL_BUILTIN_ALIAS(__builtin_hlsl_lerp)
1388_HLSL_BUILTIN_ALIAS(__builtin_hlsl_lerp)
1390
1391//===----------------------------------------------------------------------===//
1392// length builtins
1393//===----------------------------------------------------------------------===//
1394
1395/// \fn T length(T x)
1396/// \brief Returns the length of the specified floating-point vector.
1397/// \param x [in] The vector of floats, or a scalar float.
1398///
1399/// Length is based on the following formula: sqrt(x[0]^2 + x[1]^2 + ...).
1400
1401_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1402const inline half length(half X) { return __detail::length_impl(X); }
1403const inline float length(float X) { return __detail::length_impl(X); }
1404
1405template <int N>
1406_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1407const inline half length(vector<half, N> X) {
1409}
1410
1411template <int N> const inline float length(vector<float, N> X) {
1413}
1414
1415//===----------------------------------------------------------------------===//
1416// log builtins
1417//===----------------------------------------------------------------------===//
1418
1419/// \fn T log(T Val)
1420/// \brief The base-e logarithm of the input value, \a Val parameter.
1421/// \param Val The input value.
1422///
1423/// If \a Val is negative, this result is undefined. If \a Val is 0, this
1424/// function returns negative infinity.
1425
1426_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1427_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log)
1428half log(half);
1429_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1430_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log)
1432_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1433_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log)
1435_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1436_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log)
1438
1439_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log)
1440float log(float);
1441_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log)
1443_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log)
1445_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log)
1447
1448//===----------------------------------------------------------------------===//
1449// log10 builtins
1450//===----------------------------------------------------------------------===//
1451
1452/// \fn T log10(T Val)
1453/// \brief The base-10 logarithm of the input value, \a Val parameter.
1454/// \param Val The input value.
1455///
1456/// If \a Val is negative, this result is undefined. If \a Val is 0, this
1457/// function returns negative infinity.
1458
1459_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1460_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log10)
1461half log10(half);
1462_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1463_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log10)
1465_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1466_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log10)
1468_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1469_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log10)
1471
1472_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log10)
1473float log10(float);
1474_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log10)
1476_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log10)
1478_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log10)
1480
1481//===----------------------------------------------------------------------===//
1482// log2 builtins
1483//===----------------------------------------------------------------------===//
1484
1485/// \fn T log2(T Val)
1486/// \brief The base-2 logarithm of the input value, \a Val parameter.
1487/// \param Val The input value.
1488///
1489/// If \a Val is negative, this result is undefined. If \a Val is 0, this
1490/// function returns negative infinity.
1491
1492_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1493_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log2)
1494half log2(half);
1495_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1496_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log2)
1498_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1499_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log2)
1501_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1502_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log2)
1504
1505_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log2)
1506float log2(float);
1507_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log2)
1509_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log2)
1511_HLSL_BUILTIN_ALIAS(__builtin_elementwise_log2)
1513
1514//===----------------------------------------------------------------------===//
1515// mad builtins
1516//===----------------------------------------------------------------------===//
1517
1518/// \fn T mad(T M, T A, T B)
1519/// \brief The result of \a M * \a A + \a B.
1520/// \param M The multiplication value.
1521/// \param A The first addition value.
1522/// \param B The second addition value.
1523
1524_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1525_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)
1526half mad(half, half, half);
1527_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1528_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)
1530_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1531_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)
1533_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1534_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)
1536
1537#ifdef __HLSL_ENABLE_16_BIT
1538_HLSL_AVAILABILITY(shadermodel, 6.2)
1539_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)
1540int16_t mad(int16_t, int16_t, int16_t);
1541_HLSL_AVAILABILITY(shadermodel, 6.2)
1542_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)
1543int16_t2 mad(int16_t2, int16_t2, int16_t2);
1544_HLSL_AVAILABILITY(shadermodel, 6.2)
1545_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)
1546int16_t3 mad(int16_t3, int16_t3, int16_t3);
1547_HLSL_AVAILABILITY(shadermodel, 6.2)
1548_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)
1549int16_t4 mad(int16_t4, int16_t4, int16_t4);
1550
1551_HLSL_AVAILABILITY(shadermodel, 6.2)
1552_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)
1553uint16_t mad(uint16_t, uint16_t, uint16_t);
1554_HLSL_AVAILABILITY(shadermodel, 6.2)
1555_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)
1556uint16_t2 mad(uint16_t2, uint16_t2, uint16_t2);
1557_HLSL_AVAILABILITY(shadermodel, 6.2)
1558_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)
1559uint16_t3 mad(uint16_t3, uint16_t3, uint16_t3);
1560_HLSL_AVAILABILITY(shadermodel, 6.2)
1561_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)
1562uint16_t4 mad(uint16_t4, uint16_t4, uint16_t4);
1563#endif
1564
1565_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)
1566int mad(int, int, int);
1567_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)
1569_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)
1571_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)
1573
1574_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)
1576_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)
1578_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)
1580_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)
1582
1583_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)
1585_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)
1587_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)
1589_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)
1591
1592_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)
1594_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)
1596_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)
1598_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)
1600
1601_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)
1602float mad(float, float, float);
1603_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)
1605_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)
1607_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)
1609
1610_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)
1611double mad(double, double, double);
1612_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)
1614_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)
1616_HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad)
1618
1619//===----------------------------------------------------------------------===//
1620// max builtins
1621//===----------------------------------------------------------------------===//
1622
1623/// \fn T max(T X, T Y)
1624/// \brief Return the greater of \a X and \a Y.
1625/// \param X The X input value.
1626/// \param Y The Y input value.
1627
1628_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1629_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
1630half max(half, half);
1631_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1632_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
1634_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1635_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
1637_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1638_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
1640
1641#ifdef __HLSL_ENABLE_16_BIT
1642_HLSL_AVAILABILITY(shadermodel, 6.2)
1643_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
1644int16_t max(int16_t, int16_t);
1645_HLSL_AVAILABILITY(shadermodel, 6.2)
1646_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
1647int16_t2 max(int16_t2, int16_t2);
1648_HLSL_AVAILABILITY(shadermodel, 6.2)
1649_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
1650int16_t3 max(int16_t3, int16_t3);
1651_HLSL_AVAILABILITY(shadermodel, 6.2)
1652_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
1653int16_t4 max(int16_t4, int16_t4);
1654
1655_HLSL_AVAILABILITY(shadermodel, 6.2)
1656_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
1657uint16_t max(uint16_t, uint16_t);
1658_HLSL_AVAILABILITY(shadermodel, 6.2)
1659_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
1660uint16_t2 max(uint16_t2, uint16_t2);
1661_HLSL_AVAILABILITY(shadermodel, 6.2)
1662_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
1663uint16_t3 max(uint16_t3, uint16_t3);
1664_HLSL_AVAILABILITY(shadermodel, 6.2)
1665_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
1666uint16_t4 max(uint16_t4, uint16_t4);
1667#endif
1668
1669_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
1670int max(int, int);
1671_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
1673_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
1675_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
1677
1678_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
1680_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
1682_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
1684_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
1686
1687_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
1689_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
1691_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
1693_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
1695
1696_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
1698_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
1700_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
1702_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
1704
1705_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
1706float max(float, float);
1707_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
1709_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
1711_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
1713
1714_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
1715double max(double, double);
1716_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
1718_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
1720_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
1722
1723//===----------------------------------------------------------------------===//
1724// min builtins
1725//===----------------------------------------------------------------------===//
1726
1727/// \fn T min(T X, T Y)
1728/// \brief Return the lesser of \a X and \a Y.
1729/// \param X The X input value.
1730/// \param Y The Y input value.
1731
1732_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1733_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
1734half min(half, half);
1735_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1736_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
1738_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1739_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
1741_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1742_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
1744
1745#ifdef __HLSL_ENABLE_16_BIT
1746_HLSL_AVAILABILITY(shadermodel, 6.2)
1747_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
1748int16_t min(int16_t, int16_t);
1749_HLSL_AVAILABILITY(shadermodel, 6.2)
1750_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
1751int16_t2 min(int16_t2, int16_t2);
1752_HLSL_AVAILABILITY(shadermodel, 6.2)
1753_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
1754int16_t3 min(int16_t3, int16_t3);
1755_HLSL_AVAILABILITY(shadermodel, 6.2)
1756_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
1757int16_t4 min(int16_t4, int16_t4);
1758
1759_HLSL_AVAILABILITY(shadermodel, 6.2)
1760_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
1761uint16_t min(uint16_t, uint16_t);
1762_HLSL_AVAILABILITY(shadermodel, 6.2)
1763_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
1764uint16_t2 min(uint16_t2, uint16_t2);
1765_HLSL_AVAILABILITY(shadermodel, 6.2)
1766_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
1767uint16_t3 min(uint16_t3, uint16_t3);
1768_HLSL_AVAILABILITY(shadermodel, 6.2)
1769_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
1770uint16_t4 min(uint16_t4, uint16_t4);
1771#endif
1772
1773_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
1774int min(int, int);
1775_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
1777_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
1779_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
1781
1782_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
1784_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
1786_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
1788_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
1790
1791_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
1792float min(float, float);
1793_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
1795_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
1797_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
1799
1800_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
1802_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
1804_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
1806_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
1808
1809_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
1811_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
1813_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
1815_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
1817
1818_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
1819double min(double, double);
1820_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
1822_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
1824_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
1826
1827//===----------------------------------------------------------------------===//
1828// normalize builtins
1829//===----------------------------------------------------------------------===//
1830
1831/// \fn T normalize(T x)
1832/// \brief Returns the normalized unit vector of the specified floating-point
1833/// vector. \param x [in] The vector of floats.
1834///
1835/// Normalize is based on the following formula: x / length(x).
1836
1837_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1838_HLSL_BUILTIN_ALIAS(__builtin_hlsl_normalize)
1839half normalize(half);
1840_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1841_HLSL_BUILTIN_ALIAS(__builtin_hlsl_normalize)
1843_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1844_HLSL_BUILTIN_ALIAS(__builtin_hlsl_normalize)
1846_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1847_HLSL_BUILTIN_ALIAS(__builtin_hlsl_normalize)
1849
1850_HLSL_BUILTIN_ALIAS(__builtin_hlsl_normalize)
1851float normalize(float);
1852_HLSL_BUILTIN_ALIAS(__builtin_hlsl_normalize)
1854_HLSL_BUILTIN_ALIAS(__builtin_hlsl_normalize)
1856_HLSL_BUILTIN_ALIAS(__builtin_hlsl_normalize)
1858
1859//===----------------------------------------------------------------------===//
1860// pow builtins
1861//===----------------------------------------------------------------------===//
1862
1863/// \fn T pow(T Val, T Pow)
1864/// \brief Return the value \a Val, raised to the power \a Pow.
1865/// \param Val The input value.
1866/// \param Pow The specified power.
1867
1868_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1869_HLSL_BUILTIN_ALIAS(__builtin_elementwise_pow)
1870half pow(half, half);
1871_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1872_HLSL_BUILTIN_ALIAS(__builtin_elementwise_pow)
1874_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1875_HLSL_BUILTIN_ALIAS(__builtin_elementwise_pow)
1877_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1878_HLSL_BUILTIN_ALIAS(__builtin_elementwise_pow)
1880
1881_HLSL_BUILTIN_ALIAS(__builtin_elementwise_pow)
1882float pow(float, float);
1883_HLSL_BUILTIN_ALIAS(__builtin_elementwise_pow)
1885_HLSL_BUILTIN_ALIAS(__builtin_elementwise_pow)
1887_HLSL_BUILTIN_ALIAS(__builtin_elementwise_pow)
1889
1890//===----------------------------------------------------------------------===//
1891// reversebits builtins
1892//===----------------------------------------------------------------------===//
1893
1894/// \fn T reversebits(T Val)
1895/// \brief Return the value \a Val with the bit order reversed.
1896/// \param Val The input value.
1897
1898#ifdef __HLSL_ENABLE_16_BIT
1899_HLSL_AVAILABILITY(shadermodel, 6.2)
1900_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)
1901uint16_t reversebits(uint16_t);
1902_HLSL_AVAILABILITY(shadermodel, 6.2)
1903_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)
1904uint16_t2 reversebits(uint16_t2);
1905_HLSL_AVAILABILITY(shadermodel, 6.2)
1906_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)
1907uint16_t3 reversebits(uint16_t3);
1908_HLSL_AVAILABILITY(shadermodel, 6.2)
1909_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)
1910uint16_t4 reversebits(uint16_t4);
1911#endif
1912
1913_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)
1915_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)
1917_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)
1919_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)
1921
1922_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)
1924_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)
1926_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)
1928_HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse)
1930
1931//===----------------------------------------------------------------------===//
1932// cross builtins
1933//===----------------------------------------------------------------------===//
1934
1935/// \fn T cross(T x, T y)
1936/// \brief Returns the cross product of two floating-point, 3D vectors.
1937/// \param x [in] The first floating-point, 3D vector.
1938/// \param y [in] The second floating-point, 3D vector.
1939///
1940/// Result is the cross product of x and y, i.e., the resulting
1941/// components are, in order :
1942/// x[1] * y[2] - y[1] * x[2]
1943/// x[2] * y[0] - y[2] * x[0]
1944/// x[0] * y[1] - y[0] * x[1]
1945
1946_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1947_HLSL_BUILTIN_ALIAS(__builtin_hlsl_cross)
1949
1950_HLSL_BUILTIN_ALIAS(__builtin_hlsl_cross)
1952
1953//===----------------------------------------------------------------------===//
1954// D3DCOLORtoUBYTE4 builtin
1955//===----------------------------------------------------------------------===//
1956
1957/// \fn T D3DCOLORtoUBYTE4(T x)
1958/// \brief Converts a floating-point, 4D vector set by a D3DCOLOR to a UBYTE4.
1959/// \param x [in] The floating-point vector4 to convert.
1960///
1961/// The return value is the UBYTE4 representation of the \a x parameter.
1962///
1963/// This function swizzles and scales components of the \a x parameter. Use this
1964/// function to compensate for the lack of UBYTE4 support in some hardware.
1965
1966constexpr vector<uint, 4> D3DCOLORtoUBYTE4(vector<float, 4> V) {
1968}
1969
1970//===----------------------------------------------------------------------===//
1971// rcp builtins
1972//===----------------------------------------------------------------------===//
1973
1974/// \fn T rcp(T x)
1975/// \brief Calculates a fast, approximate, per-component reciprocal ie 1 / \a x.
1976/// \param x The specified input value.
1977///
1978/// The return value is the reciprocal of the \a x parameter.
1979
1980_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1981_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rcp)
1982half rcp(half);
1983_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1984_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rcp)
1986_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1987_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rcp)
1989_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
1990_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rcp)
1992
1993_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rcp)
1994float rcp(float);
1995_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rcp)
1997_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rcp)
1999_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rcp)
2001
2002_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rcp)
2003double rcp(double);
2004_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rcp)
2006_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rcp)
2008_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rcp)
2010
2011//===----------------------------------------------------------------------===//
2012// rsqrt builtins
2013//===----------------------------------------------------------------------===//
2014
2015/// \fn T rsqrt(T x)
2016/// \brief Returns the reciprocal of the square root of the specified value.
2017/// ie 1 / sqrt( \a x).
2018/// \param x The specified input value.
2019///
2020/// This function uses the following formula: 1 / sqrt(x).
2021
2022_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
2023_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rsqrt)
2024half rsqrt(half);
2025_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
2026_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rsqrt)
2028_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
2029_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rsqrt)
2031_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
2032_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rsqrt)
2034
2035_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rsqrt)
2036float rsqrt(float);
2037_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rsqrt)
2039_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rsqrt)
2041_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rsqrt)
2043
2044//===----------------------------------------------------------------------===//
2045// round builtins
2046//===----------------------------------------------------------------------===//
2047
2048/// \fn T round(T x)
2049/// \brief Rounds the specified value \a x to the nearest integer.
2050/// \param x The specified input value.
2051///
2052/// The return value is the \a x parameter, rounded to the nearest integer
2053/// within a floating-point type. Halfway cases are
2054/// rounded to the nearest even value.
2055
2056_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
2057_HLSL_BUILTIN_ALIAS(__builtin_elementwise_roundeven)
2058half round(half);
2059_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
2060_HLSL_BUILTIN_ALIAS(__builtin_elementwise_roundeven)
2062_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
2063_HLSL_BUILTIN_ALIAS(__builtin_elementwise_roundeven)
2065_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
2066_HLSL_BUILTIN_ALIAS(__builtin_elementwise_roundeven)
2068
2069_HLSL_BUILTIN_ALIAS(__builtin_elementwise_roundeven)
2070float round(float);
2071_HLSL_BUILTIN_ALIAS(__builtin_elementwise_roundeven)
2073_HLSL_BUILTIN_ALIAS(__builtin_elementwise_roundeven)
2075_HLSL_BUILTIN_ALIAS(__builtin_elementwise_roundeven)
2077
2078//===----------------------------------------------------------------------===//
2079// saturate builtins
2080//===----------------------------------------------------------------------===//
2081
2082/// \fn T saturate(T Val)
2083/// \brief Returns input value, \a Val, clamped within the range of 0.0f
2084/// to 1.0f. \param Val The input value.
2085
2086_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
2087_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_saturate)
2088half saturate(half);
2089_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
2090_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_saturate)
2092_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
2093_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_saturate)
2095_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
2096_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_saturate)
2098
2099_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_saturate)
2100float saturate(float);
2101_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_saturate)
2103_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_saturate)
2105_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_saturate)
2107
2108_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_saturate)
2109double saturate(double);
2110_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_saturate)
2112_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_saturate)
2114_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_saturate)
2116
2117//===----------------------------------------------------------------------===//
2118// select builtins
2119//===----------------------------------------------------------------------===//
2120
2121/// \fn T select(bool Cond, T TrueVal, T FalseVal)
2122/// \brief ternary operator.
2123/// \param Cond The Condition input value.
2124/// \param TrueVal The Value returned if Cond is true.
2125/// \param FalseVal The Value returned if Cond is false.
2126
2127template <typename T>
2128_HLSL_BUILTIN_ALIAS(__builtin_hlsl_select)
2129T select(bool, T, T);
2130
2131/// \fn vector<T,Sz> select(vector<bool,Sz> Conds, vector<T,Sz> TrueVals,
2132/// vector<T,Sz> FalseVals)
2133/// \brief ternary operator for vectors. All vectors must be the same size.
2134/// \param Conds The Condition input values.
2135/// \param TrueVals The vector values are chosen from when conditions are true.
2136/// \param FalseVals The vector values are chosen from when conditions are
2137/// false.
2138
2139template <typename T, int Sz>
2140_HLSL_BUILTIN_ALIAS(__builtin_hlsl_select)
2141vector<T, Sz> select(vector<bool, Sz>, vector<T, Sz>, vector<T, Sz>);
2142
2143//===----------------------------------------------------------------------===//
2144// sin builtins
2145//===----------------------------------------------------------------------===//
2146
2147/// \fn T sin(T Val)
2148/// \brief Returns the sine of the input value, \a Val.
2149/// \param Val The input value.
2150
2151_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
2152_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sin)
2153half sin(half);
2154_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
2155_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sin)
2157_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
2158_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sin)
2160_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
2161_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sin)
2163
2164_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sin)
2165float sin(float);
2166_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sin)
2168_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sin)
2170_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sin)
2172
2173//===----------------------------------------------------------------------===//
2174// sinh builtins
2175//===----------------------------------------------------------------------===//
2176
2177/// \fn T sinh(T Val)
2178/// \brief Returns the hyperbolic sine of the input value, \a Val.
2179/// \param Val The input value.
2180
2181#ifdef __HLSL_ENABLE_16_BIT
2182_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sinh)
2183half sinh(half);
2184_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sinh)
2186_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sinh)
2188_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sinh)
2190#endif
2191
2192_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sinh)
2194_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sinh)
2196_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sinh)
2198_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sinh)
2200
2201//===----------------------------------------------------------------------===//
2202// sqrt builtins
2203//===----------------------------------------------------------------------===//
2204
2205/// \fn T sqrt(T Val)
2206/// \brief Returns the square root of the input value, \a Val.
2207/// \param Val The input value.
2208
2209_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
2210_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sqrt)
2211half sqrt(half);
2212_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
2213_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sqrt)
2215_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
2216_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sqrt)
2218_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
2219_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sqrt)
2221
2222_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sqrt)
2223float sqrt(float);
2224_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sqrt)
2226_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sqrt)
2228_HLSL_BUILTIN_ALIAS(__builtin_elementwise_sqrt)
2230
2231//===----------------------------------------------------------------------===//
2232// step builtins
2233//===----------------------------------------------------------------------===//
2234
2235/// \fn T step(T x, T y)
2236/// \brief Returns 1 if the x parameter is greater than or equal to the y
2237/// parameter; otherwise, 0. vector. \param x [in] The first floating-point
2238/// value to compare. \param y [in] The first floating-point value to compare.
2239///
2240/// Step is based on the following formula: (x >= y) ? 1 : 0
2241
2242_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
2243_HLSL_BUILTIN_ALIAS(__builtin_hlsl_step)
2244half step(half, half);
2245_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
2246_HLSL_BUILTIN_ALIAS(__builtin_hlsl_step)
2248_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
2249_HLSL_BUILTIN_ALIAS(__builtin_hlsl_step)
2251_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
2252_HLSL_BUILTIN_ALIAS(__builtin_hlsl_step)
2254
2255_HLSL_BUILTIN_ALIAS(__builtin_hlsl_step)
2256float step(float, float);
2257_HLSL_BUILTIN_ALIAS(__builtin_hlsl_step)
2259_HLSL_BUILTIN_ALIAS(__builtin_hlsl_step)
2261_HLSL_BUILTIN_ALIAS(__builtin_hlsl_step)
2263
2264//===----------------------------------------------------------------------===//
2265// tan builtins
2266//===----------------------------------------------------------------------===//
2267
2268/// \fn T tan(T Val)
2269/// \brief Returns the tangent of the input value, \a Val.
2270/// \param Val The input value.
2271
2272#ifdef __HLSL_ENABLE_16_BIT
2273_HLSL_BUILTIN_ALIAS(__builtin_elementwise_tan)
2274half tan(half);
2275_HLSL_BUILTIN_ALIAS(__builtin_elementwise_tan)
2276half2 tan(half2);
2277_HLSL_BUILTIN_ALIAS(__builtin_elementwise_tan)
2278half3 tan(half3);
2279_HLSL_BUILTIN_ALIAS(__builtin_elementwise_tan)
2280half4 tan(half4);
2281#endif
2282
2283_HLSL_BUILTIN_ALIAS(__builtin_elementwise_tan)
2284float tan(float);
2285_HLSL_BUILTIN_ALIAS(__builtin_elementwise_tan)
2287_HLSL_BUILTIN_ALIAS(__builtin_elementwise_tan)
2289_HLSL_BUILTIN_ALIAS(__builtin_elementwise_tan)
2291
2292//===----------------------------------------------------------------------===//
2293// tanh builtins
2294//===----------------------------------------------------------------------===//
2295
2296/// \fn T tanh(T Val)
2297/// \brief Returns the hyperbolic tangent of the input value, \a Val.
2298/// \param Val The input value.
2299
2300#ifdef __HLSL_ENABLE_16_BIT
2301_HLSL_BUILTIN_ALIAS(__builtin_elementwise_tanh)
2302half tanh(half);
2303_HLSL_BUILTIN_ALIAS(__builtin_elementwise_tanh)
2305_HLSL_BUILTIN_ALIAS(__builtin_elementwise_tanh)
2307_HLSL_BUILTIN_ALIAS(__builtin_elementwise_tanh)
2309#endif
2310
2311_HLSL_BUILTIN_ALIAS(__builtin_elementwise_tanh)
2313_HLSL_BUILTIN_ALIAS(__builtin_elementwise_tanh)
2315_HLSL_BUILTIN_ALIAS(__builtin_elementwise_tanh)
2317_HLSL_BUILTIN_ALIAS(__builtin_elementwise_tanh)
2319
2320//===----------------------------------------------------------------------===//
2321// trunc builtins
2322//===----------------------------------------------------------------------===//
2323
2324/// \fn T trunc(T Val)
2325/// \brief Returns the truncated integer value of the input value, \a Val.
2326/// \param Val The input value.
2327
2328_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
2329_HLSL_BUILTIN_ALIAS(__builtin_elementwise_trunc)
2330half trunc(half);
2331_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
2332_HLSL_BUILTIN_ALIAS(__builtin_elementwise_trunc)
2334_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
2335_HLSL_BUILTIN_ALIAS(__builtin_elementwise_trunc)
2337_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
2338_HLSL_BUILTIN_ALIAS(__builtin_elementwise_trunc)
2340
2341_HLSL_BUILTIN_ALIAS(__builtin_elementwise_trunc)
2342float trunc(float);
2343_HLSL_BUILTIN_ALIAS(__builtin_elementwise_trunc)
2345_HLSL_BUILTIN_ALIAS(__builtin_elementwise_trunc)
2347_HLSL_BUILTIN_ALIAS(__builtin_elementwise_trunc)
2349
2350//===----------------------------------------------------------------------===//
2351// Wave* builtins
2352//===----------------------------------------------------------------------===//
2353
2354/// \brief Returns true if the expression is true in all active lanes in the
2355/// current wave.
2356///
2357/// \param Val The boolean expression to evaluate.
2358/// \return True if the expression is true in all lanes.
2359_HLSL_AVAILABILITY(shadermodel, 6.0)
2360_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_all_true)
2361__attribute__((convergent)) bool WaveActiveAllTrue(bool Val);
2362
2363/// \brief Returns true if the expression is true in any active lane in the
2364/// current wave.
2365///
2366/// \param Val The boolean expression to evaluate.
2367/// \return True if the expression is true in any lane.
2368_HLSL_AVAILABILITY(shadermodel, 6.0)
2369_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_any_true)
2370__attribute__((convergent)) bool WaveActiveAnyTrue(bool Val);
2371
2372/// \brief Counts the number of boolean variables which evaluate to true across
2373/// all active lanes in the current wave.
2374///
2375/// \param Val The input boolean value.
2376/// \return The number of lanes for which the boolean variable evaluates to
2377/// true, across all active lanes in the current wave.
2378_HLSL_AVAILABILITY(shadermodel, 6.0)
2379_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_count_bits)
2380__attribute__((convergent)) uint WaveActiveCountBits(bool Val);
2381
2382/// \brief Returns the index of the current lane within the current wave.
2383_HLSL_AVAILABILITY(shadermodel, 6.0)
2384_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_get_lane_index)
2385__attribute__((convergent)) uint WaveGetLaneIndex();
2386
2387_HLSL_AVAILABILITY(shadermodel, 6.0)
2388_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_is_first_lane)
2389__attribute__((convergent)) bool WaveIsFirstLane();
2390
2391//===----------------------------------------------------------------------===//
2392// WaveReadLaneAt builtins
2393//===----------------------------------------------------------------------===//
2394
2395// \brief Returns the value of the expression for the given lane index within
2396// the specified wave.
2397
2398_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
2399__attribute__((convergent)) bool WaveReadLaneAt(bool, int32_t);
2400_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
2401__attribute__((convergent)) bool2 WaveReadLaneAt(bool2, int32_t);
2402_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
2403__attribute__((convergent)) bool3 WaveReadLaneAt(bool3, int32_t);
2404_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
2405__attribute__((convergent)) bool4 WaveReadLaneAt(bool4, int32_t);
2406
2407#ifdef __HLSL_ENABLE_16_BIT
2408_HLSL_AVAILABILITY(shadermodel, 6.0)
2409_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
2410__attribute__((convergent)) int16_t WaveReadLaneAt(int16_t, int32_t);
2411_HLSL_AVAILABILITY(shadermodel, 6.0)
2412_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
2413__attribute__((convergent)) int16_t2 WaveReadLaneAt(int16_t2, int32_t);
2414_HLSL_AVAILABILITY(shadermodel, 6.0)
2415_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
2416__attribute__((convergent)) int16_t3 WaveReadLaneAt(int16_t3, int32_t);
2417_HLSL_AVAILABILITY(shadermodel, 6.0)
2418_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
2419__attribute__((convergent)) int16_t4 WaveReadLaneAt(int16_t4, int32_t);
2420#endif
2421
2422_HLSL_16BIT_AVAILABILITY(shadermodel, 6.0)
2423_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
2424__attribute__((convergent)) half WaveReadLaneAt(half, int32_t);
2425_HLSL_16BIT_AVAILABILITY(shadermodel, 6.0)
2426_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
2427__attribute__((convergent)) half2 WaveReadLaneAt(half2, int32_t);
2428_HLSL_16BIT_AVAILABILITY(shadermodel, 6.0)
2429_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
2430__attribute__((convergent)) half3 WaveReadLaneAt(half3, int32_t);
2431_HLSL_16BIT_AVAILABILITY(shadermodel, 6.0)
2432_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
2433__attribute__((convergent)) half4 WaveReadLaneAt(half4, int32_t);
2434
2435_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
2436__attribute__((convergent)) int WaveReadLaneAt(int, int32_t);
2437_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
2438__attribute__((convergent)) int2 WaveReadLaneAt(int2, int32_t);
2439_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
2440__attribute__((convergent)) int3 WaveReadLaneAt(int3, int32_t);
2441_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
2442__attribute__((convergent)) int4 WaveReadLaneAt(int4, int32_t);
2443
2444_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
2445__attribute__((convergent)) float WaveReadLaneAt(float, int32_t);
2446_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
2447__attribute__((convergent)) float2 WaveReadLaneAt(float2, int32_t);
2448_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
2449__attribute__((convergent)) float3 WaveReadLaneAt(float3, int32_t);
2450_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
2451__attribute__((convergent)) float4 WaveReadLaneAt(float4, int32_t);
2452
2453_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
2454__attribute__((convergent)) int64_t WaveReadLaneAt(int64_t, int32_t);
2455_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
2456__attribute__((convergent)) int64_t2 WaveReadLaneAt(int64_t2, int32_t);
2457_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
2458__attribute__((convergent)) int64_t3 WaveReadLaneAt(int64_t3, int32_t);
2459_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
2460__attribute__((convergent)) int64_t4 WaveReadLaneAt(int64_t4, int32_t);
2461
2462_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
2463__attribute__((convergent)) double WaveReadLaneAt(double, int32_t);
2464_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
2465__attribute__((convergent)) double2 WaveReadLaneAt(double2, int32_t);
2466_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
2467__attribute__((convergent)) double3 WaveReadLaneAt(double3, int32_t);
2468_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at)
2469__attribute__((convergent)) double4 WaveReadLaneAt(double4, int32_t);
2470
2471//===----------------------------------------------------------------------===//
2472// WaveActiveSum builtins
2473//===----------------------------------------------------------------------===//
2474
2475_HLSL_16BIT_AVAILABILITY(shadermodel, 6.0)
2476_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
2477__attribute__((convergent)) half WaveActiveSum(half);
2478_HLSL_16BIT_AVAILABILITY(shadermodel, 6.0)
2479_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
2480__attribute__((convergent)) half2 WaveActiveSum(half2);
2481_HLSL_16BIT_AVAILABILITY(shadermodel, 6.0)
2482_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
2483__attribute__((convergent)) half3 WaveActiveSum(half3);
2484_HLSL_16BIT_AVAILABILITY(shadermodel, 6.0)
2485_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
2486__attribute__((convergent)) half4 WaveActiveSum(half4);
2487
2488#ifdef __HLSL_ENABLE_16_BIT
2489_HLSL_AVAILABILITY(shadermodel, 6.0)
2490_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
2491__attribute__((convergent)) int16_t WaveActiveSum(int16_t);
2492_HLSL_AVAILABILITY(shadermodel, 6.0)
2493_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
2494__attribute__((convergent)) int16_t2 WaveActiveSum(int16_t2);
2495_HLSL_AVAILABILITY(shadermodel, 6.0)
2496_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
2497__attribute__((convergent)) int16_t3 WaveActiveSum(int16_t3);
2498_HLSL_AVAILABILITY(shadermodel, 6.0)
2499_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
2500__attribute__((convergent)) int16_t4 WaveActiveSum(int16_t4);
2501
2502_HLSL_AVAILABILITY(shadermodel, 6.0)
2503_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
2504__attribute__((convergent)) uint16_t WaveActiveSum(uint16_t);
2505_HLSL_AVAILABILITY(shadermodel, 6.0)
2506_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
2507__attribute__((convergent)) uint16_t2 WaveActiveSum(uint16_t2);
2508_HLSL_AVAILABILITY(shadermodel, 6.0)
2509_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
2510__attribute__((convergent)) uint16_t3 WaveActiveSum(uint16_t3);
2511_HLSL_AVAILABILITY(shadermodel, 6.0)
2512_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
2513__attribute__((convergent)) uint16_t4 WaveActiveSum(uint16_t4);
2514#endif
2515
2516_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
2517__attribute__((convergent)) int WaveActiveSum(int);
2518_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
2519__attribute__((convergent)) int2 WaveActiveSum(int2);
2520_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
2521__attribute__((convergent)) int3 WaveActiveSum(int3);
2522_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
2523__attribute__((convergent)) int4 WaveActiveSum(int4);
2524
2525_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
2526__attribute__((convergent)) uint WaveActiveSum(uint);
2527_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
2528__attribute__((convergent)) uint2 WaveActiveSum(uint2);
2529_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
2530__attribute__((convergent)) uint3 WaveActiveSum(uint3);
2531_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
2532__attribute__((convergent)) uint4 WaveActiveSum(uint4);
2533
2534_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
2535__attribute__((convergent)) int64_t WaveActiveSum(int64_t);
2536_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
2537__attribute__((convergent)) int64_t2 WaveActiveSum(int64_t2);
2538_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
2539__attribute__((convergent)) int64_t3 WaveActiveSum(int64_t3);
2540_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
2541__attribute__((convergent)) int64_t4 WaveActiveSum(int64_t4);
2542
2543_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
2544__attribute__((convergent)) uint64_t WaveActiveSum(uint64_t);
2545_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
2546__attribute__((convergent)) uint64_t2 WaveActiveSum(uint64_t2);
2547_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
2548__attribute__((convergent)) uint64_t3 WaveActiveSum(uint64_t3);
2549_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
2550__attribute__((convergent)) uint64_t4 WaveActiveSum(uint64_t4);
2551
2552_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
2553__attribute__((convergent)) float WaveActiveSum(float);
2554_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
2555__attribute__((convergent)) float2 WaveActiveSum(float2);
2556_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
2557__attribute__((convergent)) float3 WaveActiveSum(float3);
2558_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
2559__attribute__((convergent)) float4 WaveActiveSum(float4);
2560
2561_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
2562__attribute__((convergent)) double WaveActiveSum(double);
2563_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
2564__attribute__((convergent)) double2 WaveActiveSum(double2);
2565_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
2566__attribute__((convergent)) double3 WaveActiveSum(double3);
2567_HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum)
2568__attribute__((convergent)) double4 WaveActiveSum(double4);
2569
2570//===----------------------------------------------------------------------===//
2571// sign builtins
2572//===----------------------------------------------------------------------===//
2573
2574/// \fn T sign(T Val)
2575/// \brief Returns -1 if \a Val is less than zero; 0 if \a Val equals zero; and
2576/// 1 if \a Val is greater than zero. \param Val The input value.
2577
2578#ifdef __HLSL_ENABLE_16_BIT
2579_HLSL_AVAILABILITY(shadermodel, 6.2)
2580_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
2581int sign(int16_t);
2582_HLSL_AVAILABILITY(shadermodel, 6.2)
2583_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
2584int2 sign(int16_t2);
2585_HLSL_AVAILABILITY(shadermodel, 6.2)
2586_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
2587int3 sign(int16_t3);
2588_HLSL_AVAILABILITY(shadermodel, 6.2)
2589_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
2590int4 sign(int16_t4);
2591
2592_HLSL_AVAILABILITY(shadermodel, 6.2)
2593_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
2594int sign(uint16_t);
2595_HLSL_AVAILABILITY(shadermodel, 6.2)
2596_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
2597int2 sign(uint16_t2);
2598_HLSL_AVAILABILITY(shadermodel, 6.2)
2599_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
2600int3 sign(uint16_t3);
2601_HLSL_AVAILABILITY(shadermodel, 6.2)
2602_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
2603int4 sign(uint16_t4);
2604#endif
2605
2606_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
2607_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
2608int sign(half);
2609_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
2610_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
2612_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
2613_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
2615_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
2616_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
2618
2619_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
2620int sign(int);
2621_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
2623_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
2625_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
2627
2628_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
2630_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
2632_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
2634_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
2636
2637_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
2638int sign(float);
2639_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
2641_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
2643_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
2645
2646_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
2648_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
2650_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
2652_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
2654
2655_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
2657_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
2659_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
2661_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
2663
2664_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
2665int sign(double);
2666_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
2668_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
2670_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign)
2672
2673//===----------------------------------------------------------------------===//
2674// radians builtins
2675//===----------------------------------------------------------------------===//
2676
2677/// \fn T radians(T Val)
2678/// \brief Converts the specified value from degrees to radians.
2679
2680_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
2681_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_radians)
2682half radians(half);
2683_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
2684_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_radians)
2686_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
2687_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_radians)
2689_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
2690_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_radians)
2692
2693_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_radians)
2694float radians(float);
2695_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_radians)
2697_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_radians)
2699_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_radians)
2701
2702//===----------------------------------------------------------------------===//
2703// GroupMemoryBarrierWithGroupSync builtins
2704//===----------------------------------------------------------------------===//
2705
2706/// \fn void GroupMemoryBarrierWithGroupSync(void)
2707/// \brief Blocks execution of all threads in a group until all group shared
2708/// accesses have been completed and all threads in the group have reached this
2709/// call.
2710
2711_HLSL_BUILTIN_ALIAS(__builtin_hlsl_group_memory_barrier_with_group_sync)
2713
2714} // namespace hlsl
2715#endif //_HLSL_HLSL_INTRINSICS_H_
#define V(N, I)
Definition: ASTContext.h:3453
#define X(type, name)
Definition: Value.h:144
_Float16 __2f16 __attribute__((ext_vector_type(2)))
Zeroes the upper 128 bits (bits 255:128) of all YMM registers.
__device__ int
__device__ float
#define _HLSL_BUILTIN_ALIAS(builtin)
#define _HLSL_AVAILABILITY(platform, version)
#define _HLSL_16BIT_AVAILABILITY(environment, version)
constexpr enable_if_t< is_same< float, T >::value||is_same< half, T >::value, T > distance_impl(T X, T Y)
Definition: hlsl_detail.h:69
constexpr vector< uint, 4 > d3d_color_to_ubyte4_impl(vector< float, 4 > V)
Definition: hlsl_detail.h:44
constexpr enable_if_t< is_same< float, T >::value||is_same< half, T >::value, T > distance_vec_impl(vector< T, N > X, vector< T, N > Y)
Definition: hlsl_detail.h:75
constexpr enable_if_t< is_same< float, T >::value||is_same< half, T >::value, T > length_impl(T X)
Definition: hlsl_detail.h:57
constexpr enable_if_t< is_same< float, T >::value||is_same< half, T >::value, T > length_vec_impl(vector< T, N > X)
Definition: hlsl_detail.h:63
int int32_t
int sign(half)
unsigned int uint
half radians(half)
double asdouble(uint, uint)
Reinterprets a cast value (two 32-bit values) into a double.
half normalize(half)
vector< half, 4 > half4
half mad(half, half, half)
bool any(half)
T select(bool, T, T)
ternary operator.
const uint countbits(int x)
vector< half, 2 > half2
vector< uint, 2 > uint2
vector< int, 3 > int3
vector< uint64_t, 2 > uint64_t2
half rsqrt(half)
half max(half, half)
half saturate(half)
half3 cross(half3, half3)
half abs(half)
vector< float, 4 > float4
half dot(half, half)
vector< int64_t, 4 > int64_t4
unsigned long uint64_t
int dot4add_i8packed(uint, uint, int)
vector< uint64_t, 3 > uint64_t3
half lerp(half, half, half)
vector< bool, 4 > bool4
void GroupMemoryBarrierWithGroupSync(void)
Blocks execution of all threads in a group until all group shared accesses have been completed and al...
uint firstbithigh(int)
long int64_t
vector< int64_t, 3 > int64_t3
vector< int, 4 > int4
void clip(float)
constexpr vector< uint, 4 > D3DCOLORtoUBYTE4(vector< float, 4 > V)
vector< bool, 3 > bool3
half clamp(half, half, half)
vector< uint64_t, 4 > uint64_t4
const half length(half X)
half step(half, half)
constexpr vector< uint, N > asuint(vector< T, N > V)
vector< double, 3 > double3
vector< float, 2 > float2
vector< float, 3 > float3
vector< int64_t, 2 > int64_t2
const half distance(half X, half Y)
vector< uint, 3 > uint3
half degrees(half)
half rcp(half)
vector< double, 4 > double4
vector< double, 2 > double2
vector< bool, 2 > bool2
vector< int, 2 > int2
half min(half, half)
uint dot4add_u8packed(uint, uint, uint)
vector< uint, 4 > uint4
vector< half, 3 > half3
half frac(half)
uint firstbitlow(int)
constexpr vector< int, N > asint(vector< T, N > V)
bool all(half)
constexpr vector< float, N > asfloat(vector< T, N > V)
bool isinf(half)
uint reversebits(uint)
unsigned int uint
An unsigned 32-bit integer.
#define sinh(__x)
Definition: tgmath.h:373
#define asin(__x)
Definition: tgmath.h:112
#define sqrt(__x)
Definition: tgmath.h:520
#define acos(__x)
Definition: tgmath.h:83
#define exp(__x)
Definition: tgmath.h:431
#define atan2(__x, __y)
Definition: tgmath.h:566
#define exp2(__x)
Definition: tgmath.h:670
#define sin(__x)
Definition: tgmath.h:286
#define log2(__x)
Definition: tgmath.h:970
#define cosh(__x)
Definition: tgmath.h:344
#define trunc(__x)
Definition: tgmath.h:1216
#define round(__x)
Definition: tgmath.h:1148
#define fmod(__x, __y)
Definition: tgmath.h:798
#define tan(__x)
Definition: tgmath.h:315
#define cos(__x)
Definition: tgmath.h:257
#define log10(__x)
Definition: tgmath.h:936
#define pow(__x, __y)
Definition: tgmath.h:490
#define tanh(__x)
Definition: tgmath.h:402
#define atan(__x)
Definition: tgmath.h:141
#define floor(__x)
Definition: tgmath.h:722
#define ceil(__x)
Definition: tgmath.h:601
#define log(__x)
Definition: tgmath.h:460