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