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 #else 520 #define __CL_HAS_ANON_STRUCT__ 0 521 #define __CL_ANON_STRUCT__ 522 #endif 523 524 #if defined(_WIN32) && defined(_MSC_VER) && __CL_HAS_ANON_STRUCT__ 525 /* Disable warning C4201: nonstandard extension used : nameless struct/union */ 526 #pragma warning( push ) 527 #pragma warning( disable : 4201 ) 528 #endif 529 530 /* Define alignment keys */ 531 #if defined( __GNUC__ ) || defined(__INTEGRITY) 532 #define CL_ALIGNED(_x) __attribute__ ((aligned(_x))) 533 #elif defined( _WIN32) && (_MSC_VER) 534 /* Alignment keys neutered on windows because MSVC can't swallow function arguments with alignment requirements */ 535 /* http://msdn.microsoft.com/en-us/library/373ak2y1%28VS.71%29.aspx */ 536 /* #include <crtdefs.h> */ 537 /* #define CL_ALIGNED(_x) _CRT_ALIGN(_x) */ 538 #define CL_ALIGNED(_x) 539 #else 540 #warning Need to implement some method to align data here 541 #define CL_ALIGNED(_x) 542 #endif 543 544 /* Indicate whether .xyzw, .s0123 and .hi.lo are supported */ 545 #if __CL_HAS_ANON_STRUCT__ 546 /* .xyzw and .s0123...{f|F} are supported */ 547 #define CL_HAS_NAMED_VECTOR_FIELDS 1 548 /* .hi and .lo are supported */ 549 #define CL_HAS_HI_LO_VECTOR_FIELDS 1 550 #endif 551 552 /* Define cl_vector types */ 553 554 /* ---- cl_charn ---- */ 555 typedef union 556 { 557 cl_char CL_ALIGNED(2) s[2]; 558 #if __CL_HAS_ANON_STRUCT__ 559 __CL_ANON_STRUCT__ struct{ cl_char x, y; }; 560 __CL_ANON_STRUCT__ struct{ cl_char s0, s1; }; 561 __CL_ANON_STRUCT__ struct{ cl_char lo, hi; }; 562 #endif 563 #if defined( __CL_CHAR2__) 564 __cl_char2 v2; 565 #endif 566 }cl_char2; 567 568 typedef union 569 { 570 cl_char CL_ALIGNED(4) s[4]; 571 #if __CL_HAS_ANON_STRUCT__ 572 __CL_ANON_STRUCT__ struct{ cl_char x, y, z, w; }; 573 __CL_ANON_STRUCT__ struct{ cl_char s0, s1, s2, s3; }; 574 __CL_ANON_STRUCT__ struct{ cl_char2 lo, hi; }; 575 #endif 576 #if defined( __CL_CHAR2__) 577 __cl_char2 v2[2]; 578 #endif 579 #if defined( __CL_CHAR4__) 580 __cl_char4 v4; 581 #endif 582 }cl_char4; 583 584 /* cl_char3 is identical in size, alignment and behavior to cl_char4. See section 6.1.5. */ 585 typedef cl_char4 cl_char3; 586 587 typedef union 588 { 589 cl_char CL_ALIGNED(8) s[8]; 590 #if __CL_HAS_ANON_STRUCT__ 591 __CL_ANON_STRUCT__ struct{ cl_char x, y, z, w; }; 592 __CL_ANON_STRUCT__ struct{ cl_char s0, s1, s2, s3, s4, s5, s6, s7; }; 593 __CL_ANON_STRUCT__ struct{ cl_char4 lo, hi; }; 594 #endif 595 #if defined( __CL_CHAR2__) 596 __cl_char2 v2[4]; 597 #endif 598 #if defined( __CL_CHAR4__) 599 __cl_char4 v4[2]; 600 #endif 601 #if defined( __CL_CHAR8__ ) 602 __cl_char8 v8; 603 #endif 604 }cl_char8; 605 606 typedef union 607 { 608 cl_char CL_ALIGNED(16) s[16]; 609 #if __CL_HAS_ANON_STRUCT__ 610 __CL_ANON_STRUCT__ struct{ cl_char x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; 611 __CL_ANON_STRUCT__ struct{ cl_char s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; 612 __CL_ANON_STRUCT__ struct{ cl_char8 lo, hi; }; 613 #endif 614 #if defined( __CL_CHAR2__) 615 __cl_char2 v2[8]; 616 #endif 617 #if defined( __CL_CHAR4__) 618 __cl_char4 v4[4]; 619 #endif 620 #if defined( __CL_CHAR8__ ) 621 __cl_char8 v8[2]; 622 #endif 623 #if defined( __CL_CHAR16__ ) 624 __cl_char16 v16; 625 #endif 626 }cl_char16; 627 628 629 /* ---- cl_ucharn ---- */ 630 typedef union 631 { 632 cl_uchar CL_ALIGNED(2) s[2]; 633 #if __CL_HAS_ANON_STRUCT__ 634 __CL_ANON_STRUCT__ struct{ cl_uchar x, y; }; 635 __CL_ANON_STRUCT__ struct{ cl_uchar s0, s1; }; 636 __CL_ANON_STRUCT__ struct{ cl_uchar lo, hi; }; 637 #endif 638 #if defined( __cl_uchar2__) 639 __cl_uchar2 v2; 640 #endif 641 }cl_uchar2; 642 643 typedef union 644 { 645 cl_uchar CL_ALIGNED(4) s[4]; 646 #if __CL_HAS_ANON_STRUCT__ 647 __CL_ANON_STRUCT__ struct{ cl_uchar x, y, z, w; }; 648 __CL_ANON_STRUCT__ struct{ cl_uchar s0, s1, s2, s3; }; 649 __CL_ANON_STRUCT__ struct{ cl_uchar2 lo, hi; }; 650 #endif 651 #if defined( __CL_UCHAR2__) 652 __cl_uchar2 v2[2]; 653 #endif 654 #if defined( __CL_UCHAR4__) 655 __cl_uchar4 v4; 656 #endif 657 }cl_uchar4; 658 659 /* cl_uchar3 is identical in size, alignment and behavior to cl_uchar4. See section 6.1.5. */ 660 typedef cl_uchar4 cl_uchar3; 661 662 typedef union 663 { 664 cl_uchar CL_ALIGNED(8) s[8]; 665 #if __CL_HAS_ANON_STRUCT__ 666 __CL_ANON_STRUCT__ struct{ cl_uchar x, y, z, w; }; 667 __CL_ANON_STRUCT__ struct{ cl_uchar s0, s1, s2, s3, s4, s5, s6, s7; }; 668 __CL_ANON_STRUCT__ struct{ cl_uchar4 lo, hi; }; 669 #endif 670 #if defined( __CL_UCHAR2__) 671 __cl_uchar2 v2[4]; 672 #endif 673 #if defined( __CL_UCHAR4__) 674 __cl_uchar4 v4[2]; 675 #endif 676 #if defined( __CL_UCHAR8__ ) 677 __cl_uchar8 v8; 678 #endif 679 }cl_uchar8; 680 681 typedef union 682 { 683 cl_uchar CL_ALIGNED(16) s[16]; 684 #if __CL_HAS_ANON_STRUCT__ 685 __CL_ANON_STRUCT__ struct{ cl_uchar x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; 686 __CL_ANON_STRUCT__ struct{ cl_uchar s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; 687 __CL_ANON_STRUCT__ struct{ cl_uchar8 lo, hi; }; 688 #endif 689 #if defined( __CL_UCHAR2__) 690 __cl_uchar2 v2[8]; 691 #endif 692 #if defined( __CL_UCHAR4__) 693 __cl_uchar4 v4[4]; 694 #endif 695 #if defined( __CL_UCHAR8__ ) 696 __cl_uchar8 v8[2]; 697 #endif 698 #if defined( __CL_UCHAR16__ ) 699 __cl_uchar16 v16; 700 #endif 701 }cl_uchar16; 702 703 704 /* ---- cl_shortn ---- */ 705 typedef union 706 { 707 cl_short CL_ALIGNED(4) s[2]; 708 #if __CL_HAS_ANON_STRUCT__ 709 __CL_ANON_STRUCT__ struct{ cl_short x, y; }; 710 __CL_ANON_STRUCT__ struct{ cl_short s0, s1; }; 711 __CL_ANON_STRUCT__ struct{ cl_short lo, hi; }; 712 #endif 713 #if defined( __CL_SHORT2__) 714 __cl_short2 v2; 715 #endif 716 }cl_short2; 717 718 typedef union 719 { 720 cl_short CL_ALIGNED(8) s[4]; 721 #if __CL_HAS_ANON_STRUCT__ 722 __CL_ANON_STRUCT__ struct{ cl_short x, y, z, w; }; 723 __CL_ANON_STRUCT__ struct{ cl_short s0, s1, s2, s3; }; 724 __CL_ANON_STRUCT__ struct{ cl_short2 lo, hi; }; 725 #endif 726 #if defined( __CL_SHORT2__) 727 __cl_short2 v2[2]; 728 #endif 729 #if defined( __CL_SHORT4__) 730 __cl_short4 v4; 731 #endif 732 }cl_short4; 733 734 /* cl_short3 is identical in size, alignment and behavior to cl_short4. See section 6.1.5. */ 735 typedef cl_short4 cl_short3; 736 737 typedef union 738 { 739 cl_short CL_ALIGNED(16) s[8]; 740 #if __CL_HAS_ANON_STRUCT__ 741 __CL_ANON_STRUCT__ struct{ cl_short x, y, z, w; }; 742 __CL_ANON_STRUCT__ struct{ cl_short s0, s1, s2, s3, s4, s5, s6, s7; }; 743 __CL_ANON_STRUCT__ struct{ cl_short4 lo, hi; }; 744 #endif 745 #if defined( __CL_SHORT2__) 746 __cl_short2 v2[4]; 747 #endif 748 #if defined( __CL_SHORT4__) 749 __cl_short4 v4[2]; 750 #endif 751 #if defined( __CL_SHORT8__ ) 752 __cl_short8 v8; 753 #endif 754 }cl_short8; 755 756 typedef union 757 { 758 cl_short CL_ALIGNED(32) s[16]; 759 #if __CL_HAS_ANON_STRUCT__ 760 __CL_ANON_STRUCT__ struct{ cl_short x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; 761 __CL_ANON_STRUCT__ struct{ cl_short s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; 762 __CL_ANON_STRUCT__ struct{ cl_short8 lo, hi; }; 763 #endif 764 #if defined( __CL_SHORT2__) 765 __cl_short2 v2[8]; 766 #endif 767 #if defined( __CL_SHORT4__) 768 __cl_short4 v4[4]; 769 #endif 770 #if defined( __CL_SHORT8__ ) 771 __cl_short8 v8[2]; 772 #endif 773 #if defined( __CL_SHORT16__ ) 774 __cl_short16 v16; 775 #endif 776 }cl_short16; 777 778 779 /* ---- cl_ushortn ---- */ 780 typedef union 781 { 782 cl_ushort CL_ALIGNED(4) s[2]; 783 #if __CL_HAS_ANON_STRUCT__ 784 __CL_ANON_STRUCT__ struct{ cl_ushort x, y; }; 785 __CL_ANON_STRUCT__ struct{ cl_ushort s0, s1; }; 786 __CL_ANON_STRUCT__ struct{ cl_ushort lo, hi; }; 787 #endif 788 #if defined( __CL_USHORT2__) 789 __cl_ushort2 v2; 790 #endif 791 }cl_ushort2; 792 793 typedef union 794 { 795 cl_ushort CL_ALIGNED(8) s[4]; 796 #if __CL_HAS_ANON_STRUCT__ 797 __CL_ANON_STRUCT__ struct{ cl_ushort x, y, z, w; }; 798 __CL_ANON_STRUCT__ struct{ cl_ushort s0, s1, s2, s3; }; 799 __CL_ANON_STRUCT__ struct{ cl_ushort2 lo, hi; }; 800 #endif 801 #if defined( __CL_USHORT2__) 802 __cl_ushort2 v2[2]; 803 #endif 804 #if defined( __CL_USHORT4__) 805 __cl_ushort4 v4; 806 #endif 807 }cl_ushort4; 808 809 /* cl_ushort3 is identical in size, alignment and behavior to cl_ushort4. See section 6.1.5. */ 810 typedef cl_ushort4 cl_ushort3; 811 812 typedef union 813 { 814 cl_ushort CL_ALIGNED(16) s[8]; 815 #if __CL_HAS_ANON_STRUCT__ 816 __CL_ANON_STRUCT__ struct{ cl_ushort x, y, z, w; }; 817 __CL_ANON_STRUCT__ struct{ cl_ushort s0, s1, s2, s3, s4, s5, s6, s7; }; 818 __CL_ANON_STRUCT__ struct{ cl_ushort4 lo, hi; }; 819 #endif 820 #if defined( __CL_USHORT2__) 821 __cl_ushort2 v2[4]; 822 #endif 823 #if defined( __CL_USHORT4__) 824 __cl_ushort4 v4[2]; 825 #endif 826 #if defined( __CL_USHORT8__ ) 827 __cl_ushort8 v8; 828 #endif 829 }cl_ushort8; 830 831 typedef union 832 { 833 cl_ushort CL_ALIGNED(32) s[16]; 834 #if __CL_HAS_ANON_STRUCT__ 835 __CL_ANON_STRUCT__ struct{ cl_ushort x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; 836 __CL_ANON_STRUCT__ struct{ cl_ushort s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; 837 __CL_ANON_STRUCT__ struct{ cl_ushort8 lo, hi; }; 838 #endif 839 #if defined( __CL_USHORT2__) 840 __cl_ushort2 v2[8]; 841 #endif 842 #if defined( __CL_USHORT4__) 843 __cl_ushort4 v4[4]; 844 #endif 845 #if defined( __CL_USHORT8__ ) 846 __cl_ushort8 v8[2]; 847 #endif 848 #if defined( __CL_USHORT16__ ) 849 __cl_ushort16 v16; 850 #endif 851 }cl_ushort16; 852 853 854 /* ---- cl_halfn ---- */ 855 typedef union 856 { 857 cl_half CL_ALIGNED(4) s[2]; 858 #if __CL_HAS_ANON_STRUCT__ 859 __CL_ANON_STRUCT__ struct{ cl_half x, y; }; 860 __CL_ANON_STRUCT__ struct{ cl_half s0, s1; }; 861 __CL_ANON_STRUCT__ struct{ cl_half lo, hi; }; 862 #endif 863 #if defined( __CL_HALF2__) 864 __cl_half2 v2; 865 #endif 866 }cl_half2; 867 868 typedef union 869 { 870 cl_half CL_ALIGNED(8) s[4]; 871 #if __CL_HAS_ANON_STRUCT__ 872 __CL_ANON_STRUCT__ struct{ cl_half x, y, z, w; }; 873 __CL_ANON_STRUCT__ struct{ cl_half s0, s1, s2, s3; }; 874 __CL_ANON_STRUCT__ struct{ cl_half2 lo, hi; }; 875 #endif 876 #if defined( __CL_HALF2__) 877 __cl_half2 v2[2]; 878 #endif 879 #if defined( __CL_HALF4__) 880 __cl_half4 v4; 881 #endif 882 }cl_half4; 883 884 /* cl_half3 is identical in size, alignment and behavior to cl_half4. See section 6.1.5. */ 885 typedef cl_half4 cl_half3; 886 887 typedef union 888 { 889 cl_half CL_ALIGNED(16) s[8]; 890 #if __CL_HAS_ANON_STRUCT__ 891 __CL_ANON_STRUCT__ struct{ cl_half x, y, z, w; }; 892 __CL_ANON_STRUCT__ struct{ cl_half s0, s1, s2, s3, s4, s5, s6, s7; }; 893 __CL_ANON_STRUCT__ struct{ cl_half4 lo, hi; }; 894 #endif 895 #if defined( __CL_HALF2__) 896 __cl_half2 v2[4]; 897 #endif 898 #if defined( __CL_HALF4__) 899 __cl_half4 v4[2]; 900 #endif 901 #if defined( __CL_HALF8__ ) 902 __cl_half8 v8; 903 #endif 904 }cl_half8; 905 906 typedef union 907 { 908 cl_half CL_ALIGNED(32) s[16]; 909 #if __CL_HAS_ANON_STRUCT__ 910 __CL_ANON_STRUCT__ struct{ cl_half x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; 911 __CL_ANON_STRUCT__ struct{ cl_half s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; 912 __CL_ANON_STRUCT__ struct{ cl_half8 lo, hi; }; 913 #endif 914 #if defined( __CL_HALF2__) 915 __cl_half2 v2[8]; 916 #endif 917 #if defined( __CL_HALF4__) 918 __cl_half4 v4[4]; 919 #endif 920 #if defined( __CL_HALF8__ ) 921 __cl_half8 v8[2]; 922 #endif 923 #if defined( __CL_HALF16__ ) 924 __cl_half16 v16; 925 #endif 926 }cl_half16; 927 928 /* ---- cl_intn ---- */ 929 typedef union 930 { 931 cl_int CL_ALIGNED(8) s[2]; 932 #if __CL_HAS_ANON_STRUCT__ 933 __CL_ANON_STRUCT__ struct{ cl_int x, y; }; 934 __CL_ANON_STRUCT__ struct{ cl_int s0, s1; }; 935 __CL_ANON_STRUCT__ struct{ cl_int lo, hi; }; 936 #endif 937 #if defined( __CL_INT2__) 938 __cl_int2 v2; 939 #endif 940 }cl_int2; 941 942 typedef union 943 { 944 cl_int CL_ALIGNED(16) s[4]; 945 #if __CL_HAS_ANON_STRUCT__ 946 __CL_ANON_STRUCT__ struct{ cl_int x, y, z, w; }; 947 __CL_ANON_STRUCT__ struct{ cl_int s0, s1, s2, s3; }; 948 __CL_ANON_STRUCT__ struct{ cl_int2 lo, hi; }; 949 #endif 950 #if defined( __CL_INT2__) 951 __cl_int2 v2[2]; 952 #endif 953 #if defined( __CL_INT4__) 954 __cl_int4 v4; 955 #endif 956 }cl_int4; 957 958 /* cl_int3 is identical in size, alignment and behavior to cl_int4. See section 6.1.5. */ 959 typedef cl_int4 cl_int3; 960 961 typedef union 962 { 963 cl_int CL_ALIGNED(32) s[8]; 964 #if __CL_HAS_ANON_STRUCT__ 965 __CL_ANON_STRUCT__ struct{ cl_int x, y, z, w; }; 966 __CL_ANON_STRUCT__ struct{ cl_int s0, s1, s2, s3, s4, s5, s6, s7; }; 967 __CL_ANON_STRUCT__ struct{ cl_int4 lo, hi; }; 968 #endif 969 #if defined( __CL_INT2__) 970 __cl_int2 v2[4]; 971 #endif 972 #if defined( __CL_INT4__) 973 __cl_int4 v4[2]; 974 #endif 975 #if defined( __CL_INT8__ ) 976 __cl_int8 v8; 977 #endif 978 }cl_int8; 979 980 typedef union 981 { 982 cl_int CL_ALIGNED(64) s[16]; 983 #if __CL_HAS_ANON_STRUCT__ 984 __CL_ANON_STRUCT__ struct{ cl_int x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; 985 __CL_ANON_STRUCT__ struct{ cl_int s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; 986 __CL_ANON_STRUCT__ struct{ cl_int8 lo, hi; }; 987 #endif 988 #if defined( __CL_INT2__) 989 __cl_int2 v2[8]; 990 #endif 991 #if defined( __CL_INT4__) 992 __cl_int4 v4[4]; 993 #endif 994 #if defined( __CL_INT8__ ) 995 __cl_int8 v8[2]; 996 #endif 997 #if defined( __CL_INT16__ ) 998 __cl_int16 v16; 999 #endif 1000 }cl_int16; 1001 1002 1003 /* ---- cl_uintn ---- */ 1004 typedef union 1005 { 1006 cl_uint CL_ALIGNED(8) s[2]; 1007 #if __CL_HAS_ANON_STRUCT__ 1008 __CL_ANON_STRUCT__ struct{ cl_uint x, y; }; 1009 __CL_ANON_STRUCT__ struct{ cl_uint s0, s1; }; 1010 __CL_ANON_STRUCT__ struct{ cl_uint lo, hi; }; 1011 #endif 1012 #if defined( __CL_UINT2__) 1013 __cl_uint2 v2; 1014 #endif 1015 }cl_uint2; 1016 1017 typedef union 1018 { 1019 cl_uint CL_ALIGNED(16) s[4]; 1020 #if __CL_HAS_ANON_STRUCT__ 1021 __CL_ANON_STRUCT__ struct{ cl_uint x, y, z, w; }; 1022 __CL_ANON_STRUCT__ struct{ cl_uint s0, s1, s2, s3; }; 1023 __CL_ANON_STRUCT__ struct{ cl_uint2 lo, hi; }; 1024 #endif 1025 #if defined( __CL_UINT2__) 1026 __cl_uint2 v2[2]; 1027 #endif 1028 #if defined( __CL_UINT4__) 1029 __cl_uint4 v4; 1030 #endif 1031 }cl_uint4; 1032 1033 /* cl_uint3 is identical in size, alignment and behavior to cl_uint4. See section 6.1.5. */ 1034 typedef cl_uint4 cl_uint3; 1035 1036 typedef union 1037 { 1038 cl_uint CL_ALIGNED(32) s[8]; 1039 #if __CL_HAS_ANON_STRUCT__ 1040 __CL_ANON_STRUCT__ struct{ cl_uint x, y, z, w; }; 1041 __CL_ANON_STRUCT__ struct{ cl_uint s0, s1, s2, s3, s4, s5, s6, s7; }; 1042 __CL_ANON_STRUCT__ struct{ cl_uint4 lo, hi; }; 1043 #endif 1044 #if defined( __CL_UINT2__) 1045 __cl_uint2 v2[4]; 1046 #endif 1047 #if defined( __CL_UINT4__) 1048 __cl_uint4 v4[2]; 1049 #endif 1050 #if defined( __CL_UINT8__ ) 1051 __cl_uint8 v8; 1052 #endif 1053 }cl_uint8; 1054 1055 typedef union 1056 { 1057 cl_uint CL_ALIGNED(64) s[16]; 1058 #if __CL_HAS_ANON_STRUCT__ 1059 __CL_ANON_STRUCT__ struct{ cl_uint x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; 1060 __CL_ANON_STRUCT__ struct{ cl_uint s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; 1061 __CL_ANON_STRUCT__ struct{ cl_uint8 lo, hi; }; 1062 #endif 1063 #if defined( __CL_UINT2__) 1064 __cl_uint2 v2[8]; 1065 #endif 1066 #if defined( __CL_UINT4__) 1067 __cl_uint4 v4[4]; 1068 #endif 1069 #if defined( __CL_UINT8__ ) 1070 __cl_uint8 v8[2]; 1071 #endif 1072 #if defined( __CL_UINT16__ ) 1073 __cl_uint16 v16; 1074 #endif 1075 }cl_uint16; 1076 1077 /* ---- cl_longn ---- */ 1078 typedef union 1079 { 1080 cl_long CL_ALIGNED(16) s[2]; 1081 #if __CL_HAS_ANON_STRUCT__ 1082 __CL_ANON_STRUCT__ struct{ cl_long x, y; }; 1083 __CL_ANON_STRUCT__ struct{ cl_long s0, s1; }; 1084 __CL_ANON_STRUCT__ struct{ cl_long lo, hi; }; 1085 #endif 1086 #if defined( __CL_LONG2__) 1087 __cl_long2 v2; 1088 #endif 1089 }cl_long2; 1090 1091 typedef union 1092 { 1093 cl_long CL_ALIGNED(32) s[4]; 1094 #if __CL_HAS_ANON_STRUCT__ 1095 __CL_ANON_STRUCT__ struct{ cl_long x, y, z, w; }; 1096 __CL_ANON_STRUCT__ struct{ cl_long s0, s1, s2, s3; }; 1097 __CL_ANON_STRUCT__ struct{ cl_long2 lo, hi; }; 1098 #endif 1099 #if defined( __CL_LONG2__) 1100 __cl_long2 v2[2]; 1101 #endif 1102 #if defined( __CL_LONG4__) 1103 __cl_long4 v4; 1104 #endif 1105 }cl_long4; 1106 1107 /* cl_long3 is identical in size, alignment and behavior to cl_long4. See section 6.1.5. */ 1108 typedef cl_long4 cl_long3; 1109 1110 typedef union 1111 { 1112 cl_long CL_ALIGNED(64) s[8]; 1113 #if __CL_HAS_ANON_STRUCT__ 1114 __CL_ANON_STRUCT__ struct{ cl_long x, y, z, w; }; 1115 __CL_ANON_STRUCT__ struct{ cl_long s0, s1, s2, s3, s4, s5, s6, s7; }; 1116 __CL_ANON_STRUCT__ struct{ cl_long4 lo, hi; }; 1117 #endif 1118 #if defined( __CL_LONG2__) 1119 __cl_long2 v2[4]; 1120 #endif 1121 #if defined( __CL_LONG4__) 1122 __cl_long4 v4[2]; 1123 #endif 1124 #if defined( __CL_LONG8__ ) 1125 __cl_long8 v8; 1126 #endif 1127 }cl_long8; 1128 1129 typedef union 1130 { 1131 cl_long CL_ALIGNED(128) s[16]; 1132 #if __CL_HAS_ANON_STRUCT__ 1133 __CL_ANON_STRUCT__ struct{ cl_long x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; 1134 __CL_ANON_STRUCT__ struct{ cl_long s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; 1135 __CL_ANON_STRUCT__ struct{ cl_long8 lo, hi; }; 1136 #endif 1137 #if defined( __CL_LONG2__) 1138 __cl_long2 v2[8]; 1139 #endif 1140 #if defined( __CL_LONG4__) 1141 __cl_long4 v4[4]; 1142 #endif 1143 #if defined( __CL_LONG8__ ) 1144 __cl_long8 v8[2]; 1145 #endif 1146 #if defined( __CL_LONG16__ ) 1147 __cl_long16 v16; 1148 #endif 1149 }cl_long16; 1150 1151 1152 /* ---- cl_ulongn ---- */ 1153 typedef union 1154 { 1155 cl_ulong CL_ALIGNED(16) s[2]; 1156 #if __CL_HAS_ANON_STRUCT__ 1157 __CL_ANON_STRUCT__ struct{ cl_ulong x, y; }; 1158 __CL_ANON_STRUCT__ struct{ cl_ulong s0, s1; }; 1159 __CL_ANON_STRUCT__ struct{ cl_ulong lo, hi; }; 1160 #endif 1161 #if defined( __CL_ULONG2__) 1162 __cl_ulong2 v2; 1163 #endif 1164 }cl_ulong2; 1165 1166 typedef union 1167 { 1168 cl_ulong CL_ALIGNED(32) s[4]; 1169 #if __CL_HAS_ANON_STRUCT__ 1170 __CL_ANON_STRUCT__ struct{ cl_ulong x, y, z, w; }; 1171 __CL_ANON_STRUCT__ struct{ cl_ulong s0, s1, s2, s3; }; 1172 __CL_ANON_STRUCT__ struct{ cl_ulong2 lo, hi; }; 1173 #endif 1174 #if defined( __CL_ULONG2__) 1175 __cl_ulong2 v2[2]; 1176 #endif 1177 #if defined( __CL_ULONG4__) 1178 __cl_ulong4 v4; 1179 #endif 1180 }cl_ulong4; 1181 1182 /* cl_ulong3 is identical in size, alignment and behavior to cl_ulong4. See section 6.1.5. */ 1183 typedef cl_ulong4 cl_ulong3; 1184 1185 typedef union 1186 { 1187 cl_ulong CL_ALIGNED(64) s[8]; 1188 #if __CL_HAS_ANON_STRUCT__ 1189 __CL_ANON_STRUCT__ struct{ cl_ulong x, y, z, w; }; 1190 __CL_ANON_STRUCT__ struct{ cl_ulong s0, s1, s2, s3, s4, s5, s6, s7; }; 1191 __CL_ANON_STRUCT__ struct{ cl_ulong4 lo, hi; }; 1192 #endif 1193 #if defined( __CL_ULONG2__) 1194 __cl_ulong2 v2[4]; 1195 #endif 1196 #if defined( __CL_ULONG4__) 1197 __cl_ulong4 v4[2]; 1198 #endif 1199 #if defined( __CL_ULONG8__ ) 1200 __cl_ulong8 v8; 1201 #endif 1202 }cl_ulong8; 1203 1204 typedef union 1205 { 1206 cl_ulong CL_ALIGNED(128) s[16]; 1207 #if __CL_HAS_ANON_STRUCT__ 1208 __CL_ANON_STRUCT__ struct{ cl_ulong x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; 1209 __CL_ANON_STRUCT__ struct{ cl_ulong s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; 1210 __CL_ANON_STRUCT__ struct{ cl_ulong8 lo, hi; }; 1211 #endif 1212 #if defined( __CL_ULONG2__) 1213 __cl_ulong2 v2[8]; 1214 #endif 1215 #if defined( __CL_ULONG4__) 1216 __cl_ulong4 v4[4]; 1217 #endif 1218 #if defined( __CL_ULONG8__ ) 1219 __cl_ulong8 v8[2]; 1220 #endif 1221 #if defined( __CL_ULONG16__ ) 1222 __cl_ulong16 v16; 1223 #endif 1224 }cl_ulong16; 1225 1226 1227 /* --- cl_floatn ---- */ 1228 1229 typedef union 1230 { 1231 cl_float CL_ALIGNED(8) s[2]; 1232 #if __CL_HAS_ANON_STRUCT__ 1233 __CL_ANON_STRUCT__ struct{ cl_float x, y; }; 1234 __CL_ANON_STRUCT__ struct{ cl_float s0, s1; }; 1235 __CL_ANON_STRUCT__ struct{ cl_float lo, hi; }; 1236 #endif 1237 #if defined( __CL_FLOAT2__) 1238 __cl_float2 v2; 1239 #endif 1240 }cl_float2; 1241 1242 typedef union 1243 { 1244 cl_float CL_ALIGNED(16) s[4]; 1245 #if __CL_HAS_ANON_STRUCT__ 1246 __CL_ANON_STRUCT__ struct{ cl_float x, y, z, w; }; 1247 __CL_ANON_STRUCT__ struct{ cl_float s0, s1, s2, s3; }; 1248 __CL_ANON_STRUCT__ struct{ cl_float2 lo, hi; }; 1249 #endif 1250 #if defined( __CL_FLOAT2__) 1251 __cl_float2 v2[2]; 1252 #endif 1253 #if defined( __CL_FLOAT4__) 1254 __cl_float4 v4; 1255 #endif 1256 }cl_float4; 1257 1258 /* cl_float3 is identical in size, alignment and behavior to cl_float4. See section 6.1.5. */ 1259 typedef cl_float4 cl_float3; 1260 1261 typedef union 1262 { 1263 cl_float CL_ALIGNED(32) s[8]; 1264 #if __CL_HAS_ANON_STRUCT__ 1265 __CL_ANON_STRUCT__ struct{ cl_float x, y, z, w; }; 1266 __CL_ANON_STRUCT__ struct{ cl_float s0, s1, s2, s3, s4, s5, s6, s7; }; 1267 __CL_ANON_STRUCT__ struct{ cl_float4 lo, hi; }; 1268 #endif 1269 #if defined( __CL_FLOAT2__) 1270 __cl_float2 v2[4]; 1271 #endif 1272 #if defined( __CL_FLOAT4__) 1273 __cl_float4 v4[2]; 1274 #endif 1275 #if defined( __CL_FLOAT8__ ) 1276 __cl_float8 v8; 1277 #endif 1278 }cl_float8; 1279 1280 typedef union 1281 { 1282 cl_float CL_ALIGNED(64) s[16]; 1283 #if __CL_HAS_ANON_STRUCT__ 1284 __CL_ANON_STRUCT__ struct{ cl_float x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; 1285 __CL_ANON_STRUCT__ struct{ cl_float s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; 1286 __CL_ANON_STRUCT__ struct{ cl_float8 lo, hi; }; 1287 #endif 1288 #if defined( __CL_FLOAT2__) 1289 __cl_float2 v2[8]; 1290 #endif 1291 #if defined( __CL_FLOAT4__) 1292 __cl_float4 v4[4]; 1293 #endif 1294 #if defined( __CL_FLOAT8__ ) 1295 __cl_float8 v8[2]; 1296 #endif 1297 #if defined( __CL_FLOAT16__ ) 1298 __cl_float16 v16; 1299 #endif 1300 }cl_float16; 1301 1302 /* --- cl_doublen ---- */ 1303 1304 typedef union 1305 { 1306 cl_double CL_ALIGNED(16) s[2]; 1307 #if __CL_HAS_ANON_STRUCT__ 1308 __CL_ANON_STRUCT__ struct{ cl_double x, y; }; 1309 __CL_ANON_STRUCT__ struct{ cl_double s0, s1; }; 1310 __CL_ANON_STRUCT__ struct{ cl_double lo, hi; }; 1311 #endif 1312 #if defined( __CL_DOUBLE2__) 1313 __cl_double2 v2; 1314 #endif 1315 }cl_double2; 1316 1317 typedef union 1318 { 1319 cl_double CL_ALIGNED(32) s[4]; 1320 #if __CL_HAS_ANON_STRUCT__ 1321 __CL_ANON_STRUCT__ struct{ cl_double x, y, z, w; }; 1322 __CL_ANON_STRUCT__ struct{ cl_double s0, s1, s2, s3; }; 1323 __CL_ANON_STRUCT__ struct{ cl_double2 lo, hi; }; 1324 #endif 1325 #if defined( __CL_DOUBLE2__) 1326 __cl_double2 v2[2]; 1327 #endif 1328 #if defined( __CL_DOUBLE4__) 1329 __cl_double4 v4; 1330 #endif 1331 }cl_double4; 1332 1333 /* cl_double3 is identical in size, alignment and behavior to cl_double4. See section 6.1.5. */ 1334 typedef cl_double4 cl_double3; 1335 1336 typedef union 1337 { 1338 cl_double CL_ALIGNED(64) s[8]; 1339 #if __CL_HAS_ANON_STRUCT__ 1340 __CL_ANON_STRUCT__ struct{ cl_double x, y, z, w; }; 1341 __CL_ANON_STRUCT__ struct{ cl_double s0, s1, s2, s3, s4, s5, s6, s7; }; 1342 __CL_ANON_STRUCT__ struct{ cl_double4 lo, hi; }; 1343 #endif 1344 #if defined( __CL_DOUBLE2__) 1345 __cl_double2 v2[4]; 1346 #endif 1347 #if defined( __CL_DOUBLE4__) 1348 __cl_double4 v4[2]; 1349 #endif 1350 #if defined( __CL_DOUBLE8__ ) 1351 __cl_double8 v8; 1352 #endif 1353 }cl_double8; 1354 1355 typedef union 1356 { 1357 cl_double CL_ALIGNED(128) s[16]; 1358 #if __CL_HAS_ANON_STRUCT__ 1359 __CL_ANON_STRUCT__ struct{ cl_double x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; 1360 __CL_ANON_STRUCT__ struct{ cl_double s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; 1361 __CL_ANON_STRUCT__ struct{ cl_double8 lo, hi; }; 1362 #endif 1363 #if defined( __CL_DOUBLE2__) 1364 __cl_double2 v2[8]; 1365 #endif 1366 #if defined( __CL_DOUBLE4__) 1367 __cl_double4 v4[4]; 1368 #endif 1369 #if defined( __CL_DOUBLE8__ ) 1370 __cl_double8 v8[2]; 1371 #endif 1372 #if defined( __CL_DOUBLE16__ ) 1373 __cl_double16 v16; 1374 #endif 1375 }cl_double16; 1376 1377 /* Macro to facilitate debugging 1378 * Usage: 1379 * Place CL_PROGRAM_STRING_DEBUG_INFO on the line before the first line of your source. 1380 * The first line ends with: CL_PROGRAM_STRING_DEBUG_INFO \" 1381 * Each line thereafter of OpenCL C source must end with: \n\ 1382 * The last line ends in "; 1383 * 1384 * Example: 1385 * 1386 * const char *my_program = CL_PROGRAM_STRING_DEBUG_INFO "\ 1387 * kernel void foo( int a, float * b ) \n\ 1388 * { \n\ 1389 * // my comment \n\ 1390 * *b[ get_global_id(0)] = a; \n\ 1391 * } \n\ 1392 * "; 1393 * 1394 * This should correctly set up the line, (column) and file information for your source 1395 * string so you can do source level debugging. 1396 */ 1397 #define __CL_STRINGIFY( _x ) # _x 1398 #define _CL_STRINGIFY( _x ) __CL_STRINGIFY( _x ) 1399 #define CL_PROGRAM_STRING_DEBUG_INFO "#line " _CL_STRINGIFY(__LINE__) " \"" __FILE__ "\" \n\n" 1400 1401 #ifdef __cplusplus 1402 } 1403 #endif 1404 1405 #if defined(_WIN32) && defined(_MSC_VER) && __CL_HAS_ANON_STRUCT__ 1406 #pragma warning( pop ) 1407 #endif 1408 1409 #endif /* __CL_PLATFORM_H */ 1410