DPC++ Runtime
Runtime libraries for oneAPI DPC++
builtins_helper.hpp
Go to the documentation of this file.
1 //==----------- builtins_helper.hpp - SYCL built-in helper ----------------==//
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 #include <CL/sycl/detail/export.hpp>
10 #include <CL/sycl/detail/generic_type_traits.hpp>
11 #include <CL/sycl/exception.hpp>
12 #include <CL/sycl/pointers.hpp>
13 #include <CL/sycl/types.hpp>
14 
15 // TODO Decide whether to mark functions with this attribute.
16 #define __NOEXC /*noexcept*/
17 
18 #define __MAKE_1V(Fun, Call, N, Ret, Arg1) \
19  __SYCL_EXPORT sycl::vec<Ret, N> Fun __NOEXC(sycl::vec<Arg1, N> x) { \
20  sycl::vec<Ret, N> r; \
21  detail::helper<N - 1>().run_1v( \
22  r, [](Arg1 x) { return cl::__host_std::Call(x); }, x); \
23  return r; \
24  }
25 
26 #define __MAKE_1V_2V(Fun, Call, N, Ret, Arg1, Arg2) \
27  __SYCL_EXPORT sycl::vec<Ret, N> Fun __NOEXC(sycl::vec<Arg1, N> x, \
28  sycl::vec<Arg2, N> y) { \
29  sycl::vec<Ret, N> r; \
30  detail::helper<N - 1>().run_1v_2v( \
31  r, [](Arg1 x, Arg2 y) { return cl::__host_std::Call(x, y); }, x, y); \
32  return r; \
33  }
34 
35 #define __MAKE_1V_2V_RS(Fun, Call, N, Ret, Arg1, Arg2) \
36  __SYCL_EXPORT Ret Fun __NOEXC(sycl::vec<Arg1, N> x, sycl::vec<Arg2, N> y) { \
37  Ret r = Ret(); \
38  detail::helper<N - 1>().run_1v_2v_rs( \
39  r, \
40  [](Ret &r, Arg1 x, Arg2 y) { return cl::__host_std::Call(r, x, y); }, \
41  x, y); \
42  return r; \
43  }
44 
45 #define __MAKE_1V_RS(Fun, Call, N, Ret, Arg1) \
46  __SYCL_EXPORT Ret Fun __NOEXC(sycl::vec<Arg1, N> x) { \
47  Ret r = Ret(); \
48  detail::helper<N - 1>().run_1v_rs( \
49  r, [](Ret &r, Arg1 x) { return cl::__host_std::Call(r, x); }, x); \
50  return r; \
51  }
52 
53 #define __MAKE_1V_2V_3V(Fun, Call, N, Ret, Arg1, Arg2, Arg3) \
54  __SYCL_EXPORT sycl::vec<Ret, N> Fun __NOEXC( \
55  sycl::vec<Arg1, N> x, sycl::vec<Arg2, N> y, sycl::vec<Arg3, N> z) { \
56  sycl::vec<Ret, N> r; \
57  detail::helper<N - 1>().run_1v_2v_3v( \
58  r, \
59  [](Arg1 x, Arg2 y, Arg3 z) { return cl::__host_std::Call(x, y, z); }, \
60  x, y, z); \
61  return r; \
62  }
63 
64 #define __MAKE_1V_2S_3S(Fun, N, Ret, Arg1, Arg2, Arg3) \
65  __SYCL_EXPORT sycl::vec<Ret, N> Fun __NOEXC(sycl::vec<Arg1, N> x, Arg2 y, \
66  Arg3 z) { \
67  sycl::vec<Ret, N> r; \
68  detail::helper<N - 1>().run_1v_2s_3s( \
69  r, \
70  [](Arg1 x, Arg2 y, Arg3 z) { return cl::__host_std::Fun(x, y, z); }, \
71  x, y, z); \
72  return r; \
73  }
74 
75 #define __MAKE_1V_2S(Fun, N, Ret, Arg1, Arg2) \
76  __SYCL_EXPORT sycl::vec<Ret, N> Fun __NOEXC(sycl::vec<Arg1, N> x, Arg2 y) { \
77  sycl::vec<Ret, N> r; \
78  detail::helper<N - 1>().run_1v_2s( \
79  r, [](Arg1 x, Arg2 y) { return cl::__host_std::Fun(x, y); }, x, y); \
80  return r; \
81  }
82 
83 #define __MAKE_SR_1V_AND(Fun, Call, N, Ret, Arg1) \
84  __SYCL_EXPORT Ret Fun __NOEXC(sycl::vec<Arg1, N> x) { \
85  Ret r; \
86  detail::helper<N - 1>().run_1v_sr_and( \
87  r, [](Arg1 x) { return cl::__host_std::Call(x); }, x); \
88  return r; \
89  }
90 
91 #define __MAKE_SR_1V_OR(Fun, Call, N, Ret, Arg1) \
92  __SYCL_EXPORT Ret Fun __NOEXC(sycl::vec<Arg1, N> x) { \
93  Ret r; \
94  detail::helper<N - 1>().run_1v_sr_or( \
95  r, [](Arg1 x) { return cl::__host_std::Call(x); }, x); \
96  return r; \
97  }
98 
99 #define __MAKE_1V_2P(Fun, N, Ret, Arg1, Arg2) \
100  __SYCL_EXPORT sycl::vec<Ret, N> Fun __NOEXC(sycl::vec<Arg1, N> x, \
101  sycl::vec<Arg2, N> *y) { \
102  sycl::vec<Ret, N> r; \
103  detail::helper<N - 1>().run_1v_2p( \
104  r, [](Arg1 x, Arg2 *y) { return cl::__host_std::Fun(x, y); }, x, y); \
105  return r; \
106  }
107 
108 #define __MAKE_1V_2V_3P(Fun, N, Ret, Arg1, Arg2, Arg3) \
109  __SYCL_EXPORT sycl::vec<Ret, N> Fun __NOEXC( \
110  sycl::vec<Arg1, N> x, sycl::vec<Arg2, N> y, sycl::vec<Arg3, N> *z) { \
111  sycl::vec<Ret, N> r; \
112  detail::helper<N - 1>().run_1v_2v_3p( \
113  r, \
114  [](Arg1 x, Arg2 y, Arg3 *z) { return cl::__host_std::Fun(x, y, z); }, \
115  x, y, z); \
116  return r; \
117  }
118 
119 #define MAKE_1V(Fun, Ret, Arg1) MAKE_1V_FUNC(Fun, Fun, Ret, Arg1)
120 
121 #define MAKE_1V_FUNC(Fun, Call, Ret, Arg1) \
122  __MAKE_1V(Fun, Call, 1, Ret, Arg1) \
123  __MAKE_1V(Fun, Call, 2, Ret, Arg1) \
124  __MAKE_1V(Fun, Call, 3, Ret, Arg1) \
125  __MAKE_1V(Fun, Call, 4, Ret, Arg1) \
126  __MAKE_1V(Fun, Call, 8, Ret, Arg1) \
127  __MAKE_1V(Fun, Call, 16, Ret, Arg1)
128 
129 #define MAKE_1V_2V(Fun, Ret, Arg1, Arg2) \
130  MAKE_1V_2V_FUNC(Fun, Fun, Ret, Arg1, Arg2)
131 
132 #define MAKE_1V_2V_FUNC(Fun, Call, Ret, Arg1, Arg2) \
133  __MAKE_1V_2V(Fun, Call, 1, Ret, Arg1, Arg2) \
134  __MAKE_1V_2V(Fun, Call, 2, Ret, Arg1, Arg2) \
135  __MAKE_1V_2V(Fun, Call, 3, Ret, Arg1, Arg2) \
136  __MAKE_1V_2V(Fun, Call, 4, Ret, Arg1, Arg2) \
137  __MAKE_1V_2V(Fun, Call, 8, Ret, Arg1, Arg2) \
138  __MAKE_1V_2V(Fun, Call, 16, Ret, Arg1, Arg2)
139 
140 #define MAKE_1V_2V_3V(Fun, Ret, Arg1, Arg2, Arg3) \
141  MAKE_1V_2V_3V_FUNC(Fun, Fun, Ret, Arg1, Arg2, Arg3)
142 
143 #define MAKE_1V_2V_3V_FUNC(Fun, Call, Ret, Arg1, Arg2, Arg3) \
144  __MAKE_1V_2V_3V(Fun, Call, 1, Ret, Arg1, Arg2, Arg3) \
145  __MAKE_1V_2V_3V(Fun, Call, 2, Ret, Arg1, Arg2, Arg3) \
146  __MAKE_1V_2V_3V(Fun, Call, 3, Ret, Arg1, Arg2, Arg3) \
147  __MAKE_1V_2V_3V(Fun, Call, 4, Ret, Arg1, Arg2, Arg3) \
148  __MAKE_1V_2V_3V(Fun, Call, 8, Ret, Arg1, Arg2, Arg3) \
149  __MAKE_1V_2V_3V(Fun, Call, 16, Ret, Arg1, Arg2, Arg3)
150 
151 #define MAKE_SC_1V_2V_3V(Fun, Ret, Arg1, Arg2, Arg3) \
152  MAKE_SC_3ARG(Fun, Ret, Arg1, Arg2, Arg3) \
153  MAKE_1V_2V_3V_FUNC(Fun, Fun, Ret, Arg1, Arg2, Arg3)
154 
155 #define MAKE_SC_FSC_1V_2V_3V_FV(FunSc, FunV, Ret, Arg1, Arg2, Arg3) \
156  MAKE_SC_3ARG(FunSc, Ret, Arg1, Arg2, Arg3) \
157  MAKE_1V_2V_3V_FUNC(FunSc, FunV, Ret, Arg1, Arg2, Arg3)
158 
159 #define MAKE_SC_3ARG(Fun, Ret, Arg1, Arg2, Arg3) \
160  __SYCL_EXPORT Ret Fun __NOEXC(Arg1 x, Arg2 y, Arg3 z) { \
161  return (Ret)__##Fun(x, y, z); \
162  }
163 
164 #define MAKE_1V_2S(Fun, Ret, Arg1, Arg2) \
165  __MAKE_1V_2S(Fun, 1, Ret, Arg1, Arg2) \
166  __MAKE_1V_2S(Fun, 2, Ret, Arg1, Arg2) \
167  __MAKE_1V_2S(Fun, 3, Ret, Arg1, Arg2) \
168  __MAKE_1V_2S(Fun, 4, Ret, Arg1, Arg2) \
169  __MAKE_1V_2S(Fun, 8, Ret, Arg1, Arg2) \
170  __MAKE_1V_2S(Fun, 16, Ret, Arg1, Arg2)
171 
172 #define MAKE_1V_2S_3S(Fun, Ret, Arg1, Arg2, Arg3) \
173  __MAKE_1V_2S_3S(Fun, 1, Ret, Arg1, Arg2, Arg3) \
174  __MAKE_1V_2S_3S(Fun, 2, Ret, Arg1, Arg2, Arg3) \
175  __MAKE_1V_2S_3S(Fun, 3, Ret, Arg1, Arg2, Arg3) \
176  __MAKE_1V_2S_3S(Fun, 4, Ret, Arg1, Arg2, Arg3) \
177  __MAKE_1V_2S_3S(Fun, 8, Ret, Arg1, Arg2, Arg3) \
178  __MAKE_1V_2S_3S(Fun, 16, Ret, Arg1, Arg2, Arg3)
179 
180 #define MAKE_SR_1V_AND(Fun, Call, Ret, Arg1) \
181  __MAKE_SR_1V_AND(Fun, Call, 1, Ret, Arg1) \
182  __MAKE_SR_1V_AND(Fun, Call, 2, Ret, Arg1) \
183  __MAKE_SR_1V_AND(Fun, Call, 3, Ret, Arg1) \
184  __MAKE_SR_1V_AND(Fun, Call, 4, Ret, Arg1) \
185  __MAKE_SR_1V_AND(Fun, Call, 8, Ret, Arg1) \
186  __MAKE_SR_1V_AND(Fun, Call, 16, Ret, Arg1)
187 
188 #define MAKE_SR_1V_OR(Fun, Call, Ret, Arg1) \
189  __MAKE_SR_1V_OR(Fun, Call, 1, Ret, Arg1) \
190  __MAKE_SR_1V_OR(Fun, Call, 2, Ret, Arg1) \
191  __MAKE_SR_1V_OR(Fun, Call, 3, Ret, Arg1) \
192  __MAKE_SR_1V_OR(Fun, Call, 4, Ret, Arg1) \
193  __MAKE_SR_1V_OR(Fun, Call, 8, Ret, Arg1) \
194  __MAKE_SR_1V_OR(Fun, Call, 16, Ret, Arg1)
195 
196 #define MAKE_1V_2P(Fun, Ret, Arg1, Arg2) \
197  __MAKE_1V_2P(Fun, 1, Ret, Arg1, Arg2) \
198  __MAKE_1V_2P(Fun, 2, Ret, Arg1, Arg2) \
199  __MAKE_1V_2P(Fun, 3, Ret, Arg1, Arg2) \
200  __MAKE_1V_2P(Fun, 4, Ret, Arg1, Arg2) \
201  __MAKE_1V_2P(Fun, 8, Ret, Arg1, Arg2) \
202  __MAKE_1V_2P(Fun, 16, Ret, Arg1, Arg2)
203 
204 #define MAKE_GEO_1V_2V_RS(Fun, Call, Ret, Arg1, Arg2) \
205  __MAKE_1V_2V_RS(Fun, Call, 1, Ret, Arg1, Arg2) \
206  __MAKE_1V_2V_RS(Fun, Call, 2, Ret, Arg1, Arg2) \
207  __MAKE_1V_2V_RS(Fun, Call, 3, Ret, Arg1, Arg2) \
208  __MAKE_1V_2V_RS(Fun, Call, 4, Ret, Arg1, Arg2) \
209  __MAKE_1V_2V_RS(Fun, Call, 8, Ret, Arg1, Arg2) \
210  __MAKE_1V_2V_RS(Fun, Call, 16, Ret, Arg1, Arg2)
211 
212 #define MAKE_1V_2V_3P(Fun, Ret, Arg1, Arg2, Arg3) \
213  __MAKE_1V_2V_3P(Fun, 1, Ret, Arg1, Arg2, Arg3) \
214  __MAKE_1V_2V_3P(Fun, 2, Ret, Arg1, Arg2, Arg3) \
215  __MAKE_1V_2V_3P(Fun, 3, Ret, Arg1, Arg2, Arg3) \
216  __MAKE_1V_2V_3P(Fun, 4, Ret, Arg1, Arg2, Arg3) \
217  __MAKE_1V_2V_3P(Fun, 8, Ret, Arg1, Arg2, Arg3) \
218  __MAKE_1V_2V_3P(Fun, 16, Ret, Arg1, Arg2, Arg3)
219 
220 __SYCL_INLINE_NAMESPACE(cl) {
221 namespace __host_std {
222 namespace detail {
223 
224 template <int N> struct helper {
225  template <typename Res, typename Op, typename T1>
226  inline void run_1v(Res &r, Op op, T1 x) {
227  helper<N - 1>().run_1v(r, op, x);
228  r.template swizzle<N>() = op(x.template swizzle<N>());
229  }
230 
231  template <typename Res, typename Op, typename T1, typename T2>
232  inline void run_1v_2v(Res &r, Op op, T1 x, T2 y) {
233  helper<N - 1>().run_1v_2v(r, op, x, y);
234  r.template swizzle<N>() =
235  op(x.template swizzle<N>(), y.template swizzle<N>());
236  }
237 
238  template <typename Res, typename Op, typename T1, typename T2>
239  inline void run_1v_2s(Res &r, Op op, T1 x, T2 y) {
240  helper<N - 1>().run_1v_2s(r, op, x, y);
241  r.template swizzle<N>() = op(x.template swizzle<N>(), y);
242  }
243 
244  template <typename Res, typename Op, typename T1, typename T2, typename T3>
245  inline void run_1v_2s_3s(Res &r, Op op, T1 x, T2 y, T3 z) {
246  helper<N - 1>().run_1v_2s_3s(r, op, x, y, z);
247  r.template swizzle<N>() = op(x.template swizzle<N>(), y, z);
248  }
249 
250  template <typename Res, typename Op, typename T1, typename T2>
251  inline void run_1v_2v_rs(Res &r, Op op, T1 x, T2 y) {
252  helper<N - 1>().run_1v_2v_rs(r, op, x, y);
253  op(r, x.template swizzle<N>(), y.template swizzle<N>());
254  }
255 
256  template <typename Res, typename Op, typename T1>
257  inline void run_1v_rs(Res &r, Op op, T1 x) {
258  helper<N - 1>().run_1v_rs(r, op, x);
259  op(r, x.template swizzle<N>());
260  }
261 
262  template <typename Res, typename Op, typename T1, typename T2>
263  inline void run_1v_2p(Res &r, Op op, T1 x, T2 y) {
264  helper<N - 1>().run_1v_2p(r, op, x, y);
265  // TODO avoid creating a temporary variable
266  typename std::remove_pointer<T2>::type::element_type temp;
267  r.template swizzle<N>() = op(x.template swizzle<N>(), &temp);
268  y->template swizzle<N>() = temp;
269  }
270 
271  template <typename Res, typename Op, typename T1, typename T2, typename T3>
272  inline void run_1v_2v_3p(Res &r, Op op, T1 x, T2 y, T3 z) {
273  helper<N - 1>().run_1v_2v_3p(r, op, x, y, z);
274  // TODO avoid creating a temporary variable
275  typename std::remove_pointer<T3>::type::element_type temp;
276  r.template swizzle<N>() =
277  op(x.template swizzle<N>(), y.template swizzle<N>(), &temp);
278  z->template swizzle<N>() = temp;
279  }
280 
281  template <typename Res, typename Op, typename T1, typename T2, typename T3>
282  inline void run_1v_2v_3v(Res &r, Op op, T1 x, T2 y, T3 z) {
283  helper<N - 1>().run_1v_2v_3v(r, op, x, y, z);
284  r.template swizzle<N>() =
285  op(x.template swizzle<N>(), y.template swizzle<N>(),
286  z.template swizzle<N>());
287  }
288 
289  template <typename Res, typename Op, typename T1>
290  inline void run_1v_sr_or(Res &r, Op op, T1 x) {
291  helper<N - 1>().run_1v_sr_or(r, op, x);
292  r = (op(x.template swizzle<N>()) || r);
293  }
294 
295  template <typename Res, typename Op, typename T1>
296  inline void run_1v_sr_and(Res &r, Op op, T1 x) {
297  helper<N - 1>().run_1v_sr_and(r, op, x);
298  r = (op(x.template swizzle<N>()) && r);
299  }
300 };
301 
302 template <> struct helper<0> {
303  template <typename Res, typename Op, typename T1>
304  inline void run_1v(Res &r, Op op, T1 x) {
305  r.template swizzle<0>() = op(x.template swizzle<0>());
306  }
307 
308  template <typename Res, typename Op, typename T1, typename T2>
309  inline void run_1v_2v(Res &r, Op op, T1 x, T2 y) {
310  r.template swizzle<0>() =
311  op(x.template swizzle<0>(), y.template swizzle<0>());
312  }
313 
314  template <typename Res, typename Op, typename T1, typename T2>
315  inline void run_1v_2s(Res &r, Op op, T1 x, T2 y) {
316  r.template swizzle<0>() = op(x.template swizzle<0>(), y);
317  }
318 
319  template <typename Res, typename Op, typename T1, typename T2, typename T3>
320  inline void run_1v_2s_3s(Res &r, Op op, T1 x, T2 y, T3 z) {
321  r.template swizzle<0>() = op(x.template swizzle<0>(), y, z);
322  }
323 
324  template <typename Res, typename Op, typename T1, typename T2>
325  inline void run_1v_2v_rs(Res &r, Op op, T1 x, T2 y) {
326  op(r, x.template swizzle<0>(), y.template swizzle<0>());
327  }
328 
329  template <typename Res, typename Op, typename T1>
330  inline void run_1v_rs(Res &r, Op op, T1 x) {
331  op(r, x.template swizzle<0>());
332  }
333 
334  template <typename Res, typename Op, typename T1, typename T2>
335  inline void run_1v_2p(Res &r, Op op, T1 x, T2 y) {
336  // TODO avoid creating a temporary variable
337  typename std::remove_pointer<T2>::type::element_type temp;
338  r.template swizzle<0>() = op(x.template swizzle<0>(), &temp);
339  y->template swizzle<0>() = temp;
340  }
341 
342  template <typename Res, typename Op, typename T1, typename T2, typename T3>
343  inline void run_1v_2v_3p(Res &r, Op op, T1 x, T2 y, T3 z) {
344  // TODO avoid creating a temporary variable
345  typename std::remove_pointer<T3>::type::element_type temp;
346  r.template swizzle<0>() =
347  op(x.template swizzle<0>(), y.template swizzle<0>(), &temp);
348  z->template swizzle<0>() = temp;
349  }
350 
351  template <typename Res, typename Op, typename T1, typename T2, typename T3>
352  inline void run_1v_2v_3v(Res &r, Op op, T1 x, T2 y, T3 z) {
353  r.template swizzle<0>() =
354  op(x.template swizzle<0>(), y.template swizzle<0>(),
355  z.template swizzle<0>());
356  }
357 
358  template <typename Res, typename Op, typename T1>
359  inline void run_1v_sr_or(Res &r, Op op, T1 x) {
360  r = op(x.template swizzle<0>());
361  }
362 
363  template <typename Res, typename Op, typename T1>
364  inline void run_1v_sr_and(Res &r, Op op, T1 x) {
365  r = op(x.template swizzle<0>());
366  }
367 };
368 
369 } // namespace detail
370 } // namespace __host_std
371 } // __SYCL_INLINE_NAMESPACE(cl)
cl::__host_std::detail::helper< 0 >::run_1v
void run_1v(Res &r, Op op, T1 x)
Definition: builtins_helper.hpp:304
cl::__host_std::detail::helper::run_1v_sr_and
void run_1v_sr_and(Res &r, Op op, T1 x)
Definition: builtins_helper.hpp:296
cl::__host_std::detail::helper::run_1v_2s_3s
void run_1v_2s_3s(Res &r, Op op, T1 x, T2 y, T3 z)
Definition: builtins_helper.hpp:245
cl::__host_std::detail::helper< 0 >::run_1v_2v_3p
void run_1v_2v_3p(Res &r, Op op, T1 x, T2 y, T3 z)
Definition: builtins_helper.hpp:343
cl::__host_std::detail::helper< 0 >::run_1v_2s
void run_1v_2s(Res &r, Op op, T1 x, T2 y)
Definition: builtins_helper.hpp:315
cl::__host_std::detail::helper< 0 >::run_1v_2s_3s
void run_1v_2s_3s(Res &r, Op op, T1 x, T2 y, T3 z)
Definition: builtins_helper.hpp:320
cl::__host_std::detail::helper< 0 >::run_1v_2v_3v
void run_1v_2v_3v(Res &r, Op op, T1 x, T2 y, T3 z)
Definition: builtins_helper.hpp:352
cl::__host_std::detail::helper< 0 >::run_1v_sr_or
void run_1v_sr_or(Res &r, Op op, T1 x)
Definition: builtins_helper.hpp:359
export.hpp
generic_type_traits.hpp
cl::__host_std::detail::helper< 0 >::run_1v_rs
void run_1v_rs(Res &r, Op op, T1 x)
Definition: builtins_helper.hpp:330
cl::__host_std::detail::helper< 0 >::run_1v_2v_rs
void run_1v_2v_rs(Res &r, Op op, T1 x, T2 y)
Definition: builtins_helper.hpp:325
cl
We provide new interfaces for matrix muliply in this patch:
Definition: access.hpp:13
cl::__host_std::detail::helper::run_1v_sr_or
void run_1v_sr_or(Res &r, Op op, T1 x)
Definition: builtins_helper.hpp:290
cl::__host_std::detail::helper::run_1v_2p
void run_1v_2p(Res &r, Op op, T1 x, T2 y)
Definition: builtins_helper.hpp:263
cl::__host_std::detail::helper< 0 >::run_1v_2p
void run_1v_2p(Res &r, Op op, T1 x, T2 y)
Definition: builtins_helper.hpp:335
cl::__host_std::detail::helper< 0 >::run_1v_2v
void run_1v_2v(Res &r, Op op, T1 x, T2 y)
Definition: builtins_helper.hpp:309
cl::__host_std::detail::helper::run_1v_2v_3v
void run_1v_2v_3v(Res &r, Op op, T1 x, T2 y, T3 z)
Definition: builtins_helper.hpp:282
cl::__host_std::detail::helper< 0 >::run_1v_sr_and
void run_1v_sr_and(Res &r, Op op, T1 x)
Definition: builtins_helper.hpp:364
cl::__host_std::detail::helper::run_1v_2v_rs
void run_1v_2v_rs(Res &r, Op op, T1 x, T2 y)
Definition: builtins_helper.hpp:251
exception.hpp
cl::__host_std::detail::helper
Definition: builtins_helper.hpp:224
cl::__host_std::detail::helper::run_1v_2s
void run_1v_2s(Res &r, Op op, T1 x, T2 y)
Definition: builtins_helper.hpp:239
types.hpp
pointers.hpp
cl::__host_std::detail::helper::run_1v_2v_3p
void run_1v_2v_3p(Res &r, Op op, T1 x, T2 y, T3 z)
Definition: builtins_helper.hpp:272
cl::__host_std::detail::helper::run_1v_2v
void run_1v_2v(Res &r, Op op, T1 x, T2 y)
Definition: builtins_helper.hpp:232
cl::__host_std::detail::helper::run_1v
void run_1v(Res &r, Op op, T1 x)
Definition: builtins_helper.hpp:226
cl::__host_std::detail::helper::run_1v_rs
void run_1v_rs(Res &r, Op op, T1 x)
Definition: builtins_helper.hpp:257
__SYCL_INLINE_NAMESPACE
#define __SYCL_INLINE_NAMESPACE(X)
Definition: defines_elementary.hpp:12