clang 22.0.0git
hlsl_compat_overloads.h
Go to the documentation of this file.
1//===--- hlsl_compat_overloads.h - Extra HLSL overloads 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_COMPAT_OVERLOADS_H_
10#define _HLSl_COMPAT_OVERLOADS_H_
11
12namespace hlsl {
13
14// Note: Functions in this file are sorted alphabetically, then grouped by base
15// element type, and the element types are sorted by size, then singed integer,
16// unsigned integer and floating point. Keeping this ordering consistent will
17// help keep this file manageable as it grows.
18
19#define _DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(fn) \
20 constexpr float fn(double V) { return fn((float)V); } \
21 constexpr float2 fn(double2 V) { return fn((float2)V); } \
22 constexpr float3 fn(double3 V) { return fn((float3)V); } \
23 constexpr float4 fn(double4 V) { return fn((float4)V); }
24
25#define _DXC_COMPAT_BINARY_DOUBLE_OVERLOADS(fn) \
26 constexpr float fn(double V1, double V2) { \
27 return fn((float)V1, (float)V2); \
28 } \
29 constexpr float2 fn(double2 V1, double2 V2) { \
30 return fn((float2)V1, (float2)V2); \
31 } \
32 constexpr float3 fn(double3 V1, double3 V2) { \
33 return fn((float3)V1, (float3)V2); \
34 } \
35 constexpr float4 fn(double4 V1, double4 V2) { \
36 return fn((float4)V1, (float4)V2); \
37 }
38
39#define _DXC_COMPAT_TERNARY_DOUBLE_OVERLOADS(fn) \
40 constexpr float fn(double V1, double V2, double V3) { \
41 return fn((float)V1, (float)V2, (float)V3); \
42 } \
43 constexpr float2 fn(double2 V1, double2 V2, double2 V3) { \
44 return fn((float2)V1, (float2)V2, (float2)V3); \
45 } \
46 constexpr float3 fn(double3 V1, double3 V2, double3 V3) { \
47 return fn((float3)V1, (float3)V2, (float3)V3); \
48 } \
49 constexpr float4 fn(double4 V1, double4 V2, double4 V3) { \
50 return fn((float4)V1, (float4)V2, (float4)V3); \
51 }
52
53#define _DXC_COMPAT_UNARY_INTEGER_OVERLOADS(fn) \
54 constexpr float fn(int V) { return fn((float)V); } \
55 constexpr float2 fn(int2 V) { return fn((float2)V); } \
56 constexpr float3 fn(int3 V) { return fn((float3)V); } \
57 constexpr float4 fn(int4 V) { return fn((float4)V); } \
58 constexpr float fn(uint V) { return fn((float)V); } \
59 constexpr float2 fn(uint2 V) { return fn((float2)V); } \
60 constexpr float3 fn(uint3 V) { return fn((float3)V); } \
61 constexpr float4 fn(uint4 V) { return fn((float4)V); } \
62 constexpr float fn(int64_t V) { return fn((float)V); } \
63 constexpr float2 fn(int64_t2 V) { return fn((float2)V); } \
64 constexpr float3 fn(int64_t3 V) { return fn((float3)V); } \
65 constexpr float4 fn(int64_t4 V) { return fn((float4)V); } \
66 constexpr float fn(uint64_t V) { return fn((float)V); } \
67 constexpr float2 fn(uint64_t2 V) { return fn((float2)V); } \
68 constexpr float3 fn(uint64_t3 V) { return fn((float3)V); } \
69 constexpr float4 fn(uint64_t4 V) { return fn((float4)V); }
70
71#define _DXC_COMPAT_BINARY_INTEGER_OVERLOADS(fn) \
72 constexpr float fn(int V1, int V2) { return fn((float)V1, (float)V2); } \
73 constexpr float2 fn(int2 V1, int2 V2) { return fn((float2)V1, (float2)V2); } \
74 constexpr float3 fn(int3 V1, int3 V2) { return fn((float3)V1, (float3)V2); } \
75 constexpr float4 fn(int4 V1, int4 V2) { return fn((float4)V1, (float4)V2); } \
76 constexpr float fn(uint V1, uint V2) { return fn((float)V1, (float)V2); } \
77 constexpr float2 fn(uint2 V1, uint2 V2) { \
78 return fn((float2)V1, (float2)V2); \
79 } \
80 constexpr float3 fn(uint3 V1, uint3 V2) { \
81 return fn((float3)V1, (float3)V2); \
82 } \
83 constexpr float4 fn(uint4 V1, uint4 V2) { \
84 return fn((float4)V1, (float4)V2); \
85 } \
86 constexpr float fn(int64_t V1, int64_t V2) { \
87 return fn((float)V1, (float)V2); \
88 } \
89 constexpr float2 fn(int64_t2 V1, int64_t2 V2) { \
90 return fn((float2)V1, (float2)V2); \
91 } \
92 constexpr float3 fn(int64_t3 V1, int64_t3 V2) { \
93 return fn((float3)V1, (float3)V2); \
94 } \
95 constexpr float4 fn(int64_t4 V1, int64_t4 V2) { \
96 return fn((float4)V1, (float4)V2); \
97 } \
98 constexpr float fn(uint64_t V1, uint64_t V2) { \
99 return fn((float)V1, (float)V2); \
100 } \
101 constexpr float2 fn(uint64_t2 V1, uint64_t2 V2) { \
102 return fn((float2)V1, (float2)V2); \
103 } \
104 constexpr float3 fn(uint64_t3 V1, uint64_t3 V2) { \
105 return fn((float3)V1, (float3)V2); \
106 } \
107 constexpr float4 fn(uint64_t4 V1, uint64_t4 V2) { \
108 return fn((float4)V1, (float4)V2); \
109 }
110
111#define _DXC_COMPAT_TERNARY_INTEGER_OVERLOADS(fn) \
112 constexpr float fn(int V1, int V2, int V3) { \
113 return fn((float)V1, (float)V2, (float)V3); \
114 } \
115 constexpr float2 fn(int2 V1, int2 V2, int2 V3) { \
116 return fn((float2)V1, (float2)V2, (float2)V3); \
117 } \
118 constexpr float3 fn(int3 V1, int3 V2, int3 V3) { \
119 return fn((float3)V1, (float3)V2, (float3)V3); \
120 } \
121 constexpr float4 fn(int4 V1, int4 V2, int4 V3) { \
122 return fn((float4)V1, (float4)V2, (float4)V3); \
123 } \
124 constexpr float fn(uint V1, uint V2, uint V3) { \
125 return fn((float)V1, (float)V2, (float)V3); \
126 } \
127 constexpr float2 fn(uint2 V1, uint2 V2, uint2 V3) { \
128 return fn((float2)V1, (float2)V2, (float2)V3); \
129 } \
130 constexpr float3 fn(uint3 V1, uint3 V2, uint3 V3) { \
131 return fn((float3)V1, (float3)V2, (float3)V3); \
132 } \
133 constexpr float4 fn(uint4 V1, uint4 V2, uint4 V3) { \
134 return fn((float4)V1, (float4)V2, (float4)V3); \
135 } \
136 constexpr float fn(int64_t V1, int64_t V2, int64_t V3) { \
137 return fn((float)V1, (float)V2, (float)V3); \
138 } \
139 constexpr float2 fn(int64_t2 V1, int64_t2 V2, int64_t2 V3) { \
140 return fn((float2)V1, (float2)V2, (float2)V3); \
141 } \
142 constexpr float3 fn(int64_t3 V1, int64_t3 V2, int64_t3 V3) { \
143 return fn((float3)V1, (float3)V2, (float3)V3); \
144 } \
145 constexpr float4 fn(int64_t4 V1, int64_t4 V2, int64_t4 V3) { \
146 return fn((float4)V1, (float4)V2, (float4)V3); \
147 } \
148 constexpr float fn(uint64_t V1, uint64_t V2, uint64_t V3) { \
149 return fn((float)V1, (float)V2, (float)V3); \
150 } \
151 constexpr float2 fn(uint64_t2 V1, uint64_t2 V2, uint64_t2 V3) { \
152 return fn((float2)V1, (float2)V2, (float2)V3); \
153 } \
154 constexpr float3 fn(uint64_t3 V1, uint64_t3 V2, uint64_t3 V3) { \
155 return fn((float3)V1, (float3)V2, (float3)V3); \
156 } \
157 constexpr float4 fn(uint64_t4 V1, uint64_t4 V2, uint64_t4 V3) { \
158 return fn((float4)V1, (float4)V2, (float4)V3); \
159 }
160
161//===----------------------------------------------------------------------===//
162// acos builtins overloads
163//===----------------------------------------------------------------------===//
164
165_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(acos)
166_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(acos)
167
168//===----------------------------------------------------------------------===//
169// asin builtins overloads
170//===----------------------------------------------------------------------===//
171
172_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(asin)
173_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(asin)
174
175//===----------------------------------------------------------------------===//
176// atan builtins overloads
177//===----------------------------------------------------------------------===//
178
179_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(atan)
180_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(atan)
181
182//===----------------------------------------------------------------------===//
183// atan2 builtins overloads
184//===----------------------------------------------------------------------===//
185
186_DXC_COMPAT_BINARY_DOUBLE_OVERLOADS(atan2)
187_DXC_COMPAT_BINARY_INTEGER_OVERLOADS(atan2)
188
189//===----------------------------------------------------------------------===//
190// ceil builtins overloads
191//===----------------------------------------------------------------------===//
192
193_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(ceil)
194_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(ceil)
195
196//===----------------------------------------------------------------------===//
197// clamp builtins overloads
198//===----------------------------------------------------------------------===//
199
200template <typename T, uint N>
201constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>>
202clamp(vector<T, N> p0, vector<T, N> p1, T p2) {
203 return clamp(p0, p1, (vector<T, N>)p2);
204}
205
206template <typename T, uint N>
207constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>>
208clamp(vector<T, N> p0, T p1, vector<T, N> p2) {
209 return clamp(p0, (vector<T, N>)p1, p2);
210}
211
212template <typename T, uint N>
213constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>>
214clamp(vector<T, N> p0, T p1, T p2) {
215 return clamp(p0, (vector<T, N>)p1, (vector<T, N>)p2);
216}
217
218//===----------------------------------------------------------------------===//
219// cos builtins overloads
220//===----------------------------------------------------------------------===//
221
222_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(cos)
223_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(cos)
224
225//===----------------------------------------------------------------------===//
226// cosh builtins overloads
227//===----------------------------------------------------------------------===//
228
229_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(cosh)
230_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(cosh)
231
232//===----------------------------------------------------------------------===//
233// degrees builtins overloads
234//===----------------------------------------------------------------------===//
235
236_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(degrees)
237_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(degrees)
238
239//===----------------------------------------------------------------------===//
240// exp builtins overloads
241//===----------------------------------------------------------------------===//
242
243_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(exp)
244_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(exp)
245
246//===----------------------------------------------------------------------===//
247// exp2 builtins overloads
248//===----------------------------------------------------------------------===//
249
250_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(exp2)
251_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(exp2)
252
253//===----------------------------------------------------------------------===//
254// floor builtins overloads
255//===----------------------------------------------------------------------===//
256
257_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(floor)
258_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(floor)
259
260//===----------------------------------------------------------------------===//
261// frac builtins overloads
262//===----------------------------------------------------------------------===//
263
264_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(frac)
265_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(frac)
266
267//===----------------------------------------------------------------------===//
268// isinf builtins overloads
269//===----------------------------------------------------------------------===//
270
271constexpr bool isinf(double V) { return isinf((float)V); }
272constexpr bool2 isinf(double2 V) { return isinf((float2)V); }
273constexpr bool3 isinf(double3 V) { return isinf((float3)V); }
274constexpr bool4 isinf(double4 V) { return isinf((float4)V); }
275
276//===----------------------------------------------------------------------===//
277// lerp builtins overloads
278//===----------------------------------------------------------------------===//
279
280template <typename T, uint N>
281constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>>
282lerp(vector<T, N> x, vector<T, N> y, T s) {
283 return lerp(x, y, (vector<T, N>)s);
284}
285
286_DXC_COMPAT_TERNARY_DOUBLE_OVERLOADS(lerp)
287_DXC_COMPAT_TERNARY_INTEGER_OVERLOADS(lerp)
288
289//===----------------------------------------------------------------------===//
290// log builtins overloads
291//===----------------------------------------------------------------------===//
292
293_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(log)
294_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(log)
295
296//===----------------------------------------------------------------------===//
297// log10 builtins overloads
298//===----------------------------------------------------------------------===//
299
300_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(log10)
301_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(log10)
302
303//===----------------------------------------------------------------------===//
304// log2 builtins overloads
305//===----------------------------------------------------------------------===//
306
307_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(log2)
308_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(log2)
309
310//===----------------------------------------------------------------------===//
311// max builtins overloads
312//===----------------------------------------------------------------------===//
313
314template <typename T, uint N>
315constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>>
316max(vector<T, N> p0, T p1) {
317 return max(p0, (vector<T, N>)p1);
318}
319
320template <typename T, uint N>
321constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>>
322max(T p0, vector<T, N> p1) {
323 return max((vector<T, N>)p0, p1);
324}
325
326//===----------------------------------------------------------------------===//
327// min builtins overloads
328//===----------------------------------------------------------------------===//
329
330template <typename T, uint N>
331constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>>
332min(vector<T, N> p0, T p1) {
333 return min(p0, (vector<T, N>)p1);
334}
335
336template <typename T, uint N>
337constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>>
338min(T p0, vector<T, N> p1) {
339 return min((vector<T, N>)p0, p1);
340}
341
342//===----------------------------------------------------------------------===//
343// normalize builtins overloads
344//===----------------------------------------------------------------------===//
345
346_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(normalize)
347_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(normalize)
348
349//===----------------------------------------------------------------------===//
350// pow builtins overloads
351//===----------------------------------------------------------------------===//
352
353_DXC_COMPAT_BINARY_DOUBLE_OVERLOADS(pow)
354_DXC_COMPAT_BINARY_INTEGER_OVERLOADS(pow)
355
356//===----------------------------------------------------------------------===//
357// rsqrt builtins overloads
358//===----------------------------------------------------------------------===//
359
360_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(rsqrt)
361_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(rsqrt)
362
363//===----------------------------------------------------------------------===//
364// round builtins overloads
365//===----------------------------------------------------------------------===//
366
367_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(round)
368_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(round)
369
370//===----------------------------------------------------------------------===//
371// sin builtins overloads
372//===----------------------------------------------------------------------===//
373
374_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(sin)
375_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(sin)
376
377//===----------------------------------------------------------------------===//
378// sinh builtins overloads
379//===----------------------------------------------------------------------===//
380
381_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(sinh)
382_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(sinh)
383
384//===----------------------------------------------------------------------===//
385// sqrt builtins overloads
386//===----------------------------------------------------------------------===//
387
388_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(sqrt)
389_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(sqrt)
390
391//===----------------------------------------------------------------------===//
392// step builtins overloads
393//===----------------------------------------------------------------------===//
394
395_DXC_COMPAT_BINARY_DOUBLE_OVERLOADS(step)
396_DXC_COMPAT_BINARY_INTEGER_OVERLOADS(step)
397
398//===----------------------------------------------------------------------===//
399// tan builtins overloads
400//===----------------------------------------------------------------------===//
401
402_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(tan)
403_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(tan)
404
405//===----------------------------------------------------------------------===//
406// tanh builtins overloads
407//===----------------------------------------------------------------------===//
408
409_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(tanh)
410_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(tanh)
411
412//===----------------------------------------------------------------------===//
413// trunc builtins overloads
414//===----------------------------------------------------------------------===//
415
416_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(trunc)
417_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(trunc)
418
419//===----------------------------------------------------------------------===//
420// radians builtins overloads
421//===----------------------------------------------------------------------===//
422
423_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(radians)
424_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(radians)
425
426} // namespace hlsl
427#endif // _HLSL_COMPAT_OVERLOADS_H_
V
#define V(N, I)
Definition ASTContext.h:3593
rsqrt
__DEVICE__ double rsqrt(double __a)
Definition __clang_cuda_math.h:279
s
__device__ __2f16 float __ockl_bool s
Definition __clang_hip_libdevice_declares.h:296
_DXC_COMPAT_BINARY_DOUBLE_OVERLOADS
#define _DXC_COMPAT_BINARY_DOUBLE_OVERLOADS(fn)
Definition hlsl_compat_overloads.h:25
_DXC_COMPAT_TERNARY_INTEGER_OVERLOADS
#define _DXC_COMPAT_TERNARY_INTEGER_OVERLOADS(fn)
Definition hlsl_compat_overloads.h:111
_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS
#define _DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(fn)
Definition hlsl_compat_overloads.h:19
_DXC_COMPAT_TERNARY_DOUBLE_OVERLOADS
#define _DXC_COMPAT_TERNARY_DOUBLE_OVERLOADS(fn)
Definition hlsl_compat_overloads.h:39
_DXC_COMPAT_UNARY_INTEGER_OVERLOADS
#define _DXC_COMPAT_UNARY_INTEGER_OVERLOADS(fn)
Definition hlsl_compat_overloads.h:53
_DXC_COMPAT_BINARY_INTEGER_OVERLOADS
#define _DXC_COMPAT_BINARY_INTEGER_OVERLOADS(fn)
Definition hlsl_compat_overloads.h:71
hlsl::__detail::enable_if_t
typename enable_if< B, T >::Type enable_if_t
Definition hlsl_detail.h:31
hlsl::max
half max(half, half)
hlsl::float4
vector< float, 4 > float4
Definition hlsl_basic_types.h:96
hlsl::lerp
half lerp(half, half, half)
hlsl::bool4
vector< bool, 4 > bool4
Definition hlsl_basic_types.h:63
hlsl::bool3
vector< bool, 3 > bool3
Definition hlsl_basic_types.h:62
hlsl::clamp
half clamp(half, half, half)
hlsl::double3
vector< double, 3 > double3
Definition hlsl_basic_types.h:99
hlsl::float2
vector< float, 2 > float2
Definition hlsl_basic_types.h:94
hlsl::float3
vector< float, 3 > float3
Definition hlsl_basic_types.h:95
hlsl::double4
vector< double, 4 > double4
Definition hlsl_basic_types.h:100
hlsl::double2
vector< double, 2 > double2
Definition hlsl_basic_types.h:98
hlsl::bool2
vector< bool, 2 > bool2
Definition hlsl_basic_types.h:61
hlsl::min
half min(half, half)
hlsl::frac
half frac(half)
hlsl::isinf
bool isinf(half)
step
float __ovld __cnfn step(float, float)
Returns 0.0 if x < edge, otherwise it returns 1.0.
radians
float __ovld __cnfn radians(float)
Converts degrees to radians, i.e.
degrees
float __ovld __cnfn degrees(float)
Converts radians to degrees, i.e.
normalize
float __ovld __cnfn normalize(float)
Returns a vector in the same direction as p but with a length of 1.
sinh
#define sinh(__x)
Definition tgmath.h:373
asin
#define asin(__x)
Definition tgmath.h:112
sqrt
#define sqrt(__x)
Definition tgmath.h:520
acos
#define acos(__x)
Definition tgmath.h:83
exp
#define exp(__x)
Definition tgmath.h:431
atan2
#define atan2(__x, __y)
Definition tgmath.h:566
exp2
#define exp2(__x)
Definition tgmath.h:670
sin
#define sin(__x)
Definition tgmath.h:286
log2
#define log2(__x)
Definition tgmath.h:970
cosh
#define cosh(__x)
Definition tgmath.h:344
trunc
#define trunc(__x)
Definition tgmath.h:1216
round
#define round(__x)
Definition tgmath.h:1148
tan
#define tan(__x)
Definition tgmath.h:315
cos
#define cos(__x)
Definition tgmath.h:257
log10
#define log10(__x)
Definition tgmath.h:936
pow
#define pow(__x, __y)
Definition tgmath.h:490
tanh
#define tanh(__x)
Definition tgmath.h:402
atan
#define atan(__x)
Definition tgmath.h:141
floor
#define floor(__x)
Definition tgmath.h:722
ceil
#define ceil(__x)
Definition tgmath.h:601
log
#define log(__x)
Definition tgmath.h:460
Generated on for clang by doxygen 1.14.0