1 /********************************************************************************** 2 * Copyright (c) 2008-2012 The Khronos Group Inc. 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining a 5 * copy of this software and/or associated documentation files (the 6 * "Materials"), to deal in the Materials without restriction, including 7 * without limitation the rights to use, copy, modify, merge, publish, 8 * distribute, sublicense, and/or sell copies of the Materials, and to 9 * permit persons to whom the Materials are furnished to do so, subject to 10 * the following conditions: 11 * 12 * The above copyright notice and this permission notice shall be included 13 * in all copies or substantial portions of the Materials. 14 * 15 * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 16 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 17 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 18 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY 19 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 20 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 21 * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. 22 **********************************************************************************/ 23 24 /* $Revision: 11803 $ on $Date: 2010-06-25 10:02:12 -0700 (Fri, 25 Jun 2010) $ */ 25 26 #ifndef __CL_PLATFORM_H 27 #define __CL_PLATFORM_H 28 29 #ifdef __APPLE__ 30 /* Contains #defines for AVAILABLE_MAC_OS_X_VERSION_10_6_AND_LATER below */ 31 #include <AvailabilityMacros.h> 32 #endif 33 34 #ifdef __cplusplus 35 extern "C" { 36 #endif 37 38 #if defined(_WIN32) 39 #define CL_API_ENTRY 40 #define CL_API_CALL __stdcall 41 #define CL_CALLBACK __stdcall 42 #else 43 #define CL_API_ENTRY 44 #define CL_API_CALL 45 #define CL_CALLBACK 46 #endif 47 48 #ifdef __APPLE__ 49 #define CL_EXTENSION_WEAK_LINK __attribute__((weak_import)) 50 #define CL_API_SUFFIX__VERSION_1_0 AVAILABLE_MAC_OS_X_VERSION_10_6_AND_LATER 51 #define CL_EXT_SUFFIX__VERSION_1_0 CL_EXTENSION_WEAK_LINK AVAILABLE_MAC_OS_X_VERSION_10_6_AND_LATER 52 #define CL_API_SUFFIX__VERSION_1_1 AVAILABLE_MAC_OS_X_VERSION_10_7_AND_LATER 53 #define GCL_API_SUFFIX__VERSION_1_1 AVAILABLE_MAC_OS_X_VERSION_10_7_AND_LATER 54 #define CL_EXT_SUFFIX__VERSION_1_1 CL_EXTENSION_WEAK_LINK AVAILABLE_MAC_OS_X_VERSION_10_7_AND_LATER 55 #define CL_EXT_SUFFIX__VERSION_1_0_DEPRECATED CL_EXTENSION_WEAK_LINK AVAILABLE_MAC_OS_X_VERSION_10_6_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_7 56 57 #ifdef AVAILABLE_MAC_OS_X_VERSION_10_8_AND_LATER 58 #define CL_API_SUFFIX__VERSION_1_2 AVAILABLE_MAC_OS_X_VERSION_10_8_AND_LATER 59 #define GCL_API_SUFFIX__VERSION_1_2 AVAILABLE_MAC_OS_X_VERSION_10_8_AND_LATER 60 #define CL_EXT_SUFFIX__VERSION_1_2 CL_EXTENSION_WEAK_LINK AVAILABLE_MAC_OS_X_VERSION_10_8_AND_LATER 61 #define CL_EXT_PREFIX__VERSION_1_1_DEPRECATED 62 #define CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED CL_EXTENSION_WEAK_LINK AVAILABLE_MAC_OS_X_VERSION_10_7_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_8 63 #else 64 #warning This path should never happen outside of internal operating system development. AvailabilityMacros do not function correctly here! 65 #define CL_API_SUFFIX__VERSION_1_2 AVAILABLE_MAC_OS_X_VERSION_10_7_AND_LATER 66 #define GCL_API_SUFFIX__VERSION_1_2 AVAILABLE_MAC_OS_X_VERSION_10_7_AND_LATER 67 #define CL_EXT_SUFFIX__VERSION_1_2 CL_EXTENSION_WEAK_LINK AVAILABLE_MAC_OS_X_VERSION_10_7_AND_LATER 68 #define CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED CL_EXTENSION_WEAK_LINK AVAILABLE_MAC_OS_X_VERSION_10_7_AND_LATER 69 #endif 70 #else 71 #define CL_EXTENSION_WEAK_LINK 72 #define CL_API_SUFFIX__VERSION_1_0 73 #define CL_EXT_SUFFIX__VERSION_1_0 74 #define CL_API_SUFFIX__VERSION_1_1 75 #define CL_EXT_SUFFIX__VERSION_1_1 76 #define CL_API_SUFFIX__VERSION_1_2 77 #define CL_EXT_SUFFIX__VERSION_1_2 78 79 #ifdef __GNUC__ 80 #ifdef CL_USE_DEPRECATED_OPENCL_1_0_APIS 81 #define CL_EXT_SUFFIX__VERSION_1_0_DEPRECATED 82 #define CL_EXT_PREFIX__VERSION_1_0_DEPRECATED 83 #else 84 #define CL_EXT_SUFFIX__VERSION_1_0_DEPRECATED __attribute__((deprecated)) 85 #define CL_EXT_PREFIX__VERSION_1_0_DEPRECATED 86 #endif 87 88 #ifdef CL_USE_DEPRECATED_OPENCL_1_1_APIS 89 #define CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED 90 #define CL_EXT_PREFIX__VERSION_1_1_DEPRECATED 91 #else 92 #define CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED __attribute__((deprecated)) 93 #define CL_EXT_PREFIX__VERSION_1_1_DEPRECATED 94 #endif 95 #elif _WIN32 96 #ifdef CL_USE_DEPRECATED_OPENCL_1_0_APIS 97 #define CL_EXT_SUFFIX__VERSION_1_0_DEPRECATED 98 #define CL_EXT_PREFIX__VERSION_1_0_DEPRECATED 99 #else 100 #define CL_EXT_SUFFIX__VERSION_1_0_DEPRECATED 101 #define CL_EXT_PREFIX__VERSION_1_0_DEPRECATED __declspec(deprecated) 102 #endif 103 104 #ifdef CL_USE_DEPRECATED_OPENCL_1_1_APIS 105 #define CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED 106 #define CL_EXT_PREFIX__VERSION_1_1_DEPRECATED 107 #else 108 #define CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED 109 #define CL_EXT_PREFIX__VERSION_1_1_DEPRECATED __declspec(deprecated) 110 #endif 111 #else 112 #define CL_EXT_SUFFIX__VERSION_1_0_DEPRECATED 113 #define CL_EXT_PREFIX__VERSION_1_0_DEPRECATED 114 115 #define CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED 116 #define CL_EXT_PREFIX__VERSION_1_1_DEPRECATED 117 #endif 118 #endif 119 120 #if (defined (_WIN32) && defined(_MSC_VER)) 121 122 /* scalar types */ 123 typedef signed __int8 cl_char; 124 typedef unsigned __int8 cl_uchar; 125 typedef signed __int16 cl_short; 126 typedef unsigned __int16 cl_ushort; 127 typedef signed __int32 cl_int; 128 typedef unsigned __int32 cl_uint; 129 typedef signed __int64 cl_long; 130 typedef unsigned __int64 cl_ulong; 131 132 typedef unsigned __int16 cl_half; 133 typedef float cl_float; 134 typedef double cl_double; 135 136 /* Macro names and corresponding values defined by OpenCL */ 137 #define CL_CHAR_BIT 8 138 #define CL_SCHAR_MAX 127 139 #define CL_SCHAR_MIN (-127-1) 140 #define CL_CHAR_MAX CL_SCHAR_MAX 141 #define CL_CHAR_MIN CL_SCHAR_MIN 142 #define CL_UCHAR_MAX 255 143 #define CL_SHRT_MAX 32767 144 #define CL_SHRT_MIN (-32767-1) 145 #define CL_USHRT_MAX 65535 146 #define CL_INT_MAX 2147483647 147 #define CL_INT_MIN (-2147483647-1) 148 #define CL_UINT_MAX 0xffffffffU 149 #define CL_LONG_MAX ((cl_long) 0x7FFFFFFFFFFFFFFFLL) 150 #define CL_LONG_MIN ((cl_long) -0x7FFFFFFFFFFFFFFFLL - 1LL) 151 #define CL_ULONG_MAX ((cl_ulong) 0xFFFFFFFFFFFFFFFFULL) 152 153 #define CL_FLT_DIG 6 154 #define CL_FLT_MANT_DIG 24 155 #define CL_FLT_MAX_10_EXP +38 156 #define CL_FLT_MAX_EXP +128 157 #define CL_FLT_MIN_10_EXP -37 158 #define CL_FLT_MIN_EXP -125 159 #define CL_FLT_RADIX 2 160 #define CL_FLT_MAX 340282346638528859811704183484516925440.0f 161 #define CL_FLT_MIN 1.175494350822287507969e-38f 162 #define CL_FLT_EPSILON 0x1.0p-23f 163 164 #define CL_DBL_DIG 15 165 #define CL_DBL_MANT_DIG 53 166 #define CL_DBL_MAX_10_EXP +308 167 #define CL_DBL_MAX_EXP +1024 168 #define CL_DBL_MIN_10_EXP -307 169 #define CL_DBL_MIN_EXP -1021 170 #define CL_DBL_RADIX 2 171 #define CL_DBL_MAX 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.0 172 #define CL_DBL_MIN 2.225073858507201383090e-308 173 #define CL_DBL_EPSILON 2.220446049250313080847e-16 174 175 #define CL_M_E 2.718281828459045090796 176 #define CL_M_LOG2E 1.442695040888963387005 177 #define CL_M_LOG10E 0.434294481903251816668 178 #define CL_M_LN2 0.693147180559945286227 179 #define CL_M_LN10 2.302585092994045901094 180 #define CL_M_PI 3.141592653589793115998 181 #define CL_M_PI_2 1.570796326794896557999 182 #define CL_M_PI_4 0.785398163397448278999 183 #define CL_M_1_PI 0.318309886183790691216 184 #define CL_M_2_PI 0.636619772367581382433 185 #define CL_M_2_SQRTPI 1.128379167095512558561 186 #define CL_M_SQRT2 1.414213562373095145475 187 #define CL_M_SQRT1_2 0.707106781186547572737 188 189 #define CL_M_E_F 2.71828174591064f 190 #define CL_M_LOG2E_F 1.44269502162933f 191 #define CL_M_LOG10E_F 0.43429449200630f 192 #define CL_M_LN2_F 0.69314718246460f 193 #define CL_M_LN10_F 2.30258512496948f 194 #define CL_M_PI_F 3.14159274101257f 195 #define CL_M_PI_2_F 1.57079637050629f 196 #define CL_M_PI_4_F 0.78539818525314f 197 #define CL_M_1_PI_F 0.31830987334251f 198 #define CL_M_2_PI_F 0.63661974668503f 199 #define CL_M_2_SQRTPI_F 1.12837922573090f 200 #define CL_M_SQRT2_F 1.41421353816986f 201 #define CL_M_SQRT1_2_F 0.70710676908493f 202 203 #define CL_NAN (CL_INFINITY - CL_INFINITY) 204 #define CL_HUGE_VALF ((cl_float) 1e50) 205 #define CL_HUGE_VAL ((cl_double) 1e500) 206 #define CL_MAXFLOAT CL_FLT_MAX 207 #define CL_INFINITY CL_HUGE_VALF 208 209 #else 210 211 #include <stdint.h> 212 213 /* scalar types */ 214 typedef int8_t cl_char; 215 typedef uint8_t cl_uchar; 216 typedef int16_t cl_short __attribute__((aligned(2))); 217 typedef uint16_t cl_ushort __attribute__((aligned(2))); 218 typedef int32_t cl_int __attribute__((aligned(4))); 219 typedef uint32_t cl_uint __attribute__((aligned(4))); 220 typedef int64_t cl_long __attribute__((aligned(8))); 221 typedef uint64_t cl_ulong __attribute__((aligned(8))); 222 223 typedef uint16_t cl_half __attribute__((aligned(2))); 224 typedef float cl_float __attribute__((aligned(4))); 225 typedef double cl_double __attribute__((aligned(8))); 226 227 /* Macro names and corresponding values defined by OpenCL */ 228 #define CL_CHAR_BIT 8 229 #define CL_SCHAR_MAX 127 230 #define CL_SCHAR_MIN (-127-1) 231 #define CL_CHAR_MAX CL_SCHAR_MAX 232 #define CL_CHAR_MIN CL_SCHAR_MIN 233 #define CL_UCHAR_MAX 255 234 #define CL_SHRT_MAX 32767 235 #define CL_SHRT_MIN (-32767-1) 236 #define CL_USHRT_MAX 65535 237 #define CL_INT_MAX 2147483647 238 #define CL_INT_MIN (-2147483647-1) 239 #define CL_UINT_MAX 0xffffffffU 240 #define CL_LONG_MAX ((cl_long) 0x7FFFFFFFFFFFFFFFLL) 241 #define CL_LONG_MIN ((cl_long) -0x7FFFFFFFFFFFFFFFLL - 1LL) 242 #define CL_ULONG_MAX ((cl_ulong) 0xFFFFFFFFFFFFFFFFULL) 243 244 #define CL_FLT_DIG 6 245 #define CL_FLT_MANT_DIG 24 246 #define CL_FLT_MAX_10_EXP +38 247 #define CL_FLT_MAX_EXP +128 248 #define CL_FLT_MIN_10_EXP -37 249 #define CL_FLT_MIN_EXP -125 250 #define CL_FLT_RADIX 2 251 #define CL_FLT_MAX 0x1.fffffep127f 252 #define CL_FLT_MIN 0x1.0p-126f 253 #define CL_FLT_EPSILON 0x1.0p-23f 254 255 #define CL_DBL_DIG 15 256 #define CL_DBL_MANT_DIG 53 257 #define CL_DBL_MAX_10_EXP +308 258 #define CL_DBL_MAX_EXP +1024 259 #define CL_DBL_MIN_10_EXP -307 260 #define CL_DBL_MIN_EXP -1021 261 #define CL_DBL_RADIX 2 262 #define CL_DBL_MAX 0x1.fffffffffffffp1023 263 #define CL_DBL_MIN 0x1.0p-1022 264 #define CL_DBL_EPSILON 0x1.0p-52 265 266 #define CL_M_E 2.718281828459045090796 267 #define CL_M_LOG2E 1.442695040888963387005 268 #define CL_M_LOG10E 0.434294481903251816668 269 #define CL_M_LN2 0.693147180559945286227 270 #define CL_M_LN10 2.302585092994045901094 271 #define CL_M_PI 3.141592653589793115998 272 #define CL_M_PI_2 1.570796326794896557999 273 #define CL_M_PI_4 0.785398163397448278999 274 #define CL_M_1_PI 0.318309886183790691216 275 #define CL_M_2_PI 0.636619772367581382433 276 #define CL_M_2_SQRTPI 1.128379167095512558561 277 #define CL_M_SQRT2 1.414213562373095145475 278 #define CL_M_SQRT1_2 0.707106781186547572737 279 280 #define CL_M_E_F 2.71828174591064f 281 #define CL_M_LOG2E_F 1.44269502162933f 282 #define CL_M_LOG10E_F 0.43429449200630f 283 #define CL_M_LN2_F 0.69314718246460f 284 #define CL_M_LN10_F 2.30258512496948f 285 #define CL_M_PI_F 3.14159274101257f 286 #define CL_M_PI_2_F 1.57079637050629f 287 #define CL_M_PI_4_F 0.78539818525314f 288 #define CL_M_1_PI_F 0.31830987334251f 289 #define CL_M_2_PI_F 0.63661974668503f 290 #define CL_M_2_SQRTPI_F 1.12837922573090f 291 #define CL_M_SQRT2_F 1.41421353816986f 292 #define CL_M_SQRT1_2_F 0.70710676908493f 293 294 #if defined( __GNUC__ ) 295 #define CL_HUGE_VALF __builtin_huge_valf() 296 #define CL_HUGE_VAL __builtin_huge_val() 297 #define CL_NAN __builtin_nanf( "" ) 298 #else 299 #define CL_HUGE_VALF ((cl_float) 1e50) 300 #define CL_HUGE_VAL ((cl_double) 1e500) 301 float nanf( const char * ); 302 #define CL_NAN nanf( "" ) 303 #endif 304 #define CL_MAXFLOAT CL_FLT_MAX 305 #define CL_INFINITY CL_HUGE_VALF 306 307 #endif 308 309 #include <stddef.h> 310 311 /* 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. */ 312 typedef unsigned int cl_GLuint; 313 typedef int cl_GLint; 314 typedef unsigned int cl_GLenum; 315 316 /* 317 * Vector types 318 * 319 * Note: OpenCL requires that all types be naturally aligned. 320 * This means that vector types must be naturally aligned. 321 * For example, a vector of four floats must be aligned to 322 * a 16 byte boundary (calculated as 4 * the natural 4-byte 323 * alignment of the float). The alignment qualifiers here 324 * will only function properly if your compiler supports them 325 * and if you don't actively work to defeat them. For example, 326 * in order for a cl_float4 to be 16 byte aligned in a struct, 327 * the start of the struct must itself be 16-byte aligned. 328 * 329 * Maintaining proper alignment is the user's responsibility. 330 */ 331 332 /* Define basic vector types */ 333 #if defined( __VEC__ ) 334 #include <altivec.h> /* may be omitted depending on compiler. AltiVec spec provides no way to detect whether the header is required. */ 335 typedef vector unsigned char __cl_uchar16; 336 typedef vector signed char __cl_char16; 337 typedef vector unsigned short __cl_ushort8; 338 typedef vector signed short __cl_short8; 339 typedef vector unsigned int __cl_uint4; 340 typedef vector signed int __cl_int4; 341 typedef vector float __cl_float4; 342 #define __CL_UCHAR16__ 1 343 #define __CL_CHAR16__ 1 344 #define __CL_USHORT8__ 1 345 #define __CL_SHORT8__ 1 346 #define __CL_UINT4__ 1 347 #define __CL_INT4__ 1 348 #define __CL_FLOAT4__ 1 349 #endif 350 351 #if defined( __SSE__ ) 352 #if defined( __MINGW64__ ) 353 #include <intrin.h> 354 #else 355 #include <xmmintrin.h> 356 #endif 357 #if defined( __GNUC__ ) 358 typedef float __cl_float4 __attribute__((vector_size(16))); 359 #else 360 typedef __m128 __cl_float4; 361 #endif 362 #define __CL_FLOAT4__ 1 363 #endif 364 365 #if defined( __SSE2__ ) 366 #if defined( __MINGW64__ ) 367 #include <intrin.h> 368 #else 369 #include <emmintrin.h> 370 #endif 371 #if defined( __GNUC__ ) 372 typedef cl_uchar __cl_uchar16 __attribute__((vector_size(16))); 373 typedef cl_char __cl_char16 __attribute__((vector_size(16))); 374 typedef cl_ushort __cl_ushort8 __attribute__((vector_size(16))); 375 typedef cl_short __cl_short8 __attribute__((vector_size(16))); 376 typedef cl_uint __cl_uint4 __attribute__((vector_size(16))); 377 typedef cl_int __cl_int4 __attribute__((vector_size(16))); 378 typedef cl_ulong __cl_ulong2 __attribute__((vector_size(16))); 379 typedef cl_long __cl_long2 __attribute__((vector_size(16))); 380 typedef cl_double __cl_double2 __attribute__((vector_size(16))); 381 #else 382 typedef __m128i __cl_uchar16; 383 typedef __m128i __cl_char16; 384 typedef __m128i __cl_ushort8; 385 typedef __m128i __cl_short8; 386 typedef __m128i __cl_uint4; 387 typedef __m128i __cl_int4; 388 typedef __m128i __cl_ulong2; 389 typedef __m128i __cl_long2; 390 typedef __m128d __cl_double2; 391 #endif 392 #define __CL_UCHAR16__ 1 393 #define __CL_CHAR16__ 1 394 #define __CL_USHORT8__ 1 395 #define __CL_SHORT8__ 1 396 #define __CL_INT4__ 1 397 #define __CL_UINT4__ 1 398 #define __CL_ULONG2__ 1 399 #define __CL_LONG2__ 1 400 #define __CL_DOUBLE2__ 1 401 #endif 402 403 #if defined( __MMX__ ) 404 #include <mmintrin.h> 405 #if defined( __GNUC__ ) 406 typedef cl_uchar __cl_uchar8 __attribute__((vector_size(8))); 407 typedef cl_char __cl_char8 __attribute__((vector_size(8))); 408 typedef cl_ushort __cl_ushort4 __attribute__((vector_size(8))); 409 typedef cl_short __cl_short4 __attribute__((vector_size(8))); 410 typedef cl_uint __cl_uint2 __attribute__((vector_size(8))); 411 typedef cl_int __cl_int2 __attribute__((vector_size(8))); 412 typedef cl_ulong __cl_ulong1 __attribute__((vector_size(8))); 413 typedef cl_long __cl_long1 __attribute__((vector_size(8))); 414 typedef cl_float __cl_float2 __attribute__((vector_size(8))); 415 #else 416 typedef __m64 __cl_uchar8; 417 typedef __m64 __cl_char8; 418 typedef __m64 __cl_ushort4; 419 typedef __m64 __cl_short4; 420 typedef __m64 __cl_uint2; 421 typedef __m64 __cl_int2; 422 typedef __m64 __cl_ulong1; 423 typedef __m64 __cl_long1; 424 typedef __m64 __cl_float2; 425 #endif 426 #define __CL_UCHAR8__ 1 427 #define __CL_CHAR8__ 1 428 #define __CL_USHORT4__ 1 429 #define __CL_SHORT4__ 1 430 #define __CL_INT2__ 1 431 #define __CL_UINT2__ 1 432 #define __CL_ULONG1__ 1 433 #define __CL_LONG1__ 1 434 #define __CL_FLOAT2__ 1 435 #endif 436 437 #if defined( __AVX__ ) 438 #if defined( __MINGW64__ ) 439 #include <intrin.h> 440 #else 441 #include <immintrin.h> 442 #endif 443 #if defined( __GNUC__ ) 444 typedef cl_float __cl_float8 __attribute__((vector_size(32))); 445 typedef cl_double __cl_double4 __attribute__((vector_size(32))); 446 #else 447 typedef __m256 __cl_float8; 448 typedef __m256d __cl_double4; 449 #endif 450 #define __CL_FLOAT8__ 1 451 #define __CL_DOUBLE4__ 1 452 #endif 453 454 /* Define capabilities for anonymous struct members. */ 455 #if defined( __GNUC__) && ! defined( __STRICT_ANSI__ ) 456 #define __CL_HAS_ANON_STRUCT__ 1 457 #define __CL_ANON_STRUCT__ __extension__ 458 #elif defined( _WIN32) && (_MSC_VER >= 1500) 459 /* Microsoft Developer Studio 2008 supports anonymous structs, but 460 * complains by default. */ 461 #define __CL_HAS_ANON_STRUCT__ 1 462 #define __CL_ANON_STRUCT__ 463 /* Disable warning C4201: nonstandard extension used : nameless 464 * struct/union */ 465 #pragma warning( push ) 466 #pragma warning( disable : 4201 ) 467 #else 468 #define __CL_HAS_ANON_STRUCT__ 0 469 #define __CL_ANON_STRUCT__ 470 #endif 471 472 /* Define alignment keys */ 473 #if defined( __GNUC__ ) 474 #define CL_ALIGNED(_x) __attribute__ ((aligned(_x))) 475 #elif defined( _WIN32) && (_MSC_VER) 476 /* Alignment keys neutered on windows because MSVC can't swallow function arguments with alignment requirements */ 477 /* http://msdn.microsoft.com/en-us/library/373ak2y1%28VS.71%29.aspx */ 478 /* #include <crtdefs.h> */ 479 /* #define CL_ALIGNED(_x) _CRT_ALIGN(_x) */ 480 #define CL_ALIGNED(_x) 481 #else 482 #warning Need to implement some method to align data here 483 #define CL_ALIGNED(_x) 484 #endif 485 486 /* Indicate whether .xyzw, .s0123 and .hi.lo are supported */ 487 #if __CL_HAS_ANON_STRUCT__ 488 /* .xyzw and .s0123...{f|F} are supported */ 489 #define CL_HAS_NAMED_VECTOR_FIELDS 1 490 /* .hi and .lo are supported */ 491 #define CL_HAS_HI_LO_VECTOR_FIELDS 1 492 #endif 493 494 /* Define cl_vector types */ 495 496 /* ---- cl_charn ---- */ 497 typedef union 498 { 499 cl_char CL_ALIGNED(2) s[2]; 500 #if __CL_HAS_ANON_STRUCT__ 501 __CL_ANON_STRUCT__ struct{ cl_char x, y; }; 502 __CL_ANON_STRUCT__ struct{ cl_char s0, s1; }; 503 __CL_ANON_STRUCT__ struct{ cl_char lo, hi; }; 504 #endif 505 #if defined( __CL_CHAR2__) 506 __cl_char2 v2; 507 #endif 508 }cl_char2; 509 510 typedef union 511 { 512 cl_char CL_ALIGNED(4) s[4]; 513 #if __CL_HAS_ANON_STRUCT__ 514 __CL_ANON_STRUCT__ struct{ cl_char x, y, z, w; }; 515 __CL_ANON_STRUCT__ struct{ cl_char s0, s1, s2, s3; }; 516 __CL_ANON_STRUCT__ struct{ cl_char2 lo, hi; }; 517 #endif 518 #if defined( __CL_CHAR2__) 519 __cl_char2 v2[2]; 520 #endif 521 #if defined( __CL_CHAR4__) 522 __cl_char4 v4; 523 #endif 524 }cl_char4; 525 526 /* cl_char3 is identical in size, alignment and behavior to cl_char4. See section 6.1.5. */ 527 typedef cl_char4 cl_char3; 528 529 typedef union 530 { 531 cl_char CL_ALIGNED(8) s[8]; 532 #if __CL_HAS_ANON_STRUCT__ 533 __CL_ANON_STRUCT__ struct{ cl_char x, y, z, w; }; 534 __CL_ANON_STRUCT__ struct{ cl_char s0, s1, s2, s3, s4, s5, s6, s7; }; 535 __CL_ANON_STRUCT__ struct{ cl_char4 lo, hi; }; 536 #endif 537 #if defined( __CL_CHAR2__) 538 __cl_char2 v2[4]; 539 #endif 540 #if defined( __CL_CHAR4__) 541 __cl_char4 v4[2]; 542 #endif 543 #if defined( __CL_CHAR8__ ) 544 __cl_char8 v8; 545 #endif 546 }cl_char8; 547 548 typedef union 549 { 550 cl_char CL_ALIGNED(16) s[16]; 551 #if __CL_HAS_ANON_STRUCT__ 552 __CL_ANON_STRUCT__ struct{ cl_char x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; 553 __CL_ANON_STRUCT__ struct{ cl_char s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; 554 __CL_ANON_STRUCT__ struct{ cl_char8 lo, hi; }; 555 #endif 556 #if defined( __CL_CHAR2__) 557 __cl_char2 v2[8]; 558 #endif 559 #if defined( __CL_CHAR4__) 560 __cl_char4 v4[4]; 561 #endif 562 #if defined( __CL_CHAR8__ ) 563 __cl_char8 v8[2]; 564 #endif 565 #if defined( __CL_CHAR16__ ) 566 __cl_char16 v16; 567 #endif 568 }cl_char16; 569 570 571 /* ---- cl_ucharn ---- */ 572 typedef union 573 { 574 cl_uchar CL_ALIGNED(2) s[2]; 575 #if __CL_HAS_ANON_STRUCT__ 576 __CL_ANON_STRUCT__ struct{ cl_uchar x, y; }; 577 __CL_ANON_STRUCT__ struct{ cl_uchar s0, s1; }; 578 __CL_ANON_STRUCT__ struct{ cl_uchar lo, hi; }; 579 #endif 580 #if defined( __cl_uchar2__) 581 __cl_uchar2 v2; 582 #endif 583 }cl_uchar2; 584 585 typedef union 586 { 587 cl_uchar CL_ALIGNED(4) s[4]; 588 #if __CL_HAS_ANON_STRUCT__ 589 __CL_ANON_STRUCT__ struct{ cl_uchar x, y, z, w; }; 590 __CL_ANON_STRUCT__ struct{ cl_uchar s0, s1, s2, s3; }; 591 __CL_ANON_STRUCT__ struct{ cl_uchar2 lo, hi; }; 592 #endif 593 #if defined( __CL_UCHAR2__) 594 __cl_uchar2 v2[2]; 595 #endif 596 #if defined( __CL_UCHAR4__) 597 __cl_uchar4 v4; 598 #endif 599 }cl_uchar4; 600 601 /* cl_uchar3 is identical in size, alignment and behavior to cl_uchar4. See section 6.1.5. */ 602 typedef cl_uchar4 cl_uchar3; 603 604 typedef union 605 { 606 cl_uchar CL_ALIGNED(8) s[8]; 607 #if __CL_HAS_ANON_STRUCT__ 608 __CL_ANON_STRUCT__ struct{ cl_uchar x, y, z, w; }; 609 __CL_ANON_STRUCT__ struct{ cl_uchar s0, s1, s2, s3, s4, s5, s6, s7; }; 610 __CL_ANON_STRUCT__ struct{ cl_uchar4 lo, hi; }; 611 #endif 612 #if defined( __CL_UCHAR2__) 613 __cl_uchar2 v2[4]; 614 #endif 615 #if defined( __CL_UCHAR4__) 616 __cl_uchar4 v4[2]; 617 #endif 618 #if defined( __CL_UCHAR8__ ) 619 __cl_uchar8 v8; 620 #endif 621 }cl_uchar8; 622 623 typedef union 624 { 625 cl_uchar CL_ALIGNED(16) s[16]; 626 #if __CL_HAS_ANON_STRUCT__ 627 __CL_ANON_STRUCT__ struct{ cl_uchar x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; 628 __CL_ANON_STRUCT__ struct{ cl_uchar s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; 629 __CL_ANON_STRUCT__ struct{ cl_uchar8 lo, hi; }; 630 #endif 631 #if defined( __CL_UCHAR2__) 632 __cl_uchar2 v2[8]; 633 #endif 634 #if defined( __CL_UCHAR4__) 635 __cl_uchar4 v4[4]; 636 #endif 637 #if defined( __CL_UCHAR8__ ) 638 __cl_uchar8 v8[2]; 639 #endif 640 #if defined( __CL_UCHAR16__ ) 641 __cl_uchar16 v16; 642 #endif 643 }cl_uchar16; 644 645 646 /* ---- cl_shortn ---- */ 647 typedef union 648 { 649 cl_short CL_ALIGNED(4) s[2]; 650 #if __CL_HAS_ANON_STRUCT__ 651 __CL_ANON_STRUCT__ struct{ cl_short x, y; }; 652 __CL_ANON_STRUCT__ struct{ cl_short s0, s1; }; 653 __CL_ANON_STRUCT__ struct{ cl_short lo, hi; }; 654 #endif 655 #if defined( __CL_SHORT2__) 656 __cl_short2 v2; 657 #endif 658 }cl_short2; 659 660 typedef union 661 { 662 cl_short CL_ALIGNED(8) s[4]; 663 #if __CL_HAS_ANON_STRUCT__ 664 __CL_ANON_STRUCT__ struct{ cl_short x, y, z, w; }; 665 __CL_ANON_STRUCT__ struct{ cl_short s0, s1, s2, s3; }; 666 __CL_ANON_STRUCT__ struct{ cl_short2 lo, hi; }; 667 #endif 668 #if defined( __CL_SHORT2__) 669 __cl_short2 v2[2]; 670 #endif 671 #if defined( __CL_SHORT4__) 672 __cl_short4 v4; 673 #endif 674 }cl_short4; 675 676 /* cl_short3 is identical in size, alignment and behavior to cl_short4. See section 6.1.5. */ 677 typedef cl_short4 cl_short3; 678 679 typedef union 680 { 681 cl_short CL_ALIGNED(16) s[8]; 682 #if __CL_HAS_ANON_STRUCT__ 683 __CL_ANON_STRUCT__ struct{ cl_short x, y, z, w; }; 684 __CL_ANON_STRUCT__ struct{ cl_short s0, s1, s2, s3, s4, s5, s6, s7; }; 685 __CL_ANON_STRUCT__ struct{ cl_short4 lo, hi; }; 686 #endif 687 #if defined( __CL_SHORT2__) 688 __cl_short2 v2[4]; 689 #endif 690 #if defined( __CL_SHORT4__) 691 __cl_short4 v4[2]; 692 #endif 693 #if defined( __CL_SHORT8__ ) 694 __cl_short8 v8; 695 #endif 696 }cl_short8; 697 698 typedef union 699 { 700 cl_short CL_ALIGNED(32) s[16]; 701 #if __CL_HAS_ANON_STRUCT__ 702 __CL_ANON_STRUCT__ struct{ cl_short x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; 703 __CL_ANON_STRUCT__ struct{ cl_short s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; 704 __CL_ANON_STRUCT__ struct{ cl_short8 lo, hi; }; 705 #endif 706 #if defined( __CL_SHORT2__) 707 __cl_short2 v2[8]; 708 #endif 709 #if defined( __CL_SHORT4__) 710 __cl_short4 v4[4]; 711 #endif 712 #if defined( __CL_SHORT8__ ) 713 __cl_short8 v8[2]; 714 #endif 715 #if defined( __CL_SHORT16__ ) 716 __cl_short16 v16; 717 #endif 718 }cl_short16; 719 720 721 /* ---- cl_ushortn ---- */ 722 typedef union 723 { 724 cl_ushort CL_ALIGNED(4) s[2]; 725 #if __CL_HAS_ANON_STRUCT__ 726 __CL_ANON_STRUCT__ struct{ cl_ushort x, y; }; 727 __CL_ANON_STRUCT__ struct{ cl_ushort s0, s1; }; 728 __CL_ANON_STRUCT__ struct{ cl_ushort lo, hi; }; 729 #endif 730 #if defined( __CL_USHORT2__) 731 __cl_ushort2 v2; 732 #endif 733 }cl_ushort2; 734 735 typedef union 736 { 737 cl_ushort CL_ALIGNED(8) s[4]; 738 #if __CL_HAS_ANON_STRUCT__ 739 __CL_ANON_STRUCT__ struct{ cl_ushort x, y, z, w; }; 740 __CL_ANON_STRUCT__ struct{ cl_ushort s0, s1, s2, s3; }; 741 __CL_ANON_STRUCT__ struct{ cl_ushort2 lo, hi; }; 742 #endif 743 #if defined( __CL_USHORT2__) 744 __cl_ushort2 v2[2]; 745 #endif 746 #if defined( __CL_USHORT4__) 747 __cl_ushort4 v4; 748 #endif 749 }cl_ushort4; 750 751 /* cl_ushort3 is identical in size, alignment and behavior to cl_ushort4. See section 6.1.5. */ 752 typedef cl_ushort4 cl_ushort3; 753 754 typedef union 755 { 756 cl_ushort CL_ALIGNED(16) s[8]; 757 #if __CL_HAS_ANON_STRUCT__ 758 __CL_ANON_STRUCT__ struct{ cl_ushort x, y, z, w; }; 759 __CL_ANON_STRUCT__ struct{ cl_ushort s0, s1, s2, s3, s4, s5, s6, s7; }; 760 __CL_ANON_STRUCT__ struct{ cl_ushort4 lo, hi; }; 761 #endif 762 #if defined( __CL_USHORT2__) 763 __cl_ushort2 v2[4]; 764 #endif 765 #if defined( __CL_USHORT4__) 766 __cl_ushort4 v4[2]; 767 #endif 768 #if defined( __CL_USHORT8__ ) 769 __cl_ushort8 v8; 770 #endif 771 }cl_ushort8; 772 773 typedef union 774 { 775 cl_ushort CL_ALIGNED(32) s[16]; 776 #if __CL_HAS_ANON_STRUCT__ 777 __CL_ANON_STRUCT__ struct{ cl_ushort x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; 778 __CL_ANON_STRUCT__ struct{ cl_ushort s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; 779 __CL_ANON_STRUCT__ struct{ cl_ushort8 lo, hi; }; 780 #endif 781 #if defined( __CL_USHORT2__) 782 __cl_ushort2 v2[8]; 783 #endif 784 #if defined( __CL_USHORT4__) 785 __cl_ushort4 v4[4]; 786 #endif 787 #if defined( __CL_USHORT8__ ) 788 __cl_ushort8 v8[2]; 789 #endif 790 #if defined( __CL_USHORT16__ ) 791 __cl_ushort16 v16; 792 #endif 793 }cl_ushort16; 794 795 /* ---- cl_intn ---- */ 796 typedef union 797 { 798 cl_int CL_ALIGNED(8) s[2]; 799 #if __CL_HAS_ANON_STRUCT__ 800 __CL_ANON_STRUCT__ struct{ cl_int x, y; }; 801 __CL_ANON_STRUCT__ struct{ cl_int s0, s1; }; 802 __CL_ANON_STRUCT__ struct{ cl_int lo, hi; }; 803 #endif 804 #if defined( __CL_INT2__) 805 __cl_int2 v2; 806 #endif 807 }cl_int2; 808 809 typedef union 810 { 811 cl_int CL_ALIGNED(16) s[4]; 812 #if __CL_HAS_ANON_STRUCT__ 813 __CL_ANON_STRUCT__ struct{ cl_int x, y, z, w; }; 814 __CL_ANON_STRUCT__ struct{ cl_int s0, s1, s2, s3; }; 815 __CL_ANON_STRUCT__ struct{ cl_int2 lo, hi; }; 816 #endif 817 #if defined( __CL_INT2__) 818 __cl_int2 v2[2]; 819 #endif 820 #if defined( __CL_INT4__) 821 __cl_int4 v4; 822 #endif 823 }cl_int4; 824 825 /* cl_int3 is identical in size, alignment and behavior to cl_int4. See section 6.1.5. */ 826 typedef cl_int4 cl_int3; 827 828 typedef union 829 { 830 cl_int CL_ALIGNED(32) s[8]; 831 #if __CL_HAS_ANON_STRUCT__ 832 __CL_ANON_STRUCT__ struct{ cl_int x, y, z, w; }; 833 __CL_ANON_STRUCT__ struct{ cl_int s0, s1, s2, s3, s4, s5, s6, s7; }; 834 __CL_ANON_STRUCT__ struct{ cl_int4 lo, hi; }; 835 #endif 836 #if defined( __CL_INT2__) 837 __cl_int2 v2[4]; 838 #endif 839 #if defined( __CL_INT4__) 840 __cl_int4 v4[2]; 841 #endif 842 #if defined( __CL_INT8__ ) 843 __cl_int8 v8; 844 #endif 845 }cl_int8; 846 847 typedef union 848 { 849 cl_int CL_ALIGNED(64) s[16]; 850 #if __CL_HAS_ANON_STRUCT__ 851 __CL_ANON_STRUCT__ struct{ cl_int x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; 852 __CL_ANON_STRUCT__ struct{ cl_int s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; 853 __CL_ANON_STRUCT__ struct{ cl_int8 lo, hi; }; 854 #endif 855 #if defined( __CL_INT2__) 856 __cl_int2 v2[8]; 857 #endif 858 #if defined( __CL_INT4__) 859 __cl_int4 v4[4]; 860 #endif 861 #if defined( __CL_INT8__ ) 862 __cl_int8 v8[2]; 863 #endif 864 #if defined( __CL_INT16__ ) 865 __cl_int16 v16; 866 #endif 867 }cl_int16; 868 869 870 /* ---- cl_uintn ---- */ 871 typedef union 872 { 873 cl_uint CL_ALIGNED(8) s[2]; 874 #if __CL_HAS_ANON_STRUCT__ 875 __CL_ANON_STRUCT__ struct{ cl_uint x, y; }; 876 __CL_ANON_STRUCT__ struct{ cl_uint s0, s1; }; 877 __CL_ANON_STRUCT__ struct{ cl_uint lo, hi; }; 878 #endif 879 #if defined( __CL_UINT2__) 880 __cl_uint2 v2; 881 #endif 882 }cl_uint2; 883 884 typedef union 885 { 886 cl_uint CL_ALIGNED(16) s[4]; 887 #if __CL_HAS_ANON_STRUCT__ 888 __CL_ANON_STRUCT__ struct{ cl_uint x, y, z, w; }; 889 __CL_ANON_STRUCT__ struct{ cl_uint s0, s1, s2, s3; }; 890 __CL_ANON_STRUCT__ struct{ cl_uint2 lo, hi; }; 891 #endif 892 #if defined( __CL_UINT2__) 893 __cl_uint2 v2[2]; 894 #endif 895 #if defined( __CL_UINT4__) 896 __cl_uint4 v4; 897 #endif 898 }cl_uint4; 899 900 /* cl_uint3 is identical in size, alignment and behavior to cl_uint4. See section 6.1.5. */ 901 typedef cl_uint4 cl_uint3; 902 903 typedef union 904 { 905 cl_uint CL_ALIGNED(32) s[8]; 906 #if __CL_HAS_ANON_STRUCT__ 907 __CL_ANON_STRUCT__ struct{ cl_uint x, y, z, w; }; 908 __CL_ANON_STRUCT__ struct{ cl_uint s0, s1, s2, s3, s4, s5, s6, s7; }; 909 __CL_ANON_STRUCT__ struct{ cl_uint4 lo, hi; }; 910 #endif 911 #if defined( __CL_UINT2__) 912 __cl_uint2 v2[4]; 913 #endif 914 #if defined( __CL_UINT4__) 915 __cl_uint4 v4[2]; 916 #endif 917 #if defined( __CL_UINT8__ ) 918 __cl_uint8 v8; 919 #endif 920 }cl_uint8; 921 922 typedef union 923 { 924 cl_uint CL_ALIGNED(64) s[16]; 925 #if __CL_HAS_ANON_STRUCT__ 926 __CL_ANON_STRUCT__ struct{ cl_uint x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; 927 __CL_ANON_STRUCT__ struct{ cl_uint s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; 928 __CL_ANON_STRUCT__ struct{ cl_uint8 lo, hi; }; 929 #endif 930 #if defined( __CL_UINT2__) 931 __cl_uint2 v2[8]; 932 #endif 933 #if defined( __CL_UINT4__) 934 __cl_uint4 v4[4]; 935 #endif 936 #if defined( __CL_UINT8__ ) 937 __cl_uint8 v8[2]; 938 #endif 939 #if defined( __CL_UINT16__ ) 940 __cl_uint16 v16; 941 #endif 942 }cl_uint16; 943 944 /* ---- cl_longn ---- */ 945 typedef union 946 { 947 cl_long CL_ALIGNED(16) s[2]; 948 #if __CL_HAS_ANON_STRUCT__ 949 __CL_ANON_STRUCT__ struct{ cl_long x, y; }; 950 __CL_ANON_STRUCT__ struct{ cl_long s0, s1; }; 951 __CL_ANON_STRUCT__ struct{ cl_long lo, hi; }; 952 #endif 953 #if defined( __CL_LONG2__) 954 __cl_long2 v2; 955 #endif 956 }cl_long2; 957 958 typedef union 959 { 960 cl_long CL_ALIGNED(32) s[4]; 961 #if __CL_HAS_ANON_STRUCT__ 962 __CL_ANON_STRUCT__ struct{ cl_long x, y, z, w; }; 963 __CL_ANON_STRUCT__ struct{ cl_long s0, s1, s2, s3; }; 964 __CL_ANON_STRUCT__ struct{ cl_long2 lo, hi; }; 965 #endif 966 #if defined( __CL_LONG2__) 967 __cl_long2 v2[2]; 968 #endif 969 #if defined( __CL_LONG4__) 970 __cl_long4 v4; 971 #endif 972 }cl_long4; 973 974 /* cl_long3 is identical in size, alignment and behavior to cl_long4. See section 6.1.5. */ 975 typedef cl_long4 cl_long3; 976 977 typedef union 978 { 979 cl_long CL_ALIGNED(64) s[8]; 980 #if __CL_HAS_ANON_STRUCT__ 981 __CL_ANON_STRUCT__ struct{ cl_long x, y, z, w; }; 982 __CL_ANON_STRUCT__ struct{ cl_long s0, s1, s2, s3, s4, s5, s6, s7; }; 983 __CL_ANON_STRUCT__ struct{ cl_long4 lo, hi; }; 984 #endif 985 #if defined( __CL_LONG2__) 986 __cl_long2 v2[4]; 987 #endif 988 #if defined( __CL_LONG4__) 989 __cl_long4 v4[2]; 990 #endif 991 #if defined( __CL_LONG8__ ) 992 __cl_long8 v8; 993 #endif 994 }cl_long8; 995 996 typedef union 997 { 998 cl_long CL_ALIGNED(128) s[16]; 999 #if __CL_HAS_ANON_STRUCT__ 1000 __CL_ANON_STRUCT__ struct{ cl_long x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; 1001 __CL_ANON_STRUCT__ struct{ cl_long s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; 1002 __CL_ANON_STRUCT__ struct{ cl_long8 lo, hi; }; 1003 #endif 1004 #if defined( __CL_LONG2__) 1005 __cl_long2 v2[8]; 1006 #endif 1007 #if defined( __CL_LONG4__) 1008 __cl_long4 v4[4]; 1009 #endif 1010 #if defined( __CL_LONG8__ ) 1011 __cl_long8 v8[2]; 1012 #endif 1013 #if defined( __CL_LONG16__ ) 1014 __cl_long16 v16; 1015 #endif 1016 }cl_long16; 1017 1018 1019 /* ---- cl_ulongn ---- */ 1020 typedef union 1021 { 1022 cl_ulong CL_ALIGNED(16) s[2]; 1023 #if __CL_HAS_ANON_STRUCT__ 1024 __CL_ANON_STRUCT__ struct{ cl_ulong x, y; }; 1025 __CL_ANON_STRUCT__ struct{ cl_ulong s0, s1; }; 1026 __CL_ANON_STRUCT__ struct{ cl_ulong lo, hi; }; 1027 #endif 1028 #if defined( __CL_ULONG2__) 1029 __cl_ulong2 v2; 1030 #endif 1031 }cl_ulong2; 1032 1033 typedef union 1034 { 1035 cl_ulong CL_ALIGNED(32) s[4]; 1036 #if __CL_HAS_ANON_STRUCT__ 1037 __CL_ANON_STRUCT__ struct{ cl_ulong x, y, z, w; }; 1038 __CL_ANON_STRUCT__ struct{ cl_ulong s0, s1, s2, s3; }; 1039 __CL_ANON_STRUCT__ struct{ cl_ulong2 lo, hi; }; 1040 #endif 1041 #if defined( __CL_ULONG2__) 1042 __cl_ulong2 v2[2]; 1043 #endif 1044 #if defined( __CL_ULONG4__) 1045 __cl_ulong4 v4; 1046 #endif 1047 }cl_ulong4; 1048 1049 /* cl_ulong3 is identical in size, alignment and behavior to cl_ulong4. See section 6.1.5. */ 1050 typedef cl_ulong4 cl_ulong3; 1051 1052 typedef union 1053 { 1054 cl_ulong CL_ALIGNED(64) s[8]; 1055 #if __CL_HAS_ANON_STRUCT__ 1056 __CL_ANON_STRUCT__ struct{ cl_ulong x, y, z, w; }; 1057 __CL_ANON_STRUCT__ struct{ cl_ulong s0, s1, s2, s3, s4, s5, s6, s7; }; 1058 __CL_ANON_STRUCT__ struct{ cl_ulong4 lo, hi; }; 1059 #endif 1060 #if defined( __CL_ULONG2__) 1061 __cl_ulong2 v2[4]; 1062 #endif 1063 #if defined( __CL_ULONG4__) 1064 __cl_ulong4 v4[2]; 1065 #endif 1066 #if defined( __CL_ULONG8__ ) 1067 __cl_ulong8 v8; 1068 #endif 1069 }cl_ulong8; 1070 1071 typedef union 1072 { 1073 cl_ulong CL_ALIGNED(128) s[16]; 1074 #if __CL_HAS_ANON_STRUCT__ 1075 __CL_ANON_STRUCT__ struct{ cl_ulong x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; 1076 __CL_ANON_STRUCT__ struct{ cl_ulong s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; 1077 __CL_ANON_STRUCT__ struct{ cl_ulong8 lo, hi; }; 1078 #endif 1079 #if defined( __CL_ULONG2__) 1080 __cl_ulong2 v2[8]; 1081 #endif 1082 #if defined( __CL_ULONG4__) 1083 __cl_ulong4 v4[4]; 1084 #endif 1085 #if defined( __CL_ULONG8__ ) 1086 __cl_ulong8 v8[2]; 1087 #endif 1088 #if defined( __CL_ULONG16__ ) 1089 __cl_ulong16 v16; 1090 #endif 1091 }cl_ulong16; 1092 1093 1094 /* --- cl_floatn ---- */ 1095 1096 typedef union 1097 { 1098 cl_float CL_ALIGNED(8) s[2]; 1099 #if __CL_HAS_ANON_STRUCT__ 1100 __CL_ANON_STRUCT__ struct{ cl_float x, y; }; 1101 __CL_ANON_STRUCT__ struct{ cl_float s0, s1; }; 1102 __CL_ANON_STRUCT__ struct{ cl_float lo, hi; }; 1103 #endif 1104 #if defined( __CL_FLOAT2__) 1105 __cl_float2 v2; 1106 #endif 1107 }cl_float2; 1108 1109 typedef union 1110 { 1111 cl_float CL_ALIGNED(16) s[4]; 1112 #if __CL_HAS_ANON_STRUCT__ 1113 __CL_ANON_STRUCT__ struct{ cl_float x, y, z, w; }; 1114 __CL_ANON_STRUCT__ struct{ cl_float s0, s1, s2, s3; }; 1115 __CL_ANON_STRUCT__ struct{ cl_float2 lo, hi; }; 1116 #endif 1117 #if defined( __CL_FLOAT2__) 1118 __cl_float2 v2[2]; 1119 #endif 1120 #if defined( __CL_FLOAT4__) 1121 __cl_float4 v4; 1122 #endif 1123 }cl_float4; 1124 1125 /* cl_float3 is identical in size, alignment and behavior to cl_float4. See section 6.1.5. */ 1126 typedef cl_float4 cl_float3; 1127 1128 typedef union 1129 { 1130 cl_float CL_ALIGNED(32) s[8]; 1131 #if __CL_HAS_ANON_STRUCT__ 1132 __CL_ANON_STRUCT__ struct{ cl_float x, y, z, w; }; 1133 __CL_ANON_STRUCT__ struct{ cl_float s0, s1, s2, s3, s4, s5, s6, s7; }; 1134 __CL_ANON_STRUCT__ struct{ cl_float4 lo, hi; }; 1135 #endif 1136 #if defined( __CL_FLOAT2__) 1137 __cl_float2 v2[4]; 1138 #endif 1139 #if defined( __CL_FLOAT4__) 1140 __cl_float4 v4[2]; 1141 #endif 1142 #if defined( __CL_FLOAT8__ ) 1143 __cl_float8 v8; 1144 #endif 1145 }cl_float8; 1146 1147 typedef union 1148 { 1149 cl_float CL_ALIGNED(64) s[16]; 1150 #if __CL_HAS_ANON_STRUCT__ 1151 __CL_ANON_STRUCT__ struct{ cl_float x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; 1152 __CL_ANON_STRUCT__ struct{ cl_float s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; 1153 __CL_ANON_STRUCT__ struct{ cl_float8 lo, hi; }; 1154 #endif 1155 #if defined( __CL_FLOAT2__) 1156 __cl_float2 v2[8]; 1157 #endif 1158 #if defined( __CL_FLOAT4__) 1159 __cl_float4 v4[4]; 1160 #endif 1161 #if defined( __CL_FLOAT8__ ) 1162 __cl_float8 v8[2]; 1163 #endif 1164 #if defined( __CL_FLOAT16__ ) 1165 __cl_float16 v16; 1166 #endif 1167 }cl_float16; 1168 1169 /* --- cl_doublen ---- */ 1170 1171 typedef union 1172 { 1173 cl_double CL_ALIGNED(16) s[2]; 1174 #if __CL_HAS_ANON_STRUCT__ 1175 __CL_ANON_STRUCT__ struct{ cl_double x, y; }; 1176 __CL_ANON_STRUCT__ struct{ cl_double s0, s1; }; 1177 __CL_ANON_STRUCT__ struct{ cl_double lo, hi; }; 1178 #endif 1179 #if defined( __CL_DOUBLE2__) 1180 __cl_double2 v2; 1181 #endif 1182 }cl_double2; 1183 1184 typedef union 1185 { 1186 cl_double CL_ALIGNED(32) s[4]; 1187 #if __CL_HAS_ANON_STRUCT__ 1188 __CL_ANON_STRUCT__ struct{ cl_double x, y, z, w; }; 1189 __CL_ANON_STRUCT__ struct{ cl_double s0, s1, s2, s3; }; 1190 __CL_ANON_STRUCT__ struct{ cl_double2 lo, hi; }; 1191 #endif 1192 #if defined( __CL_DOUBLE2__) 1193 __cl_double2 v2[2]; 1194 #endif 1195 #if defined( __CL_DOUBLE4__) 1196 __cl_double4 v4; 1197 #endif 1198 }cl_double4; 1199 1200 /* cl_double3 is identical in size, alignment and behavior to cl_double4. See section 6.1.5. */ 1201 typedef cl_double4 cl_double3; 1202 1203 typedef union 1204 { 1205 cl_double CL_ALIGNED(64) s[8]; 1206 #if __CL_HAS_ANON_STRUCT__ 1207 __CL_ANON_STRUCT__ struct{ cl_double x, y, z, w; }; 1208 __CL_ANON_STRUCT__ struct{ cl_double s0, s1, s2, s3, s4, s5, s6, s7; }; 1209 __CL_ANON_STRUCT__ struct{ cl_double4 lo, hi; }; 1210 #endif 1211 #if defined( __CL_DOUBLE2__) 1212 __cl_double2 v2[4]; 1213 #endif 1214 #if defined( __CL_DOUBLE4__) 1215 __cl_double4 v4[2]; 1216 #endif 1217 #if defined( __CL_DOUBLE8__ ) 1218 __cl_double8 v8; 1219 #endif 1220 }cl_double8; 1221 1222 typedef union 1223 { 1224 cl_double CL_ALIGNED(128) s[16]; 1225 #if __CL_HAS_ANON_STRUCT__ 1226 __CL_ANON_STRUCT__ struct{ cl_double x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; 1227 __CL_ANON_STRUCT__ struct{ cl_double s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; 1228 __CL_ANON_STRUCT__ struct{ cl_double8 lo, hi; }; 1229 #endif 1230 #if defined( __CL_DOUBLE2__) 1231 __cl_double2 v2[8]; 1232 #endif 1233 #if defined( __CL_DOUBLE4__) 1234 __cl_double4 v4[4]; 1235 #endif 1236 #if defined( __CL_DOUBLE8__ ) 1237 __cl_double8 v8[2]; 1238 #endif 1239 #if defined( __CL_DOUBLE16__ ) 1240 __cl_double16 v16; 1241 #endif 1242 }cl_double16; 1243 1244 /* Macro to facilitate debugging 1245 * Usage: 1246 * Place CL_PROGRAM_STRING_DEBUG_INFO on the line before the first line of your source. 1247 * The first line ends with: CL_PROGRAM_STRING_DEBUG_INFO \" 1248 * Each line thereafter of OpenCL C source must end with: \n\ 1249 * The last line ends in "; 1250 * 1251 * Example: 1252 * 1253 * const char *my_program = CL_PROGRAM_STRING_DEBUG_INFO "\ 1254 * kernel void foo( int a, float * b ) \n\ 1255 * { \n\ 1256 * // my comment \n\ 1257 * *b[ get_global_id(0)] = a; \n\ 1258 * } \n\ 1259 * "; 1260 * 1261 * This should correctly set up the line, (column) and file information for your source 1262 * string so you can do source level debugging. 1263 */ 1264 #define __CL_STRINGIFY( _x ) # _x 1265 #define _CL_STRINGIFY( _x ) __CL_STRINGIFY( _x ) 1266 #define CL_PROGRAM_STRING_DEBUG_INFO "#line " _CL_STRINGIFY(__LINE__) " \"" __FILE__ "\" \n\n" 1267 1268 #ifdef __cplusplus 1269 } 1270 #endif 1271 1272 #undef __CL_HAS_ANON_STRUCT__ 1273 #undef __CL_ANON_STRUCT__ 1274 #if defined( _WIN32) && (_MSC_VER >= 1500) 1275 #pragma warning( pop ) 1276 #endif 1277 1278 #endif /* __CL_PLATFORM_H */ 1279
