HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
cl_platform.h
Go to the documentation of this file.
1 /*******************************************************************************
2  * Copyright (c) 2008-2020 The Khronos Group Inc.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  ******************************************************************************/
16 
17 #ifndef __CL_PLATFORM_H
18 #define __CL_PLATFORM_H
19 
20 #include <CL/cl_version.h>
21 
22 #ifdef __cplusplus
23 extern "C" {
24 #endif
25 
26 #if defined(_WIN32)
27  #if !defined(CL_API_ENTRY)
28  #define CL_API_ENTRY
29  #endif
30  #if !defined(CL_API_CALL)
31  #define CL_API_CALL __stdcall
32  #endif
33  #if !defined(CL_CALLBACK)
34  #define CL_CALLBACK __stdcall
35  #endif
36 #else
37  #if !defined(CL_API_ENTRY)
38  #define CL_API_ENTRY
39  #endif
40  #if !defined(CL_API_CALL)
41  #define CL_API_CALL
42  #endif
43  #if !defined(CL_CALLBACK)
44  #define CL_CALLBACK
45  #endif
46 #endif
47 
48 /*
49  * Deprecation flags refer to the last version of the header in which the
50  * feature was not deprecated.
51  *
52  * E.g. VERSION_1_1_DEPRECATED means the feature is present in 1.1 without
53  * deprecation but is deprecated in versions later than 1.1.
54  */
55 
56 #ifndef CL_API_SUFFIX_USER
57 #define CL_API_SUFFIX_USER
58 #endif
59 
60 #ifndef CL_API_PREFIX_USER
61 #define CL_API_PREFIX_USER
62 #endif
63 
64 #define CL_API_SUFFIX_COMMON CL_API_SUFFIX_USER
65 #define CL_API_PREFIX_COMMON CL_API_PREFIX_USER
66 
67 #define CL_API_SUFFIX__VERSION_1_0 CL_API_SUFFIX_COMMON
68 #define CL_API_SUFFIX__VERSION_1_1 CL_API_SUFFIX_COMMON
69 #define CL_API_SUFFIX__VERSION_1_2 CL_API_SUFFIX_COMMON
70 #define CL_API_SUFFIX__VERSION_2_0 CL_API_SUFFIX_COMMON
71 #define CL_API_SUFFIX__VERSION_2_1 CL_API_SUFFIX_COMMON
72 #define CL_API_SUFFIX__VERSION_2_2 CL_API_SUFFIX_COMMON
73 #define CL_API_SUFFIX__VERSION_3_0 CL_API_SUFFIX_COMMON
74 #define CL_API_SUFFIX__EXPERIMENTAL CL_API_SUFFIX_COMMON
75 
76 
77 #ifdef __GNUC__
78  #define CL_API_SUFFIX_DEPRECATED __attribute__((deprecated))
79  #define CL_API_PREFIX_DEPRECATED
80 #elif defined(_WIN32)
81  #define CL_API_SUFFIX_DEPRECATED
82  #define CL_API_PREFIX_DEPRECATED __declspec(deprecated)
83 #else
84  #define CL_API_SUFFIX_DEPRECATED
85  #define CL_API_PREFIX_DEPRECATED
86 #endif
87 
88 #ifdef CL_USE_DEPRECATED_OPENCL_1_0_APIS
89  #define CL_API_SUFFIX__VERSION_1_0_DEPRECATED CL_API_SUFFIX_COMMON
90  #define CL_API_PREFIX__VERSION_1_0_DEPRECATED CL_API_PREFIX_COMMON
91 #else
92  #define CL_API_SUFFIX__VERSION_1_0_DEPRECATED CL_API_SUFFIX_COMMON CL_API_SUFFIX_DEPRECATED
93  #define CL_API_PREFIX__VERSION_1_0_DEPRECATED CL_API_PREFIX_COMMON CL_API_PREFIX_DEPRECATED
94 #endif
95 
96 #ifdef CL_USE_DEPRECATED_OPENCL_1_1_APIS
97  #define CL_API_SUFFIX__VERSION_1_1_DEPRECATED CL_API_SUFFIX_COMMON
98  #define CL_API_PREFIX__VERSION_1_1_DEPRECATED CL_API_PREFIX_COMMON
99 #else
100  #define CL_API_SUFFIX__VERSION_1_1_DEPRECATED CL_API_SUFFIX_COMMON CL_API_SUFFIX_DEPRECATED
101  #define CL_API_PREFIX__VERSION_1_1_DEPRECATED CL_API_PREFIX_COMMON CL_API_PREFIX_DEPRECATED
102 #endif
103 
104 #ifdef CL_USE_DEPRECATED_OPENCL_1_2_APIS
105  #define CL_API_SUFFIX__VERSION_1_2_DEPRECATED CL_API_SUFFIX_COMMON
106  #define CL_API_PREFIX__VERSION_1_2_DEPRECATED CL_API_PREFIX_COMMON
107 #else
108  #define CL_API_SUFFIX__VERSION_1_2_DEPRECATED CL_API_SUFFIX_COMMON CL_API_SUFFIX_DEPRECATED
109  #define CL_API_PREFIX__VERSION_1_2_DEPRECATED CL_API_PREFIX_COMMON CL_API_PREFIX_DEPRECATED
110  #endif
111 
112 #ifdef CL_USE_DEPRECATED_OPENCL_2_0_APIS
113  #define CL_API_SUFFIX__VERSION_2_0_DEPRECATED CL_API_SUFFIX_COMMON
114  #define CL_API_PREFIX__VERSION_2_0_DEPRECATED CL_API_PREFIX_COMMON
115 #else
116  #define CL_API_SUFFIX__VERSION_2_0_DEPRECATED CL_API_SUFFIX_COMMON CL_API_SUFFIX_DEPRECATED
117  #define CL_API_PREFIX__VERSION_2_0_DEPRECATED CL_API_PREFIX_COMMON CL_API_PREFIX_DEPRECATED
118 #endif
119 
120 #ifdef CL_USE_DEPRECATED_OPENCL_2_1_APIS
121  #define CL_API_SUFFIX__VERSION_2_1_DEPRECATED CL_API_SUFFIX_COMMON
122  #define CL_API_PREFIX__VERSION_2_1_DEPRECATED CL_API_PREFIX_COMMON
123 #else
124  #define CL_API_SUFFIX__VERSION_2_1_DEPRECATED CL_API_SUFFIX_COMMON CL_API_SUFFIX_DEPRECATED
125  #define CL_API_PREFIX__VERSION_2_1_DEPRECATED CL_API_PREFIX_COMMON CL_API_PREFIX_DEPRECATED
126 #endif
127 
128 #ifdef CL_USE_DEPRECATED_OPENCL_2_2_APIS
129  #define CL_API_SUFFIX__VERSION_2_2_DEPRECATED CL_API_SUFFIX_COMMON
130  #define CL_API_PREFIX__VERSION_2_2_DEPRECATED CL_API_PREFIX_COMMON
131 #else
132  #define CL_API_SUFFIX__VERSION_2_2_DEPRECATED CL_API_SUFFIX_COMMON CL_API_SUFFIX_DEPRECATED
133  #define CL_API_PREFIX__VERSION_2_2_DEPRECATED CL_API_PREFIX_COMMON CL_API_PREFIX_DEPRECATED
134 #endif
135 
136 #if (defined (_WIN32) && defined(_MSC_VER))
137 
138 #if defined(__clang__)
139 #pragma clang diagnostic push
140 #pragma clang diagnostic ignored "-Wlanguage-extension-token"
141 #endif
142 
143 /* intptr_t is used in cl.h and provided by stddef.h in Visual C++, but not in clang */
144 /* stdint.h was missing before Visual Studio 2010, include it for later versions and for clang */
145 #if defined(__clang__) || _MSC_VER >= 1600
146  #include <stdint.h>
147 #endif
148 
149 /* scalar types */
150 typedef signed __int8 cl_char;
151 typedef unsigned __int8 cl_uchar;
152 typedef signed __int16 cl_short;
153 typedef unsigned __int16 cl_ushort;
154 typedef signed __int32 cl_int;
155 typedef unsigned __int32 cl_uint;
156 typedef signed __int64 cl_long;
157 typedef unsigned __int64 cl_ulong;
158 
159 typedef unsigned __int16 cl_half;
160 typedef float cl_float;
161 typedef double cl_double;
162 
163 #if defined(__clang__)
164 #pragma clang diagnostic pop
165 #endif
166 
167 /* Macro names and corresponding values defined by OpenCL */
168 #define CL_CHAR_BIT 8
169 #define CL_SCHAR_MAX 127
170 #define CL_SCHAR_MIN (-127-1)
171 #define CL_CHAR_MAX CL_SCHAR_MAX
172 #define CL_CHAR_MIN CL_SCHAR_MIN
173 #define CL_UCHAR_MAX 255
174 #define CL_SHRT_MAX 32767
175 #define CL_SHRT_MIN (-32767-1)
176 #define CL_USHRT_MAX 65535
177 #define CL_INT_MAX 2147483647
178 #define CL_INT_MIN (-2147483647-1)
179 #define CL_UINT_MAX 0xffffffffU
180 #define CL_LONG_MAX ((cl_long) 0x7FFFFFFFFFFFFFFFLL)
181 #define CL_LONG_MIN ((cl_long) -0x7FFFFFFFFFFFFFFFLL - 1LL)
182 #define CL_ULONG_MAX ((cl_ulong) 0xFFFFFFFFFFFFFFFFULL)
183 
184 #define CL_FLT_DIG 6
185 #define CL_FLT_MANT_DIG 24
186 #define CL_FLT_MAX_10_EXP +38
187 #define CL_FLT_MAX_EXP +128
188 #define CL_FLT_MIN_10_EXP -37
189 #define CL_FLT_MIN_EXP -125
190 #define CL_FLT_RADIX 2
191 #define CL_FLT_MAX 340282346638528859811704183484516925440.0f
192 #define CL_FLT_MIN 1.175494350822287507969e-38f
193 #define CL_FLT_EPSILON 1.1920928955078125e-7f
194 
195 #define CL_HALF_DIG 3
196 #define CL_HALF_MANT_DIG 11
197 #define CL_HALF_MAX_10_EXP +4
198 #define CL_HALF_MAX_EXP +16
199 #define CL_HALF_MIN_10_EXP -4
200 #define CL_HALF_MIN_EXP -13
201 #define CL_HALF_RADIX 2
202 #define CL_HALF_MAX 65504.0f
203 #define CL_HALF_MIN 6.103515625e-05f
204 #define CL_HALF_EPSILON 9.765625e-04f
205 
206 #define CL_DBL_DIG 15
207 #define CL_DBL_MANT_DIG 53
208 #define CL_DBL_MAX_10_EXP +308
209 #define CL_DBL_MAX_EXP +1024
210 #define CL_DBL_MIN_10_EXP -307
211 #define CL_DBL_MIN_EXP -1021
212 #define CL_DBL_RADIX 2
213 #define CL_DBL_MAX 1.7976931348623158e+308
214 #define CL_DBL_MIN 2.225073858507201383090e-308
215 #define CL_DBL_EPSILON 2.220446049250313080847e-16
216 
217 #define CL_M_E 2.7182818284590452354
218 #define CL_M_LOG2E 1.4426950408889634074
219 #define CL_M_LOG10E 0.43429448190325182765
220 #define CL_M_LN2 0.69314718055994530942
221 #define CL_M_LN10 2.30258509299404568402
222 #define CL_M_PI 3.14159265358979323846
223 #define CL_M_PI_2 1.57079632679489661923
224 #define CL_M_PI_4 0.78539816339744830962
225 #define CL_M_1_PI 0.31830988618379067154
226 #define CL_M_2_PI 0.63661977236758134308
227 #define CL_M_2_SQRTPI 1.12837916709551257390
228 #define CL_M_SQRT2 1.41421356237309504880
229 #define CL_M_SQRT1_2 0.70710678118654752440
230 
231 #define CL_M_E_F 2.718281828f
232 #define CL_M_LOG2E_F 1.442695041f
233 #define CL_M_LOG10E_F 0.434294482f
234 #define CL_M_LN2_F 0.693147181f
235 #define CL_M_LN10_F 2.302585093f
236 #define CL_M_PI_F 3.141592654f
237 #define CL_M_PI_2_F 1.570796327f
238 #define CL_M_PI_4_F 0.785398163f
239 #define CL_M_1_PI_F 0.318309886f
240 #define CL_M_2_PI_F 0.636619772f
241 #define CL_M_2_SQRTPI_F 1.128379167f
242 #define CL_M_SQRT2_F 1.414213562f
243 #define CL_M_SQRT1_2_F 0.707106781f
244 
245 #define CL_NAN (CL_INFINITY - CL_INFINITY)
246 #define CL_HUGE_VALF ((cl_float) 1e50)
247 #define CL_HUGE_VAL ((cl_double) 1e500)
248 #define CL_MAXFLOAT CL_FLT_MAX
249 #define CL_INFINITY CL_HUGE_VALF
250 
251 #else
252 
253 #include <stdint.h>
254 
255 /* scalar types */
256 typedef int8_t cl_char;
257 typedef uint8_t cl_uchar;
258 typedef int16_t cl_short;
259 typedef uint16_t cl_ushort;
260 typedef int32_t cl_int;
261 typedef uint32_t cl_uint;
262 typedef int64_t cl_long;
263 typedef uint64_t cl_ulong;
264 
265 typedef uint16_t cl_half;
266 typedef float cl_float;
267 typedef double cl_double;
268 
269 /* Macro names and corresponding values defined by OpenCL */
270 #define CL_CHAR_BIT 8
271 #define CL_SCHAR_MAX 127
272 #define CL_SCHAR_MIN (-127-1)
273 #define CL_CHAR_MAX CL_SCHAR_MAX
274 #define CL_CHAR_MIN CL_SCHAR_MIN
275 #define CL_UCHAR_MAX 255
276 #define CL_SHRT_MAX 32767
277 #define CL_SHRT_MIN (-32767-1)
278 #define CL_USHRT_MAX 65535
279 #define CL_INT_MAX 2147483647
280 #define CL_INT_MIN (-2147483647-1)
281 #define CL_UINT_MAX 0xffffffffU
282 #define CL_LONG_MAX ((cl_long) 0x7FFFFFFFFFFFFFFFLL)
283 #define CL_LONG_MIN ((cl_long) -0x7FFFFFFFFFFFFFFFLL - 1LL)
284 #define CL_ULONG_MAX ((cl_ulong) 0xFFFFFFFFFFFFFFFFULL)
285 
286 #define CL_FLT_DIG 6
287 #define CL_FLT_MANT_DIG 24
288 #define CL_FLT_MAX_10_EXP +38
289 #define CL_FLT_MAX_EXP +128
290 #define CL_FLT_MIN_10_EXP -37
291 #define CL_FLT_MIN_EXP -125
292 #define CL_FLT_RADIX 2
293 #define CL_FLT_MAX 340282346638528859811704183484516925440.0f
294 #define CL_FLT_MIN 1.175494350822287507969e-38f
295 #define CL_FLT_EPSILON 1.1920928955078125e-7f
296 
297 #define CL_HALF_DIG 3
298 #define CL_HALF_MANT_DIG 11
299 #define CL_HALF_MAX_10_EXP +4
300 #define CL_HALF_MAX_EXP +16
301 #define CL_HALF_MIN_10_EXP -4
302 #define CL_HALF_MIN_EXP -13
303 #define CL_HALF_RADIX 2
304 #define CL_HALF_MAX 65504.0f
305 #define CL_HALF_MIN 6.103515625e-05f
306 #define CL_HALF_EPSILON 9.765625e-04f
307 
308 #define CL_DBL_DIG 15
309 #define CL_DBL_MANT_DIG 53
310 #define CL_DBL_MAX_10_EXP +308
311 #define CL_DBL_MAX_EXP +1024
312 #define CL_DBL_MIN_10_EXP -307
313 #define CL_DBL_MIN_EXP -1021
314 #define CL_DBL_RADIX 2
315 #define CL_DBL_MAX 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.0
316 #define CL_DBL_MIN 2.225073858507201383090e-308
317 #define CL_DBL_EPSILON 2.220446049250313080847e-16
318 
319 #define CL_M_E 2.7182818284590452354
320 #define CL_M_LOG2E 1.4426950408889634074
321 #define CL_M_LOG10E 0.43429448190325182765
322 #define CL_M_LN2 0.69314718055994530942
323 #define CL_M_LN10 2.30258509299404568402
324 #define CL_M_PI 3.14159265358979323846
325 #define CL_M_PI_2 1.57079632679489661923
326 #define CL_M_PI_4 0.78539816339744830962
327 #define CL_M_1_PI 0.31830988618379067154
328 #define CL_M_2_PI 0.63661977236758134308
329 #define CL_M_2_SQRTPI 1.12837916709551257390
330 #define CL_M_SQRT2 1.41421356237309504880
331 #define CL_M_SQRT1_2 0.70710678118654752440
332 
333 #define CL_M_E_F 2.718281828f
334 #define CL_M_LOG2E_F 1.442695041f
335 #define CL_M_LOG10E_F 0.434294482f
336 #define CL_M_LN2_F 0.693147181f
337 #define CL_M_LN10_F 2.302585093f
338 #define CL_M_PI_F 3.141592654f
339 #define CL_M_PI_2_F 1.570796327f
340 #define CL_M_PI_4_F 0.785398163f
341 #define CL_M_1_PI_F 0.318309886f
342 #define CL_M_2_PI_F 0.636619772f
343 #define CL_M_2_SQRTPI_F 1.128379167f
344 #define CL_M_SQRT2_F 1.414213562f
345 #define CL_M_SQRT1_2_F 0.707106781f
346 
347 #if defined( __GNUC__ )
348  #define CL_HUGE_VALF __builtin_huge_valf()
349  #define CL_HUGE_VAL __builtin_huge_val()
350  #define CL_NAN __builtin_nanf( "" )
351 #else
352  #define CL_HUGE_VALF ((cl_float) 1e50)
353  #define CL_HUGE_VAL ((cl_double) 1e500)
354  float nanf( const char * );
355  #define CL_NAN nanf( "" )
356 #endif
357 #define CL_MAXFLOAT CL_FLT_MAX
358 #define CL_INFINITY CL_HUGE_VALF
359 
360 #endif
361 
362 #include <stddef.h>
363 
364 /* Mirror types to GL types. Mirror types allow us to avoid deciding which 87s to load based on whether we are using GL or GLES here. */
365 typedef unsigned int cl_GLuint;
366 typedef int cl_GLint;
367 typedef unsigned int cl_GLenum;
368 
369 /*
370  * Vector types
371  *
372  * Note: OpenCL requires that all types be naturally aligned.
373  * This means that vector types must be naturally aligned.
374  * For example, a vector of four floats must be aligned to
375  * a 16 byte boundary (calculated as 4 * the natural 4-byte
376  * alignment of the float). The alignment qualifiers here
377  * will only function properly if your compiler supports them
378  * and if you don't actively work to defeat them. For example,
379  * in order for a cl_float4 to be 16 byte aligned in a struct,
380  * the start of the struct must itself be 16-byte aligned.
381  *
382  * Maintaining proper alignment is the user's responsibility.
383  */
384 
385 /* Define basic vector types */
386 #if defined( __VEC__ )
387  #if !defined(__clang__)
388  #include <altivec.h> /* may be omitted depending on compiler. AltiVec spec provides no way to detect whether the header is required. */
389  #endif
390  typedef __vector unsigned char __cl_uchar16;
391  typedef __vector signed char __cl_char16;
392  typedef __vector unsigned short __cl_ushort8;
393  typedef __vector signed short __cl_short8;
394  typedef __vector unsigned int __cl_uint4;
395  typedef __vector signed int __cl_int4;
396  typedef __vector float __cl_float4;
397  #define __CL_UCHAR16__ 1
398  #define __CL_CHAR16__ 1
399  #define __CL_USHORT8__ 1
400  #define __CL_SHORT8__ 1
401  #define __CL_UINT4__ 1
402  #define __CL_INT4__ 1
403  #define __CL_FLOAT4__ 1
404 #endif
405 
406 #if defined( __SSE__ )
407  #if defined( __MINGW64__ )
408  #include <intrin.h>
409  #else
410  #include <xmmintrin.h>
411  #endif
412  #if defined( __GNUC__ )
413  typedef float __cl_float4 __attribute__((vector_size(16)));
414  #else
415  typedef __m128 __cl_float4;
416  #endif
417  #define __CL_FLOAT4__ 1
418 #endif
419 
420 #if defined( __SSE2__ )
421  #if defined( __MINGW64__ )
422  #include <intrin.h>
423  #else
424  #include <emmintrin.h>
425  #endif
426  #if defined( __GNUC__ )
427  typedef cl_uchar __cl_uchar16 __attribute__((vector_size(16)));
428  typedef cl_char __cl_char16 __attribute__((vector_size(16)));
429  typedef cl_ushort __cl_ushort8 __attribute__((vector_size(16)));
430  typedef cl_short __cl_short8 __attribute__((vector_size(16)));
431  typedef cl_uint __cl_uint4 __attribute__((vector_size(16)));
432  typedef cl_int __cl_int4 __attribute__((vector_size(16)));
433  typedef cl_ulong __cl_ulong2 __attribute__((vector_size(16)));
434  typedef cl_long __cl_long2 __attribute__((vector_size(16)));
435  typedef cl_double __cl_double2 __attribute__((vector_size(16)));
436  #else
437  typedef __m128i __cl_uchar16;
438  typedef __m128i __cl_char16;
439  typedef __m128i __cl_ushort8;
440  typedef __m128i __cl_short8;
441  typedef __m128i __cl_uint4;
442  typedef __m128i __cl_int4;
443  typedef __m128i __cl_ulong2;
444  typedef __m128i __cl_long2;
445  typedef __m128d __cl_double2;
446  #endif
447  #define __CL_UCHAR16__ 1
448  #define __CL_CHAR16__ 1
449  #define __CL_USHORT8__ 1
450  #define __CL_SHORT8__ 1
451  #define __CL_INT4__ 1
452  #define __CL_UINT4__ 1
453  #define __CL_ULONG2__ 1
454  #define __CL_LONG2__ 1
455  #define __CL_DOUBLE2__ 1
456 #endif
457 
458 #if defined( __MMX__ )
459  #include <mmintrin.h>
460  #if defined( __GNUC__ )
461  typedef cl_uchar __cl_uchar8 __attribute__((vector_size(8)));
462  typedef cl_char __cl_char8 __attribute__((vector_size(8)));
463  typedef cl_ushort __cl_ushort4 __attribute__((vector_size(8)));
464  typedef cl_short __cl_short4 __attribute__((vector_size(8)));
465  typedef cl_uint __cl_uint2 __attribute__((vector_size(8)));
466  typedef cl_int __cl_int2 __attribute__((vector_size(8)));
467  typedef cl_ulong __cl_ulong1 __attribute__((vector_size(8)));
468  typedef cl_long __cl_long1 __attribute__((vector_size(8)));
469  typedef cl_float __cl_float2 __attribute__((vector_size(8)));
470  #else
471  typedef __m64 __cl_uchar8;
472  typedef __m64 __cl_char8;
473  typedef __m64 __cl_ushort4;
474  typedef __m64 __cl_short4;
475  typedef __m64 __cl_uint2;
476  typedef __m64 __cl_int2;
477  typedef __m64 __cl_ulong1;
478  typedef __m64 __cl_long1;
479  typedef __m64 __cl_float2;
480  #endif
481  #define __CL_UCHAR8__ 1
482  #define __CL_CHAR8__ 1
483  #define __CL_USHORT4__ 1
484  #define __CL_SHORT4__ 1
485  #define __CL_INT2__ 1
486  #define __CL_UINT2__ 1
487  #define __CL_ULONG1__ 1
488  #define __CL_LONG1__ 1
489  #define __CL_FLOAT2__ 1
490 #endif
491 
492 #if defined( __AVX__ )
493  #if defined( __MINGW64__ )
494  #include <intrin.h>
495  #else
496  #include <immintrin.h>
497  #endif
498  #if defined( __GNUC__ )
499  typedef cl_float __cl_float8 __attribute__((vector_size(32)));
500  typedef cl_double __cl_double4 __attribute__((vector_size(32)));
501  #else
502  typedef __m256 __cl_float8;
503  typedef __m256d __cl_double4;
504  #endif
505  #define __CL_FLOAT8__ 1
506  #define __CL_DOUBLE4__ 1
507 #endif
508 
509 /* Define capabilities for anonymous struct members. */
510 #if !defined(__cplusplus) && defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
511 #define __CL_HAS_ANON_STRUCT__ 1
512 #define __CL_ANON_STRUCT__
513 #elif defined(_WIN32) && defined(_MSC_VER) && !defined(__STDC__)
514 #define __CL_HAS_ANON_STRUCT__ 1
515 #define __CL_ANON_STRUCT__
516 #elif defined(__GNUC__) && ! defined(__STRICT_ANSI__)
517 #define __CL_HAS_ANON_STRUCT__ 1
518 #define __CL_ANON_STRUCT__ __extension__
519 #elif defined(__clang__)
520 #define __CL_HAS_ANON_STRUCT__ 1
521 #define __CL_ANON_STRUCT__ __extension__
522 #else
523 #define __CL_HAS_ANON_STRUCT__ 0
524 #define __CL_ANON_STRUCT__
525 #endif
526 
527 #if defined(_WIN32) && defined(_MSC_VER) && __CL_HAS_ANON_STRUCT__
528  /* Disable warning C4201: nonstandard extension used : nameless struct/union */
529  #pragma warning( push )
530  #pragma warning( disable : 4201 )
531 #endif
532 
533 /* Define alignment keys */
534 #if defined( __GNUC__ ) || defined(__INTEGRITY)
535  #define CL_ALIGNED(_x) __attribute__ ((aligned(_x)))
536 #elif defined( _WIN32) && (_MSC_VER)
537  /* Alignment keys neutered on windows because MSVC can't swallow function arguments with alignment requirements */
538  /* http://msdn.microsoft.com/en-us/library/373ak2y1%28VS.71%29.aspx */
539  /* #include <crtdefs.h> */
540  /* #define CL_ALIGNED(_x) _CRT_ALIGN(_x) */
541  #define CL_ALIGNED(_x)
542 #else
543  #warning Need to implement some method to align data here
544  #define CL_ALIGNED(_x)
545 #endif
546 
547 /* Indicate whether .xyzw, .s0123 and .hi.lo are supported */
548 #if __CL_HAS_ANON_STRUCT__
549  /* .xyzw and .s0123...{f|F} are supported */
550  #define CL_HAS_NAMED_VECTOR_FIELDS 1
551  /* .hi and .lo are supported */
552  #define CL_HAS_HI_LO_VECTOR_FIELDS 1
553 #endif
554 
555 /* Define cl_vector types */
556 
557 /* ---- cl_charn ---- */
558 typedef union
559 {
560  cl_char CL_ALIGNED(2) s[2];
561 #if __CL_HAS_ANON_STRUCT__
562  __CL_ANON_STRUCT__ struct{ cl_char x, y; };
563  __CL_ANON_STRUCT__ struct{ cl_char s0, s1; };
564  __CL_ANON_STRUCT__ struct{ cl_char lo, hi; };
565 #endif
566 #if defined( __CL_CHAR2__)
567  __cl_char2 v2;
568 #endif
569 }cl_char2;
570 
571 typedef union
572 {
573  cl_char CL_ALIGNED(4) s[4];
574 #if __CL_HAS_ANON_STRUCT__
575  __CL_ANON_STRUCT__ struct{ cl_char x, y, z, w; };
576  __CL_ANON_STRUCT__ struct{ cl_char s0, s1, s2, s3; };
577  __CL_ANON_STRUCT__ struct{ cl_char2 lo, hi; };
578 #endif
579 #if defined( __CL_CHAR2__)
580  __cl_char2 v2[2];
581 #endif
582 #if defined( __CL_CHAR4__)
583  __cl_char4 v4;
584 #endif
585 }cl_char4;
586 
587 /* cl_char3 is identical in size, alignment and behavior to cl_char4. See section 6.1.5. */
589 
590 typedef union
591 {
592  cl_char CL_ALIGNED(8) s[8];
593 #if __CL_HAS_ANON_STRUCT__
594  __CL_ANON_STRUCT__ struct{ cl_char x, y, z, w; };
595  __CL_ANON_STRUCT__ struct{ cl_char s0, s1, s2, s3, s4, s5, s6, s7; };
596  __CL_ANON_STRUCT__ struct{ cl_char4 lo, hi; };
597 #endif
598 #if defined( __CL_CHAR2__)
599  __cl_char2 v2[4];
600 #endif
601 #if defined( __CL_CHAR4__)
602  __cl_char4 v4[2];
603 #endif
604 #if defined( __CL_CHAR8__ )
605  __cl_char8 v8;
606 #endif
607 }cl_char8;
608 
609 typedef union
610 {
611  cl_char CL_ALIGNED(16) s[16];
612 #if __CL_HAS_ANON_STRUCT__
613  __CL_ANON_STRUCT__ struct{ cl_char x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; };
614  __CL_ANON_STRUCT__ struct{ cl_char s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; };
615  __CL_ANON_STRUCT__ struct{ cl_char8 lo, hi; };
616 #endif
617 #if defined( __CL_CHAR2__)
618  __cl_char2 v2[8];
619 #endif
620 #if defined( __CL_CHAR4__)
621  __cl_char4 v4[4];
622 #endif
623 #if defined( __CL_CHAR8__ )
624  __cl_char8 v8[2];
625 #endif
626 #if defined( __CL_CHAR16__ )
627  __cl_char16 v16;
628 #endif
629 }cl_char16;
630 
631 
632 /* ---- cl_ucharn ---- */
633 typedef union
634 {
635  cl_uchar CL_ALIGNED(2) s[2];
636 #if __CL_HAS_ANON_STRUCT__
637  __CL_ANON_STRUCT__ struct{ cl_uchar x, y; };
638  __CL_ANON_STRUCT__ struct{ cl_uchar s0, s1; };
639  __CL_ANON_STRUCT__ struct{ cl_uchar lo, hi; };
640 #endif
641 #if defined( __cl_uchar2__)
642  __cl_uchar2 v2;
643 #endif
644 }cl_uchar2;
645 
646 typedef union
647 {
648  cl_uchar CL_ALIGNED(4) s[4];
649 #if __CL_HAS_ANON_STRUCT__
650  __CL_ANON_STRUCT__ struct{ cl_uchar x, y, z, w; };
651  __CL_ANON_STRUCT__ struct{ cl_uchar s0, s1, s2, s3; };
652  __CL_ANON_STRUCT__ struct{ cl_uchar2 lo, hi; };
653 #endif
654 #if defined( __CL_UCHAR2__)
655  __cl_uchar2 v2[2];
656 #endif
657 #if defined( __CL_UCHAR4__)
658  __cl_uchar4 v4;
659 #endif
660 }cl_uchar4;
661 
662 /* cl_uchar3 is identical in size, alignment and behavior to cl_uchar4. See section 6.1.5. */
664 
665 typedef union
666 {
667  cl_uchar CL_ALIGNED(8) s[8];
668 #if __CL_HAS_ANON_STRUCT__
669  __CL_ANON_STRUCT__ struct{ cl_uchar x, y, z, w; };
670  __CL_ANON_STRUCT__ struct{ cl_uchar s0, s1, s2, s3, s4, s5, s6, s7; };
671  __CL_ANON_STRUCT__ struct{ cl_uchar4 lo, hi; };
672 #endif
673 #if defined( __CL_UCHAR2__)
674  __cl_uchar2 v2[4];
675 #endif
676 #if defined( __CL_UCHAR4__)
677  __cl_uchar4 v4[2];
678 #endif
679 #if defined( __CL_UCHAR8__ )
680  __cl_uchar8 v8;
681 #endif
682 }cl_uchar8;
683 
684 typedef union
685 {
686  cl_uchar CL_ALIGNED(16) s[16];
687 #if __CL_HAS_ANON_STRUCT__
688  __CL_ANON_STRUCT__ struct{ cl_uchar x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; };
689  __CL_ANON_STRUCT__ struct{ cl_uchar s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; };
690  __CL_ANON_STRUCT__ struct{ cl_uchar8 lo, hi; };
691 #endif
692 #if defined( __CL_UCHAR2__)
693  __cl_uchar2 v2[8];
694 #endif
695 #if defined( __CL_UCHAR4__)
696  __cl_uchar4 v4[4];
697 #endif
698 #if defined( __CL_UCHAR8__ )
699  __cl_uchar8 v8[2];
700 #endif
701 #if defined( __CL_UCHAR16__ )
702  __cl_uchar16 v16;
703 #endif
704 }cl_uchar16;
705 
706 
707 /* ---- cl_shortn ---- */
708 typedef union
709 {
710  cl_short CL_ALIGNED(4) s[2];
711 #if __CL_HAS_ANON_STRUCT__
712  __CL_ANON_STRUCT__ struct{ cl_short x, y; };
713  __CL_ANON_STRUCT__ struct{ cl_short s0, s1; };
714  __CL_ANON_STRUCT__ struct{ cl_short lo, hi; };
715 #endif
716 #if defined( __CL_SHORT2__)
717  __cl_short2 v2;
718 #endif
719 }cl_short2;
720 
721 typedef union
722 {
723  cl_short CL_ALIGNED(8) s[4];
724 #if __CL_HAS_ANON_STRUCT__
725  __CL_ANON_STRUCT__ struct{ cl_short x, y, z, w; };
726  __CL_ANON_STRUCT__ struct{ cl_short s0, s1, s2, s3; };
727  __CL_ANON_STRUCT__ struct{ cl_short2 lo, hi; };
728 #endif
729 #if defined( __CL_SHORT2__)
730  __cl_short2 v2[2];
731 #endif
732 #if defined( __CL_SHORT4__)
733  __cl_short4 v4;
734 #endif
735 }cl_short4;
736 
737 /* cl_short3 is identical in size, alignment and behavior to cl_short4. See section 6.1.5. */
739 
740 typedef union
741 {
742  cl_short CL_ALIGNED(16) s[8];
743 #if __CL_HAS_ANON_STRUCT__
744  __CL_ANON_STRUCT__ struct{ cl_short x, y, z, w; };
745  __CL_ANON_STRUCT__ struct{ cl_short s0, s1, s2, s3, s4, s5, s6, s7; };
746  __CL_ANON_STRUCT__ struct{ cl_short4 lo, hi; };
747 #endif
748 #if defined( __CL_SHORT2__)
749  __cl_short2 v2[4];
750 #endif
751 #if defined( __CL_SHORT4__)
752  __cl_short4 v4[2];
753 #endif
754 #if defined( __CL_SHORT8__ )
755  __cl_short8 v8;
756 #endif
757 }cl_short8;
758 
759 typedef union
760 {
761  cl_short CL_ALIGNED(32) s[16];
762 #if __CL_HAS_ANON_STRUCT__
763  __CL_ANON_STRUCT__ struct{ cl_short x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; };
764  __CL_ANON_STRUCT__ struct{ cl_short s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; };
765  __CL_ANON_STRUCT__ struct{ cl_short8 lo, hi; };
766 #endif
767 #if defined( __CL_SHORT2__)
768  __cl_short2 v2[8];
769 #endif
770 #if defined( __CL_SHORT4__)
771  __cl_short4 v4[4];
772 #endif
773 #if defined( __CL_SHORT8__ )
774  __cl_short8 v8[2];
775 #endif
776 #if defined( __CL_SHORT16__ )
777  __cl_short16 v16;
778 #endif
779 }cl_short16;
780 
781 
782 /* ---- cl_ushortn ---- */
783 typedef union
784 {
785  cl_ushort CL_ALIGNED(4) s[2];
786 #if __CL_HAS_ANON_STRUCT__
787  __CL_ANON_STRUCT__ struct{ cl_ushort x, y; };
788  __CL_ANON_STRUCT__ struct{ cl_ushort s0, s1; };
789  __CL_ANON_STRUCT__ struct{ cl_ushort lo, hi; };
790 #endif
791 #if defined( __CL_USHORT2__)
792  __cl_ushort2 v2;
793 #endif
794 }cl_ushort2;
795 
796 typedef union
797 {
798  cl_ushort CL_ALIGNED(8) s[4];
799 #if __CL_HAS_ANON_STRUCT__
800  __CL_ANON_STRUCT__ struct{ cl_ushort x, y, z, w; };
801  __CL_ANON_STRUCT__ struct{ cl_ushort s0, s1, s2, s3; };
802  __CL_ANON_STRUCT__ struct{ cl_ushort2 lo, hi; };
803 #endif
804 #if defined( __CL_USHORT2__)
805  __cl_ushort2 v2[2];
806 #endif
807 #if defined( __CL_USHORT4__)
808  __cl_ushort4 v4;
809 #endif
810 }cl_ushort4;
811 
812 /* cl_ushort3 is identical in size, alignment and behavior to cl_ushort4. See section 6.1.5. */
814 
815 typedef union
816 {
817  cl_ushort CL_ALIGNED(16) s[8];
818 #if __CL_HAS_ANON_STRUCT__
819  __CL_ANON_STRUCT__ struct{ cl_ushort x, y, z, w; };
820  __CL_ANON_STRUCT__ struct{ cl_ushort s0, s1, s2, s3, s4, s5, s6, s7; };
821  __CL_ANON_STRUCT__ struct{ cl_ushort4 lo, hi; };
822 #endif
823 #if defined( __CL_USHORT2__)
824  __cl_ushort2 v2[4];
825 #endif
826 #if defined( __CL_USHORT4__)
827  __cl_ushort4 v4[2];
828 #endif
829 #if defined( __CL_USHORT8__ )
830  __cl_ushort8 v8;
831 #endif
832 }cl_ushort8;
833 
834 typedef union
835 {
836  cl_ushort CL_ALIGNED(32) s[16];
837 #if __CL_HAS_ANON_STRUCT__
838  __CL_ANON_STRUCT__ struct{ cl_ushort x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; };
839  __CL_ANON_STRUCT__ struct{ cl_ushort s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; };
840  __CL_ANON_STRUCT__ struct{ cl_ushort8 lo, hi; };
841 #endif
842 #if defined( __CL_USHORT2__)
843  __cl_ushort2 v2[8];
844 #endif
845 #if defined( __CL_USHORT4__)
846  __cl_ushort4 v4[4];
847 #endif
848 #if defined( __CL_USHORT8__ )
849  __cl_ushort8 v8[2];
850 #endif
851 #if defined( __CL_USHORT16__ )
852  __cl_ushort16 v16;
853 #endif
854 }cl_ushort16;
855 
856 
857 /* ---- cl_halfn ---- */
858 typedef union
859 {
860  cl_half CL_ALIGNED(4) s[2];
861 #if __CL_HAS_ANON_STRUCT__
862  __CL_ANON_STRUCT__ struct{ cl_half x, y; };
863  __CL_ANON_STRUCT__ struct{ cl_half s0, s1; };
864  __CL_ANON_STRUCT__ struct{ cl_half lo, hi; };
865 #endif
866 #if defined( __CL_HALF2__)
867  __cl_half2 v2;
868 #endif
869 }cl_half2;
870 
871 typedef union
872 {
873  cl_half CL_ALIGNED(8) s[4];
874 #if __CL_HAS_ANON_STRUCT__
875  __CL_ANON_STRUCT__ struct{ cl_half x, y, z, w; };
876  __CL_ANON_STRUCT__ struct{ cl_half s0, s1, s2, s3; };
877  __CL_ANON_STRUCT__ struct{ cl_half2 lo, hi; };
878 #endif
879 #if defined( __CL_HALF2__)
880  __cl_half2 v2[2];
881 #endif
882 #if defined( __CL_HALF4__)
883  __cl_half4 v4;
884 #endif
885 }cl_half4;
886 
887 /* cl_half3 is identical in size, alignment and behavior to cl_half4. See section 6.1.5. */
889 
890 typedef union
891 {
892  cl_half CL_ALIGNED(16) s[8];
893 #if __CL_HAS_ANON_STRUCT__
894  __CL_ANON_STRUCT__ struct{ cl_half x, y, z, w; };
895  __CL_ANON_STRUCT__ struct{ cl_half s0, s1, s2, s3, s4, s5, s6, s7; };
896  __CL_ANON_STRUCT__ struct{ cl_half4 lo, hi; };
897 #endif
898 #if defined( __CL_HALF2__)
899  __cl_half2 v2[4];
900 #endif
901 #if defined( __CL_HALF4__)
902  __cl_half4 v4[2];
903 #endif
904 #if defined( __CL_HALF8__ )
905  __cl_half8 v8;
906 #endif
907 }cl_half8;
908 
909 typedef union
910 {
911  cl_half CL_ALIGNED(32) s[16];
912 #if __CL_HAS_ANON_STRUCT__
913  __CL_ANON_STRUCT__ struct{ cl_half x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; };
914  __CL_ANON_STRUCT__ struct{ cl_half s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; };
915  __CL_ANON_STRUCT__ struct{ cl_half8 lo, hi; };
916 #endif
917 #if defined( __CL_HALF2__)
918  __cl_half2 v2[8];
919 #endif
920 #if defined( __CL_HALF4__)
921  __cl_half4 v4[4];
922 #endif
923 #if defined( __CL_HALF8__ )
924  __cl_half8 v8[2];
925 #endif
926 #if defined( __CL_HALF16__ )
927  __cl_half16 v16;
928 #endif
929 }cl_half16;
930 
931 /* ---- cl_intn ---- */
932 typedef union
933 {
934  cl_int CL_ALIGNED(8) s[2];
935 #if __CL_HAS_ANON_STRUCT__
936  __CL_ANON_STRUCT__ struct{ cl_int x, y; };
937  __CL_ANON_STRUCT__ struct{ cl_int s0, s1; };
938  __CL_ANON_STRUCT__ struct{ cl_int lo, hi; };
939 #endif
940 #if defined( __CL_INT2__)
941  __cl_int2 v2;
942 #endif
943 }cl_int2;
944 
945 typedef union
946 {
947  cl_int CL_ALIGNED(16) s[4];
948 #if __CL_HAS_ANON_STRUCT__
949  __CL_ANON_STRUCT__ struct{ cl_int x, y, z, w; };
950  __CL_ANON_STRUCT__ struct{ cl_int s0, s1, s2, s3; };
951  __CL_ANON_STRUCT__ struct{ cl_int2 lo, hi; };
952 #endif
953 #if defined( __CL_INT2__)
954  __cl_int2 v2[2];
955 #endif
956 #if defined( __CL_INT4__)
957  __cl_int4 v4;
958 #endif
959 }cl_int4;
960 
961 /* cl_int3 is identical in size, alignment and behavior to cl_int4. See section 6.1.5. */
962 typedef cl_int4 cl_int3;
963 
964 typedef union
965 {
966  cl_int CL_ALIGNED(32) s[8];
967 #if __CL_HAS_ANON_STRUCT__
968  __CL_ANON_STRUCT__ struct{ cl_int x, y, z, w; };
969  __CL_ANON_STRUCT__ struct{ cl_int s0, s1, s2, s3, s4, s5, s6, s7; };
970  __CL_ANON_STRUCT__ struct{ cl_int4 lo, hi; };
971 #endif
972 #if defined( __CL_INT2__)
973  __cl_int2 v2[4];
974 #endif
975 #if defined( __CL_INT4__)
976  __cl_int4 v4[2];
977 #endif
978 #if defined( __CL_INT8__ )
979  __cl_int8 v8;
980 #endif
981 }cl_int8;
982 
983 typedef union
984 {
985  cl_int CL_ALIGNED(64) s[16];
986 #if __CL_HAS_ANON_STRUCT__
987  __CL_ANON_STRUCT__ struct{ cl_int x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; };
988  __CL_ANON_STRUCT__ struct{ cl_int s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; };
989  __CL_ANON_STRUCT__ struct{ cl_int8 lo, hi; };
990 #endif
991 #if defined( __CL_INT2__)
992  __cl_int2 v2[8];
993 #endif
994 #if defined( __CL_INT4__)
995  __cl_int4 v4[4];
996 #endif
997 #if defined( __CL_INT8__ )
998  __cl_int8 v8[2];
999 #endif
1000 #if defined( __CL_INT16__ )
1001  __cl_int16 v16;
1002 #endif
1003 }cl_int16;
1004 
1005 
1006 /* ---- cl_uintn ---- */
1007 typedef union
1008 {
1009  cl_uint CL_ALIGNED(8) s[2];
1010 #if __CL_HAS_ANON_STRUCT__
1011  __CL_ANON_STRUCT__ struct{ cl_uint x, y; };
1012  __CL_ANON_STRUCT__ struct{ cl_uint s0, s1; };
1013  __CL_ANON_STRUCT__ struct{ cl_uint lo, hi; };
1014 #endif
1015 #if defined( __CL_UINT2__)
1016  __cl_uint2 v2;
1017 #endif
1018 }cl_uint2;
1019 
1020 typedef union
1021 {
1022  cl_uint CL_ALIGNED(16) s[4];
1023 #if __CL_HAS_ANON_STRUCT__
1024  __CL_ANON_STRUCT__ struct{ cl_uint x, y, z, w; };
1025  __CL_ANON_STRUCT__ struct{ cl_uint s0, s1, s2, s3; };
1026  __CL_ANON_STRUCT__ struct{ cl_uint2 lo, hi; };
1027 #endif
1028 #if defined( __CL_UINT2__)
1029  __cl_uint2 v2[2];
1030 #endif
1031 #if defined( __CL_UINT4__)
1032  __cl_uint4 v4;
1033 #endif
1034 }cl_uint4;
1035 
1036 /* cl_uint3 is identical in size, alignment and behavior to cl_uint4. See section 6.1.5. */
1038 
1039 typedef union
1040 {
1041  cl_uint CL_ALIGNED(32) s[8];
1042 #if __CL_HAS_ANON_STRUCT__
1043  __CL_ANON_STRUCT__ struct{ cl_uint x, y, z, w; };
1044  __CL_ANON_STRUCT__ struct{ cl_uint s0, s1, s2, s3, s4, s5, s6, s7; };
1045  __CL_ANON_STRUCT__ struct{ cl_uint4 lo, hi; };
1046 #endif
1047 #if defined( __CL_UINT2__)
1048  __cl_uint2 v2[4];
1049 #endif
1050 #if defined( __CL_UINT4__)
1051  __cl_uint4 v4[2];
1052 #endif
1053 #if defined( __CL_UINT8__ )
1054  __cl_uint8 v8;
1055 #endif
1056 }cl_uint8;
1057 
1058 typedef union
1059 {
1060  cl_uint CL_ALIGNED(64) s[16];
1061 #if __CL_HAS_ANON_STRUCT__
1062  __CL_ANON_STRUCT__ struct{ cl_uint x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; };
1063  __CL_ANON_STRUCT__ struct{ cl_uint s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; };
1064  __CL_ANON_STRUCT__ struct{ cl_uint8 lo, hi; };
1065 #endif
1066 #if defined( __CL_UINT2__)
1067  __cl_uint2 v2[8];
1068 #endif
1069 #if defined( __CL_UINT4__)
1070  __cl_uint4 v4[4];
1071 #endif
1072 #if defined( __CL_UINT8__ )
1073  __cl_uint8 v8[2];
1074 #endif
1075 #if defined( __CL_UINT16__ )
1076  __cl_uint16 v16;
1077 #endif
1078 }cl_uint16;
1079 
1080 /* ---- cl_longn ---- */
1081 typedef union
1082 {
1083  cl_long CL_ALIGNED(16) s[2];
1084 #if __CL_HAS_ANON_STRUCT__
1085  __CL_ANON_STRUCT__ struct{ cl_long x, y; };
1086  __CL_ANON_STRUCT__ struct{ cl_long s0, s1; };
1087  __CL_ANON_STRUCT__ struct{ cl_long lo, hi; };
1088 #endif
1089 #if defined( __CL_LONG2__)
1090  __cl_long2 v2;
1091 #endif
1092 }cl_long2;
1093 
1094 typedef union
1095 {
1096  cl_long CL_ALIGNED(32) s[4];
1097 #if __CL_HAS_ANON_STRUCT__
1098  __CL_ANON_STRUCT__ struct{ cl_long x, y, z, w; };
1099  __CL_ANON_STRUCT__ struct{ cl_long s0, s1, s2, s3; };
1100  __CL_ANON_STRUCT__ struct{ cl_long2 lo, hi; };
1101 #endif
1102 #if defined( __CL_LONG2__)
1103  __cl_long2 v2[2];
1104 #endif
1105 #if defined( __CL_LONG4__)
1106  __cl_long4 v4;
1107 #endif
1108 }cl_long4;
1109 
1110 /* cl_long3 is identical in size, alignment and behavior to cl_long4. See section 6.1.5. */
1112 
1113 typedef union
1114 {
1115  cl_long CL_ALIGNED(64) s[8];
1116 #if __CL_HAS_ANON_STRUCT__
1117  __CL_ANON_STRUCT__ struct{ cl_long x, y, z, w; };
1118  __CL_ANON_STRUCT__ struct{ cl_long s0, s1, s2, s3, s4, s5, s6, s7; };
1119  __CL_ANON_STRUCT__ struct{ cl_long4 lo, hi; };
1120 #endif
1121 #if defined( __CL_LONG2__)
1122  __cl_long2 v2[4];
1123 #endif
1124 #if defined( __CL_LONG4__)
1125  __cl_long4 v4[2];
1126 #endif
1127 #if defined( __CL_LONG8__ )
1128  __cl_long8 v8;
1129 #endif
1130 }cl_long8;
1131 
1132 typedef union
1133 {
1134  cl_long CL_ALIGNED(128) s[16];
1135 #if __CL_HAS_ANON_STRUCT__
1136  __CL_ANON_STRUCT__ struct{ cl_long x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; };
1137  __CL_ANON_STRUCT__ struct{ cl_long s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; };
1138  __CL_ANON_STRUCT__ struct{ cl_long8 lo, hi; };
1139 #endif
1140 #if defined( __CL_LONG2__)
1141  __cl_long2 v2[8];
1142 #endif
1143 #if defined( __CL_LONG4__)
1144  __cl_long4 v4[4];
1145 #endif
1146 #if defined( __CL_LONG8__ )
1147  __cl_long8 v8[2];
1148 #endif
1149 #if defined( __CL_LONG16__ )
1150  __cl_long16 v16;
1151 #endif
1152 }cl_long16;
1153 
1154 
1155 /* ---- cl_ulongn ---- */
1156 typedef union
1157 {
1158  cl_ulong CL_ALIGNED(16) s[2];
1159 #if __CL_HAS_ANON_STRUCT__
1160  __CL_ANON_STRUCT__ struct{ cl_ulong x, y; };
1161  __CL_ANON_STRUCT__ struct{ cl_ulong s0, s1; };
1162  __CL_ANON_STRUCT__ struct{ cl_ulong lo, hi; };
1163 #endif
1164 #if defined( __CL_ULONG2__)
1165  __cl_ulong2 v2;
1166 #endif
1167 }cl_ulong2;
1168 
1169 typedef union
1170 {
1171  cl_ulong CL_ALIGNED(32) s[4];
1172 #if __CL_HAS_ANON_STRUCT__
1173  __CL_ANON_STRUCT__ struct{ cl_ulong x, y, z, w; };
1174  __CL_ANON_STRUCT__ struct{ cl_ulong s0, s1, s2, s3; };
1175  __CL_ANON_STRUCT__ struct{ cl_ulong2 lo, hi; };
1176 #endif
1177 #if defined( __CL_ULONG2__)
1178  __cl_ulong2 v2[2];
1179 #endif
1180 #if defined( __CL_ULONG4__)
1181  __cl_ulong4 v4;
1182 #endif
1183 }cl_ulong4;
1184 
1185 /* cl_ulong3 is identical in size, alignment and behavior to cl_ulong4. See section 6.1.5. */
1187 
1188 typedef union
1189 {
1190  cl_ulong CL_ALIGNED(64) s[8];
1191 #if __CL_HAS_ANON_STRUCT__
1192  __CL_ANON_STRUCT__ struct{ cl_ulong x, y, z, w; };
1193  __CL_ANON_STRUCT__ struct{ cl_ulong s0, s1, s2, s3, s4, s5, s6, s7; };
1194  __CL_ANON_STRUCT__ struct{ cl_ulong4 lo, hi; };
1195 #endif
1196 #if defined( __CL_ULONG2__)
1197  __cl_ulong2 v2[4];
1198 #endif
1199 #if defined( __CL_ULONG4__)
1200  __cl_ulong4 v4[2];
1201 #endif
1202 #if defined( __CL_ULONG8__ )
1203  __cl_ulong8 v8;
1204 #endif
1205 }cl_ulong8;
1206 
1207 typedef union
1208 {
1209  cl_ulong CL_ALIGNED(128) s[16];
1210 #if __CL_HAS_ANON_STRUCT__
1211  __CL_ANON_STRUCT__ struct{ cl_ulong x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; };
1212  __CL_ANON_STRUCT__ struct{ cl_ulong s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; };
1213  __CL_ANON_STRUCT__ struct{ cl_ulong8 lo, hi; };
1214 #endif
1215 #if defined( __CL_ULONG2__)
1216  __cl_ulong2 v2[8];
1217 #endif
1218 #if defined( __CL_ULONG4__)
1219  __cl_ulong4 v4[4];
1220 #endif
1221 #if defined( __CL_ULONG8__ )
1222  __cl_ulong8 v8[2];
1223 #endif
1224 #if defined( __CL_ULONG16__ )
1225  __cl_ulong16 v16;
1226 #endif
1227 }cl_ulong16;
1228 
1229 
1230 /* --- cl_floatn ---- */
1231 
1232 typedef union
1233 {
1234  cl_float CL_ALIGNED(8) s[2];
1235 #if __CL_HAS_ANON_STRUCT__
1236  __CL_ANON_STRUCT__ struct{ cl_float x, y; };
1237  __CL_ANON_STRUCT__ struct{ cl_float s0, s1; };
1238  __CL_ANON_STRUCT__ struct{ cl_float lo, hi; };
1239 #endif
1240 #if defined( __CL_FLOAT2__)
1241  __cl_float2 v2;
1242 #endif
1243 }cl_float2;
1244 
1245 typedef union
1246 {
1247  cl_float CL_ALIGNED(16) s[4];
1248 #if __CL_HAS_ANON_STRUCT__
1249  __CL_ANON_STRUCT__ struct{ cl_float x, y, z, w; };
1250  __CL_ANON_STRUCT__ struct{ cl_float s0, s1, s2, s3; };
1251  __CL_ANON_STRUCT__ struct{ cl_float2 lo, hi; };
1252 #endif
1253 #if defined( __CL_FLOAT2__)
1254  __cl_float2 v2[2];
1255 #endif
1256 #if defined( __CL_FLOAT4__)
1257  __cl_float4 v4;
1258 #endif
1259 }cl_float4;
1260 
1261 /* cl_float3 is identical in size, alignment and behavior to cl_float4. See section 6.1.5. */
1263 
1264 typedef union
1265 {
1266  cl_float CL_ALIGNED(32) s[8];
1267 #if __CL_HAS_ANON_STRUCT__
1268  __CL_ANON_STRUCT__ struct{ cl_float x, y, z, w; };
1269  __CL_ANON_STRUCT__ struct{ cl_float s0, s1, s2, s3, s4, s5, s6, s7; };
1270  __CL_ANON_STRUCT__ struct{ cl_float4 lo, hi; };
1271 #endif
1272 #if defined( __CL_FLOAT2__)
1273  __cl_float2 v2[4];
1274 #endif
1275 #if defined( __CL_FLOAT4__)
1276  __cl_float4 v4[2];
1277 #endif
1278 #if defined( __CL_FLOAT8__ )
1279  __cl_float8 v8;
1280 #endif
1281 }cl_float8;
1282 
1283 typedef union
1284 {
1285  cl_float CL_ALIGNED(64) s[16];
1286 #if __CL_HAS_ANON_STRUCT__
1287  __CL_ANON_STRUCT__ struct{ cl_float x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; };
1288  __CL_ANON_STRUCT__ struct{ cl_float s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; };
1289  __CL_ANON_STRUCT__ struct{ cl_float8 lo, hi; };
1290 #endif
1291 #if defined( __CL_FLOAT2__)
1292  __cl_float2 v2[8];
1293 #endif
1294 #if defined( __CL_FLOAT4__)
1295  __cl_float4 v4[4];
1296 #endif
1297 #if defined( __CL_FLOAT8__ )
1298  __cl_float8 v8[2];
1299 #endif
1300 #if defined( __CL_FLOAT16__ )
1301  __cl_float16 v16;
1302 #endif
1303 }cl_float16;
1304 
1305 /* --- cl_doublen ---- */
1306 
1307 typedef union
1308 {
1309  cl_double CL_ALIGNED(16) s[2];
1310 #if __CL_HAS_ANON_STRUCT__
1311  __CL_ANON_STRUCT__ struct{ cl_double x, y; };
1312  __CL_ANON_STRUCT__ struct{ cl_double s0, s1; };
1313  __CL_ANON_STRUCT__ struct{ cl_double lo, hi; };
1314 #endif
1315 #if defined( __CL_DOUBLE2__)
1316  __cl_double2 v2;
1317 #endif
1318 }cl_double2;
1319 
1320 typedef union
1321 {
1322  cl_double CL_ALIGNED(32) s[4];
1323 #if __CL_HAS_ANON_STRUCT__
1324  __CL_ANON_STRUCT__ struct{ cl_double x, y, z, w; };
1325  __CL_ANON_STRUCT__ struct{ cl_double s0, s1, s2, s3; };
1326  __CL_ANON_STRUCT__ struct{ cl_double2 lo, hi; };
1327 #endif
1328 #if defined( __CL_DOUBLE2__)
1329  __cl_double2 v2[2];
1330 #endif
1331 #if defined( __CL_DOUBLE4__)
1332  __cl_double4 v4;
1333 #endif
1334 }cl_double4;
1335 
1336 /* cl_double3 is identical in size, alignment and behavior to cl_double4. See section 6.1.5. */
1338 
1339 typedef union
1340 {
1341  cl_double CL_ALIGNED(64) s[8];
1342 #if __CL_HAS_ANON_STRUCT__
1343  __CL_ANON_STRUCT__ struct{ cl_double x, y, z, w; };
1344  __CL_ANON_STRUCT__ struct{ cl_double s0, s1, s2, s3, s4, s5, s6, s7; };
1345  __CL_ANON_STRUCT__ struct{ cl_double4 lo, hi; };
1346 #endif
1347 #if defined( __CL_DOUBLE2__)
1348  __cl_double2 v2[4];
1349 #endif
1350 #if defined( __CL_DOUBLE4__)
1351  __cl_double4 v4[2];
1352 #endif
1353 #if defined( __CL_DOUBLE8__ )
1354  __cl_double8 v8;
1355 #endif
1356 }cl_double8;
1357 
1358 typedef union
1359 {
1360  cl_double CL_ALIGNED(128) s[16];
1361 #if __CL_HAS_ANON_STRUCT__
1362  __CL_ANON_STRUCT__ struct{ cl_double x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; };
1363  __CL_ANON_STRUCT__ struct{ cl_double s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; };
1364  __CL_ANON_STRUCT__ struct{ cl_double8 lo, hi; };
1365 #endif
1366 #if defined( __CL_DOUBLE2__)
1367  __cl_double2 v2[8];
1368 #endif
1369 #if defined( __CL_DOUBLE4__)
1370  __cl_double4 v4[4];
1371 #endif
1372 #if defined( __CL_DOUBLE8__ )
1373  __cl_double8 v8[2];
1374 #endif
1375 #if defined( __CL_DOUBLE16__ )
1376  __cl_double16 v16;
1377 #endif
1378 }cl_double16;
1379 
1380 /* Macro to facilitate debugging
1381  * Usage:
1382  * Place CL_PROGRAM_STRING_DEBUG_INFO on the line before the first line of your source.
1383  * The first line ends with: CL_PROGRAM_STRING_DEBUG_INFO \"
1384  * Each line thereafter of OpenCL C source must end with: \n\
1385  * The last line ends in ";
1386  *
1387  * Example:
1388  *
1389  * const char *my_program = CL_PROGRAM_STRING_DEBUG_INFO "\
1390  * kernel void foo( int a, float * b ) \n\
1391  * { \n\
1392  * // my comment \n\
1393  * *b[ get_global_id(0)] = a; \n\
1394  * } \n\
1395  * ";
1396  *
1397  * This should correctly set up the line, (column) and file information for your source
1398  * string so you can do source level debugging.
1399  */
1400 #define __CL_STRINGIFY( _x ) # _x
1401 #define _CL_STRINGIFY( _x ) __CL_STRINGIFY( _x )
1402 #define CL_PROGRAM_STRING_DEBUG_INFO "#line " _CL_STRINGIFY(__LINE__) " \"" __FILE__ "\" \n\n"
1403 
1404 #ifdef __cplusplus
1405 }
1406 #endif
1407 
1408 #if defined(_WIN32) && defined(_MSC_VER) && __CL_HAS_ANON_STRUCT__
1409  #pragma warning( pop )
1410 #endif
1411 
1412 #endif /* __CL_PLATFORM_H */
uint32_t cl_uint
Definition: cl_platform.h:261
cl_half4 cl_half3
Definition: cl_platform.h:888
cl_double4 cl_double3
Definition: cl_platform.h:1337
uint16_t cl_ushort
Definition: cl_platform.h:259
cl_float4 cl_float3
Definition: cl_platform.h:1262
GLdouble GLdouble GLdouble z
Definition: glcorearb.h:848
uint16_t cl_half
Definition: cl_platform.h:265
GLdouble s
Definition: glad.h:3009
int32_t cl_int
Definition: cl_platform.h:260
uint8_t cl_uchar
Definition: cl_platform.h:257
#define __CL_ANON_STRUCT__
Definition: cl_platform.h:524
GLint y
Definition: glcorearb.h:103
GLfloat GLfloat GLfloat v2
Definition: glcorearb.h:818
unsigned int cl_GLenum
Definition: cl_platform.h:367
double cl_double
Definition: cl_platform.h:267
__attribute__((visibility("default")))
cl_ulong4 cl_ulong3
Definition: cl_platform.h:1186
unsigned int cl_GLuint
Definition: cl_platform.h:365
int8_t cl_char
Definition: cl_platform.h:256
cl_char4 cl_char3
Definition: cl_platform.h:588
int64_t cl_long
Definition: cl_platform.h:262
GLint GLenum GLint x
Definition: glcorearb.h:409
cl_int4 cl_int3
Definition: cl_platform.h:962
cl_long4 cl_long3
Definition: cl_platform.h:1111
float cl_float
Definition: cl_platform.h:266
cl_uint4 cl_uint3
Definition: cl_platform.h:1037
cl_uchar4 cl_uchar3
Definition: cl_platform.h:663
cl_short4 cl_short3
Definition: cl_platform.h:738
GLubyte GLubyte GLubyte GLubyte w
Definition: glcorearb.h:857
#define CL_ALIGNED(_x)
Definition: cl_platform.h:544
uint64_t cl_ulong
Definition: cl_platform.h:263
int16_t cl_short
Definition: cl_platform.h:258
int cl_GLint
Definition: cl_platform.h:366
cl_ushort4 cl_ushort3
Definition: cl_platform.h:813
float nanf(const char *)