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